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()