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_MFRC522(self, addr): val = spi.transfer((((addr<<1)&0x7E) | 0x80,0)) return val[1]
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 Write_MFRC522(self, addr, val): spi.transfer(((addr<<1)&0x7E,val))
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]
