NEED HELP WITH SCRIPT FOR Adafruit MCP9808 TEMP SENSOR

Discussion about programs, libraries and tools that work with MicroPython. Mostly these are provided by a third party.
Target audience: All users and developers of MicroPython.
Post Reply
marine_hm
Posts: 16
Joined: Mon Oct 18, 2021 10:45 am
Location: USA: Eastern NC
Contact:

NEED HELP WITH SCRIPT FOR Adafruit MCP9808 TEMP SENSOR

Post by marine_hm » Sun Nov 14, 2021 2:46 am

I asked on the Adafruit forum, with no response.
Just learning Micropython; Since I have a few successful temp sensors throughout the house using Arduino.IDE and ESP8266. I took one of the sensors offline, uploaded Micropython on the ESP8266, ran the I2C scanner script. I get feedback from the REPL that it found 1 device at Decimal Address: 24, Hexa Address: 0X18

I searched the web and came up with 2 scripts:

The first script seems very short. It runs without errors but I get a blank REPL >>> after running it.
The second script is very lengthy but the same end results: No errors, a blank REPL >>> after running it.

1.
ref: https://pythonforundergradengineers.com ... ensor.html

Code: Select all

import machine
i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4))
byte_data = bytearray(2)
i2c.readfrom_mem_into(24, 5, byte_data)
value = byte_data[0] << 8 | byte_data[1]
temp = (value & 0xFFF) / 16.0
if value & 0x1000:
    temp -= 256.0
    print(temp)
2.
ref: https://github.com/kfricke/micropython- ... mcp9808.py

Code: Select all

# Imports
from machine import I2C


# Register pointers
REG_CONFIG = const(1)
REG_TEMP_BOUNDARY_UPPER = const(2)
REG_TEMP_BOUNDARY_LOWER = const(3)
REG_TEMP_BOUNDARY_CRITICAL = const(4)
REG_TEMP = const(5)
REG_MANUFACTURER_ID = const(6)
REG_DEVIDE_ID = const(7)
REG_RESOLUTION = const(8)


# Sensor resolution values
TEMP_RESOLUTION_MIN = const(0) # +0.5 C, refresh rate 30 ms
TEMP_RESOLUTION_LOW = const(1) # +0.25 C, refresh rate 65 ms
TEMP_RESOLUTION_AVG = const(2) # +0.125 C, refresh rate 130 ms
TEMP_RESOLUTION_MAX = const(3) # +0.0625 C, refresh rate 250 ms [Default]


# Alert selectors
ALERT_SELECT_ALL = const(0) # ambient > upper || ambient > critical || ambient < lower [Default]
ALERT_SELECT_CRIT = const(1) # Ambient temp > critical


# Alert polarity
ALERT_POLARITY_ALOW = const(0) # Active-low, requires pull-up [Default]
ALERT_POLARITY_AHIGH = const(1) # Active-high


# Alert output mode
ALERT_OUTPUT_COMPARATOR = const(0)
ALERT_OUTPUT_INTERRUPT = const(1)

class MCP9808(object):
    """
    This class implements an interface to the MCP9808 temprature sensor from
    Microchip.
    """

    def __init__(self, i2c=None, addr=0x18):
        """
        Initialize a sensor object on the given I2C bus and accessed by the
        given address.
        """
        if i2c == None or i2c.__class__ != I2C:
            raise ValueError('I2C object needed as argument!')
        self._i2c = i2c
        self._addr = addr
        self._check_device()

    def _send(self, buf):
        """
        Sends the given bufer object over I2C to the sensor.
        """
        if hasattr(self._i2c, "writeto"):
            # Micropython
            self._i2c.writeto(self._addr, buf)
        elif hasattr(self._i2c, "send"):
            # PyBoard Micropython
            self._i2c.send(self._addr, buf)
        else:
            raise Exception("Invalid I2C object. Unknown Micropython/platform?")

    def _recv(self, n):
        """
        Read bytes from the sensor using I2C. The byte count must be specified
        as an argument.
        Returns a bytearray containing the result.
        """
        if hasattr(self._i2c, "writeto"):
            # Micropython (PyCom)
            return self._i2c.readfrom(self._addr, n)
        elif hasattr(self._i2c, "send"):
            # PyBoard Micropython
            return self._i2c.recv(n, self._addr)
        else:
            raise Exception("Invalid I2C object. Unknown Micropython/platform?")

    def _check_device(self):
        """
        Tries to identify the manufacturer and device identifiers.
        """
        self._send(REG_MANUFACTURER_ID)
        self._m_id = self._recv(2)
        if not self._m_id == b'\x00T':
            raise Exception("Invalid manufacturer ID: '%s'!" % self._m_id)
        self._send(REG_DEVIDE_ID)
        self._d_id = self._recv(2)
        if not self._d_id == b'\x04\x00':
            raise Exception("Invalid device or revision ID: '%s'!" % self._d_id)

    def set_shutdown_mode(self, shdn=True):
        """
        Set sensor into shutdown mode to draw less than 1 uA and disable
        continous temperature conversion.
        """
        if shdn.__class__ != bool:
            raise ValueError('Boolean argument needed to set shutdown mode!')
        self._send(REG_CONFIG)
        cfg = self._recv(2)
        b = bytearray()
        b.append(REG_CONFIG)
        if shdn:
            b.append(cfg[0] | 1)
        else:
            b.append(cfg[0] & ~1)
        b.append(cfg[1])
        self._send(b)

    def set_alert_mode(self, enable_alert=True, output_mode=ALERT_OUTPUT_INTERRUPT, polarity=ALERT_POLARITY_ALOW, selector=ALERT_SELECT_ALL):
        """
        Set sensor into alert mode with the provided output,
        polarity and selector parameters

        If output mode is set to interrupt, a call to acknowledge_alert_irq()
        is required to deassert the MCP9808
        """
        if enable_alert.__class__ != bool:
            raise ValueError('Boolean argument needed to set alert mode!')
        if output_mode not in [ALERT_OUTPUT_COMPARATOR, ALERT_OUTPUT_INTERRUPT]:
            raise ValueError("Invalid output mode set.")
        if selector not in [ALERT_SELECT_ALL, ALERT_SELECT_CRIT]:
            raise ValueError("Invalid alert selector set.")
        if polarity not in [ALERT_POLARITY_ALOW, ALERT_POLARITY_AHIGH]:
            raise ValueError("Invalid alert polarity set.")
       
        enable_alert = 1 if enable_alert else 0
        self._send(REG_CONFIG)
        cfg = self._recv(2)

        alert_bits = (output_mode | (polarity << 1) | (selector << 2) | (enable_alert << 3)) & 0xF
        lsb_data = (cfg[1] & 0xF0) | alert_bits

        b = bytearray()
        b.append(REG_CONFIG)
        b.append(cfg[0])
        b.append(lsb_data)
        self._send(b)

    def acknowledge_alert_irq(self):
        """
        Must be called if MCP9808 is operating in interrupt output mode
        """
        self._send(REG_CONFIG)
        cfg = self._recv(2)
        b = bytearray()
        b.append(REG_CONFIG)
        b.append(cfg[0]) # MSB data
        b.append(cfg[1] | 0x20) # LSB data with interrupt clear bit set
        self._send(b) 

    def set_alert_boundary_temp(self, boundary_register, value):
        """
        Sets the alert boundary for the requested boundary register
        """
        if boundary_register not in [REG_TEMP_BOUNDARY_LOWER, REG_TEMP_BOUNDARY_UPPER, REG_TEMP_BOUNDARY_CRITICAL]:
            raise ValueError("Given alert boundary register is not valid!")
        if value < -128 or value > 127: # 8 bit two's complement
            raise ValueError("Temperature out of range [-128, 127]")

        integral = int(value)
        frac = abs(value - integral)
        if integral < 0:
            integral = (1 << 9) + integral
        integral = ((integral & 0x1FF) << 4)
        frac = (((1 if frac * 2 >= 1 else 0) << 1) + (1 if (frac * 2 - int(frac * 2)) * 2 >= 1 else 0)) << 2
        twos_value = (integral + frac if value >= 0 else integral - frac) & 0x1ffc
        b = bytearray()
        b.append(boundary_register)
        b.append((twos_value & 0xFF00) >> 8)
        b.append(twos_value & 0xFF)
        self._send(b)
       

    def set_resolution(self, r):
        """
        Sets the temperature resolution.
        """
        if r not in [TEMP_RESOLUTION_MIN, TEMP_RESOLUTION_LOW, TEMP_RESOLUTION_AVG, TEMP_RESOLUTION_MAX]:
            raise ValueError('Invalid temperature resolution requested!')
        b = bytearray()
        b.append(REG_RESOLUTION)
        b.append(r)
        self._send(b)

    def get_temp(self):
        """
        Read temperature in degree celsius and return float value.
        """
        self._send(REG_TEMP)
        raw = self._recv(2)
        u = (raw[0] & 0x0f) << 4
        l = raw[1] / 16
        if raw[0] & 0x10 == 0x10:
            temp = (u + l) - 256
        else:
            temp = u + l
        return temp

    def get_temp_int(self):
        """
        Read a temperature in degree celsius and return a tuple of two parts.
        The first part is the decimal part and the second the fractional part
        of the value.
        This method does avoid floating point arithmetic completely to support
        platforms missing float support.
        """
        self._send(REG_TEMP)
        raw = self._recv(2)
        u = (raw[0] & 0xf) << 4
        l = raw[1] >> 4
        if raw[0] & 0x10 == 0x10:
            temp = (u + l) - 256
            frac = -((raw[1] & 0x0f) * 100 >> 4)
        else:
            temp = u + l
            frac = (raw[1] & 0x0f) * 100 >> 4
        return temp, frac

    def _debug_config(self, cfg=None):
        """
        Prints the first 9 bits of the config register mapped to human
        readable descriptions
        """
        if not cfg:
            self._send(REG_CONFIG)
            cfg = self._recv(2)
       
        # meanings[a][b] with a the bit index (LSB order),
        # b=0 the config description and b={bit value}+1 the value description
        meanings = [
            ["Alert output mode", "Comparator", "Interrupt"],
            ["Alert polarity", "Active-low", "Active-high"],
            ["Alert Selector", "All", "Only Critical"],
            ["Alert enabled", "False", "True"],
            ["Alert status", "Not asserted", "Asserted as set by mode"],
            ["Interrupt clear bit", "0", "1"],
            ["Window [low, high] locked", "Unlocked", "Locked"],
            ["Critical locked", "Unlocked", "Locked"],
            ["Shutdown", "False", "True"]
        ]

        print("Raw config: {}".format(str(cfg)))
        for i in range(0, min(len(meanings), len(cfg)*8)):
            part = 0 if i > 7 else 1
            value = 1 if (cfg[part] & (2**(i % 8))) > 0 else 0
            print(meanings[i][0] + ": " + meanings[i][1 + value])

marine_hm
Posts: 16
Joined: Mon Oct 18, 2021 10:45 am
Location: USA: Eastern NC
Contact:

Re: NEED HELP WITH SCRIPT FOR Adafruit MCP9808 TEMP SENSOR

Post by marine_hm » Wed Dec 01, 2021 9:34 am

Solved:

Code: Select all

#############################################################
#                                                           #
# Adafruit MCP9808                                          #
#                                                           #
# LOLIN ESP8266 (Wemos D-1 mini)                            #
# SCL D1                                                    #
# SDA D2                                                    #
# VDD 5v                                                    #
#                                                           #
# By: Nick Sebring                                          #
# 11-20-21                                                  #
# with the help of Micropython FaceBook group               #
# ref: https://www.facebook.com/groups/1811015682533631     #
#                                                           #
#############################################################


import machine
from time import sleep
i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4))
byte_data = bytearray(2)
while True:
    i2c.readfrom_mem_into(24, 5, byte_data)
    value = byte_data[0] << 8 | byte_data[1]
    tempC = (value & 0xFFF) / 16.0 # converts "byte_data" to C
    if value & 0x1000:
        tempC -= 256.0  #formats for temperatures below ZERO
    tempF = tempC * 9 / 5 + 32  #converts C to F
    print( "MCP9808 temp is {:.1f}F".format(tempF) )  # 1=number of decimal places
                                                      # use either tempC or tempF
    sleep(60) #LOOP EVERY 60 SECONDS


Post Reply