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)
