Raspberry Pi Pico 2 W Project

#######
#
# Project: PWM (Pulse Width Modulation) LED Chase Effect
# Based on open-source PWM examples from the Raspberry Pi Foundation
# and MicroPython community.
#
# Adapted and documented by Denis Legault
# Date:    2026-02-10
# Python File: main.py
# Hardware: Raspberry Pi Pico 2 W,
#           10 LEDs connected via PWM-capable pins
#
# Description:
# Demonstrates a PWM-based LED chase effect using a custom myPWM class.
# The LEDs gradually fade in and out using different duty cycle values,
# creating a smooth flowing light pattern from left to right and then
# right to left.
#
# PWM duty values are cycled through a predefined list to control
# brightness levels. The effect runs continuously until interrupted.
#
# GPIO Pin Connections:
# PWM Pins -> GPIO16, 17, 18, 19, 20, 21, 22, 26, 27, 28
#
# Notes:
# - Requires pwm.py containing the myPWM class.
# - Uses MicroPython PWM (16-bit duty cycle: 0–65535).
# - Saved as main.py to auto-run on power-up.
#
#######

from machine import Pin, PWM
from pwm import myPWM
import time

# Initialize PWM controller with 10 GPIO pins
mypwm = myPWM(16, 17, 18, 19, 20, 21, 22, 26, 27, 28)

# Logical PWM channel numbers (0–9)
chns = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Duty cycle values used to create a fade-in / fade-out effect
# 0 = OFF, 65535 = FULL brightness
dutys = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    65535, 32768, 16384, 8192, 4096,
    2048, 1024, 512, 256, 128,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]

# Delay between animation steps (milliseconds)
delayTimes = 50

try:
    while True:
        # Forward LED chase
        for i in range(0, 20):
            for j in range(0, 10):
                # Set PWM duty for each channel
                mypwm.ledcWrite(chns[j], dutys[i + j])
            time.sleep_ms(delayTimes)

        # Reverse LED chase
        for i in range(0, 20):
            for j in range(0, 10):
                # Reverse channel order for opposite direction
                mypwm.ledcWrite(chns[9 - j], dutys[i + j])
            time.sleep_ms(delayTimes)

except:
    # Cleanly disable all PWM outputs on exit
    mypwm.deinit()
  

#######
#
# Module: PWM Helper Class (myPWM)
# Based on open-source PWM (Pulse Width Modulation) examples from the 
# Raspberry Pi Foundation and MicroPython community.
#
# Adapted and documented by Denis Legault
# Date:    2026-02-10
# Python File: pwm.py
# Hardware: Raspberry Pi Pico 2 W
#
# Description:
# Provides a simple wrapper class around MicroPython's PWM functionality
# to control up to 10 PWM output channels using logical channel numbers
# (0–9) instead of managing individual PWM objects directly.
#
# Each PWM channel is initialized with the same frequency and can be
# updated independently using a 16-bit duty cycle value (0–65535).
#
# This module is intended to be imported by other programs (e.g. main.py)
# and is commonly used for LED dimming effects, motor control, or
# multi-channel PWM animations.
#
# GPIO Pin Connections (default):
# PWM Channel 0  -> GPIO16
# PWM Channel 1  -> GPIO17
# PWM Channel 2  -> GPIO18
# PWM Channel 3  -> GPIO19
# PWM Channel 4  -> GPIO20
# PWM Channel 5  -> GPIO21
# PWM Channel 6  -> GPIO22
# PWM Channel 7  -> GPIO26
# PWM Channel 8  -> GPIO27
# PWM Channel 9  -> GPIO28
#
# Notes:
# - Uses MicroPython PWM with 16-bit duty resolution.
# - Frequency defaults to 10 kHz but can be changed during initialization.
# - Designed to simplify multi-channel PWM usage in embedded projects.
#
#######

from machine import Pin, PWM


class myPWM:
    """
    Wrapper class for managing multiple PWM outputs using logical channels.
    """

    def __init__(
        self,
        pwm0: int = 16,
        pwm1: int = 17,
        pwm2: int = 18,
        pwm3: int = 19,
        pwm4: int = 20,
        pwm5: int = 21,
        pwm6: int = 22,
        pwm7: int = 26,
        pwm8: int = 27,
        pwm9: int = 28,
        freq_num: int = 10000
    ):
        """
        Initialize up to 10 PWM channels with a common frequency.

        :param pwm0–pwm9: GPIO pin numbers for each PWM channel
        :param freq_num:  PWM frequency in Hz (default: 10 kHz)
        """

        # Create PWM objects for each channel and set frequency
        self._pwm0 = PWM(Pin(pwm0))
        self._pwm0.freq(freq_num)

        self._pwm1 = PWM(Pin(pwm1))
        self._pwm1.freq(freq_num)

        self._pwm2 = PWM(Pin(pwm2))
        self._pwm2.freq(freq_num)

        self._pwm3 = PWM(Pin(pwm3))
        self._pwm3.freq(freq_num)

        self._pwm4 = PWM(Pin(pwm4))
        self._pwm4.freq(freq_num)

        self._pwm5 = PWM(Pin(pwm5))
        self._pwm5.freq(freq_num)

        self._pwm6 = PWM(Pin(pwm6))
        self._pwm6.freq(freq_num)

        self._pwm7 = PWM(Pin(pwm7))
        self._pwm7.freq(freq_num)

        self._pwm8 = PWM(Pin(pwm8))
        self._pwm8.freq(freq_num)

        self._pwm9 = PWM(Pin(pwm9))
        self._pwm9.freq(freq_num)

    def ledcWrite(self, chn, value):
        """
        Set the PWM duty cycle for a given channel.

        :param chn:   Logical PWM channel number (0–9)
        :param value: Duty cycle (0–65535)
        """

        if chn == 0:
            self._pwm0.duty_u16(value)
        elif chn == 1:
            self._pwm1.duty_u16(value)
        elif chn == 2:
            self._pwm2.duty_u16(value)
        elif chn == 3:
            self._pwm3.duty_u16(value)
        elif chn == 4:
            self._pwm4.duty_u16(value)
        elif chn == 5:
            self._pwm5.duty_u16(value)
        elif chn == 6:
            self._pwm6.duty_u16(value)
        elif chn == 7:
            self._pwm7.duty_u16(value)
        elif chn == 8:
            self._pwm8.duty_u16(value)
        elif chn == 9:
            self._pwm9.duty_u16(value)

    def deinit(self):
        """
        Disable all PWM channels and release hardware resources.
        """

        self._pwm0.deinit()
        self._pwm1.deinit()
        self._pwm2.deinit()
        self._pwm3.deinit()
        self._pwm4.deinit()
        self._pwm5.deinit()
        self._pwm6.deinit()
        self._pwm7.deinit()
        self._pwm8.deinit()
        self._pwm9.deinit()
  

#######
#
# Project: NeoPixel Color Cycle
# Based on open-source WS2812 PIO examples from the Raspberry Pi Foundation
# and MicroPython community.
#
# Adapted and documented by Denis Legault
# Date:    2026-02-10
# Python File: main.py
# Hardware: Raspberry Pi Pico 2 W,
#           8x WS2812 / NeoPixel LEDs connected to GPIO16
#
# Description:
# Demonstrates basic control of a NeoPixel (WS2812) LED strip using a
# custom myNeopixel class. The program cycles through a predefined list
# of colors (red, green, blue, white, and off), displaying each color
# across all LEDs for 0.5 seconds.
#
# The brightness level is set globally before entering the loop.
# The effect runs continuously until interrupted.
#
# GPIO Pin Connections:
# NeoPixel Data In -> GPIO16
# 5V               -> External 5V supply (recommended)
# GND              -> Common ground with Pico
#
# Notes:
# - Requires neopixel.py containing the myNeopixel class.
# - NeoPixels use RGB color values (0–255 per channel).
# - brightness() scales overall intensity (0–255).
# - Saved as main.py to auto-run on power-up.
#
#######

import time
from machine import Pin
from neopixel import myNeopixel

# Number of LEDs in the strip
NUM_LEDS = 8

# Initialize NeoPixel object
# Parameters: (number_of_leds, GPIO_pin)
np = myNeopixel(NUM_LEDS, 16)

# Define RGB color tuples
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
white = (255, 255, 255)
close = (0, 0, 0)  # LEDs off

# List of colors to cycle through
COLORS = [red, green, blue, white, close]

# Set global brightness (0–255)
np.brightness(10)  # Low brightness to reduce power draw

while True:
    # Loop through each predefined color
    for color in COLORS:

        # Set all LEDs to the current color
        np.fill(color[0], color[1], color[2])

        # Update the strip to display changes
        np.show()

        # Wait before changing to the next color
        time.sleep(0.5)
  

#######
#
# Module: NeoPixel (WS2812) Driver using PIO
# Based on open-source WS2812 PIO examples from the Raspberry Pi Foundation
# and MicroPython community.
#
# Adapted and documented by Denis Legault
# Date: 2026-02-10
# Python File: neopixel.py
# Hardware: Raspberry Pi Pico / Pico 2 W,
#           WS2812 / NeoPixel LED strip
#
# Description:
# Provides a custom NeoPixel driver using the RP2040/RP2350 PIO (Programmable
# I/O) subsystem for precise timing control required by WS2812 LEDs.
#
# The module defines:
# - A PIO assembly routine (ws2812) to generate the required waveform
# - A myNeopixel class to manage LED buffers, brightness control,
#   gradients, rotation, and display updates
#
# NeoPixels require strict timing (800kHz data stream). This implementation
# offloads signal generation to PIO hardware, ensuring accurate and stable
# communication without blocking the CPU.
#
# Notes:
# - Uses 24-bit GRB color format (8 bits per channel).
# - Brightness is software-scaled before transmission.
# - Requires 5V power supply for most LED strips.
# - Ground must be shared between Pico and LED strip.
#
#######

import array, time
from machine import Pin
import rp2


# ------------------------------------------------------------
# PIO Assembly Program for WS2812
# ------------------------------------------------------------
# Generates precise timing signals required by NeoPixel LEDs.
# This runs independently in hardware (PIO state machine).
# ------------------------------------------------------------
@rp2.asm_pio(
    sideset_init=rp2.PIO.OUT_LOW,
    out_shiftdir=rp2.PIO.SHIFT_LEFT,
    autopull=True,
    pull_thresh=24
)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 8

    wrap_target()
    label("bitloop")
    out(x, 1)              .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")  .side(1)    [T1 - 1]
    jmp("bitloop")         .side(1)    [T2 - 1]
    label("do_zero")
    nop()                  .side(0)    [T2 - 1]
    wrap


# ------------------------------------------------------------
# NeoPixel Class
# ------------------------------------------------------------
class myNeopixel:
    def __init__(self, num_leds, pin, delay_ms=1):
        """
        Initialize NeoPixel driver.

        :param num_leds: Number of LEDs in the strip
        :param pin: GPIO pin used for data output
        :param delay_ms: Delay after updating LEDs (stability)
        """

        # Create pixel buffer (32-bit integers per LED)
        self.pixels = array.array("I", [0 for _ in range(num_leds)])

        # Use State Machine 0
        self.state_machine = 0

        # Initialize PIO state machine with 8 MHz frequency
        self.sm = rp2.StateMachine(
            self.state_machine,
            ws2812,
            freq=8000000,
            sideset_base=Pin(pin)
        )

        # Activate state machine
        self.sm.active(1)

        self.num_leds = num_leds
        self.delay_ms = delay_ms
        self.brightnessvalue = 255  # Default full brightness

    # --------------------------------------------------------
    # Brightness Control
    # --------------------------------------------------------
    def brightness(self, brightness=None):
        """
        Get or set global brightness (1–255).
        """
        if brightness is None:
            return self.brightnessvalue
        else:
            if brightness < 1:
                brightness = 1
            if brightness > 255:
                brightness = 255

            self.brightnessvalue = brightness

    # --------------------------------------------------------
    # Gradient between two pixels
    # --------------------------------------------------------
    def set_pixel_line_gradient(
        self,
        pixel1,
        pixel2,
        left_r,
        left_g,
        left_b,
        right_r,
        right_g,
        right_b
    ):
        """
        Create a color gradient between two pixel positions.
        """
        if pixel2 - pixel1 == 0:
            return

        right_pixel = max(pixel1, pixel2)
        left_pixel = min(pixel1, pixel2)

        for i in range(right_pixel - left_pixel + 1):
            fraction = i / (right_pixel - left_pixel)
            red = round((right_r - left_r) * fraction + left_r)
            green = round((right_g - left_g) * fraction + left_g)
            blue = round((right_b - left_b) * fraction + left_b)

            self.set_pixel(left_pixel + i, red, green, blue)

    # --------------------------------------------------------
    # Set solid color across a pixel range
    # --------------------------------------------------------
    def set_pixel_line(self, pixel1, pixel2, r, g, b):
        for i in range(pixel1, pixel2 + 1):
            self.set_pixel(i, r, g, b)

    # --------------------------------------------------------
    # Set individual pixel color
    # --------------------------------------------------------
    def set_pixel(self, pixel_num, r, g, b):
        """
        Set a single pixel color with brightness scaling.
        WS2812 uses GRB format internally.
        """

        # Apply brightness scaling
        blue = round(b * (self.brightness() / 255))
        red = round(r * (self.brightness() / 255))
        green = round(g * (self.brightness() / 255))

        # Store packed GRB value
        self.pixels[pixel_num] = blue | red << 8 | green << 16

    # --------------------------------------------------------
    # Rotate pixel buffer left
    # --------------------------------------------------------
    def rotate_left(self, num_of_pixels):
        if num_of_pixels is None:
            num_of_pixels = 1
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    # --------------------------------------------------------
    # Rotate pixel buffer right
    # --------------------------------------------------------
    def rotate_right(self, num_of_pixels):
        if num_of_pixels is None:
            num_of_pixels = 1
        num_of_pixels = -1 * num_of_pixels
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    # --------------------------------------------------------
    # Send pixel data to LED strip
    # --------------------------------------------------------
    def show(self):
        """
        Transmit pixel buffer to LEDs via PIO.
        """
        for i in range(self.num_leds):
            self.sm.put(self.pixels[i], 8)

        # Small delay ensures data latch timing
        time.sleep_ms(self.delay_ms)

    # --------------------------------------------------------
    # Fill entire strip with one color
    # --------------------------------------------------------
    def fill(self, r, g, b):
        """
        Set all LEDs to a single color.
        """
        for i in range(self.num_leds):
            self.set_pixel(i, r, g, b)

        time.sleep_ms(self.delay_ms)
  

#######
#
# Project: NeoPixel Rainbow Animation
# Based on open-source WS2812 PIO examples from the Raspberry Pi Foundation
# and MicroPython community.
#
# Adapted and documented by Denis Legault
# Date:    2026-02-12
# Python File: main.py
# Hardware: Raspberry Pi Pico 2 W,
#           8x WS2812 / NeoPixel LEDs connected to GPIO16
#
# Description:
# Demonstrates a moving rainbow animation across a NeoPixel strip.
# A color wheel function generates smooth RGB transitions, and each
# LED is offset slightly to create a flowing rainbow effect.
#
# The animation continuously cycles through 0–254 color positions,
# producing a seamless moving rainbow pattern.
#
# GPIO Pin Connections:
# NeoPixel Data In -> GPIO16
# 5V               -> External 5V supply (recommended)
# GND              -> Common ground with Pico
#
# Notes:
# - Requires neopixel.py containing the myNeopixel class.
# - Uses 24-bit RGB color values (0–255 per channel).
# - Brightness is limited to reduce current draw.
# - Saved as main.py to auto-run on power-up.
#
#######

from machine import Pin
from neopixel import myNeopixel
import time

# Number of LEDs in the strip
NUM_LEDS = 8

# Initialize NeoPixel object on GPIO16
np = myNeopixel(NUM_LEDS, 16)

# Global RGB values updated by wheel()
red = 0
green = 0
blue = 0


# ------------------------------------------------------------
# Color Wheel Function
# ------------------------------------------------------------
# Generates smooth RGB transitions across a 0–254 range.
# This creates a full rainbow spectrum.
# ------------------------------------------------------------
def wheel(pos):
    global red, green, blue

    WheelPos = pos % 255  # Ensure value wraps around 0–254

    # Red -> Green transition
    if WheelPos < 85:
        red = (255 - WheelPos * 3)
        green = (WheelPos * 3)
        blue = 0

    # Green -> Blue transition
    elif WheelPos < 170:
        WheelPos -= 85
        red = 0
        green = (255 - WheelPos * 3)
        blue = (WheelPos * 3)

    # Blue -> Red transition
    else:
        WheelPos -= 170
        red = (WheelPos * 3)
        green = 0
        blue = (255 - WheelPos * 3)


# Set global brightness (0–255)
np.brightness(20)  # Lower brightness reduces power consumption

while True:
    # Cycle through full color wheel range
    for i in range(0, 255):

        # Update each LED with an offset to create moving effect
        for j in range(0, NUM_LEDS):
            wheel(i + j * 255 // NUM_LEDS)
            np.set_pixel(j, red, green, blue)

        # Send updated pixel data to strip
        np.show()

        # Short delay controls animation speed
        time.sleep_ms(1)