import time
time.sleep(0.1) # Wait for USB to become ready

print("Hello, Pi Pico W!")


main.py

diagram.json

"""
# Displays.py
# A collection of various text-based displays
# Note - as of 7/31/24 only the LCDDisplay is implemented in this module
# Use OtherDisplays.py, GraphicDisplays.py and GraphicLCD.py for the rest
# Supports LCD 1602 displays - both using an i2c backpack as well as GPIO
# Only supports number and basic text displays 
# Author: Arijit Sengupta
"""

from machine import Pin, I2C, SPI
import time
from Log import *
from gpio_lcd import *
from pico_i2c_lcd import I2cLcd

class Display:
    """
    The Display Base class - might not actually be needed
    But here to ensure we do not have a duckTyping problem
    """

    def reset(self):
        Log.e(f"reset NOT IMPLEMENTED in {type(self).__name__}")
        
    def clear(self):
        self.reset()

    def showNumber(self, number):
        Log.e(f"showNumber NOT IMPLEMENTED! in {type(self).__name__}")

    def showText(self, text):
        Log.e(f"showText NOT IMPLEMENTED! in {type(self).__name__}")

    def scroll(self, text, speed=250):
        Log.e(f"Scroll NOT IMPLEMENTED! in {type(self).__name__}")

class LCDDisplay(Display):
    """
    LCD Display class - currently supports displays with an I2C backpack
    as well as displays directly driven via the d4-d7 pins
    
    Parameters
    --------
    This is important since Python does not have method overloading, we have one init
    to do both parallel as well as i2c displays
    pass rs, e, d4, d5, d6, d7 pin numbers for parallel displays
    
    pass sda and scl for i2c displays - default is to use parallel so must pass
    both sda/scl if using i2c
    
    To connect the display to I2C 0 on GPIO pins 0,1
    usage: LCDDisplay(sda=0, scl=1)
    
    To connect the display to I2C ID 1 on GPIO pins 2,3
    usage: LCDDisplay(sda=2, scl=3)
    
    To connect via parallel with rs on pin 5, e on pin 4
    and d4,d5,d6,d7 to pins 3,2,1 and 0:
    usage:  LCDDisplay()  # yeah those are the default so you don't need to send
    usage: LCDDisplay(rs=5, e=4, d4=3, d5=2, d6=1, d7=0) # preferred - you can see how its hooked up
    
    """
    
    def __init__(self, rs=5, e=4, d4=3, d5=2, d6=1, d7=0, *, sda=-1, scl=-1):
        """
        Combined constructor for the direct-driven displays
        explicitly pass in the sda and scl if you need to use I2C
        """
        
        if sda < 0:
            Log.i("LCDDisplay Constructor")
            self._lcd = GpioLcd(rs_pin=Pin(rs),
                enable_pin=Pin(e),
                d4_pin=Pin(d4),
                d5_pin=Pin(d5),
                d6_pin=Pin(d6),
                d7_pin=Pin(d7),
                num_lines=2, num_columns=16)
        else:
            Log.i("LCDDisplay (I2C) Constructor")
            """
            Lets determine the i2c id from the sda and scl pins
            """
            i2cid = -1 # lets set an invalid value to start with
            if (sda == 0 and scl == 1) or (sda == 4 and scl == 5) or (sda == 8 and scl == 9) or (sda == 12 and scl == 13) or (sda == 16 and scl == 17) or (sda == 20 and scl == 21):    
                i2cid = 0
            elif (sda == 2 and scl == 3) or (sda == 6 and scl == 7) or (sda == 10 and scl == 11) or (sda == 14 and scl == 15) or (sda == 18 and scl == 19) or (sda == 26 and scl == 27):
                i2cid = 1
            else:
                raise ValueError('Invalid SDA/SCL pins')
            i2c = I2C(i2cid, sda=Pin(sda), scl=Pin(scl), freq=400000)
            try:
                I2C_ADDR = i2c.scan()[0]
                self._lcd = I2cLcd(i2c, I2C_ADDR, 2, 16)
            except:
                raise ValueError('Could not connect to display - check wiring.')
        self._working = False

    def reset(self):
        """ 
        clear the display screen
        """
        
        Log.i("LCDDisplay: reset")
        self._lcd.clear()
        self._working = False

    def clear(self, line=-1):
        """
        Clear only a single line - negative to reset
        """

        if line < 0 or line > 1:
            self.reset()
        else:
            self.showText(f'{" "*16}',line)

    def showNumber(self, number, row=0, col=0):
        """
        show a single number
        """
        
        if self._working:
            Log.e("LCDDisplay - Display busy")
            return
        self._working = True
        Log.i(f"LCDDisplay - showing number {number} at {row},{col}")
        self._lcd.move_to(col, row)
        self._lcd.putstr(f"{number}")
        self._working = False

    def showNumbers(self, num1, num2, colon=True, row=0, col=0):
        """
        Show two numbers optionally separated by a colon
        by default, the colon is shown
        """
        
        if self._working:
            Log.e("LCDDisplay - Display busy")
            return
        self._working = True
        Log.i(f"LCDDisplay - showing numbers {num1}, {num2} at {row},{col}")
        self._lcd.move_to(col, row)
        colsym = ":" if colon else " "
        self._lcd.putstr(f"{num1}{colsym}{num2}")
        self._working = False

    def showText(self, text, row=0, col=0):
        """
        Show a string - only first 4 characters will be shown
        for anything bigger than 4 characters.
        """
        
        if self._working:
            Log.e("LCDDisplay - Display busy")
            return
        self._working = True
        Log.i(f"LCDDisplay - showing text {text} at {row},{col}")
        self._lcd.move_to(col, row)
        self._lcd.putstr(text)
        self._working = False

    def addShape(self, position, shapearray):
        """
        Add a custom character at a position.
        position must be between 0 and 7
        shapearray needs to be a bytearray that can
        be created by going to
        https://maxpromer.github.io/LCD-Character-Creator/
        and then copying the bytes into a bytearray as a list of hex values
        as in the example below:

        d.addShape(1, [0x00,0x0A,0x0A,0x00,0x11,0x0E,0x04,0x00]) # a smiley face
        d.showText(chr(1), 0,5) # show the smiley face at position 5 of row 0
        """
        
        if position < 0 or position > 7:
            raise ValueError('Position must be between 0 and 7.')
        if len(shapearray) != 8:
            raise ValueError('Make sure array is exactly 8 bytes')
        self._lcd.custom_char(position, shapearray)

    def scroll(self, text, row=0, speed=100, skip=2):
        """
        A very simple scroll implementation
        Scrolls some text right to left in a row

        speed is essentially the delay between refresh - lower the better
        skip is the number of chars to skip for the next refresh
        higher number will be faster but may be jerky. lower will be smooth
        but slower.

        I2C devices may not have best scrolling performance. Works
        better with GPIO-driven displays
        """

        if self._working:
            Log.e("LCDDisplay - Display busy")
            return
        self._working = True
        Log.i(f"LCDDisplay - scrolling text {text} in row {row}")
        for p in range(0,len(text)+skip, skip):
            curst = (text+' '*(16+skip))[p:p+16]
            for c in range(16,0,-1):
                self._lcd.move_to(c-1, row)
                self._lcd.putchar(curst[c-1])
            time.sleep(speed/1000)
        self._working = False


Displays.py

"""
# GraphicLCD.py
# Separate from the Display hierarchy
# since it is being created as a subclass of FrameBuffer
# to improve performance. This works well on the Waveshare
# pico display hats but not tested in other devices. The
# commands are based on ST7789 drivers so it may not work
# with other chipsets like the ILI9341. I might eventually
# incorporate the two drivers but for now focusing only
# on the ST7789 since I have one of those.
# Author: Arijit Sengupta
"""
from machine import Pin,SPI,PWM
import framebuf2 as framebuf
import time
import os

REDRGB565   =   0x07E0
GREENRGB565 =   0x001f
BLUERGB565  =   0xf800
WHITERGB565 =   0xffff
BLACKRGB565 =   0x0

class GraphicLCD(framebuf.FrameBuffer):
    """
    GraphicLCD class - based on the Waveshare series of display hats for Pico
    Uses SPI sck @10 MOSI @11 no MISO
    CS @9 DC @8 RST @12 for Display control
    Backlight control @13
    
    Defaults set for the 240x240 display - for different sizes, use the width
    and height parameters. Eg. for the 240x128 use
    
    GraphicLCD(width=240, height=128)
    """
    
    def __init__(self, DC=8, CS=9, SCK=10, MOSI=11, RST=12, BL=13, width=240, height=240, brightness=50):
        self.width = width
        self.height = height
        
        self.cs = Pin(CS,Pin.OUT)
        self.rst = Pin(RST,Pin.OUT)
        self.bl = PWM(Pin(13))
        self.bl.freq(1000)
        self.brightness = brightness
        self.setBrightness(brightness)
        
        self.cs(1)
        self.spi = SPI(1)
        self.spi = SPI(1,1000_000)
        self.spi = SPI(1,100000_000,polarity=0, phase=0,sck=Pin(SCK),mosi=Pin(MOSI),miso=None)
        self.dc = Pin(DC,Pin.OUT)
        self.dc(1)
        self.buffer = bytearray(self.height * self.width * 2)
        super().__init__(self.buffer, self.width, self.height, framebuf.RGB565)
        self.init_display()
        
        self.red   =   REDRGB565
        self.green =   GREENRGB565
        self.blue  =   BLUERGB565
        self.white =   WHITERGB565
        self.black =   BLACKRGB565
        
    def reset(self):
        """
        Clear the display. By default clear sets the display to a black background.
        """
        self.clear(0)
        
    def clear(self, color=0):
        """
        Clear the display. By default clear sets the display to a black background.
        However, a separate RGB565 color can be sent to clear it with that color.
        """
        self.fill(color)
        self.show()
        
    def setBrightness(self, brightnesslevel = 50):
        """
        Set the backlight brightness to a percent level, default is 50%
        """
        self.brightness = brightnesslevel
        level = int(655.35*brightnesslevel)
        self.bl.duty_u16(level)	#max 65535
        
    def brighter(self, pct=5):
        """
        increase brightness by pct %
        """
        b = self.brightness * (100+pct) / 100
        if b > 100:
            b = 100
        self.setBrightness(b)
        
    def dimmer(self, pct=5):
        """
        Decrease brightness by pct %
        """
        b = self.brighness * (100-pct) /100
        if b < 0:
            b = 0
        self.setBrighness(b)
        

    def color565(self, red, green=0, blue=0):
        """
        Utility function to
        convert red, green and blue values (0-255) into a 16-bit 565 encoding.
        """
        try:
            red, green, blue = red  # see if the first var is a tuple/list
        except TypeError:
            pass
        return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3
    
    def showNumber(self, number, row=0, col=0, m=2, c=WHITERGB565, bc=0, show=True):
        """
        Utility method in the same line as the other Display classes
        to show a number at a certain position.
        
        Additional params are size and color
        Size is set to 2 by default since 1 is too small
        bc is background color - default is 0 (black)
        """
        s = str(number)
        self.showText(s, row, col, m, c, bc, show)

    def showText(self, text, row=0, col=0, m=2, c=WHITERGB565, bc=0, show=True):
        """
        Utility method in the same line as the other Display classes
        to show a String at a certain position.
        
        Additional params are size and color
        Size is set to 2 by default since 1 is too small
        bc is background color - default is 0 (black)
        
        The last parameter show is for immediately pushing to framebuf
        if true - if set to False, make all updates and call show for
        improved performance
        """
        # First clear the area needed by drawing a rectangle in bg color
        self.rect(row,col, 8*m*len(text), 8*m, bc, True)
        self.large_text(text, row, col, m, c)
        if show:
            self.show()

    def show(self):
        """
        Push the current framebuffer to SPI. Standard process would be
        to make all updates to the screen using regular Framebuf calls,
        then calling show() once per frame.
        
        Can be set to run on the second core of the Pico if necessary,
        if running on the second core, ensure that no updates are made
        while this method is running.
        
        The last parameter show is for immediately pushing to framebuf
        if true - if set to False, make all updates and call show for
        improved performance
        """
        
        self.write_cmd(0x2A)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xef)
        
        self.write_cmd(0x2B)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xEF)
        
        self.write_cmd(0x2C)
        
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(self.buffer)
        self.cs(1)
    
    # methods below are internal and should not need to be called directly.
    def write_cmd(self, cmd):
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(bytearray([buf]))
        self.cs(1)

    def init_display(self):
        """Initialize dispaly"""  
        self.rst(1)
        self.rst(0)
        self.rst(1)
        
        self.write_cmd(0x36)
        self.write_data(0x70)

        self.write_cmd(0x3A) 
        self.write_data(0x05)

        self.write_cmd(0xB2)
        self.write_data(0x0C)
        self.write_data(0x0C)
        self.write_data(0x00)
        self.write_data(0x33)
        self.write_data(0x33)

        self.write_cmd(0xB7)
        self.write_data(0x35) 

        self.write_cmd(0xBB)
        self.write_data(0x19)

        self.write_cmd(0xC0)
        self.write_data(0x2C)

        self.write_cmd(0xC2)
        self.write_data(0x01)

        self.write_cmd(0xC3)
        self.write_data(0x12)   

        self.write_cmd(0xC4)
        self.write_data(0x20)

        self.write_cmd(0xC6)
        self.write_data(0x0F) 

        self.write_cmd(0xD0)
        self.write_data(0xA4)
        self.write_data(0xA1)

        self.write_cmd(0xE0)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0D)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2B)
        self.write_data(0x3F)
        self.write_data(0x54)
        self.write_data(0x4C)
        self.write_data(0x18)
        self.write_data(0x0D)
        self.write_data(0x0B)
        self.write_data(0x1F)
        self.write_data(0x23)

        self.write_cmd(0xE1)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0C)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2C)
        self.write_data(0x3F)
        self.write_data(0x44)
        self.write_data(0x51)
        self.write_data(0x2F)
        self.write_data(0x1F)
        self.write_data(0x1F)
        self.write_data(0x20)
        self.write_data(0x23)
        
        self.write_cmd(0x21)

        self.write_cmd(0x11)

        self.write_cmd(0x29)

    def show(self):
        self.write_cmd(0x2A)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xef)
        
        self.write_cmd(0x2B)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0x00)
        self.write_data(0xEF)
        
        self.write_cmd(0x2C)
        
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(self.buffer)
        self.cs(1)


GraphicLCD.py

"""
# GraphicDisplays.py
# Previously part of Displays.py - split out to improve performance
# of LCD-based displays which are mostly used in our projects
# Currently supports SSD1306-based OLED devices
# and cheap 128x32 I2C LCD devices
# Author: Arijit Sengupta
"""

from Displays import *
from ssd1306 import SSD1306_I2C
import lcd128_32_fonts
from lcd128_32 import lcd128_32

class LCDHiResDisplay(Display):
    """
    LCDHiResDisplay - implements an LCD display which gives access to individual pixels
    
    Only supports I2C connection for now. Pass in sda, scl, i2cid, width and height
    
    Usage:
    Connect to I2C0 on sda to pin 0 and scl to pin 1:
    
    LCDHiResDisplay(sda=0, scl=1, i2cid=0, width=128, height=32)
    
    Connect to I2C0 on sda to pin 20, scl to pin 21:
    LCDHiResDisplay(sda=20, scl=21, i2cid=0, width=128, height=32) # default values
    
    Note that graphics outputs are not supported yet in this library.    
    """
    
    def __init__(self, sda=20, scl=21, i2cid=0, width=128, height=32):
        Log.i("LCDHiResDisplay (I2C) Constructor")
        i2c = I2C(i2cid, sda=Pin(sda), scl=Pin(scl), freq=400000)
        I2C_ADDR = i2c.scan()[0]
        try:
            I2C_ADDR = i2c.scan()[0]
            self._lcd = lcd128_32(sda, scl, i2cid, I2C_ADDR)
            self.reset()
        except:
            raise ValueError('Could not connect to display - check wiring.')

    def reset(self):
        self._lcd.Clear()
        
    def showNumber(self, number, row=0, col=0):
        self._lcd.Cursor(row,col)
        self._lcd.Display(str(number))

    def showText(self, text, row=0, col=0):
        self._lcd.Cursor(row,col)
        self._lcd.Display(text)

    
class OLEDDisplay(Display):
    """
    OLEDDisplay class - implements an OLED display
    
    Only supports I2C connection for now. Pass in sda, scl, i2cid, width and height
    
    Usage:
    Connect to I2C0 on sda to pin 0 and scl to pin 1:
    
    OLEDDisplay(sda=0, scl=1, i2cid=0, width=128, height=64)
    
    Connect to I2C1 on sda to pin 26, scl to pin 27:
    OLEDDisplay(sda=26, scl=27, i2cid=1, width=128, height=64) # default values
    
    Note that graphics outputs are not supported yet in this library.
    """

    def __init__(self, sda=26, scl=27, i2cid=1, width=128, height=64):
        self._i2c = I2C(i2cid, sda=Pin(sda), scl=Pin(scl), freq=400000)
        self._oled = SSD1306_I2C(width, height, self._i2c)
        self.reset()

    def reset(self):
        self._oled.fill(0)
        self._oled.show()
        
    def showNumber(self, number, row=0, col=0):
        self._oled.text(str(number), row, col, 1)
        self._oled.show()

    def showText(self, text, row=0, col=0):
        self._oled.text(text, row, col, 1)
        self._oled.show()



GraphicDisplays.py

"""
# Counters.py
# A collection of different kinds of counters that might be used for
# various projects
# Author: Arijit Sengupta
"""

import time
from machine import Timer, RTC
from Log import *

class Counter:
    """
    Counter base class - provides an internal count, an initiailzer and a reset method
    everything else should be defined at subclass level
    """
    
    def __init__(self, name='Counter'):
        Log.i(f"{name}: constructor")
        self._name = name
        self._count = 0

    def reset(self):
        """ Reset counter memory to 0 """
        
        Log.i("Counter - reset")
        self._count = 0

class UpDownCounter(Counter):
    """ A basic updown counter - can go up or down, can set up a min and max """
    
    def __init__(self, name='Updown counter', min = None, max = None):
        Log.i(f"{name} constructor")
        super().__init__(name)
        self._min = min
        self._max = max

    def up(self, step=1):
        """
        count up - with an optional step. Note that if the result will be less than max,
        no change will be made.
        """
                
        Log.i("Updowncounter incrementing")
        if (self._max is None or self._count + step <= self._max):
            self._count = self._count + step

    def down(self, step=1):
        """
        Count down - with an optional step. Note that if the result will be less than min,
        no change will be made
        """
        
        Log.i("Updowncounter decrementing")
        if (self._min is None or self._count - step >= self._min):
            self._count = self._count - step

    def __str__(self)->str:
        """ a string representation of the internal count """
        
        return f"{self._count}"

class TimeKeeper(Counter):
    """
    Keeps time as a count. Basically a stopwatch
    Internal count stores the number of ms of counting
    Can be stopped and started many times. Only reset will set
    count to 0
    """
    
    def __init__(self,name='Timekeeper'):
        Log.i(f"{name} : constructor")
        super().__init__(name)
        self._starttime = 0
        self._running = False

    def start(self):
        """ Start the timer. Note that if previously stopped, this will add to previous time """
        
        Log.i("Timekeeper: start")
        """ If timer was already running, the start will get reset to the new time """

        self._starttime = time.ticks_ms()
        self._running = True

    def stop(self):
        """ Stop the timer. Count will save the # of ms elapsed """
        
        Log.i("Timekeeper: stop")
        """ If it was already stopped, nothing to be done """
        if self._running:
            self._running = False
            self._count = self._count + time.ticks_diff(time.ticks_ms(),self._starttime)

    def reset(self):
        """ 
        Resetting the timer will set count to 0 and starttime to the current time 
        But timer keeps running if not stopped
        """
        
        super().reset()
        self._starttime = time.ticks_ms()
        self._running = False

    def elapsed_time(self, format='sec'):
        """
        Get the elapsed time in seconds (default) or ms by passing format='ms'
        """
        if self._running:
            ms = self._count + time.ticks_diff(time.ticks_ms(),self._starttime)
        else:
            ms = self._count
        if format == 'ms':
            return ms
        else:
            return int(ms / 1000)

    def __str__(self) -> str:
        """ Get a string representation of time in HH:MM:SS.ms format """
        
        curtime = self._count + (time.ticks_diff(time.ticks_ms(),self._starttime) if self._running else 0)
        ms = curtime % 1000
        sec = (curtime // 1000) % 60
        min = (curtime // 60000) % 60
        hr = (curtime // 3600000)
        return f"{hr:02d}:{min:02d}:{sec:02d}.{ms:03d}"


class BaseTimer(Counter):
    """ 
    Decided to create a base class for the Software and Hardware timers
    since there are many properties in common. Now allowing no handlers in init
    but obviously a handler has to be set in order to ensure something happens when
    the time runs out.
    """

    def __init__(self, name='timer', handler=None):
        super().__init__(name)
        self._handler = handler
        self._started = False

    def setHandler(self, handler):
        self._handler = handler

    def start(self, seconds):
        self._count = seconds
        self._started = True

    def cancel(self):
        self._started = False
        self._count = 0

    def reset(self):
        """ Make sure reset cancels the timer first """
        
        super().reset()
        self.cancel()
        
class HardwareTimer(BaseTimer):
    """
    This uses the hardware internal timer of the Pico. This does NOT WORK on the simulator!
    The internal count here is the timer setting that is not updated until reset or cancelled
    
    """
    
    def __init__(self, name='Hardware Timer', handler=None):
        """
        A hardware timer must be initialized with a handler. The handler must implement
        a timeout() method which will be called when the timer is up. Ideally, there
        should only be a single timer active at a time.
        """
        
        super().__init__(name, handler)
        self._timer = Timer(-1)

    def start(self, seconds):
        """ Start the timer with the number of seconds to use. """
        
        super().start(seconds)
        self._timer.init(period = int(seconds*1000), mode=Timer.ONE_SHOT, callback = self.timeout)

    def cancel(self):
        """ Cancel the timer. Note that a normal stop will cause the handler callback. """
        
        if self._started:
            self._timer.deinit()
        super().cancel()
    
    def timeout(self, timer):
        self.cancel()
        self._handler.timeout(self._name)

class SoftwareTimer(BaseTimer):
    """
    A simpler software-based timer that will work on the simulator as well. Caller
    again implements a handler method, but will need to poll the timer using the
    check method at regular intervals. Check will not return anything, but will
    call the timeout function of the caller just like the hardware timer.
    """
    
    def __init__(self, name='Software Timer', handler=None):
        super().__init__(name, handler)
        self._starttime = 0
        self._started = False

    def start(self, seconds):
        """ Start the timer with a set number of seconds """
        
        Log.i(f"Starting timer with {seconds} seconds")
        self._count = seconds
        self._starttime = time.ticks_ms()
        self._started = True

    def cancel(self):
        """ Cancel the timer - timeout hander will NOT be called """
        
        if self._started:
            self._starttime = 0
            Log.i(f"{self._count} sec timer cancelled")
        super().cancel()

    def check(self):
        """
        Periodically call the check method - can be called from anywhere
        """
        
        if self._started and time.ticks_diff(time.ticks_ms(), self._starttime) > self._count * 1000:
            Log.i(f"{self._name}: {self._count} sec timer is up")
            self._started = False
            self._count = 0
            self._handler.timeout(self._name)

class Time:
    @classmethod
    def getTime(cls):
        """
        Return the currnet time using the datetime 8-tuple:
        (year (4 dig), month (1-12), date(1-31), hour (0-23), min(0,59), sec(0-59), wkday(0-6), yday(1-366))
        """
        
        return time.localtime()

    @classmethod
    def setTime(cls, tm):
        """
        Send a semi-valid time tuple - wkday and yday are ignored
        The rest have to be valid (be careful about no. of days in a month
        """
        
        RTC().datetime((tm[0], tm[1], tm[2], 0, tm[3], tm[4], tm[5], 0))
    


Counters.py

"""
# Button.py - Object-Oriented implementation of a Button
# Also added a simple implementation of a single analog Joystick
# Author: Arijit Sengupta
"""

from machine import Pin, ADC
import time
from Log import *

class Button:
    """
    A simple Button class
    Create the button using Button(pinnumber, name, handler)
    handler is typically self, and create two methods buttonPressed and buttonReleased
    to handle the push and release of the button.
    The name of the button will be passed back to the handler to identify
    which button was pressed/released
    """
    
    def __init__(self, pin, name, *, handler=None, lowActive=True):
        """
        Initialize attributes and other internal data
        """
        
        self._pinNo = pin
        self._name = name
        Log.i(f'Button constructor: create button {name} at pin {pin}')
        if lowActive:
            self._pin = Pin(pin, Pin.IN, Pin.PULL_UP)
        else:
            self._pin = Pin(pin, Pin.IN, Pin.PULL_DOWN)
        self._debounce_time = 0
        self._lowActive = lowActive
        self._lastStatus = None
        self._handler = None
        self.setHandler(handler)
        
    def isPressed(self):
        """ Check if the button is pressed or not - useful if polling """
        
        status = (self._lowActive and self._pin.value() ==0) or (not self._lowActive and self._pin.value() == 1)
        Log.i(f'Button {self._name} isPressed: {status}')
        return status
    
    def setHandler(self, handler):
        """ 
	    set the handler to a new handler. Pass None to remove existing handler
	    """
        
        # if the old handler was active already, or if the new handler is None, remove the irq
        if self._handler is not None or handler is None:
            self._pin.irq(handler = None)
    
        # Now set it to th enew handler
        self._handler = handler
        # Create the IRQ if the handler is not None
        if self._handler:
            self._pin.irq(trigger = Pin.IRQ_FALLING | Pin.IRQ_RISING, handler = self._callback)
        
    def _callback(self, pin):
        """ The private interrupt handler - will call appropriate handlers """
        
        t = time.ticks_ms()
        v = self._pin.value()
        if ((self._lastStatus == None or self._lastStatus != v) and t-self._debounce_time) > 50:
            self._debounce_time=t
            self._lastStatus = v
            if self._handler is not None:
                if self.isPressed():
                    Log.i(f'Button {self._name} pressed')
                    self._handler.buttonPressed(self._name)
                else:
                    Log.i(f'Button {self._name} released')
                    self._handler.buttonReleased(self._name)
        #self._debounce_time=t

class Joystick(Button):
    """
    A joystick is technically more than a Button, but this is an example
    of using a subclass to inherit some functionality, and adding other
    functions as needed. 

    So we implement a Joystick as a subclass of a button, with the internal
    button inherited from the Button class, and the horizontal and vertical
    axes implemented as ADC pin implementations. 

    Interestingly, we may have looked into AnalogSensor as well, but there is
    no tripping of a Joystick so we don't need that.
    """
    
    # Some constants to store some basic conditions
    LOW = 0
    HIGH = 65535
    MID = 32760

    # Joystick status codes
    CENTER = 0
    UP = 1
    DOWN = 2
    LEFT = 3
    RIGHT = 4
    MOVING = 5
    
    # Status text
    statuscodes = ['Center', 'Up', 'Down', 'Left', 'Right', 'Moving']

    def __init__(self, vpin, hpin, swpin, name, *, handler=None, delta=1000):
        # Let the superclass handle all button functionality
        super().__init__(swpin, name, handler=handler, lowActive=True)
        Log.i(f'Joystick constructor: create joystick at v:{vpin}, h:{hpin}')

        # H and V axis pins must be standard ADC supporting
        if vpin <26 or vpin > 28 or hpin < 26 or hpin > 28:
            raise ValueError("Joystick Error: must connect v/h to ADC pins")

        self._v = ADC(vpin)
        self._h = ADC(hpin)
        self._delta = delta

    def getData(self):
        """
        A simple method to return the x and y values
        """

        return (self._h.read_u16(), self._v.read_u16())

    def getStatusCode(self):
        """
        Return the status code of the joystick
        0 - center, 1 left 2 right 3 up 4 down
        5 if it is not quite in any distinct position
        """

        (x,y) = self.getData()

        if x < self.LOW + self._delta:
            return self.RIGHT
        if x > self.HIGH - self._delta:
            return self.LEFT
        if y < self.LOW + self._delta:
            return self.DOWN
        if y > self.HIGH - self._delta:
            return self.UP
        if x > self.MID - self._delta and x < self.MID + self._delta and y > self.MID - self._delta and y < self.MID + self._delta:
            return self.CENTER
        return self.MOVING

    def getStatus(self):
        """
        Get the status of the joystick in text
        center, left, right, up, down, moving
        """
    
        return Joystick.statuscodes[self.getStatusCode()]


Button.py

"""
Log.py - a simplistic Logging process. Built to kind of mimic the
Android Logging process, but at the same time having a global level
set to see the types of logs being displayed.

Basic usage:

Log.level = DEBUG  # set global log level

# Options are: ALL/INFO (everything) DEBUG (debug and higher), ERRO (only errors)
Log.i(f'help')     # Info message: f-strings recommended for showing variables
Log.d(f'value: {v}') # Debug message
Log.e(f'Exception: {x}') # Error message
Log.name('Myproject') # Set a global project name
"""

""" Debug levels """
ALL = 4  # All messages are displayed
INFO = 3  # Basically the same as ALL - for future-proofing
DEBUG = 2  # Info is hidden - debug and higher shown
ERROR = 1  # Only error messages shown
NONE = 0  # No messages are shown from log classes


class Log:

    name = ''
    level = ALL

    @classmethod
    def i(cls, message):
        if (cls.level >= INFO):
            Log.pr(message)

    @classmethod
    def d(cls, message):
        if (cls.level >= DEBUG):
            Log.pr(message)

    @classmethod
    def e(cls, message):
        if (cls.level >= ERROR):
            Log.pr(message)

    @classmethod
    def pr(cls, message):
        if cls.name:
            m = cls.name + ": " + message
        else:
            m = message
        print(m)


if __name__ == '__main__':
    print("Hello")
    Log.level = ALL
    Log.name = 'Test'
    Log.i(f'This should print (level: {Log.level})')
    
    Log.level = ERROR
    Log.i(f'This should NOT print (level: {Log.level})')
    Log.e(f'This should print (level: {Log.level})')
    



Log.py

"""
Keypad.py - a simple implementation of a mxn keypad
typically used for providing input to microcontrollers

This is a fairly simple implementation and does use
a blocking scan, so cannot use this for detecting multi-presses

# Author: Arijit Sengupta
"""
from machine import Pin
import utime

default_keys = [
    ['1','2','3','A'],
    ['4','5','6','B'],
    ['7','8','9','C'],
    ['*','0','#','D']
]

class Keypad:
    """
    Keypad is a mxn matrix - read by turning the rows into 
    outputs and columns into inputs. Read by setting each row
    high one at a time, then checking which column became high
    and returning the value at the column.

    These come in many sizes, so keeping it at least somewhat
    flexible to support keypads of different types, but
    defaulting to the standard hex keypads that are most
    commonly available.
    """

    def __init__(self, row_pins, col_pins):
        """
        Initialize the keypad - send in the pin numbers that
        connect the rows and pin numbers that connect the columns
        """
        self._lastscan = 0
        self._rows = len(row_pins)
        self._cols = len(col_pins)

        self._row_pins = [None] * self._rows
        self._col_pins = [None] * self._cols
        self._keys = default_keys

        for r in range(0, self._rows):
            self._row_pins[r] = Pin(row_pins[r], Pin.OUT)

        for c in range(0, self._cols):
            self._col_pins[c] = Pin(col_pins[c], Pin.IN, Pin.PULL_DOWN)

    def setKeys(self, keys = default_keys):
        """
        Set the keys if they are not the default
        hex keypad
        """

        self._keys = keys

    def scanKey(self,delay=250)->str:
        """
        Scan the keypad once and return if anything is detected
        to be pressed. returns None if nothing is pressed.
        
        To avoid multi-presses, if a request comes from scanKey within
        delay ms of the last valid scan, we are going to return None
        """
        if utime.ticks_ms()-self._lastscan < delay:
            return None
        for rowKey in range(self._rows):
            self._row_pins[rowKey].value(1)
            for colKey in range(self._cols):
                if self._col_pins[colKey].value() == 1:
                    key = self._keys[rowKey][colKey]
                    self._row_pins[rowKey].value(0)
                    self._lastscan = utime.ticks_ms()
                    return(key)
            self._row_pins[rowKey].value(0)
        return None

        

Keypad.py

"""
# Lights.py
# implementation of different types of lights
# both digitally controlled (on/off)
# or PWM-controlled (dimming) to set brightness
# Author: Arijit Sengupta
"""

import utime
from machine import Pin, PWM
from Log import *
import _thread
MAX = 65535

baton = _thread.allocate_lock()

class Light:
    """
    The Light base class - just an LED controlled by a digital IO
    Pin. Save the pin in an instance variable
    """
    
    def __init__(self, pin, name="Unnamed"):
        """
        Light constructor - save the pin and set it to OUTPUT mode
        pin is the NUMBER of the pin that the LED is connected to. So
        if connecting to GP21, pass the value 21 to pin        
        name is an optional name of the light
        """
            
        Log.i(f"Light: constructor")
        self._name = name
        self._pin = pin
        self._blinking = False
        self._led = Pin(self._pin, Pin.OUT)  # We need this to use the IO functions

    def on(self):
        """ on: Turn the light on """
        
        Log.i(f"Light: turning on {self._name} light at pin {self._pin}")
        self._led.value(1)

    def off(self):
        """ off: turn the light off """
        
        Log.i(f"Light: turning off {self._name} light at pin {self._pin}")
        self._led.value(0)

    def flip(self):
        """ flip: turn off if it was on, on if it was off """
        
        Log.i(f"Light: Toggling {self._name} light at pin {self._pin}")
        self._led.toggle()

    def blink(self, delay=0.5, times=1):
        """ blink: turn on for delay sec, off for delay sec [times] times"""

        Log.i(f"Light: Blink {self._name} {times} times for {delay} sec")
        for x in range(0,times):
            self.on()
            utime.sleep(delay)
            self.off()
            utime.sleep(delay)


class DimLight(Light):
    """
    The Dimmable Light subclass - will have the standard on off methods
    and in addition will have the ability to set brightness
    """

    def __init__(self, pin, name="Unnamed"):
        """ Dimmable light constructor """

        Log.i("Dimmable light constructor")
        super().__init__(pin, name)
        self._pwm = PWM(self._led)  # Create an instance of PWM object (pulse-width modulation)
        self._pwm.freq(100000)   # set frequency to 100 khz
        self._onState = False
        self._running = False

    def on(self):
        """ Turn on - full brightness max is 255 """
        
        self._running = False
        self._onState = True
        Log.i(f"Dimlight: turn Light {self._name} on (full brightness)")
        self.setBrightness(MAX)

    def off(self):
        """  Turn off - set brightness to 0 """
        
        self._running = False
        self._onState = False
        Log.i(f"Dimlight - turn Light {self._name} off (brightness 0)")
        self.setBrightness(0)

    def flip(self):
        """ flip: turn off if it was on, on if it was off """
        
        Log.i(f"Light: Toggling {self._name} light at pin {self._pin}")
        if self._onState:
            self.off()
        else:
            self.on()       
        
    def setBrightness(self, brightness):
        """ Set brightness to a specific level 0-255 """

        Log.i(f"Dimlight: setting Light {self._name} brightness to {brightness}")
        if (brightness == MAX):
            self._pwm.duty_u16(MAX)
        else:
            self._pwm.duty_u16(brightness * brightness)
        
        if brightness < 50:
            self._onState = False
        else:
            self._onState = True

    def upDown(self):
        """
        # Do a quick demo of going up and down full brightness levels
        # Here it is better to use ChangeDutyCycle
        """
        
        Log.i(f"Dimlight: do an up-down demo on Light {self._name}")
        self._running = True
        dc = 0
        for i in range (0, 25):
            if not self._running:
                break
            dc += 10
            self.setBrightness(dc)
            utime.sleep_ms(100)

        for i in range (0, 25):
            if not self._running:
                break
            dc -= 10
            self.setBrightness(dc)
            utime.sleep_ms(100)
        self._running = False

Lights.py

"""
LevelDisplay.py
A base LevelDisplay class with a couple of subclasses with implementations using
A LightStrip and an LCD Display - I may add additional implementations in the future
for example, using an actual 7 led bar - maybe with a shift register
"""

from Displays import *
from LightStrip import *
from Log import *

class LevelDisplay:
    """
    Superclass for LevelDisplay.
    Should not be initiated directly. Wish Python had a proper abstract class
    """
    
    def __init__(self, levels):
        """
        Create a level Display with a max number of levels.
        Note that display will be from 0 (may be nothing displayed)
        Up to _levels_ so levels is inclusive.
        """
        
        self._levels = levels
        self._curlevel = 0
        
    def showLevel(self, levelpct):
        """
        Show a percentage - appropriate is calculated here.
        Subclasses should overload this method and call super().showLevel(levelpct)
        to calculate the current level
        """
        
        # if percent is < 5, treat it as 0 - nothing displayed
        # if > 95, treat as full. All levels lit up.
        if levelpct <= 5:
            self._curlevel = 0
        elif levelpct >= 95:
            self._curlevel = self._levels
        else:
            self._curlevel = int(self._levels * levelpct / 100)
        Log.i(f'Showing {levelpct}% with {self._curlevel} levels')
        
class LightStripLevel(LevelDisplay):
    """
    Implementation of the Level display using a NeoPixel lightstrip.
    """
    
    def __init__(self, strip):
        """ constructor. call superclass constructor and save the lightstrip variable"""
        
        super().__init__(strip._numleds)
        self._strip = strip
        Log.i("Creating a Light strip level") 
        
    def showLevel(self, levelpct):
        """ Show the level in the light strip. """
        
        level = levelpct
        super().showLevel(level)
        if self._curlevel == 0:
            self._strip.off()
            return
        color = WHITE if level < 30 else YELLOW if level < 60 else PURPLE if level < 90 else RED
        self._strip.setColor(color, self._curlevel)
        

class LCDLevel(LevelDisplay):
    """
    Implementation of the Level display using an LCD Display custom chars
    """
    
    def __init__(self, display):
        # LCD display can only show 8 levels so we are fixing it
        super().__init__(8)
        self._display = display
        Log.i("Creating an LCD level") 
        
        # Add the custom chars to the PRAM
        for p in range(0,8):
            arr = [0x00]*8
            for z in range(0,p+1):
                arr[7-z] = 0xff
            self._display.addShape(p, arr)

    def showLevel(self, levelpct, row=0, col=0):
        """ Show the level as bars on the display. """

        level = levelpct
        super().showLevel(level)
        if self._curlevel == 0:
            self._display.showText('.       ', row, col)
            return
        for l in range (0, self._curlevel):
            self._display.showText(chr(l), row, col+l)
        if self._curlevel < 8:
            self._display.showText(' '*(8-self._curlevel),row, col+self._curlevel)



LevelDisplay.py

"""
# Sensors.py
# A simple Sensor hierarchy for digital and analog sensors
# Added support for Ultrasonic Sensor on 9/11/23
# Added support for DHT11/DHT22 sensor on 6/14/24
# Author: Arijit Sengupta
"""

from machine import Pin, ADC
import utime
import math
import dht
from Log import *

class Sensor:
    """
    The top level sensor class - assume each sensor uses 
    at least one pin. We do not create the IO here because
    some sensors may use Analog inputs
    
    Parameters
    --------
    pin: pin number where the sensor is connected
    lowActive: set to True if the sensor gets low (or under threshold)
    when tripped. So an analog light sensor should normally get a high
    value but when covered, go low. So lowActive should be True
    
    A force sensor would be opposite - tripped when force gets high
    so lowActive should be False
    """
    
    def __init__(self, pin, name='Sensor', lowActive = True):
        self._pin = pin
        self._lowActive = lowActive
        self._name = name
        
    def tripped(self)->bool:
        Log.e(f"tripped not implemented for {type(self).__name__} {self._name}")
        return False

class DigitalSensor(Sensor):
    """
    A simple digital sensor (like the commonly available LC-393 that is a light sensor)
    has a digital output that flips based on a manual threshold control

    We are just going to poll this to keep things simple
    """
    
    def __init__(self, pin, name='Digital Sensor', lowActive=True):
        super().__init__(pin, name, lowActive)
        self._pinio = Pin(self._pin, Pin.IN)

    def tripped(self)->bool:
        v = self._pinio.value()
        if (self._lowActive and v == 0) or (not self._lowActive and v == 1):
            Log.i(f"DigitalSensor {self._name}: sensor tripped")
            return True
        else:
            return False
        
class TiltSensor(DigitalSensor):
    """
    A tilt sensor looks like a cap but has just a metal ball on two contacts
    when you tilt, the ball rolls off and the contact opens. That way its very
    much like a button which is always pressed.
    """
    
    def __init__(self, pin, name='Tilt Sensor'):
        # Init - do not call the super init - just create the Pin.
        super().__init__(pin, name)
        self._pinio = Pin(pin, Pin.IN, Pin.PULL_UP)
        
    def tripped(self):
        if self._pinio.value() == 1:
            Log.i(f"TiltSensor {self._name}: sensor tripped")
            return True
        else:
            return False

class AnalogSensor(Sensor):
    """
    A simple analog sensor that returns a voltage or voltage ratio output
    that can be read in using an ADC. Pico reads in via a 16bit unsigned

    We are just going to poll this to keep things simple
    """
    
    def __init__(self, pin, name='Analog Sensor', lowActive=True, threshold = 30000):
        """ analog sensors will need to be sent a threshold value to detect trip """
        
        super().__init__(pin, name, lowActive)
        self._pinio = ADC(self._pin)
        self._threshold = threshold

    def tripped(self)->bool:
        """ sensor is tripped if sensor value is higher or lower than threshold """
        
        v = self.rawValue()
        if (self._lowActive and v < self._threshold) or (not self._lowActive and v > self._threshold):
            Log.i(f"AnalogSensor {self._name}: sensor tripped")
            return True
        else:
            return False

    def rawValue(self):
        return self._pinio.read_u16()

class TempSensor(AnalogSensor):
    """
    Temperature sensor as a subclass of Analog Sensor - Temp sensor is a bit more
    defined since it technically returns a temperature. Note that thermistors are
    not totally accurate, but the teperature fluctuations - increases and decreases
    are what matters.
    """
    
    def __init__(self, pin, name='Temp Sensor', lowActive=False, threshold=60):
        """
        Create a new temp sensor - similar to regular analog sensor
        but now tripped will return true when temp is lower than threshold (lowActive=True)
        and higher than threshold (lowActive=False)
        """
        
        super().__init__(pin, name, lowActive, threshold)
        
    def rawValue(self):
        """
        Reture the temperature (approx) in fahrenheit
        """
        
        adcvalue = super().rawValue()
        voltage = adcvalue / 65535.0 * 5
        Rt = 10 * voltage / (5 -voltage)
        tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10)) / 3950))
        tempF = int((tempK - 273.15) * 1.8) + 32
        return tempF
        
class UltrasonicSensor(Sensor):
    """
    A simple implementation of an ultrasonic sensor with digital IO
    pins for trigger and echo.
    
    While technically Ultrasonic sensor is not an analog sensor since it
    uses digital pins, it does have continuous data, so subclassing
    AnalogSensor makes more sense. But given AnalogSensor should only be
    used in ADC pins, it is better to subclass the Sensor superclass.
    
    Continuing to use the lowActive and threshold like AnalogSensor however.

    init by sending trigger, echo and optionally lowActive and threshold
    parameters. Threshold defaults to 10cm, and lowActive defaults to true
    so when distance is < 10cm, it will return true for tripped.
    """

    def __init__(self, *, trigger=0, echo=1, name='Ultrasonic', lowActive = True, threshold=10.0):
        super().__init__(trigger, name, lowActive)
        self._trigger = Pin(trigger, Pin.OUT)
        self._echo = Pin(echo, Pin.IN)
        self._threshold = threshold

    def getDistance(self)->float:
        """ Get the distance of obstacle from the sensor in cm """
        
        self._trigger.off()
        utime.sleep_us(2)
        self._trigger.on()
        utime.sleep_us(5)
        self._trigger.off()
        while self._echo.value() == 0:
            signaloff = utime.ticks_us()
        while self._echo.value() == 1:
            signalon = utime.ticks_us()
        timepassed = signalon - signaloff
        distance = (timepassed * 0.0343) / 2
        return distance

    def tripped(self)->bool:
        """ sensor is tripped if distance is higher or lower than threshold """
        
        v = self.getDistance()
        if (self._lowActive and v < self._threshold) or (not self._lowActive and v > self._threshold):
            Log.i(f"UltrasonicSensor {self._name}: sensor tripped")
            return True
        else:
            return False

# DHT11/DHT22 Sensor
class DHTSensor(DigitalSensor):
    def __init__(self, pin, name='DHT', lowActive=False, threshold=60, poll_delay=2000, sensor_type='DHT11'):
        """
        Create a new DHT sensor - similar to regular digital sensor but can take
        either the form of a DHT11 or DHT22 based on the sensor_type parameter

        DHT11 is less accurate but cheaper, DHT22 is more accurate but more expensive

        Note that the DHT sensor is a digital sensor but it returns two values - temperature
        and humidity. So we subclass DigitalSensor but override the rawValue method

        Also, the DHT sensor is a bit slow, so we will not poll it as frequently as other sensors.
        To avoid to much polling, a default poll parameter is set to 2 seconds.

        The threshold is set to 60F by default, but can be changed. This is used to determine
        if the sensor is tripped or not. Only the temperature is used for tripping.
        """
        
        super().__init__(pin, name, lowActive)
        self._sensor_type = sensor_type
        self._sensor_class = dht.DHT11 if sensor_type == "DHT11" else dht.DHT22
        self._dht_sensor = self._sensor_class(Pin(self._pin))
        self._last_poll_time = 0
        self._poll_delay = poll_delay
        self._threshold = threshold

    def getTemperature(self):
        """
        Return the temperature of the sensor
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return self._dht_sensor.temperature()

    def getHumidity(self):
        """
        Return the humidity of the sensor
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return self._dht_sensor.humidity()

    def rawValue(self):
        """
        Returns a tuple of temperature and humidity
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return (self._dht_sensor.temperature(), self._dht_sensor.humidity())

    def tripped(self)->bool:
        """
        Sensor is tripped if temperature is higher or lower than threshold
        """
        
        if self._lowActive:
            return self.getTemperature() < self._threshold
        else:
            return self.getTemperature() >= self._threshold


Sensors.py

"""
Motors.py - a class containing code to drive different types
of motors.
# Author: Arijit Sengupta
"""

from machine import Pin, PWM
from time import sleep
from Log import *

class Motor:
    """
    A Motor superclass just to keep things together if we need to
    Currently simply stores the main pin (some motors take multiple pins)
    and a name for the motor.
    """
    
    def __init__(self, pin, name='Unnamed Motor'):
        self._pin = pin
        self._name = name


class Stepper(Motor):
    """
    A stepper motor is a powerful precision motor that can be controlled to 
    any angle (0-360). Usually requires a lot more power than what the
    Pico can deliver so will most likely need a separate power supply.
    Also requires a separate stepper motor driver since the current requirements
    are also higher than what the Pico can deliver.

    Different drivers exist - Wokwi supports the A4988 motor driver so 
    that is what I am implementing here.
    """

    def __init__(self, steppin=27, dirpin=26, *, name='Unnamed Stepper'):
        """
        For a stepper driven by A4988, we need two inputs - step and dir
        Technically there are 2 additional ones - reset and sleep but
        we are not using them here.
        """

        super().__init__(steppin, name)
        self._dirpin = dirpin
        self._step = Pin(steppin, Pin.OUT)
        self._dir = Pin(dirpin, Pin.OUT)
        self._curPos = 0 # Does a stepper go to 0 automatically?
        self._running = False

    def setAngle(self, angle):
        """
        set the stepper angle to a value in degrees. Technically can
        be any number. Note that higher than 360 will cause multiple
        rotations of the stepper.
        """
        
        Log.i(f"Setting angle of {self._name} to {angle}")
        self.rotate(angle - self._curPos)
        self._running = False

    def rotate(self, angle):
        """
        Rotate the servo by a certain angle.
        positive will be clockwise, negative will be anti-clockwise
        
        Again, technically can be any value - but higher than 360 will
        cause multiple rotations
        """

        Log.i(f"Rotating {self._name} by {angle} degrees") 
        numsteps = round(float(angle)/1.8)
        if numsteps < 0:
            self._dir.value(0)
            numsteps = numsteps * -1
        else:
            self._dir.value(1)
        
        for x in range (0,numsteps):
            self._step.value(1)
            sleep(0.01)
            self._step.value(0)
        
        self._curPos = self._curPos + angle
        self._running = False

    def spin(self, times=1, direction=1, speed=0):
        """
        Make the stepper spin at a certain speed. Note that this
        is a blocking call until the number of times is reached.

        speed is technically a delay between steps in seconds
        0 is full speed and 0.1 is 100 ms etc.

        times is the number of full rotations the stepper will make
        0 for times will keep the motor spinning forever.

        direction is 1 for clockwise, -1 for anti-clockwise

        We try to keep track of the current position, but after spinning,
        the position may be off.
        """

        if direction != 0:
            direction = 1
        self._running = True
        self._dir.value(direction)
        self._curPos = self._curPos % 360 # Let's forget higher spin positions
        n = 0
        
        Log.i(f"Spinning {self._name} {'clockwise' if direction == 1 else 'anti-clockwise'} {times} times at speed {speed} ")
        while self._running and (times == 0 or n < times):
            n = n + 1
            for x in range(0,200):
                self._step.value(1)
                sleep(0.001 + speed)
                self._step.value(0)
                self._curPos = self._curPos + 1.8 * (1 if direction else -1)
                if self._curPos >= 360 or self._curPos < 0:
                    self._curPos = self._curPos % 360
        Log.i(f"Stopped spinning {self._name}")

class Servo(Motor):
    def __init__(self, pin, name='Unnamed Servo'):
        super().__init__(pin, name)
        self._pwm = PWM(Pin(self._pin))
        self._pwm.freq(50)
        self._curPos = -1 # Initially position is unknown

    def setAngle(self, angle):
        """
        set the servo angle to something between 0 and 180
        Anything less than 0 will be treated as 0, anything
        more will be treated as 180

        Note for Wokwi:
        Wokwi has 0 at 1500 duty, 180 at 8000 duty
        So duty = int((8000-1500)*float(angle)/180.0)
        """

        if angle < 0:
            angle = 0
        if angle > 180:
            angle = 180
        
        Log.i(f"Setting angle of {self._name} to {angle}")
        duty = int((8000-1500)*float(angle)/180.0)+1500
        self._pwm.duty_u16(duty)
        self._curPos = angle

    def rotate(self, angle):
        """
        Rotate the servo by a certain angle.
        positive will be clockwise, negative will be anti-clockwise
        Rotating below 0 will set it to 0
        First rotation will set to 90, unless an angle is set before
        """

        Log.i(f"Rotating {self._name} by {angle} degrees")  
        if self._curPos < 0:
            self.setAngle(90)
        else:
            self.setAngle(self._curPos + angle)
        
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-dc-motor-micropython/

class DCMotor(Motor):
    def __init__(self, enable_pin = 0, name="DCMotor", forward_pin = 1, backward_pin=2, min_duty=15000, max_duty=65535):
        super().__init__(enable_pin, name)
        self.pin1 = Pin(forward_pin, Pin.OUT)
        self.pin2 = Pin(backward_pin, Pin.OUT)
        self.enable_pin = PWM(Pin(enable_pin), 1000)
        self.min_duty = min_duty
        self.max_duty = max_duty

    def forward(self, speed=100):
        """ Spin motor forward at a percent speed (max:100)"""
        
        Log.i(f"Moving {self._name} forward at speed {speed}")
        self.speed = speed
        self.enable_pin.duty_u16(self.duty_cycle(self.speed))
        self.pin1.value(1)
        self.pin2.value(0)

    def backwards(self, speed=100):
        """ Spin motor backwards at a percent speed (max:100) """
        
        Log.i(f"Moving {self._name} backwards at speed {speed}")
        self.speed = speed
        self.enable_pin.duty_u16(self.duty_cycle(self.speed))
        self.pin1.value(0)
        self.pin2.value(1)

    def stop(self):
        """ Stop spinning the motor """
        
        Log.i(f"Stopping {self._name}")
        self.enable_pin.duty_u16(0)
        self.pin1.value(0)
        self.pin2.value(0)

    def duty_cycle(self, speed):
        if speed <= 0 or speed > 100:
            duty_cycle = 0
        else:
            duty_cycle = int(self.min_duty + (self.max_duty - self.min_duty) * (speed / 100))
        return duty_cycle
    
if __name__ == '__main__':
    m = DCMotor(enable_pin=13, forward_pin=14,backward_pin=15)
    while True:
        # Start up slow to full speed
        for x in range(20,110,10):
            m.forward(x)
            sleep(0.5)
        
        # stop for a bit
        m.stop()
        sleep(1)
        # reverse slow to full speed
        for x in range(20,110,10):
            m.backwards(x)
            sleep(0.5)
        
        # stop for a bit
        m.stop()
        sleep(1)

Motors.py

"""
# LightStrip.py
# Re-implementing the old NeoPixel class into a LightStrip class
# Using the built-in neopixel class in MicroPython now
"""

import time, neopixel, machine
from Lights import *
from Log import *

class LightStrip(Light):
    """
    Although technically a composite light, a neopixel is a PIO-driven set of lights
    using a single output pin. So you do not send it composite lights, but just the pin
    it is connected to. It is a composite light because it has multiple lights, but
    they cannot technically be controlled individually.
    """

    FILLS = 0
    CHASES = 1
    RAINBOW = 2

    def __init__(self, pin=2, name='Neopixel', numleds=16, brightness=0.5):
        """
        Constructor for neopixel will create its own internal statemachine
        Note that if any other state machine is running, this will break the existing
        statemachine. This refers to the Pico PIO statemachine, not any software state
        machines.
        """
        
        self._name = name
        self._pin = pin
        self._numleds = numleds
        self._brightness = brightness
        self._running = False
        
        Log.i(f'Creating a neopixel {name} on pin {pin} with {numleds} LEDs')
        self._np = neopixel.NeoPixel(machine.Pin(pin), numleds)

    def on(self):
        """ Turn all LEDs ON - all white """

        self._fill(WHITE)
        self._np.write()
        Log.i(f'{self._name} ON')
    
    def off(self):
        """ Turn all LEDs OFF - all black """
        
        self._running = False
        time.sleep(0.1)
        self._clear()
        self._np.write()
        Log.i(f'{self._name} OFF')

    def flip(self):
        """ Flip the clors on all the LEDs """
        
        for x in range(0, self._numleds):
            self._np[x] = (255-self._np[x][0], 255-self._np[x][1], 255-self._np[x][2])
        self.show()
        Log.i(f'{self._name} flipped')

    def setColor(self, color, numPixels= -1):
        """ Turn all LEDs up to a set number of pixels to a specific color """
        
        if numPixels < 0 or numPixels > self._numleds:
            numPixels = self._numleds
        for i in range(numPixels):
            self._set_pixel(i, color)
        for i in range(numPixels,self._numleds):
            self._set_pixel(i, BLACK)
        self._np.write()
        Log.i(f'{self._name} set color to {color}')

    def setPixel(self, pixelno, color, show=True):
        """
        Turn a single pixel a specific color
        By default the new color is immediately shown.
        To make multiple changes, you can speed up by setting
        show to False, then calling the show method
        """
        
        self._set_pixel(pixelno, color)
        if show:
            self._np.write()
        Log.i(f'{self._name} set pixel {pixelno} to color {color}')

    def show(self):
        """
        Shows what is in the color buffer. Useful if previous
        setPixel was called without show On
        """
        
        self._np.write()
        
    def setBrightness(self, brightness=0.5):
        """ Change the brightness of the pixel 0-1 range """
        
        self._brightness = brightness
        Log.i(f'{self._name} set brightness to {brightness}')
        
    def run(self, runtype=0):
        """ Run a single cycle of FILLS, CHASES or RAINBOW """
        
        self._running = True
        if runtype == LightStrip.FILLS:
            Log.i(f'{self._name} running fills')
            for color in COLORS:
                if not self._running:
                    break       
                self.setColor(color)
                time.sleep(0.2)
        elif runtype == LightStrip.CHASES:
            Log.i(f'{self._name} running chases')
            for color in COLORS:
                if not self._running:
                    break       
                self.color_chase(color, 0.01)
        else:
            Log.i(f'{self._name} running rainbow')
            self.rainbow_cycle(0)
        self._running = False


    ################# Internal functions should not be used outside here #################
    def _set_pixel(self, p, color):
        modifiedcolor = tuple(int(col*self._brightness) for col in color)
        self._np[p] = modifiedcolor

    def _clear(self):
        self._np.fill(BLACK)
        pass

    def _fill(self, color):
        self._np.fill(color)
        pass


    def color_chase(self, color, wait):
        for i in range(self._numleds):
            if not self._running:
                break
            self._set_pixel(i, color)
            time.sleep(wait)
            self._np.write()
        time.sleep(0.2)
    
    def wheel(self, pos):
        # Input a value 0 to 255 to get a color value.
        # The colours are a transition r - g - b - back to r.
        if pos < 0 or pos > 255:
            return (0, 0, 0)
        if pos < 85:
            return (255 - pos * 3, pos * 3, 0)
        if pos < 170:
            pos -= 85
            return (0, 255 - pos * 3, pos * 3)
        pos -= 170
        return (pos * 3, 0, 255 - pos * 3)
    
    
    def rainbow_cycle(self, wait):
        for j in range(255):
            if not self._running:
                break
            for i in range(self._numleds):
                rc_index = (i * 256 // self._numleds) + j
                self._set_pixel(i, self.wheel(rc_index & 255))
            self._np.write()
            time.sleep(wait)


# Some color definitions
BLACK = (0, 0, 0)
RED = (255, 0, 0)
ORANGE = (255, 140, 0)
YELLOW = (255, 200, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
CYAN = (0, 255, 255)
INDIGO = (75, 0, 130)
WHITE = (255, 255, 255)
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE, ORANGE)



LightStrip.py

from machine import Pin, ADC
from Button import Joystick
from Sensors import TiltSensor
from Counters import UpDownCounter
from Displays import LCDDisplay
import time

# Class for the Tetris game board
class GameBoard:
    def __init__(self, lcd):
        self.lcd = lcd
        self.grid = [[0] * 10 for _ in range(16)]  # 16x10 Tetris grid

    def reset(self):
        self.grid = [[0] * 10 for _ in range(16)]
        self.lcd.clear()

    def draw(self):
        self.lcd.clear()
        for row_index, row in enumerate(self.grid):
            row_str = ''.join(['#' if cell else '.' for cell in row])
            self.lcd.showText(row_str, row=row_index)

    def update_piece(self, piece, position):
        for x, y in piece:
            self.grid[position[0] + x][position[1] + y] = 1

# Joystick input handler
class JoystickHandler:
    def __init__(self, v_pin, h_pin, sw_pin):
        self.joystick = Joystick(v_pin, h_pin, sw_pin, "Joystick")

    def get_input(self):
        status = self.joystick.getStatusCode()
        return status

# Tilt sensor handler
class TiltHandler:
    def __init__(self, pin):
        self.tilt_sensor = TiltSensor(pin)

    def is_tilted(self):
        return self.tilt_sensor.tripped()

# Score counter
class ScoreCounter:
    def __init__(self, min_val=0, max_val=999):
        self.counter = UpDownCounter("Score", min=min_val, max=max_val)

    def increment(self, value=1):
        self.counter.up(value)

    def decrement(self, value=1):
        self.counter.down(value)

    def get_score(self):
        return str(self.counter)

# Main game class
class TetrisGame:
    def __init__(self):
        self.lcd = LCDDisplay(sda=0, scl=1)  # Update with correct I2C pins
        self.game_board = GameBoard(self.lcd)
        self.joystick = JoystickHandler(v_pin=26, h_pin=27, sw_pin=28)
        self.tilt_handler = TiltHandler(pin=15)
        self.score_counter = ScoreCounter()
        self.current_piece = [(0, 0), (0, 1), (1, 0), (1, 1)]  # Example piece (square)
        self.position = [0, 4]  # Start position of the piece

    def move_piece(self, direction):
        if direction == "LEFT":
            self.position[1] -= 1
        elif direction == "RIGHT":
            self.position[1] += 1
        elif direction == "DOWN":
            self.position[0] += 1

    def rotate_piece(self):
        self.current_piece = [(y, -x) for x, y in self.current_piece]

    def play(self):
        self.game_board.reset()
        while True:
            self.game_board.reset()
            status = self.joystick.get_input()
            if status == Joystick.UP:
                self.rotate_piece()
            elif status == Joystick.LEFT:
                self.move_piece("LEFT")
            elif status == Joystick.RIGHT:
                self.move_piece("RIGHT")
            elif status == Joystick.DOWN:
                self.move_piece("DOWN")

            if self.tilt_handler.is_tilted():
                self.rotate_piece()

            self.game_board.update_piece(self.current_piece, self.position)
            self.game_board.draw()

            time.sleep(0.5)  # Adjust game speed

# Run the game
if __name__ == "__main__":
    game = TetrisGame()
    game.play()
