/*
  Custom chip playground (LM75A)
  Thanks @Tim2000 from the Wokwi community for the fixes and improvements.
  See for more info: https://link.wokwi.com/custom-chips-alpha/
*/

#include <LM75A.h>
#include <LiquidCrystal_I2C.h>

// Create I2C LM75A instance
LM75A lm75a_sensor(false,  // A0 LM75A pin state (connected to ground = false)
                   false,  // A1 LM75A pin state (connected to ground = false)
                   false); // A2 LM75A pin state (connected to ground = false)
                  
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);

float temperature = 0;

uint8_t DegreeBitmap[] = { 0x6, 0x9, 0x9, 0x6, 0x0, 0, 0, 0 };

void setup() {
  Serial.begin(9600);

  // Initialize the lcd
  lcd.init();

  // Storage the custom degree symbol as character #1
  lcd.createChar(1, DegreeBitmap);

  // Print a message to the LCD
  lcd.backlight();
  lcd.setCursor(5, 0);
  lcd.print("LM75A");
  lcd.setCursor(2, 1);
  lcd.print("Address 0x48");
  delay(1000);
  lcd.clear();
}

void loop() {
  // 11-bit ADC that offers a temperature resolution of 0.125 °C
  temperature = lm75a_sensor.getTemperatureInDegrees();

  if (temperature != INVALID_LM75A_TEMPERATURE) {
    lcd.setCursor(2, 0);
    lcd.print("Temperature:");
    lcd.setCursor(4, 1);
    lcd.print(temperature);
    lcd.print("\001C   "); // Print char 1 (which is the degree) followed by C
    delay(1000);
  }
}


lm75-chip.ino

diagram.json

// Wokwi Custom Chip - For information and examples see:
// https://link.wokwi.com/custom-chips-alpha
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2022 Uri Shaked / wokwi.com

#include <stdio.h>
#include <stdlib.h>
#include "wokwi-api.h"

const int LM75A_BASE_ADDRESS = 0x48;

DEFINE_PIN(VCC);
DEFINE_PIN(GND);
DEFINE_PIN(SCL);
DEFINE_PIN(SDA);
DEFINE_PIN(OS);
DEFINE_PIN(A0);
DEFINE_PIN(A1);
DEFINE_PIN(A2);

typedef enum
{
  PIN_OS,
  PIN_A0,
  PIN_A1,
  PIN_A2,
  MAX_PINS
} Pins;

typedef enum
{
  ST_EXPECTING_CONNECT,
  ST_EXPECTING_FIRST_DATA_BYTE,
  ST_EXPECTING_SECOND_DATA_BYTE,
  ST_EXPECTING_THIRD_DATA_BYTE,
} States;

typedef struct
{
  pin_t pins[MAX_PINS];
  States state;
  uint32_t conversion_timer_id;
  uint8_t address;
  uint8_t internal_address;
  uint8_t temperature_byte_hi;
  uint8_t temperature_byte_lo;
  uint8_t config;
  uint8_t t_os_byte_hi;
  uint8_t t_os_byte_lo;
  uint8_t t_hyst_byte_hi;
  uint8_t t_hyst_byte_lo;
  uint8_t product_id;
  uint8_t fault_count;
  uint8_t fault_count_reload;
  bool os_interrupt_triggered_high;
  bool os_interrupt_triggered_low;
  uint32_t temp_attr;
} chip_state_t;

void ActivatePinOS(chip_state_t *chip)
{
  if (chip->config & 4)
  {
    // OS is active high, so set a high impedance input.
    pin_mode(chip->pins[PIN_OS], INPUT);
  }
  else
  {
    // OS is active low, so pull the output low.
    pin_mode(chip->pins[PIN_OS], OUTPUT_LOW);
  }
}

void DeactivatePinOS(chip_state_t *chip)
{
  if (chip->config & 4)
  {
    // OS is active high, therefore the inactive state is low, so pull the output low.
    pin_mode(chip->pins[PIN_OS], OUTPUT_LOW);
  }
  else
  {
    // OS is active low, therefore the inactive state is high, so set a high impedance input.
    pin_mode(chip->pins[PIN_OS], INPUT);
  }
}

chip_state_t* EXPORT(chip_init)(void)
{
  int16_t temperature;

  chip_state_t *chip = calloc(1, sizeof(chip_state_t));

  chip->pins[PIN_OS] = pin_init("OS", INPUT);  // Open drain floating.
  chip->pins[PIN_A0] = pin_init("A0", INPUT);
  chip->pins[PIN_A1] = pin_init("A1", INPUT);
  chip->pins[PIN_A2] = pin_init("A2", INPUT);

  chip->conversion_timer_id = timer_init();
  timer_start(chip->conversion_timer_id,  100000, true);

  chip->config = 0x00;

  temperature = 80 * 256;
  chip->t_os_byte_hi = (uint8_t)(temperature >> 8);
  chip->t_os_byte_lo = (uint8_t)temperature;
  
  temperature = 75 * 256;
  chip->t_hyst_byte_hi = (uint8_t)(temperature >> 8);
  chip->t_hyst_byte_lo = (uint8_t)temperature;

  chip->product_id = 0xA1;

  uint8_t reload = (chip->config >> 3 & 3) * 2;
  if (reload == 0) reload = 1;
  chip->fault_count_reload = reload;
  chip->fault_count = reload;

  chip->os_interrupt_triggered_high = false;
  chip->os_interrupt_triggered_low = false;
  
  chip->address = LM75A_BASE_ADDRESS;

  // Update I2C address depending on how the sensor is connected
  chip->address |= (digital_read(chip->pins[PIN_A2]) << 2) | (digital_read(chip->pins[PIN_A1]) << 1) | digital_read(chip->pins[PIN_A0]);

  const pin_t scl = pin_init("SCL", INPUT);
  const pin_t sda = pin_init("SDA", INPUT);
  i2c_init(chip->address, scl, sda);

  // This attribute can be edited by the user. It's defined in lm75a.chip.json:
  chip->temp_attr = attr_init_float("temperature", 22);

  return chip;
}

void EXPORT(chip_timer_event)(chip_state_t *chip, uint32_t timer_id)
{
  float f_temperature;
  int16_t temperature, t_os, t_hyst;

  if (chip->state == ST_EXPECTING_CONNECT && timer_id == chip->conversion_timer_id)
  {
    f_temperature = attr_read_float(chip->temp_attr);

    // Temperature dependent ADC conversion time between 100,000 us and 300,000 us.
    timer_start(chip->conversion_timer_id, 100000 + (f_temperature + 55) / 180 * 200 * 1000, true);

    temperature = f_temperature * 256;
    chip->temperature_byte_hi = (uint8_t)(temperature >> 8);
    chip->temperature_byte_lo = (uint8_t)(temperature);

    if (!(chip->config & 1));  // If not in Shutdown Mode.
    {
      t_os = (int16_t)(chip->t_os_byte_hi << 8 | chip->t_os_byte_lo);
      t_hyst = (int16_t)(chip->t_hyst_byte_hi << 8 | chip->t_hyst_byte_lo);
      if (chip->config & 2)
      {
        // Interrupt mode.
        if (temperature > t_os)
        {
          // Decrement fault count.
          chip->fault_count--;
          if (chip->fault_count == 0)
          {
            if (temperature > t_os && !chip->os_interrupt_triggered_high)
            {
              ActivatePinOS(chip);  // Will be deactivated in chip_i2c_read() or Shutdown Mode.
              chip->os_interrupt_triggered_high = true;
              chip->os_interrupt_triggered_low = false;
            }
            chip->fault_count = chip->fault_count_reload;
          }
        }
        else if (temperature < t_hyst && !chip->os_interrupt_triggered_low)
        {
          ActivatePinOS(chip);  // Will be deactivated in chip_i2c_read() or Shutdown Mode.
          chip->os_interrupt_triggered_low = true;
          chip->os_interrupt_triggered_high = false;
          chip->fault_count = chip->fault_count_reload;
        }
        else
        {
          chip->fault_count = chip->fault_count_reload;
        }
      }
      else
      {
        // Comparator mode.
        if (temperature > t_os)
        {
          // Decrement fault count.
          chip->fault_count--;
          if (chip->fault_count == 0)
          {
            // OS is active.
            ActivatePinOS(chip);
            chip->fault_count = chip->fault_count_reload;
          }
        }
        else if (temperature < t_hyst)
        {
          // OS is inactive.
          DeactivatePinOS(chip);
          chip->fault_count = chip->fault_count_reload;
        }
        else
        {
          chip->fault_count = chip->fault_count_reload;
        }
      }
    }
  }
}

bool EXPORT(chip_i2c_connect)(chip_state_t *chip, uint32_t address, bool read)
{
  if (address == chip->address)
  {
    chip->state = ST_EXPECTING_FIRST_DATA_BYTE;
    return true; /* Ack */
  }
  return false;
}

uint8_t EXPORT(chip_i2c_read)(chip_state_t *chip)
{
  if (chip->config & 2)
  {
    // Interrupt mode.
    DeactivatePinOS(chip);
  }

  uint8_t result;

  switch (chip->state)
  {
    case ST_EXPECTING_FIRST_DATA_BYTE:
      switch (chip->internal_address)
      {
        case 0:
          result = chip->temperature_byte_hi;
          chip->state = ST_EXPECTING_SECOND_DATA_BYTE;
          break;
        case 1:
          result = chip->config;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        case 2:
          result = chip->t_os_byte_hi;
          chip->state = ST_EXPECTING_SECOND_DATA_BYTE;
          break;
        case 3:
          result = chip->t_hyst_byte_hi;
          chip->state = ST_EXPECTING_SECOND_DATA_BYTE;
          break;
        case 7:
          result = chip->product_id;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        default:
          chip->state = ST_EXPECTING_CONNECT;
          result = 0;
          break;
      }
      break;
    case ST_EXPECTING_SECOND_DATA_BYTE:
      switch (chip->internal_address)
      {
        case 0:
          result = chip->temperature_byte_lo;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        case 2:
          result = chip->t_os_byte_lo;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        case 3:
          result = chip->t_hyst_byte_lo;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        default:
          result = 0;
          chip->state = ST_EXPECTING_CONNECT;
          break;
      }
      break;
  }
  return result;
}

bool EXPORT(chip_i2c_write)(chip_state_t *chip, uint8_t data)
{
  uint8_t reload;

  switch (chip->state)
  {
    case ST_EXPECTING_FIRST_DATA_BYTE:
      chip->internal_address = data;
      chip->state = ST_EXPECTING_SECOND_DATA_BYTE;
      break;
    case ST_EXPECTING_SECOND_DATA_BYTE:
      switch (chip->internal_address)
      {
        case 1:
          chip->config = data;
          if (chip->config & 3)
          {
            // Shutdown Mode while in Interrupt Mode, so deactivate OS.
            DeactivatePinOS(chip);
          }
          reload = (chip->config >> 3 & 3) * 2;
          if (reload == 0) reload = 1;
          chip->fault_count_reload = reload;
          chip->fault_count = reload;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        case 2:
          chip->t_os_byte_hi = data;
          chip->state = ST_EXPECTING_THIRD_DATA_BYTE;
          break;
        case 3:
          chip->t_hyst_byte_hi = data;
          chip->state = ST_EXPECTING_THIRD_DATA_BYTE;
          break;
        default:
          chip->state = ST_EXPECTING_CONNECT;
          break;
      }
      break;
    case ST_EXPECTING_THIRD_DATA_BYTE:
      switch (chip->internal_address)
      {
        case 2:
          chip->t_os_byte_lo = data;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        case 3:
          chip->t_hyst_byte_lo = data;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        default:
          chip->state = ST_EXPECTING_CONNECT;
          break;
      }
      break;
  }
  return true; // Ack
}

void EXPORT(chip_i2c_disconnect)(chip_state_t *chip)
{
  // Do nothing
}


lm75a.chip.c

LM75A

lm75a.chip.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

LiquidCrystal I2C
LM75A@wokwi:b0ef025edfa9b18448c6b8ab2fe7337ac6594205