class Device(object):
def __init__(self, address, bus):
self._bus = SMBus(bus)
self._address = address
def writeRaw8(self, value):
value = value & 0xff
self._bus.write_byte(self._address, value)
def readRaw8(self):
result = self._bus.read_byte(self._address) & 0xff
return result
def write8(self, register, value):
value = value & 0xff
self._bus.write_byte_data(self._address, register, value)
def readU8(self, register):
result = self._bus.read_byte_data(self._address, register) & 0xFF
return result
def readS8(self, register):
result = self.readU8(register)
if result > 127:
result -= 256
return result
def write16(self, register, value):
value = value & 0xffff
self._bus.write_word_data(self._address, register, value)
def readU16(self, register, little_endian = True):
result = self._bus.read_word_data(self._address,register) & 0xFFFF
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
return result
def readS16(self, register, little_endian = True):
result = self.readU16(register, little_endian)
if result > 32767:
result -= 65536
return result
def writeList(self, register, data):
self._bus.write_i2c_block_data(self._address, register, data)
def readList(self, register, length):
results = self._bus.read_i2c_block_data(self._address, register, length)
return results
class PCF8574(object):
def __init__(self, bus_id, address):
super().__init__()
self.__bus = SMBus(bus_id)
self.__address = address
self.__value = self.__getRealValue()
@property
def value(self):
return self.__value
@value.setter
def value(self, value):
self.__bus.write_byte(self.__address,
(~value) & 0xff
)
self.__value = value
def flipBits(self, changeBits):
self.value ^= changeBits
def __getRealValue(self):
value = self.__bus.read_byte(self.__address)
return (~value) & 0xff
class HTU21D():
"""Class for accessing HTU21D sensors via I2C.
Code taken from https://github.com/jasiek/HTU21D.
Args:
busno (int): The I2C bus (0 or 1, default is 1).
address (byte): The I2C address of the sensor.
"""
CMD_TRIG_TEMP_HM = 0xE3
CMD_TRIG_HUMID_HM = 0xE5
CMD_TRIG_TEMP_NHM = 0xF3
CMD_TRIG_HUMID_NHM = 0xF5
CMD_WRITE_USER_REG = 0xE6
CMD_READ_USER_REG = 0xE7
CMD_RESET = 0xFE
def __init__(self, busno=1, address=config.SENSOR_ID_HUMIDITY_EXT):
self.bus = SMBus(busno)
self.i2c_address = address
def read_temperature(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(
self.i2c_address, self.CMD_TRIG_TEMP_HM, 3)
return -46.85 + 175.72 * (msb * 256 + lsb) / 65536
def read_humidity(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(
self.i2c_address, self.CMD_TRIG_HUMID_HM, 3)
return (-6 + 125 * (msb * 256 + lsb) / 65536.0) / 100.0
def reset(self):
self.bus.write_byte(self.i2c_address, self.CMD_RESET)
class MTSMBus(I2CBus):
""" Multi-thread compatible SMBus bus.
This is just a wrapper of SMBus, serializing I/O on the bus for use
in multi-threaded context and adding _i2c_ variants of block transfers.
"""
def __init__(self, bus_id=1, **kwargs):
"""
:param int bus_id: the SMBus id (see Raspberry Pi documentation)
:param kwargs: parameters transmitted to :py:class:`smbus.SMBus` initializer
"""
I2CBus.__init__(self, **kwargs)
self._bus = SMBus(bus_id)
# I/O serialization lock
self._lock = threading.Lock()
def read_byte(self, addr):
with self._lock:
return self._bus.read_byte(addr)
def write_byte(self, addr, data):
with self._lock:
self._bus.write_byte(addr, data)
def read_byte_data(self, addr, reg):
with self._lock:
return self._bus.read_byte_data(addr, reg)
def write_byte_data(self, addr, reg, data):
with self._lock:
self._bus.write_byte_data(addr, reg, data)
def read_word_data(self, addr, reg):
with self._lock:
return self._bus.read_word_data(addr, reg)
def write_word_data(self, addr, reg, data):
with self._lock:
self._bus.write_word_data(addr, reg, data)
def read_block_data(self, addr, reg):
with self._lock:
return self._bus.read_block_data(addr, reg)
def write_block_data(self, addr, reg, data):
with self._lock:
self._bus.write_block_data(addr, reg, data)
def read_i2c_block_data(self, addr, reg, count):
with self._lock:
return self._bus.read_i2c_block_data(addr, reg, count)
def write_i2c_block_data(self, addr, reg, data):
with self._lock:
self._bus.write_i2c_block_data(addr, reg, data)
class Pines(object):
"""docstring for Pines"""
def __init__(self,address):
conf.estado = 0b11111111
self.address = address
self.bus = SMBus(1)
def cero(self,pin):
conf.estado &=~(1<<pin)
self.bus.write_byte(self.address , conf.estado)
return conf.estado
def uno(self , pin):
conf.estado |=(1<<pin)
self.bus.write_byte(self.address , conf.estado)
return conf.estado
def toggle(self,pin):
numero = 2**pin
conf.estado = conf.estado^numero
self.bus.write_byte(self.address , conf.estado)
return conf.estado
def toggle2(self,pin1,pin2):
self.toggle(pin1)
self.toggle(pin2)
def reset(self):
self.estado = self.estado|255
self.bus.write_byte(address , self.estado)
class i2cDevice:
def __init__(self, bus_number):
self.BC_addr = 0x25
self.bus = SMBus(bus_number)
def read_register(self, address):
self.bus.write_byte(self.BC_addr, address)
time.sleep(0.02)
data = struct.pack('B', self.bus.read_byte(self.BC_addr))
return data
def write_register(self, address, data):
self.bus.write_byte_data(self.BC_addr, address, data)
time.sleep(0.02)
def get(self):
lStatus = 'ok'
lArgs = self.__mParser.parse_args()
lBusId = int(lArgs['bus_id'], 0)
lAddress = int(lArgs['address'], 0)
lValue = int(lArgs['value'], 0)
lBus = SMBus(lBusId)
try:
if lArgs['cmd'] is None:
lBus.write_byte(lAddress, lValue)
else:
lCommand = int(lArgs['cmd'], 0)
lBus.write_byte_data(lAddress, lCommand, lValue)
except IOError, pExc:
lStatus = "Error writing data: " + str(pExc)
class HTU21D:
def __init__(self, busno):
self.bus = SMBus(busno)
def read_temperature(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR, CMD_TRIG_TEMP_HM, 3)
return -46.85 + 175.72 * (msb * 256 + lsb) / 65536
def read_humidity(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR, CMD_TRIG_HUMID_HM, 3)
return -6 + 125 * (msb * 256 + lsb) / 65536.0
def reset(self):
self.bus.write_byte(I2C_ADDR, CMD_RESET)
class Pcf8574Gpio(object):
BCM = 0
OUT = 0
def __init__(self, busnum, address):
self.bus = SMBus(busnum)
self.address = address
# Set all outputs off
self.bus.write_byte(self.address, 0x00)
# Store P-port state
self.byte = 0x00
def _changebit(self, bit, new_value):
if new_value == 0:
self.byte &= ~(1 << bit)
elif new_value == 1:
self.byte |= (1 << bit)
def output(self, pin, value):
self._changebit(pin, value)
self.bus.write_byte(self.address, self.byte)
def setmode(self, mode):
pass
def setup(self, pin, mode):
pass
def cleanup(self):
# Set all outputs off
self.bus.write_byte(self.address, 0x00)
class Pcf8574Gpio(object):
BCM = 0
OUT = 0
def __init__(self, busnum, address):
self.bus = SMBus(busnum)
self.address = address
# Set all outputs off
self.bus.write_byte(self.address, 0x00)
# Store P-port state
self.byte = 0x00
def _changebit(self, bit, new_value):
if new_value == 0:
self.byte &= ~(1 << bit)
elif new_value == 1:
self.byte |= (1 << bit)
def output(self, pin, value):
self._changebit(pin, value)
self.bus.write_byte(self.address, self.byte)
def setmode(self, mode):
pass
def setup(self, pin, mode):
pass
def cleanup(self):
# Set all outputs off
self.bus.write_byte(self.address, 0x00)
class I2CDevice:
def __init__(self, addr=None, addr_default=None, bus=BUS_NUMBER):
if not addr:
# try autodetect address, else use default if provided
try:
self.addr = 0x3f #int('0x{}'.format(
#findall("[0-9a-z]{2}(?!:)", check_output(['/usr/sbin/i2cdetect', '-y', BUS_NUMBER]))[0]), base=16) \
#if exists('/usr/sbin/i2cdetect') else addr_default
except:
self.addr = addr_default
else:
self.addr = addr
self.bus = SMBus(bus)
# write a single command
def write_cmd(self, cmd):
self.bus.write_byte(self.addr, cmd)
sleep(0.0001)
# write a command and argument
def write_cmd_arg(self, cmd, data):
self.bus.write_byte_data(self.addr, cmd, data)
sleep(0.0001)
# write a block of data
def write_block_data(self, cmd, data):
self.bus.write_block_data(self.addr, cmd, data)
sleep(0.0001)
# read a single byte
def read(self):
return self.bus.read_byte(self.addr)
# read
def read_data(self, cmd):
return self.bus.read_byte_data(self.addr, cmd)
# read a block of data
def read_block_data(self, cmd):
return self.bus.read_block_data(self.addr, cmd)
class TemperatureSensor(object):
def __init__(self):
log.debug("Initialising temperature/humidity sensor")
self.bus = SMBus(1)
self.address = 0x40
self.MEASURE_RELATIVE_TEMPERATURE = 0xE3
self.MEASURE_RELATIVE_HUMIDITY = 0xE5
self.READ_FIRMWARE_VERSION = '\x84\xb8'
def read_firmware_version(self):
self.bus.write_byte(self.address, 0x84)
self.bus.write_byte(self.address, 0xB8)
response = self.bus.read_byte(self.address)
print 'firmware version:', response
# response = self.bus.read_byte_data(self.address,
# 0xB8)
# print 'firmware version:', response
return response
def read_temperature(self):
# Return dummy data for now
# return 20. + random.random()
response = self.bus.read_byte_data(self.address,
self.MEASURE_RELATIVE_TEMPERATURE)
print 'temperature:', response
return response
def read_humidity(self):
# Return dummy data for now
# return random.randint(40, 90)
response = self.bus.read_byte_data(self.address,
self.MEASURE_RELATIVE_HUMIDITY)
print 'humidity:', response
return response
class HSC:
def __init__(self, busno):
self.bus = SMBus(1)
# This function returns the pressure in PSI
def read_pressure(self):
# Trigger the pressure sensor to read data
self.bus.write_byte(I2C_ADDR, 0)
# Read the response
data = self.bus.read_i2c_block_data(I2C_ADDR, 0, 4)
# If the data isn't valid keep polling until it is.
while ((data[0] & 0xC0) == 0x80):
data = self.bus.read_i2c_block_data(I2C_ADDR, 0, 4)
# Combine data bytes
press_raw = (data[0] << 8) + data[1]
# Return the pressure in PSI
return round(((press_raw - 1638) * 1600) / 13107 + 23, 2)
class Si7021(Sensor):
def __init__(self, url):
super().__init__(url)
smbus_num = int(url.netloc)
self.bus = SMBus(smbus_num)
def get_metrics(self):
# SI7021 address, 0x40(64)
# 0xF5(245) Select Relative Humidity NO HOLD master mode
self.bus.write_byte(0x40, 0xF5)
time.sleep(0.3)
# SI7021 address, 0x40(64)
# Read data back, 2 bytes, Humidity MSB first
data0 = self.bus.read_byte(0x40)
data1 = self.bus.read_byte(0x40)
# Convert the data
humidity = ((data0 * 256 + data1) * 125 / 65536.0) - 6
time.sleep(0.3)
# SI7021 address, 0x40(64)
# 0xF3(243) Select temperature NO HOLD master mode
self.bus.write_byte(0x40, 0xF3)
time.sleep(0.3)
# SI7021 address, 0x40(64)
# Read data back, 2 bytes, Temperature MSB first
data0 = self.bus.read_byte(0x40)
data1 = self.bus.read_byte(0x40)
# Convert the data
temp = ((data0 * 256 + data1) * 175.72 / 65536.0) - 46.85
return {'humidity': humidity, 'temperature': temp}
class ArduinoI2C():
"""
Define I2C Interface protocol to arduino pro mini
"""
def __init__(self):
# Set LEGO port for arduino i2c
lego_port = LegoPort(INPUT_4)
lego_port.mode = 'other-i2c'
sleep(0.5)
# Settings for I2C (SMBus(4) for INPUT_2)
self.lego_bus = SMBus(6)
# HTU21D address
self.address = ARDUINO_ADDRESS
def read_arduino(self, command, string_length):
"""
Connect arduino pro send command to read data
"""
while True:
try:
self.lego_bus.write_byte(self.address, command)
break
except:
sleep(0.1)
sleep(0.01)
while True:
try:
block = self.lego_bus.read_i2c_block_data(self.address, 0, string_length)
break
except:
sleep(0.1)
return block
class control:
def echo(self, content):
if (self.debug == True):
print str(content)
def __init__(self, bus=1, addr=0x3f, clearbyte=True, debug=False):
self.debug = debug
self.echo("Debug:" + str(debug))
self.bus = bus
self.addr = addr
self.bus = SMBus(self.bus)
if clearbyte:
self.bus.write_byte(self.addr, 0xff)
self.echo("Sent clear byte")
else:
self.echo("Did not sent clear byte")
def change_state(self, pin):
act_byte = self.bus.read_byte(self.addr)
self.echo("Actual dec:" + str(act_byte))
self.echo("Actual bin:" + str(bin(int(act_byte))))
self.echo("Changing state of " + str(pin))
abin = int(str(bin(int(act_byte)))[2:])
pins = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]
a = 8 - pin
b = a - 1
if (str(abin).zfill(8)[b:a] == "0"):
bbin = int(str(abin).zfill(8)) + pins[pin]
else:
bbin = int(str(abin).zfill(8)) - pins[pin]
self.echo("New bin:" + str(bbin))
self.echo("New dec:" + str(int(str(bbin), 2)))
self.bus.write_byte(self.addr, int(int(str(bbin), 2)))
def range_dist():
sonar=False
lidar_sens=True # lidar sensing True, else EZ4 sonar or VL53L1X
if sonar:
# does not work well on grass
from smbus import SMBus
## i2cbus = SMBus(1)
while True:
try:
i2cbus = SMBus(1)
i2cbus.write_byte(0x70, 0x51)
time.sleep(0.12)
val = i2cbus.read_word_data(0x70, 0xE1)
distance_in_cm=val>>8 | (val & 0x0F)<<8
## print distance_in_cm, 'cm'
print>>f,distance_in_cm,'cm'
msg_sensor(distance_in_cm,25,400), #sonar facing down
except IOError, err:
print err
time.sleep(0.1)
def watering(watering_time):
wet_level = 200 # выставляем уровень влажности почвы, который необходимо достичь при поливе
watering.output = False
addr = 0x48
channel = 0b1000010
bus = SMBus(1)
#datetime.datetime.today().weekday()
while(True):
if (datetime.datetime.now().weekday() == watering_time['weekday'] and datetime.datetime.now().hour == watering_time['acthour']) and watering.output == False:
watering.output = True
bus.write_byte(addr, channel)
value = bus.read_byte(addr)
if 255-value == 0: # начинаем полив только если земля полностью сухая
logging.info("watering is on")
с = 0
while(255-value < wet_level):
if c==3 and 255-value==0:
sendmessage(1)
GPIO.output(9, True) # включаем помпу на 3 секунды
time.sleep(3)
GPIO.output(9, False)# выключаем
time.sleep(10) # ждем пока вода впитается в землю
value = bus.read_byte(addr) # считываем данные с модуля влажности почвы
c+=1
logging.info("watering is off")
sendmessage(0)
else:
logging.warning("the plant is already watered")
sendmessage(2)
if not (watering_time['acthour'] == datetime.datetime.now().hour):
watering.output = False
time.sleep(1*60*10)
class LCD(object):
def __init__(self, address=0x27, bus=1, width=20, rows=4, backlight=True):
self.address = address
self.bus = SMBus(bus)
self.delay = 0.0005
self.rows = rows
self.width = width
self.backlight_status = backlight
self.write(0x33)
self.write(0x32)
self.write(0x06)
self.write(0x0C)
self.write(0x28)
self.write(CLEAR_DISPLAY)
sleep(self.delay)
def _write_byte(self, byte):
self.bus.write_byte(self.address, byte)
self.bus.write_byte(self.address, (byte | ENABLE_BIT))
sleep(self.delay)
self.bus.write_byte(self.address, (byte & ~ENABLE_BIT))
sleep(self.delay)
def write(self, byte, mode=0):
backlight_mode = LCD_BACKLIGHT if self.backlight_status else LCD_NOBACKLIGHT
self._write_byte(mode | (byte & 0xF0) | backlight_mode)
self._write_byte(mode | ((byte << 4) & 0xF0) | backlight_mode)
def text(self, text, line, align='left'):
self.write(LINES.get(line, LINES[1]))
text, other_lines = self.get_text_line(text)
text = getattr(text, ALIGN_FUNC.get(align, 'ljust'))(self.width)
for char in text:
self.write(ord(char), mode=1)
if other_lines and line <= self.rows - 1:
self.text(other_lines, line + 1, align=align)
def backlight(self, turn_on=True):
self.backlight_status = turn_on
self.write(0)
def get_text_line(self, text):
line_break = self.width
if len(text) > self.width:
line_break = text[:self.width + 1].rfind(' ')
if line_break < 0:
line_break = self.width
return text[:line_break], text[line_break:].strip()
def clear(self):
self.write(CLEAR_DISPLAY)
class SHT20():
SOFT_RESET_DELAY = 0.02
TEMPERATURE_DELAY = 0.1
HUMIDITY_DELAY = 0.04
RESOLUTION_12BITS = 0b00000000
RESOLUTION_11BITS = 0b10000001
RESOLUTION_10BITS = 0b10000000
RESOLUTION_8BITS = 0b00000001
def __init__(self, bus=1, resolution=RESOLUTION_12BITS):
self.bus = SMBus(bus)
self._resolution = resolution
self._onchip_heater = _DISABLE_ONCHIP_HEATER
self._otp_reload = _DISABLE_OTP_RELOAD
self.reset()
def reset(self):
try:
self.bus.write_byte(SHT20_I2C, SHT20_RESET)
time.sleep(self.SOFT_RESET_DELAY)
config = self.bus.read_byte_data(SHT20_I2C, SHT20_READ_USER_REG)
config = ((config & _RESERVED_BITMASK) | self._resolution
| self._onchip_heater | self._otp_reload)
#self.bus.write_byte(SHT20_I2C, SHT20_WRITE_USER_REG)
self.bus.write_byte_data(SHT20_I2C, SHT20_WRITE_USER_REG, config)
except Exception as e:
logging.error("Could not initialize SHT20: " + str(e))
async def humidity(self):
self.reset()
self.bus.write_byte(SHT20_I2C, SHT20_HUMID_HM)
time.sleep(self.HUMIDITY_DELAY)
msb, lsb, crc = self.bus.read_i2c_block_data(SHT20_I2C, SHT20_HUMID_HM,
3)
return -6.0 + 125.0 * (msb * 256.0 + lsb) / 65536.0
async def temperature(self):
self.reset()
self.bus.write_byte(SHT20_I2C, SHT20_TEMP_HM)
time.sleep(self.TEMPERATURE_DELAY)
msb, lsb, crc = self.bus.read_i2c_block_data(SHT20_I2C, SHT20_TEMP_HM,
3)
return -46.85 + 175.72 * (msb * 256.0 + lsb) / 65536
class SHT20():
SOFT_RESET_DELAY = 0.02
TEMPERATURE_DELAY = 0.1
HUMIDITY_DELAY = 0.04
RESOLUTION_12BITS = 0b00000000
RESOLUTION_11BITS = 0b10000001
RESOLUTION_10BITS = 0b10000000
RESOLUTION_8BITS = 0b00000001
def __init__(self, bus=3, resolution=RESOLUTION_12BITS):
self.bus = SMBus(bus)
self._resolution = resolution
self._onchip_heater = _DISABLE_ONCHIP_HEATER
self._otp_reload = _DISABLE_OTP_RELOAD
self.bus.write_byte(SHT20_I2C, SHT20_RESET)
time.sleep(self.SOFT_RESET_DELAY)
config = self.bus.read_byte_data(SHT20_I2C, SHT20_READ_USER_REG)
config = ((config & _RESERVED_BITMASK) | self._resolution | self._onchip_heater | self._otp_reload)
#self.bus.write_byte(SHT20_I2C, SHT20_WRITE_USER_REG)
self.bus.write_byte_data(SHT20_I2C, SHT20_WRITE_USER_REG, config)
def humidity(self):
self.bus.write_byte(SHT20_I2C, SHT20_HUMID_HM)
time.sleep(self.HUMIDITY_DELAY)
msb, lsb, crc = self.bus.read_i2c_block_data(SHT20_I2C, SHT20_HUMID_HM, 3)
return -6.0 + 125.0 * (msb * 256.0 + lsb) / 65536.0
def temperature(self):
self.bus.write_byte(SHT20_I2C, SHT20_TEMP_HM)
time.sleep(self.TEMPERATURE_DELAY)
msb, lsb, crc = self.bus.read_i2c_block_data(SHT20_I2C, SHT20_TEMP_HM, 3)
return -46.85 + 175.72 * (msb * 256.0 + lsb) / 65536
def temperature_f(self):
return (self.temperature * 1.8 + 32)
def connected(self):
retval = self.bus.read_byte_data(SHT20_I2C, SHT20_READ_USER_REG)
if retval != 0xFF:
return True
else:
return False
class TCA9548A:
def __init__(self, bus=1, addr=0x70):
self._addr = addr
self._bus = SMBus(bus=bus)
def use_channel(self, ch):
"""If ch is in {0..7}, select channel ch; if ch is None, deselect all channels."""
if ch is None:
# Deselect all/any channel
self._bus.write_byte(self._addr, 0)
return
if ch not in range(8):
raise ValueError('Channel must be one of {0,1,2,3,4,5,6,7}')
self._bus.write_byte(self._addr, 1 << ch)
# the mux allows fan-out/fan-in. use at own risk
def use_channel_combo(self, chs):
self._bus.write_byte(self._addr, chs)
class sgh_PCF8591P:
# Constructor
def __init__(self, busNum):
#print "init PCF8591"
if busNum == 0:
self.__bus = SMBus(0) # on a Rev 1 board
#print "bus 0"
else:
self.__bus = SMBus(1) # on a Rev 2 board
self.__addr = self.__checkI2Caddress(0x48)
self.__DACEnabled = 0x00
#print self.readADC() # dummy call to raise exception if no chip present on the i2c bus
#print "PCF8591 init completed"
# self.__bus = __i2cBus
# self.__addr = self.__checkI2Caddress(__addr)
# self.__DACEnabled = 0x00
# i2c = SMBus(0) # on a Rev 1 board
# # i2c = SMBus(1) # if on a Rev 2 board
# # Create a PCF8591P object
# sensor = PCF8591P(i2c, 0x48)
# Read single ADC Channel
def readADC(self, __chan = 0):
__checkedChan = self.__checkChannelNo(__chan)
self.__bus.write_byte(self.__addr, 0x40 | __checkedChan & 0x03) # mod my Max - says it more reliable
# self.__bus.write_byte(self.__addr, __checkedChan | self.__DACEnabled)
__reading = self.__bus.read_byte(self.__addr) # seems to need to throw away first reading
__reading = self.__bus.read_byte(self.__addr) # read A/D
return __reading
# Read all ADC channels
def readAllADC(self):
__readings = []
self.__bus.write_byte(self.__addr, 0x04 | self.__DACEnabled)
__reading = self.__bus.read_byte(self.__addr) # seems to need to throw away first reading
for i in range (4):
__readings.append(self.__bus.read_byte(self.__addr)) # read ADC
return __readings
# Set DAC value and enable output
def writeDAC(self, __val=0):
__checkedVal = self.__checkDACVal(__val)
self.__DACEnabled = 0x40
self.__bus.write_byte_data(self.__addr, self.__DACEnabled, __checkedVal)
# Enable DAC output
def enableDAC(self):
self.__DACEnabled = 0x40
self.__bus.write_byte(self.__addr, self.__DACEnabled)
# Disable DAC output
def disableDAC(self):
self.__DACEnabled = 0x00
self.__bus.write_byte(self.__addr, self.__DACEnabled)
# Check I2C address is within bounds
def __checkI2Caddress(self, __addr):
if type(__addr) is not int:
raise I2CaddressOutOfBoundsError
elif (__addr < 0):
raise I2CaddressOutOfBoundsError
elif (__addr > 127):
raise I2CaddressOutOfBoundsError
return __addr
# Check if ADC channel number is within bounds
def __checkChannelNo(self, __chan):
if type(__chan) is not int:
raise PCF8591PchannelOutOfBoundsError
elif (__chan < 0):
raise PCF8591PchannelOutOfBoundsError
elif (__chan > 3):
raise PCF8591PchannelOutOfBoundsError
return __chan
# Check if DAC output value is within bounds
def __checkDACVal(self, __val):
if type(__val) is not int:
raise PCF8591PDACvalueOutOfBoundsError
elif (__val < 0):
raise PCF8591PDACvalueOutOfBoundsError
elif (__val > 255):
raise PCF8591PDACvalueOutOfBoundsError
return __val
from smbus import SMBus
addr = 8
bus = SMBus(1)
bus.write_byte(addr, 1)
input("press return to exit")
bus.write_byte(addr, 0)
import sys
import serial
import struct
from smbus import SMBus
from time import sleep
from icsp import *
sel = sys.argv[1] if len(sys.argv) > 1 else "N"
i2c0 = SMBus(0)
i2c2 = SMBus(2)
if sel == "A": # toggle A_!RST
print("selecting RFW [bus A] ...")
i2c2.write_byte(0x70, 0x5) # steer mux
ioa = i2c0.read_byte_data(0x23, 0x14)
i2c0.write_byte_data(0x23, 0x14, ioa&~0x10)
i2c0.write_byte_data(0x23, 0x14, ioa|0x10)
elif sel == "B": # toggle B_!RST
print("selecting RFE [bus B] ...")
i2c2.write_byte(0x70, 0x4) # steer mux
iob = i2c0.read_byte_data(0x22, 0x14)
i2c0.write_byte_data(0x22, 0x14, iob&~0x10)
i2c0.write_byte_data(0x22, 0x14, iob|0x10)
elif sel == "N":
print("disabling MUX ...")
i2c2.write_byte(0x70, 0x0) # disable mux
# Raspberry Pi Master for Arduino Slave
# i2c_master_pi.py
# Connects to Arduino via I2C
# DroneBot Workshop 2019
# https://dronebotworkshop.com
from smbus import SMBus
from time import sleep
addr_list = [0x8, 0x9] # adresses des temoins
bus = SMBus(1) # indicates /dev/ic2-1
print(F"Start!")
limit = 0
while limit < 8:
for addr in addr_list:
print(F"{addr}")
bus.write_byte(addr, 0x1)
sleep(1)
bus.write_byte(addr, 0x0)
sleep(1)
limit += 1
class LCD(object):
PCF8574T_addr = 0x27
RS = 0
RW = 1
E = 2
BL = 3
DB4 = 4
DB5 = 5
DB6 = 6
DB7 = 7
def __init__(self,bus=1,address=0x27):
self._bus = SMBus(bus)
self._state = 0
self.PCF8574T_addr = address
self.backlight(True)
self.clear_RW() # write
self.clear_RS() # instruction
# 4-bit mode
self.set_E()
self.setbit(self.DB5)
self.setbit(self.DB4)
time.sleep(0.001)
self.clear_E()
time.sleep(0.01)
self.set_E()
self.setbit(self.DB5)
self.setbit(self.DB4)
time.sleep(0.001)
self.clear_E()
time.sleep(0.01)
self.set_E()
self.setbit(self.DB5)
self.setbit(self.DB4)
time.sleep(0.001)
self.clear_E()
time.sleep(0.01)
self.set_E()
self.setbit(self.DB5)
self.clearbit(self.DB4)
time.sleep(0.001)
self.clear_E()
time.sleep(0.01)
# 4-bit mode, continue
self.sendbyte(0b00101000)
time.sleep(0.005)
self.clear()
self.home()
# cursor direction... the default is good.
#self.sendbyte(0b00000111)
# turn ON display; turn OFF cursor and blink
self.sendbyte(0b00001100)
def write_lines(self,lines):
while len(lines) < 4:
lines.append([])
for line in [lines[k] for k in (0,2,1,3)]:
self.write_str(line)
if len(line) < 20:
self.write_str(' '*(20 - len(line)))
def write_str(self,s):
for c in s:
self.write_char(c)
def write_char(self,c):
self.set_RS()
self.sendbyte(ord(c))
def clear(self):
self.clear_RS()
self.sendbyte(1)
#self.set_RS()
time.sleep(0.005)
def home(self):
self.clear_RS()
self.sendbyte(2)
#self.set_RS()
time.sleep(0.005)
def sendbyte(self,byte):
#print bin(self._state)
self.set_E()
self._state = (byte & 0xF0) | (self._state & 0x0F)
self._bus.write_byte(self.PCF8574T_addr,self._state)
self.clear_E()
self.set_E()
self._state = (self._state & 0x0F) | ((byte & 0x0F) << 4)
self._bus.write_byte(self.PCF8574T_addr,self._state)
self.clear_E()
#def writebyte(self,byte):
#self._bus.write_byte(self.PCF8574T_addr,byte)
# don't do this - it changes the other nibble as well
def backlight(self,b):
if b:
self.setbit(self.BL)
else:
self.clearbit(self.BL)
def setbit(self,bit):
self._state = self._state | 1 << bit
self._bus.write_byte(self.PCF8574T_addr,self._state)
def clearbit(self,bit):
self._state = self._state & (255 - (1 << bit))
self._bus.write_byte(self.PCF8574T_addr,self._state)
def set_RS(self):
self.setbit(self.RS)
def clear_RS(self):
self.clearbit(self.RS)
def set_RW(self):
self.setbit(self.RW)
def clear_RW(self):
self.clearbit(self.RW)
def set_E(self):
self.setbit(self.E)
def clear_E(self):
self.clearbit(self.E)
dir_pin = y_dir_pin
if axis == 1:
step_pin = x_step_pin
dir_pin = x_dir_pin
print('joy_x',joy_x,'joy_y',joy_y,'button_c',button_c,'button_z',button_z)
GPIO.output(dir_pin, direction)
GPIO.output(led_pin, True)
GPIO.output(step_pin, True)
sleep(speed)
GPIO.output(led_pin, False)
GPIO.output(step_pin, False)
sleep(speed)
while 1:
bus.write_byte(0x52,0x00)
sleep(0.000001)
data = []
for i in xrange(6):
data.append(bus.read_byte(0x52))
joy_x = data[0] -121
joy_y = data[1] -112
if (joy_y > 119): joy_y = -90
accel_x = (data[2] << 2) + ((data[5] & 0x0c) >> 2)
accel_y = (data[3] << 2) + ((data[5] & 0x30) >> 4)
accel_z = (data[4] << 2) + ((data[5] & 0xc0) >> 6)
button_c = (data[5] & 0x1) ^ ((data[5] & 0x2) >> 1)
button_z = (data[5] & 0x1) ^ 1
class I2C(object):
""" Class to set up and access I2C devices.
"""
##
## Class methods
##
## Private methods
def __init__(self, busId = 1):
""" Initialize the I2C bus. """
self._i2c = SMBus(busId)
def __del__(self):
""" Clean up routines. """
try:
# Remove SMBus connection
del(self._i2c)
except:
pass
def _combineLoHi(self, loByte, hiByte):
""" Combine low and high bytes to an unsigned 16 bit value. """
return (loByte | hiByte << 8)
def _combineSignedLoHi(self, loByte, hiByte):
""" Combine low and high bytes to a signed 16 bit value. """
combined = self._combineLoHi (loByte, hiByte)
return combined if combined < 32768 else (combined - 65536)
def _combineXLoLoHi(self, xloByte, loByte, hiByte):
""" Combine extra low, low, and high bytes to an unsigned 24 bit
value.
"""
return (xloByte | loByte << 8 | hiByte << 16)
def _combineSignedXLoLoHi(self, xloByte, loByte, hiByte):
""" Combine extra low, low, and high bytes to a signed 24 bit
value.
"""
combined = self._combineXLoLoHi(xloByte, loByte, hiByte)
return combined if combined < 8388608 else (combined - 16777216)
def _getSensorRawLoHi1(self, address, outRegs):
""" Return a scalar representing the combined raw signed 16 bit
value of the output registers of a one-dimensional sensor,
e.g. temperature.
'address' is the I2C slave address.
'outRegs' is a list of the output registers to read.
"""
# Read register outputs and combine low and high byte values
xl = self._readRegister(address, outRegs[0])
xh = self._readRegister(address, outRegs[1])
xVal = self._combineSignedLoHi(xl, xh)
# Return the scalar
return xVal
def _getSensorRawXLoLoHi1(self, address, outRegs):
""" Return a scalar representing the combined raw signed 24 bit
value of the output registers of a one-dimensional sensor,
e.g. temperature.
'address' is the I2C slave address.
'outRegs' is a list of the output registers to read.
"""
# Read register outputs and combine low and high byte values
xxl = self._readRegister(address, outRegs[0])
xl = self._readRegister(address, outRegs[1])
xh = self._readRegister(address, outRegs[2])
xVal = self._combineSignedXLoLoHi(xxl, xl, xh)
# Return the scalar
return xVal
def _getSensorRawLoHi3(self, address, outRegs):
""" Return a vector (i.e. list) representing the combined
raw signed 16 bit values of the output registers of a
3-dimensional (IMU) sensor.
'address' is the I2C slave address.
'outRegs' is a list of the output registers to read.
"""
# Read register outputs and combine low and high byte values
xl = self._readRegister(address, outRegs[0])
xh = self._readRegister(address, outRegs[1])
yl = self._readRegister(address, outRegs[2])
yh = self._readRegister(address, outRegs[3])
zl = self._readRegister(address, outRegs[4])
zh = self._readRegister(address, outRegs[5])
xVal = self._combineSignedLoHi(xl, xh)
yVal = self._combineSignedLoHi(yl, yh)
zVal = self._combineSignedLoHi(zl, zh)
# Return the vector
return [xVal, yVal, zVal]
def _readRegister(self, address, register):
""" Read a single I2C register. """
return self._i2c.read_byte_data(address, register)
def _readRegisters(self, address, register, count):
""" Read (up to 32) 'count' consecutive I2C registers. """
return self._i2c.read_i2c_block_data(address, register, count)
def _read(self, address):
""" Read a single byte from the I2C device without specifying a
register.
"""
return self._i2c.read_byte(address)
def _writeRegister(self, address, register, value):
""" Write a single byte to a I2C register. Return the value the
register had before the write.
"""
valueOld = self._readRegister(address, register)
self._i2c.write_byte_data(address, register, value)
return valueOld
def _write(self, address, value):
""" Write a single byte to the I2C device without specifying a
register.
"""
return self._i2c.write_byte(address, value)
def _testRegister(self, address, register):
""" Check, if a I2C register is readable/accessible. """
try:
return self._readRegister(address, register)
except:
return -1
class SHT21 :
RHmeasure_noHold = 0xF5
Tmeasure_noHold = 0xF3
RHmeasure_Hold = 0xE5
Tmeasure_Hold = 0xE3
Soft_Reset = 0xFE
Write_Reg = 0xE6
Read_Reg = 0xE7
##############################################################################
## Experimental register found by looking for each one individually ##
## with a 10 seconds wait between each try. CheckCRC says true for all. ##
RH_Reg = 0x05 ##
T_Reg = 0x03 ##
## read_reg? 0x06 ##
## read_reg 0x07 ##
## unknown 0x09 result was 6,0,90(constant over time) ##
## unknown 0x0F result was 2,68,32(constant over time) ##
## serial number? 0x1A periodic on 64 bits? ##
## result was [25, 203, 218, 223, 71, 170, 137, 242, 217, 140, 232 ##
## , 120, 231, 86, 128, 122, 7, 151, 248, 59, 252, 255, ##
## 232, 120, 54, 99, 129, 75, 30, 92, 80, 126] ##
## serial number? 0x1B same as 0x1A with random shift ##
## T_reg? 0xE3 result was 103,88,60(made a new measure?) ##
## RH_reg? 0xE5 result was 83,206,146(new measure?) ##
## read_reg 0xE6 result was 58,30 ##
## read_reg 0xE7 result was 58,30 ##
## unknown 0xE9 result was 6,0,90 ##
## unknown 0xEF result was 2,68,32 ##
## serial number 0xFA same as 1A, check sensirion(says 64 bits ID)##
## serial number? 0xFB same as 1B ##
## device ID? 0xFF check i2c full specs, results seems random ##
############################1#################################################
class CRCError(Exception):
pass
def __init__(self, addr, busnum = 1) :
self.address = addr
self.bus = SMBus(busnum)
#self.bus.open(busnum)
self.Reset()
#reg = self.ReadReg()
reg = 0
if (reg & 0x80) and (reg & 0x01):
self.RH_res = 11
self.T_res = 11
elif (reg & 0x80) and not(reg & 0x01):
self.RH_res = 10
self.T_res = 13
elif not(reg & 0x80) and not(reg & 0x01):
self.RH_res = 12
self.T_res = 14
else:
self.RH_res = 8
self.T_res = 12
def getRH(self):
self.bus.write_byte(self.address, self.RHmeasure_noHold)
time.sleep(0.1)
RH = self.bus.read_i2c_block_data(self.address, self.RH_Reg, 3)
#print RH
if self.CheckCRC(RH):
self.RHum = RH
RH[1] &= ~0x03 #reset 2 status bits(LSB)
return -6+125.*(RH[0]*256+RH[1])/65536.
else:
#print 'CRC checksum failed, data was corrupted(RH reading)'
#return -1
raise self.CRCError
def getT(self):
self.bus.write_byte(self.address, self.Tmeasure_noHold)
time.sleep(0.1)
T = self.bus.read_i2c_block_data(self.address, self.T_Reg, 3)
#print T
if self.CheckCRC(T):
self.Temp = T
T[1] &= ~0x03 #reset 2 status bits(LSB)
return -46.85+175.72*(T[0]*256+T[1])/65536.
else:
#print 'CRC checksum failed, data was corrupted(temp reading)'
#return -1
raise self.CRCError
def Reset(self):
self.bus.write_byte(self.address, self.Soft_Reset)
time.sleep(0.02) #must wait 15ms
def ReadReg(self):
reg = self.bus.read_word_data(self.address, self.Read_Reg)
crc = [ reg & 0xFF, (reg & 0xFF00) >> 8]
if self.CheckCRC(crc):
return reg & 0xFF
else:
#print 'Error : CRC not matching !'
#return 0
raise self.CRCError
def WriteReg(self, val):
reg = self.ReadReg()
reg &= 0x38
self.bus.write_byte_data(self.address, self.Write_Reg, val)
def test(self):
self.T = []
self.getRH()
self.getT()
for i in range(256):
try :
time.sleep(10)
self.T.append((hex(i), self.bus.read_i2c_block_data(sensor.address, i)))
print(hex(i), 'success reading')
except IOError as err:
print(hex(i), 'failed reading')
return self.T
def CheckCRC(self, buf):
poly = 0x131
crc = 0
#print buf[2]
for by in buf:
crc ^= by
for i in range(8):
if crc & 0x80 :
crc = (crc << 1)^poly
else:
crc <<= 1
#print crc
return crc==0
class LinuxI2cBus:
"""A Linux I²C device, which is itself an I²C bus.
Should not be instantiated directly; use `LinuxI2c.find_devices`
instead.
This type mimics the `smbus.SMBus` read/write/close APIs. However,
`open` does not take any parameters, and not all APIs are available.
"""
# note: this is not a liquidctl BaseBus, as that would cause
# find_liquidctl_devices to try to directly instantiate it
def __init__(self, i2c_dev):
self._i2c_dev = i2c_dev
self._smbus = None
try:
assert i2c_dev.name.startswith('i2c-')
self._number = int(i2c_dev.name[4:])
except:
raise ValueError(f'cannot infer bus number')
def find_devices(self, drivers, **kwargs):
"""Probe drivers and find compatible devices in this bus."""
for drv in drivers:
yield from drv.probe(self, **kwargs)
def open(self):
"""Open the I²C bus."""
if not self._smbus:
try:
self._smbus = SMBus(self._number)
except FileNotFoundError:
if Path('/sys/class/i2c-dev').exists():
raise
raise OSError('kernel module i2c-dev not loaded') from None
def read_byte(self, address):
"""Read a single byte from a device."""
value = self._smbus.read_byte(address)
_LOGGER.debug('read byte @ 0x%02x: 0x%02x', address, value)
return value
def read_byte_data(self, address, register):
"""Read a single byte from a designated register."""
value = self._smbus.read_byte_data(address, register)
_LOGGER.debug('read byte data @ 0x%02x:0x%02x: 0x%02x', address,
register, value)
return value
def read_word_data(self, address, register):
"""Read a single 2-byte word from a given register."""
value = self._smbus.read_word_data(address, register)
_LOGGER.debug('read word data @ 0x%02x:0x%02x: 0x%04x', address,
register, value)
return value
def read_block_data(self, address, register):
"""Read a block of up to 32 bytes from a given register."""
data = self._smbus.read_block_data(address, register)
_LOGGER.debug('read block data @ 0x%02x:0x%02x: %r', address,
register, LazyHexRepr(data))
return data
def write_byte(self, address, value):
"""Write a single byte to a device."""
_LOGGER.debug('writing byte @ 0x%02x: 0x%02x', address, value)
return self._smbus.write_byte(address, value)
def write_byte_data(self, address, register, value):
"""Write a single byte to a designated register."""
_LOGGER.debug('writing byte data @ 0x%02x:0x%02x: 0x%02x', address,
register, value)
return self._smbus.write_byte_data(address, register, value)
def write_word_data(self, address, register, value):
"""Write a single 2-byte word to a designated register."""
_LOGGER.debug('writing word data @ 0x%02x:0x%02x: 0x%04x', address,
register, value)
return self._smbus.write_word_data(address, register, value)
def write_block_data(self, address, register, data):
"""Write a block of byte data to a given register."""
_LOGGER.debug('writing block data @ 0x%02x:0x%02x: %r', address,
register, LazyHexRepr(data))
return self._smbus.write_block_data(address, register, data)
def close(self):
"""Close the I²C connection."""
if self._smbus:
self._smbus.close()
self._smbus = None
def load_eeprom(self, address):
"""Return EEPROM name and data in `address`, or None if N/A."""
# uses kernel facilities to avoid directly reading from the EEPROM
# or managing its pages, also avoiding the need for unsafe=smbus
dev = f'{self._number}-{address:04x}'
try:
name = self._i2c_dev.joinpath(dev, 'name').read_text().strip()
eeprom = self._i2c_dev.joinpath(dev, 'eeprom').read_bytes()
return LinuxEeprom(name, eeprom)
except Exception as err:
return None
@property
def name(self):
return self._i2c_dev.name
@property
def description(self):
return self._try_sysfs_read('name')
@property
def parent_vendor(self):
return self._try_sysfs_read_hex('device/vendor')
@property
def parent_device(self):
return self._try_sysfs_read_hex('device/device')
@property
def parent_subsystem_vendor(self):
return self._try_sysfs_read_hex('device/subsystem_vendor')
@property
def parent_subsystem_device(self):
return self._try_sysfs_read_hex('device/subsystem_device')
@property
def parent_driver(self):
try:
return Path(
os.readlink(self._i2c_dev.joinpath('device/driver'))).name
except FileNotFoundError:
return None
def __str__(self):
if self.description:
return f'{self.name}: {self.description}'
return self.name
def __repr__(self):
def hexid(maybe):
if maybe is not None:
return f'{maybe:#06x}'
return 'None'
return f'{self.__class__.__name__}: name: {self.name!r}, ' \
f'description: {self.description!r}, ' \
f'parent_vendor: {hexid(self.parent_vendor)}, ' \
f'parent_device: {hexid(self.parent_device)}, ' \
f'parent_subsystem_vendor: {hexid(self.parent_subsystem_vendor)}, ' \
f'parent_subsystem_device: {hexid(self.parent_subsystem_device)}, ' \
f'parent_driver: {self.parent_driver!r}'
def _try_sysfs_read(self, *sub, default=None):
try:
return self._i2c_dev.joinpath(*sub).read_text().rstrip()
except FileNotFoundError:
return default
def _try_sysfs_read_hex(self, *sub, default=None):
try:
return int(self._i2c_dev.joinpath(*sub).read_text(), base=16)
except FileNotFoundError:
return default
deg = u'\N{DEGREE SIGN}'
# sqlite config
# CREATE TABLE temp_humidity(id INTEGER primary key, datetime DATETIME DEFAULT CURRENT_TIMESTAMP, temp_c REAL NOT NULL, temp_f REAL NOT NULL, humidity INTEGER NOT NULL);
sqliteCon = sqlite.connect(dbPath)
# Main loop
while True:
# Get the current system date and time
datetime = time.strftime('%m/%d/%Y %H:%M:%S')
# Read data from sensor
bus.write_byte(ADDR, 0x00)
ans = bus.read_i2c_block_data(ADDR, 0x00, 4)
# Convert to human readable humdidity
humidity = ((ans[0] & 0x3f) << 8) + ans[1]
humidity = humidity * float('6.10e-3')
humidity = '{:.0f}'.format(humidity)
# Convert to human readable temperature
tempC = (ans[2] << 8) + ans[3]
tempC = tempC >> 2
tempC = (tempC * float('1.007e-2')) - 40
tempF = (tempC * 1.8) + 32
#insert into SQLITE database
cursor = sqliteCon.cursor()
# -*- encoding: latin-1 -*-
# Dette program læser analog input fra PCF8591P chipens kanal #0.
from smbus import SMBus
from time import sleep
# Opret forbindelse til enheden(chipen).
bus = SMBus(1) # 1 Indikere at vi bruger enhedsfilen /dev/i2c-1.
# Addressen på chipen.
addresse = 74
# Referencespænding.
Vref = 4.25
konvateret = Vref / 256
print("Læs kanal 0 fra A/D.")
print("Udskriver aflæsningen når den forandres.")
print("Tryk CTRL+C for at stoppe.")
bus.write_byte(addresse, 0) # 0 Indikere at vi vil have data fra kanal 0.
sidste_aflaesning = -1
# Start en uendelig løkke og afbryd hvis ctrl+c bliver trykket.
while True:
aflaesning = bus.read_byte(addresse)
if (abs(sidste_aflaesning - aflaesning) > 1 ):
print "A/D læsning ", aflaesning, " som betyder ", round(konvateret * aflaesning, 2), " V."
sidste_aflaesning = aflaesning
sleep(0.01)
class Nunchuk(object): """ Créait un objet "Nunchuk" qui gére l'acquisition des données de la manette nunchuk. """ def __init__(self): """ Initialise la manette nunchuk. """ self.bus = SMBus(1) self.bus.write_byte_data(0x52,0x40,0x00) sleep(0.1) def read(self): """ Renvoi les informations de la manette. Returns: int[] -- Tableau des différentes informations de la manette. [0]: Position du joystick sur l'axe horizontal. [1]: Position du joystick sur l'axe vertical. [2]: Axe X de l'accelerometre de la manette. [3]: Axe Y de l'accelerometre de la manette. [4]: Axe Z de l'accelerometre de la manette. [5]: État des boutons de la manette. """ self.bus.write_byte(0x52,0x00) sleep(0.0001) temp = [(0x17 + (0x17 ^ self.bus.read_byte(0x52))) for i in range(6)] return temp def getJoystickPosition(self): """ Renvoi la position du joystick de la manette. Returns: int[] -- Tableau des position du joystick de la manette. [0]: Position du joystick sur l'axe horizontal. [1]: Position du joystick sur l'axe vertical. """ data = self.read() return data[0],data[1] def getAccelerometerAxis(self): """ Renvoi les trois axes de l'accelerometre de la manette. Returns: int[] -- Tableau des trois axes de l'accelerometre de la manette. [0]: Axe X de l'accelerometre de la manette. [1]: Axe Y de l'accelerometre de la manette. [2]: Axe Z de l'accelerometre de la manette. """ x = 0 y = 0 z = 0 stability = 5 for i in range(stability): data = self.read() x+=data[2] y+=data[3] z+=data[4] return x/stability,y/stability,z/stability def getButtons(self): """ Renvoi les état des boutons de la manette. Returns: int[] -- Tableau des états des boutons de la manette. [0]: État du bouton "C". [1]: État du bouton "Z". """ data = self.read() butc = (data[5] & 0x02) butz = (data[5] & 0x01) return butc == 0,butz == 0
class SHT21:
"""Class to read temperature and humidity from SHT21"""
## Control constants
_SOFTRESET = 0xFE
_SLAVE_ADDRESS = 0x40
_TRIGGER_TEMPERATURE_NO_HOLD = 0xF3
_TRIGGER_HUMIDITY_NO_HOLD = 0xF5
_STATUS_BITS_MASK = 0xFFFC
# Wait a bit more than recommended
_TEMPERATURE_WAIT_TIME = 0.086 # (datasheet: typ=66, max=85)
_HUMIDITY_WAIT_TIME = 0.030 # (datasheet: typ=22, max=29)
def __init__(self, device_number = 1):
"""Opens the i2c device (assuming that the kernel modules have been
loaded) & run soft reset. (user register leaved to default value)"""
self.bus = SMBus(device_number)
self.bus.write_byte(self._SLAVE_ADDRESS, self._SOFTRESET)
time.sleep(0.015)
if DEBUG:
print("SHT21 init done.")
def getTemperature(self):
"""Reads the temperature from the sensor. Not that this call blocks
for ~86ms to allow the sensor to return the data """
self.bus.write_byte(self._SLAVE_ADDRESS, self._TRIGGER_TEMPERATURE_NO_HOLD)
data = []
time.sleep(self._TEMPERATURE_WAIT_TIME)
data.append(self.bus.read_byte(self._SLAVE_ADDRESS))
data.append(self.bus.read_byte(self._SLAVE_ADDRESS))
Temperature = self._get_temperature_from_buffer(data)
if DEBUG:
print("Temp[C] = ", Temperature)
return Temperature
def getHumidity(self):
"""Reads the humidity from the sensor. Not that this call blocks
for ~30ms to allow the sensor to return the data"""
self.bus.write_byte(self._SLAVE_ADDRESS, self._TRIGGER_HUMIDITY_NO_HOLD)
data = []
time.sleep(self._HUMIDITY_WAIT_TIME)
data.append(self.bus.read_byte(self._SLAVE_ADDRESS))
data.append(self.bus.read_byte(self._SLAVE_ADDRESS))
Humidity = self._get_humidity_from_buffer(data)
if DEBUG:
print("Humidity[%] = ", Humidity)
return Humidity
@staticmethod
def _get_temperature_from_buffer(data):
"""This function reads the first two bytes of data and
returns the temperature in C by using the following function:
T = =46.82 + (172.72 * (ST/2^16))where ST is the value from the sensor """
unadjusted = ((data[0]) << 8) + (data[1])
unadjusted &= SHT21._STATUS_BITS_MASK # zero the status bits
unadjusted *= 175.72
unadjusted /= 1 << 16 # divide by 2^16
unadjusted -= 46.85
return unadjusted
@staticmethod
def _get_humidity_from_buffer(data):
"""This function reads the first two bytes of data and returns
the relative humidity in percent by using the following function:
RH = -6 + (125 * (SRH / 2 ^16)) where SRH is the value read from the sensor """
unadjusted = (data[0] << 8) + data[1]
unadjusted &= SHT21._STATUS_BITS_MASK # zero the status bits
unadjusted *= 125.0
unadjusted /= 1 << 16 # divide by 2^16
unadjusted -= 6
return unadjusted
@staticmethod
def _calculate_checksum(data, number_of_bytes):
"""5.7 CRC Checksum using the polynomial given in the datasheet"""
# CRC
POLYNOMIAL = 0x131 # //P(x)=x^8+x^5+x^4+1 = 100110001
crc = 0
# calculates 8-Bit checksum with given polynomial
for byteCtr in range(number_of_bytes):
crc ^= (data[byteCtr])
for bit in range(8, 0, -1):
if crc & 0x80:
crc = (crc << 1) ^ POLYNOMIAL
else:
crc = (crc << 1)
return crc
from smbus import SMBus
addr = 0x8 # bus address
bus = SMBus(1) # indicates /dev/ic2-1
bus.write_byte(addr, 0x1) # switch it on
input("Press return to exit")
bus.write_byte(addr, 0x0) # switch it on
# Button to terminate
from smbus import SMBus
import sys
import time
from Disp4tronix import Disp4tronix
from ButtonLib import *
def myButtonListener(event):
global isRunning
isRunning = False
i2c_address = 0x48
dp = Disp4tronix()
print "starting"
channel = 0
bus = SMBus(1) # For revision 2 Raspberry Pi
bus.write_byte(i2c_address, channel) # set control register
addButtonListener(myButtonListener)
data_old = -1
isRunning = True
while isRunning:
data = bus.read_byte(i2c_address)
if data != data_old:
dp.showText("%4d" %data) # right adjusted
data_old = data
time.sleep(0.1) # needed because multiplexed display uses processing power!!
dp.showText("donE")
time.sleep(3)
dp.clear() # needed to stop the display thread
class Board:
# Methods list
# * __init__(gpio_en, gpio_stby, i2cbus = None, gpio_mode_bcm = False)
# * power(on = None)
# * reset()
# * mute(on = None)
# Constants list
# * DSP - holding instance of DSP control class
# * TUNER - holding instance of TUNER control class
# Internal variables list
# * _gpio_en - GPIO pin connected to the EN pin of the board
# * _gpio_stby - GPIO pin connected to the ST-BY pin of the board
# * _bus - holding instance of SMBus providing I2C bus for communication with chips on the board
# * _state - dictionary holding current setup of the board
#*
#* Inits class
#* @param int gpio_en - GPIO pin connected to the EN pin of board
#* @param int gpio_stby - GPIO pin connected to the ST-BY pin of board
#* @param int i2cbus - number of i2c bus the board is connected to
#* @param bool gpio_mode_bcm - if the mode of GPIO module used for specifying GPIO pins is BCM (True) or BOARD (False)
#*
def __init__(self, gpio_en, gpio_stby, i2cbus = None, gpio_mode_bcm = False):
if i2cbus == None:
raise Exception()#TODO auto selection based on RPI board revision
self._gpio_en = gpio_en
self._gpio_stby = gpio_stby
self._bus = SMBus(i2cbus)
sleep(0.5)
GPIO.setmode(GPIO.BCM if gpio_mode_bcm else GPIO.BOARD)
GPIO.setup(self._gpio_en, GPIO.OUT, GPIO.LOW)
GPIO.setup(self._gpio_stby, GPIO.OUT, GPIO.LOW)
self._state = {
"power": False,
"mute": True
}
self.DSP = DSP(self)
self.TUNER = TUNER(self)
# init GPIOs
self.power(False)
self.mute(True)
# end of method __init__
#*
#* Destructor
#*
def __del__(self):
self.power(False)
GPIO.cleanup()
# end of method __del__
#*
#* Turns on-board voltage regulators on or off
#* @param bool on - True/False for setting the power state, None to return current state only
#* @return bool - if the voltage regulators are on or off (software only)
#*
def power(self, on = None):
if on != None:
old_state = self._state["power"]
self._state["power"] = bool(on)
if not self._state["power"]:
self.mute(True)
self.DSP.beforePowerOff()
self.TUNER.beforePowerOff()
sleep(0.2)
GPIO.output(self._gpio_en, self._state["power"])
if not old_state and self._state["power"]:
sleep(0.5)
self.DSP.afterPowerOn()
self.TUNER.afterPowerOn()
return self._state["power"]
# end of method power
#*
#* Resets board by turning it off and then on after 2 seconds
#*
def reset(self):
self.power(False)
sleep(2)
self.power(True)
# end of method reset
#*
#* Enables or disables amplifier stand-by mode
#* @param bool on - True/False for setting the mute, None to return current state only
#* @return bool - if the amplifier is muted or not (software only)
#*
def mute(self, on = None):
if on != None:
on = bool(on)
if self._state["power"] or on:
self._state["mute"] = on
GPIO.output(self._gpio_stby, not self._state["mute"])
return self._state["mute"]
# end of method mute
#*
#* Send data over I2C if the Board is powered on
#* @param int address - address byte
#* @param tuple/list data - data bytes to be sent
#*
def _i2c_write(self, address, data):
if address < 0 or len(data) < 1:
return
if not self._state["power"]:# send data to board but only if it is powered
return
if len(data) > 1:
self._bus.write_i2c_block_data(address, data[0], data[1:])
else:
self._bus.write_byte(address, data[0])
import optparse
from smbus import SMBus
import time
#######################
# Get options
#######################
parser = optparse.OptionParser("usage: %prog [options] <decimal to write>")
#parser.add_option ('-a', dest='address', type='string',
# default = '70',
# help="Hex value of address of i2c device.")
options, args = parser.parse_args()
if len(args) != 1:
print "Please specify decimal integer to write via i2c"
sys.exit()
byteToWrite = int(args[0])
#######################
bus = SMBus(1)
address = 0x70
print bus.read_byte(address)
bus.write_byte(address, byteToWrite)
print bus.read_byte(address)
from smbus import SMBus
addr = 0x04
bus = SMBus(1)
while True:
k = input()
bus.write_byte(addr, (int)(k))
print(bus.read_byte(addr))
#referenced :https://www.thegeekpub.com/18263/raspberry-pi-to-arduino-i2c-communication/
import RPi.GPIO as GPIO
from smbus import SMBus
address = 0x8 #bus address
bus = SMBus(1) #indicates /dev/i2c-1
print("Type 1 for led to ON and 0 to OFF")
try:
while True:
value = input("Value : ")
if value == "1":
bus.write_byte(address, 0x1) #switch on
elif value == "0":
bus.write_byte(address, 0x0) #switch off
except KeyboardInterrupt:
GPIO.cleanup()
class MS5611:
"""Driver for reading temperature/pressure MS5611 Pressure Sensor."""
def __init__(self, bus = 1, i2c = 0x76, elevation = 0):
"""Initialize the Driver.
Default bus is 1. If you have a Rev 1 RPi then you will need to use bus 0.
A bus object can also be passed in if you are sharing it among other modules
Arguments (All optional):
bus -- 0, 1, or a bus object
i2c -- I2C address
elevation -- Elevation in meters"""
if(bus == 0 or bus == 1):
self.bus = SMBus(bus)
else:
self.bus = bus
self.i2c = i2c
self.elevation = elevation
def setElevation(self, elevation):
self.elevation = elevation
def setElevationFt(self, elevation):
self.elevation = elevation / 3.2808
def setI2c(self, i2c):
self.i2c = i2c
def read(self):
## Get raw pressure
self.bus.write_byte(self.i2c, 0x48)
time.sleep(0.05)
D1 = self.bus.read_i2c_block_data(self.i2c, 0x00)
D1 = D1[0] * 65536 + D1[1] * 256.0 + D1[2]
time.sleep(0.05)
## Get raw temperature
self.bus.write_byte(self.i2c, 0x58)
time.sleep(0.05)
D2 = self.bus.read_i2c_block_data(self.i2c, 0x00)
D2 = D2[0] * 65536 + D2[1] * 256.0 + D2[2]
time.sleep(0.05)
## Read Constants from Sensor
if hasattr(self, 'C1'):
C1 = self.C1
else:
C1 = self.bus.read_i2c_block_data(self.i2c, 0xA2) #Pressure Sensitivity
C1 = C1[0] * 256.0 + C1[1]
self.C1 = C1
time.sleep(0.05)
if hasattr(self, 'C2'):
C2 = self.C2
else:
C2 = self.bus.read_i2c_block_data(self.i2c, 0xA4) #Pressure Offset
C2 = C2[0] * 256.0 + C2[1]
self.C2 = C2
time.sleep(0.05)
if hasattr(self, 'C3'):
C3 = self.C3
else:
C3 = self.bus.read_i2c_block_data(self.i2c, 0xA6) #Temperature coefficient of pressure sensitivity
C3 = C3[0] * 256.0 + C3[1]
self.C3 = C3
time.sleep(0.05)
if hasattr(self, 'C4'):
C4 = self.C4
else:
C4 = self.bus.read_i2c_block_data(self.i2c, 0xA8) #Temperature coefficient of pressure offset
C4 = C4[0] * 256.0 + C4[1]
self.C4 = C4
time.sleep(0.05)
if hasattr(self, 'C5'):
C5 = self.C5
else:
C5 = self.bus.read_i2c_block_data(self.i2c, 0xAA) #Reference temperature
C5 = C5[0] * 256.0 + C5[1]
self.C5 = C5
time.sleep(0.05)
if hasattr(self, 'C6'):
C6 = self.C6
else:
C6 = self.bus.read_i2c_block_data(self.i2c, 0xAC) #Temperature coefficient of the temperature
C6 = C6[0] * 256.0 + C6[1]
self.C6 = C6
time.sleep(0.05)
## These are the calculations provided in the datasheet for the sensor.
dT = D2 - C5 * 2**8
TEMP = 2000 + dT * C6 / 2**23
## Set Values to class to be used elsewhere
self.tempC = TEMP/100.0
self.tempF = TEMP/100.0 * 9.0/5 + 32
self.tempK = TEMP/100.0 + 273.15
## These calculations are all used to produce the final pressure value
OFF = C2 * 2**16 + (C4 * dT) / 2**7
SENS = C1 * 2**15 + (C3 * dT) / 2**8
P = (D1 * SENS / 2**21 - OFF) / 2**15
self.pressure = P/100.0
## Calculate an offset for the pressure. This is required so that the readings are correct.
## Equation can be found here: http://en.wikipedia.org/wiki/Barometric_formula
altOffset = math.exp( (-9.80665 * 0.0289644 * self.elevation) / (8.31432 * self.tempK) )
self.pressureAdj = ( P/altOffset ) / 100.0
def getTempC(self):
return self.tempC
def getTempF(self):
return self.tempF
def getPressure(self):
return self.pressure
def getPressureAdj(self):
return self.pressureAdj
def getBus(self):
return self.bus
def printResults(self):
print "Temperature:", round(self.tempC, 2), "C"
print " ", round(self.tempF, 2), "F"
print "Pressure Absolute:", round(self.pressure, 2), "hPa"
print " Adjusted:", round(self.pressureAdj, 2), "hPa"
print " Adjusted:", round(self.convert2In(self.pressureAdj), 2), "in"
def convert2In(self, pressure):
return pressure * 0.0295301
for note in SONG:
p.ChangeFrequency(note[0])
sleep(note[1])
p.stop()
p.ChangeFrequency(N_BOUNCE)
for led in LEDS: gpio.setup(led, gpio.OUT)
oldBugger = WIDTH * HEIGHT * [None]
oldTime = time()
counter = 0
sorry = True
while 1:
newTime = time()
counter += newTime - oldTime
if newTime - sfxStartTime > sfxLength:
p.stop()
adc.write_byte(33, 128)
knob = adc.read_word_data(33, 0)
knob = ((knob & 15) << 8 | knob >> 8) - 683
if knob < 0: knob = 0
elif knob > 2730: knob = 2730
Player0Bat = HEIGHT - int(round(knob * (HEIGHT - Player0Height) / 2731.)) - Player0Height
if sorry:
knob = adc.read_byte_data(36,0) - 9
if knob < 0: knob = 0
elif knob > 220: knob = 220
Player1Bat = HEIGHT - int(round(knob * (HEIGHT - Player1Height) / 220.)) - Player1Height
gpio.output(17, 1)
gpio.output(17, 0)
sorry = not sorry
if Player0SizeCounter < 15: Player0SizeCounter += newTime - oldTime
else: Player0Height = 3
lcd_display_temperature(bme280.temperature)
lcd_display_humidity(bme280.humidity)
lcd_display_pressure(bme280.pressure)
lcd_display_info()
print ("System running...")
lcd_config()
lcd_clear()
ledstate = "0"
while True:
#ledstate = input(">>>> ")
ledstate = int(ledstate)+1
if(3<ledstate):
ledstate = "0"
ledstate = str(ledstate)
time.sleep(1)
lcd_display_sensor_data()
if ledstate == "1":
bus.write_byte(addr, 0x1) # switch it on
elif ledstate == "2":
bus.write_byte(addr, 0x2) # switch it on
elif ledstate == "3":
bus.write_byte(addr, 0x3) # switch it on
elif ledstate == "55":
bus.write_byte(addr, 0x55) # switch it on
elif ledstate == "aa":
bus.write_byte(addr, 0xaa) # switch it on
class MS5611:
__MS5611_ADDRESS_CSB_LOW = 0x76
__MS5611_ADDRESS_CSB_HIGH = 0x77
__MS5611_DEFAULT_ADDRESS = 0x77
__MS5611_RA_ADC = 0x00
__MS5611_RA_RESET = 0x1E
__MS5611_RA_C0 = 0xA0
__MS5611_RA_C1 = 0xA2
__MS5611_RA_C2 = 0xA4
__MS5611_RA_C3 = 0xA6
__MS5611_RA_C4 = 0xA8
__MS5611_RA_C5 = 0xAA
__MS5611_RA_C6 = 0xAC
__MS5611_RA_C7 = 0xAE
__MS5611_RA_D1_OSR_256 = 0x40
__MS5611_RA_D1_OSR_512 = 0x42
__MS5611_RA_D1_OSR_1024 = 0x44
__MS5611_RA_D1_OSR_2048 = 0x46
__MS5611_RA_D1_OSR_4096 = 0x48
__MS5611_RA_D2_OSR_256 = 0x50
__MS5611_RA_D2_OSR_512 = 0x52
__MS5611_RA_D2_OSR_1024 = 0x54
__MS5611_RA_D2_OSR_2048 = 0x56
__MS5611_RA_D2_OSR_4096 = 0x58
def __init__(self, I2C_bus_number=1, address=0x77):
self.bus = SMBus(I2C_bus_number)
self.address = address
self.C1 = 0
self.C2 = 0
self.C3 = 0
self.C4 = 0
self.C5 = 0
self.C6 = 0
self.D1 = 0
self.D2 = 0
self.TEMP = 0.0 # Calculated temperature
self.PRES = 0.0 # Calculated Pressure
def initialize(self):
## The MS6511 Sensor stores 6 values in the EPROM memory that we need in order to calculate the actual temperature and pressure
## These values are calculated/stored at the factory when the sensor is calibrated.
## I probably could have used the read word function instead of the whole block, but I wanted to keep things consistent.
C1 = self.bus.read_i2c_block_data(
self.address, self.__MS5611_RA_C1) #Pressure Sensitivity
#time.sleep(0.05)
C2 = self.bus.read_i2c_block_data(
self.address, self.__MS5611_RA_C2) #Pressure Offset
#time.sleep(0.05)
C3 = self.bus.read_i2c_block_data(
self.address, self.__MS5611_RA_C3
) #Temperature coefficient of pressure sensitivity
#time.sleep(0.05)
C4 = self.bus.read_i2c_block_data(
self.address,
self.__MS5611_RA_C4) #Temperature coefficient of pressure offset
#time.sleep(0.05)
C5 = self.bus.read_i2c_block_data(
self.address, self.__MS5611_RA_C5) #Reference temperature
#time.sleep(0.05)
C6 = self.bus.read_i2c_block_data(
self.address,
self.__MS5611_RA_C6) #Temperature coefficient of the temperature
## Again here we are converting the 2 8bit packages into a single decimal
self.C1 = C1[0] * 256.0 + C1[1]
self.C2 = C2[0] * 256.0 + C2[1]
self.C3 = C3[0] * 256.0 + C3[1]
self.C4 = C4[0] * 256.0 + C4[1]
self.C5 = C5[0] * 256.0 + C5[1]
self.C6 = C6[0] * 256.0 + C6[1]
self.update()
def refreshPressure(self, OSR=__MS5611_RA_D1_OSR_4096):
self.bus.write_byte(self.address, OSR)
def refreshTemperature(self, OSR=__MS5611_RA_D2_OSR_4096):
self.bus.write_byte(self.address, OSR)
def readPressure(self):
D1 = self.bus.read_i2c_block_data(self.address, self.__MS5611_RA_ADC)
self.D1 = D1[0] * 65536 + D1[1] * 256.0 + D1[2]
def readTemperature(self):
D2 = self.bus.read_i2c_block_data(self.address, self.__MS5611_RA_ADC)
self.D2 = D2[0] * 65536 + D2[1] * 256.0 + D2[2]
def calculatePressureAndTemperature(self):
dT = self.D2 - self.C5 * 2**8
self.TEMP = 2000 + dT * self.C6 / 2**23
OFF = self.C2 * 2**16 + (self.C4 * dT) / 2**7
SENS = self.C1 * 2**15 + (self.C3 * dT) / 2**8
if (self.TEMP >= 2000):
T2 = 0
OFF2 = 0
SENS2 = 0
elif (self.TEMP < 2000):
T2 = dT * dT / 2**31
OFF2 = 5 * ((self.TEMP - 2000)**2) / 2
SENS2 = OFF2 / 2
elif (self.TEMP < -1500):
OFF2 = OFF2 + 7 * ((self.TEMP + 1500)**2)
SENS2 = SENS2 + 11 * (self.TEMP + 1500)**2 / 2
self.TEMP = self.TEMP - T2
OFF = OFF - OFF2
SENS = SENS - SENS2
self.PRES = (self.D1 * SENS / 2**21 - OFF) / 2**15
self.TEMP = self.TEMP / 100 # Temperature updated
self.PRES = self.PRES / 100 # Pressure updated
def returnPressure(self):
return self.PRES
def returnTemperature(self):
return self.TEMP
def update(self):
self.refreshPressure()
time.sleep(0.01) # Waiting for pressure data ready
self.readPressure()
self.refreshTemperature()
time.sleep(0.01) # Waiting for temperature data ready
self.readTemperature()
self.calculatePressureAndTemperature()
def test(self):
self.initialize()
self.update()
is_pressure_valid = 1000 <= self.PRES <= 1050
is_temp_valid = -40 <= self.TEMP <= 80
return is_pressure_valid and is_temp_valid
from smbus import SMBus
import time
bus = SMBus(1) #i2c port 1 /dev/12c-1
address = 0x8
while True:
try:
ledstate = input('Put LED in state : ')
if ledstate == "1":
bus.write_byte(address, 0x1) #on
elif ledstate == "0":
bus.write_byte(address, 0x0)
elif ledstate == "b":
while True:
bus.write_byte(address, 0x1) #on
time.sleep(0.5)
bus.write_byte(address, 0x0)
time.sleep(0.5)
else:
break
except OSError:
print("Possible disconnection of I/O pins")
break
class I2C(_Basic_class):
MASTER = 0
SLAVE = 1
RETRY = 5
def __init__(self, *args,
**kargs): # *args表示位置参数（形式参数），可无，； **kargs表示默认值参数，可无。
super().__init__()
self._bus = 1
self._smbus = SMBus(self._bus)
def _i2c_write_byte(self, addr, data): # i2C 写系列函数
self._debug("_i2c_write_byte: [0x{:02X}] [0x{:02X}]".format(
addr, data))
return self._smbus.write_byte(addr, data)
def _i2c_write_byte_data(self, addr, reg, data):
self._debug(
"_i2c_write_byte_data: [0x{:02X}] [0x{:02X}] [0x{:02X}]".format(
addr, reg, data))
return self._smbus.write_byte_data(addr, reg, data)
def _i2c_write_word_data(self, addr, reg, data):
self._debug(
"_i2c_write_word_data: [0x{:02X}] [0x{:02X}] [0x{:04X}]".format(
addr, reg, data))
return self._smbus.write_word_data(addr, reg, data)
def _i2c_write_i2c_block_data(self, addr, reg, data):
self._debug(
"_i2c_write_i2c_block_data: [0x{:02X}] [0x{:02X}] {}".format(
addr, reg, data))
return self._smbus.write_i2c_block_data(addr, reg, data)
def _i2c_read_byte(self, addr): # i2C 读系列函数
self._debug("_i2c_read_byte: [0x{:02X}]".format(addr))
return self._smbus.read_byte(addr)
def _i2c_read_i2c_block_data(self, addr, reg, num):
self._debug(
"_i2c_read_i2c_block_data: [0x{:02X}] [0x{:02X}] [{}]".format(
addr, reg, num))
return self._smbus.read_i2c_block_data(addr, reg, num)
def is_ready(self, addr):
addresses = self.scan()
if addr in addresses:
return True
else:
return False
def scan(self): # 查看有哪些i2c设备
cmd = "i2cdetect -y %s" % self._bus
_, output = self.run_command(
cmd) # 调用basic中的方法，在linux中运行cmd指令，并返回运行后的内容
outputs = output.split('\n')[1:] # 以回车符为分隔符，分割第二行之后的所有行
self._debug("outputs")
addresses = []
for tmp_addresses in outputs:
if tmp_addresses == "":
continue
tmp_addresses = tmp_addresses.split(':')[1]
tmp_addresses = tmp_addresses.strip().split(
' ') # strip函数是删除字符串两端的字符，split函数是分隔符
for address in tmp_addresses:
if address != '--':
addresses.append(int(address, 16))
self._debug("Conneceted i2c device: %s" %
addresses) # append以列表的方式添加address到addresses中
return addresses
def send(self, send, addr, timeout=0): # 发送数据，addr为从机地址，send为数据
if isinstance(send, bytearray):
data_all = list(send)
elif isinstance(send, int):
data_all = []
d = "{:X}".format(send)
d = "{}{}".format(
"0" if len(d) % 2 == 1 else "", d
) # format是将()中的内容对应填入{}中，（）中的第一个参数是一个三目运算符，if条件成立则为“0”，不成立则为“”(空的意思)，第二个参数是d，此行代码意思为，当字符串为奇数位时，在字符串最强面添加‘0’，否则，不添加， 方便以下函数的应用
# print(d)
for i in range(len(d) - 2, -1, -2): # 从字符串最后开始取，每次取2位
tmp = int(d[i:i + 2], 16) # 将两位字符转化为16进制
# print(tmp)
data_all.append(tmp) # 添加到data_all数组中
data_all.reverse()
elif isinstance(send, list):
data_all = send
else:
raise ValueError(
"send data must be int, list, or bytearray, not {}".format(
type(send)))
if len(data_all) == 1: # 如果data_all只有一组数
data = data_all[0]
self._i2c_write_byte(addr, data)
elif len(data_all) == 2: # 如果data_all只有两组数
reg = data_all[0]
data = data_all[1]
self._i2c_write_byte_data(addr, reg, data)
elif len(data_all) == 3: # 如果data_all只有三组数
reg = data_all[0]
data = (data_all[2] << 8) + data_all[1]
self._i2c_write_word_data(addr, reg, data)
else:
reg = data_all[0]
data = list(data_all[1:])
self._i2c_write_i2c_block_data(addr, reg, data)
def recv(self, recv, addr=0x00, timeout=0): # 接收数据
if isinstance(recv, int): # 将recv转化为二进制数
result = bytearray(recv)
elif isinstance(recv, bytearray):
result = recv
else:
return False
for i in range(len(result)):
result[i] = self._i2c_read_byte(addr)
return result
def mem_write(self,
data,
addr,
memaddr,
timeout=5000,
addr_size=8): #memaddr match to chn
if isinstance(data, bytearray):
data_all = list(data)
elif isinstance(data, list):
data_all = data
elif isinstance(data, int):
data_all = []
data = "%x" % data
if len(data) % 2 == 1:
data = "0" + data
# print(data)
for i in range(0, len(data), 2):
# print(data[i:i+2])
data_all.append(int(data[i:i + 2], 16))
else:
raise ValueError(
"memery write require arguement of bytearray, list, int less than 0xFF"
)
# print(data_all)
self._i2c_write_i2c_block_data(addr, memaddr, data_all)
def mem_read(self, data, addr, memaddr, timeout=5000, addr_size=8): # 读取数据
if isinstance(data, int):
num = data
elif isinstance(data, bytearray):
num = len(data)
else:
return False
result = bytearray(self._i2c_read_i2c_block_data(addr, memaddr, num))
return result
def readfrom_mem_into(self, addr, memaddr, buf):
buf = self.mem_read(len(buf), addr, memaddr)
return buf
def writeto_mem(self, addr, memaddr, data):
self.mem_write(data, addr, memaddr)
# i2c = I2C()
# i2c.scan()
# i2c.mem_write(0xff53773, 20, 20)
#Read a value from analogue input 0
#in A/D in the PCF8591P @ address 0x48
from smbus import SMBus
bus = SMBus(0)
print("Read the A/D")
print("Ctrl C to stop")
bus.write_byte(0x48, 0) # set control register to read channel 0
last_reading =-1
while(0 == 0): # do forever
reading = bus.read_byte(0x48) # read A/D
if(abs(last_reading - reading) > 2):
print(reading)
last_reading = reading
class MAX30105(object):
def __init__(self, bus, address):
self.address = address
self.bus = SMBus(bus)
self._led_mode = None
self._pulse_width_set = None
try:
self.bus.read_byte(self.address)
except:
print("Sensor not found. Check wiring.")
raise SystemExit()
else:
print("Found MAX30105 Particle Sensor on bus {}: [{}]".format(
bus, hex(self.address)))
def read_register(self, REG, n_bytes=1):
self.bus.write_byte(self.address, REG)
return self.bus.read_i2c_block_data(self.address, REG, n_bytes)
def write_register(self, REG, VALUE):
self.bus.write_i2c_block_data(self.address, REG, [VALUE])
return
def bit_mask(self, REG, MASK, NEW_VALUE):
newCONTENTS = (self.byte_to_int(self.read_register(REG))
& MASK) | NEW_VALUE
self.write_register(REG, newCONTENTS)
return
def setup_sensor(self, LED_MODE=2, LED_POWER=0x1F, PULSE_WIDTH=0x01):
self.bit_mask(0x09, 0xBF, 0x40)
time.sleep(1)
# 3: 69 (15-bit), 2: 118 (16-bit), 1: 215 (17-bit), 0: 411 (18-bit)
self.bit_mask(0x0A, 0xFC, PULSE_WIDTH)
self._pulse_width_set = PULSE_WIDTH
if LED_MODE not in [1, 2, 3]:
raise ValueError('wrong LED mode:{0}!'.format(LED_MODE))
elif LED_MODE == 1:
self.bit_mask(0x09, 0xF8, 0x02)
self.write_register(0x0C, LED_POWER)
elif LED_MODE == 2:
self.bit_mask(0x09, 0xF8, 0x03)
self.write_register(0x0C, LED_POWER)
self.write_register(0x0D, LED_POWER)
elif LED_MODE == 3:
self.bit_mask(0x09, 0xF8, 0x07)
self.write_register(0x0C, LED_POWER)
self.write_register(0x0D, LED_POWER)
self.write_register(0x0E, LED_POWER)
self.write_register(0x11, 0b00100001)
self.write_register(0x12, 0b00000011)
self._led_mode = LED_MODE
self.bit_mask(0x0A, 0xE3, 0x0C) # sampl. rate: 50
# 50: 0x00, 100: 0x04, 200: 0x08, 400: 0x0C,
# 800: 0x10, 1000: 0x14, 1600: 0x18, 3200: 0x1C
self.bit_mask(0x0A, 0x9F, 0x60) # ADC range: 2048
# 2048: 0x00, 4096: 0x20, 8192: 0x40, 16384: 0x60
self.bit_mask(0x08, ~0b11100000, 0x00) # FIFO sample avg: (no)
# 1: 0x00, 2: 0x20, 4: 0x40, 8: 0x60, 16: 0x80, 32: 0xA0
self.bit_mask(0x08, 0xEF, 0x01) # FIFO rollover: enable
# 0x00/0x01: dis-/enable
self.write_register(0x04, 0)
self.write_register(0x05, 0)
self.write_register(0x06, 0)
def set_red_led_power(self, LED_POWER):
self.bit_mask(0x09, 0xF8, 0x02)
self.write_register(0x0C, LED_POWER)
def set_ir_led_power(self, LED_POWER):
self.bit_mask(0x09, 0xF8, 0x03)
self.write_register(0x0D, LED_POWER)
def set_green_led_power(self, LED_POWER):
self.bit_mask(0x09, 0xF8, 0x07)
self.write_register(0x0E, LED_POWER)
def byte_to_int(self, byte_data):
return int.from_bytes(byte_data, byteorder='big', signed=False)
def read_sensor(self, pointer_position):
self.write_register(0x06, pointer_position)
fifo_bytes = self.read_register(0x07, self._led_mode * 3)
red_int = self.byte_to_int(fifo_bytes[0:3])
IR_int = self.byte_to_int(fifo_bytes[3:6])
green_int = self.byte_to_int(fifo_bytes[6:9])
return red_int, IR_int, green_int
def clear_fifo(self):
self.write_register(0x04, 0)
self.write_register(0x05, 0)
self.write_register(0x06, 0)
import boto
import json
import time
import datetime
import boto.kinesis
from boto import kinesis
from boto.kinesis.exceptions import ResourceNotFoundException
from random import randint
from smbus import SMBus
bus = SMBus(1)
print("Read the A/D and put record Kinesis")
print("Ctrl C to stop")
bus.write_byte(0x48, 0)
last_reading =-1
ACCESS_KEY="AKIAIMV6XL4QVZA5GB2Q"
SECRET_KEY="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"
region_name="us-west-2"
kinesis =boto.kinesis.connect_to_region(region_name,aws_access_key_id = ACCESS_KEY,aws_secret_access_key = SECRET_KEY)
streamName="sound"
partitionKey="IoTExample"
shardCount=1
global stream
def readSoundSensor():
return bus.read_byte(0x48)
def runController():
class sgh_PCF8591P:
def __init__(self, busNum):
# Remove annoying init message (The Raspberry Pi Guy)
if busNum == 0:
self.__bus = SMBus(0)
else:
self.__bus = SMBus(1)
self.__addr = self.__checkI2Caddress(72)
self.__DACEnabled = 0
def readADC(self, _sgh_PCF8591P__chan = 0):
__checkedChan = self.__checkChannelNo(__chan)
self.__bus.write_byte(self.__addr, __checkedChan | self.__DACEnabled)
__reading = self.__bus.read_byte(self.__addr)
__reading = self.__bus.read_byte(self.__addr)
return __reading
def readAllADC(self):
__readings = []
self.__bus.write_byte(self.__addr, 4 | self.__DACEnabled)
__reading = self.__bus.read_byte(self.__addr)
for i in range(4):
__readings.append(self.__bus.read_byte(self.__addr))
return __readings
def writeDAC(self, _sgh_PCF8591P__val = 0):
__checkedVal = self.__checkDACVal(__val)
self.__DACEnabled = 64
self.__bus.write_byte_data(self.__addr, self.__DACEnabled, __checkedVal)
def enableDAC(self):
self.__DACEnabled = 64
self.__bus.write_byte(self.__addr, self.__DACEnabled)
def disableDAC(self):
self.__DACEnabled = 0
self.__bus.write_byte(self.__addr, self.__DACEnabled)
def __checkI2Caddress(self, _sgh_PCF8591P__addr):
if type(__addr) is not int:
raise I2CaddressOutOfBoundsError
elif __addr < 0:
raise I2CaddressOutOfBoundsError
elif __addr > 127:
raise I2CaddressOutOfBoundsError
return __addr
def __checkChannelNo(self, _sgh_PCF8591P__chan):
if type(__chan) is not int:
raise PCF8591PchannelOutOfBoundsError
elif __chan < 0:
raise PCF8591PchannelOutOfBoundsError
elif __chan > 3:
raise PCF8591PchannelOutOfBoundsError
return __chan
def __checkDACVal(self, _sgh_PCF8591P__val):
if type(__val) is not int:
raise PCF8591PDACvalueOutOfBoundsError
elif __val < 0:
raise PCF8591PDACvalueOutOfBoundsError
elif __val > 255:
raise PCF8591PDACvalueOutOfBoundsError
return __val
from smbus import SMBus
import pyfiglet
addr = 0x8
bus = SMBus(1)
welcome_screen = pyfiglet.figlet_format("POMODORO\n", font="digital")
print(welcome_screen)
print("Press 1 to open the box and press 2 to close it.\n")
run = 1
while (run == 1):
comd = input("> ")
if comd == "2":
bus.write_byte(addr, 0x39)
print("Box has been closed!\n")
elif comd == "1":
bus.write_byte(addr, 0x0)
print("Box has been opened!\n")
else:
run = 0
class PM2:
'''Handle display'''
# Translation value from String to Display
digits = {
'': 0,
'1': 96,
'2': 167,
'3': 227,
'4': 106,
'5': 203,
'6': 207,
'7': 224,
'8': 239,
'9': 235,
'0': 237
}
buffer = [0 for i in xrange(20)] # Buffer for device RAM
def __init__(self,
defaultBus=PI_DEFAULT_BUS,
defaultAddr=PM2_DEFAULT_ADDRESS):
self.bus = SMBus(defaultBus)
self.busNum = defaultBus
self.defaultAddr = defaultAddr
self.bus.close()
self.bus.open(self.busNum)
self.bus.write_byte(self.defaultAddr, PM2_MODE_SET)
self.clear()
self.set_mode('normal')
self.top_right('00')
self.middle('000')
self.top_left('0000')
self.bottom_left('0000')
def write_bit(self, addr, position, value):
'''write one bit to buffer
@addr : buffer address -> int
@position : bit position -> int
@value : bit value -> boolean
'''
mask = ~(1 << position)
value = value << position
self.buffer[addr] = (self.buffer[addr] & mask) | value
def write_digit(self, addr, value):
'''write single/multiple digit(s) to buffer
@addr : buffer address -> int
@value : single/mutiple digit -> string
'''
i = addr
for x in reversed(value):
intVal = self.digits[x]
mask = 1 << 4 # Preserve DP bit
self.buffer[i] = (self.buffer[i] & mask) | intVal
i += 1
def set_mode(self, mode):
'''Toggle between different possible mode :
-normal
-cal/hr
-watts
-heart rate
'''
if (mode == 'normal'):
"""Time, /500m, Distance"""
self.set_segment_colon_top_left(False)
self.set_segment_colon_top_right(True)
self.set_segment_dp_top(False)
self.set_segment_time_top(True)
self.set_segment_meters_top(False)
self.set_segment_spm_top(True)
self.set_segment_int_top(False)
self.set_segment_1_middle(False)
self.set_segment_colon_middle(True)
self.set_segment_500m_middle(True)
self.set_segment_calhr_middle(False)
self.set_segment_watts_middle(False)
self.set_segment_rest_time_middle(False)
self.set_segment_int_middle(False)
self.set_segment_colon_bottom_left(False)
self.set_segment_colon_bottom_right(False)
self.set_segment_dp_bottom(False)
self.set_segment_ave_bottom(False)
self.set_segment_500m_bottom(False)
self.set_segment_watts_bottom(False)
self.set_segment_split_bottom(False)
self.set_segment_cal_bottom(False)
self.set_segment_proj_bottom(False)
self.set_segment_time_bottom(False)
self.set_segment_meters_bottom(True)
self.set_segment_dragfactor_bottom(False)
elif (mode == 'watts'):
"""Time, Watts, Distance"""
self.set_segment_colon_top_left(False)
self.set_segment_colon_top_right(True)
self.set_segment_dp_top(False)
self.set_segment_time_top(True)
self.set_segment_meters_top(False)
self.set_segment_spm_top(True)
self.set_segment_int_top(False)
self.set_segment_1_middle(False)
self.set_segment_colon_middle(False)
self.set_segment_500m_middle(False)
self.set_segment_calhr_middle(False)
self.set_segment_watts_middle(True)
self.set_segment_rest_time_middle(False)
self.set_segment_int_middle(False)
self.set_segment_colon_bottom_left(False)
self.set_segment_colon_bottom_right(False)
self.set_segment_dp_bottom(False)
self.set_segment_ave_bottom(True)
self.set_segment_500m_bottom(False)
self.set_segment_watts_bottom(True)
self.set_segment_split_bottom(False)
self.set_segment_cal_bottom(False)
self.set_segment_proj_bottom(False)
self.set_segment_time_bottom(False)
self.set_segment_meters_bottom(False)
self.set_segment_dragfactor_bottom(False)
elif (mode == 'heart rate'):
self.set_segment_colon_middle(isHeartRate)
def set_segment_colon_top_left(self, enabled):
'''Set first : segment at the top from the left'''
self.write_bit(13, 5, enabled)
def set_segment_colon_top_right(self, enabled):
'''Set 2nd : segment at the top from the left'''
self.write_bit(18, 1, enabled)
def set_segment_int_top(self, enabled):
'''Set INT segment in the top right corner'''
self.write_bit(19, 0, enabled)
def set_segment_spm_top(self, enabled):
'''Set SPM segment in the top right corner'''
self.write_bit(14, 4, enabled)
def set_segment_meters_top(self, enabled):
'''Set METERS segment in at the top'''
self.write_bit(19, 4, enabled)
def set_segment_time_top(self, enabled):
'''Set TIME segment in at the top'''
self.write_bit(0, 4, enabled)
def set_segment_dp_top(self, enabled):
'''Set DP segment (decimal point) in at the top'''
self.write_bit(1, 4, enabled)
def set_segment_calhr_middle(self, enabled):
'''Set CAL/HR segment in the middle'''
self.write_bit(19, 7, enabled)
def set_segment_500m_middle(self, enabled):
'''Set /500M segment in the middle'''
self.write_bit(19, 5, enabled)
def set_segment_int_middle(self, enabled):
'''Set INT segment in the middle'''
self.write_bit(19, 2, enabled)
def set_segment_watts_middle(self, enabled):
'''Set WATTS segment in the middle'''
self.write_bit(19, 6, enabled)
def set_segment_colon_middle(self, enabled):
'''Set : segment in the middle'''
self.write_bit(19, 1, enabled)
def set_segment_1_middle(self, enabled):
'''Set '1' segment in the middle'''
self.write_bit(13, 6, enabled)
def set_segment_rest_time_middle(self, enabled):
'''Set REST TIME segment in the middle'''
self.write_bit(10, 4, enabled)
def set_segment_ave_bottom(self, enabled):
'''Set AVE segment in the bottom'''
self.write_bit(13, 7, enabled)
def set_segment_500m_bottom(self, enabled):
'''Set /500M segment in the bottom'''
self.write_bit(13, 4, enabled)
def set_segment_watts_bottom(self, enabled):
'''Set WATTS segment in the bottom'''
self.write_bit(12, 4, enabled)
def set_segment_split_bottom(self, enabled):
'''Set SPLIT segment in the bottom'''
self.write_bit(11, 4, enabled)
def set_segment_cal_bottom(self, enabled):
'''Set CAL segment in the bottom'''
self.write_bit(9, 4, enabled)
def set_segment_proj_bottom(self, enabled):
'''Set PROJ segment in the bottom'''
self.write_bit(8, 4, enabled)
def set_segment_dp_bottom(self, enabled):
'''Set DP segment (decimal point) in the bottom'''
self.write_bit(6, 4, enabled)
def set_segment_time_bottom(self, enabled):
'''Set TIME segment in the bottom'''
self.write_bit(7, 4, enabled)
def set_segment_meters_bottom(self, enabled):
'''Set METERS segment in the bottom'''
self.write_bit(13, 0, enabled)
def set_segment_dragfactor_bottom(self, enabled):
'''Set DRAG FACTOR segment in the bottom'''
self.write_bit(18, 0, enabled)
def set_segment_heartrate_bottom(self, enabled):
'''Set HEART RATE segment in the bottom'''
self.write_bit(17, 4, enabled)
def set_segment_colon_bottom_left(self, enabled):
'''Set 1st : segment at the bottom from the left'''
self.write_bit(18, 5, enabled)
def set_segment_colon_bottom_right(self, enabled):
'''Set 2nd : segment at the bottom from the left'''
self.write_bit(13, 1, enabled)
def top_right(self, value):
'''Display value to the top rigth corner of the screen'''
startAddr = 14
if (int(value) <= 99):
self.write_digit(startAddr, value)
self.refresh()
return True
else:
return False
def middle(self, value):
'''Display value to the middle of the screen'''
startAddr = 10
if (int(value) <= 999):
self.write_digit(startAddr, value)
self.refresh()
return True
elif (int(value) > 999 & int(value) <= 1999):
self.set_segment_middle_1(True)
self.write_digit(startAddr, value)
self.refresh()
else:
return False
def bottom_right(self, value):
'''Display value to the bottom right corner of the screen'''
startAddr = 17
if (int(value) <= 399):
self.write_digit(startAddr, value)
self.refrsh()
return True
else:
return False
def top_left(self, value):
'''Display value to the top left corner of the screen'''
startAddr = 0
if (int(value) <= 99999):
self.write_digit(startAddr, value)
self.refresh()
return True
else:
return False
def bottom_left(self, value):
'''Display value to the bottom left corner of the screen'''
startAddr = 5
if (int(value) <= 99999):
self.write_digit(startAddr, value)
self.refresh()
return True
else:
return False
def refresh(self):
'''Push buffer content to device RAM at once for display'''
# Do nothing special execpt avoiding an I2C communication error
self.bus.write_byte(self.defaultAddr, 0b01100000)
self.bus.write_i2c_block_data(self.defaultAddr, 0, self.buffer)
# Do nothing special execpt avoiding an I2C communication error
self.bus.write_byte(self.defaultAddr, 0b01100000)
def clear(self):
'''Clear screen'''
self.buffer = [0 for x in xrange(20)]
self.refresh()
def display_all(self):
'''Display all possible character on the screen'''
self.buffer = [255 for x in xrange(20)]
self.refresh()
def loop(self):
self.bus.write_byte_data(self.defaultAddr, 0, 255)
for x in range(2, 40, 2):
self.bus.write_byte_data(self.defaultAddr, x - 2, 0)
self.bus.write_byte_data(self.defaultAddr, x, 255)
sleep(1)
if (x > 36):
self.bus.write_byte(self.defaultAddr, 0b01100000)
parity = serial.PARITY_NONE,
stopbits = serial.STOPBITS_ONE,
# interCharTimeout = 0.2,
timeout = 10.0,
xonxoff = False,
rtscts = False,
dsrdtr = False);
i2c0 = SMBus(0)
i2c2 = SMBus(2)
print(icsp_cmd(ser, b'Z')) # tristate MCLR (icsp)
if sel == "A": # toggle A_!RST
print("selecting RFW ...")
i2c2.write_byte(0x70, 0x5) # steer mux
ioa = i2c0.read_byte_data(0x23, 0x14)
i2c0.write_byte_data(0x23, 0x14, ioa&~0x10)
i2c0.write_byte_data(0x23, 0x14, ioa|0x10)
elif sel == "B": # toggle B_!RST
print("selecting RFE ...")
i2c2.write_byte(0x70, 0x4) # steer mux
iob = i2c0.read_byte_data(0x22, 0x14)
i2c0.write_byte_data(0x22, 0x14, iob&~0x10)
i2c0.write_byte_data(0x22, 0x14, iob|0x10)
elif sel == "N":
print("disabling MUX ...")
i2c2.write_byte(0x70, 0x0) # disable mux
class I2CDevice(object):
"""
Class for communicating with an I2C device.
Allows reading and writing 8-bit, 16-bit, and byte array values to
registers on the device.
It can handle signed, unsigned and endianness.
:var uint address: Assigned I2C address.
:var uint8 busid: Assigned IC2 bus identifier.
:param uint address: I2C address.
:param uint busid: IC2 bus identifier.
:param class i2c_class: Class implementing the I2C reading interface.
If None, smbus.SMBus will be used.
"""
def __init__(self, busnum, address, i2c_class=None):
self._busnum = busnum
self._address = address
if i2c_class is None:
from smbus import SMBus
self._bus = SMBus(busnum)
else:
self._bus = i2c_class(busnum)
self._logger = logging.getLogger(
'/dev/i2c-{}/{:#x}'.format(busnum, address)
)
def _debug(self):
self._logger.setLevel(logging.DEBUG)
self._logger.addHandler(logging.StreamHandler())
@property
def busnum(self):
return self._busnum
@property
def address(self):
return self._address
def write(self, value):
"""
Write the specified 8-bit value to the device base address.
"""
assert bound_bits(value, 8)
self._bus.write_byte(self._address, value)
self._logger.debug(
'Wrote value {:#x}'.format(value)
)
def register_write_u8(self, register, value):
"""
Write an 8-bit value to the specified 8-bit register.
"""
assert bound_bits(register, 8)
assert bound_bits(value, 8)
self._bus.write_byte_data(self._address, register, value)
self._logger.debug(
'Wrote to register {:#x} value {:#x}'.format(register, value)
)
def register_write_u16(self, register, value):
assert bound_bits(register, 8)
assert bound_bits(value, 16)
self._bus.write_word_data(self._address, register, value)
self._logger.debug(
'Wrote to register pair {:#x}, {:#x} value {:#x} '.format(
register, register + 1, value
)
)
def read(self):
"""
Read the device base address and return a 8-bit value.
"""
result = self._bus.read_byte(self._address) & 0xFF
self._logger.debug(
'Read value {:#x}'.format(result)
)
return result
def register_read_u8(self, register):
"""
Read the specified 8-bit register and return a 8-bit value.
"""
assert bound_bits(register, 8)
result = self._bus.read_byte_data(self._address, register) & 0xFF
self._logger.debug(
'Read from register {:#x} returns {:#x}'.format(register, result)
)
return result
def register_read_s8(self, register):
"""
Read the specified 8-bit register and return a signed 7-bit value.
"""
result = self.register_read_u8(register)
if result > 127:
result -= 256
self._logger.debug('... as signed: {:#x}'.format(result))
return result
def register_read_u16(self, register, little_endian=True):
"""
Read the specified 8-bit register and return a 16-bit value with the
specified endianness.
Default is little endian, or least significant byte first.
"""
assert bound_bits(register, 8)
result = self._bus.read_word_data(self._address, register) & 0xFFFF
self._logger.debug(
'Read from register pair {:#x}, {:#x} value {:#x} '.format(
register, register + 1, result
)
)
# Swap bytes if using big endian because read_word_data assumes little
# endian on ARM (little endian) systems.
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
self._logger.debug('... as big endian: {:#x}'.format(result))
return result
def register_read_s16(self, register, little_endian=True):
"""
Read the specified 8-bit register and return a signed 15-bit value
with the specified endianness.
Default is little endian, or least significant byte first.
"""
result = self.register_read_u16(register, little_endian)
if result > 32767:
result -= 65536
self._logger.debug('... as signed: {:#x}'.format(result))
return result
def register_read_u16le(self, register):
"""
Same as register_read_u16 with endianness set to little endian.
"""
return self.register_read_u16(register, little_endian=True)
def register_read_u16be(self, register):
"""
Same as register_read_u16 with endianness set to big endian.
"""
return self.register_read_u16(register, little_endian=False)
def register_read_s16le(self, register):
"""
Same as register_read_s16 with endianness set to little endian.
"""
return self.register_read_s16(register, little_endian=True)
def register_read_s16be(self, register):
"""
Same as register_read_s16 with endianness set to big endian.
"""
return self.register_read_s16(register, little_endian=False)
from smbus import SMBus
from time import sleep
from bitarray import bitarray
from jtag import *
devid = {
"00000001001010111001000001000011" : "MXO2-640HC",
"00000001001010111010000001000011" : "MXO2-1200HC",
"00000001001010111011000001000011" : "MXO2-2000HC" }
i2c = SMBus(2)
i2c.write_byte(0x38, 0x01) # TDO_W input
i2c.write_byte(0x3A, 0xFF) # all pullups
i2c.write_byte(0x39, 0x00)
jtag_tms(i2c, "11111111") # goto reset
jtag_tms(i2c, "01100") # goto Shift-IR
# shift in IDCODE [11100000]
jtag_tdi(i2c, "00000111")
jtag_tms(i2c, "1100") # goto Shift-DR
idcode = jtag_tdo(i2c, 32) # read idcode
dev = devid[idcode]
print("found %s [%s]" % (dev, idcode))
if dev == "MXO2-640HC":
cso = [ 21, 31, 29, 23]
class nunchuck:
def __init__(self,delay = 0.05):
self.delay = delay
if rpi.RPI_REVISION == 1:
i2c_bus = 0
elif rpi.RPI_REVISION == 2:
i2c_bus = 1
elif rpi.RPI_REVISION == 3:
i2c_bus = 1
else:
print "Unable to determine Raspberry Pi revision."
exit
self.bus = SMBus(i2c_bus)
self.bus.write_byte_data(0x52,0x40,0x00)
time.sleep(0.1)
def read(self):
self.bus.write_byte(0x52,0x00)
time.sleep(self.delay)
temp = [(0x17 + (0x17 ^ self.bus.read_byte(0x52))) for i in range(6)]
return temp
def raw(self):
data = self.read()
return data
def joystick(self):
data = self.read()
return data[0],data[1]
def accelerometer(self):
data = self.read()
return data[2],data[3],data[4]
def button_c(self):
data = self.read()
butc = (data[5] & 0x02)
return butc == 0
def button_z(self):
data = self.read()
butc = (data[5] & 0x01)
return butc == 0
def joystick_x(self):
data = self.read()
return data[0]
def joystick_y(self):
data = self.read()
return data[1]
def accelerometer_x(self):
data = self.read()
return data[2]
def accelerometer_y(self):
data = self.read()
return data[3]
def accelerometer_z(self):
data = self.read()
return data[4]
def setdelay(self,delay):
self.delay = delay
def scale(self,value,_min,_max,_omin,_omax):
return (value - _min) * (_omax - _omin) // (_max - _min) + _omin
