--- /dev/null
+# https://github.com/flrrth/pico-bh1750
+
+import math
+
+from micropython import const
+from utime import sleep_ms
+
+
+class BH1750:
+ """Class for the BH1750 digital Ambient Light Sensor
+
+ The datasheet can be found at https://components101.com/sites/default/files/component_datasheet/BH1750.pdf
+ """
+
+ MEASUREMENT_MODE_CONTINUOUSLY = const(1)
+ MEASUREMENT_MODE_ONE_TIME = const(2)
+
+ RESOLUTION_HIGH = const(0)
+ RESOLUTION_HIGH_2 = const(1)
+ RESOLUTION_LOW = const(2)
+
+ MEASUREMENT_TIME_DEFAULT = const(69)
+ MEASUREMENT_TIME_MIN = const(31)
+ MEASUREMENT_TIME_MAX = const(254)
+
+ def __init__(self, address, i2c):
+ self._address = address
+ self._i2c = i2c
+ self._measurement_mode = BH1750.MEASUREMENT_MODE_ONE_TIME
+ self._resolution = BH1750.RESOLUTION_HIGH
+ self._measurement_time = BH1750.MEASUREMENT_TIME_DEFAULT
+
+ self._write_measurement_time()
+ self._write_measurement_mode()
+
+ def configure(self, measurement_mode: int, resolution: int, measurement_time: int):
+ """Configures the BH1750.
+
+ Keyword arguments:
+ measurement_mode -- measure either continuously or once
+ resolution -- return measurements in either high, high2 or low resolution
+ measurement_time -- the duration of a single measurement
+ """
+ if measurement_time not in range(BH1750.MEASUREMENT_TIME_MIN, BH1750.MEASUREMENT_TIME_MAX + 1):
+ raise ValueError("measurement_time must be between {0} and {1}"
+ .format(BH1750.MEASUREMENT_TIME_MIN, BH1750.MEASUREMENT_TIME_MAX))
+
+ self._measurement_mode = measurement_mode
+ self._resolution = resolution
+ self._measurement_time = measurement_time
+
+ self._write_measurement_time()
+ self._write_measurement_mode()
+
+ def _write_measurement_time(self):
+ buffer = bytearray(1)
+
+ high_bit = 1 << 6 | self._measurement_time >> 5
+ low_bit = 3 << 5 | (self._measurement_time << 3) >> 3
+
+ buffer[0] = high_bit
+ self._i2c.writeto(self._address, buffer)
+
+ buffer[0] = low_bit
+ self._i2c.writeto(self._address, buffer)
+
+ def _write_measurement_mode(self):
+ buffer = bytearray(1)
+
+ buffer[0] = self._measurement_mode << 4 | self._resolution
+ self._i2c.writeto(self._address, buffer)
+ sleep_ms(24 if self._measurement_time == BH1750.RESOLUTION_LOW else 180)
+
+ def reset(self):
+ """Clear the illuminance data register."""
+ self._i2c.writeto(self._address, bytearray(b'\x07'))
+
+ def power_on(self):
+ """Powers on the BH1750."""
+ self._i2c.writeto(self._address, bytearray(b'\x01'))
+
+ def power_off(self):
+ """Powers off the BH1750."""
+ self._i2c.writeto(self._address, bytearray(b'\x00'))
+
+ @property
+ def measurement(self) -> float:
+ """Returns the latest measurement."""
+ if self._measurement_mode == BH1750.MEASUREMENT_MODE_ONE_TIME:
+ self._write_measurement_mode()
+
+ buffer = bytearray(2)
+ self._i2c.readfrom_into(self._address, buffer)
+ lux = (buffer[0] << 8 | buffer[1]) / (1.2 * (BH1750.MEASUREMENT_TIME_DEFAULT / self._measurement_time))
+
+ if self._resolution == BH1750.RESOLUTION_HIGH_2:
+ return lux / 2
+ else:
+ return lux
+
+ def measurements(self) -> float:
+ """This is a generator function that continues to provide the latest measurement. Because the measurement time
+ is greatly affected by resolution and the configured measurement time, this function attemts to calculate the
+ appropriate sleep time between measurements.
+
+ Example usage:
+
+ for measurement in bh1750.measurements(): # bh1750 is an instance of this class
+ print(measurement)
+ """
+ while True:
+ yield self.measurement
+
+ if self._measurement_mode == BH1750.MEASUREMENT_MODE_CONTINUOUSLY:
+ base_measurement_time = 16 if self._measurement_time == BH1750.RESOLUTION_LOW else 120
+ sleep_ms(math.ceil(base_measurement_time * self._measurement_time / BH1750.MEASUREMENT_TIME_DEFAULT))
\ No newline at end of file
--- /dev/null
+'''This module implements a driver for the Si7021 humidity and temperature
+sensor.
+
+Datasheet:
+https://www.silabs.com/Support%20Documents%2FTechnicalDocs%2FSi7021-A20.pdf
+
+'''
+
+from time import sleep
+
+class CRCError(Exception):
+ 'Data failed a CRC check.'
+ pass
+
+
+class Si7021(object):
+ 'Driver for the Si7021 temperature sensor.'
+ SI7021_DEFAULT_ADDRESS = 0x40
+ SI7021_MEASTEMP_NOHOLD_CMD = bytearray([0xF3])
+ SI7021_MEASRH_NOHOLD_CMD = bytearray([0xF5])
+ SI7021_RESET_CMD = bytearray([0xFE])
+ SI7021_ID1_CMD = bytearray([0xFA, 0x0F])
+ SI7021_ID2_CMD = bytearray([0xFC, 0xC9])
+ I2C_WAIT_TIME = 0.025
+
+
+ def __init__(self, i2c, address=SI7021_DEFAULT_ADDRESS):
+ 'Initialize an Si7021 sensor object.'
+ self.i2c = i2c
+ self.address = address
+ self.serial, self.identifier = self._get_device_info()
+
+
+ @property
+ def temperature(self):
+ 'Return the temperature in Celcius.'
+ temperature = self._get_data(self.SI7021_MEASTEMP_NOHOLD_CMD)
+ celcius = temperature * 175.72 / 65536 - 46.85
+ return celcius
+
+
+ @temperature.setter
+ def temperature(self, value):
+ raise AttributeError('can\'t set attribute')
+
+
+ @property
+ def relative_humidity(self):
+ 'Return the relative humidity as a percentage. i.e. 35.59927'
+ relative_humidity = self._get_data(self.SI7021_MEASRH_NOHOLD_CMD)
+ relative_humidity = relative_humidity * 125 / 65536 - 6
+ return relative_humidity
+
+
+ @relative_humidity.setter
+ def relative_humidity(self, value):
+ raise AttributeError('can\'t set attribute')
+
+
+ def reset(self):
+ 'Reset the sensor.'
+ self.i2c.writeto(self.address, self.SI7021_RESET_CMD)
+ sleep(self.I2C_WAIT_TIME)
+
+
+ def _get_data(self, command):
+ 'Retrieve data from the sensor and verify it with a CRC check.'
+ data = bytearray(3)
+ self.i2c.writeto(self.address, command)
+ sleep(self.I2C_WAIT_TIME)
+
+ self.i2c.readfrom_into(self.address, data)
+ value = self._convert_to_integer(data[:2])
+
+ verified = self._verify_checksum(data)
+ if not verified:
+ raise CRCError('Data read off i2c bus failed CRC check.',
+ data[:2],
+ data[-1])
+ return value
+
+
+ def _get_device_info(self):
+ '''Get the serial number and the sensor identifier. The identifier is
+ part of the bytes returned for the serial number.
+
+ '''
+ # Serial 1st half
+ self.i2c.writeto(self.address, self.SI7021_ID1_CMD)
+ id1 = bytearray(8)
+ sleep(self.I2C_WAIT_TIME)
+ self.i2c.readfrom_into(self.address, id1)
+
+ # Serial 2nd half
+ self.i2c.writeto(self.address, self.SI7021_ID2_CMD)
+ id2 = bytearray(6)
+ sleep(self.I2C_WAIT_TIME)
+ self.i2c.readfrom_into(self.address, id2)
+
+ combined_id = bytearray([id1[0], id1[2], id1[4], id1[6],
+ id2[0], id2[1], id2[3], id2[4]])
+
+ serial = self._convert_to_integer(combined_id)
+ identifier = self._get_device_identifier(id2[0])
+
+ return serial, identifier
+
+ def _convert_to_integer(self, bytes_to_convert):
+ 'Use bitwise operators to convert the bytes into integers.'
+ integer = None
+ for chunk in bytes_to_convert:
+ if not integer:
+ integer = chunk
+ else:
+ integer = integer << 8
+ integer = integer | chunk
+ return integer
+
+
+ def _get_device_identifier(self, identifier_byte):
+ '''Convert the identifier byte to a device identifier. Values are based
+ on the information from page 24 of the datasheet.
+
+ '''
+ if identifier_byte == 0x00 or identifier_byte == 0xFF:
+ return 'engineering sample'
+ elif identifier_byte == 0x0D:
+ return 'Si7013'
+ elif identifier_byte == 0x14:
+ return 'Si7020'
+ elif identifier_byte == 0x15:
+ return 'Si7021'
+ else:
+ return 'unknown'
+
+
+ def _verify_checksum(self, data):
+ ''''Verify the checksum using the polynomial from page 19 of the
+ datasheet.
+
+ x8 + x5 + x4 + 1 = 0x131 = 0b100110001
+
+ Valid Example:
+ byte1: 0x67 [01100111]
+ byte2: 0x8c [10001100]
+ byte3: 0xfc [11111100] (CRC byte)
+
+ '''
+ crc = 0
+ values = data[:2]
+ checksum = int(data[-1])
+ for value in values:
+ crc = crc ^ value
+ for _ in range(8, 0, -1):
+ if crc & 0x80: #10000000
+ crc <<= 1
+ crc ^= 0x131 #100110001
+ else:
+ crc <<= 1
+ if crc != checksum:
+ return False
+ else:
+ return True
+
+def convert_celcius_to_fahrenheit(celcius):
+ 'Convert a Celcius measurement into a Fahrenheit measurement.'
+ return celcius * 1.8 + 32
\ No newline at end of file
--- /dev/null
+import utime
+
+class US100UART:
+ """Read the US-100 sonar sensor in UART mode."""
+
+ def __init__(self, uart):
+ self.uart = uart
+ uart.init(baudrate=9600, bits=8, parity=None, stop=1)
+ utime.sleep_ms(100)
+ self.buf = bytearray(2)
+ self.t = 0
+
+ def distance(self):
+ """Read the temperature compensated distance im millimeters."""
+ self.buf[0] = 0
+ self.buf[1] = 0
+ self.uart.write(b'\x55')
+ self.t = utime.ticks_ms()
+ while not self.uart.any():
+ if utime.ticks_diff(utime.ticks_ms(), self.t) > 100:
+ raise Exception('Timeout while reading from US100 sensor!')
+ utime.sleep_us(100)
+ self.uart.readinto(self.buf, 2)
+ return (self.buf[0] * 256) + self.buf[1]
+
+ def temperature(self):
+ """Read the temperature in degree celcius."""
+ self.buf[0] = 0
+ self.uart.write(b'\x50')
+ self.t = utime.ticks_ms()
+ while not self.uart.any():
+ if utime.ticks_diff(utime.ticks_ms(), self.t) > 100:
+ raise Exception('Timeout while reading from US100 sensor!')
+ utime.sleep_us(100)
+ self.uart.readinto(self.buf, 1)
+ return self.buf[0] - 45
\ No newline at end of file
--- /dev/null
+from machine import I2C, Pin
+import time
+from micropython import const
+
+#start const
+# default address
+addr = const(0x10)
+
+# Write registers
+als_conf_0 = const(0x00)
+als_WH = const(0x01)
+als_WL = const(0x02)
+pow_sav = const(0x03)
+
+# Read registers
+als = const(0x04)
+white = const(0x05)
+interrupt = const(0x06)
+
+#gain 0.125 0.25 1 2 integration time
+confValues = { 25: {1/8: bytearray([0x00, 0x13]), 1/4: bytearray([0x00,0x1B]), 1: bytearray([0x00, 0x01]), 2: bytearray([0x00, 0x0B])}, #25
+ 50: {1/8: bytearray([0x00, 0x12]), 1/4: bytearray([0x00,0x1A]), 1: bytearray([0x00, 0x02]), 2: bytearray([0x00, 0x0A])}, #50
+ 100:{1/8: bytearray([0x00, 0x10]), 1/4: bytearray([0x00,0x18]), 1: bytearray([0x00, 0x00]), 2: bytearray([0x00, 0x08])}, #100
+ 200:{1/8: bytearray([0x40, 0x10]), 1/4: bytearray([0x40,0x18]), 1: bytearray([0x40, 0x00]), 2: bytearray([0x40, 0x08])}, #200
+ 400:{1/8: bytearray([0x80, 0x10]), 1/4: bytearray([0x80,0x18]), 1: bytearray([0x80, 0x00]), 2: bytearray([0x80, 0x08])}, #400
+ 800:{1/8: bytearray([0xC0, 0x10]), 1/4: bytearray([0xC0,0x18]), 1: bytearray([0xC0, 0x00]), 2: bytearray([0xC0, 0x08])}} #800
+
+#gain 0.125, 0.25, 1, 2 integration time
+gainValues = { 25: {1/8: 1.8432, 1/4: 0.9216, 1: 0.2304, 2: 0.1152}, #25
+ 50: {1/8: 0.9216, 1/4: 0.4608, 1: 0.1152, 2: 0.0576}, #50
+ 100:{1/8: 0.4608, 1/4: 0.2304, 1: 0.0288, 2: 0.0144}, #100
+ 200:{1/8: 0.2304, 1/4: 0.1152, 1: 0.0288, 2: 0.0144}, #200
+ 400:{1/8: 0.1152, 1/4: 0.0576, 1: 0.0144, 2: 0.0072}, #400
+ 800:{1/8: 0.0876, 1/4: 0.0288, 1: 0.0072, 2: 0.0036}} #800
+
+
+# fin des constante
+
+# Reference data sheet Table 1 for configuration settings
+
+interrupt_high = bytearray([0x00, 0x00]) # Clear values
+# Reference data sheet Table 2 for High Threshold
+
+interrupt_low = bytearray([0x00, 0x00]) # Clear values
+# Reference data sheet Table 3 for Low Threshold
+
+power_save_mode= bytearray([0x00, 0x00]) # clear values
+# Reference data sheet Table 4 for Power Saving Modes
+
+
+class VEML7700:
+
+ def __init__(self,
+ address=addr,
+ i2c=None,
+ it=25,
+ gain=1/8,
+ **kwargs):
+
+ self.address = address
+ if i2c is None:
+ raise ValueError('An I2C object is required.')
+ self.i2c = i2c
+
+ confValuesForIt = confValues.get(it)
+ gainValuesForIt = gainValues.get(it)
+ if confValuesForIt is not None and gainValuesForIt is not None:
+ confValueForGain = confValuesForIt.get(gain)
+ gainValueForGain = gainValuesForIt.get(gain)
+ if confValueForGain is not None and gainValueForGain is not None:
+ self.confValues = confValueForGain
+ self.gain = gainValueForGain
+ else:
+ raise ValueError('Wrong gain value. Use 1/8, 1/4, 1, 2')
+ else:
+ raise ValueError('Wrong integration time value. Use 25, 50, 100, 200, 400, 800')
+
+ self.init()
+
+ def init(self):
+
+ # load calibration data
+ #self.i2c.writeto_mem(self.address, als_conf_0, bytearray([0x00,0x13]) )
+ self.i2c.writeto_mem(self.address, als_conf_0, self.confValues )
+ self.i2c.writeto_mem(self.address, als_WH, interrupt_high )
+ self.i2c.writeto_mem(self.address, als_WL, interrupt_low)
+ self.i2c.writeto_mem(self.address, pow_sav, power_save_mode)
+
+ def detect(self):
+ """ Functions is verified is module has detecedself.
+ this function not implemented for this time
+ """
+ None
+
+ def read_lux(self):
+ """ Reads the data from the sensor and returns the data.
+
+ Returns:
+ the number of lux detect by this captor.
+ """
+ #The frequency to read the sensor should be set greater than
+ # the integration time (and the power saving delay if set).
+ # Reading at a faster frequency will not cause an error, but
+ # will result in reading the previous data
+
+ self.lux = bytearray(2)
+
+ time.sleep(.04) # 40ms
+
+ self.i2c.readfrom_mem_into(self.address, als, self.lux)
+ self.lux= self.lux[0]+self.lux[1]*256
+ self.lux=self.lux*self.gain
+ return(int(round(self.lux,0)))
\ No newline at end of file
projects / SensorLib.git / commitdiff