def __init__( self, address: int = 0x5E, i2c: Optional[I2C] = None, spi: Optional[SPI] = None, cs: Optional[Pin] = None, dc: Optional[Pin] = None, ): displayio.release_displays() if i2c is None: i2c = board.I2C() if spi is None: spi = board.SPI() if cs is None: cs = board.D5 if dc is None: dc = board.D6 self._ss = Seesaw(i2c, address) self._ss.pin_mode_bulk(self._button_mask, self._ss.INPUT_PULLUP) self._ss.pin_mode(8, self._ss.OUTPUT) self._ss.digital_write(8, True) # Reset the Display via Seesaw self._backlight = PWMOut(self._ss, 5) self._backlight.duty_cycle = 0 display_bus = displayio.FourWire(spi, command=dc, chip_select=cs) self.display = ST7735R(display_bus, width=160, height=80, colstart=24, rotation=270, bgr=True)
def display_text(text, color): # Release any resources currently in use for the displays displayio.release_displays() spi = board.SPI() tft_cs = board.D3 tft_dc = board.D4 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D7) display = ST7735R(display_bus, width=128, height=128, colstart=2, rowstart=1, rotation=270) # Make the display context splash = displayio.Group(max_size=10) display.show(splash) # Choose the color of the screen background color_bitmap = displayio.Bitmap(128, 128, 1) color_palette = displayio.Palette(1) color_palette[0] = color bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) splash.append(bg_sprite) # Draw label text_area = label.Label(terminalio.FONT, text=text, color=0xFFFFFF, x=30, y=64) splash.append(text_area)
def __init__(self, address=0x5E, i2c=None, spi=None): if i2c is None: i2c = board.I2C() if spi is None: spi = board.SPI() self._ss = Seesaw(i2c, address) self._backlight = PWMOut(self._ss, 5) self._backlight.duty_cycle = 0 displayio.release_displays() while not spi.try_lock(): pass spi.configure(baudrate=24000000) spi.unlock() self._ss.pin_mode(8, self._ss.OUTPUT) self._ss.digital_write(8, True) # Reset the Display via Seesaw display_bus = displayio.FourWire(spi, command=board.D6, chip_select=board.D5) self.display = ST7735R(display_bus, width=160, height=80, colstart=24, rotation=270, bgr=True) self._ss.pin_mode_bulk(self._button_mask, self._ss.INPUT_PULLUP)
def Screen(tests, num_test_bytes, write_tests_to_nvm, reset): try: import board, pimoroni_physical_feather_pins, displayio from adafruit_st7735r import ST7735R #region Screen setup """ This region of code is used to setup the envirowing screen with displayio """ spi = board.SPI() # define which spi bus the screen is on spi.try_lock() # try to get control of the spi bus spi.configure( baudrate=100000000) # tell the spi bus how fast it's going to run # baudrate doesn't need to be this high in practice, it's just nice to have a quick screen refresh in this case spi.unlock() # unlocks the spi bus so displayio can control it tft_dc = pimoroni_physical_feather_pins.pin19( ) # define which pin the command line is on tft_cs = pimoroni_physical_feather_pins.pin20( ) # define which pin the chip select line is on displayio.release_displays( ) # release any displays that may exist from previous code run display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=pimoroni_physical_feather_pins. pin21()) # define the display bus display = ST7735R( display_bus, width=160, height=80, colstart=26, rowstart=1, rotation=270, invert=True ) # define the display (these values are specific to the envirowing's screen) #endregion Screen setup if display: tests["Screen"]["Passed"] = True print("Passed with", display) else: tests["Screen"]["Passed"] = False print("Failed") except Exception as e: tests["Screen"]["Passed"] = False print("Failed with ", e) finally: tests["Screen"]["Test Run"] = True write_tests_to_nvm(tests, num_test_bytes) reset()
def Screen(backlight_control=True, baudrate=100000000, spi=None): """__init__ :param bool backlight_control: determines whether this class should handle the screen's backlight (default True) (this is useful to set to False if you want to control the brightness with pwm in your own code) :param int baudrate: sets the baudrate for the spi connection to the display (default 100000000) (baudrate doesn't need to be this high for the display to function, it's just nice to have a quick screen refresh by default) This class is used to setup the envirowing screen with displayio and return a display object """ import board import pimoroni_physical_feather_pins import displayio from adafruit_st7735r import ST7735R # if not supplied an spi object, make our own if not spi: spi = board.SPI() # define which spi bus the screen is on spi.try_lock() # try to get control of the spi bus spi.configure( baudrate=baudrate) # tell the spi bus how fast it's going to run spi.unlock() # unlocks the spi bus so displayio can control it displayio.release_displays( ) # release any displays that may exist from previous code run if backlight_control: display_bus = displayio.FourWire( spi, command=pimoroni_physical_feather_pins.pin19(), chip_select=pimoroni_physical_feather_pins.pin20(), reset=pimoroni_physical_feather_pins.pin21( )) # define the display bus else: display_bus = displayio.FourWire( spi, command=pimoroni_physical_feather_pins.pin19(), chip_select=pimoroni_physical_feather_pins.pin20( )) # define the display bus display = ST7735R( display_bus, width=160, height=80, colstart=26, rowstart=1, rotation=270, invert=True ) # define the display (these values are specific to the envirowing's screen) return display
def __init__(self, backlight_control=True, baudrate=100000000): spi = board.SPI() spi.try_lock() spi.configure(baudrate=baudrate) spi.unlock() displayio.release_displays() dev = os.uname().sysname if dev == 'samd51': print('Configuring for Feather M4 Express') cmd = board.D5 cs = board.D6 rst = board.D9 elif dev == 'nrf52840': print('Configuring for Feather nRF52840') cmd = board.D2 cs = board.D3 rst = board.D4 else: raise Exception('Unknown board ' + dev) if backlight_control: display_bus = displayio.FourWire(spi, command=cmd, chip_select=cs, reset=rst, baudrate=baudrate) self.pwm = None else: display_bus = displayio.FourWire(spi, command=cmd, chip_select=cs, baudrate=baudrate) self.pwm = pulseio.PWMOut(board.D4) self.pwm.duty_cycle = 2**15 self.display = ST7735R(display_bus, width=160, height=80, colstart=26, rowstart=1, rotation=270, invert=True) #bgr=True self.init()
def setup_display(): displayio.release_displays() spi = board.SPI() tft_cs = board.A5 tft_dc = board.A3 displayio.release_displays() display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.A4) return ST7735R(display_bus, width=128, height=128, colstart=2, rowstart=1, rotation=180)
def display_results(tests): import board, pimoroni_physical_feather_pins, displayio from adafruit_st7735r import ST7735R #region Screen setup """ This region of code is used to setup the envirowing screen with displayio """ spi = board.SPI() # define which spi bus the screen is on spi.try_lock() # try to get control of the spi bus spi.configure(baudrate=100000000) # tell the spi bus how fast it's going to run # baudrate doesn't need to be this high in practice, it's just nice to have a quick screen refresh in this case spi.unlock() # unlocks the spi bus so displayio can control it tft_dc = pimoroni_physical_feather_pins.pin19() # define which pin the command line is on tft_cs = pimoroni_physical_feather_pins.pin20() # define which pin the chip select line is on displayio.release_displays() # release any displays that may exist from previous code run display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=pimoroni_physical_feather_pins.pin21()) # define the display bus display = ST7735R(display_bus, width=160, height=80, colstart=26, rowstart=1, rotation=270, invert=True) # define the display (these values are specific to the envirowing's screen) #endregion Screen setup failed = [] for test in tests.keys(): if test not in ("Finished", "Read"): if not tests[test]["Passed"]: failed.append(test) if not failed: print("All Tests Passed!") else: print("These tests failed:") print(", ".join(failed)) tests["Read"] = True write_tests_to_nvm(tests, num_test_bytes) while True: pass
upRight = servo.Servo(pwm3) #alternative name servo3 upLeft = servo.Servo(pwm4) #alternative name servo4 # setting up sonar to use pin out D3 and D4 sonar = adafruit_hcsr04.HCSR04(trigger_pin=board.D3, echo_pin=board.D4) # Release any resources currently in use for the displays displayio.release_displays() # setting up LCD board spi = board.SPI() tft_cs = board.D11 tft_dc = board.D9 # setting up the LCD board so the code knows the size of the screen display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D7) display = ST7735R(display_bus, width=128, height=128) # Make the display context splash = displayio.Group(max_size=20) my_label = label.Label(terminalio.FONT, text="My Label Text", color=0xFFFFFF, x = 40, y = 40) splash.append(my_label) display.show(splash) # setting up text to display on LCD text = "Hello world" text_area = label.Label(terminalio.FONT, text=text) text_area.x = 30 text_area.y = 60 display.show(text_area) def dance1():
# pylint: disable=attribute-defined-outside-init # Release any resources currently in use for the displays displayio.release_displays() ss = TFTShield18() spi = board.SPI() tft_cs = board.D10 tft_dc = board.D8 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs) ss.tft_reset() display = ST7735R( display_bus, width=160, height=128, rotation=90, bgr=True, auto_refresh=False ) ss.set_backlight(True) class OV7670_GrandCentral(OV7670): def __init__(self): with digitalio.DigitalInOut(board.D39) as shutdown: shutdown.switch_to_output(True) time.sleep(0.001) bus = busio.I2C(board.D24, board.D25) self._bus = bus OV7670.__init__( self, bus,
This test will initialize the display using displayio and draw a solid red background """ import board import displayio from adafruit_st7735r import ST7735R spi = board.SPI() tft_cs = board.D5 tft_dc = board.D6 displayio.release_displays() display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) display = ST7735R(display_bus, width=128, height=160, bgr=True) # Make the display context splash = displayio.Group(max_size=10) display.show(splash) color_bitmap = displayio.Bitmap(128, 160, 1) color_palette = displayio.Palette(1) color_palette[0] = 0xFF0000 try: bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, position=(0, 0)) except TypeError: bg_sprite = displayio.TileGrid(color_bitmap,
D_BLACK = 0x000000 D_WHITE = 0xFFFFFF # setup ST7735 display 1.8in TFT http://www.adafruit.com/products/358 ############### # see https://github.com/adafruit/Adafruit_CircuitPython_ST7735R/blob/master/examples/st7735r_128x160_simpletest.py spi = board.SPI() tft_cs = board.D10 tft_dc = board.D7 displayio.release_displays() display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) display = ST7735R(display_bus, width=160, height=128, rotation=90, bgr=True) # Make the display context splash = displayio.Group(max_size=10) display.show(splash) left_circle = Circle(40, 30, 15, fill=D_RED) splash.append(left_circle) right_circle = Circle(120, 30, 15, fill=D_RED) splash.append(right_circle) text = "" text_group1 = displayio.Group(max_size=2, scale=2, x=0, y=88) line1_textbox = label.Label(terminalio.FONT, text=text, color=D_YELLOW,
def __init__(self): self.reset_pin = 8 self.i2c = board.I2C() self.ss = Seesaw(self.i2c, 0x5E) self.ss.pin_mode(self.reset_pin, self.ss.OUTPUT) self.spi = board.SPI() self.tft_cs = board.D5 self.tft_dc = board.D6 self._auto_show = True displayio.release_displays() self.display_bus = displayio.FourWire(self.spi, command=self.tft_dc, chip_select=self.tft_cs) self.ss.digital_write(self.reset_pin, True) self.display = ST7735R(self.display_bus, width=160, height=80, colstart=24, rotation=270, bgr=True) self.nbr_rows = 5 self.row_height = int(self.display.height / self.nbr_rows) self.row_vpos = [ int(i * self.row_height) for i in range(self.nbr_rows) ] self.row_bkgnd_color = [ 0x808080, 0xFF0000, 0x000040, 0x0000FF, 0xAA0088 ] self.row_text_color = [ 0xFFFFFF, 0xFFFF00, 0xFF0000, 0xFFFF00, 0xFAFAFA ] self.row_text = ['r1', 'r2', 'r3', 'r4', 'r5'] # ----------------------------------------------------------------------------------- # Button handler # ----------------------------------------------------------------------------------- self.btn_mat = [] self.btn_mat.append([1 << BUTTON_RIGHT, 0, 0, False, 'right']) self.btn_mat.append([1 << BUTTON_DOWN, 0, 0, False, 'down']) self.btn_mat.append([1 << BUTTON_LEFT, 0, 0, False, 'left']) self.btn_mat.append([1 << BUTTON_UP, 0, 0, False, 'up']) self.btn_mat.append([1 << BUTTON_SEL, 0, 0, False, 'select']) self.btn_mat.append([1 << BUTTON_A, 0, 0, False, 'A']) self.btn_mat.append([1 << BUTTON_B, 0, 0, False, 'B']) # print(btn_mat) self.btn_mask = 0 for mask_indx in range(len(self.btn_mat)): self.btn_mask = self.btn_mask | self.btn_mat[mask_indx][0] # print(btn_mask) self.ss.pin_mode_bulk(self.btn_mask, self.ss.INPUT_PULLUP) self.state_dict = { 'idle': 0, 'pressed': 1, 'pressed_deb': 2, 'released': 3, 'released_deb': 4 } self.btn_repeat_time = 1.0 self.btn_deb_time = 0.1
tft_cs = board.D2 # ItsyBitsy M4 Express tft_dc = board.D3 lcd_rst = board.D4 # battery voltage measurements need a jumper from batt to A1 vbat_voltage = AnalogIn(board.A1) # Setup the bus, display object, and font for the display displayio.release_displays() if DISPLAY == "0.96 LCD": display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=lcd_rst) display = ST7735R(display_bus, rotation=TEXT_ROTATION, width=160, height=80, colstart=24, bgr=True) font = bitmap_font.load_font("mandalor80.bdf") # 80 pixel tall bitmap font elif DISPLAY == "0.96 OLED": display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=lcd_rst) display = SSD1331(display_bus, rotation=TEXT_ROTATION, width=96, height=64) font = bitmap_font.load_font("mandalor64.bdf") # 64 pixel tall bitmap font elif DISPLAY == "0.96 Mono OLED": TEXT_COLOR = 0xFFFFFF # it's monochrome, you can only do white display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs,
tft_cs = pimoroni_physical_feather_pins.pin20( ) # define which pin the chip select line is on displayio.release_displays( ) # release any displays that may exist from previous code run display_bus = displayio.FourWire( spi, command=tft_dc, chip_select=tft_cs, reset=pimoroni_physical_feather_pins.pin21()) # define the display bus display = ST7735R( display_bus, width=160, height=80, colstart=26, rowstart=1, rotation=270, invert=True ) # define the display (these values are specific to the envirowing's screen) print("Screen successfully set up!") #endregion Screen setup i2c = board.I2C() print("I2C Initialised!") #region BME280 testing bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=0x76)
reset_pin = 8 i2c = board.I2C() ss = Seesaw(i2c, 0x5E) ss.pin_mode(reset_pin, ss.OUTPUT) spi = board.SPI() tft_cs = board.D5 tft_dc = board.D6 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs) ss.digital_write(reset_pin, True) display = ST7735R(display_bus, width=160, height=80, colstart=24, rotation=270, bgr=True) # Make the display context splash = displayio.Group(max_size=10) display.show(splash) color_bitmap = displayio.Bitmap(160, 80, 1) color_palette = displayio.Palette(1) color_palette[0] = 0x00FF00 # Bright Green bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
from adafruit_st7735r import ST7735R from TryMoves import Move # Releases all previous displays displayio.release_displays() # LCD Initialization spi = board.SPI() tft_cs = board.A2 tft_dc = board.A4 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.A3) display = ST7735R(display_bus, width=128, height=128, colstart=2, rowstart=1) # Bluetooth UART uart = busio.UART(board.TX, board.RX, baudrate=9600) ''' Function that reads the bluetooth bluefruit input buffer, clears it, and then sets the bluetooth_input variable ''' def readBluetooth(): global bluetooth_input data = uart.read(8) print(data) data = str(data) if data is not None: # decodes the data if it's a valid input
# Release any resources currently in use for the displays displayio.release_displays() spi = board.SPI() tft_cs = board.D3 tft_dc = board.D4 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D7) display = ST7735R(display_bus, width=128, height=128, colstart=2, rowstart=1, rotation=270) # Make the display context splash = displayio.Group(max_size=10) display.show(splash) color_bitmap = displayio.Bitmap(128, 128, 1) color_palette = displayio.Palette(1) color_palette[0] = 0x00FF00 # Bright Green bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
import displayio import digitalio from adafruit_st7735r import ST7735R from adafruit_rgb_display import color565 import adafruit_rgb_display.st7735 as st7735 tft_cs = board.A2 #digitalio.DigitalInOut(board.A2) tft_dc = board.A3 #digitalio.DigitalInOut(board.A3) tft_rc = board.A4 #digitalio.DigitalInOut(board.A4) spi = board.SPI() displayio.release_displays() dbus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=tft_rc) display = ST7735R(dbus, width=128, height=160, colstart=0, rowstart=0, bgr=True) f = open("/img.bmp", "rb") odb = displayio.OnDiskBitmap(f) face = displayio.TileGrid(odb, pixel_shader=displayio.ColorConverter()) splash = displayio.Group(max_size=10) splash.append(face) display.show(splash) while True: pass
PIN_DC = board.GP10 PIN_RST = board.GP11 WIDTH = 160 HEIGHT = 128 spi = busio.SPI(clock=PIN_CLK, MOSI=PIN_TX) #, MISO=PIN_RX) display_bus = displayio.FourWire(spi, command=PIN_DC, chip_select=PIN_CS, reset=PIN_RST) display = ST7735R(display_bus, width=WIDTH, height=HEIGHT, rotation=270, bgr=True) # Make the display context splash = displayio.Group() display.show(splash) color_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1) color_palette = displayio.Palette(1) # write some text in each font color, rgb, cmyk color_palette[0] = 0xBBBBBB # light grey bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0,