def __init__(self, freq, sck, sdo, sdi=None, spidev=None): _mi = Pin(sdi) if sdi else None _mo = Pin(sdo) _sc = Pin(sck) if spidev == None: self._spi = SPI(baudrate=freq, sck=_sc, mosi=_mo, miso=_mi) elif spidev >= 0: self._spi = SPI(spidev, baudrate=freq, sck=_sc, mosi=_mo, miso=_mi) else: self._spi = SoftSPI(sck=_sc, mosi=_mo, miso=_mi)
def main(): ''' Draw greetings on display cycling thru hershey fonts and colors ''' try: # Turn power on display power axp = axp202c.PMU() axp.enablePower(axp202c.AXP202_LDO2) axp.enablePower(axp202c.AXP202_DCDC3) # initialize spi port spi = SoftSPI( 2, baudrate=32000000, polarity=1, phase=0, bits=8, firstbit=0, sck=Pin(18, Pin.OUT), mosi=Pin(19, Pin.OUT)) # configure display tft = st7789.ST7789( spi, 240, 240, cs=Pin(5, Pin.OUT), dc=Pin(27, Pin.OUT), backlight=Pin(12, Pin.OUT), rotation=2) tft.init() tft.fill(st7789.BLACK) height = tft.height() width = tft.width() row = 0 while True: row += 32 color = next(COLORS) tft.fill_rect(0, row-16, width, 32, st7789.BLACK) tft.draw(next(FONTS), next(GREETINGS), 0, row, color) if row > 192: row = 0 utime.sleep(0.25) finally: # shutdown spi if 'spi' in locals(): spi.deinit()
def main(): def center(font, string, row, color=st7789.WHITE): screen = tft.width # get screen width width = tft.write_width(font, string) # get the width of the string if width and width < screen: # if the string < display col = tft.width // 2 - width // 2 # find the column to center else: # otherwise col = 0 # left justify tft.write(font, string, col, row, color) # and write the string try: spi = SoftSPI( baudrate=20000000, polarity=1, phase=0, sck=Pin(18), mosi=Pin(19), miso=Pin(13)) tft = st7789.ST7789( spi, 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=1) # enable display and clear screen tft.fill(st7789.BLACK) row = 16 # center the name of the first font, using the font center(noto_sans, "NotoSans", row, st7789.RED) row += noto_sans.HEIGHT # center the name of the second font, using the font center(noto_serif, "NotoSerif", row, st7789.GREEN) row += noto_serif.HEIGHT # center the name of the third font, using the font center(noto_mono, "NotoSansMono", row, st7789.BLUE) row += noto_mono.HEIGHT finally: # shutdown spi if 'spi' in locals(): spi.deinit()
def main(): tft = st7789.ST7789(SoftSPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19)), 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=3) tft.init() tft.fill(st7789.BLACK) start = utime.ticks_ms() tft.text(font, "MicroPython", 0, 0, st7789.WHITE) tft.text(font, "MicroPython", 0, 32, st7789.RED) tft.text(font, "MicroPython", 0, 64, st7789.GREEN) tft.text(font, "MicroPython", 0, 96, st7789.BLUE) print("time:", utime.ticks_ms() - start, "ms")
def spi_jtag_on(): global hwspi, swspi try: # ESP32 classic hwspi = SPI(2, baudrate=spi_freq, polarity=1, phase=1, bits=8, firstbit=SPI.MSB, sck=Pin(jtagpin.tck), mosi=Pin(jtagpin.tdi), miso=Pin(jtagpin.tdo)) except: # ESP32-S2 hwspi = SPI(baudrate=spi_freq, polarity=1, phase=1, bits=8, firstbit=SPI.MSB, sck=Pin(jtagpin.tck), mosi=Pin(jtagpin.tdi), miso=Pin(jtagpin.tdo)) swspi = SoftSPI(baudrate=spi_freq, polarity=1, phase=1, bits=8, firstbit=SPI.MSB, sck=Pin(jtagpin.tck), mosi=Pin(jtagpin.tdi), miso=Pin(jtagpin.tdo))
def mount_sdcard(): spisd = SoftSPI(-1, miso=Pin(13), mosi=Pin(12), sck=Pin(14)) sd = SDCard(spisd, Pin(27)) vfs = os.VfsFat(sd) os.mount(vfs, '/sd')
def main(): # enable display and clear screen spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(18), mosi=Pin(19), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=1) tft.fill(st7789.BLACK) row = 0 tft.write(font_16, "abcdefghijklmnopqrst", 0, row, st7789.RED) row += font_16.HEIGHT tft.write(font_32, "abcdefghij", 0, row, st7789.GREEN) row += font_32.HEIGHT tft.write(font_64, "abcd", 0, row, st7789.BLUE) row += font_64.HEIGHT
def main(): spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(18), mosi=Pin(19), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=0) while True: for rotation in range(4): tft.rotation(rotation) tft.fill(0) col_max = tft.width - font.WIDTH * 6 row_max = tft.height - font.HEIGHT for _ in range(100): tft.text( font, "Hello!", random.randint(0, col_max), random.randint(0, row_max), st7789.color565(random.getrandbits(8), random.getrandbits(8), random.getrandbits(8)), st7789.color565(random.getrandbits(8), random.getrandbits(8), random.getrandbits(8)))
def main(): ''' Draw greetings on display cycling thru hershey fonts and colors ''' # configure display tft = st7789.ST7789(SoftSPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19)), 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=3) tft.init() tft.fill(st7789.BLACK) width = tft.width() row = 0 while True: row += 32 color = next(COLORS) tft.fill_rect(0, row - 16, width, 38, st7789.BLACK) tft.draw(next(FONTS), next(GREETINGS), 0, row, color) print(row) if row == 96: row = 0 utime.sleep(0.25)
def main(): spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(18), mosi=Pin(19), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=0) tft.fill(st7789.BLACK) while True: tft.line( random.randint(0, tft.width), random.randint(0, tft.height), random.randint(0, tft.width), random.randint(0, tft.height), st7789.color565(random.getrandbits(8), random.getrandbits(8), random.getrandbits(8))) width = random.randint(0, tft.width // 2) height = random.randint(0, tft.height // 2) col = random.randint(0, tft.width - width) row = random.randint(0, tft.height - height) tft.fill_rect( col, row, width, height, st7789.color565(random.getrandbits(8), random.getrandbits(8), random.getrandbits(8)))
def __init__(self): # Create a DotStar instance spi = SoftSPI(sck=Pin(TinyPICO.DOTSTAR_CLK), mosi=Pin(TinyPICO.DOTSTAR_DATA), miso=Pin(TinyPICO.SPI_MISO)) self.dotstar = DotStar( spi, 1, brightness=0.5) # Just one DotStar, half brightness # Turn on the power to the DotStar TinyPICO.set_dotstar_power(True) self.dotstar[0] = (255, 0, 0, 0.5) # Define state self.x = 0 self.y = 0 self.prev_x = 0 self.prev_y = 0 # Define buttons self.pin_forward = Pin(5, Pin.IN) self.pin_reverse = Pin(23, Pin.IN) self.pin_right = Pin(19, Pin.IN) self.pin_left = Pin(18, Pin.IN) # Create our device self.joystick = Joystick("Joystick") # Set a callback function to catch changes of device state self.joystick.set_state_change_callback(self.joystick_state_callback) # Start our device self.joystick.start()
def test_mfrc522_write(self): """ test mfrc522_write properly writes a value """ # Setup sck = Pin(18, Pin.OUT) copi = Pin(23, Pin.OUT) cipo = Pin(19, Pin.OUT) spi = SoftSPI(baudrate=100000, polarity=0, phase=0, sck=sck, mosi=copi, miso=cipo) sda = Pin(21, Pin.OUT) # Instantiate reader = MFRC522(spi, sda) # Calls (status, tag_type) = reader.request(reader.CARD_REQIDL) if status == reader.OK: (status, raw_uid) = reader.anticoll() if status == reader.OK: if reader.select_tag(raw_uid) == reader.OK: key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] if reader.auth(reader.AUTH, 8, key, raw_uid) == reader.OK: status = reader.write(8, b'\x08\x06\x07\x05\x03\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00') reader.stop_crypto1() # Asserts self.assertEqual(status, 0)
def test_mfrc522_read(self): """ test mfrc522_read properly reads a value """ # Setup input('\nPLEASE PLACE CARD IN FRONT OF READER TO PROCEED AND PRESS ENTER WHEN READY') sck = Pin(18, Pin.OUT) copi = Pin(23, Pin.OUT) cipo = Pin(19, Pin.OUT) spi = SoftSPI(baudrate=100000, polarity=0, phase=0, sck=sck, mosi=copi, miso=cipo) sda = Pin(21, Pin.OUT) # Instantiate reader = MFRC522(spi, sda) # Calls (status, tag_type) = reader.request(reader.CARD_REQIDL) if status == reader.OK: (status, raw_uid) = reader.anticoll() if status == reader.OK: if reader.select_tag(raw_uid) == reader.OK: key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] if reader.auth(reader.AUTH, 8, key, raw_uid) == reader.OK: reader.stop_crypto1() # Asserts self.assertEqual(status, 0)
class SPIBus(object): """SPI bus access.""" def __init__(self, freq, sck, sdo, sdi=None, spidev=None): _mi = Pin(sdi) if sdi else None _mo = Pin(sdo) _sc = Pin(sck) if spidev == None: self._spi = SPI(baudrate=freq, sck=_sc, mosi=_mo, miso=_mi) elif spidev >= 0: self._spi = SPI(spidev, baudrate=freq, sck=_sc, mosi=_mo, miso=_mi) else: self._spi = SoftSPI(sck=_sc, mosi=_mo, miso=_mi) def deinit(self): self._spi.deinit() @property def bus(self): return self._spi def write_readinto(self, wbuf, rbuf): self._spi.write_readinto(wbuf, rbuf) def write(self, wbuf): self._spi.write(wbuf)
def init_APA102(): global DOTSTAR # Configure SPI for controlling the DotStar # Internally we are using software SPI for this as the pins being used are not hardware SPI pins spi = SoftSPI(sck=Pin(TinyPICO.DOTSTAR_CLK), mosi=Pin(TinyPICO.DOTSTAR_DATA), miso=Pin(TinyPICO.SPI_MISO)) # Create a DotStar instance DOTSTAR = DotStar(spi, 1, brightness=0.4) # Just one DotStar, half brightness # Turn on the power to the DotStar TinyPICO.set_dotstar_power(True) return True
def main(): Pin(22, Pin.OUT, value=1) spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(2), mosi=Pin(3), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(0, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(1, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=0) last_line = tft.height - font.HEIGHT tfa = 40 tfb = 40 tft.vscrdef(tfa, 240, tfb) tft.fill(st7789.BLUE) scroll = 0 character = 0 while True: tft.fill_rect(0, scroll, tft.width, 1, st7789.BLUE) if scroll % font.HEIGHT == 0: tft.text(font, '\\x{:02x}= {:s} '.format(character, chr(character)), 0, (scroll + last_line) % tft.height, st7789.WHITE, st7789.BLUE) character = character + 1 if character < 256 else 0 tft.vscsad(scroll + tfa) scroll += 1 if scroll == tft.height: scroll = 0 utime.sleep(0.01)
def main(): """ Initialize the display and draw flying toasters and toast """ spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(18), mosi=Pin(19), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=0) tft.fill(st7789.BLACK) # create toast spites in random positions sprites = [ toast(TOASTERS, 135 - 64, 0), toast(TOAST, 135 - 64 * 2, 80), toast(TOASTERS, 135 - 64 * 4, 160) ] # move and draw sprites while True: for man in sprites: bitmap = man.sprites[man.step] tft.fill_rect(man.x + bitmap.WIDTH - man.speed, man.y, man.speed, bitmap.HEIGHT, st7789.BLACK) man.move() if man.x > 0: tft.bitmap(bitmap, man.x, man.y) else: tft.fill_rect(0, man.y, bitmap.WIDTH, bitmap.HEIGHT, st7789.BLACK)
def main(): Pin(22, Pin.OUT, value=1) spi = SoftSPI(baudrate=20000000, polarity=1, phase=0, sck=Pin(2), mosi=Pin(3), miso=Pin(13)) tft = st7789.ST7789(spi, 135, 240, reset=Pin(0, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(1, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=0) tft.vscrdef(40, 240, 40) while True: for font in (font1, font2, font3, font4): tft.fill(st7789.BLUE) line = 0 col = 0 for char in range(font.FIRST, font.LAST): tft.text(font, chr(char), col, line, st7789.WHITE, st7789.BLUE) col += font.WIDTH if col > tft.width - font.WIDTH: col = 0 line += font.HEIGHT if line > tft.height - font.HEIGHT: utime.sleep(3) tft.fill(st7789.BLUE) line = 0 col = 0 utime.sleep(3)
def main(): tft = st7789.ST7789(SoftSPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19)), 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=3) tft.init() while True: for font in (font1, font2, font3, font4): tft.fill(st7789.BLUE) line = 0 col = 0 for char in range(font.FIRST, font.LAST): tft.text(font, chr(char), col, line, st7789.WHITE, st7789.BLUE) col += font.WIDTH if col > tft.width() - font.WIDTH: col = 0 line += font.HEIGHT if line > tft.height() - font.HEIGHT: utime.sleep(3) tft.fill(st7789.BLUE) line = 0 col = 0 utime.sleep(3)
class NRF24L01: SCK = 5 MOSI = 4 MISO = 0 def __init__(self, ce, csn, spi=None, baudrate=400000, payload_size=16): self._csn = Pin(csn) if type(csn) == int else csn self._ce = Pin(ce) if type(ce) == int else ce self._payload_size = payload_size self._spi = spi self._init_spi(baudrate) self._ce.init(Pin.OUT, value=0) self._csn.init(Pin.OUT, value=1) self._buf = bytearray(1) self._write_reg(SETUP_AW, FIVE_BYTE_ADDRESS) if self._read_reg(SETUP_AW) != FIVE_BYTE_ADDRESS: print('Failed to set address width!') self._flush_tx() self._flush_rx() def _write_reg(self, reg, data): self._csn(0) self._spi.readinto(self._buf, 0x20 | reg) ret = self._buf[0] self._spi.readinto(self._buf, data) self._csn(1) return ret def _write_reg_bytes(self, reg, data): self._csn(0) self._spi.readinto(self._buf, 0x20 | reg) self._spi.write(data) self._csn(1) return self._buf[0] def _read_reg(self, reg): self._csn(0) self._spi.readinto(self._buf, 0x00 | reg) self._spi.readinto(self._buf) self._csn(1) return self._buf[0] def read_reg(self, reg): return bin(self._read_reg(reg)) def _init_spi(self, baudrate): if self._spi is None: self._spi = SoftSPI(baudrate=baudrate, polarity=0, phase=0, sck=Pin(self.SCK), mosi=Pin(self.MOSI), miso=Pin(self.MISO)) self._spi.init(baudrate=baudrate) def _flush_rx(self): self._csn(0) self._spi.readinto(self._buf, FLUSH_RX) self._csn(1) def _flush_tx(self): self._csn(0) self._spi.readinto(self._buf, FLUSH_TX) self._csn(1) def set_channel(self, channel): self._write_reg(RF_CH, channel) def set_speed(self, speed): self._write_reg(RF_SETUP, self._read_reg(RF_SETUP) | speed) def set_power(self, power): self._write_reg(RF_SETUP, self._read_reg(RF_SETUP) | power) def _get_address(self, address): # Ensure that address is in byte-format if type(address) == list: address = bytes(address) elif type(address) == str: address = binascii.unhexlify(address) return address # Set both RX and TX address to the given value. # Default pipe used is PIPE 0 def open_tx_pipe(self, address): address = self._get_address(address) self._write_reg_bytes(RX_ADDR_P0, address) self._write_reg_bytes(TX_ADDR, address) # Must enable RX pipe by writing data-length to it (CAN'T be 0) self._write_reg(RX_PW_P0, self._payload_size) self._ce(0) # Default pipe is PIPE 0 def open_rx_pipe(self, address): address = self._get_address(address) # Set RX address self._write_reg_bytes(RX_ADDR_P0, address) # Nbr of bytes in RX payload self._write_reg(RX_PW_P0, self._payload_size) # Enable RX self._write_reg(EN_RXADDR, self._read_reg(EN_RXADDR) | ERX_P0) self._write_reg(EN_AA, self._read_reg(EN_AA) & ~ENAA_P0) def enable_auto_ack(self): self._write_reg(EN_AA, self._read_reg(EN_AA) | ENAA_P0) # The parameter crc is the ammount of bytes to be used. # Only 1 or 2 is accepted. def set_crc(self, crc): # read config reg (wihtout the current CRC value) config = self._read_reg(CONFIG) & ~CRC if crc == 1: config |= CRC_ENA elif crc == 2: config |= CRC_ENA | CRC self._write_reg(CONFIG, config) def start_listening(self): # Power-up and enable RX self._write_reg(CONFIG, self._read_reg(CONFIG) | PWR_UP | PRIM_RX) self._write_reg(STATUS, self._read_reg(STATUS) | RX_DR | TX_DS | MAX_RT) # Flush fifos and set CE HIGH to start listening. self._flush_rx() self._flush_tx() self._ce(1) def stop_listening(self): self._ce(0) self._flush_rx() self._flush_tx() def read(self): # Read the data from the payload reg self._ce(0) self._csn(0) # R_RX_PAYLOAD = 0x61 self._spi.readinto(self._buf, 0x61) data = self._spi.read(self._payload_size) # Must toggle CE here as well, to disable receiver temporarly self._ce(1) self._csn(1) # Clear RX ready flag when done self._write_reg(STATUS, self._read_reg(STATUS) | RX_DR) return data def send(self, buf, timeout=500): self._send_start(buf) start = time.ticks_ms() result = None while (result is None and time.ticks_diff(time.ticks_ms(), start) < timeout): result = self._send_done() print('result: %s' % result) def _send_done(self): status = self._read_reg(STATUS) if not (status & (TX_DS | MAX_RT)): # Haven't finished yet return None # Transmission is over, clear the interrupt bits in the status-reg self._write_reg(STATUS, status | RX_DR | TX_DS | MAX_RT) if status & TX_DS: # Successfull send return 1 else: # MAX attempts have passed, return 2 to indicate failure return 2 def _send_start(self, buf): # Power-up and enable TX self._write_reg(CONFIG, (self._read_reg(CONFIG) | PWR_UP) & ~PRIM_RX) time.sleep_us(200) # Send the data self._csn(0) # W_TX_PAYLOAD = 0xA0 self._spi.readinto(self._buf, 0xA0) self._spi.write(buf) # Need to pad the rest of the packet if data ist too small. if len(buf) < self._payload_size: self._spi.write(b'\x00' * (self._payload_size - len(buf))) self._csn(1) # Toggle the ce-signal to send that data self._ce(1) time.sleep_us(15) # MINIMUM 10 us according to datasheet self._ce(0) def close(self): self._spi.deinit()
from machine import Pin, SoftSPI from micropython_mfrc522.mfrc522 import MFRC522 sck = Pin(18, Pin.OUT) copi = Pin(23, Pin.OUT) # Controller out, peripheral in cipo = Pin(19, Pin.OUT) # Controller in, peripheral out spi = SoftSPI(baudrate=100000, polarity=0, phase=0, sck=sck, mosi=copi, miso=cipo) sda = Pin(21, Pin.OUT) reader = MFRC522(spi, sda) print('Place Card In Front Of Device To Write Unique Address') print('') while True: try: (status, tag_type) = reader.request(reader.CARD_REQIDL) if status == reader.OK: (status, raw_uid) = reader.anticoll() if status == reader.OK: print('New Card Detected') print(' - Tag Type: 0x%02x' % tag_type) print(' - UID: 0x%02x%02x%02x%02x' % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])) print('') if reader.select_tag(raw_uid) == reader.OK:
import ssd1306 import time PWR_ON = 2 OLED_PWR = 33 TOUCH = 15 TOUCH_PWR = 32 TOUCHD = False pwr_on = Pin(2, Pin.OUT, value=0) oled_pwr = Pin(33, Pin.OUT, value=0) touch = Pin(TOUCH, Pin.IN) touch_pwr = Pin(TOUCH_PWR, Pin.OUT, value=0) spi = SoftSPI(baudrate=27000000, sck=Pin(18), mosi=Pin(23), miso=Pin(32)) dc = Pin(19) rst = Pin(4) cs = Pin(5) pwr_on.value(1) touch_pwr.value(0) oled_pwr.value(1) display = ssd1306.SSD1306_SPI(128, 64, spi, dc, rst, cs) display.poweron() display.text('Hello', 0, 0, 1) display.show() while (1): SoftSPI.deinit(spi)
def _init_spi(self, baudrate): if self._spi is None: self._spi = SoftSPI(baudrate=baudrate, polarity=0, phase=0, sck=Pin(self.SCK), mosi=Pin(self.MOSI), miso=Pin(self.MISO)) self._spi.init(baudrate=baudrate)
def initSPI(): spi = SoftSPI(baudrate=config.BAUD, sck=Pin(config.SCK), mosi=Pin(config.MOSI), miso=Pin(config.MISO)) return spi
def main(): global m_selected_device, m_selected_device_idx, m_all_devices, m_env_data, m_has_update, m_tim0 global CLOCKMODE mqtt_client = None hasNetwork = initNetwork(secrets.SSID, secrets.PASS) spi = initSPI() display = initDisplay(spi) bignum = Writer(display, largedigits, verbose=False) wris = Writer(display, smallfont, verbose=False) wrisc = Writer(display, tinyfont, verbose=False) if hasNetwork: mqtt_client = initMQTT() ntptime.settime() powerOn() display.poweron() adc = initADC() batt_lvl = readBatteryLevel(adc) display.fill(0) wris.set_textpos(display, 0, 0) wris.printstring('Weather 1.0') if hasNetwork: display.text('WiFi', 0, 48, 1) if mqtt_client is not None: display.text('WiFi+MQTT', 0, 48, 1) display.show() time.sleep(2) was_touched = False virgin = True touch_start_time = 0 m_tim0 = None while 1: mc = False if mqtt_client is not None: mqtt_client.check_msg() # mc = mqtt_client.connect(clean_session=False) mc = True # Touch power overlapped with MISO, need to take SPI away fist SoftSPI.deinit(spi) touch = initTouch() time.sleep_ms(50) # We only act when finger lifted touched = (touch.value() == 1) if (touched and not was_touched): touch_start_time = time.time() released = (not touched and was_touched) was_touched = touched if not released and touched: if (touch_start_time > 0) and ( (time.time() - touch_start_time) > 3): # Hold for 5 seconds, a long touch if not CLOCKMODE: touch_start_time = 0 CLOCKMODE = True else: CLOCKMODE = False touch_start_time = 0 virgin = True if m_tim0 is not None: m_tim0.deinit() m_tim0 = None elif released and ( (time.time() - touch_start_time) <= 3) and CLOCKMODE: if CLOCKMODE: touch_start_time = 0 m_tim0 = Timer(0) m_tim0.init(period=2000, mode=Timer.ONE_SHOT, callback=lambda t: set_clockMode()) virgin = True CLOCKMODE = False # We are done, SPI again spi = initSPI() if (released or virgin) and not CLOCKMODE: if m_tim0 is not None: m_tim0.deinit() m_tim0 = Timer(0) m_tim0.init(period=2000, mode=Timer.ONE_SHOT, callback=lambda t: set_clockMode()) if len(m_all_devices) > 0: if not virgin: # First touch will not move pointer forward m_selected_device_idx = m_selected_device_idx + 1 if m_selected_device_idx >= len(m_all_devices): m_selected_device_idx = 0 m_has_update = False if released: virgin = False # Touched, no longer virgin m_selected_device = m_all_devices[m_selected_device_idx] (temp, humi, pres, lux) = m_env_data[m_selected_device] # display.fill_rect(0, 0, 127, 16, 0) if not CLOCKMODE: display.fill(0) # display.text(m_selected_device, 0, 0, 1) if (config.STYLE == 0): if (temp is not None): display.text(temp, 8, 16, 1) if (humi is not None): display.text(humi, 64, 16, 1) if (pres is not None): display.text(pres, 8, 32, 1) if (lux is not None): display.text(lux, 64, 32, 1) else: row = 24 if (temp is not None): bignum.set_textpos(display, col=0, row=row) bignum.printstring(str(temp) + '"c') if (humi is not None): wris.set_textpos(display, col=config.DISPLAY_WIDTH - wris.stringlen('{:s}%'.format(humi)), row=row + 10) wris.printstring('{:s}%'.format(humi)) else: print_clock(display, bignum, wris) if temp is not None: temp = '{:d}'.format(round(float(temp))) wris.set_textpos(display, col=config.DISPLAY_WIDTH - wris.stringlen(temp), row=42) wris.printstring(temp) batt_lvl = readBatteryLevel(adc) print_status(display, hasNetwork, mqtt_client is not None, m_has_update, batt_lvl) if mqtt_client is not None: mqtt_client.disconnect()
def callback_b2(p): fill_random_color() button1.irq( trigger=Pin.IRQ_FALLING, handler=callback_b1 ) # interrupt for right button (button 2) button2.irq( trigger=Pin.IRQ_FALLING, handler=callback_b2 ) # interrupt for left button (button 1) BLK = Pin(BL_Pin, Pin.OUT) spi = SoftSPI( baudrate=80000000, miso=Pin(MISO_Pin), mosi=Pin(MOSI_Pin, Pin.OUT), sck=Pin(SCLK_Pin, Pin.OUT), ) display = st7789.ST7789(spi, 135, 240, cs=Pin(CS_Pin), dc=Pin(DC_Pin), rst=None) def clear_screen(): display._set_mem_access_mode(0, False, False, False) display.fill(0) # filling the display with black def fill_random_color(): fill_hline() fill_vline() display.fill(random_color())
from machine import Pin, SoftSPI import tinypico as TinyPICO from dotstar import DotStar import time, random, micropython, gc # Configure SPI for controlling the DotStar # Internally we are using software SPI for this as the pins being used are not hardware SPI pins spi = SoftSPI(sck=Pin(TinyPICO.DOTSTAR_CLK), mosi=Pin(TinyPICO.DOTSTAR_DATA), miso=Pin(TinyPICO.SPI_MISO)) # Create a DotStar instance dotstar = DotStar(spi, 1, brightness=0.5) # Just one DotStar, half brightness # Turn on the power to the DotStar TinyPICO.set_dotstar_power(True) # Say hello print("\nHello from TinyPICO!") print("--------------------\n") # Show some info on boot print("Battery Voltage is {}V".format(TinyPICO.get_battery_voltage())) print("Battery Charge State is {}\n".format(TinyPICO.get_battery_charging())) # Show available memory print("Memory Info - micropython.mem_info()") print("------------------------------------") micropython.mem_info() # Create a colour wheel index int
i2c_sda = Pin(4, Pin.OUT, Pin.PULL_UP) # Create the bus object i2c = SoftI2C(scl=i2c_scl, sda=i2c_sda) # Create the display object oled = SSD1306_I2C(oled_width, oled_height, i2c) oled.fill(0) oled.text('Samim SmartHome', 0, 10) oled.text('LoRaMQTTDev '+str(DEV_VER), 0, 20) oled.show() print("OLED configured") if module_config['module_type']=='ESP32': print("Configuring ESP32.") device_spi = SoftSPI(baudrate = 10000000, polarity = 0, phase = 0, bits = 8, firstbit = SoftSPI.MSB, sck = Pin(device_config['sck'], Pin.OUT, Pin.PULL_DOWN), mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP), miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP)) else: print("Configuring ESP8266") device_spi = SoftSPI(baudrate = 10000000, polarity = 0, phase = 0, bits = 8, firstbit = SoftSPI.MSB, sck = Pin(device_config['sck'], Pin.OUT), mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP), miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP)) wdt.feed() lora = SX127x(device_spi, pins=device_config, parameters=lora_parameters) wdt.feed()
adc.read() # read value, 0-4095 across voltage range 0.0v - 1.0v adc.atten(ADC.ATTN_11DB) # set 11dB input attenuation (voltage range roughly 0.0v - 3.6v) adc.width(ADC.WIDTH_9BIT) # set 9 bit return values (returned range 0-511) adc.read() # read value using the newly configured attenuation and width # Software SPI bus from machine import Pin, SoftSPI # construct a SoftSPI bus on the given pins # polarity is the idle state of SCK # phase=0 means sample on the first edge of SCK, phase=1 means the second spi = SoftSPI(baudrate=100000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4)) spi.init(baudrate=200000) # set the baudrate spi.read(10) # read 10 bytes on MISO spi.read(10, 0xFF) # read 10 bytes while outputting 0xff on MOSI buf = bytearray(50) # create a buffer spi.readinto(buf) # read into the given buffer (reads 50 bytes in this case) spi.readinto(buf, 0xFF) # read into the given buffer and output 0xff on MOSI spi.write(b"12345") # write 5 bytes on MOSI buf = bytearray(4) # create a buffer spi.write_readinto(b"1234", buf) # write to MOSI and read from MISO into the buffer spi.write_readinto(buf, buf) # write buf to MOSI and read MISO back into buf
def main(): ''' The big show! ''' #enable display and clear screen tft = st7789.ST7789(SoftSPI(baudrate=30000000, polarity=1, sck=Pin(10), mosi=Pin(11), miso=Pin(16)), 135, 240, reset=Pin(12, Pin.OUT), cs=Pin(9, Pin.OUT), dc=Pin(8, Pin.OUT), backlight=Pin(13, Pin.OUT), rotation=1) tft.fill(st7789.BLACK) # clear screen height = tft.height # height of display in pixels width = tft.width # width if display in pixels tfa = 40 # top free area when scrolling bfa = 40 # bottom free area when scrolling scroll = 0 # scroll position wheel = 0 # color wheel position tft.vscrdef(tfa, width, bfa) # set scroll area tft.vscsad(scroll + tfa) # set scroll position tft.fill(st7789.BLACK) # clear screen half = (height >> 1) - 1 # half the height of the dislay interval = 0 # steps between new points increment = 0 # increment per step counter = 1 # step counter, overflow to start current_y = 0 # current_y value (right point) last_y = 0 # last_y value (left point) # segment offsets x_offsets = [x * (width // 8) - 1 for x in range(2, 9)] while True: # when the counter exceeds the interval, save current_y to last_y, # choose a new random value for current_y between 0 and 1/2 the # height of the display, choose a new random interval then reset # the counter to 0 if counter > interval: last_y = current_y current_y = random.randint(0, half) counter = 0 interval = random.randint(10, 100) increment = 1 / interval # increment per step # clear the first column of the display and scroll it tft.vline(scroll, 0, height, st7789.BLACK) tft.vscsad(scroll + tfa) # get the next point between last_y and current_y tween = int(between(last_y, current_y, counter * increment)) # draw mirrored pixels across the display at the offsets using the color_wheel effect for i, x_offset in enumerate(x_offsets): tft.pixel((scroll + x_offset) % width, half + tween, color_wheel(wheel + (i << 2))) tft.pixel((scroll + x_offset) % width, half - tween, color_wheel(wheel + (i << 2))) # increment scroll, counter, and wheel scroll = (scroll + 1) % width wheel = (wheel + 1) % 256 counter += 1