def sendstr(self, content, address1, address2, address3, address4):
self.openSPI()
# SetTx
GPIO.output(self.TRX_CE, GPIO.LOW)
GPIO.output(self.TXEN, GPIO.HIGH)
sleep(0.01)
GPIO.output(self.CSN, GPIO.LOW)
spi.transfer((0x20,))
for i in range(32):
a = 32
if i < len(content):
a = ord(content[i])
spi.transfer((a,))
GPIO.output(self.CSN, GPIO.HIGH)
sleep(0.01)
GPIO.output(self.CSN, GPIO.LOW)
spi.transfer((0x22,))
spi.transfer((address1,))
spi.transfer((address2,))
spi.transfer((address3,))
spi.transfer((address4,))
GPIO.output(self.CSN, GPIO.HIGH)
GPIO.output(self.TRX_CE, GPIO.HIGH)
sleep(0.01)
GPIO.output(self.TRX_CE, GPIO.LOW)
spi.closeSPI()
def ReInit(self, dev='/dev/spidev0.0', spd=1000000):
spi.closeSPI(device=dev)
spi.openSPI(device=dev, speed=spd)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.NRSTPD, GPIO.OUT)
GPIO.output(self.NRSTPD, 1)
self.MFRC522_Init()
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 cleanup(self):
"""
Calls stop_crypto() if needed and cleanups GPIO.
"""
if self.authed:
self.stop_crypto()
GPIO.cleanup()
SPI.closeSPI()
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 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 gap():
while continue_reading:
for i in range(0, 10):
time.sleep(1)
if pygame.mixer.music.get_busy() == False:
list1[0] = "0"
list2[0] = "0"
try:
spi.closeSPI()
print("closed")
except:
print("")
time.sleep(5)
def MRFC522_AdvanceDevice(self):
# Advance to the next device in device_list
# (wrapping back to the first device after we reach the end)
self.curr_device_id = self.curr_device_id + 1
if (self.curr_device_id >= len(self.device_list)):
self.curr_device_id = 0
# Close the current SPI device, and open the next
spi.closeSPI()
spi.openSPI(device=self.device_list[self.curr_device_id],
speed=self.curr_speed)
# Finally call MFRC522's MFRC522_Init() method
super(MRFC522TeamTrack, self).MFRC522_Init()
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 writeconfig(self, address1, address2, address3, address4):
self.openSPI()
GPIO.output(self.CSN, GPIO.LOW)
spi.transfer((0x00,))
spi.transfer((0x4C,))
spi.transfer((0x0C,))
spi.transfer((0x44,))
spi.transfer((0x20,))
spi.transfer((0x20,))
spi.transfer((address1,))
spi.transfer((address2,))
spi.transfer((address3,))
spi.transfer((address4,))
spi.transfer((0x58,))
GPIO.output(self.CSN, GPIO.HIGH)
spi.closeSPI()
def main():
try:
# Specify GPIO mode
GPIO.setmode(GPIO.BOARD)
webserver = WebServer(port=8888, debug=True)
# Open and configure SPI interface
status = spi.openSPI(speed=1000000, mode=0)
print "SPI configuration: ",status
GPIO.setup(SPI_SEL1_PIN, GPIO.OUT)
GPIO.setup(SPI_SEL2_PIN, GPIO.OUT)
GPIO.setup(SPI_SEL3_PIN, GPIO.OUT)
print 'GPIOs initialized'
volume.change_handlers.append(volume_updated)
volume.open_handlers.append(volume_open)
volume.close_handlers.append(airset_close)
tone.change_handlers.append(tone_updated)
tone.open_handlers.append(tone_open)
tone.close_handlers.append(airset_close)
sustain.change_handlers.append(sustain_updated)
sustain.open_handlers.append(sustain_open)
sustain.close_handlers.append(airset_close)
webserver.websocket('/volume-value',volume)
webserver.websocket('/tone-value',tone)
webserver.websocket('/sustain-value',sustain)
webserver.websocket('/save-preset',
SharedValue(value=read_preset(), on_change=save_preset))
webserver.websocket('/get-preset',
SharedValue(on_change=get_preset))
webserver.static_files('/', './static')
print('Listening on %s' % webserver.url)
webserver.run()
except (KeyboardInterrupt, SystemExit):
print "Closing SPI..."
spi.closeSPI()
print "Cleaning up GPIO..."
GPIO.cleanup()
def write_to_shiftbrite(redval, greenval, blueval, controlbyte): tx_bytes = [] tx_bytes.append(((controlbyte<<6) & 255 ) | (blueval>>4)) tx_bytes.append(((blueval<<4) & 255) | redval>>6) tx_bytes.append(((redval<<2) & 255) | greenval>>8) tx_bytes.append(greenval & 255) print tx_bytes #GPIO.output(18, GPIO.HIGH) # ensure falling edge for SPI s = spi.openSPI(speed=10000) GPIO.output(18, GPIO.LOW) print spi.transfer(tuple(tx_bytes+tx_bytes+tx_bytes+tx_bytes+tx_bytes)) spi.closeSPI() GPIO.output(18, GPIO.HIGH) GPIO.output(18, GPIO.LOW) # latch registers
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 close(self): spi.closeSPI() GPIO.cleanup()
def AntennaOff(self): self.ClearBitMask(self.TxControlReg, 0x03) spi.closeSPI()
def closeSPI(self):
status = spi.closeSPI()
def close(self):
spi.closeSPI()
def Close_MFRC522(self): spi.closeSPI()
def sendCommand(self, spiMode=3):
spi.openSPI(mode=spiMode)
spi.transfer(self.command())
spi.closeSPI()
def close(self): spi.closeSPI()
def sendCommand(self, spiMode=3):
spi.openSPI(mode=spiMode)
spi.transfer(self.command())
spi.closeSPI()
#!/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)
def close(self):
self.refreshThreadStop.set()
# Wait for thread to stop
while(self.refreshThreadStop.is_set()):
pass
spi.closeSPI()
def __del__(self):
spi.closeSPI()
def __del__(self):
spi.closeSPI()
GPIO.output(15, GPIO.LOW)
GPIO.output(15, GPIO.HIGH)
GPIO.cleanup()
def fecha_spi(self):
spi.closeSPI()
print "SPI closed!"
def cleanup(self, device, pin):
GPIO.output(pin, GPIO.LOW)
GPIO.setup(pin, GPIO.IN)
spi.closeSPI()
for i in range(1,no_step+1):
tmp_theta=i*theta/no_step;
tmp_x_pos=xcenter+e1[0]*cos(tmp_theta)+e2[0]*sin(tmp_theta);
tmp_y_pos=ycenter+e1[1]*cos(tmp_theta)+e2[1]*sin(tmp_theta);
moveto(MX,tmp_x_pos,dx,MY, tmp_y_pos,dy,speed,True);
else: #Manual Control Mode
while True:
xsteps = int(raw_input("X Stepper Steps: "))
ysteps = int(raw_input("Y Stepper Steps: "))
laservar = int(raw_input("Laser state (1 on, 0 off): "))
GPIO.output(Laser_switch,laservar)
if (xsteps > 0):
MX.move(1,abs(xsteps),0.01)
else:
MX.move(-1,abs(xsteps),0.01)
if (ysteps > 0):
MY.move(1,abs(ysteps),0.01)
else:
MY.move(-1,abs(ysteps),0.01)
except KeyboardInterrupt:
pass
GPIO.output(Laser_switch,False); # turn off laser
moveto(MX,0,dx,MY,0,dy,50,False); # move back to Origin
MX.unhold();
MY.unhold();
spi.closeSPI();
GPIO.cleanup();
def __exit__(self, exc_type, exc_value, traceback):
spi.closeSPI()
def __del__(self):
spi.closeSPI()
GPIO.output(15,GPIO.LOW)
GPIO.output(15,GPIO.HIGH)
GPIO.cleanup()
def Close_MFRC522(self):
spi.closeSPI(self.spi_fd)
GPIO.cleanup()
def closeSPI(self):
status = spi.closeSPI()
data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(led_dict['camclose left'])) # Delay time.sleep(0.5) # Send ledmap data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(led_dict['camopen left'])) # Delay time.sleep(0.5) # Send ledmap data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(led_dict['heart left'])) # Delay time.sleep(2) # Send ledmap data = [0x26] spi.transfer(tuple(data)) spi.transfer(tuple(led_dict['open left'])) # Close SPI spi.closeSPI()
def fecha_spi(self):
spi.closeSPI()
#!/usr/bin/python
import spi
# This is a very simple script that uses the rPi SPI port to read out the various registers in a nRF24L01+ device
# connected to the rPI SPI port 0
# It should be pretty self-explanitory
status = spi.openSPI(speed=1000000)
print "SPI configuration = ", status
print "Reading nRF24L01 status registers:"
for x in range(28):
dat = spi.transfer((x, 0))
print "nRF Register 0x%X: %X" % (x, dat[1])
spi.closeSPI()
def fecha_spi(self):
spi.closeSPI()
print "GSPI closed!"
