def __init__(self,pwm=None,uart=None,uart_divisor=None,**kwargs): log.info("start build") log.info(str(*kwargs)) super().__init__(**kwargs) #test = Testing() #self.add(test) for i in range(4): temp = TimerPeripheral(32,name="timer_"+str(i)) self.add(temp) borker = BorkPeripheral() self.add(borker) blinky = LedPeripheral(Signal(2)) self.add(blinky) counter = CounterPeripheral(10) self.add(counter) spi_interface = SPI() self.add(spi_interface) if uart is not None: serial1 = AsyncSerialPeripheral(divisor=uart_divisor) self.add(serial1) if pwm is not None: pwm = PWM(pwm) self.add(pwm)
def create_spi_dbg(dev_name, reg_size): spi_dbg = SPIBusDebugger() if dev_name == '': spi_dbg.spi_bus = SPIBusEmulator('spi_emulator', reg_size) else: if utility.is_pl_device(dev_name): axi4_bus = AXI4LiteBus(dev_name, reg_size) spi_dbg.spi_bus = PLSPIBus(axi4_bus) else: spi_dbg.spi_bus = SPI(dev_name) return spi_dbg
""" Created on Tue May 22 11:04:44 2018 @author: anind """ from spi import SPI import numpy as np import os, random from PIL import Image import time import gdal import osr from math import isnan spi = SPI() spi.set_rolling_window_params( span=1, window_type=None, center=True) # Set distribution parameters spi.set_distribution_params(dist_type='gam') def use_spi(arr: np.array) -> np.array: data = spi.calculate(arr, starting_month=1) data = data.flatten() #Calculate and return 1d array return data
def __init__(self): #setup device self.pullup = 0x00 self.spi = SPI(miso=22, mosi=23, clk=20, reset=38) self.lock= threading.Lock()
# interval timer from https://stackoverflow.com/questions/22498038#22498708 from threading import Event, Thread def repeat(interval, func): def loop(): while not Event().wait(interval): func() Thread(target=loop).start() # uses https://raw.githubusercontent.com/tomstokes/python-spi/master/spi.py from spi import SPI spi = SPI('/dev/spidev1.0') spi.mode = SPI.MODE_0 spi.bits_per_word = 8 spi.speed = 10 * 1000000 IODIRA = 0x00 IOCON = 0x0a GPIOA = 0x12 # write to MCP23S17 register(s), GPIOA by default def mcp23s17(address, values, register=GPIOA): global spi opcode = 0x40 | (address << 1) spi.write([opcode, register] + values)
D2 = MODE1 = X D3 = MODE2 = X D4 = nRESET = 1 D5 = nSLEEP = 1 D6 = nENABLE = 0 D7 = - = X """ import time import logging from Path import Path try: from spi import SPI # init the SPI for the DAC spi2_0 = SPI(1, 0) spi2_0.bpw = 8 spi2_0.mode = 1 # Init the SPI for the serial to parallel spi2_1 = SPI(1, 1) spi2_1.bpw = 8 spi2_1.mode = 0 except ImportError: pass class Stepper: all_steppers = list() revision = "A4" SLEEP = 6
yield dut.ss_select.eq(0) yield dut.rx_start.eq(0) yield dut.word_length.eq(0) trans_bits = 1 while trans_bits < 12: new_clk = (yield dut.sck) #rising edge, change data if new_clk == 1 and clk == 0 and (yield dut.ss_s[2]) == 0: yield dut.miso.eq(num & 1) num = num >> 1 trans_bits += 1 clk = new_clk yield while (yield dut.ss_s[2]) == 0: yield yield yield dut.rx_ack.eq(1) yield yield dut.rx_ack.eq(0) for i in range(50): yield if __name__ == "__main__": dut1 = SPI(clk_freq=100, operating_freq=10) run_simulation(dut1, spi_tx(dut1), vcd_name="spi_tx.vcd") dut2 = SPI(clk_freq=100, operating_freq=10) run_simulation(dut2, spi_rx(dut2), vcd_name="spi_rx.vcd")
bing = BingVoice(BING_KEY) pa = pyaudio.PyAudio() stream = pa.open( format=FORMAT, channels=CHANNELS, rate=RATE, input=True, start=False, # input_device_index=2, frames_per_buffer=CHUNK_SIZE) got_a_sentence = False leave = False bridge = SPI() def process_text(text): # This is pretty kludgy. Just look color name or command in the text string. # and send it to Arduino via SPI print("Matching " + text) m = re.search( '(red|orange|green|blue|yellow|purple|white|pink|turquoise|magenta|brighter|brightness\sup|brightness\sdown|on|off)', text) if m: # send the command to the Arduino via SPI command = m.group(0) # SPI bridge needs ASC command = command.encode('ascii', 'ignore') print("Sending command '%s' to Arduino" % command)
#!/usr/bin/env python3 import struct from spi import SPI from tqdm import tqdm spi = SPI(0) print("speed:", spi.get_speed()) spi.set_speed(8000000) print("speed:", spi.get_speed()) print("delay:", spi.get_delay()) spi.put(b"\x9e" + b"\x00" * 20) allret = [] for addr in tqdm(range(0, 0x1000000, 0x1000)): ret = spi.put(b"\x03" + struct.pack(">I", addr)[1:], fSelEnd=0) ret = spi.get(0x1000, fSelEnd=1) allret.append(ret) out = b''.join(allret) with open("dump", "wb") as f: f.write(out) del spi
def __init__(self, clk_freq, baud_rate, spi_operating_freq): # submodules self.submodules.uart = uart = UART(clk_freq, baud_rate) self.submodules.spi = spi = SPI(clk_freq, spi_operating_freq) self.submodules.spi_man = spi_man = ControlManager() # UART ports self.tx_port = tx_port = uart.tx_port self.rx_port = rx_port = uart.rx_port # SPI ports self.sck = sck = spi.sck self.miso = miso = spi.miso self.mosi = mosi = spi.mosi self.ss_s = ss_s = spi.ss_s # interconnect submodules # SPI manager self.comb += spi.word_length.eq(spi_man.word_length) self.comb += spi.ss_select.eq(spi_man.ss_select) self.comb += spi.lsb_first.eq(spi_man.lsb_first) self.comb += spi.rising_edge.eq(spi_man.rising_edge) # I/O self.ios = {tx_port, rx_port} | \ {sck, miso, mosi, ss_s[0], ss_s[1], ss_s[2], ss_s[3]} #Inner needed data self.uart_buffer = uart_buffer = Signal(8) self.spi_buffer = spi_buffer = Signal(16) self.num_words = num_words = Signal(6) # FSM to implementing protocol self.submodules.op_fsm = FSM(reset_state="IDLE") #IDLE, we need to receive data from UART to start. self.op_fsm.act( "IDLE", # is there new data If( uart.rx_ready, # get the new data NextValue(uart_buffer, uart.rx_data), # ack the new data NextValue(uart.rx_ack, 1), # handle the command NextState("HANDLE_COMMAND"), ).Else( NextValue(spi.tx_start, 0), NextValue(spi.rx_start, 0), NextValue(spi.rx_ack, 0), NextValue(uart.rx_ack, 0), NextValue(uart.tx_ack, 0), )) self.op_fsm.act( "HANDLE_COMMAND", # un-ack any new data NextValue(uart.rx_ack, 0), # handle if transfer message If( uart_buffer[7], # how many words in this transfer? NextValue(num_words, uart_buffer[0:6]), #recv If( uart_buffer[6], NextState("RECV_1"), #send ).Else(NextState("SEND_1"), ), # handle if control message ).Else( # send it to the control manager spi_man.instruction.eq(uart_buffer), spi_man.valid_input.eq(1), # handle the command NextState("HANDLE_CONTROL"), )) self.op_fsm.act( "HANDLE_CONTROL", # invalidate the input spi_man.valid_input.eq(0), # return to idle NextState("IDLE"), ) self.op_fsm.act( "RECV_1", # needed from RECV_4 & RECV_5 NextValue(uart.tx_ack, 0), # done? If( num_words == 0, NextState("IDLE"), ).Else( # decrease num_words NextValue(num_words, num_words - 1), # keep going NextState("RECV_2"), )) self.op_fsm.act( "RECV_2", # if spi ready If( spi.rx_ready, # start rx operation NextValue(spi.rx_start, 1), # go to next NextState("RECV_3"), )) self.op_fsm.act( "RECV_3", # set rx_start back to zero NextValue(spi.rx_start, 0), # if spi ready If( spi.rx_data_ready, # get data from spi NextValue(spi_buffer, spi.rx_data), # ack the received data NextValue(spi.rx_ack, 1), # go to next NextState("RECV_4"), )) self.op_fsm.act( "RECV_4", # set rx_ack back to zero NextValue(spi.rx_ack, 0), # if uart ready to send data, send data by UART back. If( uart.tx_ready, # send data to uart input port. NextValue(uart.tx_data, spi_buffer[0:8]), # start tx NextValue(uart.tx_ack, 1), If( spi_man.word_length > 7, # go to next NextState("RECV_5_WAIT"), ).Else( #recv next word NextState("RECV_1"), ))) self.op_fsm.act( "RECV_5_WAIT", NextValue(uart.tx_ack, 0), NextState("RECV_5"), ) self.op_fsm.act( "RECV_5", # if uart ready to send data, send data by UART back. If( uart.tx_ready, # send data to uart input port. NextValue(uart.tx_data, spi_buffer[8:16]), # start tx NextValue(uart.tx_ack, 1), #recv next word NextState("RECV_1"), )) self.op_fsm.act( "SEND_1", # needed from SEND_4 NextValue(spi.tx_start, 0), # done? If( num_words == 0, NextState("IDLE"), ).Else( # decrease num_words NextValue(num_words, num_words - 1), # keep going NextState("SEND_2"), )) self.op_fsm.act( "SEND_2", # recv from UART If( uart.rx_ready, NextValue(spi_buffer[0:8], uart.rx_data), NextValue(uart.rx_ack, 1), If( spi_man.word_length > 7, # recv spi[8:16] NextState("WAIT_SEND_3"), ).Else( # send via spi NextState("SEND_4"), ))) self.op_fsm.act( "WAIT_SEND_3", NextValue(uart.rx_ack, 0), NextState("SEND_3"), ) self.op_fsm.act( "SEND_3", # recv from UART If( uart.rx_ready, NextValue(spi_buffer[8:16], uart.rx_data), NextValue(uart.rx_ack, 1), NextState("SEND_4"), )) self.op_fsm.act( "SEND_4", NextValue(uart.rx_ack, 0), If( spi.tx_ready, NextValue(spi.tx_data, spi_buffer), NextValue(spi.tx_start, 1), NextState("SEND_1"), ))
def __init__(self, dev='/dev/spidev0.0', speed=1000000): self.__spiDev = SPI(device=dev, speed=speed) self.MFRC522_Init()
def __init__(self, logger): Logger.log.debug('{} initializing....'.format(__name__)) self.logger = logger self.config = Config(logger=self.logger) self.support = Support(config=self.config, logger=self.logger) self.gpio = Gpio(config=self.config, logger=self.logger) self.pollperm = Pollperm(logger=self.logger) self.decoder = Decoder(config=self.config, logger=self.logger, gpio=self.gpio) self.spi = SPI(config=self.config, logger=self.logger, decoder=self.decoder, pollperm=self.pollperm) self.codegen = Codegen(config=self.config, logger=self.logger, gpio=self.gpio, spi=self.spi) self.securitylevel = SecurityLevel(logger=self.logger) self.gui = Mainwindow(self, codegen=self.codegen, config=self.config, logger=self.logger, support=self.support, securitylevel=self.securitylevel) self.switches = Switches(config=self.config, logger=self.logger, spi=self.spi, gui=self.gui) self.currentsense = CurrentSense(logger=self.logger, spi=self.spi, decoder=self.decoder, gui=self.gui, config=self.config) self.pollvalues = Pollvalues(pollperm=self.pollperm, logger=logger, config=self.config, currentsense=self.currentsense, switches=self.switches, sense_callback=self.poll_sense_callback, switch_callback=self.poll_switch_callback) self.securitywindow = SecurityWindow(logger=self.logger, securitylevel=self.securitylevel) self.window = self.gui.window self.log = self.logger.log self.knob_values = 0 self.rotary_0_pins = None self.rotary_1_pins = None self.rotary_2_pins = None self.rotary_3_pins = None self.rotary_0_pin_0_debounce = None self.rotary_0_pin_1_debounce = None self.rotary_1_pin_0_debounce = None self.rotary_1_pin_1_debounce = None self.rotary_2_pin_0_debounce = None self.rotary_2_pin_1_debounce = None self.rotary_3_pin_0_debounce = None self.rotary_3_pin_1_debounce = None self.gain0_val = 0 self.gain1_val = 0 self.gain_0_name = None self.gain_1_name = None self.gain_0_spi_channel = None self.gain_1_spi_channel = None self.gain_0_thresholds = None self.gain_1_thresholds = None self.GAIN_0_CS = None self.GAIN_1_CS = None self.speed0_val = 0 self.speed1_val = 0 self.speed_0_name = None self.speed_1_name = None self.speed_0_shape = None self.speed_1_shape = None self.speed_0_spi_channel = None self.speed_1_spi_channel = None self.speed_0_thresholds = None self.speed_1_thresholds = None self.screen_brightness_max = None self.screen_brightness_min = None self.display_brightness = None self.spi_log_pause = False self.SPEED_0_CS = None # 6 # SPEED SIMULATION TACH 1 self.SPEED_1_CS = None # 7 # SPEED SIMULATION TACH 2 self.load_from_config() self.adc_scale = None self.sense_amp_max_amps = None self.sense_ad_vin = None # LM4128CQ1MF3.3/NOPB voltage reference self.sense_ad_max_bits = 0 # AD7940 ADC self.sense_scaling_factor_mv_amp = None # 110 milivolts per amp self.sense_ad_max_scaled_value = None self.speed0 = Speedgen( pollperm=self.pollperm, logger=self.logger, config=self.config, decoder=self.decoder, spi=self.spi, gpio=self.gpio, name=self.speed_0_name, shape=self.speed_0_shape, spi_channel=self.speed_0_spi_channel, chip_select=self.SPEED_0_CS, pin_0=self.rotary_0_pins[0], pin_1=self.rotary_0_pins[1], pin_0_debounce=self.rotary_0_pin_0_debounce, pin_1_debounce=self.rotary_0_pin_1_debounce, thresholds=self.speed_0_thresholds, callback=self.speed_callback, commander_speed_move_callback=self.speed_move_callback) self.speed1 = Speedgen( pollperm=self.pollperm, logger=self.logger, config=self.config, decoder=self.decoder, spi=self.spi, gpio=self.gpio, name=self.speed_1_name, shape=self.speed_1_shape, spi_channel=self.speed_1_spi_channel, chip_select=self.SPEED_1_CS, pin_0=self.rotary_1_pins[0], pin_1=self.rotary_1_pins[1], pin_0_debounce=self.rotary_1_pin_0_debounce, pin_1_debounce=self.rotary_1_pin_1_debounce, thresholds=self.speed_1_thresholds, callback=self.speed_callback, commander_speed_move_callback=self.speed_move_callback) self.gain0 = Gains( pollperm=self.pollperm, config=self.config, logger=self.logger, decoder=self.decoder, spi=self.spi, gpio=self.gpio, name=self.gain_0_name, spi_channel=self.gain_0_spi_channel, chip_select=self.GAIN_0_CS, pin_0=self.rotary_2_pins[0], pin_1=self.rotary_2_pins[1], pin_0_debounce=self.rotary_2_pin_0_debounce, pin_1_debounce=self.rotary_2_pin_1_debounce, thresholds=self.gain_0_thresholds, callback=self.gains_callback, commander_gain_move_callback=self.gain_move_callback) self.gain1 = Gains( pollperm=self.pollperm, config=self.config, logger=self.logger, decoder=self.decoder, spi=self.spi, gpio=self.gpio, name=self.gain_1_name, spi_channel=self.gain_1_spi_channel, chip_select=self.GAIN_1_CS, pin_0=self.rotary_3_pins[0], pin_1=self.rotary_3_pins[1], pin_0_debounce=self.rotary_3_pin_0_debounce, pin_1_debounce=self.rotary_3_pin_1_debounce, thresholds=self.gain_1_thresholds, callback=self.gains_callback, commander_gain_move_callback=self.gain_move_callback) self.startup_processes()
def __init__(self, device): _spi = SPI(device)
#!/usr/bin/env python import sys import time try: from termcolor import colored except ImportError: print "Termcolor module is not installed." print '' print 'Loading SPI-MODULE.....', try: from spi import SPI lcd = SPI(0, 0) lcd.msh = 1000000 try: print colored('Done', 'green') except NameError: print 'Done' except ImportError: try: print colored('Fail', 'red') except NameError: print 'Fail' sys.exit(0) print 'Loading GPIO-MODULE.....', try: import RPi.GPIO as GPIO try:
#!/usr/bin/python from spi import SPI dev = SPI(miso=22, mosi=23, clk=20, reset=38) #dev.reset() while True: print dev.sendByte(0x50)
#!/usr/bin/env python3 import serial import time import argparse from spi import SPI # get port name from arguments #parser = argparse.ArgumentParser() #parser.add_argument('--port_name', type=str, default='/dev/ttyS1', help='string of port name ex/ /dev/ttyS1') #args = parser.parse_args() # spi setup spi = SPI("/dev/spidev1.0") spi.mode = SPI.MODE_0 spi.bits_per_word = 8 spi.speed = 500000 #received = spi.transfer([0x11, 0x22, 0xFF]) #spi.write([0x12, 0x34, 0xAB, 0xCD]) def sendHandler(): while 1: time.sleep(1) try: spi.write([0x12, 0x34, 0xAB, 0xCD]) print("Sent to spi bus.") except Exception as e: print("Error writing to spi bus: {}".format(str(e)))
from core import Core from port import Ports from irq import IRQTable from timer import Timer from pins import Pins from spi import SPI from usart import USART converters=[ Core(), IRQTable(), Ports(), Timer(), Pins(), SPI(), USART() ] from os import listdir # for fn in listdir("atmel-xml/"): # if (fn.find(".xml")<0 # or fn.find("ATxmega")>=0 # or fn.find("AT89")>=0 # or fn.find("AT86")>=0 # or fn.find("ATtiny10")>=0 # or fn.find("ATtiny28")>=0 # <- has weird port logic. FIXME: support this! # or fn.find("HV")>=0 # 'smart battery devices' also have some weird port logic. # or fn.find("CAN")>=0 # CAN devices are not implemented either
from spi import SPI s = SPI() s.send_data([0x1A]) s.rec_data(len=4)