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 RHTS:
""" Driver for Si7021 temperatuer and humidity sensor
"""
meas_RH = 0xf5
read_temp = 0xe0
reset = 0xfe
def __init__(self, i2cbus, addr):
self.i2cbus = i2cbus
self.bus = SMBus(self.i2cbus)
self.addr = addr
def measure(self):
self.bus.write_byte(self.addr, self.meas_RH)
sleep(0.3)
def readall(self):
"""Units of temperature in deg C """
self.measure()
# Pull the MSB of the RH data
data0 = self.bus.read_byte(self.addr)
# Pull the LSB from the RH data
data1 = self.bus.read_byte(self.addr)
# Calculate the RH from user manual section 5.1.1
RH = ((data0*256 + data1)*125 / 65535.0)-6
self.RH = max(0, min(100, RH))
# Pull the two byte temperature dats - needs byte shifting
data3 = self.bus.read_word_data(self.addr, self.read_temp)
# Shift the bytes
data4 = ((data3 & 0xff) << 8) | (data3 >> 8)
# Calculate the temperature in deg C from manual section 5.1.1
self.tempC = 175.72 * data4 / 65536. - 46.85
# return the RH and Temperature data
return [self.tempC, self.RH]
class I2C:
CHAN_1 = 0b1000000 # 0x40 (foto-resistor)
CHAN_2 = 0b1000001 # 0x41 (thermistor)
CHAN_3 = 0b1000010 # 0x42 (not connected)
CHAN_4 = 0b1000011 # 0x43 (variable resistor)
CHAN_OUT = 0b1000000
def __init__(self, dev_addr, bus_id):
self.dev_addr = dev_addr
self.bus = SMBus(bus_id)
self.write_out(0)
def read_chan(self, chan_name):
self.bus.write_byte(self.dev_addr, chan_name)
# skipping 2 history values from chan
self.bus.read_byte(self.dev_addr)
self.bus.read_byte(self.dev_addr)
value = self.bus.read_byte(self.dev_addr)
return value
def write_out(self, value):
self.bus.write_byte_data(self.dev_addr, I2C.CHAN_OUT, value)
def test_keypad_presence(self):
#Checking keypad controller - 0x12 should answer
bus = SMBus(1)
try:
bus.read_byte(0x12)
except IOError:
PrettyPrinter("Keypad does not respond!", self.i, self.o)
else:
PrettyPrinter("Keypad found!", self.i, self.o)
class PFC8591:
def __init__(self, debug):
self.bus_i2c = 0
self.Vref = 0
self.address = 0
self.port = 0
self.value = 0.0
self.debug = debug
def SetOptions(self, options):
opts = {}
if (self.debug):
print "%s [DEBUG]Otrzymane opcje %s" % (datetime.now(), options)
try:
for option in options.split(";"):
option = option.split("=")
opts[option[0]] = option[1]
self.bus_i2c = SMBus(int(opts['bus']))
self.Vref = float(opts['Vref'])
self.address = int(opts['address'])
self.port = int(opts['port'])
except:
if (self.debug):
print "%s [DEBUG]Ustawianie opcji zakończyło się błędnie, możliwe błędne opcje lub czujnik nie działa" % datetime.now(
)
return False
if (self.debug):
print "%s [DEBUG]Ustawianie opcji zakończyło się powodzeniem bus_i2c=%s, address=%s, port=%s, Vref=%s" % (
datetime.now(), self.bus_i2c, self.address, self.port,
self.Vref)
return True
def ReadValue(self):
if (self.debug):
print "%s [DEBUG]Odczyt wartości dla port=%s" % (datetime.now(),
self.port)
try:
self.bus_i2c.write_byte(self.address, self.port)
time.sleep(0.4)
self.bus_i2c.read_byte(self.address)
self.bus_i2c.read_byte(self.address)
Ain = float(self.bus_i2c.read_byte(self.address))
self.value = (Ain * self.Vref) / float(255)
except:
if (self.debug):
print "%s [DEBUG]Błąd odczytu wartości" % datetime.now()
return False
if (self.debug):
print "%s [DEBUG]Odczyt poprawny, wartość=%s" % (datetime.now(),
self.value)
return self.value
def test_i2c_gpio(self):
#Checking IO expander - 0x20 should raise IOError with busy errno
self.expander_ok = False
bus = SMBus(1)
try:
bus.read_byte(0x20)
except IOError as e:
if e.errno == 16:
PrettyPrinter("IO expander OK!", self.i, self.o)
self.expander_ok = True
elif e.errno == 121:
PrettyPrinter("IO expander not found!", self.i, self.o)
else:
PrettyPrinter("IO expander driver not loaded!", self.i, self.o)
class LEDSign:
def __init__(self):
self.s = SMBus(0)
self.lock = Lock()
def print_message(self, line, message):
if len(message) > 255:
message = message[:255]
if message[:-1] != "\x00":
message = "".join([message, "\x00"])
self.print_message_loop(line, message)
def print_message_loop(self, line, message):
if message == "":
return
self.lock.acquire()
self.s.write_i2c_block_data(signAddress, line, [ord(x) for x in message[0:payLoadLen]])
self.lock.release()
self.print_message_loop(line, message[payLoadLen:])
def get_status(self):
self.lock.acquire()
labStatus = self.s.read_byte(signAddress)
self.lock.release()
return labStatus
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)))
class LEDSign:
def __init__(self):
self.s = SMBus(0)
self.lock = Lock()
def print_message(self, line, message):
if len(message) > 255:
message = message[:255]
if message[:-1] != "\x00":
message = ''.join([message, "\x00"])
self.print_message_loop(line, message)
def print_message_loop(self, line, message):
if message == "":
return
self.lock.acquire()
self.s.write_i2c_block_data(signAddress, line,
[ord(x) for x in message[0:payLoadLen]])
self.lock.release()
self.print_message_loop(line, message[payLoadLen:])
def get_status(self):
self.lock.acquire()
labStatus = self.s.read_byte(signAddress)
self.lock.release()
return labStatus
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 I2CInterface(object):
def __init__(self, addr: int):
self.bus = SMBus(1) # indicates /dev/i2c-1
self.addr = addr
self.errormsg = "Sensor device offline or incorrect address set"
self.formatted_data = ""
def write_byte(self, data: int):
try:
self.bus.write_byte(self.addr, data)
except OSError as e:
print(e)
print(self.errormsg)
def read_byte(self):
try:
data = self.bus.read_byte(self.addr)
return data
except OSError as e:
print(e)
print(self.errormsg)
def read_data_7Bchunk(self):
"""
Reads and returns a 7-byte data chunk
"""
try:
data = self.bus.read_i2c_block_data(self.addr, 0, 7)
return data
except OSError as e:
print(e)
print(self.errormsg)
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)
def detect(bus_number=1):
bus = SMBus(bus_number)
if hasattr(bus, 'is_fake'):
return [0x30]
addresses = [];
for address in range(0x30, 0x38):
try:
result = bus.read_byte(address)
addresses.append(address)
except:
next
return addresses
def get_status(command, value):
status = ""
bus = SMBus(i2cBusAddr)
BytesToSend = convert_string_to_bytes(value)
bus.write_i2c_block_data(arduinoSlaveAddress, ord(command), BytesToSend)
time.sleep(0.001)
for i in range (0, 11):
statusChr = chr(bus.read_byte(arduinoSlaveAddress))
if statusChr != ";":
status += statusChr
else:
break
bus.close()
return status
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)
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}
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)
def _read_device_state():
"""INTERNAL. Read from the I2C bus to get the current state of the pulse. Caller should handle exceptions"""
try:
PTLogger.debug("Connecting to bus...")
i2c_bus = SMBus(_bus_id)
current_state = i2c_bus.read_byte(_device_addr) & 0x0F
return int(current_state)
except:
PTLogger.warning("Error: There was a problem reading from the device")
# Best to re-raise as we can't recover from this
raise
def detect_device():
for busNum in range(20):
if not os.path.exists('/dev/i2c-' + str(busNum)):
if busNum == 20 - 1:
print("device not found.")
return -1
continue
bus = SMBus(busNum)
print("Bus #{} open. Searching...".format(busNum))
response = bus.read_byte(addr)
if response >= 0:
#print("On bus {} a device {} found with response of {}".format(busNum, hex(dev_addr), hex(response)))
if bus.read_byte_data(addr, 0x00) == 2:
M = bus.read_byte(addr)
m = bus.read_byte(addr)
print(
"Bus:{} Addr:{} Reg:0x00 query returns {}.{}.\nPossible AsRock AURA device with FW nu50_{}.{} detected."
.format(busNum, hex(addr), M, m, M, m))
if M != 1 and m != 10:
print(
"This FW is NOT supported, yet. Try with your own risk!"
)
return bus
bus.close()
class VL53LOX:
def __init__(self, address):
self.address = address
self.i2c = SMBus()
self.setup()
def setup(self):
self.i2c.open(1)
def read_data(self):
self.i2c.write_byte(self.address, 0)
value = self.i2c.read_byte(self.address)
return value
def close(self):
self.i2c.close()
def get(self):
lStatus = "ok"
lCommand = ""
lValue = ""
lArgs = self.__mParser.parse_args()
lBusId = int(lArgs['bus_id'], 0)
lBus = SMBus(lBusId)
lAddress = int(lArgs['address'], 0)
try:
if lArgs['cmd'] is None:
lValue = lBus.read_byte(lAddress)
else:
lCommand = int(lArgs['cmd'], 0)
lValue = lBus.read_byte_data(lAddress, lCommand)
except IOError, pExc:
lStatus = "Error reading from bus: " + str(pExc)
class nunchuk:
def __init__(self, delay=0.001):
self.delay = delay
self.bus = SMBus(1)
self.bus.write_byte_data(0x52, 0xF0, 0x55)
time.sleep(0.1)
self.bus.write_byte_data(0x52, 0xFB, 0x00)
time.sleep(0.1)
def read(self):
self.bus.write_byte(0x52, 0x00)
time.sleep(self.delay)
return [self.bus.read_byte(0x52) for i in range(6)]
def extractAccelData(self, data):
x = data[2] + (data[5] >> 2 & 3) - 128
y = data[3] + (data[5] >> 2 & 3) - 128
z = data[4] + (data[5] >> 6) - 128
return (x, y, z)
def getAccelData(self):
local = self.read()
return self.extractAccelData(local)
def getData(self):
local = self.read()
return {
"accel": self.extractAccelData(local),
"btn": (local[5] & 2 != 2, local[5] & 1 != 1),
"joystk": (local[0], local[1])
}
def selectSheet(self, path, sheetname):
self.path = path
self.wb = load_workbook(path)
self.ws = self.wb[sheetname]
def appendToExcl(self, row):
self.ws.append(row)
def saveExcl(self):
self.wb.save(self.path)
def getTemp():
rdis_addr = r_server.hget("config.sensor.1", "Address")
address = int(rdis_addr, 16)
bus = SMBus(1)
raw_temp = bus.read_byte(address)
vorkomma = raw_temp & 0xFF
nachkomma = raw_temp >> 15
# ist Wert positiv oder negativ
if (vorkomma & 0x80) != 0x80: # positiv
temp = vorkomma + nachkomma * 0.5
else: # negativ
vorkomma = -((~vorkomma & 0xFF) + 1)
temp = vorkomma + nachkomma * (0.5)
# print (temp)
r_server.hset("boat.temperature", "value", temp)
r_server.hset("boat.temperature", "time", vtime)
class I2CDriver:
"""Thread-safe driver interacting over I2C with actuators boards."""
def __init__(self, bus_id):
"""Create driver with default values."""
self._mutex = RLock()
self._bus_id = bus_id
self._i2c = SMBus(self._bus_id)
def read_byte(self, addr: int):
"""Read pump driver outputs state."""
if self._i2c != self._bus_id:
with self._mutex:
return self._i2c.read_byte(addr)
return 0
def write_byte(self, addr: int, value: int):
"""Write pump driver outputs state."""
if self._i2c != self._bus_id:
with self._mutex:
self._i2c.write_byte(addr, value)
def getTemp():
rdis_addr = r_server.hget("config.sensor.1", "Address")
address = int(rdis_addr,16)
bus = SMBus(1)
raw_temp = bus.read_byte(address);
vorkomma = raw_temp & 0xFF
nachkomma = raw_temp >> 15
# ist Wert positiv oder negativ
if (vorkomma & 0x80)!= 0x80: #positiv
temp = vorkomma + nachkomma * 0.5
else: #negativ
vorkomma =-((~vorkomma & 0xFF) +1)
temp = vorkomma + nachkomma *(0.5)
#print (temp)
r_server.hset("boat.temperature","value",temp)
r_server.hset("boat.temperature","time", vtime)
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 = int('0x{}'.format(
findall("[0-9a-z]{2}(?!:)", check_output(['/usr/sbin/i2cdetect', '-y', str(BUS_NUMBER)]).decode())[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
# 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
"TCK_E", "TMS_E",
"IO_SCL", "IO_SDA",
"JTAGENB_E", "PROGRAMN_E" ]
return ret
i2c2 = SMBus(2)
# ver = gpio_probe(i2c0)
ver = "0.23"
if len(sys.argv) > 1:
if sys.argv[1] == "init":
# gpio_init(i2c, ver)
pass
mux = i2c2.read_byte(0x70)
if mux == 4:
sel = 'B'
elif mux == 5:
sel = 'A'
data, names = {}, {}
for addr in [ 0x30, 0x34, 0x38 ]:
names[addr,'A'] = gpio_names(ver, 'A', addr)
names[addr,'B'] = gpio_names(ver, 'B', addr)
for reg in (0x00, 0x01, 0x02, 0x03):
data[addr, reg] = i2c2.read_byte(addr + reg)
for bit in range(8):
for addr, port in [ (0x30,'A'), (0x34,'B'), (0x38,'C') ]:
name = names[addr,sel][bit]
#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 nunchuck:
def __init__(self):
if rpi.RPI_REVISION == 1:
i2c_bus = 0
elif rpi.RPI_REVISION == 2:
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(0.2)
data0 = self.bus.read_byte(0x52)
data1 = self.bus.read_byte(0x52)
data2 = self.bus.read_byte(0x52)
data3 = self.bus.read_byte(0x52)
data4 = self.bus.read_byte(0x52)
data5 = self.bus.read_byte(0x52)
return [data0,data1,data2,data3,data4,data5]
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)
if butc == 0:
return True
else:
return False
def button_z(self):
data = self.read()
butc = (data[5] & 0x01)
if butc == 0:
return True
else:
return False
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 scale(self,value,_min,_max,_omin,_omax):
return (value - _min) * (_omax - _omin) // (_max - _min) + _omin
from smbus import SMBus
import time
bus = SMBus(1)
print("read the ad")
#bus.write_byte(0x48, 0)
while True:
time.sleep(1)
print(5*(bus.read_byte(0x48)/255.0))
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)
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)
# Inizio transazione MySQL per evitare confilitti su i2C
con.begin()
print "inizio"
# Attivazione del blocco risorsa sul database
# Altri programmi che usano bus i2C aspettano
cur = con.cursor()
cur.execute("SELECT * FROM xBus WHERE xBus = 'I2C1' for update")
print "fine"
# Lettura canale 0 ADC - un byte esadecimale
# La prima istruzione imposta la richiesta di campionamento su ADC 0
# Si eseguino tre letture per evitare 0x80 all'accensione e per la precisone
# incrementale del convertire
bus.write_byte(adc_address1,adc_channel1)
raw_val = bus.read_byte(adc_address1)
raw_val = bus.read_byte(adc_address1)
raw_val = bus.read_byte(adc_address1)
print "Hex ADC_0 = ",
print hex(raw_val)
# Elimina i primi due caratteri 0x dal valore letto ed eventuale L finale
# Trasforma il risultato in decimale
hex_val = hex(raw_val)[2:].rstrip('L')
dec_val = int(hex_val,16)
print "Dec ADC_0 = ",
print dec_val
# Trasformazione in tensione del valore letto
V = (dec_val * V_REF) / 256.0
print "Volt NTC = ",
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
if joy_y > 15:
step(0,0)
elif joy_y < -15:
step(0,1)
if joy_x > 15:
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
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
try:
MQTT.init()
last_reading =-1
last_reading1 =-1
last_reading2 =-1
last_reading3 =-1
for i in [1,255,1]:
writeAOUT(i)
while True:
time.sleep(0.1)
bus.write_byte(address, 0x40) # set control register to read channel 0
reading = bus.read_byte(address) # read A/D for starting AD conversion
reading = bus.read_byte(address) # read A/D value
if(abs(last_reading - reading) > 2):
last_reading = reading
MQTT.mqttc.publish("/RPiMower/World/PowerM1", reading)
if DEBUG:
print("1:",reading)
bus.write_byte(address, 0x41) # set control register to read channel 1
reading = bus.read_byte(address) # read A/D for starting AD conversion
reading = bus.read_byte(address) # read A/D value
if(abs(last_reading1 - reading) > 2):
last_reading1 = reading
MQTT.mqttc.publish("/RPiMower/World/PowerM2", reading)
if DEBUG:
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)
import RPi.GPIO as GPIO
# compatibility for different versions of RasPi
# rev 2 or 3 will use bus address 1
# rev 1 will use bus address 0
rev = GPIO.RPI_REVISION
if rev == 2 or rev == 3:
b = SMBus(1)
else:
b = SMBus(0)
GPR_I2C_DEV_ID = 0x50
# test to see if this is always I2C-1
address = 0x50
# Pulse will return -1 in case of immediate IOError
pulse = -1
while True:
# handling IOError incase Grove decides to go on a walk
try:
pulse = b.read_byte(address)
except IOError:
print("there was an IO Error")
# print the pulse otherwise
print(pulse)
# wait two seconds
sleep(2)
from smbus import SMBus
addr = 0x04
bus = SMBus(1)
while True:
k = input()
bus.write_byte(addr, (int)(k))
print(bus.read_byte(addr))
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 CommunicationI2C(Communication):
def __init__(self, name="i2c", address="0x00"):
Communication.__init__(self, name)
self.bus = None
self.address = int(address, 16)
self.timeout = 0.2
self.stopThread = False
self.rwMutex = threading.Lock()
def connect(self, address=0x00, timeout=0.2):
try:
if address is 0x00:
address = self.address
else:
self.address = address
self.timeout = timeout
print "opening i2c ", self.address
self.bus = SMBus(1)
self.rwMutex.acquire()
try:
self.bus.read_byte(self.address)
self.connected = True
except:
self.connected = False
self.rwMutex.release()
print "connected", self.connected
self.thread = threading.Thread(target=self.__receiveLoop)
self.thread.start()
return self.connected
except:
# e = sys.exc_info()[0]
# print e
return False
def disconnect(self):
if self.bus is None:
return
self.stopThread = True
self.thread.join()
self.connected = False
def sendMessage(self, message):
while len(self.pendingMessageList): #empty receive list
self.pendingMessageList.pop(0)
if self.bus is None or not self.connected:
print "send message, not connected"
return
if len(message) > 30:
print "Too long(", len(message), ") ", message
return
#print "sending: ", message
self.rwMutex.acquire()
#print self.name, "Locked W"
try:
#print self.name, "try W"
self.bus.write_i2c_block_data(self.address, 68, map(ord, message))
#print self.name, "wrote"
time.sleep(0.01)
#print self.name, ">", message
except:
print "Write failed on ", self.address
self.rwMutex.release()
self.disconnect()
self.connect(self.address, 1)
if self.connected:
print "reconnected ", self.address
else:
#print self.name, "About Unlocked W"
self.rwMutex.release()
#print self.name, "Unlocked W"
def __receiveLoop(self):
errorDetected = False
while self.bus is not None and self.connected and not self.stopThread:
time.sleep(0.015)
message = ""
self.rwMutex.acquire()
try:
message = self.bus.read_i2c_block_data(self.address, 0, 30)
time.sleep(0.005)
message = "".join(map(chr, message))
if "\r\n" not in message:
message = ""
message = message.replace('\r\n', '')
message = message.replace(chr(255), '')
message = message.replace(chr(0), '')
except Exception as e:
errorDetected = True
self.rwMutex.release()
if message and len(message) > 0:
self.addPendingMessage(message)
#print self.name, "<", message
if errorDetected and not self.stopThread:
print "recv reconnecting ", self.address
self.connect(self.address, self.timeout)
# -*- 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)
# prepare to read EEPROM chip starting at address zero
# what address belongs to EEPROM? 1010000 in binary ==> 0x50 ==> 80 in base ten, before left shifting the Read/Write bit into the address
# to read, we set the R/W bit to 1 (R/~W).
# 1010 0001
# send that address (control byte)
# then send two bytes for addressing into the EEPROM
# declare object
bus = SMBus(1) # NOTE: the i2c bus number is 1, not zero like in some tutorials
bus.write_byte_data(0x50, 0, 0) # start reading EEPROM at address zero
numRecordsHigh = bus.read_byte(0x50) # read high byte of the number of records on the EEPROM
numRecordsLow = bus.read_byte(0x50) # read low byte of the number of records on the EEPROM
dummy = bus.read_byte(0x50) # clear dummy byte
dummy = bus.read_byte(0x50) # clear dummy byte
numRecords = (numRecordsHigh << 8) + numRecordsLow # splice together the low and high bytes to get the number of records
firstRecordTime = currTime - (numRecords * samplePeriod) - bootDelay # calculate starting time in seconds
# EEPROM loop
for i in range(numRecords): # loop reads an entire three byte record (sample) + one dummy byte for EEPROM organization purposes
recordNumHigh = bus.read_byte(0x50)
recordNumLow = bus.read_byte(0x50)
pulseCount = bus.read_byte(0x50)
dummy = bus.read_byte(0x50)
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
ih.puts(a*2, struct.pack("<h", val))
icsp_cmd(ser, b'[X0=]', 0) # switch to config mem
print("dumping config memory ...")
data = icsp_read_data(ser, 0x11)
for a in range(0x8000, 0x8011):
val = data[a - 0x8000]
ih.puts(a*2, struct.pack("<h", val))
print(icsp_cmd(ser, b'#', 9)) # retrieve checksum
print(icsp_cmd(ser, b'Z')) # tristate MCLK (icsp)
if ver == "0.36":
print("mux = 0x%02x" % i2c2.read_byte(0x30))
if sel == "A": # bring A_!RST high again
i2c0.write_byte_data(0x23, 0x14, ioa|0x10)
elif sel == "B": # bring B_!RST high again
i2c0.write_byte_data(0x22, 0x14, iob|0x10)
elif sel == "P":
pass
else:
if ver == "0.36":
i2c2.write_byte(0x30, 0x0) # disable mux
else:
i2c2.write_byte(0x70, 0x0) # disable mux
ih.tofile(sys.argv[2], "hex")
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 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
import time
bus = SMBus(1)
bus.write_byte(0x48, 0x40)
bus.read_byte(0x48)
while(True):
voltaje = bus.read_byte(0x48)
print "voltaje = %s mV"%(voltaje)
time.sleep(0.5)
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
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)
