def __init__(self, spi=None, cs=None, dc=None, ts_cs=None, sd_cs=None):
displayio.release_displays()
if spi is None:
spi = board.SPI()
if cs is None:
cs = board.D9
if dc is None:
dc = board.D10
if ts_cs is None:
ts_cs = board.D6
if sd_cs is None:
sd_cs = board.D5
ts_cs = digitalio.DigitalInOut(ts_cs)
self._display_bus = displayio.FourWire(spi, command=dc, chip_select=cs)
self._sdcard = None
try:
self._sdcard = sdcardio.SDCard(spi, sd_cs)
vfs = storage.VfsFat(self._sdcard)
storage.mount(vfs, "/sd")
except OSError as error:
print("No SD card found:", error)
try:
# the screen might not be ready from cold boot
time.sleep(0.8)
self.touchscreen = Adafruit_STMPE610_SPI(spi, ts_cs)
except RuntimeError:
# wait and try once more
time.sleep(1.0)
self.touchscreen = Adafruit_STMPE610_SPI(spi, ts_cs)
def __init__(self, spi=None, cs=None, dc=None, i2c=None):
displayio.release_displays()
if spi is None:
spi = board.SPI()
if cs is None:
cs = board.D9
if dc is None:
dc = board.D10
if i2c is None:
i2c = board.I2C()
ts_cs = digitalio.DigitalInOut(board.D6)
self.touchscreen = Adafruit_STMPE610_SPI(spi, ts_cs)
display_bus = displayio.FourWire(spi, command=dc, chip_select=cs)
self.display = adafruit_ili9341.ILI9341(display_bus, width=320, height=240)
self.neopixel = neopixel.NeoPixel(board.D11, 1)
self.keyboard = BBQ10Keyboard(i2c)
sd_cs = board.D5
self._sdcard = None
try:
self._sdcard = sdcardio.SDCard(spi, sd_cs)
vfs = storage.VfsFat(self._sdcard)
storage.mount(vfs, "/sd")
except OSError as error:
print("No SD card found:", error)
def setup_sd(self, sdcs):
try:
self.sdcard = sdcardio.SDCard(self.sp, sdcs)
except OSError:
return False
self.vfs = storage.VfsFat(self.sdcard)
storage.mount(self.vfs, "/sd")
return True
def check_SDCARD():
initialize_OLED()
LED[10].deinit()
LED[11].deinit()
LED[12].deinit()
LED[15].deinit()
spi = busio.SPI(board.GP10, MOSI=board.GP11, MISO=board.GP12)
cs = board.GP15
try:
global sd
sd = sdcardio.SDCard(spi, cs)
vfs = storage.VfsFat(sd)
storage.mount(vfs, '/sd')
with open("/sd/pico.txt", "w") as file:
file.write("1. Hello, world!\r\n")
with open("/sd/pico.txt", "r") as file:
for line in file:
if line == "1. Hello, world!\r\n":
for i in up:
buzzer.frequency = tones[i]
buzzer.duty_cycle = 19660
time.sleep(0.15)
buzzer.duty_cycle = 0
if I2C:
oled.text('GP22 PRESSED', 30, 20, 1)
oled.text('SD CARD TEST: PASS', 7, 40, 1)
else:
if I2C:
oled.text('GP22 PRESSED', 30, 10, 1)
oled.text('SD CARD TEST: FAILED', 5, 25, 1)
oled.text('WRONG DATA', 33, 40, 1)
buzzer.frequency = 1661
buzzer.duty_cycle = 19660
time.sleep(2)
buzzer.duty_cycle = 0
time.sleep(2)
storage.umount(vfs)
spi.deinit()
sd.deinit()
except:
if I2C:
oled.text('GP22 PRESSED', 30, 10, 1)
oled.text('SD CARD TEST: FAILED', 5, 25, 1)
oled.text('NO SD CARD', 33, 40, 1)
buzzer.frequency = 1661
buzzer.duty_cycle = 19660
time.sleep(2)
buzzer.duty_cycle = 0
spi.deinit()
if I2C:
deinitialize_OLED()
LED[10] = digitalio.DigitalInOut(board.GP10)
LED[10].direction = digitalio.Direction.OUTPUT
LED[11] = digitalio.DigitalInOut(board.GP11)
LED[11].direction = digitalio.Direction.OUTPUT
LED[12] = digitalio.DigitalInOut(board.GP12)
LED[12].direction = digitalio.Direction.OUTPUT
LED[15] = digitalio.DigitalInOut(board.GP15)
LED[15].direction = digitalio.Direction.OUTPUT
def __init__(self, spi, display, splash_group, debug=False):
# Speaker Enable
self._speaker_enable = DigitalInOut(board.SPEAKER_ENABLE)
self._speaker_enable.switch_to_output(False)
self._display = display
if hasattr(board, "AUDIO_OUT"):
self.audio = audioio.AudioOut(board.AUDIO_OUT)
elif hasattr(board, "SPEAKER"):
self.audio = audioio.AudioOut(board.SPEAKER)
else:
raise AttributeError("Board does not have a builtin speaker!")
if debug:
print("Init SD Card")
sd_cs = board.SD_CS
if not NATIVE_SD:
sd_cs = DigitalInOut(sd_cs)
self._sdcard = None
try:
self._sdcard = sdcardio.SDCard(spi, sd_cs)
vfs = storage.VfsFat(self._sdcard)
storage.mount(vfs, "/sd")
except OSError as error:
print("No SD card found:", error)
try:
if hasattr(board, "TFT_BACKLIGHT"):
self._backlight = pulseio.PWMOut(board.TFT_BACKLIGHT) # pylint: disable=no-member
elif hasattr(board, "TFT_LITE"):
self._backlight = pulseio.PWMOut(board.TFT_LITE) # pylint: disable=no-member
except ValueError:
self._backlight = None
self.set_backlight(1.0) # turn on backlight
# pylint: disable=import-outside-toplevel
if hasattr(board, "TOUCH_XL"):
import adafruit_touchscreen
if debug:
print("Init touchscreen")
# pylint: disable=no-member
self.touchscreen = adafruit_touchscreen.Touchscreen(
board.TOUCH_XL,
board.TOUCH_XR,
board.TOUCH_YD,
board.TOUCH_YU,
calibration=((5200, 59000), (5800, 57000)),
size=(board.DISPLAY.width, board.DISPLAY.height),
)
# pylint: enable=no-member
self.set_backlight(1.0) # turn on backlight
elif hasattr(board, "BUTTON_CLOCK"):
from adafruit_cursorcontrol.cursorcontrol import Cursor
from adafruit_cursorcontrol.cursorcontrol_cursormanager import CursorManager
if debug:
print("Init cursor")
self.mouse_cursor = Cursor(board.DISPLAY,
display_group=splash_group,
cursor_speed=8)
self.mouse_cursor.hide()
self.cursor = CursorManager(self.mouse_cursor)
else:
raise AttributeError(
"PyPortal module requires either a touchscreen or gamepad.")
# pylint: enable=import-outside-toplevel
gc.collect()
def __init__(self,
*,
url=None,
headers=None,
json_path=None,
regexp_path=None,
convert_image=True,
default_bg=0x000000,
status_neopixel=None,
text_font=terminalio.FONT,
text_position=None,
text_color=0x808080,
text_wrap=False,
text_maxlen=0,
text_transform=None,
text_scale=1,
json_transform=None,
image_json_path=None,
image_resize=None,
image_position=None,
image_dim_json_path=None,
caption_text=None,
caption_font=None,
caption_position=None,
caption_color=0x808080,
image_url_path=None,
success_callback=None,
esp=None,
external_spi=None,
debug=False):
self._debug = debug
self._convert_image = convert_image
try:
if hasattr(board, "TFT_BACKLIGHT"):
self._backlight = pulseio.PWMOut(board.TFT_BACKLIGHT) # pylint: disable=no-member
elif hasattr(board, "TFT_LITE"):
self._backlight = pulseio.PWMOut(board.TFT_LITE) # pylint: disable=no-member
except ValueError:
self._backlight = None
self.set_backlight(1.0) # turn on backlight
self._url = url
self._headers = headers
if json_path:
if isinstance(json_path[0], (list, tuple)):
self._json_path = json_path
else:
self._json_path = (json_path, )
else:
self._json_path = None
self._regexp_path = regexp_path
self._success_callback = success_callback
if status_neopixel:
self.neopix = neopixel.NeoPixel(status_neopixel, 1, brightness=0.2)
else:
self.neopix = None
self.neo_status(0)
try:
os.stat(LOCALFILE)
self._uselocal = True
except OSError:
self._uselocal = False
if self._debug:
print("Init display")
self.splash = displayio.Group(max_size=15)
if self._debug:
print("Init background")
self._bg_group = displayio.Group(max_size=1)
self._bg_file = None
self._default_bg = default_bg
self.splash.append(self._bg_group)
# show thank you and bootup file if available
for bootscreen in ("/thankyou.bmp", "/pyportal_startup.bmp"):
try:
os.stat(bootscreen)
board.DISPLAY.show(self.splash)
for i in range(100, -1, -1): # dim down
self.set_backlight(i / 100)
time.sleep(0.005)
self.set_background(bootscreen)
try:
board.DISPLAY.refresh(target_frames_per_second=60)
except AttributeError:
board.DISPLAY.wait_for_frame()
for i in range(100): # dim up
self.set_backlight(i / 100)
time.sleep(0.005)
time.sleep(2)
except OSError:
pass # they removed it, skip!
self._speaker_enable = DigitalInOut(board.SPEAKER_ENABLE)
self._speaker_enable.switch_to_output(False)
if hasattr(board, "AUDIO_OUT"):
self.audio = audioio.AudioOut(board.AUDIO_OUT)
elif hasattr(board, "SPEAKER"):
self.audio = audioio.AudioOut(board.SPEAKER)
else:
raise AttributeError("Board does not have a builtin speaker!")
try:
self.play_file("pyportal_startup.wav")
except OSError:
pass # they deleted the file, no biggie!
if esp: # If there was a passed ESP Object
if self._debug:
print("Passed ESP32 to PyPortal")
self._esp = esp
if external_spi: # If SPI Object Passed
spi = external_spi
else: # Else: Make ESP32 connection
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
else:
if self._debug:
print("Init ESP32")
esp32_ready = DigitalInOut(board.ESP_BUSY)
esp32_gpio0 = DigitalInOut(board.ESP_GPIO0)
esp32_reset = DigitalInOut(board.ESP_RESET)
esp32_cs = DigitalInOut(board.ESP_CS)
spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
self._esp = adafruit_esp32spi.ESP_SPIcontrol(
spi, esp32_cs, esp32_ready, esp32_reset, esp32_gpio0)
# self._esp._debug = 1
for _ in range(3): # retries
try:
print("ESP firmware:", self._esp.firmware_version)
break
except RuntimeError:
print("Retrying ESP32 connection")
time.sleep(1)
self._esp.reset()
else:
raise RuntimeError("Was not able to find ESP32")
requests.set_socket(socket, self._esp)
if url and not self._uselocal:
self._connect_esp()
if self._debug:
print("My IP address is",
self._esp.pretty_ip(self._esp.ip_address))
# set the default background
self.set_background(self._default_bg)
board.DISPLAY.show(self.splash)
if self._debug:
print("Init SD Card")
sd_cs = board.SD_CS
if not NATIVE_SD:
sd_cs = DigitalInOut(sd_cs)
self._sdcard = None
try:
self._sdcard = sdcardio.SDCard(spi, sd_cs)
vfs = storage.VfsFat(self._sdcard)
storage.mount(vfs, "/sd")
except OSError as error:
print("No SD card found:", error)
self._qr_group = None
# Tracks whether we've hidden the background when we showed the QR code.
self._qr_only = False
if self._debug:
print("Init caption")
self._caption = None
if caption_font:
self._caption_font = bitmap_font.load_font(caption_font)
self.set_caption(caption_text, caption_position, caption_color)
if text_font:
if text_position is not None and isinstance(
text_position[0], (list, tuple)):
num = len(text_position)
if not text_wrap:
text_wrap = [0] * num
if not text_maxlen:
text_maxlen = [0] * num
if not text_transform:
text_transform = [None] * num
if not isinstance(text_scale, (list, tuple)):
text_scale = [text_scale] * num
else:
num = 1
text_position = (text_position, )
text_color = (text_color, )
text_wrap = (text_wrap, )
text_maxlen = (text_maxlen, )
text_transform = (text_transform, )
text_scale = (text_scale, )
self._text = [None] * num
self._text_color = [None] * num
self._text_position = [None] * num
self._text_wrap = [None] * num
self._text_maxlen = [None] * num
self._text_transform = [None] * num
self._text_scale = [None] * num
if text_font is not terminalio.FONT:
self._text_font = bitmap_font.load_font(text_font)
else:
self._text_font = terminalio.FONT
if self._debug:
print("Loading font glyphs")
# self._text_font.load_glyphs(b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
# b'0123456789:/-_,. ')
gc.collect()
for i in range(num):
if self._debug:
print("Init text area", i)
self._text[i] = None
self._text_color[i] = text_color[i]
self._text_position[i] = text_position[i]
self._text_wrap[i] = text_wrap[i]
self._text_maxlen[i] = text_maxlen[i]
self._text_transform[i] = text_transform[i]
if not isinstance(text_scale[i],
(int, float)) or text_scale[i] < 1:
text_scale[i] = 1
self._text_scale[i] = text_scale[i]
else:
self._text_font = None
self._text = None
# Add any JSON translators
self._json_transform = []
if json_transform:
if callable(json_transform):
self._json_transform.append(json_transform)
else:
self._json_transform.extend(filter(callable, json_transform))
self._image_json_path = image_json_path
self._image_url_path = image_url_path
self._image_resize = image_resize
self._image_position = image_position
self._image_dim_json_path = image_dim_json_path
if image_json_path or image_url_path:
if self._debug:
print("Init image path")
if not self._image_position:
self._image_position = (0, 0) # default to top corner
if not self._image_resize:
self._image_resize = (
board.DISPLAY.width,
board.DISPLAY.height,
) # default to full screen
if hasattr(board, "TOUCH_XL"):
if self._debug:
print("Init touchscreen")
# pylint: disable=no-member
self.touchscreen = adafruit_touchscreen.Touchscreen(
board.TOUCH_XL,
board.TOUCH_XR,
board.TOUCH_YD,
board.TOUCH_YU,
calibration=((5200, 59000), (5800, 57000)),
size=(board.DISPLAY.width, board.DISPLAY.height),
)
# pylint: enable=no-member
self.set_backlight(1.0) # turn on backlight
elif hasattr(board, "BUTTON_CLOCK"):
if self._debug:
print("Init cursor")
self.mouse_cursor = Cursor(board.DISPLAY,
display_group=self.splash,
cursor_speed=8)
self.mouse_cursor.hide()
self.cursor = CursorManager(self.mouse_cursor)
else:
raise AttributeError(
"PyPortal module requires either a touchscreen or gamepad.")
gc.collect()
import terminalio
from adafruit_display_text import label
from adafruit_bitmap_font import bitmap_font
print(os.uname().machine)
display = board.DISPLAY
FONT = bitmap_font.load_font("fonts/helvB10.bdf")
TEXTHEIGHT = 10
#print('Display width:',display.width)
# FONT = terminalio.FONT
# Connect to the SDcard and mount the filesystem.
spi = board.SPI()
cs = board.SD_CS
sdcard = sdcardio.SDCard(spi, cs)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")
root_folder = "/sd/syx"
# MIDI init
# NB: We are just sending "raw" sysex MIDI data so I'm avoiding the MIDI library...
uart = busio.UART(board.TX, board.RX, baudrate=31250, timeout=0.001)
def send_message(msg):
uart.write(bytearray(msg))
# Button Constants
BUTTON_A = 1
def __init__(self):
"""
Big init routine as the whole board is brought up.
"""
self.BOOTTIME = const(time.time())
self.data_cache = {}
self.filenumbers = {}
self.vlowbatt = 6.0
self.send_buff = memoryview(SEND_BUFF)
self.debug = True
self.micro = microcontroller
self.hardware = {
'IMU': False,
'Radio1': False,
'Radio2': False,
'SDcard': False,
'GPS': False,
'WDT': False,
'USB': False,
'PWR': False
}
# Define burn wires:
self._relayA = digitalio.DigitalInOut(board.RELAY_A)
self._relayA.switch_to_output(
drive_mode=digitalio.DriveMode.OPEN_DRAIN)
self._resetReg = digitalio.DigitalInOut(board.VBUS_RST)
self._resetReg.switch_to_output(
drive_mode=digitalio.DriveMode.OPEN_DRAIN)
# Define battery voltage
self._vbatt = AnalogIn(board.BATTERY)
# Define MPPT charge current measurement
self._ichrg = AnalogIn(board.L1PROG)
self._chrg = digitalio.DigitalInOut(board.CHRG)
self._chrg.switch_to_input()
# Define SPI,I2C,UART
self.i2c1 = busio.I2C(board.SCL, board.SDA)
self.spi = board.SPI()
self.uart = busio.UART(board.TX, board.RX)
# Define GPS
self.en_gps = digitalio.DigitalInOut(board.EN_GPS)
self.en_gps.switch_to_output()
# Define filesystem stuff
self.logfile = "/log.txt"
# Define radio
_rf_cs1 = digitalio.DigitalInOut(board.RF1_CS)
_rf_rst1 = digitalio.DigitalInOut(board.RF1_RST)
self.enable_rf = digitalio.DigitalInOut(board.EN_RF)
self.radio1_DIO0 = digitalio.DigitalInOut(board.RF1_IO0)
# self.enable_rf.switch_to_output(value=False) # if U21
self.enable_rf.switch_to_output(value=True) # if U7
_rf_cs1.switch_to_output(value=True)
_rf_rst1.switch_to_output(value=True)
self.radio1_DIO0.switch_to_input()
# Initialize SD card (always init SD before anything else on spi bus)
try:
# Baud rate depends on the card, 4MHz should be safe
_sd = sdcardio.SDCard(self.spi, board.SD_CS, baudrate=4000000)
_vfs = VfsFat(_sd)
mount(_vfs, "/sd")
self.fs = _vfs
sys.path.append("/sd")
self.hardware['SDcard'] = True
self.logfile = "/sd/log.txt"
except Exception as e:
if self.debug: print('[ERROR][SD Card]', e)
# Initialize Neopixel
try:
self.neopixel = neopixel.NeoPixel(board.NEOPIXEL,
1,
brightness=0.2,
pixel_order=neopixel.GRB)
self.neopixel[0] = (0, 0, 0)
self.hardware['Neopixel'] = True
except Exception as e:
if self.debug: print('[WARNING][Neopixel]', e)
# Initialize USB charger
try:
self.usb = bq25883.BQ25883(self.i2c1)
self.usb.charging = False
self.usb.wdt = False
self.usb.led = False
self.usb.charging_current = 8 #400mA
self.usb_charging = False
self.hardware['USB'] = True
except Exception as e:
if self.debug: print('[ERROR][USB Charger]', e)
# Initialize Power Monitor
try:
self.pwr = adm1176.ADM1176(self.i2c1)
self.pwr.sense_resistor = 1
self.hardware['PWR'] = True
except Exception as e:
if self.debug: print('[ERROR][Power Monitor]', e)
# Initialize IMU
try:
self.IMU = bmx160.BMX160_I2C(self.i2c1)
self.hardware['IMU'] = True
except Exception as e:
if self.debug: print('[ERROR][IMU]', e)
# # Initialize GPS
# try:
# self.gps = GPS(self.uart,debug=False) # still powered off!
# self.gps.timeout_handler=self.timeout_handler
# self.hardware['GPS'] = True
# except Exception as e:
# if self.debug: print('[ERROR][GPS]',e)
# Initialize radio #1 - UHF
try:
self.radio1 = pycubed_rfm9x.RFM9x(self.spi,
_rf_cs1,
_rf_rst1,
433.0,
code_rate=8,
baudrate=1320000)
# Default LoRa Modulation Settings
# Frequency: 433 MHz, SF7, BW125kHz, CR4/8, Preamble=8, CRC=True
self.radio1.dio0 = self.radio1_DIO0
self.radio1.enable_crc = True
self.radio1.ack_delay = 0.2
self.radio1.sleep()
self.hardware['Radio1'] = True
except Exception as e:
if self.debug: print('[ERROR][RADIO 1]', e)
# set PyCubed power mode
self.power_mode = 'normal'
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT
import board
import storage
from adafruit_pyoa import PYOA_Graphics
try:
try:
import sdcardio
sdcard = sdcardio.SDCard(board.SPI, board.SD_CS)
except ImportError:
import adafruit_sdcard
import digitalio
sdcard = adafruit_sdcard.SDCard(
board.SPI(),
digitalio.DigitalInOut(board.SD_CS),
)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")
print("SD card found") # no biggie
except OSError:
print("No SD card found") # no biggie
gfx = PYOA_Graphics()
gfx.load_game("/cyoa")
current_card = 0 # start with first card