def __init__(self, slave=0x60, prescale0=0, prescale1=0, ledmode=0b1110):
# Check parameter sanity
pres0 = toint(prescale0)
if not pres0 in range(0, 0xFF + 1):
raise ValueError("prescale0 value %d out of range [%d..%d]" %
(pres0, 0x00, 0xFF))
pres1 = toint(prescale1)
if not pres1 in range(0, 0xFF + 1):
raise ValueError("prescale1 value %d out of range [%d..%d]" %
(pres1, 0x00, 0xFF))
lmode = toint(ledmode)
if not lmode in range(0, 0x0F + 1):
raise ValueError("ledmode value %d out of range [%d..%d]" %
(lmode, 0x00, 0x0F))
# Go for it
I2C.__init__(self, toint(slave))
PWM.__init__(self, self.PWM_CHANNELS, self.PWM_RESOLUTION,
self.__calculateFrequency__(pres0))
DAC.__init__(self, self.DAC_CHANNELS, self.DAC_RESOLUTION, self.VREF)
GPIOPort.__init__(self, self.GPIO_CHANNELS, self.GPIO_BANKS)
d = bytearray(5)
d[0] = pres0
d[1] = self.D_PWM0
d[2] = pres1
d[3] = self.D_PWM1
d[4] = lmode | 0xF0
self.writeRegisters((self.PSC0 | self.FLAG_AI), d)
def __init__(self, busnum=0, slave=0x40):
I2C.__init__(self, toint(slave))
self.red = 0
self.green = 0
self.blue = 0
data = [ 0x05, 0x03, self.red, self.green, self.blue ]
self.writeBytes(data)
def __init__(self,
altitude=0,
external=None,
oversampling=0,
filter=0,
standby=0.5,
slave=0x76):
I2C.__init__(self, toint(slave))
Pressure.__init__(self, altitude, external)
self.t1 = self.readUnsigned(0x88, 2)
self.t2 = self.readSigned(0x8A, 2)
self.t3 = self.readSigned(0x8C, 2)
self.p1 = self.readUnsigned(0x8E, 2)
self.p2 = self.readSigned(0x90, 2)
self.p3 = self.readSigned(0x92, 2)
self.p4 = self.readSigned(0x94, 2)
self.p5 = self.readSigned(0x96, 2)
self.p6 = self.readSigned(0x98, 2)
self.p7 = self.readSigned(0x9A, 2)
self.p8 = self.readSigned(0x9C, 2)
self.p9 = self.readSigned(0x9E, 2)
self.h1 = self.readUnsigned(0xA1, 1)
self.h2 = self.readSigned(0xE1, 2)
self.h3 = self.readUnsigned(0xE3, 1)
self.h4 = (self.readUnsigned(0xE4, 1) << 4) | (
self.readUnsigned(0xE5, 1) & 0x0F)
self.h5 = (self.readSigned(0xE6, 1) << 4) | (
self.readSigned(0xE5, 1) >> 4)
self.h6 = self.readSigned(0xE7, 1)
oversamplingBits = toint(oversampling).bit_length()
self.writeRegister(
0xF2, oversamplingBits
) # Humidity oversampling. Must be set before temp/press oversampling (see datasheet 5.4.3).
self.writeRegister(
0xF4, (oversamplingBits << 5) | (oversamplingBits << 2)
| 0x03) # Pressure, temperature oversampling, sensor normal mode.
standbyValues = {
'0.5': 0,
'10': 6,
'20': 7,
'62.5': 1,
'125': 2,
'250': 3,
'500': 4,
'1000': 5
}
if standby in standbyValues:
tStandbyBits = standbyValues[standby]
else:
tStandbyBits = 0 # Default to 0.5ms t_standby
# logger.warn('Invalid value for standby: %s' % standby)
spiBits = 0 # No SPI of course.
filterBits = toint(filter) >> 1
self.writeRegister(0xF5,
(tStandbyBits << 5) | (filterBits << 2) | spiBits)
def __init__(self, slave=0x18, resolution=12):
I2C.__init__(self, toint(slave))
resolution = toint(resolution)
if not resolution in range(9, 13):
raise ValueError("%dbits resolution out of range [%d..%d]bits" %
(resolution, 9, 12))
self.resolution = resolution
self.writeRegister(0x08, (resolution - 9))
def __init__(self, control):
I2C.__init__(self, 0x68)
Clock.__init__(self)
if control != None:
con = toint(control)
if not con in range(0, 0xFF + 1):
raise ValueError("control value [%d] out of range [%d..%d]" %
(con, 0x00, 0xFF))
self.__setCon__(con)
else:
self.__setCon__(self.CON_DEFAULT)
def __init__(self, slave=0b0010011, current=20, frequency=781, prox_threshold=15, prox_cycles=10, cal_cycles= 5):
I2C.__init__(self, toint(slave))
self.setCurrent(toint(current))
self.setFrequency(toint(frequency))
self.prox_threshold = toint(prox_threshold)
self.prox_cycles = toint(prox_cycles)
self.cal_cycles = toint(cal_cycles)
self.__setProximityTiming__()
self.__setAmbientMeasuringMode__()
time.sleep(0.001)
self.calibrate() # may have to be repeated from time to time or before every proximity measurement
def __init__(self, slave, byteCount, pageSize, writeTime, name):
slave = toint(slave)
if not slave in range(0x50, 0x57 + 1):
raise ValueError(
"Slave value [0x%02X] out of range [0x%02X..0x%02X]" %
(slave, 0x50, 0x57))
I2C.__init__(self, slave)
# Tbd: HAT uses I2C channel 0
Memory.__init__(self, byteCount)
self._pageSize = pageSize
self._writeTime = toint(writeTime) / 1000
self.name = name
def __init__(self, slave=0x20):
slave = toint(slave)
if slave in range(0x20, 0x28):
name = "PCF8574"
elif slave in range(0x38, 0x40):
name = "PCF8574A"
else:
raise ValueError("Bad slave address for PCF8574(A) : 0x%02X not in range [0x20..0x27, 0x38..0x3F]" % slave)
I2C.__init__(self, slave, name)
GPIOPort.__init__(self, 8)
self.portWrite(0xFF)
self.portRead()
def __init__(self, slave=0x40, frequency=50):
I2C.__init__(self, toint(slave))
PWM.__init__(self, 16, 12, toint(frequency))
self.VREF = 0
self.prescale = int(25000000.0 / ((2**12) * self.frequency))
self.mode1 = self.M1_RESTART | self.M1_AI
self.writeRegister(self.MODE1, self.M1_SLEEP)
self.writeRegister(self.PRESCALE, self.prescale)
time.sleep(0.01)
self.writeRegister(self.MODE1, self.mode1)
def __init__(self, slave=0x40, frequency=50):
I2C.__init__(self, toint(slave))
PWM.__init__(self, 16, 12, toint(frequency))
self.VREF = 0
self.prescale = int(25000000.0/((2**12)*self.frequency))
self.mode1 = self.M1_RESTART | self.M1_AI
self.writeRegister(self.MODE1, self.M1_SLEEP)
self.writeRegister(self.PRESCALE, self.prescale)
time.sleep(0.01)
self.writeRegister(self.MODE1, self.mode1)
def __init__(self, altitude=0, external=None, reset_pin_bcm=None):
NativeGPIO.__init__(self)
self._reset_pin_bcm = reset_pin_bcm
self.resetHardware()
I2C.__init__(self, 0x60)
Pressure.__init__(self, altitude, external)
coef_values = self._getCoefValues()
self._coef_a0 = coef_values[0]
self._coef_b1 = coef_values[1]
self._coef_b2 = coef_values[2]
self._coef_c12 = coef_values[3]
def __init__(self, altitude=0, external=None, reset_pin_bcm=None):
NativeGPIO.__init__(self)
self._reset_pin_bcm = reset_pin_bcm
self.resetHardware()
I2C.__init__(self, 0x60)
Pressure.__init__(self, altitude, external)
coef_values = self._getCoefValues()
self._coef_a0 = coef_values[0]
self._coef_b1 = coef_values[1]
self._coef_b2 = coef_values[2]
self._coef_c12 = coef_values[3]
def __init__(self, control=None):
I2C.__init__(self, 0x6F)
Clock.__init__(self)
Memory.__init__(self, 64)
if control != None:
con = toint(control)
if not con in range(0, 0xFF + 1):
raise ValueError("control value %d out of range [%d..%d]" %
(con, 0x00, 0xFF))
self.__setCon__(con)
else:
self.__setCon__(self.CON_DEFAULT)
# Clock is stopped by default upon poweron, so start it
self.start()
def __init__(self, altitude=0, external=None):
I2C.__init__(self, 0x77)
Pressure.__init__(self, altitude, external)
self.ac1 = self.readSignedInteger(0xAA)
self.ac2 = self.readSignedInteger(0xAC)
self.ac3 = self.readSignedInteger(0xAE)
self.ac4 = self.readUnsignedInteger(0xB0)
self.ac5 = self.readUnsignedInteger(0xB2)
self.ac6 = self.readUnsignedInteger(0xB4)
self.b1 = self.readSignedInteger(0xB6)
self.b2 = self.readSignedInteger(0xB8)
self.mb = self.readSignedInteger(0xBA)
self.mc = self.readSignedInteger(0xBC)
self.md = self.readSignedInteger(0xBE)
def __init__(self, altitude=0, external=None):
I2C.__init__(self, 0x77)
Pressure.__init__(self, altitude, external)
self.ac1 = self.readSignedInteger(0xAA)
self.ac2 = self.readSignedInteger(0xAC)
self.ac3 = self.readSignedInteger(0xAE)
self.ac4 = self.readUnsignedInteger(0xB0)
self.ac5 = self.readUnsignedInteger(0xB2)
self.ac6 = self.readUnsignedInteger(0xB4)
self.b1 = self.readSignedInteger(0xB6)
self.b2 = self.readSignedInteger(0xB8)
self.mb = self.readSignedInteger(0xBA)
self.mc = self.readSignedInteger(0xBC)
self.md = self.readSignedInteger(0xBE)
def __init__(self, slave=0x20):
slave = toint(slave)
I2C.__init__(self, slave)
self.porta = self.LCD_LED_ON
self.led = self.LCD_LED_ON
self.writeRegister(self.MCP23008_IODIR, 0x00)
self.writeRegisters( self.MCP23008_IODIR,
[0b00000000, # IODIR
0b00000000, # IPOL
0b00000000, # GPINTEN
0b00000000, # DEFVAL
0b00000000, # INTCON
0b00000000, # IOCON
0b00000000, # GPPU
0b00000000, # INTF
0b00000000, # INTCAP
self.porta | self.led, # GPIO
self.porta | self.led ])# OLAT
self.writeRegister( self.MCP23008_IOCON, 0x20 )
self.displayshift = (self.LCD_CURSORMOVE |
self.LCD_MOVERIGHT)
self.displaymode = (self.LCD_ENTRYLEFT |
self.LCD_ENTRYSHIFTDECREMENT)
self.displaycontrol = (self.LCD_DISPLAYON |
self.LCD_CURSOROFF |
self.LCD_BLINKOFF)
self.write_lcd(self.LCD_DATA_E1, 0x33) # Init
self.write_lcd(self.LCD_DATA_E1, 0x32) # Init
self.write_lcd(self.LCD_DATA_E1, 0x24) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E1, 0x09) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E1, 0x20) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E1, self.LCD_CLEARDISPLAY)
self.write_lcd(self.LCD_DATA_E1, self.LCD_CURSORSHIFT | self.displayshift)
self.write_lcd(self.LCD_DATA_E1, self.LCD_ENTRYMODESET | self.displaymode)
self.write_lcd(self.LCD_DATA_E1, self.LCD_DISPLAYCONTROL | self.displaycontrol)
self.write_lcd(self.LCD_DATA_E1, self.LCD_RETURNHOME)
self.write_lcd(self.LCD_DATA_E2, 0x33) # Init
self.write_lcd(self.LCD_DATA_E2, 0x32) # Init
self.write_lcd(self.LCD_DATA_E2, 0x24) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E2, 0x09) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E2, 0x20) # 2 line 5x8 matrix
self.write_lcd(self.LCD_DATA_E2, self.LCD_CLEARDISPLAY)
self.write_lcd(self.LCD_DATA_E2, self.LCD_CURSORSHIFT | self.displayshift)
self.write_lcd(self.LCD_DATA_E2, self.LCD_ENTRYMODESET | self.displaymode)
self.write_lcd(self.LCD_DATA_E2, self.LCD_DISPLAYCONTROL | self.displaycontrol)
self.write_lcd(self.LCD_DATA_E2, self.LCD_RETURNHOME)
def __init__(self, slave, resolution, name, gain=1):
self.__address = toint(slave)
self.resolution = toint(resolution)
self.initResolution = toint(resolution) - 1
self.name = name
self.gain = toint(gain)
self.channelCount = 4
self.byteCount = 3
#pass the integer of the chip address to I2C.__init__
I2C.__init__(self, self.__address)
#pass the ADC channel, resolution, and vref to ADC.__init__
ADC.__init__(self, self.channelCount, self.initResolution, vref=5)
#setBitRate and set_pga must follow I2C and ADC init()
#The I2C bus must be set up first.
self.setBitRate(self.resolution)
self.set_pga(self.gain) # set the gain
def __init__(self, slave, channelCount, resolution, name):
I2C.__init__(self, toint(slave))
ADC.__init__(self, channelCount, resolution, 4.096)
self._analogMax = 2**(resolution-1)
self.name = name
config = self.readRegisters(self.CONFIG, 2)
mode = 0 # continuous
config[0] &= ~self.CONFIG_MODE_MASK
config[0] |= mode
gain = 0x1 # FS = +/- 4.096V
config[0] &= ~self.CONFIG_GAIN_MASK
config[0] |= gain << 1
self.writeRegisters(self.CONFIG, config)
def __init__(self,
slave=0b0010011,
current=20,
frequency=781,
prox_threshold=15,
prox_cycles=10,
cal_cycles=5):
I2C.__init__(self, toint(slave))
self.setCurrent(toint(current))
self.setFrequency(toint(frequency))
self.prox_threshold = toint(prox_threshold)
self.prox_cycles = toint(prox_cycles)
self.cal_cycles = toint(cal_cycles)
self.__setProximityTiming__()
self.__setAmbientMeasuringMode__()
time.sleep(0.001)
self.calibrate(
) # may have to be repeated from time to time or before every proximity measurement
def __init__(self, slave=0x20, invert_oe=False, outconf=0xFF):
# Check parameter sanity
oconf = toint(outconf)
if oconf != 0xFF:
if not oconf in range(0, 0xFF):
raise ValueError("outconf value %d out of range [%d..%d]" %
(oconf, 0x00, 0xFE))
# Go for it
I2C.__init__(self, toint(slave))
GPIOPort.__init__(self, self.CHANNELS, self.BANKS)
iv_oe = str2bool(invert_oe)
if iv_oe:
self.writeRegister(self.MODE,
(self.VAL_MODEDEF | self.FLAG_OEPOLHI))
else:
self.writeRegister(self.MODE, self.VAL_MODEDEF)
self.writeRegister(self.OUTCONF, oconf)
self.reset()
def __init__(self, slave=0x60):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 1, 12, 3.3)
def __init__(self, slave=0x48, vref=3.3):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 5, 8, float(vref))
self.daValue = 0
def setRGB(self, value):
r = (value>>16) & 0xff
g = (value>>8) & 0xff
b = value & 0xff
I2C.writeRegisters(self, self.slave, bytes([self.GO_TO_RGB, r, g, b]))
return r, g, b
def __init__(self, slave, channelCount, name):
I2C.__init__(self, toint(slave))
MCP23XXX.__init__(self, channelCount)
self.name = name
def __init__(self, slave, channelCount, name):
I2C.__init__(self, toint(slave), name)
MCP23XXX.__init__(self, channelCount)
def __init__(self, slave, time, name="TSL_LIGHT_X"):
I2C.__init__(self, toint(slave))
self.name = name
self.wake() # devices are powered down after power reset, wake them
self.setTime(toint(time))
def __init__(self, slave=0x48):
I2C.__init__(self, toint(slave))
def __init__(self):
I2C.__init__(self, 0x40)
self.resolutions = self.get_resolutions()
self.rh_timing, self.temp_timing = self.MEASURE_TIMES[self.resolutions]
def __init__(self):
I2C.__init__(self, 0x40)
def __init__(self, slave=0x28):
I2C.__init__(self, toint(slave))
self.__startMeasuring__()
def __init__(self, slave=0x0a):
I2C.__init__(self, toint(slave))
I2C.writeRegister(self, self.slave, self.STOP_SCRIPT)
def __init__(self, slave=0x20):
I2C.__init__(self, toint(slave))
GPIOPort.__init__(self, self.CHANNELS)
self.reset()
def __init__(self, slave=0x48, vref=3.3):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 5, 8, float(vref))
self.daValue = 0
def __init__(self, slave=0x60, vref=3.3):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 1, 12, float(vref))
def __init__(self, slave, vref, channelCount, resolution, name):
I2C.__init__(self, toint(slave))
DAC.__init__(self, channelCount, resolution, float(vref))
self.name = name
def __init__(self, slave=0x60, vref=3.3):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 1, 12, float(vref))
def __init__(self, slave=0x28):
I2C.__init__(self, toint(slave))
self.__startMeasuring__()
def getRGB(self):
I2C.writeRegister(self, self.slave, self.GET_CURRENT_RGB)
r, g, b = I2C.readRegisters(self, self.slave, 3)
return r, g, b
def __init__(self, slave=0x48):
I2C.__init__(self, toint(slave))
def __init__(self, slave, time, name="TSL_LIGHT_X"):
I2C.__init__(self, toint(slave))
self.name = name
self.wake() # devices are powered down after power reset, wake them
self.setTime(toint(time))
