def __init__(self,
freqs=8000000,
debug=None,
brightness=100,
pixel_order=PixelFormat.gbr,
spi_dev=None):
BaseDriver.__init__(self)
self.supportsChangeColor = False
try:
import mraa
self.spiDev = mraa.Spi(0)
self.spiDev.frequency(freqs)
except Exception:
print("Apa102Driver: SPI not available. Using FakeSPI")
self.spiDev = FakeSpi()
# Global brightness setting 0-100%
self.brightness = brightness
"""
Set the color order of the lights. This is used to convert
RGB (the default format) to the right physical colors on the
light.
"""
self.pixel_order = pixel_order
# Constant data structures:
self.header = [0x00, 0x00, 0x00, 0x00]
self.numLeds = None
def __init__(self, dev=0, spd=1000000): pin_22 = mraa.Gpio(self.NRSTPD) # Initialize GPIO2 (P10 on LinkIt Smart 7688 board) pin_22.dir(mraa.DIR_OUT) # set as OUTPUT pin spi = mraa.Spi(0) spi.frequency(spd) pin_22.write(1) self.MFRC522_Init()
def __init__(self, cs):
self.spi = mraa.Spi(0)
self.cs = mraa.Gpio(23) if cs == 0 else mraa.Gpio(9)
self.cs.dir(mraa.DIR_OUT)
self.cs.write(1)
self.spi.frequency(100000)
self.spi.mode(mraa.SPI_MODE3)
# first write a dummy byte
self.spi.writeByte(0)
def SPI_init():
global SPI_port
try:
SPI_port = m.Spi(spi_p)
print("Initializing port " + str(spi_p) + " as SPI")
return 0
except ValueError:
print(sys.exc_info()[1][0])
return 1
def __init__(self, freqs=800000, debug=None):
BaseDriver.__init__(self)
try:
import mraa
self.spiDev = mraa.Spi(0)
self.spiDev.frequency(freqs)
except Exception:
print("Ws2801Driver: SPI not available. Using FakeSPI")
self.spiDev = FakeSpi()
def __init__(self):
self.rfid_device = mraa.Spi(0)
#self.rfid_device.frequency(1000000)
self.RST = mraa.Gpio(9)
self.RST.dir(mraa.DIR_OUT)
self.RST.write(1)
# 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 configureArduinoSpi(self):
btnchoicewind = ButtonChoiceWindow(screen=self.topmenu.gscreen,
title='Enable SPI on IO10-IO13',
text='',
buttons=['Enable', 'Disable', ('Cancel', 'ESC')],
width=40)
if btnchoicewind == 'cancel':
return
elif btnchoicewind == 'enable':
spi = mraa.Spi(0)
self.setPinmuxOfUserConfig('SPI')
elif btnchoicewind == 'disable' and self.checkPinmuxConfig('SPI'):
self.resetPinmuxOfUserConfig('SPI')
self.saveConfig(self.config)
def __init__(self):
self.target = 0x00
self.state = 'PREOPERATION'
self.data = 0
self.rxbuf = ""
# delay related
self.delay_state = 'clear'
self.delay_duration = 0
self.timestamp = 0
self.spi = mraa.Spi(0)
self.spi.mode(0)
self.spi.frequency(1000000) # 1MHz
def __init__(self, cs, spi_mode=mraa.SPI_MODE3):
self.spi = mraa.Spi(0)
if cs==0:
self.cs = mraa.Gpio(23)
elif cs==1:
self.cs = mraa.Gpio(9)
elif cs==2:
self.cs = mraa.Gpio(32)
self.cs.dir(mraa.DIR_OUT)
self.cs.write(1)
self.spi.frequency(2000000) # 2 MHz
self.spi.mode(spi_mode)
self.spi_mode = spi_mode
self._WRITE_MAX = 20
# first write a dummy byte
self.spi.writeByte(0)
def _init_spi(self):
"""
Initialize the SPI hardware. This function will setup all SPI pins and related hardware.
"""
self._iocls = mraa.Spi(0)
# Maximum SPI frequency is 10MHz, lets set the frequency to 4MHz:
self._iocls.frequency(SPI_CLOCK_4MHZ)
# Data is read and written MSb first.
self._iocls.lsbmode(False)
# Data is captured on rising edge of clock (CPHA = 0)
# Base value of the clock is HIGH (CPOL = 1)
self._iocls.setDataMode(SPI_MODE1)
return
def __init__(self):
# Initialize an ADS1299 object
self.SETTINGS = Settings()
self.SETTINGS.update(ADS1299.DEFAULT_SETTINGS)
try:
# Lazy import local settings when __init__ is called.
# If local settings exist, overwrite this object settings.
from .settings import LOCAL_SETTINGS
self.SETTINGS.update(LOCAL_SETTINGS)
except ImportError:
pass
# Initialize SPI for ADS1299
self.spi = mraa.Spi(self.SETTINGS.SPI_CHANNEL)
self.spi.frequency(self.SETTINGS.SPI_FREQUENCY)
self.spi.mode(self.SETTINGS.SPI_MODE)
# Initialize hardware control for ADS1299
self.hardware = Hardware()
self.hardware.power = self.init_gpio(self.SETTINGS.PIN_POWER,
mraa.DIR_OUT_LOW,
mraa.MODE_STRONG)
self.hardware.reset = self.init_gpio(self.SETTINGS.PIN_RESET,
mraa.DIR_OUT_HIGH,
mraa.MODE_STRONG)
self.hardware.start = self.init_gpio(self.SETTINGS.PIN_START,
mraa.DIR_OUT_LOW,
mraa.MODE_STRONG)
self.hardware.ready = self.init_gpio(self.SETTINGS.PIN_READY,
mraa.DIR_IN, mraa.MODE_HIZ)
self.hardware.chip_select = self.init_gpio(
self.SETTINGS.PIN_CHIP_SELECT, mraa.DIR_OUT_HIGH, mraa.MODE_STRONG)
self.hardware.chip_select_2 = self.init_gpio(
self.SETTINGS.PIN_CHIP_SELECT_2, mraa.DIR_OUT_HIGH,
mraa.MODE_STRONG)
self.hardware.power.write(1) # power up
# wait for internal reference waking up (150ms)
# wait for internal clock waking up (20us)
# wait for external cloxk waking up (1.5ms)
sleep(160 * 10**(-3))
self.hardware.reset.write(0) # reset ADS1299
sleep(1 * 10**(-3)) # wait for reset register (18 CLK)
self.hardware.reset.write(1) # finish reseting ADS1299
# Connect Register controller for ADS1299
self.register = Register(self.spi, self.hardware.chip_select)
def __init__(self):
# Set up the wiringpi object to use physical pin numbers
# wp.wiringPiSetupPhys()
# Intel MRAA
# CS_PIN = 15 GPIO(22)
# DRDY_PIN = 11 GPIO(17)
# RESET_PIN = 12 GPIO(18)
# PDWN_PIN = 13 GPIO(27)
self.CS_PIN = m.Gpio(15) #phy. 15
self.DRDY_PIN = m.Gpio(11) #phy. 11
self.RESET_PIN = m.Gpio(12) #phy. 12
self.PDWN_PIN = m.Gpio(13) #phy. 13
# Initialize the DRDY pin
self.DRDY_PIN.dir(m.DIR_IN)
# wp.pinMode(self.DRDY_PIN, wp.INPUT)
# Initialize the reset pin
self.RESET_PIN.dir(m.DIR_OUT)
self.RESET_PIN.write(1)
# reset = m.Gpio(15).dir(m.DIR_OUT)
# wp.pinMode(self.RESET_PIN, wp.OUTPUT)
# wp.digitalWrite(self.RESET_PIN, wp.HIGH)
# self.reset.write(1)
# Initialize PDWN pin
self.PDWN_PIN.dir(m.DIR_OUT)
self.PDWN_PIN.write(1)
# wp.pinMode(self.PDWN_PIN, wp.OUTPUT)
# wp.digitalWrite(self.PDWN_PIN, wp.HIGH)
# Initialize CS pin
self.CS_PIN.dir(m.DIR_OUT)
self.CS_PIN.write(1)
#wp.pinMode(self.CS_PIN, wp.OUTPUT)
#wp.digitalWrite(self.CS_PIN, wp.HIGH)
# Initialize the wiringpi SPI setup
#spi_success = wp.wiringPiSPISetupMode(self.SPI_CHANNEL, self.SPI_FREQUENCY, self.SPI_MODE)
self.x = m.Spi(self.SPI_CHANNEL)
self.x.frequency(self.SPI_FREQUENCY)
self.x.mode(self.SPI_MODE)
spi_success = self.x
debug_print("SPI success " + str(spi_success))
def __init__(self, gyro_scale=250.0, accel_scale=2.0):
super(Mpu9250, self).__init__()
self.gyro_scale = gyro_scale # 250, 500, 1000 or 2000 deg/s
self.accel_scale = accel_scale # 2, 4, 8 or 16 g
self.compass_scale = 1200.0 # 1200 uT
self.dev = mraa.Spi(0)
self.dev.mode(mraa.SPI_MODE3)
self.dev.frequency(800000)
self.dev.bitPerWord(16)
self.__setup_conf()
# Compute scaling factors
self.gyro_scaling = (65536.0 / (2 * gyro_scale)) * (180.0 / math.pi)
self.accel_scaling = 65536.0 / (2 * accel_scale * 9.81)
self.compass_scaling = 4000.0 / self.compass_scale
def __init__(self):
self.RS = mraa.Gpio(36) #GP_IO14
self.RS.dir(mraa.DIR_OUT)
self.RS.write(1)
self.CS = mraa.Gpio(48) #GP_IO15
self.CS.dir(mraa.DIR_OUT)
self.CS.write(1)
self.SPI = mraa.Spi(5)
self.SPI.frequency(20000)
print "Init"
try:
from PIL import Image, ImageDraw
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 48
self.buffer = Image.new("1", (SCREEN_WIDTH,SCREEN_HEIGHT), "black") #"white"
self.draw = ImageDraw.Draw(self.buffer)
except ImportError:
raise NoSuchLibraryError('PIL')
def __init__(self, port, device, mode=0, speed=5000000):
self.spi = mraa.Spi(port)
self.spi.frequency(speed)
self.spi.mode(mode)
def __init__(self):
self.init = m.Spi(0) #Initialise SPI bus
self.total_val = 0
#!/usr/bin/env python # -*- coding: utf8 -*- import mraa spi = mraa.Spi(0) import signal import time class MFRC522: NRSTPD = 37 MAX_LEN = 16 PCD_IDLE = 0x00 PCD_AUTHENT = 0x0E PCD_RECEIVE = 0x08 PCD_TRANSMIT = 0x04 PCD_TRANSCEIVE = 0x0C PCD_RESETPHASE = 0x0F PCD_CALCCRC = 0x03 PICC_REQIDL = 0x26 PICC_REQALL = 0x52 PICC_ANTICOLL = 0x93 PICC_SElECTTAG = 0x93 PICC_AUTHENT1A = 0x60 PICC_AUTHENT1B = 0x61 PICC_READ = 0x30 PICC_WRITE = 0xA0 PICC_DECREMENT = 0xC0
def dsensors():
spi = mraa.Spi(0) #Bus comunication
spi.mode(mraa.SPI_MODE0) #Comunication MODE0
spi.frequency(4100000) #Frequency of 4.1MHz
spi.lsbmode(False) #Format data MSB
ss = mraa.Gpio(9) #wire CS1
ss.dir(mraa.DIR_OUT)
ss.write(1)
sc = mraa.Gpio(8) #wire CS2
sc.dir(mraa.DIR_OUT)
sc.write(1)
def readadc(pinaleer, ss):
dieccionaleer = 0x0c #Input c=1100 so Output data length 16bits, MSB first, Unipolar
pinaleer = int(hex(pinaleer), 16) #address bits (4)
dieccionaleer = dieccionaleer | (pinaleer << 4
) #Put address bit in the 4th bits
#Comunication
ss.write(0) #CS=0 <-- Enables the device
esc = spi.writeByte(dieccionaleer) #First byte with input info
esc2 = spi.writeByte(0x00) #Complete the 16bits --> Clock
ss.write(1) #CS=1 <--- Disables the device
time.sleep(0.00020) #Wait more time than 10us= time conversion AD
ss.write(0) #CS=0 <-- Enables the device
primerbyte = spi.writeByte(0x00) #First byte with 8bit of information
segundobyte = spi.writeByte(
0x00) #Second byte with 4bit (MSB) information , 8+4=12bits
ss.write(1) #CS=1 <--- Disables the device
salida1 = 0x0000
salida1 = salida1 | (primerbyte << 8)
salida1 = salida1 | (segundobyte)
salida = (salida1 >> 4) + 1 #Output 12bits
return salida
dato1 = readadc(0, ss)
dato2 = readadc(1, ss)
dato3 = readadc(2, ss)
dato4 = readadc(3, ss)
dato5 = readadc(4, ss)
dato6 = readadc(5, ss)
dato7 = readadc(6, ss)
dato8 = readadc(7, ss)
#dato9 = readadc(9,ss)
#dato10= readadc(10,ss)
#dato11= readadc(11,ss) #pin Test (Vref+ - Vref-) /2 =~ 2048
#dato12= readadc(12,ss) #pin Test Vref- 0000
#dato13= readadc(13,ss) #pin Test Vref+ 4096
dato14 = readadc(0, sc)
dato15 = readadc(1, sc)
dato16 = readadc(2, sc)
dato17 = readadc(3, sc)
dato18 = readadc(4, sc)
dato19 = readadc(5, sc)
dato20 = readadc(6, sc)
dato21 = readadc(7, sc)
#dato22 = readadc(9,sc)
#dato23 = readadc(10,sc)
#dato24 = readadc(11,sc) #pin Test (Vref+ - Vref-) /2 =~ 2048
#dato25 = readadc(12,sc) #pin Test Vref- 0000
#dato26 = readadc(13,sc) #pin Test Vref+ 4096
#print ("Datos 1 ADCp8 Azul")
values = [
dato1, dato2, dato3, dato4, dato5, dato6, dato7, dato8, dato14, dato15,
dato16, dato17, dato18, dato19, dato20, dato21
] #, dato9, dato10, dato11, dato12, dato13, 0, dato14, dato15, dato16, dato17, dato18, dato19, dato20, dato21, dato22, dato23, dato24, dato25, dato26]
dates = time.strftime("%Y-%m-%d %H:%M:%S")
# return [dates,values]
return [values]
def __init__(self, port, device, max_speed_hz=500000):
import mraa
self._device = mraa.Spi(0)
self._device.mode(0)
def __init__(self): self.rfid_device = mraa.Spi(0) self.RST = mraa.Gpio(9) self.RST.dir(mraa.DIR_OUT) self.RST.write(1) self.MFRC522_Init()
def setUp(self):
self.spi = m.Spi(MRAA_SPI_BUS_NUM)
def enableSpi(self):
s = mraa.Spi(0)
self.showIoConfiguration()
import mraa, time #Importando os modulos
spi = mraa.Spi(0) #Habilitando o SPI
spi.frequency(4000000) #Definindo a frequencia de 4MHz
tx = bytearray(3) #Criando o bytearray que armazenara os
tx[0] = 0 # valores dos bytes enviados
tx[1] = 0
tx[2] = 0
global i #Inicializando a variavel que contara de
i = 0 # forma crescente
while True:
i = i + 1
tx[0] = i #Definindo o valor de saida
print('Valor enviado: %d' % tx[0]) #Exibindo a saida antes do envio
rx = spi.write(tx) #Enviando os bytes
print('Valor recebido: %d' % rx[2]) #Exibindo o valor recebido
time.sleep(1)
#!/usr/bin/env python
import sys
sys.path.append('/usr/local/lib/i386-linux-gnu/python2.7/site-packages/')
import mraa as m
import random as rand
import time
dev = m.Spi(0)
dev = m.Spi(0)
print "SPI mode is: {}".format(dev.mode(0))
dev.frequency(1000000)
while(True):
txbuf = bytearray("HELLO\n".encode('ascii'))
# txbuf[0] = 'A'
# txbuf[1] = 'W'
# txbuf[2] = 'C'
# txbuf[3] = 'e'
# txbuf[4] = '\n'
dev.write(txbuf)
print "Tx sent: {}".format(txbuf)
time.sleep(0.1)
import time
right_motor_enable = 15
left_motor_enable = 13
# Export the GPIO pin for use
right_motor_enable_pin = mraa.Gpio(right_motor_enable)
left_motor_enable_pin = mraa.Gpio(left_motor_enable)
# Small delay to allow udev rules to execute (necessary only on up)
time.sleep(0.1)
# Configure the pin direction
right_motor_enable_pin.dir(mraa.DIR_OUT)
left_motor_enable_pin.dir(mraa.DIR_OUT)
dev = mraa.Spi(0)
#dev.frequency(100000)
dev.mode(0)
# Loop
while True:
tb = bytearray(1)
tb[0] = 0
left_motor_enable_pin.write(0)
rxbuf = dev.write(tb)
v = rxbuf[0] << 8
rxbuf = dev.write(tb)
v = v | rxbuf[0]
left_motor_enable_pin.write(1)
print ("v", v)
# byte max7219_reg_digit2 = 0x03;
# byte max7219_reg_digit3 = 0x04;
# byte max7219_reg_digit4 = 0x05;
# byte max7219_reg_digit5 = 0x06;
# byte max7219_reg_digit6 = 0x07;
# byte max7219_reg_digit7 = 0x08;
# byte max7219_reg_decodeMode = 0x09;
# byte max7219_reg_intensity = 0x0a;
# byte max7219_reg_scanLimit = 0x0b;
# byte max7219_reg_shutdown = 0x0c;
# byte max7219_reg_displayTest = 0x0f;
x = mraa.Gpio(7)
#x.dir(mraa.PIN_OUT)
dev = mraa.Spi(7)
dev.mode(mraa.SPI_MODE0)
def spiTransfer(spi, addr, opcode, data):
tx = bytearray(2)
tx[0] = opcode
tx[1] = data
ret = spi.write(tx)
x.write(0)
spiTransfer(dev, 1, 0x0f, 0x00)
x.write(1)
