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)