Add LTR507 module

Author: JosipKuci

LTR507/LTR507/Examples/ltr507-CustomConfiguration.py

@@ -0,0 +1,109 @@
+# FILE: ltr507-CustomConfiguration.py 
+# AUTHOR: Josip Šimun Kuči @ Soldered
+# BRIEF:  An example showing how to initialize the LTR-507 sensor and get light and proximity measurements
+# WORKS WITH: Digital light & proximity sensor LTR-507 breakout: www.solde.red/333063
+# LAST UPDATED: 2025-06-10
+
+from machine import I2C, Pin
+from time import sleep
+from ltr507 import LTR507  # This assumes you have an ltr507.py module with the driver
+from ltr507_config import *
+
+"""
+Connecting diagram:
+
+IMPORTANT: an IR LED must be connected when measuring proximity!
+LTR-507                      IR LED
+VLED------------------------>CATHODE (-)
+VCC------------------------->ANODE (+)
+"""
+
+# If you aren't using the Qwiic connector, manually enter your I2C pins
+#i2c = I2C(0, scl=Pin(22), sda=Pin(21))
+#sensor = LTR507(i2c)
+
+#Initialize I2C communication with the sensor over Qwiic
+sensor = LTR507()
+
+#Set up the sensor with its default values
+sensor.begin()
+# You can change the following settings:
+
+# This turns off the ambient light sensor (ALS) and proximity sensor
+# sensor.set_als_mode(False)
+# sensor.set_ps_mode(False)
+# Setting the parameter to 'True' will turn it back on, this is done by default in init()
+
+# Set the gain of the sensor
+# This way you can get more or less sensitivity
+# From the datasheet:
+#      - LTR507_ALS_GAIN_RANGE1: 1 lux to 64k lux (1 lux/count) (default)
+#      - LTR507_ALS_GAIN_RANGE2: 0.5 lux to 32k lux (0.5 lux/count)
+#      - LTR507_ALS_GAIN_RANGE3: 0.02 lux to 640 lux (0.01 lux/count)
+#      - LTR507_ALS_GAIN_RANGE4: 0.01 lux to 320 lux (0.005 lux/count)
+sensor.set_als_gain(LTR507_ALS_GAIN_RANGE1)
+
+# Set the automatic measurement rate
+# You can use:
+#      - LTR507_ALS_MEASUREMENT_RATE_100MS (default)
+#      - LTR507_ALS_MEASUREMENT_RATE_200MS
+#      - LTR507_ALS_MEASUREMENT_RATE_500MS
+#      - LTR507_ALS_MEASUREMENT_RATE_1000MS
+#      - LTR507_ALS_MEASUREMENT_RATE_2000MS
+sensor.set_als_meas_rate(LTR507_ALS_MEASUREMENT_RATE_100MS)
+
+# Set the bit width of the ALS measurement
+# This changes the time required to complete a single measurement
+# So, it's recommended to leave it as default
+# sensor.set_als_bitwidth(sensor.ALS_ADC_BIT_WIDTH_16BIT)
+
+# Set the auto measurement rate for proximity
+# You can use:
+#      - LTR507_PS_MEASUREMENT_RATE_12_5MS
+#      - LTR507_PS_MEASUREMENT_RATE_50MS
+#      - LTR507_PS_MEASUREMENT_RATE_70MS
+#      - LTR507_PS_MEASUREMENT_RATE_100MS (default)
+#      - LTR507_PS_MEASUREMENT_RATE_200MS
+#      - LTR507_PS_MEASUREMENT_RATE_500MS
+#      - LTR507_PS_MEASUREMENT_RATE_1000MS
+#      - LTR507_PS_MEASUREMENT_RATE_2000MS
+sensor.set_ps_meas_rate(LTR507_PS_MEASUREMENT_RATE_100MS)
+
+# Set the max current supplied to the IR LED
+# You can use:
+#      - LTR507_LED_PEAK_CURRENT_5MA
+#      - LTR507_LED_PEAK_CURRENT_10MA
+#      - LTR507_LED_PEAK_CURRENT_20MA
+#      - LTR507_LED_PEAK_CURRENT_50MA (default)
+sensor.set_led_peak_current(LTR507_LED_PEAK_CURRENT_50MA)
+
+# Set the pulse frequency of the IR LED
+# You can use:
+#      - LTR507_LED_PULSE_FREQ_30KHZ
+#      - LTR507_LED_PULSE_FREQ_40KHZ
+#      - LTR507_LED_PULSE_FREQ_50KHZ
+#      - LTR507_LED_PULSE_FREQ_60KHZ (default)
+#      - LTR507_LED_PULSE_FREQ_70KHZ
+#      - LTR507_LED_PULSE_FREQ_80KHZ
+#      - LTR507_LED_PULSE_FREQ_90KHZ
+#      - LTR507_LED_PULSE_FREQ_100KHZ
+sensor.set_led_pulse_freq(LTR507_LED_PULSE_FREQ_60KHZ)
+
+# Set the number of pulses for a proximity measurement
+# You can use any number from 1 to 15, default is 1
+sensor.set_ps_num_pulses(1)
+
+# Main loop
+while True:
+    #Measure the light intensity from the sensor in lux 
+    lux = sensor.getLightIntensity()
+    #Measure the proximity value of the sensor
+    prox = sensor.getProximity()
+
+    # Print the readings
+    print("Light sensor reading:", lux)
+    print("Proximity reading:", prox)
+    print()  # Newline
+
+    # Wait a bit until the next reading so output isn't too fast
+    sleep(1)

LTR507/LTR507/Examples/ltr507-LightAndProximity.py

@@ -0,0 +1,40 @@
+# FILE: LTR507-LightAndProximity.py 
+# AUTHOR: Josip Šimun Kuči @ Soldered
+# BRIEF:  An example showing how to initialize the LTR-507 sensor and get light and proximity measurements
+# WORKS WITH: Digital light & proximity sensor LTR-507 breakout: www.solde.red/333063
+# LAST UPDATED: 2025-06-10 
+
+from machine import I2C, Pin
+import time
+from ltr507 import LTR507
+
+"""
+Connecting diagram:
+
+IMPORTANT: an IR LED must be connected when measuring proximity!
+LTR-507                      IR LED
+VLED------------------------>CATHODE (-)
+VCC------------------------->ANODE (+)
+"""
+
+# If you aren't using the Qwiic connector, manually enter your I2C pins
+#i2c = I2C(0, scl=Pin(22), sda=Pin(21))
+#sensor = LTR507(i2c)
+
+#Initialize I2C communication with the sensor over Qwiic
+sensor = LTR507()
+
+#Set up the sensor with its default values
+sensor.begin()
+
+#Infinite loop
+while 1:
+    #Measure the light intensity from the sensor in lux 
+    lux = sensor.getLightIntensity()
+    #Measure the proximity value of the sensor
+    prox = sensor.getProximity()
+    
+    #Print the values over Serial communication
+    print("Lux:", lux, "Proximity:", prox)
+    #Pause for 1 second
+    time.sleep(1)

LTR507/LTR507/ltr507.py

@@ -0,0 +1,203 @@
+# FILE: LTR507.py 
+# AUTHOR: Josip Šimun Kuči @ Soldered
+# BRIEF: A Micropython module for the LTR-507 Light and proximity sensor
+# LAST UPDATED: 2025-06-10 
+
+from machine import I2C, Pin
+from os import uname
+from time import sleep_ms
+from ltr507_config import *
+
+class LTR507:
+    def __init__(self, i2c=None, address=0x3A):
+        """
+        Initialize the LTR507 sensor.
+
+        :param i2c: Initialized I2C object
+        :param address: I2C address of the sensor (default 0x3A)
+        """
+        if i2c != None:
+            self.i2c = i2c
+        else:
+            if uname().sysname == "esp32" or uname().sysname == "esp8266":
+                self.i2c = I2C(0, scl=Pin(22), sda=Pin(21))
+            else:
+                raise Exception("Board not recognized, enter I2C pins manually")
+        self.address = address
+        self.raw = bytearray(2)  # Buffer for reading multi-byte registers
+
+    def _read_register(self, reg, length=1):
+        """
+        Read bytes from a sensor register.
+
+        :param reg: Register address to read from
+        :param length: Number of bytes to read (default 1)
+        :return: Bytes read from the register
+        """
+        return self.i2c.readfrom_mem(self.address, reg, length)
+
+    def _write_register(self, reg, data):
+        """
+        Write a single byte to a sensor register.
+
+        :param reg: Register address to write to
+        :param data: Byte value to write
+        """
+        self.i2c.writeto_mem(self.address, reg, bytes([data]))
+
+    def _write_registers(self, reg, values):
+        """
+        Write multiple bytes to consecutive sensor registers.
+
+        :param reg: Starting register address
+        :param values: Iterable of byte values to write
+        """
+        self.i2c.writeto_mem(self.address, reg, bytes(values))
+
+    def begin(self):
+        """
+        Initialize the sensor with default configuration settings.
+        Enables ALS and PS modes and sets recommended measurement parameters.
+        """
+        self.set_als_mode(True)
+        self.set_ps_mode(True)
+        self.set_als_gain(LTR507_ALS_GAIN_RANGE1)
+        self.set_als_bitwidth(LTR507_ALS_ADC_BIT_WIDTH_16BIT)
+        self.set_als_meas_rate(LTR507_ALS_MEASUREMENT_RATE_100MS)
+        self.set_led_pulse_freq(LTR507_LED_PULSE_FREQ_60KHZ)
+        self.set_led_duty_cycle(LTR507_LED_CURRENT_DUTY_DEFAULT)
+        self.set_ps_meas_rate(LTR507_PS_MEASUREMENT_RATE_100MS)
+        self.set_led_peak_current(LTR507_LED_PEAK_CURRENT_50MA)
+        self.set_ps_num_pulses(1)
+
+    def set_ps_mode(self, mode):
+        """
+        Enable or disable proximity sensing mode.
+
+        :param mode: Boolean indicating whether to enable (True) or disable (False) PS mode
+        """
+        val = self._read_register(LTR507_PS_CONTR_REG)[0]
+        val &= ~LTR507_PS_MODE_MASK
+        val |= (mode << LTR507_PS_MODE_SHIFT) & LTR507_PS_MODE_MASK
+        self._write_register(LTR507_PS_CONTR_REG, val)
+
+    def set_als_mode(self, mode):
+        """
+        Enable or disable ambient light sensing mode.
+
+        :param mode: Boolean indicating whether to enable (True) or disable (False) ALS mode
+        """
+        val = self._read_register(LTR507_ALS_CONTR_REG)[0]
+        if mode:
+            val |= 0x02  # Set bit 1
+        else:
+            val &= 0xFD  # Clear bit 1
+        self._write_register(LTR507_ALS_CONTR_REG, val)
+
+    def set_led_pulse_freq(self, freq):
+        """
+        Set the LED pulse frequency for proximity sensing.
+
+        :param freq: Frequency constant (e.g., LTR507_LED_PULSE_FREQ_60KHZ)
+        """
+        val = self._read_register(LTR507_PS_LED_REG)[0]
+        val &= ~LTR507_LED_PULSE_FREQ_MASK
+        val |= (freq << LTR507_LED_PULSE_FREQ_SHIFT) & LTR507_LED_PULSE_FREQ_MASK
+        self._write_register(LTR507_PS_LED_REG, val)
+
+    def set_led_duty_cycle(self, duty):
+        """
+        Set the duty cycle of the proximity LED.
+
+        :param duty: Duty cycle constant (e.g., LTR507_LED_CURRENT_DUTY_DEFAULT)
+        """
+        val = self._read_register(LTR507_PS_LED_REG)[0]
+        val &= ~LTR507_LED_DUTY_CYCLE_MASK
+        val |= (duty << LTR507_LED_DUTY_CYCLE_SHIFT) & LTR507_LED_DUTY_CYCLE_MASK
+        self._write_register(LTR507_PS_LED_REG, val)
+
+    def set_ps_meas_rate(self, rate):
+        """
+        Set the measurement rate for proximity sensing.
+
+        :param rate: Measurement rate constant (e.g., LTR507_PS_MEASUREMENT_RATE_100MS)
+        """
+        val = rate & LTR507_PS_MEAS_RATE_MASK
+        self._write_register(LTR507_PS_MEAS_RATE_REG, val)
+
+    def set_led_peak_current(self, current):
+        """
+        Set the peak drive current of the proximity LED.
+
+        :param current: Current constant (e.g., LTR507_LED_PEAK_CURRENT_50MA)
+        """
+        val = self._read_register(LTR507_PS_LED_REG)[0]
+        val &= ~LTR507_LED_PEAK_CURRENT_MASK
+        val |= current & LTR507_LED_PEAK_CURRENT_MASK
+        self._write_register(LTR507_PS_LED_REG, val)
+
+    def set_ps_num_pulses(self, num_pulses):
+        """
+        Set the number of LED pulses for each proximity measurement.
+
+        :param num_pulses: Integer value between 1 and 15
+        """
+        num_pulses = max(1, min(15, num_pulses))
+        val = num_pulses & LTR507_PS_PULSES_MASK
+        self._write_register(LTR507_PS_N_PULSES_REG, val)
+
+    def set_als_gain(self, gain):
+        """
+        Set the analog gain for ambient light sensing.
+
+        :param gain: Gain constant (e.g., LTR507_ALS_GAIN_RANGE1)
+        """
+        val = self._read_register(LTR507_ALS_CONTR_REG)[0]
+        val &= ~LTR507_ALS_GAIN_MASK
+        val |= (gain << LTR507_ALS_GAIN_SHIFT) & LTR507_ALS_GAIN_MASK
+        self._write_register(LTR507_ALS_CONTR_REG, val)
+
+    def set_als_bitwidth(self, bitwidth):
+        """
+        Set the ADC resolution (bit width) for ambient light measurements.
+
+        :param bitwidth: Bit width constant (e.g., LTR507_ALS_ADC_BIT_WIDTH_16BIT)
+        """
+        val = self._read_register(LTR507_ALS_MEAS_PATE_REG)[0]
+        val &= ~LTR507_ALS_ADC_BIT_WIDTH_MASK
+        val |= (bitwidth << LTR507_ALS_ADC_BIT_WIDTH_SHIFT) & LTR507_ALS_ADC_BIT_WIDTH_MASK
+        self._write_register(LTR507_ALS_MEAS_PATE_REG, val)
+
+    def set_als_meas_rate(self, rate):
+        """
+        Set the ambient light sensor measurement rate.
+
+        :param rate: Measurement rate constant (e.g., LTR507_ALS_MEASUREMENT_RATE_100MS)
+        """
+        val = self._read_register(LTR507_ALS_MEAS_PATE_REG)[0]
+        val &= ~LTR507_ALS_MEASURE_RATE_MASK
+        val |= (rate << LTR507_ALS_MEASURE_RATE_SHIFT) & LTR507_ALS_MEASURE_RATE_MASK
+        self._write_register(LTR507_ALS_MEAS_PATE_REG, val)
+
+    def getLightIntensity(self):
+        """
+        Read and return the current ambient light level.
+
+        :return: 16-bit integer light value (0 if data not ready)
+        """
+        status = self._read_register(LTR507_ALS_PS_STATUS_REG)[0]
+        if not (status & 0x04):  # Check if ALS data is valid
+            return 0
+        data = self._read_register(LTR507_ALS_DATA_0_REG, 2)
+        return data[0] | (data[1] << 8)  # Combine low and high bytes
+
+    def getProximity(self):
+        """
+        Read and return the current proximity sensor value.
+
+        :return: 16-bit integer proximity value
+        """
+        data = self._read_register(LTR507_PS_DATA_LOW_REG, 2)
+        low = data[0] & LTR507_PS_DATA_LOW_MASK
+        high = data[1] & LTR507_PS_DATA_HIGH_MASK
+        return low | (high << 8)  # Combine low and high bytes