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)