def main(): # Open file descriptor for # spi device 0 using the CE0 pin for chip select device_0 = spi.openSPI(device="/dev/spidev0.0", mode=0, speed=1000000) # Open file descriptor for # spi device 0 using the CE1 pin for chip select device_1 = spi.openSPI(device="/dev/spidev0.1", mode=0, speed=1000000) # Transact data data_out = (0xFF, 0x00, 0xFF) # This is not necessary, not just demonstrate loop-back data_in = (0x00, 0x00, 0x00) data_in = spi.transfer(device_0, data_out) print("Received from device 0:") print(data_in) data_in = (0x00, 0x00, 0x00) data_in = spi.transfer(device_1, data_out) print("Received from device 1:") print(data_in) # Close file descriptors spi.closeSPI(device_0) spi.closeSPI(device_1)
def adc(self, cmd, osr): # osr: 0 = 256, 1 = 512, 2 = 1024, 3 = 2048, 4 = 4096 assert 0 <= osr <= 4 spi.transfer((cmd | (2 * osr),)) time.sleep(.01) # conversion time for osr=4096 is 8.22ms h, m, l = spi.transfer((0, 0, 0, 0))[1:] return (h << 16) | (m << 8) | l
def send(self, dc, data): gpio(self.dc, dc) if hasattr(data, "__iter__"): data = tuple(data) else: data = (data,) spi.transfer(data)
def _send_spi_string(self): self._job = None send_str = "0:%d:1:%d:\n" % (self.slider_horiz.get(), self.slider_vert.get()) print send_str l = tuple(map(ord, send_str)) print l spi.transfer((l))
def write(self, addr, vals, inc): transfer_tuple = () cmd = (addr << 2) + write_cmd + (inc << 1) transfer_tuple = transfer_tuple + ((cmd >> 8),) transfer_tuple = transfer_tuple + ((cmd & 0x00FF),) for v in vals: transfer_tuple = transfer_tuple + (v,) spi.transfer(transfer_tuple)
def setLaserPower(lines): zchar_loc=lines.index('Z'); i=zchar_loc+1; while (47<ord(lines[i])<58)|(lines[i]=='.')|(lines[i]=='-'): i+=1; lpowr=float(lines[zchar_loc+1:i]); lpow=int(lpowr*255); print 'Laser Pow= ', lpow; spi.transfer((0xB0000, 255-lpow))
def lcd_cmd(cmd): stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8) # print "LCD CMD(1)=%X, SPI_open=" % (cmd) , stat spi.transfer((0,cmd>>8,0x00ff&cmd,0x11)) # 0x11 - CMD_BE const from ili9341.c spi.closeSPI() # time.sleep(0.0001) # 100us stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8) # print "LCD CMD(2)=%X, SPI_open=" % (cmd) , stat spi.transfer((0,cmd>>8,0x00ff&cmd,0x1B)) # x01B - CMD_AF const from ili9341.c spi.closeSPI() return
def lcd_data(data): stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8) # print "LCD DATA(1)=%X, SPI_open=" % (data) , stat spi.transfer((0,data>>8,0x00ff&data,0x15)) # 0x15 - DATA_BE const from ili9341.c (BE is short form "before") spi.closeSPI() # time.sleep(0.00001) # 10us stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8) # print "LCD DATA(2)=%X, SPI_open=" % (data) , stat spi.transfer((0,data>>8,0x00ff&data,0x1F)) # 0x1F - DATA_AF const from ili9341.c (AF is short form "after") spi.closeSPI() return
def setTLCvalue(data,DCMode): # put the chip into DC mode GPIO.output(VPRG, DCMode) #print tuple(data) spi.transfer(tuple(data)) # latch data GPIO.output(XLAT, GPIO.HIGH) #time.sleep(0.25) GPIO.output(XLAT, GPIO.LOW) GPIO.output(VPRG, GPIO.LOW)
def lcd_reset(): # for reset I use slow clock - just my habit stat = spi.openSPI(SPI_DEVICE,speed=1000000,bits=8) # print "LCD RESET(1), SPI_open=",stat spi.transfer((0,0,0,0)) # set 0 on U1-Q2 spi.closeSPI() time.sleep(0.05) # 50ms reset # unreset stat = spi.openSPI(SPI_DEVICE,speed=1000000,bits=8) # print "LCD RESET(2), SPI_open=",stat spi.transfer((0,0,0,2)) # set 1 on U1-Q2 spi.closeSPI() time.sleep(0.1) # 100ms after reset return
def _write_register(self, reg, value): """Writes the entire register, identified by its name (datasheet).""" if reg in short_addr_registers: reg_addr = short_addr_registers[reg] bytes = [((reg_addr << 1) + self.short_write_mask), value] else: if reg in long_addr_registers: reg_addr = long_addr_registers[reg] else: reg_addr = reg bytes = [] bytes.append((reg_addr >> 3) + self.long_addr_bit) bytes.append(((reg_addr << 5) & 0xE0) + self.long_write_mask) bytes.append(value) spi.transfer(tuple(bytes))
def transfer(self, data=[]): if isinstance(data,str): data = [ord(x) for x in data] data = tuple(data) data = spi.transfer(data) dataout = "".join([chr(x) for x in data]) return dataout
def drive(self, dev, value): if self.devMaxX or self.devMinX or self.devMaxY or self.devMinY is None: raise Exception("Must override X min and max values") try: try: dev = int(dev) except ValueError,e: print "need numeric device ID" if dev == 1: newVal = self.__convertValueX(value) if dev == 2: newVal = self.__convertValueY(value) else: newVal = value spi.transfer((dev, self.__getBits(newVal)))
def spi_transfer(self, data): if self.pin_ce != 0: GPIO.output(self.pin_ce, 0) r = SPI.transfer(data) if self.pin_ce != 0: GPIO.output(self.pin_ce, 1) return r
def writecmd(self, app, verb, count=0, data=[]): if verb: # ignore all but R/W cmd return if isinstance(data,str): data = [ord(x) for x in data] data = tuple(data) data = spi.transfer(data) self.data = "".join([chr(x) for x in data])
def LEDspit(COLOR): #data = ["0000000000001" + COLOR * (8 * 50 + 8) ] # data = (0, ) * 50 + 0099991 # Start bits for LEDs basedata = 0, 0, 0, 1, # 62 * 4 bytes + 4 bytes works- 63 craps out, as PyArg_ParseTupleAndKeywords function only seems to support ints of 32 bits. data = basedata + (50, 0, 255, 1) * 408 # data = tuple(data) #Calculates the length, and devides by 2 for two bytes of data sent. # length_data = len(data[0])/2 #transfers data string #print 'Value transfered to C spimodule:',data #for i, printdata in enumerate(data): spi.transfer((data)) #sleep(SLEEPTIME) data = basedata + (0, 255, 0, 1) * 408 spi.transfer((data))
def read(self, addr, nb, inc): transfer_tuple = () cmd = (addr << 2) + read_cmd + + (inc << 1) transfer_tuple = transfer_tuple + ((cmd >> 8),) transfer_tuple = transfer_tuple + ((cmd & 0x00FF),) transfer_tuple = transfer_tuple + tuple([0]*nb) data = spi.transfer(transfer_tuple) return list(data)[2:]
def _read_register(self, reg): """Reads the entire register, identified by its name (datasheet).""" if reg in short_addr_registers: reg_addr = short_addr_registers[reg] bytes = [(reg_addr << 1), 0] result = spi.transfer(tuple(bytes)) return result[1] else: if reg in long_addr_registers: reg_addr = long_addr_registers[reg] else: reg_addr = reg bytes = [] bytes.append((reg_addr >> 3) + self.long_addr_bit) bytes.append((reg_addr << 5) & 0xE0) bytes.append(0) result = spi.transfer(tuple(bytes)) return result[2]
def prom(self): words = [] for i in range(8): h, l = spi.transfer((0xa0 | (2*i), 0, 0))[1:] words.append(h << 8 | l) assert any(words) verify_crc4(words) self.C = words assert len(self.C) == 8
def issue_write(self, data): """ Emulate the facedancer's write command, which blasts data directly over to the SPI bus. """ if isinstance(data,str): data = [ord(x) for x in data] data = tuple(data) data = spi.transfer(data) return bytearray(data)
def write(self, gcode_h): if config[botname]["type"] == "dev": self.dev.write(gcode_h.gcode) self.readLine = self.dev.readline() elif config[botname]["type"] == "file": self.f.write(gcode_h.gcode + "\n") self.f.flush() self.readLine = "this is a file, can not read robot return" elif config[botname]["type"] == "spi": # compute crc on last 7 bytes crc = 0 for b in gcode_h.gcode: crc += ord(b) crc &= 0xFF # keep only last byte print (crc) self.readLine = "\n" list_c = tuple(map(ord, list(gcode_h.gcode)) + [crc, 10]) print list_c spi.transfer(list_c) elif config[botname]["type"] == "socket": self.socket.sendall(bytes(gcode_h.gcode + "\n", "UTF-8")) self.readLine = self.socket.recv(1024).decode("UTF-8")
def listen(self, callback): self.openSPI() # SetRx GPIO.output(self.TXEN, GPIO.LOW) GPIO.output(self.TRX_CE, GPIO.HIGH) while 1 == 1: while GPIO.input(self.DR) == GPIO.LOW: a = 10 GPIO.output(self.TRX_CE, GPIO.LOW) GPIO.output(self.CSN, GPIO.LOW) spi.transfer((0x24,)) data = "" for x in range(32): data = data + chr(spi.transfer((0x00,))[0]) # print("2:"+data) callback(data) GPIO.output(self.CSN, GPIO.HIGH) GPIO.output(self.TRX_CE, GPIO.HIGH) sleep(0.01) spi.closeSPI()
def draw_eyes(self, left_eye, right_eye): self.clear_eyes() if self.debug > 0: print 'Drawing eyes: ' + left_eye + ', ' + right_eye if self.debug < 2: data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(self.led_dict[right_eye])) time.sleep(0.01) spi.transfer(tuple(self.led_dict[left_eye]))
def clear_eyes(self): if self.debug > 0: print 'Clearing eyes' if self.debug < 2: data = [0x26] spi.transfer(tuple(data)) data = [] for i in range(0, 64): data.append(0x00) spi.transfer(tuple(data)) time.sleep(0.01) spi.transfer(tuple(data))
def dumpconfig(self): GPIO.output(NRF_CSN,0) cfg = spi.transfer((R_CONFIG,0,0,0,0,0,0,0,0,0,0)) GPIO.output(NRF_CSN,1) print("STATUS = 0x%0.2x" % cfg[0]) print("CHANNEL = 0x%0.2x %d" % (cfg[1],cfg[1])) print("AUTO_RETRAN = 0x%0.2x RX_RED_PWR = 0x%0.2x PWR = 0x%0.2x BAND = 0x%0.2x" % (cfg[2]& NRF905_MASK_AUTO_RETRAN,cfg[2]& NRF905_MASK_LOW_RX, cfg[2]& NRF905_MASK_PWR, cfg[2]& NRF905_MASK_BAND)) print("RX_AFW = 0x%0.2x TX_AFW = 0x%0.2x" %((cfg[3] & 0x70)>>4,cfg[3] & 0x7)) print("RX_PW = 0x%0.2x TX_PW = 0x%0.2x" % (cfg[4]& 0x3f,cfg[5]& 0x3f)) print("RX_ADDRESS = 0x%0.2x%0.2x%0.2x%0.2x" % (cfg[6],cfg[7],cfg[8],cfg[9])) print("CRC_MODE = 0x%0.2x CRC_EN = 0x%0.2x XOF = 0x%0.2x OUTCLK = 0x%0.2x OUTCLK_FREQ = 0x%0.2x" % ((cfg[10] & NRF905_MASK_CRC_MODE)>>7, (cfg[10] & NRF905_MASK_CRC)>>6,(cfg[10] & NRF905_MASK_CLK)>>3,(cfg[10] & NRF905_MASK_OUTCLK)>>2,cfg[10] & NRF905_MASK_OUTCLK_FREQ)) return cfg
def Write_MFRC522(self, addr, val): spi.transfer(self.dev_dictionary, ((addr << 1) & 0x7E, val))
def read(address): val = spi.transfer((((address << 1) & 0x7E) | 0x80, 0)) return val[1]
# import signal from time import sleep ### modify any SPI settings as required dev='/dev/spidev0.0' spd=1000000 spi.openSPI(device=dev,speed=spd) # GPIO.setmode(GPIO.BOARD) ### start the loop count = 0 while (count < 1000): vals = count ## uncomment this part for basic flashing (no counting) # if count % 2 == 0: # vals = 0b1111 # else: # vals = 0b0000 spi.transfer((0x00, vals)) sleep(0.5) rdVal = spi.transfer((0x00, 0)) print 'Read back (MISO - QH`): ', bin(rdVal[0]), rdVal[0] print 'Flash count:', count count = count + 1 print 'Finished'
def Read_MFRC522(self, addr): val = spi.transfer((((addr<<1)&0x7E) | 0x80,0)) return val[1]
def reset(self): spi.transfer((0x1e,))
def dev_write(self, addr, val): spi.transfer(((addr << 1) & 0x7E, val))
def read(self, address): value = spi.transfer((((address << 1) & 0x7E) | 0x80, 0)) return value[1]
def receive(self, addr): val = spi.transfer((((addr << 1) & 0x7E) | 0x80, 0)) return val[1]
def Write_MFRC522(self, addr, val): spi.transfer(((addr<<1)&0x7E,val))
def send(self, addr, val): spi.transfer(((addr << 1) & 0x7E, val))
import spi spi.openSPI(speed=2000000) val = spi.transfer((0x9F, 0x0, 0x0, 0x0)) print "%x %x %x %x" % (val[0], val[1], val[2], val[3]) val = spi.transfer((0x90, 0x0, 0x0, 0x0, 0x0, 0x0)) print "%x %x" % (val[4], val[5])
print "need numeric device ID or value" newVal = value if dev == 1: newVal = self.__convertValueY(value) if dev == 2: newVal = self.__convertValueX(value) except Exception, e: print dev, value, newVal # spi.transfer((0x00, 0, 0, 0)) print 'Shutting Down', e spi.closeSPI() sys.exit(1) try: a, b, c = self.__getBits(newVal) if dev == 1: dev = 0x01 if dev == 2: dev = 0x02 send = (dev, a, b, c) print 'sending: ', send print spi.transfer(send) except Exception, e: print "Couldn't transfer over SPI", e spi.closeSPI() print dev, newVal, self.__getBits(newVal) sys.exit(1)
def write(address, val): spi.transfer(((address << 1) & 0x7E, val))
#!/usr/bin/python import spi ret = spi.openSPI(speed=1000000) print("openSPI returns: "), ret fd = ret["fd"] print("fd = "), fd print("Reading nRF24L01 status registers:") for x in range(28): dat = spi.transfer(fd, (x, 0)) print("nRF Register 0x%X: %X") % (x, dat[1]) spi.closeSPI(fd)
if comports != []: ind = input( "\nEscolha a porta Serial onde esta conectado o Conversor RS845: ") else: print( "Nenhuma porta serial detectada ! \nPressione enter para atualizar" ) input() try: ind = int(ind) comport = serial.Serial(comports[ind], baudrate=BAUDRATE) comport.close() comport = comports[ind] break except: print("Comport inválida, tente outra!") comport = 0 spi = spi.SPI(comport) spi.mode = spi.SPI.MODE_0 spi.bits_per_word = 8 spi.speed = 1000000 received = spi.transfer([0x11, 0x22, 0xFF]) spi.write([0x12, 0x34, 0xAB, 0xCD]) received = spi.read(10)
import spi status = spi.openSPI(speed=500000) print "SPI configuration = ", status print "Reading from Arduinos:" dat = spi.transfer((1, 3, 5)) for i in range(len(dat)): print dat[i] spi.closeSPI()
def write(self, address, value): spi.transfer(((address << 1) & 0x7E, value))
def sendCommand(self, spiMode=3): spi.openSPI(mode=spiMode) spi.transfer(self.command()) spi.closeSPI()
def dev_read(self, addr): val = spi.transfer((((addr << 1) & 0x7E) | 0x80, 0)) return val[1]
def __read__(self, address): assert (address >= 0 and address <= 0x07) return spi.transfer((address, 0))[1]
# https://github.com/lthiery/SPI-Py # # 26 Mar 2013 - Mike Hord, SparkFun Electronics # # This code is beerware- if you find it useful, please buy me (or, for that # matter, any other SparkFun employee you met) a pint next time you meet us at # the local. # ############################################################################## #!/usr/bin/env python import spi ## The openSPI() function is where the SPI interface is configured. There are ## three possible configuration options, and they all expect integer values: ## speed - the clock speed in Hz ## mode - the SPI mode (0, 1, 2, 3) ## bits - the length of each word, in bits (defaults to 8, which is standard) ## It is also possible to pass a device name, but the default, spidev0.0, is ## the only device currently supported by the pcDuino. spi.openSPI(speed=1000000, mode=0) ## Data is sent as a tuple, so you can construct a tuple as long as you want ## and the result will come back as a tuple of the same length. print spi.transfer((0x0B, 0x02, 0x00)) ## Finally, close the SPI connection. This is probably not necessary but it's ## good practice. spi.closeSPI()
def __write__(self, address, n): assert (address >= 0 and address <= 0x07) assert (n >= 0 and n <= 0xFF) spi.transfer((address | 0x80, n))
def send_byte(register, data): spi.transfer((register, data))
print led_dict['1 left'] # Set pin modes MODE = 2 MODE_FILE = '/sys/devices/virtual/misc/gpio/mode/gpio' for i in range(10, 14): file = MODE_FILE + str(i) os.system('echo ' + str(MODE) + ' > ' + file) # Init SPI spi.openSPI(speed=100000, mode=0, device='/dev/spidev0.0') # Initialize wtih number of boards data = [0x25, 0x01] spi.transfer(tuple(data)) # Clear LED matrix data = [0x26] spi.transfer(tuple(data)) data = [] for i in range(0, 64): data.append(0x00) spi.transfer(tuple(data)) # Send ledmap data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(led_dict['open left'])) # Delay
def Read_MFRC522(self, addr): val = spi.transfer(self.dev_dictionary, (((addr << 1) & 0x7E) | 0x80, 0)) return val[1]