def __init__(self, board=0):
mcp = MCP23S17(0, 0x20 + toint(board))
mcp.writeRegister(mcp.getAddress(mcp.IODIR, 0),
0x00) # Port A as output
mcp.writeRegister(mcp.getAddress(mcp.IODIR, 8),
0xFF) # Port B as input
mcp.writeRegister(mcp.getAddress(mcp.GPPU, 0), 0x00) # Port A PU OFF
mcp.writeRegister(mcp.getAddress(mcp.GPPU, 8), 0xFF) # Port B PU ON
self.mcp = mcp
self.board = toint(board)
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, time=0.18, slave= 0x23,mode=4, name="gy_30"):
I2C.__init__(self, toint(slave))
self.name = name
# self.wake() # devices are powered down after power reset, wake them
# self.setTime(toint(time))
if slave == 0:
self.addr = self.I2C_ADDRESS_L
else:
self.addr = self.I2C_ADDRESS_H
if mode == 0:
self.mode = self.CONTINUOUSLY_H_RES_MODE
self.wait = 0.18 # Wait 180ms for result
self.resolution_div = 1
elif mode == 1:
self.mode = self.CONTINUOUSLY_H_RES_MODE_2
self.wait = 0.18 # Wait 180ms for result
self.resolution_div = 2
elif mode == 2:
self.mode = self.CONTINUOUSLY_L_RES_MODE
self.wait = 0.024 # Wait 24ms for result
self.resolution_div = 1
elif mode == 3:
self.mode = self.ONE_TIME_H_RES_MODE
self.wait = 0.18 # Wait 180ms for result
self.resolution_div = 1
elif mode == 4:
self.mode = self.ONE_TIME_H_RES_MODE_2
self.wait = 0.18 # Wait 180ms for result
self.resolution_div = 2
else:
self.mode = self.ONE_TIME_L_RES_MODE
self.wait = 0.024 # Wait 24ms for result
self.resolution_div = 1
def __init__(self, chip, channelCount, vref):
SPI.__init__(self, toint(chip), 0, 8, 10000000)
DAC.__init__(self, channelCount, 12, float(vref))
self.buffered = False
self.gain = False
self.shutdown = False
self.values = [0 for i in range(channelCount)]
def __init__(self, chip, channelCount, resolution, name):
SPI.__init__(self, toint(chip), 0, 8, 10000000)
DAC.__init__(self, channelCount, resolution, 2.048)
self.name = name
self.buffered=False
self.gain=False
self.shutdown=True
self.values = [0 for i in range(channelCount)]
def __init__(self, chip, slave, channelCount, name):
global MCP23S_SLAVES
index = toint(chip) << 7 | toint(slave)
print(MCP23S_SLAVES[index])
if MCP23S_SLAVES[index] != None:
raise Exception("SLAVE_ADDRESS_USED")
SPI.__init__(self, toint(chip), 0, 8, 10000000)
MCP23XXX.__init__(self, channelCount)
self.slave = self.SLAVE
iocon_value = 0x08 # Hardware Address Enable
iocon_addr = self.getAddress(self.IOCON)
self.writeRegister(iocon_addr, iocon_value)
self.slave = toint(slave)
self.name = name
MCP23S_SLAVES[index] = self
print(MCP23S_SLAVES[index])
def __init__(self, altitude=0, external=None):
self.altitude = toint(altitude)
if isinstance(external, str):
self.external = deviceInstance(external)
else:
self.external = external
if self.external != None and not isinstance(self.external,
Temperature):
raise Exception("external must be a Temperature sensor")
def __init__(self, gpio, channel, invert=False):
self.gpioname = gpio
self.channel = toint(channel)
if isinstance(invert, str):
self.invert = str2bool(invert)
else:
self.invert = invert
self.gpio = None
self.setGPIOInstance()
self.gpio.setFunction(self.channel, GPIO.IN)
def __init__(self, board=0):
self.board = toint(board)
MCP23S17.__init__(self, 0, 0x20 + self.board)
self.writeRegister(self.getAddress(self.IODIR, 0),
0x00) # Port A as output
self.writeRegister(self.getAddress(self.IODIR, 8),
0xFF) # Port B as input
self.writeRegister(self.getAddress(self.GPPU, 0),
0x00) # Port A PU OFF
self.writeRegister(self.getAddress(self.GPPU, 8), 0xFF) # Port B PU ON
def __init__(self, slave=0x48, resolution=12):
TMP102.__init__(self, 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
config = self.readRegister(0x01)
config &= ~0x60
config |= (self.resolution - 9) << 5
self.writeRegister(0x01, config)
self.readRegisters(0x00, 2)
def __init__(self, slave=0x20):
slave = toint(slave)
if slave in range(0x20, 0x28):
self.name = "PCF8574"
elif slave in range(0x38, 0x40):
self.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)
GPIOPort.__init__(self, 8)
self.portWrite(0xFF)
self.portRead()
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, time, gain, name="TSL2561X"):
TSL_LIGHT_X.__init__(self, slave, time, name)
self.setGain(toint(gain))
def __init__(self, adc, channel):
self.adcname = adc
self.channel = toint(channel)
self.adc = None
self.pluginManager = PluginManager()
self.setADCInstance()
def __init__(self, slave, channelCount, name):
I2C.__init__(self, toint(slave))
MCP23XXX.__init__(self, channelCount)
self.name = name
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, chip, channelCount, resolution, vref, name):
SPI.__init__(self, toint(chip), 0, 8, 10000)
ADC.__init__(self, channelCount, resolution, float(vref))
self.name = name
self.MSB_MASK = 2**(resolution-8) - 1
def __init__(self, pwm, channel):
self.pwmname = pwm
self.channel = toint(channel)
self.pwm = None
self.setPWMInstance()
self.pwm.pwmWriteAngle(self.channel, 0)
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=0x48):
I2C.__init__(self, toint(slave))
def __init__(self, slave=0x60, vref=3.3):
I2C.__init__(self, toint(slave))
DAC.__init__(self, 1, 12, float(vref))
def __init__(self, adc, channel):
self.adcname = adc
self.channel = toint(channel)
self.adc = None
self.setADCInstance()
def __init__(self, slave=0x28):
I2C.__init__(self, toint(slave))
self.__startMeasuring__()
