def toggle_enable(self, bits): # Toggle enable time.sleep(self.E_DELAY) Adafruit_I2C.writeRaw8(self, bits | self.ENABLE) time.sleep(self.E_PULSE) Adafruit_I2C.writeRaw8(self, bits & ~self.ENABLE) time.sleep(self.E_DELAY)
def read_sensor(self): hival = Adafruit_I2C.write8(self.sensor_address, self.MEASURE_REG, self.MEASURE_VAL) sleep(.02) loval = Adafruit_I2C.readU8(self.sensor_address, self.DISTANCE_REG_LO) hival = Adafruit_I2C.readS8(self.sensor_address, self.DISTANCE_REG_HI) return ((hival << 8) + loval)
def write_byte(self, reg, value): """SC16IS7X0 expects a R/W first, followd by a 4 bit register address and combine with a value """ Write_bit = 0b00000000 # left shift by 3 bit reg = reg << 3 # bitwise or with a write bit actual_reg = reg | Write_bit Adafruit_I2C.write8(self, actual_reg, value)
def send_byte(self, bits, mode): # Send byte to data pins # bits = the data # mode = 1 for data # 0 for command bits_high = mode | (bits & 0xF0) | self.LCD_BACKLIGHT bits_low = mode | ((bits<<4) & 0xF0) | self.LCD_BACKLIGHT # High bits Adafruit_I2C.writeRaw8(self, bits_high) self.toggle_enable(bits_high) # Low bits Adafruit_I2C.writeRaw8(self, bits_low) self.toggle_enable(bits_low)
def read_byte(self, reg): """SC16IS7X0 expects a R/W first, followd by a 4 bit register address and combine with a value """ Read_bit = 0b10000000 # left shift by 3 bit reg = reg << 3 # bitwise or with a write bit actual_reg = reg | Read_bit return Adafruit_I2C.readU8(self, actual_reg)
def updFuelGauge(): global chkFuel, batteryLast, batteryLevel, Volt, Fuel, text_file, t_i2c Volt = ((Adafruit_I2C.readU16(AdaI2C, 0x02, little_endian=False)) >> 4) * 1.25 /1000 Fuel = Adafruit_I2C.readU8(AdaI2C, 0x04) # Load Fuel Level # text_file = open("Output.txt", "a") # text_file.write("Fuel: %003d, Volts: %.4f \n" % (Fuel, Volt)) # text_file.close() if Volt >= 3.68: batteryLevel = 0 elif Volt >= 3.61: batteryLevel = 1 elif Volt >= 3.54: batteryLevel = 2 elif Volt >= 3.47: batteryLevel = 3 elif Volt >= 3.40: batteryLevel = 4 elif Volt == 0.00: batteryLevel = 4 else: batteryLevel = 4 chkFuel = False if (GPIO.input(17)==0): batteryLevel += 5 if batteryLevel != batteryLast: if batteryLevel in [4, 9]: GPIO.output(18, GPIO.LOW) else: GPIO.output(18, GPIO.HIGH) # print "Fuel: 0x%02X - Level: 0x%02X - Last: 0x%02X " % (Fuel, batteryLevel, batteryLast) batteryLast = batteryLevel setBatteryLevel(batteryLevel) pygame.display.update()
def read_raw(self, reg, allowZero): i = 0 value = "" sleep(.001) while True: value = Adafruit_I2C.readU8(self.sensor_address, reg) if value == self.ERROR_READ or (value == 0 and not allowZero): sleep(.02) if i > 50: print "Timeout" return self.ERROR_READ i += 1 else: return value
def __init__(self, address=0x70, bus=Adafruit_I2C.getPiI2CBusNumber(), debug=False): self.i2c = Adafruit_I2C(address, bus) self.address = address self.debug = debug # Turn the oscillator on self.i2c.write8(self.__HT16K33_REGISTER_SYSTEM_SETUP | 0x01, 0x00) # Turn blink off self.setBlinkRate(self.__HT16K33_BLINKRATE_OFF) # Set maximum brightness self.setBrightness(15) # Clear the screen self.clear()
def srf08 (pin, cycles, outData, outTime, name, location): print name, 'started' GPIO.setup(pin[1], GPIO.OUT) i2c = bus(0x70) bus.write8(i2c, 2, 255) bus.write8(i2c, 1, 0) window = [] data = [] time_ = [] rowTime = [] Location = [] i = 0 while i < cycles: bus.write8(i2c, 0, 84) time.sleep(0.07) ranging_result = [] n = 4 while n < 36 : ranging_result.append(bus.readU8(i2c, n)) n += 1 #******** for index, element in enumerate(ranging_result): if element == 255: GPIO.output(pin[1], GPIO.HIGH) flag = 1 Location.append(locations[index]) break else: GPIO.output(pin[1], GPIO.LOW) flag = 0 Location.append(locations[index]) data.append(flag) rowTime.append(time.time()) time_.append(rowTime[i] - rowTime[0]) i += 1 #********** print name, 'finished' outData.put(data) outTime.put(time_) location.put(Location)
def read_status(self): value = "okay" status = Adafruit_I2C.readU8(self.sensor_address, self.STATUS_REG) if (status & self.STAT_BUSY): value = "busy" if (status & self.STAT_REF_OVER): value = "reference overflow" if (status & self.STAT_SIG_OVER): value = "signal overflow" if (status & self.STAT_PIN): value = "mode select pin" if (status & self.STAT_SECOND_PEAK): value = "second peak" if (status & self.STAT_TIME): value = "active between pairs" if (status & self.STAT_INVALID): value = "no signal" if (status & self.STAT_EYE): value = " eye safety" return value
#!/usr/bin/env python from Adafruit_I2C import Adafruit_I2C import time import math Oled = Adafruit_I2C(0x3c) Command_Mode = 0x80 Data_mode = 0x40 grayH = 0xF0 grayL = 0x0F Normal_Display_Cmd = 0xA4 BasicFont = [[0 for x in xrange(8)] for x in xrange(10)] BasicFont = [[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], [0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x00, 0x00], [0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00], [0x00, 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 0x00], [0x00, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00, 0x00], [0x00, 0x23, 0x13, 0x08, 0x64, 0x62, 0x00, 0x00], [0x00, 0x36, 0x49, 0x55, 0x22, 0x50, 0x00, 0x00], [0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0x00], [0x00, 0x1C, 0x22, 0x41, 0x00, 0x00, 0x00, 0x00], [0x00, 0x41, 0x22, 0x1C, 0x00, 0x00, 0x00, 0x00], [0x00, 0x08, 0x2A, 0x1C, 0x2A, 0x08, 0x00, 0x00], [0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00], [0x00, 0xA0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00], [0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00], [0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00], [0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00],
def __init__(self): # Get the ~private namespace parameters from command line or launch file rate = float(rospy.get_param('~rate', '10.0')) address = rospy.get_param('~address', '0x0e') no_sensors = rospy.get_param('~no_sensors', 1) # Create a publisher for magnet messages pub = rospy.Publisher("magnet_topic", AxesValues, queue_size=0) # Initialize and I2C nodes i2c = [] msg = AxesValues() for i in range(0, no_sensors): i2c.append(Adafruit_I2C(address[i])) msg.id.append(i) msg.x_axis.append(0) msg.y_axis.append(0) msg.z_axis.append(0) #initialize bus i2c[i].write8(17, 128) i2c[i].write8(16, 1) time.sleep(0.0002) # Main while loop while not rospy.is_shutdown(): data = [0, 0, 0, 0, 0, 0] for node in range(0, no_sensors): # read x i2c[node].write8(1, 0) time.sleep(0.0002) data[0] = i2c[node].readU8(1) time.sleep(0.0002) i2c[node].write8(2, 0) time.sleep(0.0002) data[1] = i2c[node].readU8(2) msg.x_axis[node] = data[1] + (data[0] << 8) # read y i2c[node].write8(3, 0) time.sleep(0.0002) data[2] = i2c[node].readU8(3) time.sleep(0.0002) i2c[node].write8(4, 0) time.sleep(0.0002) data[3] = i2c[node].readU8(4) msg.y_axis[node] = data[3] + (data[2] << 8) # read z i2c[node].write8(5, 0) time.sleep(0.0002) data[4] = i2c[node].readU8(5) time.sleep(0.0002) i2c[node].write8(6, 0) time.sleep(0.0002) data[5] = i2c[node].readU8(6) msg.z_axis[node] = data[5] + (data[4] << 8) msg.id[node] = node # publish data out pub.publish(msg) # Sleep for a while before publishing new messages if rate: rospy.sleep(1 / rate) else: rospy.sleep(1.0)
def __init__(self, address=0x40, debug=False): self.i2c = Adafruit_I2C(address, debug=False) self.address = address self.debug = debug self.ina219SetCalibration_32V_2A()
def __init__(self, addr, bus): self.i2c = Adafruit_I2C(0x20, bus=1) #starts sensor watching proximity self.i2c.write8(0x3, 0xFE)
def __init__(self, busnum=-1, addr=0x20, debug=False): self.i2c = Adafruit_I2C(addr, busnum, debug) # I2C is relatively slow. MCP output port states are cached # so we don't need to constantly poll-and-change bit states. self.porta, self.portb, self.ddrb = 0, 0, 0b00010000 # Set MCP23017 IOCON register to Bank 0 with sequential operation. # If chip is already set for Bank 0, this will just write to OLATB, # which won't seriously bother anything on the plate right now # (blue backlight LED will come on, but that's done in the next # step anyway). self.i2c.bus.write_byte_data(self.i2c.address, self.MCP23017_IOCON_BANK1, 0) # Brute force reload ALL registers to known state. This also # sets up all the input pins, pull-ups, etc. for the Pi Plate. self.i2c.bus.write_i2c_block_data( self.i2c.address, 0, [ 0b00111111, # IODIRA R+G LEDs=outputs, buttons=inputs self.ddrb, # IODIRB LCD D7=input, Blue LED=output 0b00111111, # IPOLA Invert polarity on button inputs 0b00000000, # IPOLB 0b00000000, # GPINTENA Disable interrupt-on-change 0b00000000, # GPINTENB 0b00000000, # DEFVALA 0b00000000, # DEFVALB 0b00000000, # INTCONA 0b00000000, # INTCONB 0b00000000, # IOCON 0b00000000, # IOCON 0b00111111, # GPPUA Enable pull-ups on buttons 0b00000000, # GPPUB 0b00000000, # INTFA 0b00000000, # INTFB 0b00000000, # INTCAPA 0b00000000, # INTCAPB self.porta, # GPIOA self.portb, # GPIOB self.porta, # OLATA 0 on all outputs; side effect of self.portb ]) # OLATB turning on R+G+B backlight LEDs. # Switch to Bank 1 and disable sequential operation. # From this point forward, the register addresses do NOT match # the list immediately above. Instead, use the constants defined # at the start of the class. Also, the address register will no # longer increment automatically after this -- multi-byte # operations must be broken down into single-byte calls. self.i2c.bus.write_byte_data(self.i2c.address, self.MCP23017_IOCON_BANK0, 0b10100000) self.displayshift = (self.LCD_CURSORMOVE | self.LCD_MOVERIGHT) self.displaymode = (self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT) self.displaycontrol = (self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF) self.write(0x33) # Init self.write(0x32) # Init self.write(0x28) # 2 line 5x8 matrix self.write(self.LCD_CLEARDISPLAY) self.write(self.LCD_CURSORSHIFT | self.displayshift) self.write(self.LCD_ENTRYMODESET | self.displaymode) self.write(self.LCD_DISPLAYCONTROL | self.displaycontrol) self.write(self.LCD_RETURNHOME)
def magnetometer(): #I2C code for reading the magnetometer counter = 0 global Zmag_raw global Ymag_raw global Xmag_raw global Zmag global Ymag global Xmag global mag_vector for counter in xrange(0,10): #send the commands several times to ensure Magnetometer receives the command Adafruit_I2C.write8(i2c, 0x00, 0x18) # 1 Average, 15 Hz, normal measurement Adafruit_I2C.write8(i2c, 0x01, 0x20) # Set Gain Adafruit_I2C.write8(i2c, 0x02, 0x00) # Continuous measurement counter += 1 z_l = Adafruit_I2C.readU8(i2c, Z_lsb) #Data is stored in 2 registers on the chip, the Least significant and the z_m = Adafruit_I2C.readS8(i2c, Z_msb) #most significant. Both must be read and the two combined into the actual number Zmag_raw = z_m << 8 | z_l Zmag = Zmag_raw/2048.0 * 1.3 #Calculate Gauss value from the raw 12 bit number y_l = Adafruit_I2C.readU8(i2c, Y_lsb) #rinse and repeat for each axis y_m = Adafruit_I2C.readS8(i2c, Y_msb) Ymag_raw = y_m << 8 | y_l Ymag = Ymag_raw/2048.0 * 1.3 x_l = Adafruit_I2C.readU8(i2c, X_lsb) x_m = Adafruit_I2C.readS8(i2c, X_msb) Xmag_raw = x_m << 8 | x_l Xmag = Xmag_raw/2048.0 * 1.3 mag_vector = np.array([Xmag,Ymag,Zmag]) return
#!/usr/bin/python import time from Adafruit_I2C import Adafruit_I2C #Create variable called i2c which refers to the address of the TPA2016 amplifier. i2c = Adafruit_I2C(0x58) TPA2016_SETUP = 0x1 TPA2016_SETUP_R_EN = 0x80 TPA2016_SETUP_L_EN = 0x40 TPA2016_SETUP_R_FAULT = 0x10 TPA2016_SETUP_L_FAULT = 0x08 TPA2016_GAIN = 0x5 TPA2016_AGC_OFF = 0x00 # def setup(): # Set up the speakers setup_speakers = i2c.readS8(TPA2016_SETUP) print 'Speaker setup value =', setup_speakers setup_rt_spkr = i2c.readS8(TPA2016_SETUP_R_EN) # write_rt_spkr = i2c.write8(TPA2016_SETUP_R_FAULT, 1) i2c.write8(TPA2016_SETUP_R_FAULT, 0) print 'Right Speaker value =', setup_rt_spkr # setup_rt_fault = i2c.readS8(TPA2016_SETUP_R_FAULT) # # write_rt_fault = i2c.write8(TPA2016_SETUP_R_FAULT, 1) # i2c.write8(TPA2016_SETUP_R_FAULT, 0) # print 'Right Speaker Fault value =', setup_rt_fault
pub = rospy.Publisher('mpu6050', Imu) rospy.init_node('MPU6050-Driver') #calibrate(imu, accel+gyro, samples = 0) global seq seq = 0 while not rospy.is_shutdown(): sample = Imu() sample.header = make_header() sample.orientation_covariance[0] = -1 sample.angular_velocity_covariance = [0] * 9 sample.angular_velocity = read_gyros() sample.linear_acceleration_covariance = [0] * 9 sample.linear_acceleration = read_accels() rospy.loginfo(str(sample)) pub.publish(sample) time.sleep(0.1) if __name__ == "__main__": try: global imu imu = Adafruit_I2C(0x68) # initializing the i2c device imu.write8(0x6b, 0) # waking the imu talker() # ROS Stuff except rospy.ROSInterruptException: pass
#!/usr/bin/python from Adafruit_I2C import Adafruit_I2C import time tester = Adafruit_I2C(0x05, 3, True) print "----------------------------------------" tester.write8(1,0x00) tester.write8(2,0x00) #print tester.readU8(5) print "----------------------------------------"
import Adafruit_BBIO.GPIO as GPIO import time from Adafruit_I2C import Adafruit_I2C #http://datasheets.maximintegrated.com/en/ds/DS3231M.pdf DS3231M_address = 0x68 RTC_address = 0x68 RTC_i2c = Adafruit_I2C(RTC_address) #RTC address information secondsAddress = 0x00 minutesAddress = 0x01 hoursAddress = 0x02 dayOfWeekAddress = 0x03 dayOfMonthAddress = 0x04 monthCenturAddressy = 0x05 yeaAddressr = 0x06 controlAddress = 0x0E statusAddress = 0x0F agingOffsetAddress = 0x10 temperatureMSBAddress = 0x11 temperatureLSBAddress = 0x12 seconds = 0x00 minutes = 0x00 hours = 0x00 dayOfWeek = 00000XXX dayOfMonth = 00NNXXXX
from Adafruit_I2C import Adafruit_I2C import time ADDR_ADC121 = 0x50 REG_ADDR_RESULT = 0x00 REG_ADDR_ALERT = 0x01 REG_ADDR_CONFIG = 0x02 REG_ADDR_LIMITL = 0x03 REG_ADDR_LIMITH = 0x04 REG_ADDR_HYST = 0x05 REG_ADDR_CONVL = 0x06 REG_ADDR_CONVH = 0x07 #i2c = Adafruit_I2C(ADDR_ADC121, debug=1) i2c = Adafruit_I2C(ADDR_ADC121) class I2cAdc: def __init__(self): i2c.write8(REG_ADDR_CONFIG, 0x20) def read_adc(self): data_list = i2c.readList(REG_ADDR_RESULT, 2) #print 'data list', data_list data = ((data_list[0] & 0x0f) << 8 | data_list[1]) & 0xfff return data if __name__ == '__main__': adc = I2cAdc()
sock_out = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #Code on Teensy: #uint8_t adc_pins[] = {A0,A1,A2,A3, A6,A7,A8,A9,A10,A11,A13,A14, A18,A19,A20}; adc_linpot_i = [11, 12, 0, 1, 2] adc_strain_i = [7, 6, 5, 4, 3] adc_jointpot_i = [13, 14, 10, 9, 8] index = 0 adc_linpot = [0, 0, 0, 0, 0] adc_strain = [0, 0, 0, 0, 0] adc_jointpot = [0, 0, 0, 0, 0] adc_values = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] i2c = Adafruit_I2C(9) #communication with Teensy at address 9 #Motor DIR GPIO.setup("P8_26", GPIO.OUT) GPIO.setup("P8_14", GPIO.OUT) GPIO.setup("P8_15", GPIO.OUT) GPIO.setup("P8_16", GPIO.OUT) GPIO.setup("P8_17", GPIO.OUT) #Motor PWM PWM.start("P9_31", 0.0) PWM.set_frequency("P9_31", 1000.0) PWM.start("P9_14", 0.0) PWM.set_frequency("P9_14", 1000.0) PWM.start("P8_19", 0.0) PWM.set_frequency("P8_19", 1000.0) PWM.start("P9_42", 0.0)
#f2 = open('rawData.csv','a'); f1.write("Datestamp,Timestamp,Latitude,Longitude,Speed,Course,Accel Z,Accel Y,Accel X,Accel Norm,Mag Z,Mag Y,Mag X,Mag Norm,Int Temp,Ext Temp,Pressure,Sound,\n") #f2.write("Datestamp,Timestamp,Latitude,Longitude,Speed,Course,Accel Z,Accel Y,Accel X,Mag Z,May Y,Mag X,Int Temp,Ext Temp,Pressure,Sound\n") while 1 : # get gps data gps = ser.readline() while(not gps.startswith('$GPRMC')): gps = ser.readline() gprmc.parse(gps) # I2C code for reading the magnetometer counter = 0 for counter in xrange(0,10): #send the commands several times to ensure Magnetometer receives the command Adafruit_I2C.write8(i2c, 0x00, 0x18) # 1 Average, 15 Hz, normal measurement Adafruit_I2C.write8(i2c, 0x01, 0x20) # Set Gain Adafruit_I2C.write8(i2c, 0x02, 0x00) # Continuous measurement counter += 1 z_l = Adafruit_I2C.readU8(i2c, Z_lsb) #Data is stored in 2 registers on the chip, the Least significant and the z_m = Adafruit_I2C.readS8(i2c, Z_msb) #most significant. Both must be read and the two combined into the actual number Zmag_raw = z_m << 8 | z_l Zmag = Zmag_raw/2048.0 * 1.3 #Calculate Gauss value from the raw 12 bit number y_l = Adafruit_I2C.readU8(i2c, Y_lsb) #rinse and repeat for each axis y_m = Adafruit_I2C.readS8(i2c, Y_msb) Ymag_raw = y_m << 8 | y_l Ymag = Ymag_raw/2048.0 * 1.3 x_l = Adafruit_I2C.readU8(i2c, X_lsb) x_m = Adafruit_I2C.readS8(i2c, X_msb)
#!/usr/bin/python import time import datetime from Adafruit_7Segment import SevenSegment from Adafruit_I2C import Adafruit_I2C # =========================================================================== # Clock Example # =========================================================================== i2CBus = Adafruit_I2C.getPiI2CBusNumber() # if using this example with a BeagleBone, uncomment the line below and specify # which I2C Bus the backpack is connected on. If connected to I2C1 (Header P9, # pin 17 & 18) specify 1, if connected to I2C2 (Header P9, pin 19 & 20) specify 3. # WARNING: if using with a BeagleBone use a logic-level convertor such as this one # https://www.adafruit.com/products/757 # i2CBus = 1 | 3 segment = SevenSegment(address=0x70, bus=i2CBus) print "Press CTRL+Z to exit" # Continually update the time on a 4 char, 7-segment display while(True): now = datetime.datetime.now() hour = now.hour minute = now.minute second = now.second # Set hours segment.writeDigit(0, int(hour / 10)) # Tens
class PWM: # Registers/etc. __MODE1 = 0x00 __MODE2 = 0x01 __SUBADR1 = 0x02 __SUBADR2 = 0x03 __SUBADR3 = 0x04 __PRESCALE = 0xFE __LED0_ON_L = 0x06 __LED0_ON_H = 0x07 __LED0_OFF_L = 0x08 __LED0_OFF_H = 0x09 __ALL_LED_ON_L = 0xFA __ALL_LED_ON_H = 0xFB __ALL_LED_OFF_L = 0xFC __ALL_LED_OFF_H = 0xFD # Bits __RESTART = 0x80 __SLEEP = 0x10 __ALLCALL = 0x01 __INVRT = 0x10 __OUTDRV = 0x04 general_call_i2c = Adafruit_I2C(0x00) @classmethod def softwareReset(cls): "Sends a software reset (SWRST) command to all the servo drivers on the bus" cls.general_call_i2c.writeRaw8(0x06) # SWRST def __init__(self, address=0x40, debug=False): self.i2c = Adafruit_I2C(address) self.i2c.debug = debug self.address = address self.debug = debug if (self.debug): print "Reseting PCA9685 MODE1 (without SLEEP) and MODE2" self.setAllPWM(0, 0) self.i2c.write8(self.__MODE2, self.__OUTDRV) self.i2c.write8(self.__MODE1, self.__ALLCALL) time.sleep(0.005) # wait for oscillator mode1 = self.i2c.readU8(self.__MODE1) mode1 = mode1 & ~self.__SLEEP # wake up (reset sleep) self.i2c.write8(self.__MODE1, mode1) time.sleep(0.005) # wait for oscillator def setPWMFreq(self, freq): "Sets the PWM frequency" prescaleval = 25000000.0 # 25MHz prescaleval /= 4096.0 # 12-bit prescaleval /= float(freq) prescaleval -= 1.0 if (self.debug): print "Setting PWM frequency to %d Hz" % freq print "Estimated pre-scale: %d" % prescaleval prescale = math.floor(prescaleval + 0.5) if (self.debug): print "Final pre-scale: %d" % prescale oldmode = self.i2c.readU8(self.__MODE1) newmode = (oldmode & 0x7F) | 0x10 # sleep self.i2c.write8(self.__MODE1, newmode) # go to sleep self.i2c.write8(self.__PRESCALE, int(math.floor(prescale))) self.i2c.write8(self.__MODE1, oldmode) time.sleep(0.005) self.i2c.write8(self.__MODE1, oldmode | 0x80) def setPWM(self, channel, on, off): "Sets a single PWM channel" self.i2c.write8(self.__LED0_ON_L + 4 * channel, on & 0xFF) self.i2c.write8(self.__LED0_ON_H + 4 * channel, on >> 8) self.i2c.write8(self.__LED0_OFF_L + 4 * channel, off & 0xFF) self.i2c.write8(self.__LED0_OFF_H + 4 * channel, off >> 8) def setAllPWM(self, on, off): "Sets a all PWM channels" self.i2c.write8(self.__ALL_LED_ON_L, on & 0xFF) self.i2c.write8(self.__ALL_LED_ON_H, on >> 8) self.i2c.write8(self.__ALL_LED_OFF_L, off & 0xFF) self.i2c.write8(self.__ALL_LED_OFF_H, off >> 8)
from Adafruit_I2C import Adafruit_I2C i2c = Adafruit_I2C(0x77) # some useful APIs are as follows: # class Adafruit_I2C # | Methods defined here: # | # | __init__(self, address, busnum=-1, debug=False) # | # | errMsg(self) # | # | readList(self, reg, length) # | Read a list of bytes from the I2C device # | # | readS16(self, reg) # | Reads a signed 16-bit value from the I2C device # | # | readS16Rev(self, reg) # | Reads a signed 16-bit value from the I2C device with rev byte order # | # | readS8(self, reg) # | Reads a signed byte from the I2C device # | # | readU16(self, reg) # | Reads an unsigned 16-bit value from the I2C device # | # | readU16Rev(self, reg) # | Reads an unsigned 16-bit value from the I2C device with rev byte order # | # | readU8(self, reg)
def __init__(self, address): Adafruit_I2C.__init__(self, address)
CUPHOLDER_2_PWM = 13 UNDER_SEAT_PWM_R = 0 UNDER_SEAT_PWM_G = 1 UNDER_SEAT_PWM_B = 2 UPPER_SHELL_RED = 8 UPPER_SHELL_GREEN = 9 UPPER_SHELL_BLUE = 10 ############################################################ # i2c ############################################################ # prox detection address GP2Y0E02B = 0x40 proxSensor1 = Adafruit_I2C(GP2Y0E02B) #proxSensor2 = Adafruit_I2C(VCNL4010_I2CADDR_DEFAULT) #PWM driver connected on i2c ledDriver = PWM(0x42) ######################################################################## # websocket ######################################################################## amcServerIP = '192.168.42.1' def on_show_video_1(message): if (message['id'] == ID): global player
#!/usr/bin/python from Adafruit_I2C import Adafruit_I2C from TSL2591 import TSL2591 if __name__ == "__main__": print "Revision", Adafruit_I2C.getPiRevision() chip = TSL2591(debug=True) chip.getFullLuminosity()
def __init__(self, busnum=-1, debug=False, hires=False): #define the pilight address self.pilight = Adafruit_I2C(self.PILIGHT_ADDRESS, busnum, debug)
B6C = 0x0101 # 0.0157 * 2^LUX_SCALE M6C = 0x0127 # 0.0180 * 2^LUX_SCALE K7C = 0x029a # 1.3 * 2^RATIO_SCALE B7C = 0x0037 # 0.00338 * 2^LUX_SCALE M7C = 0x002b # 0.00260 * 2^LUX_SCALE K8C = 0x029a # 1.3 * 2^RATIO_SCALE B8C = 0x0000 # 0.000 * 2^LUX_SCALE M8C = 0x0000 # 0.000 * 2^LUX_SCALE # bus parameters rev = GPIO.RPI_REVISION if rev == 2 or rev == 3: bus = smbus.SMBus(1) else: bus = smbus.SMBus(0) i2c = Adafruit_I2C(TSL2561_Address) debug = False packageType = 0 # 0=T package, 1=CS package gain = 0 # current gain: 0=1x, 1=16x [dynamically selected] gain_m = 1 # current gain, as multiplier timing = 2 # current integration time: 0=13.7ms, 1=101ms, 2=402ms [dynamically selected] timing_ms = 0 # current integration time, in ms channel0 = 0 # raw current value of visible+ir sensor channel1 = 0 # raw current value of ir sensor schannel0 = 0 # normalized current value of visible+ir sensor schannel1 = 0 # normalized current value of ir sensor def readRegister(address): try:
import datetime POCKETNC_DIRECTORY = "/home/pocketnc/pocketnc" INI_FILE = os.path.join(POCKETNC_DIRECTORY, "Settings/PocketNC.ini") sys.path.insert(0, os.path.join(POCKETNC_DIRECTORY, "Rockhopper")) from ini import read_ini_data, get_parameter import Adafruit_BBIO.GPIO as GPIO try: from Adafruit_GPIO.I2C import Device i2c = Device(0x60, 2) except: from Adafruit_I2C import Adafruit_I2C i2c = Adafruit_I2C(0x60) import hal import time iniData = read_ini_data(INI_FILE) spindleClockPinParam = get_parameter(iniData, "POCKETNC_PINS", "SPINDLE_CLOCK_PIN") resetTime = time.time() pulses = 0 def countPulses(x): global pulses pulses += 1
def __init__(self, address, busnum=-1, debug=False, height=4, width=20): Adafruit_I2C.__init__(self, address, busnum, debug) self.height = height self.width = width
#!/usr/bin/python from sys import exit from Adafruit_I2C import Adafruit_I2C from time import sleep import datetime import math import Adafruit_BMP.BMP085 as BMP085 CTRL_REG1_XM = 0x20 CTRL_REG2_XM = 0x21 WHO_AM_I_XM = 0x0F LSB_VAL = 0.732 accel = Adafruit_I2C(0x1D) sensor = BMP085.BMP085() INIT_ALT = 72 Po = sensor.read_sealevel_pressure( INIT_ALT) #must calibrate using a known itial state #our altimeter function def osu_aiaa_alt(s): alt = s.read_altitude(Po) alt -= INIT_ALT return alt accel_in = accel.readU8(WHO_AM_I_XM)
import time from Adafruit_I2C import Adafruit_I2C # this device has two I2C addresses DisplayRGB = Adafruit_I2C(0x62) DisplayText = Adafruit_I2C(0x3e) dot = [0b00111,\ 0b00101,\ 0b00111,\ 0b00000,\ 0b00000,\ 0b00000,\ 0b00000,\ 0b00000] class LCD(): def functionset(self): DisplayText.write8(0x20,0b00111100) def displaycontrol(self): DisplayText.write8(0x08, 0b11110000) def displayclear(self): DisplayText.write8(0x01, 100000000) def entrymodeset(self): DisplayText.write8(0x04, 111000000) def setText(self,texte): DisplayText.write8(0x80,0x01) time.sleep(.05) DisplayText.write8(0x80,0x08 | 0x04)
''' A fan is for blowing stuff away. This one is for Replicape. Author: Elias Bakken email: elias(dot)bakken(at)gmail(dot)com Website: http://www.thing-printer.com License: CC BY-SA: http://creativecommons.org/licenses/by-sa/2.0/ ''' from Adafruit_I2C import Adafruit_I2C import time PCA9685_MODE1 = 0x0 PCA9685_PRESCALE = 0xFE pwm = Adafruit_I2C(0x70, 1, False) # Open device pwm.write8(PCA9685_MODE1, 0x01) # Reset time.sleep(0.05) # Wait for reset class Fan: @staticmethod def set_PWM_frequency(freq): """ Set the PWM frequency for all fans connected on this PWM-chip """ prescaleval = 25000000 prescaleval /= 4096 prescaleval /= float(freq) prescaleval -= 1 prescale = int(prescaleval + 0.5)
def __init__(self, address=0x70): self.i2c = Adafruit_I2C(address) self.address = address self.i2c.write8(self.__LED_CONTROL, self.__FULLOFF)
# -*- coding: utf-8 -*- # Get heading from a HMC5883L magnetometer connected via I2C # # Requires Adafruit_I2C from: # https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/tree/master/Adafruit_I2C # # The Adafruit_I2C module included with the BBB doesn't have the ability to change # the endianness of the read 16-bit values # from Adafruit_I2C import Adafruit_I2C import math from time import sleep mag = Adafruit_I2C(0x1e) mag.write8(0x02, 0x00) while 1: # X- Register Z-Register Y-Register (x, z, y) = (mag.readS16(0x04, False), mag.readS16(0x06, False), mag.readS16(0x08, False)) # Scaling valuesbased on defaults from datasheet x = x / 1100 * 100 y = y / 1100 * 100 z = z / 980 * 100 # Convert X & Y angles to a heading headingRad = math.atan2(y, x) + (11 + 35 / 60) * (math.pi / 180) # Correct for reversed heading
magxPin = h.newpin("mag-x", hal.HAL_FLOAT, hal.HAL_OUT) magyPin = h.newpin("mag-y", hal.HAL_FLOAT, hal.HAL_OUT) magzPin = h.newpin("mag-z", hal.HAL_FLOAT, hal.HAL_OUT) accelxPin = h.newpin("accel-x", hal.HAL_FLOAT, hal.HAL_OUT) accelyPin = h.newpin("accel-y", hal.HAL_FLOAT, hal.HAL_OUT) accelzPin = h.newpin("accel-z", hal.HAL_FLOAT, hal.HAL_OUT) gyroxPin = h.newpin("gyro-x", hal.HAL_FLOAT, hal.HAL_OUT) gyroyPin = h.newpin("gyro-y", hal.HAL_FLOAT, hal.HAL_OUT) gyrozPin = h.newpin("gyro-z", hal.HAL_FLOAT, hal.HAL_OUT) h.ready() i2c_bus = int(args.bus_id) # /dev/i2c-2 mpu6050 = Adafruit_I2C(0x68, i2c_bus) # ADC 16bit hmc5883 = Adafruit_I2C(0x1e, i2c_bus) # ADC 12bit ms5611 = Adafruit_I2C(0x77, i2c_bus) # ADC 24bit # mpu6050 i2c master enable bit mpu6050.write8(0x6A, 0) # mpu6050 i2c bypass enable bit mpu6050.write8(0x37, 2) # mpu6050 turn off sleep mode mpu6050.write8(0x6B, 0) # hmc5883 continuous mode hmc5883.write8(0x02, 0x00) # ms5611 reset ms5611.writeList(0x1e, [])
import time from Adafruit_I2C import Adafruit_I2C as bus i2c = bus(0x70) bus.write16(i2c, 0x02, 0xff) while True : bus.write16(i2c, 0x00, 0x51) time.sleep(0.1) print bus.readS16(i2c, 0x03), ' ' , bus.readS16(i2c, 0x05)
#! /usr/bin/python2.7 from Adafruit_I2C import Adafruit_I2C reserved = [0,1,2,44,45,46,47,56,57,58,59,60,61,62] blocks = [] for address in range(0,128): if address in reserved: continue block = {} i2caddr = Adafruit_I2C(address) block['addr'] = address block['func'] = i2caddr.readU8(0) if block['func'] < 0: continue block['x'] = i2caddr.readU8(5) block['y'] = i2caddr.readU8(4) # print(block) blocks.append(block) func_to_str = { 36: 'A', 12: ':', 117: '3', 19: 'p', 0:' '
acc_y = [ACC_Y_MSB, ACC_Y_LSB] acc_z = [ACC_Z_MSB, ACC_Z_LSB] pitch = [PITCH_MSB, PITCH_LSB] roll = [ROLL_MSB, ROLL_LSB] yaw = [YAW_MSB, YAW_LSB] mag_x = [MAG_X_MSB, MAG_X_LSB] mag_y = [MAG_Y_MSB, MAG_Y_LSB] mag_z = [MAG_Z_MSB, MAG_Z_LSB] #dump registers into parent lists self.accel = [acc_x, acc_y, acc_z] self.gyro = [pitch, roll, yaw] self.mag = [mag_x, mag_y, mag_z] #set accelerometer and gyroscope data rate I2C.write8(self.accel_gyro_addr, CTRL_REG1_G, 0xc0) #0xc0 is 952 Hz #Method to read accelerometer data # def read_accel(self) # #initialize IMU #set accelerometer and gyroscope data rate #I2C.write8(accgy, 0x10, 0xc0) #0xc0 is 952 Hz #I2C.write8(accgy, 0x20, 0xc0) #set high resolution mode for accelerometer #I2C.write8(accgy, 0x21, 0x80) #set continuous FIFO mode #I2C.write8(accgy, 0x2E, 0xc0)
X_lsb = 0x04 Z_msb = 0x05 Z_lsb = 0x06 Y_msb = 0x07 Y_lsb = 0x08 i2c = Adafruit_I2C(mag_addr) #i2c_read = Adafruit_I2C(mag_read_addr) #i2c_write = Adafruit_I2C(mag_write_addr) while 1: x = 0 time.sleep(1) for x in xrange(0,10): Adafruit_I2C.write8(i2c, 0x00, 0x18) # 1 Average, 15 Hz, normal measurement Adafruit_I2C.write8(i2c, 0x01, 0x20) # Set Gain Adafruit_I2C.write8(i2c, 0x02, 0x00) # Continuous measurement x += 1 z_l = Adafruit_I2C.readU8(i2c, Z_lsb) z_m = Adafruit_I2C.readS8(i2c, Z_msb) z = z_m << 8 | z_l z = z/2048.0 * 1.3 y_l = Adafruit_I2C.readU8(i2c, Y_lsb) y_m = Adafruit_I2C.readS8(i2c, Y_msb) y = y_m << 8 | y_l y = y/2048.0 * 1.3 x_l = Adafruit_I2C.readU8(i2c, X_lsb) x_m = Adafruit_I2C.readS8(i2c, X_msb)
## Follow this guide on the adafruit_i2c module if this test code ## is not running. ## https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/i2c ## Probably, you need to apt-get python-smbus ## from Adafruit_I2C import Adafruit_I2C import time address = 0x6b #I2C address. can also be 0x6a if SD0 is grounded i2c = Adafruit_I2C(address) print "id: %d" % i2c.readU8(0x0F) #print device id. i2c.write8(0x20, 0x0F) #switch to normal mode i2c.write8(0x23, 0x00) #set resolution. time.sleep(1) n = 0 while n < 20000: time.sleep(.05) xlo = i2c.readU8(0x28) #read the xlo bit. it is signed xhi = i2c.readS8(0x29) #read the xhi bit. it is signed print((xlo | (xhi << 8)) * 0.00875) # bit shift into place and multiply n = n + 1
def __init__(self, address, busnum=-1, debug=False, height = 4, width = 20): Adafruit_I2C.__init__(self, address, busnum, debug) self.height = height self.width = width
from Adafruit_I2C import Adafruit_I2C i2c = Adafruit_I2C(0x6a,2) reg = 0 print i2c.readS16(0x4819c000) print reg
def __init__(self, address=0x6b, debug=False): self.i2c = Adafruit_I2C(address=address, debug=debug) self.address = address self.debug = debug self.i2c.write8(self.__L3G4200D_CTRL_REG1, self.__L3G4200D_CTRL_DEFAULT_POWER_ON)
def read_sensor(self): hival = Adafruit_I2C.write8(self.sensor_address, self.MEASURE_REG, self.MEASURE_VAL) sleep(.02) loval = self.read_raw(self.DISTANCE_REG_LO, False) hival = self.read_raw(self.DISTANCE_REG_HI, True) return ((hival << 8) + loval)
atexit.register(camera.close) camera.resolution = sizeData[sizeMode][1] #camera.crop = sizeData[sizeMode][2] camera.crop = (0.0, 0.0, 1.0, 1.0) # Leave raw format at default YUV, don't touch, don't set to RGB! # Load all icons at startup. for file in os.listdir(iconPath): if fnmatch.fnmatch(file, '*.png'): icons.append(Icon(file.split('.')[0])) # Initialize I2C try: # print "Initialize I2C" AdaI2C = Adafruit_I2C(0x36) Adafruit_I2C.__init__(AdaI2C, 0x36) AdaI2C.address = 0x36 # SparkFun "Fuel Gauge" AdaI2C.bus = smbus.SMBus(Adafruit_I2C.getPiI2CBusNumber()) Adafruit_I2C.write16(AdaI2C, 0xFE, 0x0054) # POR register Adafruit_I2C.write16(AdaI2C, 0x0C, 0x00FE) # RCOMP register time.sleep(10) # Initialize GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.IN) # Monitor Charging Status LED on LiPo Charger GPIO.setup(18, GPIO.OUT) # Controls an Alarm LED during last 20% Battey Life GPIO.output(18, GPIO.HIGH) updFuelGauge() getFuelLevel() # print "Default I2C bus is accessible" except: # print "Error accessing default I2C bus"
def __init__(self, address=0x1e, debug=False): self.i2c = Adafruit_I2C(address=address, debug=debug) self.address = address self.debug = debug self.powerOn()
# BeagleBone Black Health Sensors # Autores: Mario Baldini, Joao Baggio, Raimes Moraes POWER_CTL_addr = 0x2D DATA_FORMAT_addr = 0x31 import numpy import os import time import Adafruit_BBIO.ADC as ADC from time import sleep from Adafruit_I2C import Adafruit_I2C ADC.setup() adx1 = Adafruit_I2C(0x1d, 1) #(device addr, i2c bus addr) adx2 = Adafruit_I2C(0x53, 1) adx3 = Adafruit_I2C(0x1d, 2) adx4 = Adafruit_I2C(0x53, 2) adx1.write8(POWER_CTL_addr, 0x08) adx2.write8(POWER_CTL_addr, 0x08) adx3.write8(POWER_CTL_addr, 0x08) adx4.write8(POWER_CTL_addr, 0x08) #D7 D6 D5 D4 D3 D2 D1 #SELF_TEST SPI INT_INVERT FULL_RES Justify Range 1 Range 2 #0 1 1 0 0 0 1 #arduino 0x31 #0 0 0 0 0 0 0 #nosso: 2g adx1.write8(DATA_FORMAT_addr, 0x00)
def __init__(self, address=0x70, bus=Adafruit_I2C.getPiI2CBusNumber(), debug=False): if (debug): print "Initializing a new instance of LEDBackpack at 0x%02X" % address self.disp = LEDBackpack(address=address, bus=bus, debug=debug)