def __init__(self,sck,tx,cs): # Initialize LCD
self.column = 0
self.row = 0
self.data = bytearray(2)
self.command = bytearray(2)
_tx = machine.Pin(tx)
_sck = machine.Pin(sck)
self.CS = machine.Pin(cs, machine.Pin.OUT)
self.CS.value(1)
# Cofigure SPI ports
if sck == 10 or sck == 14:
_rx = machine.Pin(12)
self.spi=machine.SPI(1,baudrate=1000000,polarity = 0,phase = 0,bits=8,sck=_sck, mosi=_tx, miso=_rx)
else:
_rx = machine.Pin(4)
self.spi=machine.SPI(0,baudrate=1000000,polarity = 0,phase = 0,bits=8,sck=_sck, mosi=_tx, miso=_rx)
utime.sleep_ms(50)
self._command(FUNCTIONSET | _2LINE )
self.on()
self.clear()
self._command(ENTRYMODESET | ENTRYLEFT | ENTRYSHIFTDECREMENT)
self.set_cursor(0,0)
def from_pins(cls,
cs,
sck,
mosi,
miso,
irq,
rst,
ttn_config,
datarate="SF7BW125",
fport=1,
channel=None,
spi_id=None):
""" Interface for a Semtech SX1276 module. Sets module up for sending to
The Things Network.
"""
# Set up SPI device on Mode 0
if (spi_id == None):
spi_device = machine.SPI(baudrate=4000000,
polarity=0,
phase=0,
sck=machine.Pin(sck),
mosi=machine.Pin(mosi),
miso=machine.Pin(miso))
else:
spi_device = machine.SPI(spi_id,
baudrate=4000000,
polarity=0,
phase=0,
sck=machine.Pin(sck),
mosi=machine.Pin(mosi),
miso=machine.Pin(miso))
return cls(spi_device, cs, irq, rst, ttn_config, datarate, fport,
channel)
def setup(use_spi=False, soft=True):
if use_spi:
# Pyb SSD
# 3v3 Vin
# Gnd Gnd
# X1 DC
# X2 CS
# X3 Rst
# X6 CLK
# X8 DATA
pdc = machine.Pin('X1', machine.Pin.OUT_PP)
pcs = machine.Pin('X2', machine.Pin.OUT_PP)
prst = machine.Pin('X3', machine.Pin.OUT_PP)
if soft:
spi = machine.SPI(sck=machine.Pin('X6'), mosi=machine.Pin('X8'), miso=machine.Pin('X7'))
else:
spi = machine.SPI(1)
ssd = SSD1306_SPI(WIDTH, HEIGHT, spi, pdc, prst, pcs)
else: # I2C
# Pyb SSD
# 3v3 Vin
# Gnd Gnd
# Y9 CLK
# Y10 DATA
if soft:
pscl = machine.Pin('Y9', machine.Pin.OPEN_DRAIN)
psda = machine.Pin('Y10', machine.Pin.OPEN_DRAIN)
i2c = machine.I2C(scl=pscl, sda=psda)
else:
i2c = machine.I2C(2)
ssd = SSD1306_I2C(WIDTH, HEIGHT, i2c)
return ssd
def configure(self, config):
super().configure(config)
import ssd1306
self.display = None
try:
if self.display_type == "SSD1306_I2C":
i2c = machine.I2C(self.i2c.bus,
scl=machine.Pin(self.i2c.gpio_scl),
sda=machine.Pin(self.i2c.gpio_sda)
# freq=self.i2c.max_freq
)
# addrs = i2c.scan()
# print("Scanning I2C devices:", [hex(x) for x in addrs])
# if self.sla not in addrs:
# import ubinascii
# print("ICT device not detected on address", ubinascii.hexlify(device_addr))
self.display = ssd1306.SSD1306_I2C(self.width, self.height,
i2c)
self.display.poweron()
elif self.display_type == "SSD1306_SPI":
spi = None
if self.bitbanging_mode:
spi = machine.SPI(self.spi.id,
baudrate=self.spi.baudrate,
polarity=self.spi.polarity,
phase=self.spi.phase,
sck=machine.Pin(self.spi.gpio_sck),
mosi=machine.Pin(self.spi.gpio_mosi),
miso=machine.Pin(self.spi.gpio_miso))
else:
spi = machine.SPI(self.spi.id,
baudrate=self.spi.baudrate,
polarity=self.spi.polarity,
phase=self.spi.phase)
self.display = ssd1306.SSD1306_SPI(
self.width, self.height, spi,
machine.Pin(self.spi.gpio_dc),
machine.Pin(self.spi.gpio_res),
machine.Pin(self.spi.gpio_cs))
except OSError as e:
import kiota.Util as Util
Util.log(self, "failed to configure display", e)
def setup(self):
dp = machine.Pin(self.config['dht']['pin'])
self.dht = dht.DHT22(dp)
# ntc_cfg = self.config['temp_sensor']
# self.adc_cal = machine.Pin(ntc_cfg['adc_cal_pin'], machine.Pin.OUT, value=0)
# self.ntc = NTC(pin=ntc_cfg['adc_pin'],
# ntc_nom_r=ntc_cfg['ntc_nom_r'],
# ntc_nom_t=ntc_cfg['ntc_nom_t'],
# ntc_bcoeff=ntc_cfg['ntc_bcoeff'],
# vdiv_r2=ntc_cfg['ntc_div_r2'],
# t_offset=ntc_cfg['ntc_offset'],
# cal_pin=self.adc_cal, cal_duty=2.76/3.3,
# samples=15, samples_delay_us=3000)
oled_cfg = self.config['oled']
# noinspection PyArgumentList
spi = machine.SPI(oled_cfg['spi_bus_id'],
baudrate=6 * 1024 * 1024,
polarity=0,
phase=0)
oled_resume_mode = self.lowpower_phase or machine.reset_cause(
) not in (0, 1, 6)
self.oled = SSD1306_SPI_custom(oled_cfg['width'],
oled_cfg['height'],
spi=spi,
dc=machine.Pin(oled_cfg['dc_pin']),
res=machine.Pin(oled_cfg['res_pin']),
cs=machine.Pin(oled_cfg['cs_pin']),
resume_mode=oled_resume_mode)
self.oled.contrast(0)
if not oled_resume_mode:
self.oled.text('BOOTING', 36, 28)
self.oled.show()
self.oled.fill(0)
def main():
spi = machine.SPI(1,
baudrate=8000000,
polarity=1,
phase=1,
sck=Pin(18, Pin.OUT, Pin.PULL_DOWN),
mosi=Pin(23, Pin.OUT, Pin.PULL_UP),
miso=Pin(19, Pin.IN, Pin.PULL_UP))
display = st7789.ST7789(
spi,
240,
240,
reset=Pin(2, machine.Pin.OUT, Pin.PULL_UP),
dc=Pin(4, machine.Pin.OUT, Pin.PULL_UP),
)
display.init()
display.fill(st7789.color565(128, 128, 255))
graphics = gfx.GFX(240, 240, display.pixel)
graphics.fill_rect(50, 50, 50, 50, st7789.color565(0, 0, 0))
print(mem_free())
collect()
print(mem_free())
while True:
display.fill(
st7789.color565(
random.getrandbits(8),
random.getrandbits(8),
random.getrandbits(8),
), )
# Pause 2 seconds.
time.sleep(0.5)
def upload(filename):
# Read in the binary fpga configuration
fpga_file = open(filename, 'rb')
bblob = fpga_file.read()
fpga_file.close()
# Setup a soft SPI bus (18, 27, 19)
spi = machine.SPI(baudrate=4000000,
polarity=1,
phase=0,
sck=Pin(18),
mosi=Pin(19),
miso=Pin(27))
spi.init(baudrate=4000000)
ICE_SS = Pin(14, Pin.OUT) # 14
CRESET_B = Pin(25, Pin.OUT) # 25
CDONE = Pin(26, Pin.IN) # 26
ICE_SS.value(0)
CRESET_B.value(0) # Reset the FPGA
time.sleep_ms(1)
CRESET_B.value(1)
time.sleep_ms(1)
spi.write(bblob)
for x in range(8):
spi.write(b'0')
print(CDONE.value())
def _iniSpi(self, sck, mosi, miso):
sck = machine.Pin(sck, machine.Pin.OUT)
mosi = machine.Pin(mosi, machine.Pin.OUT)
miso = machine.Pin(miso, machine.Pin.IN)
self.__spi = machine.SPI(-1, sck=sck, mosi=mosi, miso=miso)
self.__spi.deinit()
self.__spi.init(baudrate=500000, polarity=1, phase=1)
def __init__(self, spi_channel, slave_select_pin):
self.cmdbuf = bytearray(33)
self.cmdmv = memoryview(self.cmdbuf)
self.fbuff = [
memoryview(bytearray(X_BOUNDRY)) for x in range(Y_BOUNDRY)
]
self.spi = machine.SPI(spi_channel)
self.slaveSelectPin = machine.Pin(slave_select_pin, machine.Pin.OUT)
self.slaveSelectPin.value(1)
self.send_flag(LCD_BASIC)
sleep_ms(1)
self.send_flag(LCD_DISPLAYON)
sleep_ms(1)
self.send_flag(LCD_CLS)
sleep_ms(20)
self.send_flag(LCD_EXTEND)
sleep_us(100)
self.send_flag(LCD_GRAPHIC)
sleep_us(100)
self.send_flag(LCD_DISPLAYCTRL)
sleep_us(100)
self.send_flag(LCD_CLS)
sleep_ms(20)
self.slaveSelectPin.value(0)
def test_dual_atm90e26():
sck = machine.Pin(5, machine.Pin.OUT)
mosi = machine.Pin(18, machine.Pin.OUT)
miso = machine.Pin(19, machine.Pin.IN)
cs1 = machine.Pin(15, machine.Pin.OUT)
cs2 = machine.Pin(33, machine.Pin.OUT)
spi = machine.SPI(1,
baudrate=200000,
bits=8,
polarity=1,
phase=1,
firstbit=machine.SPI.MSB,
sck=sck,
mosi=mosi,
miso=miso)
all_ics = [ATM90E26_SPI(spi, cs1), ATM90E26_SPI(spi, cs2)]
while True:
for energy_ic in all_ics:
sys_val = energy_ic.GetSysStatus()
print("Sys Status:", hex(sys_val))
met_val = energy_ic.GetMeterStatus()
print("Met Status:", hex(met_val))
voltage = energy_ic.GetLineVoltage()
print("Voltage:", voltage)
current = energy_ic.GetLineCurrent()
print("Current:", current)
time.sleep_ms(1000)
def setup():
pdc = machine.Pin('X1', machine.Pin.OUT_PP, value=0)
pcs = machine.Pin('X2', machine.Pin.OUT_PP, value=1)
prst = machine.Pin('X3', machine.Pin.OUT_PP, value=1)
spi = machine.SPI(1)
ssd = SSD(spi, pcs, pdc, prst) # Create a display instance
return ssd
def get_uPy_spi(cls,
id=-1,
baudrate=10000000,
polarity=0,
phase=0,
bits=8,
firstbit=SPI_MSB,
pin_id_sck=14,
pin_id_mosi=13,
pin_id_miso=12):
import machine
spi = machine.SPI(
id,
baudrate=baudrate,
polarity=polarity,
phase=phase,
bits=bits,
firstbit=firstbit,
sck=machine.Pin(
pin_id_sck, machine.Pin.OUT,
machine.Pin.PULL_UP if polarity else machine.Pin.PULL_DOWN),
mosi=machine.Pin(pin_id_mosi,
machine.Pin.OUT), # , machine.Pin.PULL_UP),
miso=machine.Pin(pin_id_miso,
machine.Pin.IN)) # , machine.Pin.PULL_UP))
spi.init()
return spi
def main():
gpio_csn = const(17)
gpio_resn = const(26)
gpio_dc = const(16)
gpio_sck = const(14)
gpio_mosi = const(15)
gpio_miso = const(2)
spi = machine.SPI(-1,
baudrate=40000000,
polarity=1,
sck=machine.Pin(gpio_sck),
mosi=machine.Pin(gpio_mosi),
miso=machine.Pin(gpio_miso))
display = st7789.ST7789(
spi,
240,
240,
reset=machine.Pin(gpio_resn, machine.Pin.OUT),
dc=machine.Pin(gpio_dc, machine.Pin.OUT),
)
display.init()
while True:
display.fill(
st7789.color565(
random.getrandbits(8),
random.getrandbits(8),
random.getrandbits(8),
), )
# Pause 2 seconds.
time.sleep(2)
def boot(binfile):
creset = machine.Pin(5, machine.Pin.OUT, machine.Pin.PULL_UP)
cdone = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP)
ss = machine.Pin(15, machine.Pin.OUT, machine.Pin.PULL_UP)
s = machine.SPI(1, polarity=1, phase=1, baudrate=10000000)
creset.off()
ss.off()
time.sleep(1)
creset.on()
print(cdone.value())
time.sleep(1)
with open(binfile, 'rb') as f:
b = f.read(32)
while b:
b = f.read(32)
s.write(b)
print(cdone.value())
bytecnt = 0
while bytecnt < 20:
bytecnt += 1
s.write(b'X')
print(bytecnt)
ss.on()
print(cdone.value())
def __init__(self,
width=128,
height=64,
spi=machine.SPI(1,
baudrate=10000000,
sck=machine.Pin(14),
mosi=machine.Pin(13)),
dc=machine.Pin(16),
res=machine.Pin(17),
cs=machine.Pin(15),
external_vcc=False):
self.rate = 10 * 1000 * 1000
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
self.dc.init(self.dc.OUT, value=0)
if self.res is not None:
self.res.init(self.res.OUT, value=0)
if self.cs is not None:
self.cs.init(self.cs.OUT, value=1)
super().__init__(external_vcc, width, height)
def __init__(self, NSS, SCK, MOSI, MISO, baudrate=328125):
self.spi_bus = machine.SPI(baudrate=baudrate,
sck=machine.Pin(SCK),
mosi=machine.Pin(MOSI),
miso=machine.Pin(MISO))
self.CS_pin = machine.Pin(NSS)
self.CS_pin.init(mode=machine.Pin.OUT)
self.buffer = bytearray(2)
def __init__(self, cs_pin=15, clk_freq=500000):
self._address = NUM_SPI
self._cs = machine.Pin(cs_pin, machine.Pin.OUT)
self._bus = machine.SPI(self._address,
baudrate=clk_freq,
polarity=0,
phase=0)
self._cs.value(1)
def sdtest2():
spi = machine.SPI(1)
spi.init() # Ensure right baudrate
sd = sdcard.SDCard(spi, machine.Pin(15)) # Compatible with PCB
# vfs = os.VfsLfs2(sd)
vfs = os.VfsFat(sd)
os.mount(vfs, "/fc")
print("Filesystem check")
print(os.listdir("/fc"))
line = "abcdefghijklmnopqrstuvwxyz\n"
lines = line * 200 # 5400 chars
short = "1234567890\n"
fn = "/fc/rats.txt"
print()
print("Multiple block read/write")
with open(fn, "w") as f:
n = f.write(lines)
print(n, "bytes written")
n = f.write(short)
print(n, "bytes written")
n = f.write(lines)
print(n, "bytes written")
with open(fn, "r") as f:
result1 = f.read()
print(len(result1), "bytes read")
fn = "/fc/rats1.txt"
print()
print("Single block read/write")
with open(fn, "w") as f:
n = f.write(short) # one block
print(n, "bytes written")
with open(fn, "r") as f:
result2 = f.read()
print(len(result2), "bytes read")
os.umount("/fc")
print()
print("Verifying data read back")
success = True
if result1 == "".join((lines, short, lines)):
print("Large file Pass")
else:
print("Large file Fail")
success = False
if result2 == short:
print("Small file Pass")
else:
print("Small file Fail")
success = False
print()
print("Tests", "passed" if success else "failed")
def __init__(self): self.cs = machine.Pin(5, machine.Pin.OUT) self.spi = machine.SPI(2) self.spi.init(sck=machine.Pin(18), mosi=machine.Pin(23), baudrate=30000000) self.set_shutdown() self.set_decode() self.set_intensity() self.set_limit() self.set_test()
def sdtest():
spi = machine.SPI(1)
spi.init() # Ensure right baudrate
sd = sdcard.SDCard(spi, machine.Pin.board.X21) # Compatible with PCB
vfs = os.VfsFat(sd)
os.mount(vfs, '/fc')
print('Filesystem check')
print(os.listdir('/fc'))
line = 'abcdefghijklmnopqrstuvwxyz\n'
lines = line * 200 # 5400 chars
short = '1234567890\n'
fn = '/fc/rats.txt'
print()
print('Multiple block read/write')
with open(fn,'w') as f:
n = f.write(lines)
print(n, 'bytes written')
n = f.write(short)
print(n, 'bytes written')
n = f.write(lines)
print(n, 'bytes written')
with open(fn,'r') as f:
result1 = f.read()
print(len(result1), 'bytes read')
fn = '/fc/rats1.txt'
print()
print('Single block read/write')
with open(fn,'w') as f:
n = f.write(short) # one block
print(n, 'bytes written')
with open(fn,'r') as f:
result2 = f.read()
print(len(result2), 'bytes read')
os.umount('/fc')
print()
print('Verifying data read back')
success = True
if result1 == ''.join((lines, short, lines)):
print('Large file Pass')
else:
print('Large file Fail')
success = False
if result2 == short:
print('Small file Pass')
else:
print('Small file Fail')
success = False
print()
print('Tests', 'passed' if success else 'failed')
def sdtest1():
spi = machine.SPI(1, sck=machine.Pin(10), mosi=machine.Pin(11), miso=machine.Pin(12))
spi = machine.SPI(1)
cs = machine.Pin(15)
sd = sdcard.SDCard(spi, cs)
vfs = os.VfsFat(sd)
os.mount(vfs, '/sd')
os.mkdir('/sd/sd2')
os.chdir('/sd/sd2')
with open("pico2.txt", "a") as file:
for i in range(10):
file.write(str(i)+"2. Hello, world!\r\n")
os.chdir('/')
os.umount("/sd")
def __init__(self, lora_freq=915E6, lora_txpwr=2):
self._i2c = machine.I2C(-1,
scl=machine.Pin(15),
sda=machine.Pin(4),
freq=400000)
self._oled = ssd1306.SSD1306_I2C(128, 64, self._i2c)
self._d_rst = machine.Pin(16, machine.Pin.OUT)
self._d_rst.value(0)
time.sleep_ms(20)
device_pins = {
'miso': 19,
'mosi': 27,
'ss': 18,
'sck': 5,
'dio_0': 26,
'reset': 16,
'led': 2,
}
lora_parameters = {
'frequency': lora_freq,
'tx_power_level': lora_txpwr,
'signal_bandwidth': 125E3,
'spreading_factor': 8,
'coding_rate': 5,
'preamble_length': 8,
'implicit_header': False,
'sync_word': 0x12,
'enable_CRC': False,
'invert_IQ': False,
}
self._device_spi = machine.SPI(
baudrate=10000000,
polarity=0,
phase=0,
bits=8,
firstbit=machine.SPI.MSB,
sck=machine.Pin(device_pins['sck'], machine.Pin.OUT,
machine.Pin.PULL_DOWN),
mosi=machine.Pin(device_pins['mosi'], machine.Pin.OUT,
machine.Pin.PULL_UP),
miso=machine.Pin(device_pins['miso'], machine.Pin.IN,
machine.Pin.PULL_UP))
self._lora = sx127x.SX127x(self._device_spi,
pins=device_pins,
parameters=lora_parameters)
self._d_rst.value(1)
self._oled.init_display()
self._oled.contrast(1)
self.show('System Initialized', 'Call receiver()', '...or sender()')
def __init__(self,
connect=None,
*,
pwr=None,
i2c=None,
spi=None,
i2c_addr=98):
if connect in ('X', 'Y', 'XY', 'YX'):
i = connect[-1]
j = connect[0]
y = j + '4'
elif connect == 'C':
i = 2
j = 2
y = 'A7'
else:
if pwr is None or i2c is None or spi is None:
raise ValueError(
'must specify valid "connect" or all of "pwr", "i2c" and "spi"'
)
if pwr is None:
pwr = machine.Pin(y, machine.Pin.OUT)
if i2c is None:
i2c = machine.I2C(i, freq=1000000)
if spi is None:
spi = machine.SPI(j, baudrate=13500000, polarity=0, phase=0)
if not pwr.value():
pwr(1)
sleep_ms(10)
# else:
# alread have power
# lets be optimistic...
# set connections
self.pwr = pwr
self.i2c = i2c
self.spi = spi
self.i2c_addr = i2c_addr
# create temp buffers and memoryviews
self.buf16 = bytearray(16)
self.buf19 = bytearray(19)
self.buf = [None] * 10
for i in range(1, 10):
self.buf[i] = memoryview(self.buf16)[0:i]
self.buf1 = self.buf[1]
self.array4 = [0, 0, 0, 0]
# set default orientation and window
self.set_orient(PORTRAIT)
self._fcmd2b('<BBBBBB', 0x76, 0, 0, self.w, self.h) # viewport 'v'
self._fcmd2b('<BBBBBB', 0x79, 0, 0, self.w, self.h) # window 'y'
def main():
scl=machine.Pin(15,machine.Pin.OUT, 1)
sda=machine.Pin(14, machine.Pin.OUT, 0)
sdo=machine.Pin(17, machine.Pin.IN, 0)
cs=machine.Pin(18, machine.Pin.OUT,1)
spi = machine.SPI(-1, sck=scl, miso=sdo, mosi=sda)
spi.init(400000, polarity=0, phase=0)
return LIS3SDH_SPI(spi, cs)
def __init__(self):
from machine import Pin
spi = machine.SPI(1)
reset_pin = Pin('PA6', Pin.OUT)
dc_pin = Pin('PA8', Pin.OUT)
cs_pin = Pin('PA4', Pin.OUT)
self.dis = SSD1306_SPI(128, 64, spi, dc_pin, reset_pin, cs_pin)
self.clear()
self.show()
def start_pmode(self):
try:
# 'esp32' == os.uname().sysname
self.SPI = machine.SPI(ESP_HSPI, baudrate = self._spi_freq, sck = machine.Pin(ESP_SCK), mosi = machine.Pin(ESP_MOSI), miso = machine.Pin(ESP_MISO))
except:
# SPI 'esp8266' == os.uname().sysname
self.SPI = machine.SPI(ESP_HSPI, baudrate = self._spi_freq, polarity = 0, phase = 0)
self.SPI.init(baudrate = self._spi_freq)
# self.SPI.setHwCs(False);
# try to sync the bus
self.SPI.write(bytearray([0x00]))
self.digitalWrite(self._reset_pin, self._resetLevel(False));
time.sleep_us(50);
self.digitalWrite(self._reset_pin, self._resetLevel(True));
time.sleep_ms(30);
self.spi_transaction(0xAC, 0x53, 0x00, 0x00)
self.pmode = 1
return
def mount_sd():
logger.info("mounting sd...")
try:
sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
os.mount(sd, "/sd")
except Exception as e:
logger.exc(e, "sd could not be mounted.")
failed_mounts_count = increment_counter("failed_mounts")
if failed_mounts_count == 1:
print_error_msg("SD-Karte konnte nicht gelesen werden! Sag besser mal Fabian bescheid!")
else:
reset_counter("failed_mounts")
def __init__(self,
SPI_type: str,
reset: str = None,
CS: str = None,
MI: str = None,
MO: str = None,
SCK: str = None):
# SPI_type = 'SPI1' or 'SPI2' or 'softSPI'
SPIparams = {
'baudrate': 1000000,
'polarity': 1,
'phase': 1,
'bits': 8,
'firstbit': machine.SPI.MSB
}
if '1' in SPI_type:
self.SPI = machine.SPI(1, **SPIparams)
elif '2' in SPI_type:
self.SPI = machine.SPI(2, **SPIparams)
elif 'soft' in SPI_type.lower(
): # Works for newer versions of micropython
self.SPI = machine.SoftSPI(
sck=machine.Pin(SCK,
mode=machine.Pin.OUT,
pull=machine.Pin.PULL_DOWN),
mosi=machine.Pin(MO,
mode=machine.Pin.OUT,
pull=machine.Pin.PULL_DOWN),
miso=machine.Pin(MI, mode=machine.Pin.IN),
**SPIparams)
self.select = Digital_output(pin=CS, inverted=True)
self.reset = Digital_output(pin=reset, inverted=True)
self.reset.off()
self.select.off()
def __init__(self, platform=None):
''' platform -- object which has gateware settings
only passed to controller if virtual
test is executed. Needed in lasers.py
as each test here has a slightly
different TestPlatform
'''
# case raspberry
if platform is None:
self.test = False
from gpiozero import LED
import spidev
from smbus2 import SMBus
self.platform = Firestarter(micropython=False)
# IC bus used to set power laser
self.bus = SMBus(self.platform.ic_dev_nr)
# SPI to sent data to scanner
self.spi = spidev.SpiDev()
self.spi.open(*self.platform.spi_dev)
self.spi.mode = 1
self.spi.max_speed_hz = round(1E6)
self.chip_select = LED(self.platform.chip_select)
# programs TMC2130
self.init_steppers()
# stepper motor enable pin
self.enable = LED(self.platform.enable_pin)
# case micropython:
elif upython:
self.test = False
import machine
self.platform = platformmicro(micropython=True)
# IC bus
self.bus = machine.I2C(self.platform.ic_dev_nr)
self.bus.init(machine.I2C.CONTROLLER, adr=self.platform.ic_addr)
# SPI
# spi port is hispi
self.spi = machine.SPI(self.spi_dev, baudrate=round(1E6))
self.chip_select = machine.Pin(self.platform.chip_select)
# program TMC2130
# TODO: add TMC2130 library to micropython
# self.init_steppers()
# stepper motor enable pin
self.enable = machine.Pin(self.platform.enable_pin)
else:
self.platform = platform
self.test = True
# maximum number of times tried to write to FIFO
# if memoery is full
self.maxtrials = 10 if self.test else 1E5
self.laser_params = params(self.platform)
self._position = np.array([0]*self.platform.motors, dtype='float64')
def display_init():
global display
spi = machine.SPI(1,
baudrate=30000000,
polarity=0,
phase=0,
sck=Pin(32),
mosi=Pin(5)) # 26.6MHz
display = st7735.ST7735(spi,
80,
160,
dc=machine.Pin(4, machine.Pin.OUT),
rotation=3)
display.init()
