Raspberry Pico Development board

Date: 12/2022

Revision: 1

Raspberry Pico Development Board

Introduction

The Raspberry Pico is a powerful and inexpensive microcontroller that can be used for a variety of projects. However, the Raspberry Pi Foundation prioritized factors of size, efficiency, and cost when creating the board. This leaves certain drawbacks of the microcontroller that are well documented in the Pico datasheet 15. In this project, I aim to solve a few minor inconveniences of the Pico’s design and create a development board better suited to approaching projects. Fixes include a reset button, an off switch for the onboard SMPS, LDO voltage regulators, and better ADC performance. Additionally, Parallel 16x2 LCD display, two 10-bit DAC channels, and SD card R/W capability are added to allow the development board to act as a drop in test bench for relaying or saving information.

Methods

See also

This device focuses on ADCs, DACs, and displays to streamline development of a project. Concepts and components from the pages below are employed. Topics that required greater detail for clarification are revisited.

• Raspberry Pico Microcontroller

• Data Conversion: ADC and DAC Theory

• Communication Protocols

• LTC1661 DAC

• 16x2 LCD Display

ADC Configuration

Since the ADC in on the Raspberry Pico, initial setup of the ADC can easily be achieved using the ADC section of the Pico Software Development Kit (SDK) 14. This provides the engineer with a simple and straightforward introduction on taking ADC readings. However, the 12-bit ADC onboard the Pico is not great by any means. This is due to the switching power regulator on the Pico. As a result of switching signal noise, the onboard voltage reference for the ADC is setup in poor conditions. The ADC has a 30mV offset and its signal is quite noisy 13. The datasheet gives suggestions on improvement of the ADC readings. An External reference voltage may be used, the R7 resistor can be removed, or issues can be mitigated in averaging and offset code. I chose a different route entirely, by adding bypass capacitors to the reference voltage and ADC input pins for filtering and smoothing.

Figure 18: Pico ADC reference circuit 13.

The Approach taken in this circuit was to provide an external power source and bypass the SMPS entirely. By incorporating a series of LDO’s we are able to create 5V and 3.3V rails with minimal noise. Driving the Pico via a 3.3V LDO feeds the ADC reference through a lowpass filter onboard. This creates a significant improvement from ADC SMPS measurements. However, since the entire Pico is supplied through the LDO 3.3V rail, voltage spikes and drops may occur from computations occurring on the device. This could be further mitigated by exclusively feeding the Pico’s ADC reference with a 3.3V LDO and removing the R7 resistor on the device. This would disconnect the internal 3.3V rail from the ADC reference entirely.

Power Regulation and Filtering

To supply power to the system, I chose to use the LDL1117 5V and 3.3V low-dropout regulators. This allows for a 9-12V DC source to supply the devices without much overhead. This provided a smooth 5V and 3.3V source for most components, with local decoupling capacitors where needed.

In addition to the 5V source, I powered the Raspberry Pico via the VSYS node to activate the device and use the 3.3V Switching Mode Power Supply (SMPS). This was done using a Schottky diode from 5V to VSYS to avoid backflow when the Pico is plugged in via USB 13. The Pico power-chain is good because the SMPS is efficient, but noise on the output causes problems with other systems like the ADC 13, 14. As a result, I byapassed the SMPS entirely by incorporating a shutoff switch for the SMPS.

Figure 18: Pico Power-chain and the implemented method of external supply [8]_.

SD Card Reader

An SD card reader has been added via SPI 16. This permits the user to incorporate data collection over time via sensors and ADC readings. These data readings can be written to text or csv files on a SD card for post test analysis.

Inputs and Outputs

A physical reset button was added to the development board to interrupt the RUN pin on the Pico. When this pin is connected to ground, the device will shut off. To insure proper reset, hold the reset button for 3 seconds. This will guarantee that the Pico has been discharged. The Pico has a full array of female headers for easy pinout access and another for seating the pico onboard. Pinout names have been added to the silkscreen simplify development.

Schematic and PCB Design

Figure 22: Devboard schematic page 1 of 2.

Figure 23: Devboard schematic page 2 of 2.

Figure 24: Top side of Devboard PCB layout.

Figure 24: Bottom side of Devboard PCB layout.

Bill Of Materials

Results

The schematic of the circuit and PCB turned out well, with minimal errors. The assembled PCB was easy to debug because of its plentiful headers employed in the diagram. Also, using female headers for the ultrasonic sensors, LCD, DIP packages, and potentiometers aided debug and ensured that any errors in design could be more easily fixed if the PCB was routed wrong. Thankfully, there were no design breaking errors in this circuit, and most components worked immediately after installation.

Figure 42: Raspberry Pico Development Board

Power

The power regulation and filtering produced a 5V and 3.3V source with minimal noise, observed with as little as 10mV ripple on both sources.

Figure 27: Power regulation system on the PCB

Figure 28: 5V and 3.3V source observed on the oscilloscope.

Figure 29: 5V and 3.3V source observed on the oscilloscope, both from a 20mV div.

Appendix

LCD.py

# -----------------------------------------
#                 NOTES 
# -----------------------------------------
"""
Dieter Steinhauser
5/2023
Parallel LCD functions, Configured for 4-bit communication.
"""

# -----------------------------------------
#               IMPORTS
# -----------------------------------------

from machine import Pin
import utime

# -----------------------------------------
#          CONSTANTS AND VARIABLES
# -----------------------------------------

# CONSTANTS
# ----------------------

LCD_CMD = 0
LCD_DATA = 1

# ----------------------
# GPIO Wiring: Legacy Structure
# ----------------------

# EN = Pin(0, Pin.OUT) # Enable Pin
# RS = Pin(1, Pin.OUT) # Register Select

# PINS = [2, 3, 4, 5]  
# Pin numbers for the upper nibble, does the below assignment in configure method.
# D4 = Pin(2, Pin.OUT)
# D5 = Pin(3, Pin.OUT)
# D6 = Pin(4, Pin.OUT)
# D7 = Pin(5, Pin.OUT)
 
# list that gets populated with pinout objects for data line.
# DATA_BUS = []

# -----------------------------------------
#                 METHODS
# -----------------------------------------

# def Configure():
#     """Creates the data bus object from the pin list"""

#     for index in range(4):
#        DATA_BUS.append(Pin(PINS[index], Pin.OUT))

# # -----------------------------------------

# def lcd_strobe():
#     """Flashes the enable line and provides wait period."""

#     EN.value(1)
#     utime.sleep_ms(1)

#     EN.value(0)
#     utime.sleep_ms(1)

# # -----------------------------------------
 
# def lcd_write(command, mode):
#     """Sends data to the LCD module. """

#     # determine if writing a command or data
#     data = command if mode == 0 else ord(command)

#     # need upper nibble for first loop. lower nibble can use data directly.
#     upper = data >> 4
    
#     # write the upper nibble
#     for index in range(4):
#         bit = upper & 1
#         DATA_BUS[index].value(bit)
#         upper = upper >> 1

#     # strobe the LCD, sending the nibble
#     RS.value(mode)
#     lcd_strobe()

#     # write the lower nibble
#     for index in range(4):
#         bit = data & 1
#         DATA_BUS[index].value(bit)
#         data = data >> 1

#     # Strobe the LCD, sending the nibble 
#     RS.value(mode)
#     lcd_strobe()
#     utime.sleep_ms(1)
#     RS.value(1)

# # -----------------------------------------

# def lcd_clear():
#     """Clear the LCD Screen."""

#     lcd_write(0x01, 0)
#     utime.sleep_ms(5)

# # -----------------------------------------

# def lcd_home():
#     """Return the Cursor to the starting position."""

#     lcd_write(0x02, 0)
#     utime.sleep_ms(5)

# # -----------------------------------------


# def lcd_cursor_blink():
#     """Have the cursor start blinking."""

#     lcd_write(0x0D, 0)
#     utime.sleep_ms(1)

# # -----------------------------------------

# def lcd_cursor_on():
#     """Have the cursor on, Good for debugging."""

#     lcd_write(0x0E, 0)
#     utime.sleep_ms(1)

# # -----------------------------------------

# def lcd_cursor_off():
#     """Turn the cursor off."""

#     lcd_write(0x0C, 0)
#     utime.sleep_ms(1)

# # -----------------------------------------

# def lcd_puts(string):
#     """Write a string on to the LCD."""

#     for element in string:
#        lcd_putch(element)

# # -----------------------------------------

# def lcd_putch(c):
#     """Write a character on to the LCD."""
#     lcd_write(c, 1)

# # -----------------------------------------

# def lcd_goto(column, row):
    
    
#     if row == 0:
#         address = 0

#     if row == 1:
#         address = 0x40

#     if row == 2:
#         address = 0x14

#     if row == 3:
#         address = 0x54

#     address = address + column
#     lcd_write(0x80 | address, 0)

# # -----------------------------------------

# def lcd_init():
    
#     # Configure the pins of the device.
#     Configure()
#     utime.sleep_ms(120)

#     # clear values on data bus.
#     for index in range(4):
#         DATA_BUS[index].value(0)
#     utime.sleep_ms(50)

#     # initialization sequence.
#     DATA_BUS[0].value(1)
#     DATA_BUS[1].value(1)
#     lcd_strobe()
#     utime.sleep_ms(10)

#     lcd_strobe()
#     utime.sleep_ms(10)

#     lcd_strobe()
#     utime.sleep_ms(10)

#     DATA_BUS[0].value(0)
#     lcd_strobe()
#     utime.sleep_ms(5)

#     lcd_write(0x28, 0)
#     utime.sleep_ms(1)

#     lcd_write(0x08, 0)
#     utime.sleep_ms(1)

#     lcd_write(0x01, 0)
#     utime.sleep_ms(10)

#     lcd_write(0x06, 0)
#     utime.sleep_ms(5)

#     lcd_write(0x0C, 0)
#     utime.sleep_ms(10)


# -----------------------------------------
#                 LCD Class:
# -----------------------------------------


class LCD:
    """The LCD class is meant to abstract the LCD driver further and streamline development."""

    CMD_MODE = 0
    DATA_MODE = 1

    def __init__(self, enable_pin: int, reg_select_pin: int, data_pins: list) -> None:
        """Object initialization"""

        self.enable_pin = Pin(enable_pin, Pin.OUT)
        self.reg_select_pin = Pin(reg_select_pin, Pin.OUT)
        self._data_pins = data_pins
        self.data_bus = []
        
        # Configure the pins of the device.
        self._configure()
        utime.sleep_ms(120)

    # -----------------------------------------    

    def _configure(self):
        """Creates the data bus object from the pin list. """

        # Configure the pins of the device.
        for element in self._data_pins:
            self.data_bus.append(Pin(element, Pin.OUT))

    # -----------------------------------------

    def init(self):
        """Initializes the LCD for communication."""

        # clear values on data bus.
        for index in range(4):
            self.data_bus[index].value(0)
        utime.sleep_ms(50)

        # initialization sequence.
        self.data_bus[0].value(1)
        self.data_bus[1].value(1)
        self.strobe()
        utime.sleep_ms(10)

        self.strobe()
        utime.sleep_ms(10)

        self.strobe()
        utime.sleep_ms(10)

        self.data_bus[0].value(0)
        self.strobe()
        utime.sleep_ms(5)

        self.write(0x28, 0)
        utime.sleep_ms(1)

        self.write(0x08, 0)
        utime.sleep_ms(1)

        self.write(0x01, 0)
        utime.sleep_ms(10)

        self.write(0x06, 0)
        utime.sleep_ms(5)

        self.write(0x0C, 0)
        utime.sleep_ms(10)

    # -----------------------------------------

    def strobe(self):
        """Flashes the enable line and provides wait period."""

        self.enable_pin.value(1)
        utime.sleep_ms(1)

        self.enable_pin.value(0)
        utime.sleep_ms(1)

    # -----------------------------------------
    
    def write(self, command, mode):
        """Sends data to the LCD module. """

        # determine if writing a command or data
        data = command if mode == 0 else ord(command)

        # need upper nibble for first loop. lower nibble can use data directly.
        upper = data >> 4
        
        # write the upper nibble
        for index in range(4):
            bit = upper & 1
            self.data_bus[index].value(bit)
            upper = upper >> 1

        # strobe the LCD, sending the nibble
        self.reg_select_pin.value(mode)
        self.strobe()

        # write the lower nibble
        for index in range(4):
            bit = data & 1
            self.data_bus[index].value(bit)
            data = data >> 1

        # Strobe the LCD, sending the nibble 
        self.reg_select_pin.value(mode)
        self.strobe()
        utime.sleep_ms(1)
        self.reg_select_pin.value(1)

    # -----------------------------------------

    def clear(self):
        """Clear the LCD Screen."""

        self.write(0x01, 0)
        utime.sleep_ms(5)

    # -----------------------------------------

    def home(self):
        """Return the Cursor to the starting position."""

        self.write(0x02, 0)
        utime.sleep_ms(5)

    # -----------------------------------------


    def blink(self):
        """Have the cursor start blinking."""

        self.write(0x0D, 0)
        utime.sleep_ms(1)

    # -----------------------------------------

    def cursor_on(self):
        """Have the cursor on, Good for debugging."""

        self.write(0x0E, 0)
        utime.sleep_ms(1)

    # -----------------------------------------

    def cursor_off(self):
        """Turn the cursor off."""

        self.write(0x0C, 0)
        utime.sleep_ms(1)

    # -----------------------------------------

    def print(self, string):
        """Write a string on to the LCD."""

        for element in string:
            self._putch(element)

    # -----------------------------------------

    def _putch(self, c):
        """Write a character on to the LCD."""
        self.write(c, 1)

    # -----------------------------------------

    def _puts(self, string):
        """Write a string on to the LCD."""

        for element in string:
            self._putch(element)


    # -----------------------------------------
    def go_to(self, column, row):
        
        
        if row == 0:
            address = 0

        if row == 1:
            address = 0x40

        if row == 2:
            address = 0x14

        if row == 3:
            address = 0x54

        address = address + column
        self.write(0x80 | address, 0)

 
# -----------------------------------------
#              END OF FILE
# -----------------------------------------

sdcard.py

"""
MicroPython driver for SD cards using SPI bus.

Requires an SPI bus and a CS pin.  Provides readblocks and writeblocks
methods so the device can be mounted as a filesystem.

Example usage on pyboard:

    import pyb, sdcard, os
    sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
    pyb.mount(sd, '/sd2')
    os.listdir('/')

Example usage on ESP8266:

    import machine, sdcard, os
    sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
    os.mount(sd, '/sd')
    os.listdir('/')

"""

from micropython import const
import time


_CMD_TIMEOUT = const(100)

_R1_IDLE_STATE = const(1 << 0)
# R1_ERASE_RESET = const(1 << 1)
_R1_ILLEGAL_COMMAND = const(1 << 2)
# R1_COM_CRC_ERROR = const(1 << 3)
# R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
# R1_ADDRESS_ERROR = const(1 << 5)
# R1_PARAMETER_ERROR = const(1 << 6)
_TOKEN_CMD25 = const(0xFC)
_TOKEN_STOP_TRAN = const(0xFD)
_TOKEN_DATA = const(0xFE)


class SDCard:
    def __init__(self, spi, cs):
        self.spi = spi
        self.cs = cs

        self.cmdbuf = bytearray(6)
        self.dummybuf = bytearray(512)
        self.tokenbuf = bytearray(1)
        for i in range(512):
            self.dummybuf[i] = 0xFF
        self.dummybuf_memoryview = memoryview(self.dummybuf)

        # initialise the card
        self.init_card()

    def init_spi(self, baudrate):
        try:
            master = self.spi.MASTER
        except AttributeError:
            # on ESP8266
            self.spi.init(baudrate=baudrate, phase=0, polarity=0)
        else:
            # on pyboard
            self.spi.init(master, baudrate=baudrate, phase=0, polarity=0)

    def init_card(self):
        # init CS pin
        self.cs.init(self.cs.OUT, value=1)

        # init SPI bus; use low data rate for initialisation
        self.init_spi(100000)

        # clock card at least 100 cycles with cs high
        for i in range(16):
            self.spi.write(b"\xff")

        # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
        for _ in range(5):
            if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE:
                break
        else:
            raise OSError("no SD card")

        # CMD8: determine card version
        r = self.cmd(8, 0x01AA, 0x87, 4)
        if r == _R1_IDLE_STATE:
            self.init_card_v2()
        elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
            self.init_card_v1()
        else:
            raise OSError("couldn't determine SD card version")

        # get the number of sectors
        # CMD9: response R2 (R1 byte + 16-byte block read)
        if self.cmd(9, 0, 0, 0, False) != 0:
            raise OSError("no response from SD card")
        csd = bytearray(16)
        self.readinto(csd)
        if csd[0] & 0xC0 == 0x40:  # CSD version 2.0
            self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
        elif csd[0] & 0xC0 == 0x00:  # CSD version 1.0 (old, <=2GB)
            c_size = csd[6] & 0b11 | csd[7] << 2 | (csd[8] & 0b11000000) << 4
            c_size_mult = ((csd[9] & 0b11) << 1) | csd[10] >> 7
            self.sectors = (c_size + 1) * (2 ** (c_size_mult + 2))
        else:
            raise OSError("SD card CSD format not supported")
        # print('sectors', self.sectors)

        # CMD16: set block length to 512 bytes
        if self.cmd(16, 512, 0) != 0:
            raise OSError("can't set 512 block size")

        # set to high data rate now that it's initialised
        self.init_spi(1320000)

    def init_card_v1(self):
        for i in range(_CMD_TIMEOUT):
            self.cmd(55, 0, 0)
            if self.cmd(41, 0, 0) == 0:
                self.cdv = 512
                # print("[SDCard] v1 card")
                return
        raise OSError("timeout waiting for v1 card")

    def init_card_v2(self):
        for i in range(_CMD_TIMEOUT):
            time.sleep_ms(50)
            self.cmd(58, 0, 0, 4)
            self.cmd(55, 0, 0)
            if self.cmd(41, 0x40000000, 0) == 0:
                self.cmd(58, 0, 0, 4)
                self.cdv = 1
                # print("[SDCard] v2 card")
                return
        raise OSError("timeout waiting for v2 card")

    def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
        self.cs(0)

        # create and send the command
        buf = self.cmdbuf
        buf[0] = 0x40 | cmd
        buf[1] = arg >> 24
        buf[2] = arg >> 16
        buf[3] = arg >> 8
        buf[4] = arg
        buf[5] = crc
        self.spi.write(buf)

        if skip1:
            self.spi.readinto(self.tokenbuf, 0xFF)

        # wait for the response (response[7] == 0)
        for i in range(_CMD_TIMEOUT):
            self.spi.readinto(self.tokenbuf, 0xFF)
            response = self.tokenbuf[0]
            if not (response & 0x80):
                # this could be a big-endian integer that we are getting here
                for j in range(final):
                    self.spi.write(b"\xff")
                if release:
                    self.cs(1)
                    self.spi.write(b"\xff")
                return response

        # timeout
        self.cs(1)
        self.spi.write(b"\xff")
        return -1

    def readinto(self, buf):
        self.cs(0)

        # read until start byte (0xff)
        for i in range(_CMD_TIMEOUT):
            self.spi.readinto(self.tokenbuf, 0xFF)
            if self.tokenbuf[0] == _TOKEN_DATA:
                break
        else:
            self.cs(1)
            raise OSError("timeout waiting for response")

        # read data
        mv = self.dummybuf_memoryview
        if len(buf) != len(mv):
            mv = mv[: len(buf)]
        self.spi.write_readinto(mv, buf)

        # read checksum
        self.spi.write(b"\xff")
        self.spi.write(b"\xff")

        self.cs(1)
        self.spi.write(b"\xff")

    def write(self, token, buf):
        self.cs(0)

        # send: start of block, data, checksum
        self.spi.read(1, token)
        self.spi.write(buf)
        self.spi.write(b"\xff")
        self.spi.write(b"\xff")

        # check the response
        if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05:
            self.cs(1)
            self.spi.write(b"\xff")
            return

        # wait for write to finish
        while self.spi.read(1, 0xFF)[0] == 0:
            pass

        self.cs(1)
        self.spi.write(b"\xff")

    def write_token(self, token):
        self.cs(0)
        self.spi.read(1, token)
        self.spi.write(b"\xff")
        # wait for write to finish
        while self.spi.read(1, 0xFF)[0] == 0x00:
            pass

        self.cs(1)
        self.spi.write(b"\xff")

    def readblocks(self, block_num, buf):
        nblocks = len(buf) // 512
        assert nblocks and not len(buf) % 512, "Buffer length is invalid"
        if nblocks == 1:
            # CMD17: set read address for single block
            if self.cmd(17, block_num * self.cdv, 0, release=False) != 0:
                # release the card
                self.cs(1)
                raise OSError(5)  # EIO
            # receive the data and release card
            self.readinto(buf)
        else:
            # CMD18: set read address for multiple blocks
            if self.cmd(18, block_num * self.cdv, 0, release=False) != 0:
                # release the card
                self.cs(1)
                raise OSError(5)  # EIO
            offset = 0
            mv = memoryview(buf)
            while nblocks:
                # receive the data and release card
                self.readinto(mv[offset : offset + 512])
                offset += 512
                nblocks -= 1
            if self.cmd(12, 0, 0xFF, skip1=True):
                raise OSError(5)  # EIO

    def writeblocks(self, block_num, buf):
        nblocks, err = divmod(len(buf), 512)
        assert nblocks and not err, "Buffer length is invalid"
        if nblocks == 1:
            # CMD24: set write address for single block
            if self.cmd(24, block_num * self.cdv, 0) != 0:
                raise OSError(5)  # EIO

            # send the data
            self.write(_TOKEN_DATA, buf)
        else:
            # CMD25: set write address for first block
            if self.cmd(25, block_num * self.cdv, 0) != 0:
                raise OSError(5)  # EIO
            # send the data
            offset = 0
            mv = memoryview(buf)
            while nblocks:
                self.write(_TOKEN_CMD25, mv[offset : offset + 512])
                offset += 512
                nblocks -= 1
            self.write_token(_TOKEN_STOP_TRAN)

    def ioctl(self, op, arg):
        if op == 4:  # get number of blocks
            return self.sectors

test.py

# -----------------------------------------
#                 NOTES 
# -----------------------------------------
"""
Dieter Steinhauser
12/2022
PicoPAD Test Script

"""

# -----------------------------------------
#               IMPORTS
# -----------------------------------------

from LCD import LCD
# import _thread
from utime import sleep, sleep_ms, sleep_us, ticks_ms
from machine import Pin, Timer, ADC, freq
# import gc

# -----------------------------------------
#         CONSTANTS/VARIABLES
# -----------------------------------------   

# ------------------
REFRESH_RATE = 10 # Frequency in Hz
REFRESH_PERIOD = int((1 / REFRESH_RATE) * 1000) # delay in milliseconds

# ------------------
UPY_BIT_RES = 16
ADC_REF = 3.3
VOLT_PER_BIT = ADC_REF / (2**UPY_BIT_RES) # ADC recieves in 2 byte packets and micropython automagically fixes it.

# ------------------
DAC_REF = 5.0
DC_OFFSET = 0
DC_OFFSET_RES = int((DC_OFFSET / DAC_REF) * (2**UPY_BIT_RES))

# ------------------
FREQ_MAX = 160
FREQ_MIN = 10
AMP_MAX = DAC_REF
AMP_MIN = 0

MAX_DIST_US0 = 50
MAX_DIST_US1 = 20


# -------------------------------------------------------------
#           INITIALIZATION
# -------------------------------------------------------------

# -----------------------------------------
#           SYSTEM CLOCK
# -----------------------------------------

DEFAULT_SYS_CLK = 125_000_000
STABLE_OVERCLOCK = 270_000_000

# Pico can go up to 270MHz before needing to flash to the eeprom directly.
system_clock = DEFAULT_SYS_CLK

# if the system clock is not the default, apply the clock speed.
if system_clock !=  DEFAULT_SYS_CLK:
    freq(system_clock)

# print(f'Clock: {freq()/1e6}MHz')

# -----------------------------------------
#               PINOUT
# -----------------------------------------

# LCD Pins handled in LCD.py
# ----------------------------
# EN = Pin(0, Pin.OUT)
# RS = Pin(1, Pin.OUT)
# D7 = Pin(2, Pin.OUT)
# D6 = Pin(3, Pin.OUT)
# D5 = Pin(4, Pin.OUT)
# D4 = Pin(5, Pin.OUT)

# Ultrasonic sensor pins handled in sensors.py
# ----------------------------
# us0_trig = Pin(6, Pin.OUT)
# us0_echo = Pin(7, Pin.IN)
# us1_trig = Pin(8, Pin.OUT)
# us1_echo = Pin(9, Pin.IN)

# Switches
# ----------------------------
# sw0 = Pin(10, Pin.IN, Pin.PULL_DOWN)
# sw1 = Pin(11, Pin.IN, Pin.PULL_DOWN)
# sw2 = Pin(12, Pin.IN, Pin.PULL_DOWN)
# sw3 = Pin(13, Pin.IN, Pin.PULL_DOWN)
# switch_pins = [sw0, sw1, sw2, sw3]

# LEDs
# ----------------------------
# led0 = Pin(14, Pin.OUT)
# led1 = Pin(15, Pin.OUT)
led_onboard = Pin(25, Pin.OUT)
# led_pins = [led0, led1, led_onboard]

# SPI handled by the Hardware in spi_config.py
# ----------------------------
# miso = Pin(16, Pin.IN)
# cs = Pin(17, Pin.OUT, value=1)
# mosi = Pin(18, Pin.OUT)
# sck = Pin(19, Pin.OUT)

# Buttons
# ----------------------------
# button0 = Pin(20, Pin.IN)
# button1 = Pin(21, Pin.IN)
# button2 = Pin(22, Pin.IN)
# button3 = Pin(28, Pin.IN)
# button_pins = [button0, button1, button2, button3]

# ADC
# ----------------------------
# adc0 = ADC(26) # Connect to GP26, which is channel 0
# adc1 = ADC(27) # Connect to GP27, which is channel 1

# -----------------------------------------
#           LCD
# -----------------------------------------
lcd = LCD(enable_pin=0,
         reg_select_pin=1, 
         data_pins=[2, 3, 4, 5]
         )

lcd.init()
lcd.clear()
# lcd.cursor_on()
# lcd.blink()
# -----------------------------------------
#           ADC
# -----------------------------------------
adc0 = ADC(26) # Connect to GP26, which is channel 0
adc1 = ADC(27) # Connect to GP27, which is channel 1
# adc2 = machine.ADC(28) # Connect to GP28, which is channel 2
# adc_reading = adc0.read_u16() * VOLT_PER_BIT # read and report the ADC reading

# -----------------------------------------
#           SD CARD VIA SPI
# -----------------------------------------
# 
# import sdcard
# import os
# import uos
# 
# # Assign chip select (CS) pin (and start it high)
# cs = Pin(20, machine.Pin.OUT)
# 
# # Intialize SPI peripheral (start with 1 MHz)
# spi = machine.SPI(0,
#                   baudrate=1000000,
#                   polarity=0,
#                   phase=0,
#                   bits=8,
#                   firstbit=machine.SPI.MSB,
#                   sck=Pin(18),
#                   mosi=Pin(19),
#                   miso=Pin(16))
# 
# # Initialize SD card
# sd = sdcard.SDCard(spi, cs)
# 
# vfs = uos.VfsFat(sd)
# uos.mount(vfs, "/sd")
# 
# # Create a file and write something to it
# file = open("/sd/test01.txt", "w")
# 
# with open("/sd/test01.txt", "w") as file:
#     file.write("Hello, SD World!\r\n")
#     file.write("This is a test\r\n")
# 
# # Open the file we just created and read from it
# with open("/sd/test01.txt", "r") as file:
#     data = file.read()
#     print(data)

# -----------------------------------------
#           PROCESS 1: IO
# -----------------------------------------

while True:

    splash = True
    # Display the splash screen on startup.
    if splash is True:
        led_onboard(1)
        lcd.print(f'PicoPAD Test  ')
        lcd.go_to(0,1)
        lcd.print(f'Dieter S.        ')
        sleep(2)
        lcd.home()
        lcd.clear()
        lcd.print(f'System Clock')
        lcd.go_to(0,1)
        lcd.print(f'{freq()/1e6}MHz')
        sleep(2)
        lcd.home()
        lcd.clear()
        led_onboard.toggle()

    while True:

        # read ADC
        # -----------------------------------------
        adc0_reading = (adc0.read_u16() * VOLT_PER_BIT)
        adc1_reading = (adc1.read_u16() * VOLT_PER_BIT)
        lcd.home()
        lcd.print(f'ADC0: {round(adc0_reading,3)}       ')
        lcd.go_to(0,1)
        lcd.print(f'ADC1: {round(adc1_reading,3)}       ')
        
        # toggle onboard LED for System speed status and refresh delay
        # -----------------------------------------
        led_onboard.toggle()
        sleep_ms(REFRESH_PERIOD)
        # gc.collect()

References

2

“What is a bypass capacitor? tutorial: Applications,” Electronics Hub, 14-Sep-2021. [Online]. Available: https://www.electronicshub.org/bypass-capacitor-tutorial/. [Accessed: 27-Aug-2022].

10

“Ltc1661 – micropower dual 10-bit DAC in MSOP - Analog Devices.” [Online]. Available: https://www.analog.com/media/en/technical-documentation/data-sheets/1661fb.pdf. [Accessed: 17-Oct-2022].

13(1,2,3,4)

“Raspberry Pico Datasheet,” raspberrypi.com. [Online]. Available: https://datasheets.raspberrypi.com/pico/pico-datasheet.pdf. [Accessed: 15-Nov-2022].

14(1,2)

“Raspberry Pico python SDK,” raspberrypi.com. [Online]. Available: https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-python-sdk.pdf. [Accessed: 15- Nov-2022].

15

“RP2040 Datasheet,” raspberrypi.com. [Online]. Available: https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf. [Accessed: 14-Nov-2022].

16

“Serial peripheral interface,” Wikipedia, 27-Sep-2022. [Online]. Available: https://en.wikipedia.org/wiki/Serial_Peripheral_Interface. [Accessed: 19-Oct-2022].

17

“Sitronix ST7066U - Crystalfontz,” crystalfontz. [Online]. Available: https://www.crystalfontz.com/controllers/Sitronix/ST7066U/438. [Accessed: 03-Oct2022].

18

“What is a Bypass Capacitor?,” What is a bypass capacitor? [Online]. Available: http://www.learningaboutelectronics.com/Articles/What-is-a-bypass-capacitor.html. [Accessed: 27-Aug-2022].