def mount(location='/sd'): print('Setting up SD card') spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, location)
def save(): spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") save_pixels("/sd/splot.bmp")
def mount_sd(): """Mount the SD card""" spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) sd_cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, sd_cs, baudrate=6000000) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd")
def __init__(self): """ Big init routine as the whole board is brought up. """ self.hardware = { 'SDcard': False, 'ESP32': False, 'Neopixel': False, } self.payload = None self.filename = '' # Define LEDs: self._led = digitalio.DigitalInOut(board.LED) self._led.switch_to_output() # Define battery voltage # self._vbatt = analogio.AnalogIn(board.BATTERY) # Define SPI,I2C,UART self._spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) self._uart = busio.UART(board.TX2, board.RX2) # Define sdcard self._sdcs = digitalio.DigitalInOut(board.xSDCS) self._sdcs.direction = digitalio.Direction.OUTPUT self._sdcs.value = True # Initialize sdcard try: import adafruit_sdcard self._sd = adafruit_sdcard.SDCard(self._spi, self._sdcs) self._vfs = storage.VfsFat(self._sd) storage.mount(self._vfs, "/sd") sys.path.append("/sd") self.hardware['SDcard'] = True except Exception as e: print('[WARNING]', e) # Define ESP32 self._esp_dtr = digitalio.DigitalInOut(board.DTR) self._esp_rts = digitalio.DigitalInOut(board.RTS) self._esp_cs = digitalio.DigitalInOut(board.TMS) #GPIO14 self._esp_rdy = digitalio.DigitalInOut(board.TCK) #GPIO13 self._esp_cs.direction = digitalio.Direction.OUTPUT self._esp_dtr.direction = digitalio.Direction.OUTPUT self._esp_rts.direction = digitalio.Direction.OUTPUT self._esp_cs.value = True self._esp_dtr.value = False self._esp_rts.value = False # 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: print('[WARNING]', e)
def save(): spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") print("Taking Screenshot...") save_pixels("/sd/screenshot.bmp") print("Screenshot taken")
def __init__(self, spi, i2c): cs = digitalio.DigitalInOut(board.D10) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, '/sd') # Location on the sd-card where the information is saved self.pressure_path = '/sd/pressure.txt' # The storage unit responsible for time self.rtc = adafruit_pcf8523.PCF8523(i2c)
def setup_sd(mountpoint='/sd'): import adafruit_sdcard import storage try: spi = busio.SPI(board.SCK, board.MOSI, board.MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, mountpoint) print('Found SD card.') blink_led(gled, .075, 5) return sdcard, vfs except Exception as e: print('Failed to set up and mount SD card! Exception info:', str(e), '\nPrinting to console instead.') blink_led(rled, .075, 5) return None, None
import neopixel import simpleio import adafruit_sdcard import microcontroller import storage import os # Set up Objects--------------------------------------------------------------: led = digitalio.DigitalInOut(board.D13) led.direction = digitalio.Direction.OUTPUT pixels = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=True) uart = busio.UART(board.TX, board.RX, baudrate=9600) # SD Card Objects spi = busio.SPI(board.SD_SCK, board.SD_MOSI, board.SD_MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") # Colors RED = (50, 0, 0) YELLOW = (50, 30, 0) GREEN = (0, 50, 0) CYAN = (0, 50, 50) BLUE = (0, 0, 50) PURPLE = (40, 0, 50) WHITE = (50, 50, 50) BYELLOW = (100, 60, 0) # Movement routines:--------------------------------------------------------:
def __init__(self): """ Big init routine as the whole board is brought up. """ self.hardware = { 'IMU': False, 'Radio1': False, 'Radio2': False, 'SDcard': False, 'GPS': False, 'MRAM': False, 'WDT': False, 'USB': False, 'PWR': False, } # Define burn wires: self._relayA = digitalio.DigitalInOut(board.RELAY_A) self._relayA.switch_to_output() self._deployA = False # Define battery voltage self._vbatt = analogio.AnalogIn(board.BATTERY) # Define MPPT charge current measurement self._ichrg = analogio.AnalogIn(board.L1PROG) # Define SPI,I2C,UART self.i2c = busio.I2C(board.SCL,board.SDA) self.spi = busio.SPI(board.SCK,MOSI=board.MOSI,MISO=board.MISO) #self.uart = busio.UART(board.TX,board.RX, baudrate=9600, timeout=10) # Define GPS self.en_gps = digitalio.DigitalInOut(board.EN_GPS) self.en_gps.switch_to_output() # Define sdcard self._sdcs = digitalio.DigitalInOut(board.xSDCS) self._sdcs.switch_to_output(value=True) # Define radio self._rf_cs1 = digitalio.DigitalInOut(board.RF1_CS) self._rf_rst1 = digitalio.DigitalInOut(board.RF1_RST) self._rf_cs1.switch_to_output(value=True) self._rf_rst1.switch_to_output(value=True) self._rf_cs2 = digitalio.DigitalInOut(board.RF2_CS) self._rf_rst2 = digitalio.DigitalInOut(board.RF2_RST) self._rf_cs2.switch_to_output(value=True) self._rf_rst2.switch_to_output(value=True) # Define MRAM (manual-mode) # self._mram_cs = digitalio.DigitalInOut(microcontroller.pin.PB11) # self._mram_cs.switch_to_output(value=True) # 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: print('[WARNING][Neopixel]',e) # Initialize USB charger try: self.usb = bq25883.BQ25883(self.i2c) self.usb.charging = False self.usb.wdt = False self.usb.led=False self.hardware['USB'] = True except Exception as e: print('[ERROR][USB Charger]',e) # Initialize sdcard try: self._sd = adafruit_sdcard.SDCard(self.spi, self._sdcs) self._vfs = storage.VfsFat(self._sd) storage.mount(self._vfs, "/sd") sys.path.append("/sd") self.hardware['SDcard'] = True except Exception as e: print('[ERROR][SD Card]',e) # Initialize Power Monitor try: self.pwr = adm1176.ADM1176(self.i2c) self.pwr.sense_resistor = 1 self.hardware['PWR'] = True except Exception as e: print('[ERROR][Power Monitor]',e) # Initialize IMU try: self.IMU = bmx160.BMX160_I2C(self.i2c) self.hardware['IMU'] = True except Exception as e: print('[ERROR]',e) # Initialize radio(s) try: self.radio1 = adafruit_rfm9x.RFM9x(self.spi, self._rf_cs1, self._rf_rst1, 433.0) self.hardware['Radio1'] = True except Exception as e: print('[ERROR][RADIO 1]',e) try: self.radio2 = adafruit_rfm9x.RFM9x(self.spi, self._rf_cs2, self._rf_rst2, 433.0) self.hardware['Radio2'] = True except Exception as e: print('[ERROR][RADIO 2]',e)
def __init__(self, measurements, headers=None, filename=None, use_SD=True, spi=None, SD_CS=None): """__init__ :param int measurements: The number of different measurements that will be taken per reading. :param list headers: A list of strings of headers for the different measurements. List length must be equal to `measurements`. If None, headers will not be used. :param string filename: Filename of the log. Defaults to `log.txt` if none is supplied. :param bool use_SD: Whether to write to the SD card or the local filesystem. Defaults to SD. :param spi: A supplied spi bus. Creates it's own if none is supplied. Only used if `use_SD` is `True`. :param SD_CS: The SD card's chip select pin. if none is supplied, it will try the inbuilt `board.SD_CS` """ self.reading_no = 0 self.num_measurements = 0 if headers: assert ( measurements == len(headers) ), "The number of headers must equal the number of different measurements" self.num_measurements = measurements self.headers = ["Reading no"] + headers if filename: self.filename = filename else: self.filename = "log.txt" import storage if use_SD: import adafruit_sdcard, digitalio if spi: self.spi = spi else: import board self.spi = board.SPI() if SD_CS: self.SD_CS = SD_CS else: import board try: self.SD_CS = board.SD_CS except AttributeError: raise AttributeError( "Your board does not have a built in SD card, please supply the chip select pin for the SD card of the addon board" ) self.sdcard = adafruit_sdcard.SDCard( self.spi, digitalio.DigitalInOut(self.SD_CS)) self.vfs = storage.VfsFat(self.sdcard) storage.mount(self.vfs, "/sd") self.filepath = "/sd/" + self.filename else: #print("WARNING!! This will not work unless you have set up boot.py to mount the filesystem as rw, see https://learn.adafruit.com/circuitpython-essentials/circuitpython-storage") try: storage.remount("/") self.filepath = "/" + self.filename except RuntimeError as e: raise RuntimeError( str(e) + "\nLocal filesystem logging will only work when CIRCUITPY is not mounted by a computer" ) # will only work once running a release after https://github.com/adafruit/circuitpython/commit/8e8eb07 try: with open(self.filepath, "r") as f: # check if continuing last log or starting a new one firstline = f.readline().split(",") for index, value in enumerate(firstline): firstline[index] = value.strip() if firstline == self.headers or firstline[0] == "0": for line in f: if line != "\n": lastline = line lastline = lastline.split(",") self.reading_no = int(lastline[0]) + 1 self.num_measurements = len(lastline) - 1 newfileneeded = False else: from os import rename rename(self.filepath, self.filepath + ".old") newfileneeded = True except OSError as e: if e.args[0] == 2: # no such file newfileneeded = True elif e.args[0] == 30: # read only fs raise RuntimeError( "The filesystem has been mounted as read only") if newfileneeded: with open(self.filepath, "w") as f: if headers: f.write(', '.join(str(x) for x in self.headers)) f.write("\n")
from adafruit_button import Button import adafruit_touchscreen import busio import digitalio import storage import adafruit_sdcard import supervisor import json # See if a card is present card_detect_pin = digitalio.DigitalInOut(board.SD_CARD_DETECT) card_detect_pin.direction = digitalio.Direction.INPUT card_detect_pin.pull = digitalio.Pull.UP print('SD card present: %s' % card_detect_pin.value) # Try to connect to the SD card sdcard = adafruit_sdcard.SDCard(busio.SPI(board.SCK, board.MOSI, board.MISO), digitalio.DigitalInOut(board.SD_CS)) # Mount the card to a directory virtual_file_system = storage.VfsFat(sdcard) storage.mount(virtual_file_system, '/sd') a = {"a": 1, "b": 2} f = open('/sd/test.yaml', 'w') json.dump(a, f) f.close() def save_settings(values): with open('/sd/DAC.txt', 'w') as output_file: for i in range(8): output_file.write('%f\n' % values[i])
def __init__(self, *, url=None, headers=None, json_path=None, regexp_path=None, default_bg=0x000000, status_neopixel=None, text_font=None, text_position=None, text_color=0x808080, text_wrap=False, text_maxlen=0, text_transform=None, json_transform=None, image_json_path=None, image_resize=None, image_position=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 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) 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 = DigitalInOut(board.SD_CS) self._sdcard = None try: self._sdcard = adafruit_sdcard.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 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 else: num = 1 text_position = (text_position, ) text_color = (text_color, ) text_wrap = (text_wrap, ) text_maxlen = (text_maxlen, ) text_transform = (text_transform, ) 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_font = bitmap_font.load_font(text_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] 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 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 = (320, 240) # 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=(320, 240)) # 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()
def __init__(self, *, url=None, json_path=None, regexp_path=None, default_bg=0x000000, status_neopixel=None, text_font=None, text_position=None, text_color=0x808080, text_wrap=False, text_maxlen=0, text_transform=None, image_json_path=None, image_resize=None, image_position=None, caption_text=None, caption_font=None, caption_position=None, caption_color=0x808080, success_callback=None, debug=False): self._debug = debug try: self._backlight = pulseio.PWMOut(board.TFT_BACKLIGHT) # pylint: disable=no-member except ValueError: self._backlight = None self.set_backlight(1.0) # turn on backlight self._url = url 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) 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) self.audio = audioio.AudioOut(board.AUDIO_OUT) try: self.play_file("pyportal_startup.wav") except OSError: pass # they deleted the file, no biggie! # Make ESP32 connection 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_interface(self._esp) if url and not self._uselocal: self._connect_esp() # set the default background self.set_background(self._default_bg) board.DISPLAY.show(self.splash) if self._debug: print("Init SD Card") sd_cs = DigitalInOut(board.SD_CS) self._sdcard = None try: self._sdcard = adafruit_sdcard.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 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 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 else: num = 1 text_position = (text_position, ) text_color = (text_color, ) text_wrap = (text_wrap, ) text_maxlen = (text_maxlen, ) text_transform = (text_transform, ) 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_font = bitmap_font.load_font(text_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] else: self._text_font = None self._text = None self._image_json_path = image_json_path self._image_resize = image_resize self._image_position = image_position if image_json_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 = (320, 240) # default to full screen 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=(320, 240)) # pylint: enable=no-member self.set_backlight(1.0) # turn on backlight gc.collect()
def __init__(self): """ Big init routine as the whole board is brought up. """ self.hardware = { 'IMU': False, 'radio': False, 'SDcard': False, 'GPS': False, 'MRAM': False, 'WDT': False, } # Define LEDs: self._led = digitalio.DigitalInOut(board.LED) self._led.switch_to_output() # Define burn wires: self._relayA = digitalio.DigitalInOut(board.RELAY_A) self._relayB = digitalio.DigitalInOut(board.RELAY_B) self._relayA.switch_to_output() self._relayB.switch_to_output() self._deployA = False self._deployB = False # Define battery voltage self._vbatt = analogio.AnalogIn(board.BATTERY) # Define battery charge current self._ichrg = analogio.AnalogIn(board.L1PROG) # Define battery current draw self._idraw = analogio.AnalogIn(board.IBATT) # Define SPI,I2C,UART self._i2c = busio.I2C(board.SCL, board.SDA) self._spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) self._uart = busio.UART(board.TX, board.RX) # Define MRAM (manual-mode) self._mram_cs = digitalio.DigitalInOut(microcontroller.pin.PB11) self._mram_cs.switch_to_output(value=True) # Define sdcard self._sdcs = digitalio.DigitalInOut(board.xSDCS) self._sdcs.switch_to_output(value=True) # Define radio self._rf_cs = digitalio.DigitalInOut(board.RF_CS) self._rf_rst = digitalio.DigitalInOut(board.RF_RST) self._rf_cs.switch_to_output(value=True) self._rf_rst.switch_to_output(value=True) # Define GPS self._en_gps = digitalio.DigitalInOut(board.EN_GPS) self._en_gps.switch_to_output() # Initialize sdcard try: self._sd = adafruit_sdcard.SDCard(self._spi, self._sdcs) self._vfs = storage.VfsFat(self._sd) storage.mount(self._vfs, "/sd") sys.path.append("/sd") self.hardware['SDcard'] = True except Exception as e: print('[ERROR]', e) # Initialize IMU try: self.IMU = adafruit_lsm9ds1.LSM9DS1_I2C(self._i2c) self.hardware['IMU'] = True except Exception as e: print('[ERROR]', e) # Initialize radio try: self.radio = adafruit_rfm9x.RFM9x(self._spi, self._rf_cs, self._rf_rst, 433.0) self.hardware['Radio'] = True except Exception as e: print('[ERROR]', e)
def run_test(pins, mosi_pin=MOSI_PIN_NAME, miso_pin=MISO_PIN_NAME, sck_pin=SCK_PIN_NAME, cs_pin=CS_PIN_NAME): """ Performs random writes and reads to file on attached SD card. :param list[str] pins: list of pins to run the test on :param str mosi_pin: pin name of SPI MOSI :param str miso_pin: pin name of SPI MISO :param str sck_pin: pin name of SPI SCK :param str cs_pin: pin name of SPI CS :param str filename: name of file to use as test on SD card :return: tuple(str, list[str]): test result followed by list of pins tested """ # Write characters to file on SD card and verify they were written if list(set(pins).intersection(set([mosi_pin, miso_pin, sck_pin]))): # Tell user to connect SD card print("Insert SD card into holder and connect SPI lines to holder.") print("Connect " + cs_pin + " to the CS (DAT3) pin on the SD " + "card holder.") print("WARNING: " + FILENAME + " will be created or overwritten.") print("Press enter to continue.") input() # Configure CS pin csel = digitalio.DigitalInOut(getattr(board, cs_pin)) csel.direction = digitalio.Direction.OUTPUT csel.value = True # Set up SPI spi = busio.SPI(getattr(board, sck_pin), MOSI=getattr(board, mosi_pin), MISO=getattr(board, miso_pin)) # Try to connect to the card and mount the filesystem try: sdcard = adafruit_sdcard.SDCard(spi, csel) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") except OSError: print("Could not mount SD card") return FAIL, [mosi_pin, miso_pin, sck_pin] # Generate test string test_str = "" for _ in range(NUM_UART_BYTES): test_str += chr(random.randint(ASCII_MIN, ASCII_MAX)) # Write test string to a text file on the card try: with open("/sd/" + FILENAME, "w") as file: print("Writing:\t" + test_str) file.write(test_str) except OSError: print("Could not write to SD card") return FAIL, [mosi_pin, miso_pin, sck_pin] # Read from test file on the card read_str = "" try: with open("/sd/" + FILENAME, "r") as file: lines = file.readlines() for line in lines: read_str += line print("Read:\t\t" + read_str) except OSError: print("Could not write to SD card") return FAIL, [mosi_pin, miso_pin, sck_pin] # Release SPI spi.deinit() # Compare strings if read_str == test_str: return PASS, [mosi_pin, miso_pin, sck_pin] return FAIL, [mosi_pin, miso_pin, sck_pin] # Else (no pins found) print("No SD card pins found") return NA, []
def takeimage(): # Configuration: SD_CS_PIN = board.D10 # CS for SD card (SD_CS is for Feather Adalogger) IMAGE_FILE = '/sd/image.jpg' # Full path to file name to save captured image. # Will overwrite! # Setup SPI bus (hardware SPI). spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) # Setup SD card and mount it in the filesystem. sd_cs = digitalio.DigitalInOut(SD_CS_PIN) sdcard = adafruit_sdcard.SDCard(spi, sd_cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, '/sd') # Create a serial connection for the VC0706 connection, speed is auto-detected. uart = busio.UART(board.TX, board.RX, timeout=250) # Setup VC0706 camera vc0706 = adafruit_vc0706.VC0706(uart) # Print the version string from the camera. print('VC0706 version:') print(vc0706.version) # Set the baud rate to 115200 for fastest transfer (its the max speed) vc0706.baudrate = 115200 # Set the image size. vc0706.image_size = adafruit_vc0706.IMAGE_SIZE_640x480 # Or set IMAGE_SIZE_320x240 or # IMAGE_SIZE_160x120 # Note you can also read the property and compare against those values to # see the current size: # size = vc0706.image_size # if size == adafruit_vc0706.IMAGE_SIZE_640x480: # print('Using 640x480 size image.') # elif size == adafruit_vc0706.IMAGE_SIZE_320x240: # print('Using 320x240 size image.') # elif size == adafruit_vc0706.IMAGE_SIZE_160x120: # print('Using 160x120 size image.') # Take a picture. print('Taking a picture in 3 seconds...') time.sleep(3) print('SNAP!') if not vc0706.take_picture(): raise RuntimeError('Failed to take picture!') # Print size of picture in bytes. frame_length = vc0706.frame_length print('Picture size (bytes): {}'.format(frame_length)) # Open a file for writing (overwriting it if necessary). # This will write 50 bytes at a time using a small buffer. # You MUST keep the buffer size under 100! print('Writing image: {}'.format(IMAGE_FILE), end='') with open(IMAGE_FILE, 'wb') as outfile: wcount = 0 while frame_length > 0: # Compute how much data is left to read as the lesser of remaining bytes # or the copy buffer size (32 bytes at a time). Buffer size MUST be # a multiple of 4 and under 100. Stick with 32! to_read = min(frame_length, 32) copy_buffer = bytearray(to_read) # Read picture data into the copy buffer. if vc0706.read_picture_into(copy_buffer) == 0: raise RuntimeError('Failed to read picture frame data!') # Write the data to SD card file and decrement remaining bytes. outfile.write(copy_buffer) frame_length -= 32 # Print a dot every 2k bytes to show progress. wcount += 1 if wcount >= 64: print('.', end='') wcount = 0 print("") print('Finished!')
spi_bus = busio.SPI(board.SCK, board.MOSI, board.MISO) i2c_bus = busio.I2C(board.SCL, board.SDA) # Initialize the onboard clock rtc = adafruit_pcf8523.PCF8523(i2c_bus) # Set the onboard clock if needed # The format is (year, month, day, hour, minute, second, dayOfWeek, dayInYear, isDST) # See https://docs.python.org/3/library/time.html#time.struct_time for more details # Uncomment the next two lines to set the onboard clock: # rtc.datetime = time.struct_time( # (2020, 6, 24, 14, 40, 0, 0, -1, -1)) # SD SD_CS = board.D10 cs = digitalio.DigitalInOut(SD_CS) sdcard = adafruit_sdcard.SDCard(spi_bus, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") # Create metadata file meta = {} meta["pilot"] = "Fill this in." t = rtc.datetime meta["date-start"] = "%s-%s-%s" % (t.tm_mon, t.tm_mday, t.tm_year) meta["time-start"] = "%s:%s:%s" % (t.tm_hour, t.tm_min, t.tm_sec) meta["location"] = "Fill this in." meta["TimeZone"] = "PST" with open('/sd/meta.json', 'w') as outfile: json.dump(meta, outfile) # Set the Neopixel to green now that we found a valid SD card
import board import adafruit_sdcard import sys import digitalio import busio import storage # Initialize SD card print("Setting up communication with SDCard...") sd_spi = busio.SPI(board.SD_SCK, board.SD_MOSI, board.SD_MISO) sd_cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(sd_spi, sd_cs) print("Mounting...") vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") sys.path.append("/sd")
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries # SPDX-License-Identifier: MIT import board import digitalio import adafruit_sdcard import storage from adafruit_pyoa import PYOA_Graphics try: 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 while True: print("Current card:", current_card) current_card = gfx.display_card(current_card)
def dir_command(): sdcard = adafruit_sdcard.SDCard(spi, digitalio.DigitalInOut(sd_cs)) vfs = storage.VfsFat(sdcard) storage.mount(vfs, '/sd') return "{}\n\r".format(os.listdir('/sd/'))
spi = board.SPI() i2c = board.I2C() # setup display displayio.release_displays() tft_cs = board.D9 tft_dc = board.D10 display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs) display = adafruit_ili9341.ILI9341(display_bus, width=320, height=240) # setup keyboard kbd = BBQ10Keyboard(i2c) # setup microSD sd_cs = board.D5 sdcard = adafruit_sdcard.SDCard(spi, digitalio.DigitalInOut(sd_cs)) vfs = storage.VfsFat(sdcard) storage.mount(vfs, '/sd') # setup NeoPixels pix0 = neopixel.NeoPixel(board.NEOPIXEL, 1) pix0[0] = 0x000080 pix1 = neopixel.NeoPixel(board.D11, 1) # while True: k = kbd.keys for i in k: if i[0] == 1: print(i[1], end='')
def __init__(self): self.spi = busio.SPI(SCK, MOSI, MISO) self.cs = digitalio.DigitalInOut(CS) self.sdcard = adafruit_sdcard.SDCard(self.spi, self.cs) self.vfs = storage.VfsFat(self.sdcard) storage.mount(self.vfs, "/sd")
lora_spi = busio.SPI(board.D13, MOSI=board.D11, MISO=board.D12) cs = digitalio.DigitalInOut(board.D5) reset = digitalio.DigitalInOut(board.D7) rfm9x = adafruit_rfm9x.RFM9x(lora_spi, cs, reset, 915.0) # SD card #SD_CS = DigitalInOut(board.A5) # Connect to the card and mount the filesystem. #spi = busio.SPI(board.SCK, board.MOSI, board.MISO) sd_cs = digitalio.DigitalInOut(board.A5) sdcard = adafruit_sdcard.SDCard(lora_spi, sd_cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd") # bme280 i2c = busio.I2C(board.SCL, board.SDA) bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c) # change this to match the location's pressure (hPa) at sea level bme280.sea_level_pressure = 1013.25 # display #display = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c, addr=0x3c, reset=reset_pin) display = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c, addr=0x3c)
def mount(): spi = busio.SPI(board.SCK, board.MOSI, board.MISO) cs = digitalio.DigitalInOut(board.SD_CS) sdcard = adafruit_sdcard.SDCard(spi, cs) vfs = storage.VfsFat(sdcard) storage.mount(vfs, "/sd")