TSL2591

[Marine2531]

I cannot get the TSL2591 sensor to work with the pyboard. Any suggestions. Has anyone done this?

[peterhinch]

I can't see a driver on Awesome Micropython. There is an Adafruit driver but this would need a little work to adapt it to MicroPython, mainly replacing the Adafruit busio object.

[royvanhal]

This is a modified version of (I think) a CircuitPython driver I adapted a couple of years ago. Let me know if it still works, haven't used it for a while!

# tsl2591 lux sensor interface
import time

VISIBLE = 2
INFRARED = 1
FULLSPECTRUM = 0

ADDR = 0x29
READBIT = 0x01
COMMAND_BIT = 0xA0
CLEAR_BIT = 0x40
WORD_BIT = 0x20
BLOCK_BIT = 0x10
ENABLE_POWERON = 0x01
ENABLE_POWEROFF = 0x00
ENABLE_AEN = 0x02
ENABLE_AIEN = 0x10
CONTROL_RESET = 0x80
LUX_DF = 408.0
LUX_COEFB = 1.64
LUX_COEFC = 0.59
LUX_COEFD = 0.86

REGISTER_ENABLE = 0x00
REGISTER_CONTROL = 0x01
REGISTER_THRESHHOLDL_LOW = 0x02
REGISTER_THRESHHOLDL_HIGH = 0x03
REGISTER_THRESHHOLDH_LOW = 0x04
REGISTER_THRESHHOLDH_HIGH = 0x05
REGISTER_INTERRUPT = 0x06
REGISTER_CRC = 0x08
REGISTER_ID = 0x0A
REGISTER_CHAN0_LOW = 0x14
REGISTER_CHAN0_HIGH = 0x15
REGISTER_CHAN1_LOW = 0x16
REGISTER_CHAN1_HIGH = 0x17
INTEGRATIONTIME_100MS = 0x00
INTEGRATIONTIME_200MS = 0x01
INTEGRATIONTIME_300MS = 0x02
INTEGRATIONTIME_400MS = 0x03
INTEGRATIONTIME_500MS = 0x04
INTEGRATIONTIME_600MS = 0x05

GAIN_LOW = 0x00
GAIN_MED = 0x10
GAIN_HIGH = 0x20
GAIN_MAX = 0x30

def _bytes_to_int(data):
    return data[0] + (data[1]<<8)

from machine import I2C, Pin
class SMBusEmulator:
    __slots__ = ('i2c',)
    def __init__(self, scl_pinno=22, sda_pinno=21):
        self.i2c = I2C(scl=Pin(scl_pinno, Pin.IN),
                       sda=Pin(sda_pinno, Pin.IN))

    def write_byte_data(self, addr, cmd, val):
        buf = bytes([cmd, val])
        self.i2c.writeto(addr, buf)

    def read_word_data(self, addr, cmd):
        assert cmd < 256
        buf = bytes([cmd])
        self.i2c.writeto(addr, buf)
        data = self.i2c.readfrom(addr, 4)
        return _bytes_to_int(data)

SENSOR_ADDRESS=0x29

class Tsl2591:
    def __init__(
                 self,
                 sensor_id,
                 integration=INTEGRATIONTIME_100MS,
                 gain=GAIN_LOW
                 ):
        self.sensor_id = sensor_id
        self.bus = SMBusEmulator()
        self.integration_time = integration
        self.gain = gain
        self.set_timing(self.integration_time)
        self.set_gain(self.gain)
        self.disable()

    def set_timing(self, integration):
        self.enable()
        self.integration_time = integration
        self.bus.write_byte_data(
                    SENSOR_ADDRESS,
                    COMMAND_BIT | REGISTER_CONTROL,
                    self.integration_time | self.gain
                    )
        self.disable()

    def set_gain(self, gain):
        self.enable()
        self.gain = gain
        self.bus.write_byte_data(
                    SENSOR_ADDRESS,
                    COMMAND_BIT | REGISTER_CONTROL,
                    self.integration_time | self.gain
                    )
        self.disable()

    def calculate_lux(self, full, ir):
        if (full == 0xFFFF) | (ir == 0xFFFF):
            return 0
            
        case_integ = {
            INTEGRATIONTIME_100MS: 100.,
            INTEGRATIONTIME_200MS: 200.,
            INTEGRATIONTIME_300MS: 300.,
            INTEGRATIONTIME_400MS: 400.,
            INTEGRATIONTIME_500MS: 500.,
            INTEGRATIONTIME_600MS: 600.,
            }
        if self.integration_time in case_integ.keys():
            atime = case_integ[self.integration_time]
        else:
            atime = 100.

        case_gain = {
            GAIN_LOW: 1.,
            GAIN_MED: 25.,
            GAIN_HIGH: 428.,
            GAIN_MAX: 9876.,
            }

        if self.gain in case_gain.keys():
            again = case_gain[self.gain]
        else:
            again = 1.

        cpl = (atime * again) / LUX_DF
        lux1 = (full - (LUX_COEFB * ir)) / cpl

        lux2 = ((LUX_COEFC * full) - (LUX_COEFD * ir)) / cpl

        return max([lux1, lux2])

    def enable(self):
        self.bus.write_byte_data(
                    SENSOR_ADDRESS,
                    COMMAND_BIT | REGISTER_ENABLE,
                    ENABLE_POWERON | ENABLE_AEN | ENABLE_AIEN
                    )

    def disable(self):
        self.bus.write_byte_data(
                    SENSOR_ADDRESS,
                    COMMAND_BIT | REGISTER_ENABLE,
                    ENABLE_POWEROFF
                    )

    def get_full_luminosity(self):
        self.enable()
        time.sleep(0.120*self.integration_time+1)
        full = self.bus.read_word_data(
                    SENSOR_ADDRESS, COMMAND_BIT | REGISTER_CHAN0_LOW
                    )
        ir = self.bus.read_word_data(
                    SENSOR_ADDRESS, COMMAND_BIT | REGISTER_CHAN1_LOW
                    )                    
        self.disable()
        return full, ir

    def get_luminosity(self, channel):
        full, ir = self.get_full_luminosity()
        if channel == FULLSPECTRUM:
            return full
        elif channel == INFRARED:
            return ir
        elif channel == VISIBLE:
            return full - ir
        else:
            return 0

    def sample(self):
        full, ir = self.get_full_luminosity()
        return self.calculate_lux(full, ir)

[Marine2531]

wow, that looks great. Unfortunately my python skills are just beginning. How to use the classes you provide are not in my skill list yet. But I know what you have written is what I need. I hate to ask but could you provide a very basic program to read the sensor value using the classes you provided. I promise I am studying object oriented programming in python.

[Marine2531]

So, with the help of an AI I was able to get the code running. Here's what it came up with for the tsl2591.py file

class TSL2591:
TSL2591_ADDR = 0x29
COMMAND_BIT = 0xA0
ENABLE_REGISTER = 0x00
ENABLE_POWERON = 0x01
ENABLE_AEN = 0x02
CONTROL_REGISTER = 0x01
C0DATAL = 0x14
C1DATAL = 0x16

def __init__(self, i2c):
    self.i2c = i2c
    self.addr = self.TSL2591_ADDR
    self.integration_time = 2  # Default value
    self.gain = 1  # Default value

    # Power on and enable ALS
    self.i2c.writeto_mem(self.addr, self.COMMAND_BIT | self.ENABLE_REGISTER,
                         bytes([self.ENABLE_POWERON | self.ENABLE_AEN]))

    # Apply default gain and timing
    self._update_control()

def set_gain(self, gain):
    self.gain = gain
    self._update_control()

def set_timing(self, time):
    self.integration_time = time
    self._update_control()

def _update_control(self):
    ctl = (self.integration_time & 0x07) | ((self.gain & 0x03) << 4)
    self.i2c.writeto_mem(self.addr, self.COMMAND_BIT | self.CONTROL_REGISTER, bytes([ctl]))

def get_full_luminosity(self):
    data0 = self.i2c.readfrom_mem(self.addr, self.COMMAND_BIT | self.C0DATAL, 2)
    data1 = self.i2c.readfrom_mem(self.addr, self.COMMAND_BIT | self.C1DATAL, 2)
    full = data0[1] << 8 | data0[0]
    ir = data1[1] << 8 | data1[0]
    return full, ir

def calculate_lux(self, full, ir):
    if full == 0xFFFF or ir == 0xFFFF:
        return 0
    return full - ir  # Very rough approximation

Here is the main.py file
class TSL2591:
TSL2591_ADDR = 0x29
COMMAND_BIT = 0xA0
ENABLE_REGISTER = 0x00
ENABLE_POWERON = 0x01
ENABLE_AEN = 0x02
CONTROL_REGISTER = 0x01
C0DATAL = 0x14
C1DATAL = 0x16

def __init__(self, i2c):
    self.i2c = i2c
    self.addr = self.TSL2591_ADDR
    self.integration_time = 2  # Default value
    self.gain = 1  # Default value

    # Power on and enable ALS
    self.i2c.writeto_mem(self.addr, self.COMMAND_BIT | self.ENABLE_REGISTER,
                         bytes([self.ENABLE_POWERON | self.ENABLE_AEN]))

    # Apply default gain and timing
    self._update_control()

def set_gain(self, gain):
    self.gain = gain
    self._update_control()

def set_timing(self, time):
    self.integration_time = time
    self._update_control()

def _update_control(self):
    ctl = (self.integration_time & 0x07) | ((self.gain & 0x03) << 4)
    self.i2c.writeto_mem(self.addr, self.COMMAND_BIT | self.CONTROL_REGISTER, bytes([ctl]))

def get_full_luminosity(self):
    data0 = self.i2c.readfrom_mem(self.addr, self.COMMAND_BIT | self.C0DATAL, 2)
    data1 = self.i2c.readfrom_mem(self.addr, self.COMMAND_BIT | self.C1DATAL, 2)
    full = data0[1] << 8 | data0[0]
    ir = data1[1] << 8 | data1[0]
    return full, ir

def calculate_lux(self, full, ir):
    if full == 0xFFFF or ir == 0xFFFF:
        return 0
    return full - ir  # Very rough approximation

[aliarifat]

Use MicroPython's I2C scanner to check if the sensor is detected:
from machine import I2C
i2c = I2C(1) # (SCL=X9, SDA=X10)
print(i2c.scan()) # Should return [41] if TSL2591 is found (0x29)

The TSL2591 should appear at 0x29 (default address).
If it appears without any problem, you can use the TSL2591 MicroPython Library.https://github.com/jfischer/micropython-tsl2591/blob/master/tsl2591.py
I don't know if you're using a ready-made TSL2591 sensor module or made one by yourself. If you want to make a functional TSL2591 sensor module by yourself, you can see here. https://www.pcbway.com/project/shareproject/TSL25911_Light_Sensor_615d1cdf.html

[Marine2531]

Yes, the address is coming as 0x29. My OOP skills are lacking. Using the class will be a struggle. But it looks like it has everything I would need.

[Marine2531]

I am very new to python and jumped in the deep end of the pool.

[Marine2531]

So I need to educate myself. Can anyone provide a book reference for learning python? or Micropython?

[Marine2531]

ok, update. I was able to find an AI that was able to get the code working for me. I found Micropython copilot. Everything is working wonderful. But I still have to learn python. I'm totally amazed that the AI could everything, and direct me on the how, why, and where. Just freaking amazing.