TMP144 Texas Instruments UART

[coffeemakingtoaster]

Hello everyone,

right now I am working on a project with the TMP144 temperature sensor from Texas Instruments and I cant seem to get it working.
I (to the best of my knowledge) implemented a driver that follows the datasheet but I cant get it working.

My driver so far:

from machine import UART, Pin
from time import sleep_ms

CMD_SOFT_RESET=0xB4
CMD_GLOBAL_INIT=0x8C
CMD_GLOBAL_ADDRESS_ASSIGN=0x90
CMD_GLOBAL_READ_TEMP=0xF1
CALIBRATION_BYTE=0x55


class TMP144:
    
    def __init__(self, tx_pin=12, rx_pin=13, baud_rate=9600):
        self.uart = UART(0, baudrate=baud_rate, tx=Pin(tx_pin), rx=Pin(rx_pin))
        self._reset()
        self._setup()
        
    def _reset(self):
        self.uart.write(bytes([CALIBRATION_BYTE, CMD_SOFT_RESET]))
        self.uart.flush()
        
    def _setup(self):
        databuf = bytes([
            CALIBRATION_BYTE,
            CMD_GLOBAL_INIT,
            CMD_GLOBAL_ADDRESS_ASSIGN
        ])
        self.uart.write(databuf)
        self.uart.flush()
        sleep_ms(10)
        print(self.uart.read())
    
    def read_temp(self):
       buffer = bytes([CALIBRATION_BYTE, CMD_GLOBAL_READ_TEMP]) 
       self.uart.write(buffer)
       data = self.uart.read() 
       return data
       
       
       
sensor = TMP144()
print(sensor.read_temp())

The output I am currently getting is

b'\x00'
None

Anyone that might have experience with this sensor that is able to help me?

[robert-hh]

a) You surely considered that GPIO pin 12 is board pin 16, GPIO pin 13 is board pin 17.
b) uart.read() returns what is available at that very moment in the read buffer. If it is empty, it return None. Since when calling read() in read_temp() the write is not finished yet, it return None. You have to call flush() like in setup() and then either us a loop with uart.any() to scan for incoming data, or configure uart with a timeout and use uart.read(n), where n is the amount of data you expect. Then uart will return the requested amount, unless a timeout happens.

[JiriSvacek]

I just played with TMP144 so I wrote basic class as example

import machine
import time


class PointerAddress:
    TEMPERATURE_REGISTER = 0x0
    CONFIGURATION_REGISTER = 0x2
    T_LOW_REGISTER = 0x4
    T_HIGH_REGISTER = 0x6


class TMP144:
    GLOBAL_RESET = 0xB4
    GLOBAL_INIT = 0x8C
    GLOBAL_ADDRESS_ASSIGNMENT = 0x90
    GLOBAL_CLEAR_INTERRUPT = 0xA9
    CALIBRATION_BYTE = 0x55
    TEMP_FORMAT = 0.0625

    def __init__(self, uart: machine.UART, temperatures_counter: int):
        self.uart = uart
        actual_count = self._init()
        if temperatures_counter != actual_count:
            raise ValueError("Wrong number of temperatures connected!")

    @staticmethod
    def decode_value(value_: int, msb: int, lsb: int) -> int:
        mask = 2 ** (1 + msb - lsb) - 1 << lsb
        value = (value_ & mask) >> lsb
        return value

    @staticmethod
    def get_int16(l_byte: int, h_byte: int) -> int:
        return (h_byte << 8) + l_byte

    @staticmethod
    def chunks(data: list[int], n: int) -> list[list[int]]:
        """Returns successive n-sized chunks from data."""
        return [data[i : i + n] for i in range(0, len(data), n)]

    @staticmethod
    def get_data(data: list[int], msb: int, lsb: int) -> list[int]:
        return [TMP144.decode_value(value, msb, lsb) for value in data]

    @staticmethod
    def calculate_temperature(raw_data: list[int]) -> list[float]:
        parsed_data = TMP144.get_data(raw_data, 15, 4)
        output = []
        for value in parsed_data:
            temperature = TMP144.signed_int(value, 12) * TMP144.TEMP_FORMAT
            output.append(round(temperature, 1))
        return output

    @staticmethod
    def shift_left_by(value: int, by: int) -> int:
        return value << by

    @staticmethod
    def signed_int(value: int, size: int) -> int:
        if value & (1 << (size - 1)):
            value -= 1 << size
        return value

    def _init(self) -> int:
        cmd = [self.GLOBAL_RESET]
        self.send_and_receive(cmd)
        cmd = [self.GLOBAL_INIT, self.GLOBAL_ADDRESS_ASSIGNMENT]
        data = self.send_and_receive(cmd)
        return self.decode_value(data[1], 3, 0)

    def send_and_receive(self, cmd: list[int]) -> list[int]:
        data = [self.CALIBRATION_BYTE] + cmd
        self.uart.write(bytes(data))
        time.sleep(0.1)
        if self.uart.any():
            response = self.uart.read()
            calibration_byte, *data = response
            if 0x55 == calibration_byte:
                return data
            raise ValueError("First recivied byte is not CALIBRATION BYTE!")
        raise ValueError("No response received")

    def _read(self, cmd: int, pointer_address) -> list[int]:
        result = self.send_and_receive([cmd | pointer_address])[1:]
        if len(result) % 2 != 0:
            raise ValueError("Read response is not in 2 bytes array.")
        data = list(self.chunks(result, 2))
        return [self.get_int16(values[0], values[1]) for values in data]

    def read_global(self, pointer_address: int) -> list[int] | list[float]:
        response = self._read(0xF1, pointer_address)
        if pointer_address == PointerAddress.CONFIGURATION_REGISTER:
            return self.get_data(response, 15, 0)
        return self.calculate_temperature(response)

    def read_by_id(self, id_: int, pointer_address: int) -> int | float:
        cmd = self.shift_left_by(id_, 3) | 1
        response = self._read(cmd, pointer_address)
        if pointer_address == PointerAddress.CONFIGURATION_REGISTER:
            return self.get_data(response, 15, 0)[0]
        return self.calculate_temperature(response)[0]

    def write_global(self, pointer_address: int, h_byte: int, l_byte: int):
        cmd = [0xF0 | pointer_address, l_byte, h_byte]
        self.send_and_receive(cmd)

    def write_by_id(self, id_: int, pointer_address: int, h_byte: int, l_byte: int):
        cmd = [self.shift_left_by(id_, 3) | pointer_address, l_byte, h_byte]
        self.send_and_receive(cmd)


uart = machine.UART(0, baudrate=9600, tx=machine.Pin(0), rx=machine.Pin(1))
measurements = TMP144(uart, 1)
temp = PointerAddress.TEMPERATURE_REGISTER
print(measurements.read_global(temp))
measurements.write_by_id(0, PointerAddress.CONFIGURATION_REGISTER, 0x62, 0x0)
while True:
    time.sleep(0.8)
    print(measurements.read_by_id(0, temp))