diff --git a/lib/apds9960/apds9960/device.py b/lib/apds9960/apds9960/device.py index d9316a6f..e83efe82 100644 --- a/lib/apds9960/apds9960/device.py +++ b/lib/apds9960/apds9960/device.py @@ -37,7 +37,7 @@ def __init__(self, i2c, address=APDS9960_I2C_ADDR, valid_id=APDS9960_DEV_ID): self.gesture_data_ = APDS9960.GestureData() # check device id - self.dev_id = self._read_byte_data(APDS9960_REG_ID) + self.dev_id = self._read_reg(APDS9960_REG_ID) if self.dev_id not in valid_id: raise APDS9960InvalidDevId(self.dev_id, valid_id) @@ -45,12 +45,12 @@ def __init__(self, i2c, address=APDS9960_I2C_ADDR, valid_id=APDS9960_DEV_ID): self.setMode(APDS9960_MODE_ALL, False) # set default values for ambient light and proximity registers - self._write_byte_data(APDS9960_REG_ATIME, APDS9960_DEFAULT_ATIME) - self._write_byte_data(APDS9960_REG_WTIME, APDS9960_DEFAULT_WTIME) - self._write_byte_data(APDS9960_REG_PPULSE, APDS9960_DEFAULT_PROX_PPULSE) - self._write_byte_data(APDS9960_REG_POFFSET_UR, APDS9960_DEFAULT_POFFSET_UR) - self._write_byte_data(APDS9960_REG_POFFSET_DL, APDS9960_DEFAULT_POFFSET_DL) - self._write_byte_data(APDS9960_REG_CONFIG1, APDS9960_DEFAULT_CONFIG1) + self._write_reg(APDS9960_REG_ATIME, APDS9960_DEFAULT_ATIME) + self._write_reg(APDS9960_REG_WTIME, APDS9960_DEFAULT_WTIME) + self._write_reg(APDS9960_REG_PPULSE, APDS9960_DEFAULT_PROX_PPULSE) + self._write_reg(APDS9960_REG_POFFSET_UR, APDS9960_DEFAULT_POFFSET_UR) + self._write_reg(APDS9960_REG_POFFSET_DL, APDS9960_DEFAULT_POFFSET_DL) + self._write_reg(APDS9960_REG_CONFIG1, APDS9960_DEFAULT_CONFIG1) self.setLEDDrive(APDS9960_DEFAULT_LDRIVE) self.setProximityGain(APDS9960_DEFAULT_PGAIN) self.setAmbientLightGain(APDS9960_DEFAULT_AGAIN) @@ -59,28 +59,28 @@ def __init__(self, i2c, address=APDS9960_I2C_ADDR, valid_id=APDS9960_DEV_ID): self.setLightIntLowThreshold(APDS9960_DEFAULT_AILT) self.setLightIntHighThreshold(APDS9960_DEFAULT_AIHT) - self._write_byte_data(APDS9960_REG_PERS, APDS9960_DEFAULT_PERS) - self._write_byte_data(APDS9960_REG_CONFIG2, APDS9960_DEFAULT_CONFIG2) - self._write_byte_data(APDS9960_REG_CONFIG3, APDS9960_DEFAULT_CONFIG3) + self._write_reg(APDS9960_REG_PERS, APDS9960_DEFAULT_PERS) + self._write_reg(APDS9960_REG_CONFIG2, APDS9960_DEFAULT_CONFIG2) + self._write_reg(APDS9960_REG_CONFIG3, APDS9960_DEFAULT_CONFIG3) # set default values for gesture sense registers self.setGestureEnterThresh(APDS9960_DEFAULT_GPENTH) self.setGestureExitThresh(APDS9960_DEFAULT_GEXTH) - self._write_byte_data(APDS9960_REG_GCONF1, APDS9960_DEFAULT_GCONF1) + self._write_reg(APDS9960_REG_GCONF1, APDS9960_DEFAULT_GCONF1) self.setGestureGain(APDS9960_DEFAULT_GGAIN) self.setGestureLEDDrive(APDS9960_DEFAULT_GLDRIVE) self.setGestureWaitTime(APDS9960_DEFAULT_GWTIME) - self._write_byte_data(APDS9960_REG_GOFFSET_U, APDS9960_DEFAULT_GOFFSET) - self._write_byte_data(APDS9960_REG_GOFFSET_D, APDS9960_DEFAULT_GOFFSET) - self._write_byte_data(APDS9960_REG_GOFFSET_L, APDS9960_DEFAULT_GOFFSET) - self._write_byte_data(APDS9960_REG_GOFFSET_R, APDS9960_DEFAULT_GOFFSET) - self._write_byte_data(APDS9960_REG_GPULSE, APDS9960_DEFAULT_GPULSE) - self._write_byte_data(APDS9960_REG_GCONF3, APDS9960_DEFAULT_GCONF3) + self._write_reg(APDS9960_REG_GOFFSET_U, APDS9960_DEFAULT_GOFFSET) + self._write_reg(APDS9960_REG_GOFFSET_D, APDS9960_DEFAULT_GOFFSET) + self._write_reg(APDS9960_REG_GOFFSET_L, APDS9960_DEFAULT_GOFFSET) + self._write_reg(APDS9960_REG_GOFFSET_R, APDS9960_DEFAULT_GOFFSET) + self._write_reg(APDS9960_REG_GPULSE, APDS9960_DEFAULT_GPULSE) + self._write_reg(APDS9960_REG_GCONF3, APDS9960_DEFAULT_GCONF3) self.setGestureIntEnable(APDS9960_DEFAULT_GIEN) def getMode(self): - return self._read_byte_data(APDS9960_REG_ENABLE) + return self._read_reg(APDS9960_REG_ENABLE) def setMode(self, mode, enable=True): # read ENABLE register @@ -102,7 +102,7 @@ def setMode(self, mode, enable=True): reg_val &= ~(1 << mode) # write value to ENABLE register - self._write_byte_data(APDS9960_REG_ENABLE, reg_val) + self._write_reg(APDS9960_REG_ENABLE, reg_val) # start the light (R/G/B/Ambient) sensor def enableLightSensor(self, interrupts=True): @@ -132,8 +132,8 @@ def disableProximitySensor(self): # start the gesture recognition engine def enableGestureSensor(self, interrupts=True): self.resetGestureParameters() - self._write_byte_data(APDS9960_REG_WTIME, 0xFF) - self._write_byte_data(APDS9960_REG_PPULSE, APDS9960_DEFAULT_GESTURE_PPULSE) + self._write_reg(APDS9960_REG_WTIME, 0xFF) + self._write_reg(APDS9960_REG_PPULSE, APDS9960_DEFAULT_GESTURE_PPULSE) self.setLEDBoost(APDS9960_LED_BOOST_300) self.setGestureIntEnable(interrupts) self.setGestureMode(True) @@ -151,7 +151,7 @@ def disableGestureSensor(self): # check if there is a gesture available def isGestureAvailable(self): - val = self._read_byte_data(APDS9960_REG_GSTATUS) + val = self._read_reg(APDS9960_REG_GSTATUS) # shift and mask out GVALID bit val &= APDS9960_BIT_GVALID @@ -170,13 +170,13 @@ def readGesture(self): # keep looping as long as gesture data is valid while self.isGestureAvailable(): # read the current FIFO level - fifo_level = self._read_byte_data(APDS9960_REG_GFLVL) + fifo_level = self._read_reg(APDS9960_REG_GFLVL) # if there's stuff in the FIFO, read it into our data block if fifo_level > 0: fifo_data = [] for _i in range(fifo_level): - fifo_data += self._read_i2c_block_data(APDS9960_REG_GFIFO_U, 4) + fifo_data += self._read_block(APDS9960_REG_GFIFO_U, 4) # if at least 1 set of data, sort the data into U/D/L/R if len(fifo_data) >= 4: @@ -223,7 +223,7 @@ def disablePower(self): # check if there is new light data available def isLightAvailable(self): - val = self._read_byte_data(APDS9960_REG_STATUS) + val = self._read_reg(APDS9960_REG_STATUS) # shift and mask out AVALID bit val &= APDS9960_BIT_AVALID @@ -233,40 +233,40 @@ def isLightAvailable(self): # reads the ambient (clear) light level as a 16-bit value def readAmbientLight(self): # read value from clear channel, low byte register - low = self._read_byte_data(APDS9960_REG_CDATAL) + low = self._read_reg(APDS9960_REG_CDATAL) # read value from clear channel, high byte register - high = self._read_byte_data(APDS9960_REG_CDATAH) + high = self._read_reg(APDS9960_REG_CDATAH) return low + (high << 8) # reads the red light level as a 16-bit value def readRedLight(self): # read value from red channel, low byte register - low = self._read_byte_data(APDS9960_REG_RDATAL) + low = self._read_reg(APDS9960_REG_RDATAL) # read value from red channel, high byte register - high = self._read_byte_data(APDS9960_REG_RDATAH) + high = self._read_reg(APDS9960_REG_RDATAH) return low + (high << 8) # reads the green light level as a 16-bit value def readGreenLight(self): # read value from green channel, low byte register - low = self._read_byte_data(APDS9960_REG_GDATAL) + low = self._read_reg(APDS9960_REG_GDATAL) # read value from green channel, high byte register - high = self._read_byte_data(APDS9960_REG_GDATAH) + high = self._read_reg(APDS9960_REG_GDATAH) return low + (high << 8) # reads the blue light level as a 16-bit value def readBlueLight(self): # read value from blue channel, low byte register - low = self._read_byte_data(APDS9960_REG_BDATAL) + low = self._read_reg(APDS9960_REG_BDATAL) # read value from blue channel, high byte register - high = self._read_byte_data(APDS9960_REG_BDATAH) + high = self._read_reg(APDS9960_REG_BDATAH) return low + (high << 8) @@ -276,7 +276,7 @@ def readBlueLight(self): # reads the proximity level as an 8-bit value def readProximity(self): - return self._read_byte_data(APDS9960_REG_PDATA) + return self._read_reg(APDS9960_REG_PDATA) # ******************************************************************************* # High-level gesture controls @@ -467,19 +467,19 @@ def decodeGesture(self): def getProxIntLowThresh(self): """Returns the lower threshold for proximity detection""" - return self._read_byte_data(APDS9960_REG_PILT) + return self._read_reg(APDS9960_REG_PILT) def setProxIntLowThresh(self, threshold): """Sets the lower threshold for proximity detection.""" - self._write_byte_data(APDS9960_REG_PILT, threshold) + self._write_reg(APDS9960_REG_PILT, threshold) def getProxIntHighThresh(self): """Returns the high threshold for proximity detection.""" - return self._read_byte_data(APDS9960_REG_PIHT) + return self._read_reg(APDS9960_REG_PIHT) def setProxIntHighThresh(self, threshold): """Sets the high threshold for proximity detection.""" - self._write_byte_data(APDS9960_REG_PIHT, threshold) + self._write_reg(APDS9960_REG_PIHT, threshold) def getLEDDrive(self): """Returns LED drive strength for proximity and ALS. @@ -493,7 +493,7 @@ def getLEDDrive(self): Returns: int: the value of the LED drive strength """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # shift and mask out LED drive bits return (val >> 6) & 0b00000011 @@ -510,7 +510,7 @@ def setLEDDrive(self, drive): Args: drive (int): value for the LED drive strength """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # set bits in register to given value drive &= 0b00000011 @@ -518,7 +518,7 @@ def setLEDDrive(self, drive): val &= 0b00111111 val |= drive - self._write_byte_data(APDS9960_REG_CONTROL, val) + self._write_reg(APDS9960_REG_CONTROL, val) def getProximityGain(self): """Returns receiver gain for proximity detection. @@ -532,7 +532,7 @@ def getProximityGain(self): Returns: int: the value of the proximity gain """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # shift and mask out PDRIVE bits return (val >> 2) & 0b00000011 @@ -549,7 +549,7 @@ def setProximityGain(self, drive): Args: drive (int): value for the proximity gain """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # set bits in register to given value drive &= 0b00000011 @@ -557,7 +557,7 @@ def setProximityGain(self, drive): val &= 0b11110011 val |= drive - self._write_byte_data(APDS9960_REG_CONTROL, val) + self._write_reg(APDS9960_REG_CONTROL, val) def getAmbientLightGain(self): """Returns receiver gain for the ambient light sensor (ALS). @@ -571,7 +571,7 @@ def getAmbientLightGain(self): Returns: int: the value of the ALS gain """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # shift and mask out ADRIVE bits return val & 0b00000011 @@ -588,14 +588,14 @@ def setAmbientLightGain(self, drive): Args: drive (int): value for the ALS gain """ - val = self._read_byte_data(APDS9960_REG_CONTROL) + val = self._read_reg(APDS9960_REG_CONTROL) # set bits in register to given value drive &= 0b00000011 val &= 0b11111100 val |= drive - self._write_byte_data(APDS9960_REG_CONTROL, val) + self._write_reg(APDS9960_REG_CONTROL, val) def getLEDBoost(self): """Get the current LED boost value. @@ -609,7 +609,7 @@ def getLEDBoost(self): Returns: int: the LED boost value """ - val = self._read_byte_data(APDS9960_REG_CONFIG2) + val = self._read_reg(APDS9960_REG_CONFIG2) # shift and mask out LED_BOOST bits return (val >> 4) & 0b00000011 @@ -626,7 +626,7 @@ def setLEDBoost(self, boost): Args: boost (int): value for the LED boost """ - val = self._read_byte_data(APDS9960_REG_CONFIG2) + val = self._read_reg(APDS9960_REG_CONFIG2) # set bits in register to given value boost &= 0b00000011 @@ -634,7 +634,7 @@ def setLEDBoost(self, boost): val &= 0b11001111 val |= boost - self._write_byte_data(APDS9960_REG_CONFIG2, val) + self._write_reg(APDS9960_REG_CONFIG2, val) def getProxGainCompEnable(self): """Gets proximity gain compensation enable. @@ -642,7 +642,7 @@ def getProxGainCompEnable(self): Returns: bool: True if compensation is enabled, False if not """ - val = self._read_byte_data(APDS9960_REG_CONFIG3) + val = self._read_reg(APDS9960_REG_CONFIG3) # Shift and mask out PCMP bits val = (val >> 5) & 0b00000001 @@ -654,14 +654,14 @@ def setProxGainCompEnable(self, enable): Args: enable (bool): True to enable compensation, False to disable """ - val = self._read_byte_data(APDS9960_REG_CONFIG3) + val = self._read_reg(APDS9960_REG_CONFIG3) # set bits in register to given value val &= 0b11011111 if enable: val |= 0b00100000 - self._write_byte_data(APDS9960_REG_CONFIG3, val) + self._write_reg(APDS9960_REG_CONFIG3, val) def getProxPhotoMask(self): """Gets the current mask for enabled/disabled proximity photodiodes. @@ -677,7 +677,7 @@ def getProxPhotoMask(self): Returns: int: Current proximity mask for photodiodes. """ - val = self._read_byte_data(APDS9960_REG_CONFIG3) + val = self._read_reg(APDS9960_REG_CONFIG3) # mask out photodiode enable mask bits return val & 0b00001111 @@ -696,14 +696,14 @@ def setProxPhotoMask(self, mask): Args: mask (int): 4-bit mask value """ - val = self._read_byte_data(APDS9960_REG_CONFIG3) + val = self._read_reg(APDS9960_REG_CONFIG3) # set bits in register to given value mask &= 0b00001111 val &= 0b11110000 val |= mask - self._write_byte_data(APDS9960_REG_CONFIG3, val) + self._write_reg(APDS9960_REG_CONFIG3, val) def getGestureEnterThresh(self): """Gets the entry proximity threshold for gesture sensing. @@ -711,7 +711,7 @@ def getGestureEnterThresh(self): Returns: int: current entry proximity threshold """ - return self._read_byte_data(APDS9960_REG_GPENTH) + return self._read_reg(APDS9960_REG_GPENTH) def setGestureEnterThresh(self, threshold): """Sets the entry proximity threshold for gesture sensing. @@ -719,7 +719,7 @@ def setGestureEnterThresh(self, threshold): Args: threshold (int): threshold proximity value needed to start gesture mode """ - self._write_byte_data(APDS9960_REG_GPENTH, threshold) + self._write_reg(APDS9960_REG_GPENTH, threshold) def getGestureExitThresh(self): """Gets the exit proximity threshold for gesture sensing. @@ -727,7 +727,7 @@ def getGestureExitThresh(self): Returns: int: current exit proximity threshold """ - return self._read_byte_data(APDS9960_REG_GEXTH) + return self._read_reg(APDS9960_REG_GEXTH) def setGestureExitThresh(self, threshold): """Sets the exit proximity threshold for gesture sensing. @@ -735,7 +735,7 @@ def setGestureExitThresh(self, threshold): Args: threshold (int): threshold proximity value needed to end gesture mode """ - self._write_byte_data(APDS9960_REG_GEXTH, threshold) + self._write_reg(APDS9960_REG_GEXTH, threshold) def getGestureGain(self): """Gets the gain of the photodiode during gesture mode. @@ -749,7 +749,7 @@ def getGestureGain(self): Returns: int: the current photodiode gain """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # shift and mask out PDRIVE bits return (val >> 5) & 0b00000011 @@ -766,7 +766,7 @@ def setGestureGain(self, gain): Args: gain (int): the value for the photodiode gain """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # set bits in register to given value gain &= 0b00000011 @@ -774,7 +774,7 @@ def setGestureGain(self, gain): val &= 0b10011111 val |= gain - self._write_byte_data(APDS9960_REG_GCONF2, val) + self._write_reg(APDS9960_REG_GCONF2, val) def getGestureLEDDrive(self): """Gets the drive current of the LED during gesture mode. @@ -788,7 +788,7 @@ def getGestureLEDDrive(self): Returns: int: the LED drive current value """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # shift and mask out LED drive bits return (val >> 3) & 0b00000011 @@ -805,7 +805,7 @@ def setGestureLEDDrive(self, drive): Args: drive (int): value for the LED drive current """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # set bits in register to given value drive &= 0b00000011 @@ -813,7 +813,7 @@ def setGestureLEDDrive(self, drive): val &= 0b11100111 val |= drive - self._write_byte_data(APDS9960_REG_GCONF2, val) + self._write_reg(APDS9960_REG_GCONF2, val) def getGestureWaitTime(self): """Gets the time in low power mode between gesture detections. @@ -831,7 +831,7 @@ def getGestureWaitTime(self): Returns: int: the current wait time between gestures """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # shift and mask out LED drive bits return val & 0b00000111 @@ -852,14 +852,14 @@ def setGestureWaitTime(self, time): Args: time (int): value for the wait time """ - val = self._read_byte_data(APDS9960_REG_GCONF2) + val = self._read_reg(APDS9960_REG_GCONF2) # set bits in register to given value time &= 0b00000111 val &= 0b11111000 val |= time - self._write_byte_data(APDS9960_REG_GCONF2, val) + self._write_reg(APDS9960_REG_GCONF2, val) def getLightIntLowThreshold(self): """Gets the low threshold for ambient light interrupts. @@ -867,8 +867,8 @@ def getLightIntLowThreshold(self): Returns: int: threshold current low threshold stored on the APDS9960 """ - return self._read_byte_data(APDS9960_REG_AILTL) | ( - self._read_byte_data(APDS9960_REG_AILTH) << 8 + return self._read_reg(APDS9960_REG_AILTL) | ( + self._read_reg(APDS9960_REG_AILTH) << 8 ) def setLightIntLowThreshold(self, threshold): @@ -878,8 +878,8 @@ def setLightIntLowThreshold(self, threshold): threshold (int): low threshold value for interrupt to trigger """ # break 16-bit threshold into 2 8-bit values - self._write_byte_data(APDS9960_REG_AILTL, threshold & 0x00FF) - self._write_byte_data(APDS9960_REG_AILTH, (threshold & 0xFF00) >> 8) + self._write_reg(APDS9960_REG_AILTL, threshold & 0x00FF) + self._write_reg(APDS9960_REG_AILTH, (threshold & 0xFF00) >> 8) def getLightIntHighThreshold(self): """Gets the high threshold for ambient light interrupts. @@ -887,8 +887,8 @@ def getLightIntHighThreshold(self): Returns: int: threshold current low threshold stored on the APDS9960 """ - return self._read_byte_data(APDS9960_REG_AIHTL) | ( - self._read_byte_data(APDS9960_REG_AIHTH) << 8 + return self._read_reg(APDS9960_REG_AIHTL) | ( + self._read_reg(APDS9960_REG_AIHTH) << 8 ) def setLightIntHighThreshold(self, threshold): @@ -898,8 +898,8 @@ def setLightIntHighThreshold(self, threshold): threshold (int): high threshold value for interrupt to trigger """ # break 16-bit threshold into 2 8-bit values - self._write_byte_data(APDS9960_REG_AIHTL, threshold & 0x00FF) - self._write_byte_data(APDS9960_REG_AIHTH, (threshold & 0xFF00) >> 8) + self._write_reg(APDS9960_REG_AIHTL, threshold & 0x00FF) + self._write_reg(APDS9960_REG_AIHTH, (threshold & 0xFF00) >> 8) def getProximityIntLowThreshold(self): """Gets the low threshold for proximity interrupts. @@ -907,7 +907,7 @@ def getProximityIntLowThreshold(self): Returns: int: threshold current low threshold stored on the APDS9960 """ - return self._read_byte_data(APDS9960_REG_PILT) + return self._read_reg(APDS9960_REG_PILT) def setProximityIntLowThreshold(self, threshold): """Sets the low threshold for proximity interrupts. @@ -915,7 +915,7 @@ def setProximityIntLowThreshold(self, threshold): Args: threshold (int): low threshold value for interrupt to trigger """ - self._write_byte_data(APDS9960_REG_PILT, threshold) + self._write_reg(APDS9960_REG_PILT, threshold) def getProximityIntHighThreshold(self): """Gets the high threshold for proximity interrupts. @@ -923,7 +923,7 @@ def getProximityIntHighThreshold(self): Returns: int: threshold current high threshold stored on the APDS9960 """ - return self._read_byte_data(APDS9960_REG_PIHT) + return self._read_reg(APDS9960_REG_PIHT) def setProximityIntHighThreshold(self, threshold): """Sets the high threshold for proximity interrupts. @@ -931,7 +931,7 @@ def setProximityIntHighThreshold(self, threshold): Args: threshold (int): high threshold value for interrupt to trigger """ - self._write_byte_data(APDS9960_REG_PIHT, threshold) + self._write_reg(APDS9960_REG_PIHT, threshold) def getAmbientLightIntEnable(self): """Gets if ambient light interrupts are enabled or not. @@ -939,7 +939,7 @@ def getAmbientLightIntEnable(self): Returns: bool: True if interrupts are enabled, False if not """ - val = self._read_byte_data(APDS9960_REG_ENABLE) + val = self._read_reg(APDS9960_REG_ENABLE) return (val >> 4) & 0b00000001 == 1 def setAmbientLightIntEnable(self, enable): @@ -948,14 +948,14 @@ def setAmbientLightIntEnable(self, enable): Args: enable (bool): True to enable interrupts, False to turn them off """ - val = self._read_byte_data(APDS9960_REG_ENABLE) + val = self._read_reg(APDS9960_REG_ENABLE) # set bits in register to given value val &= 0b11101111 if enable: val |= 0b00010000 - self._write_byte_data(APDS9960_REG_ENABLE, val) + self._write_reg(APDS9960_REG_ENABLE, val) def getProximityIntEnable(self): """Gets if proximity interrupts are enabled or not. @@ -963,7 +963,7 @@ def getProximityIntEnable(self): Returns: bool: True if interrupts are enabled, False if not """ - val = self._read_byte_data(APDS9960_REG_ENABLE) + val = self._read_reg(APDS9960_REG_ENABLE) return (val >> 5) & 0b00000001 == 1 def setProximityIntEnable(self, enable): @@ -972,14 +972,14 @@ def setProximityIntEnable(self, enable): Args: enable (bool): True to enable interrupts, False to turn them off """ - val = self._read_byte_data(APDS9960_REG_ENABLE) + val = self._read_reg(APDS9960_REG_ENABLE) # set bits in register to given value val &= 0b11011111 if enable: val |= 0b00100000 - self._write_byte_data(APDS9960_REG_ENABLE, val) + self._write_reg(APDS9960_REG_ENABLE, val) def getGestureIntEnable(self): """Gets if gesture interrupts are enabled or not. @@ -987,7 +987,7 @@ def getGestureIntEnable(self): Returns: bool: True if interrupts are enabled, False if not """ - val = self._read_byte_data(APDS9960_REG_GCONF4) + val = self._read_reg(APDS9960_REG_GCONF4) return (val >> 1) & 0b00000001 == 1 def setGestureIntEnable(self, enable): @@ -996,22 +996,22 @@ def setGestureIntEnable(self, enable): Args: enable (bool): True to enable interrupts, False to turn them off """ - val = self._read_byte_data(APDS9960_REG_GCONF4) + val = self._read_reg(APDS9960_REG_GCONF4) # set bits in register to given value val &= 0b11111101 if enable: val |= 0b00000010 - self._write_byte_data(APDS9960_REG_GCONF4, val) + self._write_reg(APDS9960_REG_GCONF4, val) def clearAmbientLightInt(self): """Clears the ambient light interrupt.""" - self._read_byte_data(APDS9960_REG_AICLEAR) + self._read_reg(APDS9960_REG_AICLEAR) def clearProximityInt(self): """Clears the proximity interrupt.""" - self._read_byte_data(APDS9960_REG_PICLEAR) + self._read_reg(APDS9960_REG_PICLEAR) def getGestureMode(self): """Tells if the gesture state machine is currently running. @@ -1019,7 +1019,7 @@ def getGestureMode(self): Returns: bool: True if gesture state machine is running, False if not """ - val = self._read_byte_data(APDS9960_REG_GCONF4) + val = self._read_reg(APDS9960_REG_GCONF4) return val & 0b00000001 == 1 def setGestureMode(self, enable): @@ -1028,26 +1028,26 @@ def setGestureMode(self, enable): Args: enable (bool): True to enter gesture state machine, False to turn them off """ - val = self._read_byte_data(APDS9960_REG_GCONF4) + val = self._read_reg(APDS9960_REG_GCONF4) # set bits in register to given value val &= 0b11111110 if enable: val |= 0b00000001 - self._write_byte_data(APDS9960_REG_GCONF4, val) + self._write_reg(APDS9960_REG_GCONF4, val) # ******************************************************************************* # Raw I2C Reads and Writes # ******************************************************************************* - def _read_byte_data(self, cmd): + def _read_reg(self, cmd): return self.i2c.read_byte_data(self.address, cmd) - def _write_byte_data(self, cmd, val): + def _write_reg(self, cmd, val): return self.i2c.write_byte_data(self.address, cmd, val) - def _read_i2c_block_data(self, cmd, num): + def _read_block(self, cmd, num): return self.i2c.read_i2c_block_data(self.address, cmd, num) @@ -1059,11 +1059,11 @@ class uAPDS9960(APDS9960): address=APDS9960_I2C_ADDR, valid_id=APDS9960_DEV_ID) """ - def _read_byte_data(self, cmd): + def _read_reg(self, cmd): return self.i2c.readfrom_mem(self.address, cmd, 1)[0] - def _write_byte_data(self, cmd, val): + def _write_reg(self, cmd, val): self.i2c.writeto_mem(self.address, cmd, bytes([val])) - def _read_i2c_block_data(self, cmd, num): + def _read_block(self, cmd, num): return self.i2c.readfrom_mem(self.address, cmd, num) diff --git a/lib/bq27441/bq27441/device.py b/lib/bq27441/bq27441/device.py index 7cab8c3a..2bd89c51 100644 --- a/lib/bq27441/bq27441/device.py +++ b/lib/bq27441/bq27441/device.py @@ -461,7 +461,7 @@ def softReset(self): # Read a 16 - bit command word from the BQ27441-G1A, def format = little endian int16 def readWord(self, subAddress, format="> 8 subCommandLSB = function & 0x00FF command = [subCommandLSB, subCommandMSB] - self.i2cWriteBytes(0, command, 2) - data = self.i2cReadBytes(0, 2) + self._write_reg(0, command, 2) + data = self._read_reg(0, 2) if data: return (data[1] << 8) | data[0] @@ -481,7 +481,7 @@ def executeControlWord(self, function): subCommandMSB = function >> 8 subCommandLSB = function & 0x00FF command = [subCommandLSB, subCommandMSB] - if self.i2cWriteBytes(0, command, 2): + if self._write_reg(0, command, 2): return True return False @@ -490,39 +490,40 @@ def executeControlWord(self, function): # Issue a BlockDataControl() command to enable BlockData access def blockDataControl(self): enableByte = [0x00] - return self.i2cWriteBytes(BQ27441_EXTENDED_CONTROL, enableByte, 1) + return self._write_reg(BQ27441_EXTENDED_CONTROL, enableByte, 1) # Issue a DataClass() command to set the data class to be accessed def blockDataClass(self, _id): - return self.i2cWriteBytes(BQ27441_EXTENDED_DATACLASS, _id, 1) + _id = [_id] + return self._write_reg(BQ27441_EXTENDED_DATACLASS, _id, 1) # Issue a DataBlock() command to set the data block to be accessed def blockDataOffset(self, offset): offset = [offset] - return self.i2cWriteBytes(BQ27441_EXTENDED_DATABLOCK, offset, 1) + return self._write_reg(BQ27441_EXTENDED_DATABLOCK, offset, 1) # Read the current checksum using BlockDataCheckSum() def blockDataChecksum(self): - csum = self.i2cReadBytes(BQ27441_EXTENDED_CHECKSUM, 1) + csum = self._read_reg(BQ27441_EXTENDED_CHECKSUM, 1) return csum # Use BlockData() to read a byte from the loaded extended data def readBlockData(self, offset): address = offset + BQ27441_EXTENDED_BLOCKDATA - ret = self.i2cReadBytes(address, 1) + ret = self._read_reg(address, 1) return ret # Use BlockData() to write a byte to an offset of the loaded data def writeBlockData(self, offset, data): address = offset + BQ27441_EXTENDED_BLOCKDATA data = [data] - return self.i2cWriteBytes(address, data, 1) + return self._write_reg(address, data, 1) # Read all 32 bytes of the loaded extended data and compute a # checksum based on the values. def computeBlockChecksum(self): - data = self.i2cReadBytes(BQ27441_EXTENDED_BLOCKDATA, 32) + data = self._read_reg(BQ27441_EXTENDED_BLOCKDATA, 32) csum = 0 for i in range(32): csum += data[i] @@ -533,7 +534,7 @@ def computeBlockChecksum(self): # Use the BlockDataCheckSum() command to write a checksum value def writeBlockChecksum(self, csum): csum = [csum] - return self.i2cWriteBytes(BQ27441_EXTENDED_CHECKSUM, csum, 1) + return self._write_reg(BQ27441_EXTENDED_CHECKSUM, csum, 1) # Read a byte from extended data specifying a class ID and position offset def readExtendedData(self, classID, offset): @@ -593,12 +594,12 @@ def writeExtendedData(self, class_id, offset, data, length): return True # I2C Read / Write Functions - def i2cReadBytes(self, subAddress, count): + def _read_reg(self, subAddress, count): result = self.i2c.readfrom_mem(self.address, subAddress, count) return list(result) # Write a specified number of bytes over I2C to a given subAddress - def i2cWriteBytes(self, memAddress, buf, count): + def _write_reg(self, memAddress, buf, count): self.i2c.writeto_mem(self.address, memAddress, bytes(buf)) return True diff --git a/lib/hts221/hts221/device.py b/lib/hts221/hts221/device.py index 12eb6a06..fdacc307 100644 --- a/lib/hts221/hts221/device.py +++ b/lib/hts221/hts221/device.py @@ -25,75 +25,75 @@ def __init__(self, i2c, address=HTS_I2C_ADDR): def calibrate_temperature(self): # HTS221 Temp Calibration registers - self.T0_OUT = int16(self.get2Reg(HTS221_T0_OUT_L)) - self.T1_OUT = int16(self.get2Reg(HTS221_T1_OUT_L)) + self.T0_OUT = int16(self._read_reg16(HTS221_T0_OUT_L)) + self.T1_OUT = int16(self._read_reg16(HTS221_T1_OUT_L)) - t1 = self.getReg(HTS221_T1T0_msb) - self.T0_degC = (self.getReg(HTS221_T0_degC_x8) + (t1 % 4) * 256) / 8 - self.T1_degC = (self.getReg(HTS221_T1_degC_x8) + ((t1 % 16) / 4) * 256) / 8 + t1 = self._read_reg(HTS221_T1T0_msb) + self.T0_degC = (self._read_reg(HTS221_T0_degC_x8) + (t1 % 4) * 256) / 8 + self.T1_degC = (self._read_reg(HTS221_T1_degC_x8) + ((t1 % 16) / 4) * 256) / 8 def calibrate_humidity(self): # HTS221 Humi Calibration registers - self.H0_OUT = self.get2Reg(HTS221_H0_T0_OUT_L) - self.H1_OUT = self.get2Reg(HTS221_H1_T0_OUT_L) - self.H0_rH = self.getReg(HTS221_H0_rH_x2) / 2 - self.H1_rH = self.getReg(HTS221_H1_rH_x2) / 2 + self.H0_OUT = self._read_reg16(HTS221_H0_T0_OUT_L) + self.H1_OUT = self._read_reg16(HTS221_H1_T0_OUT_L) + self.H0_rH = self._read_reg(HTS221_H0_rH_x2) / 2 + self.H1_rH = self._read_reg(HTS221_H1_rH_x2) / 2 - def setReg(self, dat, reg): + def _write_reg(self, reg, dat): self.writebuffer[0] = dat self.i2c.writeto_mem(self.address, reg, self.writebuffer) - def getReg(self, reg): + def _read_reg(self, reg): self.i2c.readfrom_mem_into(self.address, reg, self.readbuffer) return self.readbuffer[0] - def get2Reg(self, reg): - lowerByte = self.getReg(reg) - higherByte = self.getReg(reg + 1) + def _read_reg16(self, reg): + lowerByte = self._read_reg(reg) + higherByte = self._read_reg(reg + 1) return (higherByte << 8) + lowerByte # Device identification def whoAmI(self): - return self.getReg(HTS221_WHO_AM_I) + return self._read_reg(HTS221_WHO_AM_I) # get STATUS register def status(self): - return self.getReg(HTS221_STATUS_REG) + return self._read_reg(HTS221_STATUS_REG) # power control def poweroff(self): - t = self.getReg(HTS221_CTRL_REG1) & 0x7F - self.setReg(t, HTS221_CTRL_REG1) + t = self._read_reg(HTS221_CTRL_REG1) & 0x7F + self._write_reg(HTS221_CTRL_REG1, t) def poweron(self): - t = self.getReg(HTS221_CTRL_REG1) | 0x80 - self.setReg(t, HTS221_CTRL_REG1) + t = self._read_reg(HTS221_CTRL_REG1) | 0x80 + self._write_reg(HTS221_CTRL_REG1, t) # get/set Output data rate def getODR(self): - return self.getReg(HTS221_CTRL_REG1) & 0x03 + return self._read_reg(HTS221_CTRL_REG1) & 0x03 def setODR(self, odr=0): - t = self.getReg(HTS221_CTRL_REG1) & 0xFC - self.setReg(t | odr, HTS221_CTRL_REG1) + t = self._read_reg(HTS221_CTRL_REG1) & 0xFC + self._write_reg(HTS221_CTRL_REG1, t | odr) # get/set Humidity and temperature average configuration def getAv(self): - return self.getReg(HTS221_AV_CONF) + return self._read_reg(HTS221_AV_CONF) def setAv(self, av=0): - self.setReg(av, HTS221_AV_CONF) + self._write_reg(HTS221_AV_CONF, av) # calculate Temperature def temperature(self): - t = self.get2Reg(HTS221_TEMP_OUT_L) + t = self._read_reg16(HTS221_TEMP_OUT_L) return self.T0_degC + (self.T1_degC - self.T0_degC) * (t - self.T0_OUT) / ( self.T1_OUT - self.T0_OUT ) # calculate Humidity def humidity(self): - t = self.get2Reg(HTS221_HUMIDITY_OUT_L) + t = self._read_reg16(HTS221_HUMIDITY_OUT_L) return self.H0_rH + (self.H1_rH - self.H0_rH) * (t - self.H0_OUT) / ( self.H1_OUT - self.H0_OUT ) diff --git a/lib/lis2mdl/lis2mdl/device.py b/lib/lis2mdl/lis2mdl/device.py index 66e24cce..cb50376a 100644 --- a/lib/lis2mdl/lis2mdl/device.py +++ b/lib/lis2mdl/lis2mdl/device.py @@ -33,7 +33,7 @@ def __init__( self.readbuffer = bytearray(1) # Perform a soft reset to ensure the sensor starts in a known state. - self.setReg(0x20, LIS2MDL_CFG_REG_A) # SOFT_RST=1 (not 0x10) + self._write_reg(LIS2MDL_CFG_REG_A, 0x20) # SOFT_RST=1 (not 0x10) try: sleep_ms(10) # Small delay for reset to complete except Exception: @@ -44,14 +44,14 @@ def __init__( comp = 1 if temp_comp else 0 lp = 1 if low_power else 0 cfg_a = (comp << 7) | (lp << 4) | (odr_bits << 2) | 0b00 - self.setReg(cfg_a, LIS2MDL_CFG_REG_A) # Essential to exit IDLE mode + self._write_reg(LIS2MDL_CFG_REG_A, cfg_a) # Essential to exit IDLE mode # Configure low-pass filter and other optional settings. - self.setReg(0x00, LIS2MDL_CFG_REG_B) # Default: LPF and offset cancellation off + self._write_reg(LIS2MDL_CFG_REG_B, 0x00) # Default: LPF and offset cancellation off # Enable block data update and optionally configure the DRDY pin. cfg_c = 0x10 | (0x01 if drdy_enable else 0x00) - self.setReg(cfg_c, LIS2MDL_CFG_REG_C) + self._write_reg(LIS2MDL_CFG_REG_C, cfg_c) ## # --- SET functions --- @@ -61,39 +61,39 @@ def __init__( def set_mode(self, mode: str): # MD1..MD0: 00=continuous, 01=single, 11=idle md = {"continuous": 0b00, "single": 0b01, "idle": 0b11}.get(mode, 0b00) - reg = self.read_reg(LIS2MDL_CFG_REG_A) + reg = self._read_reg(LIS2MDL_CFG_REG_A) reg = (reg & ~0b11) | md - self.setReg(reg, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, reg) def set_odr(self, hz: int): # ODR1..0: 00=10Hz, 01=20Hz, 10=50Hz, 11=100Hz odr_bits = {10: 0b00, 20: 0b01, 50: 0b10, 100: 0b11}.get(hz, 0b00) - reg = self.read_reg(LIS2MDL_CFG_REG_A) + reg = self._read_reg(LIS2MDL_CFG_REG_A) reg = (reg & ~(0b11 << 2)) | (odr_bits << 2) - self.setReg(reg, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, reg) def set_low_power(self, enabled: bool): # LP bit (bit4) : 0=High-Res, 1=Low-Power - reg = self.read_reg(LIS2MDL_CFG_REG_A) + reg = self._read_reg(LIS2MDL_CFG_REG_A) if enabled: reg |= 1 << 4 else: reg &= ~(1 << 4) - self.setReg(reg, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, reg) # --- Filters / offset cancellation (CFG_REG_B: 0x61) --- def set_low_pass(self, enabled: bool): # LPF (bit0) - reg = self.read_reg(LIS2MDL_CFG_REG_B) + reg = self._read_reg(LIS2MDL_CFG_REG_B) if enabled: reg |= 1 << 0 else: reg &= ~(1 << 0) - self.setReg(reg, LIS2MDL_CFG_REG_B) + self._write_reg(LIS2MDL_CFG_REG_B, reg) def set_offset_cancellation(self, enabled: bool, oneshot: bool = False): # OFF_CANC (bit1), OFF_CANC_ONE_SHOT (bit4) - reg = self.read_reg(LIS2MDL_CFG_REG_B) + reg = self._read_reg(LIS2MDL_CFG_REG_B) if enabled: reg |= 1 << 1 else: @@ -102,35 +102,35 @@ def set_offset_cancellation(self, enabled: bool, oneshot: bool = False): reg |= 1 << 4 else: reg &= ~(1 << 4) - self.setReg(reg, LIS2MDL_CFG_REG_B) + self._write_reg(LIS2MDL_CFG_REG_B, reg) # --- Interface options / BDU (CFG_REG_C: 0x62) --- def set_bdu(self, enable=True): # BDU (bit4) - reg = self.read_reg(LIS2MDL_CFG_REG_C) + reg = self._read_reg(LIS2MDL_CFG_REG_C) if enable: reg |= 1 << 4 else: reg &= ~(1 << 4) - self.setReg(reg, LIS2MDL_CFG_REG_C) + self._write_reg(LIS2MDL_CFG_REG_C, reg) def set_endianness(self, big_endian: bool): # BLE (bit3) - reg = self.read_reg(LIS2MDL_CFG_REG_C) + reg = self._read_reg(LIS2MDL_CFG_REG_C) if big_endian: reg |= 1 << 3 else: reg &= ~(1 << 3) - self.setReg(reg, LIS2MDL_CFG_REG_C) + self._write_reg(LIS2MDL_CFG_REG_C, reg) def use_spi_4wire(self, enable: bool): # 4WSPI (bit2) - reg = self.read_reg(LIS2MDL_CFG_REG_C) + reg = self._read_reg(LIS2MDL_CFG_REG_C) if enable: reg |= 1 << 2 else: reg &= ~(1 << 2) - self.setReg(reg, LIS2MDL_CFG_REG_C) + self._write_reg(LIS2MDL_CFG_REG_C, reg) # --- Compass: heading offset & declination (software) --- _heading_offset_deg = 0.0 # user setting: align your physical 0° @@ -144,15 +144,15 @@ def set_declination(self, deg: float): # (remember to correct your heading_flat_only with atan2(y, x) then + offsets) - def setReg(self, data, reg): + def _write_reg(self, reg, data): # Write a byte to a specific register. self.writebuffer[0] = data self.i2c.writeto_mem(self.address, reg, self.writebuffer) def _write_16(self, reg_l, value): value &= 0xFFFF - self.setReg(value & 0xFF, reg_l) - self.setReg((value >> 8) & 0xFF, reg_l + 1) + self._write_reg(reg_l, value & 0xFF) + self._write_reg(reg_l + 1, (value >> 8) & 0xFF) def set_hw_offsets(self, x: int, y: int, z: int): # writes to OFFSET_X/Y/Z_REG_L/H @@ -170,7 +170,7 @@ def read_magnet_raw(self): def read_status(self) -> int: """Reads STATUS_REG (0x67).""" - return self.read_reg(LIS2MDL_STATUS_REG) + return self._read_reg(LIS2MDL_STATUS_REG) def data_ready(self) -> bool: """True if a new XYZ triplet is ready (Zyxda bit).""" @@ -178,9 +178,9 @@ def data_ready(self) -> bool: def read_int_source(self) -> int: """Reads INT_SOURCE_REG (0x64): source of the interrupt.""" - return self.read_reg(LIS2MDL_INT_SOURCE_REG) + return self._read_reg(LIS2MDL_INT_SOURCE_REG) - def read_reg(self, reg): + def _read_reg(self, reg): # Read a byte from a specific register. self.i2c.readfrom_mem_into(self.address, reg, self.readbuffer) return self.readbuffer[0] @@ -228,8 +228,8 @@ def read_magnet(self): def read_temperature_raw(self) -> int: """Reads the raw temperature (LSB), 8 LSB/°C, absolute offset not guaranteed.""" - lo = self.read_reg(LIS2MDL_TEMP_OUT_L_REG) - hi = self.read_reg(LIS2MDL_TEMP_OUT_H_REG) + lo = self._read_reg(LIS2MDL_TEMP_OUT_L_REG) + hi = self._read_reg(LIS2MDL_TEMP_OUT_H_REG) v = (hi << 8) | lo return v - 0x10000 if (v & 0x8000) else v @@ -241,12 +241,12 @@ def read_temperature_c(self) -> float: def read_who_am_i(self) -> int: """Reads WHO_AM_I (should be 0x40).""" - return self.read_reg(LIS2MDL_WHO_AM_I) + return self._read_reg(LIS2MDL_WHO_AM_I) def _read_16(self, reg_l) -> int: """Reads a signed 16-bit value from a _L (LSB) register.""" - lo = self.read_reg(reg_l) - hi = self.read_reg(reg_l + 1) + lo = self._read_reg(reg_l) + hi = self._read_reg(reg_l + 1) v = (hi << 8) | lo return v - 0x10000 if (v & 0x8000) else v @@ -529,31 +529,31 @@ def direction_label(self, angle=None): def get_mode(self) -> str: """Returns the current mode from MD1..0 (CFG_REG_A).""" - r = self.read_reg(LIS2MDL_CFG_REG_A) + r = self._read_reg(LIS2MDL_CFG_REG_A) md = r & 0b11 return {0b00: "continuous", 0b01: "single", 0b11: "idle"}.get(md, "idle") def power_down(self): """Switches to IDLE mode (low power).""" - r = self.read_reg(LIS2MDL_CFG_REG_A) + r = self._read_reg(LIS2MDL_CFG_REG_A) r = (r & ~0b11) | 0b11 # MD1..0 = 11 - self.setReg(r, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, r) def wake(self, mode: str = "continuous"): """Wakes the sensor: 'continuous' (default) or 'single'.""" md = {"continuous": 0b00, "single": 0b01}.get(mode, 0b00) - r = self.read_reg(LIS2MDL_CFG_REG_A) + r = self._read_reg(LIS2MDL_CFG_REG_A) r = (r & ~0b11) | md - self.setReg(r, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, r) def soft_reset(self, wait_ms: int = 10): """ SOFT_RST (bit5) in CFG_REG_A. The bit auto-clears; after reset, the sensor returns to default values (idle mode expected). """ - r = self.read_reg(LIS2MDL_CFG_REG_A) + r = self._read_reg(LIS2MDL_CFG_REG_A) r |= 1 << 5 # SOFT_RST - self.setReg(r, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, r) sleep_ms(wait_ms) def reboot(self, wait_ms: int = 10): @@ -561,11 +561,11 @@ def reboot(self, wait_ms: int = 10): REBOOT (bit6) in CFG_REG_A: reload internal registers. The bit auto-clears. """ - r = self.read_reg(LIS2MDL_CFG_REG_A) + r = self._read_reg(LIS2MDL_CFG_REG_A) r |= 1 << 6 # REBOOT - self.setReg(r, LIS2MDL_CFG_REG_A) + self._write_reg(LIS2MDL_CFG_REG_A, r) sleep_ms(wait_ms) def is_idle(self) -> bool: """True if the sensor is in IDLE mode (MD1..0 == 11).""" - return (self.read_reg(LIS2MDL_CFG_REG_A) & 0b11) == 0b11 + return (self._read_reg(LIS2MDL_CFG_REG_A) & 0b11) == 0b11 diff --git a/lib/mcp23009e/mcp23009e/device.py b/lib/mcp23009e/mcp23009e/device.py index 85d1d73f..7190e990 100644 --- a/lib/mcp23009e/mcp23009e/device.py +++ b/lib/mcp23009e/mcp23009e/device.py @@ -61,13 +61,13 @@ def reset(self): def _soft_reset(self): """Réinitialise le composant avec les valeurs par défaut""" # Configuration par défaut : toutes les pins en entrée - self._write_register(MCP23009_IODIR, 0xFF) + self._write_reg(MCP23009_IODIR, 0xFF) # Désactiver les pull-ups - self._write_register(MCP23009_GPPU, 0x00) + self._write_reg(MCP23009_GPPU, 0x00) # Configuration IOCON par défaut - self._write_register(MCP23009_IOCON, 0x00) + self._write_reg(MCP23009_IOCON, 0x00) # Désactiver les interruptions - self._write_register(MCP23009_GPINTEN, 0x00) + self._write_reg(MCP23009_GPINTEN, 0x00) def setup(self, gpx, direction, pullup=MCP23009_NO_PULLUP, polarity=MCP23009_POL_SAME): """ @@ -83,9 +83,9 @@ def setup(self, gpx, direction, pullup=MCP23009_NO_PULLUP, polarity=MCP23009_POL return # Lire les registres actuels - iodir = self._read_register(MCP23009_IODIR) - gppu = self._read_register(MCP23009_GPPU) - ipol = self._read_register(MCP23009_IPOL) + iodir = self._read_reg(MCP23009_IODIR) + gppu = self._read_reg(MCP23009_GPPU) + ipol = self._read_reg(MCP23009_IPOL) # Modifier les bits appropriés iodir = _set_bit(iodir, gpx, direction) @@ -93,9 +93,9 @@ def setup(self, gpx, direction, pullup=MCP23009_NO_PULLUP, polarity=MCP23009_POL ipol = _set_bit(ipol, gpx, polarity) # Écrire les registres modifiés - self._write_register(MCP23009_IODIR, iodir) - self._write_register(MCP23009_GPPU, gppu) - self._write_register(MCP23009_IPOL, ipol) + self._write_reg(MCP23009_IODIR, iodir) + self._write_reg(MCP23009_GPPU, gppu) + self._write_reg(MCP23009_IPOL, ipol) def set_level(self, gpx, level): """ @@ -109,14 +109,14 @@ def set_level(self, gpx, level): return # Vérifier que le pin est configuré en sortie - iodir = self._read_register(MCP23009_IODIR) + iodir = self._read_reg(MCP23009_IODIR) if _get_bit(iodir, gpx) == MCP23009_DIR_INPUT: return # Le pin est en entrée, on ne peut pas modifier son niveau # Modifier le registre GPIO - gpio = self._read_register(MCP23009_GPIO) + gpio = self._read_reg(MCP23009_GPIO) gpio = _set_bit(gpio, gpx, level) - self._write_register(MCP23009_GPIO, gpio) + self._write_reg(MCP23009_GPIO, gpio) def get_level(self, gpx): """ @@ -131,14 +131,14 @@ def get_level(self, gpx): if gpx > 7: return MCP23009_LOGIC_LOW - gpio = self._read_register(MCP23009_GPIO) + gpio = self._read_reg(MCP23009_GPIO) return _get_bit(gpio, gpx) - def _write_register(self, register, value): + def _write_reg(self, register, value): """Écrit une valeur dans un registre""" self.i2c.writeto_mem(self.address, register, bytes([value])) - def _read_register(self, register): + def _read_reg(self, register): """Lit une valeur depuis un registre""" return self.i2c.readfrom_mem(self.address, register, 1)[0] @@ -146,43 +146,43 @@ def _read_register(self, register): def set_iodir(self, value): """Définit le registre IODIR (Input/Output Direction)""" - self._write_register(MCP23009_IODIR, value) + self._write_reg(MCP23009_IODIR, value) def get_iodir(self): """Lit le registre IODIR (Input/Output Direction)""" - return self._read_register(MCP23009_IODIR) + return self._read_reg(MCP23009_IODIR) def set_ipol(self, value): """Définit le registre IPOL (Input Polarity)""" - self._write_register(MCP23009_IPOL, value) + self._write_reg(MCP23009_IPOL, value) def get_ipol(self): """Lit le registre IPOL (Input Polarity)""" - return self._read_register(MCP23009_IPOL) + return self._read_reg(MCP23009_IPOL) def set_gpinten(self, value): """Définit le registre GPINTEN (GPIO Interrupt Enable)""" - self._write_register(MCP23009_GPINTEN, value) + self._write_reg(MCP23009_GPINTEN, value) def get_gpinten(self): """Lit le registre GPINTEN (GPIO Interrupt Enable)""" - return self._read_register(MCP23009_GPINTEN) + return self._read_reg(MCP23009_GPINTEN) def set_defval(self, value): """Définit le registre DEFVAL (Default Value)""" - self._write_register(MCP23009_DEFVAL, value) + self._write_reg(MCP23009_DEFVAL, value) def get_defval(self): """Lit le registre DEFVAL (Default Value)""" - return self._read_register(MCP23009_DEFVAL) + return self._read_reg(MCP23009_DEFVAL) def set_intcon(self, value): """Définit le registre INTCON (Interrupt Control)""" - self._write_register(MCP23009_INTCON, value) + self._write_reg(MCP23009_INTCON, value) def get_intcon(self): """Lit le registre INTCON (Interrupt Control)""" - return self._read_register(MCP23009_INTCON) + return self._read_reg(MCP23009_INTCON) def set_iocon(self, config): """ @@ -192,9 +192,9 @@ def set_iocon(self, config): config: Instance de MCP23009Config ou valeur entière """ if isinstance(config, MCP23009Config): - self._write_register(MCP23009_IOCON, config.get_register_value()) + self._write_reg(MCP23009_IOCON, config.get_register_value()) else: - self._write_register(MCP23009_IOCON, config) + self._write_reg(MCP23009_IOCON, config) def get_iocon(self): """ @@ -203,39 +203,39 @@ def get_iocon(self): Returns: Instance de MCP23009Config """ - return MCP23009Config(self._read_register(MCP23009_IOCON)) + return MCP23009Config(self._read_reg(MCP23009_IOCON)) def set_gppu(self, value): """Définit le registre GPPU (GPIO Pull-Up)""" - self._write_register(MCP23009_GPPU, value) + self._write_reg(MCP23009_GPPU, value) def get_gppu(self): """Lit le registre GPPU (GPIO Pull-Up)""" - return self._read_register(MCP23009_GPPU) + return self._read_reg(MCP23009_GPPU) def get_intf(self): """Lit le registre INTF (Interrupt Flag)""" - return self._read_register(MCP23009_INTF) + return self._read_reg(MCP23009_INTF) def get_intcap(self): """Lit le registre INTCAP (Interrupt Captured value)""" - return self._read_register(MCP23009_INTCAP) + return self._read_reg(MCP23009_INTCAP) def set_gpio(self, value): """Définit le registre GPIO""" - self._write_register(MCP23009_GPIO, value) + self._write_reg(MCP23009_GPIO, value) def get_gpio(self): """Lit le registre GPIO""" - return self._read_register(MCP23009_GPIO) + return self._read_reg(MCP23009_GPIO) def set_olat(self, value): """Définit le registre OLAT (Output Latch)""" - self._write_register(MCP23009_OLAT, value) + self._write_reg(MCP23009_OLAT, value) def get_olat(self): """Lit le registre OLAT (Output Latch)""" - return self._read_register(MCP23009_OLAT) + return self._read_reg(MCP23009_OLAT) # ===== Méthodes d'interruption ===== @@ -247,8 +247,8 @@ def _send_enable_interrupt(self, gpx): gpx: Numéro de GPIO (0 à 7) """ # Lire les registres actuels - gpinten = self._read_register(MCP23009_GPINTEN) - intcon = self._read_register(MCP23009_INTCON) + gpinten = self._read_reg(MCP23009_GPINTEN) + intcon = self._read_reg(MCP23009_INTCON) # Activer l'interruption sur changement pour ce GPIO gpinten = _set_bit(gpinten, gpx, MCP23009_INTEN_ENABLE) @@ -256,8 +256,8 @@ def _send_enable_interrupt(self, gpx): intcon = _set_bit(intcon, gpx, MCP23009_INTCON_PREVIOUS_STATE) # Écrire les registres - self._write_register(MCP23009_GPINTEN, gpinten) - self._write_register(MCP23009_INTCON, intcon) + self._write_reg(MCP23009_GPINTEN, gpinten) + self._write_reg(MCP23009_INTCON, intcon) def _send_disable_interrupt(self, gpx): """ @@ -267,9 +267,9 @@ def _send_disable_interrupt(self, gpx): gpx: Numéro de GPIO (0 à 7) """ # Lire les registres actuels - gpinten = self._read_register(MCP23009_GPINTEN) - intcon = self._read_register(MCP23009_INTCON) - defval = self._read_register(MCP23009_DEFVAL) + gpinten = self._read_reg(MCP23009_GPINTEN) + intcon = self._read_reg(MCP23009_INTCON) + defval = self._read_reg(MCP23009_DEFVAL) # Désactiver l'interruption pour ce GPIO gpinten = _set_bit(gpinten, gpx, MCP23009_INTEN_DISABLE) @@ -277,9 +277,9 @@ def _send_disable_interrupt(self, gpx): defval = _set_bit(defval, gpx, MCP23009_LOGIC_LOW) # Écrire les registres - self._write_register(MCP23009_GPINTEN, gpinten) - self._write_register(MCP23009_INTCON, intcon) - self._write_register(MCP23009_DEFVAL, defval) + self._write_reg(MCP23009_GPINTEN, gpinten) + self._write_reg(MCP23009_INTCON, intcon) + self._write_reg(MCP23009_DEFVAL, defval) def interrupt_on_change(self, gpx, callback): """ @@ -356,15 +356,15 @@ def interrupt_event(self): iocon = self.get_iocon() # Lire les flags d'interruption - intf = self._read_register(MCP23009_INTF) + intf = self._read_reg(MCP23009_INTF) # Lire l'état des GPIO if iocon.has_intcc(): # Si INTCC est activé, lire INTCAP efface l'interruption - state = self._read_register(MCP23009_INTCAP) + state = self._read_reg(MCP23009_INTCAP) else: # Sinon, lire GPIO efface l'interruption - state = self._read_register(MCP23009_GPIO) + state = self._read_reg(MCP23009_GPIO) # Traiter chaque GPIO ayant généré une interruption for i in range(8): diff --git a/lib/vl53l1x/vl53l1x/device.py b/lib/vl53l1x/vl53l1x/device.py index b3cd5a4f..6e43362d 100644 --- a/lib/vl53l1x/vl53l1x/device.py +++ b/lib/vl53l1x/vl53l1x/device.py @@ -110,31 +110,31 @@ def __init__(self, i2c, address=0x29): # machine.lightsleep(100) # the API triggers this change in VL53L1_init_and_start_range() once a # measurement is started; assumes MM1 and MM2 are disabled - self.writeReg16Bit(0x001E, self.readReg16Bit(0x0022) * 4) + self._write_reg16(0x001E, self._read_reg16(0x0022) * 4) machine.lightsleep(200) - def writeReg(self, reg, value): + def _write_reg(self, reg, value): return self.i2c.writeto_mem(self.address, reg, bytes([value]), addrsize=16) - def writeReg16Bit(self, reg, value): + def _write_reg16(self, reg, value): return self.i2c.writeto_mem( self.address, reg, bytes([(value >> 8) & 0xFF, value & 0xFF]), addrsize=16 ) - def readReg(self, reg): + def _read_reg(self, reg): return self.i2c.readfrom_mem(self.address, reg, 1, addrsize=16)[0] - def readReg16Bit(self, reg): + def _read_reg16(self, reg): data = self.i2c.readfrom_mem(self.address, reg, 2, addrsize=16) return (data[0] << 8) + data[1] def read_model_id(self): - return self.readReg16Bit(0x010F) + return self._read_reg16(0x010F) def reset(self): - self.writeReg(0x0000, 0x00) + self._write_reg(0x0000, 0x00) machine.lightsleep(100) - self.writeReg(0x0000, 0x01) + self._write_reg(0x0000, 0x01) def read(self): data = self.i2c.readfrom_mem(self.address, 0x0089, 17, addrsize=16) # RESULT__RANGE_STATUS diff --git a/lib/wsen-pads/wsen_pads/device.py b/lib/wsen-pads/wsen_pads/device.py index 85f75e4f..19b81306 100644 --- a/lib/wsen-pads/wsen_pads/device.py +++ b/lib/wsen-pads/wsen_pads/device.py @@ -58,15 +58,15 @@ def _is_present(self): except Exception: return False - def _read_u8(self, reg): + def _read_reg(self, reg): """Read and return one unsigned byte from a register.""" return self.i2c.readfrom_mem(self.address, reg, 1)[0] - def _read(self, reg, length): + def _read_block(self, reg, length): """Read and return multiple bytes starting at a register.""" return self.i2c.readfrom_mem(self.address, reg, length) - def _write_u8(self, reg, value): + def _write_reg(self, reg, value): """Write one unsigned byte to a register.""" self.i2c.writeto_mem(self.address, reg, bytes((value & 0xFF,))) @@ -76,9 +76,9 @@ def _update_reg(self, reg, mask, value): Only the bits set in 'mask' are modified. Other bits are preserved. """ - current = self._read_u8(reg) + current = self._read_reg(reg) current = (current & ~mask) | (value & mask) - self._write_u8(reg, current) + self._write_reg(reg, current) # --------------------------------------------------------------------- # Internal conversion helpers @@ -109,7 +109,7 @@ def _wait_boot(self, timeout_ms=20): The sensor sets BOOT_ON while internal trimming parameters are loaded. """ start = ticks_ms() - while self._read_u8(REG_INT_SOURCE) & INT_SOURCE_BOOT_ON: + while self._read_reg(REG_INT_SOURCE) & INT_SOURCE_BOOT_ON: if ticks_diff(ticks_ms(), start) > timeout_ms: raise WSENPADSTimeout("WSEN-PADS boot timeout") sleep_ms(1) @@ -151,11 +151,11 @@ def _configure_default(self): def device_id(self): """Return the value of the DEVICE_ID register.""" - return self._read_u8(REG_DEVICE_ID) + return self._read_reg(REG_DEVICE_ID) def status(self): """Return the raw STATUS register value.""" - return self._read_u8(REG_STATUS) + return self._read_reg(REG_STATUS) def pressure_available(self): """Return True when new pressure data is available.""" @@ -212,7 +212,7 @@ def reboot(self): def _is_power_down(self): """Return True if the sensor is in power-down mode (ODR = 000).""" - return (self._read_u8(REG_CTRL_1) & CTRL1_ODR_MASK) == 0 + return (self._read_reg(REG_CTRL_1) & CTRL1_ODR_MASK) == 0 def _ensure_data(self): """Trigger a one-shot conversion if the sensor is in power-down mode.""" @@ -227,7 +227,7 @@ def pressure_raw(self): triggered automatically before reading. """ self._ensure_data() - data = self._read(REG_DATA_P_XL, 3) + data = self._read_block(REG_DATA_P_XL, 3) raw = (data[2] << 16) | (data[1] << 8) | data[0] return self._to_signed24(raw) @@ -239,7 +239,7 @@ def temperature_raw(self): triggered automatically before reading. """ self._ensure_data() - data = self._read(REG_DATA_T_L, 2) + data = self._read_block(REG_DATA_T_L, 2) raw = (data[1] << 8) | data[0] return self._to_signed16(raw) @@ -281,9 +281,9 @@ def read(self): tuple: (pressure_hpa, temperature_c) """ self.trigger_one_shot() - p_data = self._read(REG_DATA_P_XL, 3) + p_data = self._read_block(REG_DATA_P_XL, 3) p_raw = self._to_signed24((p_data[2] << 16) | (p_data[1] << 8) | p_data[0]) - t_data = self._read(REG_DATA_T_L, 2) + t_data = self._read_block(REG_DATA_T_L, 2) t_raw = self._to_signed16((t_data[1] << 8) | t_data[0]) return p_raw * PRESSURE_HPA_PER_DIGIT, t_raw * TEMPERATURE_C_PER_DIGIT @@ -385,7 +385,7 @@ def set_continuous( if low_pass_strong: ctrl1_value |= CTRL1_LPFP_CFG - self._write_u8(REG_CTRL_1, ctrl1_value) + self._write_reg(REG_CTRL_1, ctrl1_value) # --------------------------------------------------------------------- # Optional helper methods @@ -397,16 +397,16 @@ def enable_low_pass(self, strong=False): This helper preserves the current ODR and only updates filter bits. """ - current = self._read_u8(REG_CTRL_1) + current = self._read_reg(REG_CTRL_1) current |= CTRL1_EN_LPFP if strong: current |= CTRL1_LPFP_CFG else: current &= ~CTRL1_LPFP_CFG - self._write_u8(REG_CTRL_1, current) + self._write_reg(REG_CTRL_1, current) def disable_low_pass(self): """Disable the optional LPF2 pressure filter.""" - current = self._read_u8(REG_CTRL_1) + current = self._read_reg(REG_CTRL_1) current &= ~(CTRL1_EN_LPFP | CTRL1_LPFP_CFG) - self._write_u8(REG_CTRL_1, current) + self._write_reg(REG_CTRL_1, current) diff --git a/tests/scenarios/apds9960.yaml b/tests/scenarios/apds9960.yaml index 82987d3b..b19db006 100644 --- a/tests/scenarios/apds9960.yaml +++ b/tests/scenarios/apds9960.yaml @@ -50,7 +50,7 @@ mock_registers: tests: - name: "Verify device ID register (mock)" action: call - method: _read_byte_data + method: _read_reg args: [0x92] expect: 0xAB mode: [mock]