moving-rainbow

Generate MicroPython programs for the Moving Rainbow LED strip educational project using Raspberry Pi Pico with NeoPixel strips and button controls.

⭐4stars🔀1forks📁View on GitHub🕐Updated Dec 11, 2025

When & Why to Use This Skill

The Moving Rainbow skill is a specialized MicroPython program generator tailored for Raspberry Pi Pico and NeoPixel (WS2812B) LED projects. It simplifies the development of complex LED animations—such as rainbow cycles, comet tails, and random color effects—while integrating hardware configurations and interactive button controls. Designed with educational principles in mind, it provides clean, commented, and modular code templates that help students and hobbyists master embedded systems programming and hardware-software interaction.

Use Cases

  • STEM Education: Quickly generate structured MicroPython code for classroom LED projects to teach students about loops, variables, and hardware control.
  • Interactive Lighting Design: Create multi-mode LED strips that respond to physical button presses for DIY home decor or art installations.
  • Rapid Prototyping: Use pre-defined templates for NeoPixel animations like 'Rainbow Cycle' or 'Comet Tail' to speed up development on the RP2040 platform.
  • Learning Hardware Integration: Provide beginners with best-practice code for debouncing buttons and managing GPIO pins on the Raspberry Pi Pico.
namemoving-rainbow
descriptionGenerate MicroPython programs for the Moving Rainbow LED strip educational project using Raspberry Pi Pico with NeoPixel strips and button controls.

Moving Rainbow MicroPython Program Generator

This skill helps create MicroPython programs for the Moving Rainbow educational project. Use this skill when the user asks to create LED animations, NeoPixel programs, or Moving Rainbow examples for Raspberry Pi Pico.

Hardware Configuration

The default hardware setup consists of:

  • Microcontroller: Raspberry Pi Pico (RP2040)
  • LED Strip: 30-pixel NeoPixel/WS2812B addressable LED strip connected to GPIO pin 0
  • Input Controls: Two momentary push buttons
    • Button 1: GPIO pin 14
    • Button 2: GPIO pin 15
  • Built-in LED: GPIO pin 25 (can be used for status indication)

Configuration values are stored in a config.py file that should be imported by programs. See the references/config.py file for the standard configuration template.

Code Structure and Patterns

Basic Program Template

All programs should follow this structure:

from machine import Pin
from neopixel import NeoPixel
from utime import sleep
import config

# Initialize the LED strip
strip = NeoPixel(Pin(config.NEOPIXEL_PIN), config.NUMBER_PIXELS)

# Your code here

while True:
    # Animation loop
    pass

Essential Components

  1. Imports: Always import from machine, neopixel, utime, and the config module
  2. Strip Initialization: Create the NeoPixel object using configuration values
  3. Main Loop: Use a while True: loop for continuous animations
  4. Color Format: Colors are RGB tuples like (red, green, blue) with values 0-255

Common Functions and Patterns

Color Wheel Function

For smooth rainbow transitions, use the standard color wheel function:

def wheel(pos):
    # Input a value 0 to 255 to get a color value.
    # The colors 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)

Strip Control Patterns

Setting pixels:

strip[index] = (red_value, green_value, blue_value)
strip.write()  # Always call write() to display changes

Erasing the strip:

def erase():
    for i in range(0, config.NUMBER_PIXELS):
        strip[i] = (0, 0, 0)
    strip.write()

Using a counter with modulo for wrapping:

counter = 0
while True:
    # Use counter for position
    strip[counter] = color
    strip.write()
    sleep(delay)

    counter += 1
    counter = counter % config.NUMBER_PIXELS  # Wrap around

Button Integration

For interactive programs with button controls:

from machine import Pin
from utime import ticks_ms
import config

BUTTON_PIN_1 = config.BUTTON_PIN_1
BUTTON_PIN_2 = config.BUTTON_PIN_2

button1 = Pin(BUTTON_PIN_1, Pin.IN, Pin.PULL_DOWN)
button2 = Pin(BUTTON_PIN_2, Pin.IN, Pin.PULL_DOWN)

last_time = 0

def button_pressed_handler(pin):
    global mode, last_time
    new_time = ticks_ms()
    # Debounce: require 200ms between button presses
    if (new_time - last_time) > 200:
        pin_num = int(str(pin)[4:6])
        if pin_num == BUTTON_PIN_1:
            # Button 1 action (e.g., increment mode)
            mode += 1
        else:
            # Button 2 action (e.g., decrement mode)
            mode -= 1
        last_time = new_time

# Register interrupt handlers
button1.irq(trigger=Pin.IRQ_FALLING, handler=button_pressed_handler)
button2.irq(trigger=Pin.IRQ_FALLING, handler=button_pressed_handler)

Common Animation Patterns

Moving Dot

def move_dot(counter, color, delay):
    strip[counter] = color
    strip.write()
    sleep(delay)
    strip[counter] = (0, 0, 0)

Color Wipe

def color_wipe(color, delay):
    for i in range(config.NUMBER_PIXELS):
        strip[i] = color
        strip.write()
        sleep(delay)

Rainbow Cycle

def rainbow_cycle(counter, delay):
    percent_color_wheel = round(255 / config.NUMBER_PIXELS)
    for i in range(0, config.NUMBER_PIXELS):
        color_index = round(i * percent_color_wheel)
        color = wheel(color_index)
        strip[(i + counter) % config.NUMBER_PIXELS] = color
        strip.write()
    sleep(delay)

Comet Tail Effect

def comet_tail(counter, color, tail_length, delay):
    levels = [255, 128, 64, 32, 16, 8, 4, 2, 1]
    for i in range(0, tail_length):
        target = (counter - i) % config.NUMBER_PIXELS
        scale = levels[i] / 255
        strip[target] = (int(color[0]*scale), int(color[1]*scale), int(color[2]*scale))
    strip.write()
    sleep(delay)

Random Effects

from urandom import randint

def random_color(delay):
    random_offset = randint(0, config.NUMBER_PIXELS - 1)
    random_color_value = randint(0, 255)
    strip[random_offset] = wheel(random_color_value)
    strip.write()
    sleep(delay)

Multi-Mode Programs

For programs with multiple animation modes that can be switched with buttons:

mode_list = ['moving rainbow', 'red dot', 'blue dot', 'candle flicker', 'random']
mode_count = len(mode_list)
mode = 0
last_mode = -1

while True:
    # Print mode changes
    if mode != last_mode:
        print('mode=', mode, 'running', mode_list[mode])
        last_mode = mode

    # Execute the current mode
    if mode == 0:
        moving_rainbow(counter, 0.05)
    elif mode == 1:
        move_dot(counter, red, 0.05)
    # ... more modes

    counter += 1
    counter = counter % config.NUMBER_PIXELS

Standard Color Definitions

Use these common color constants:

red = (255, 0, 0)
orange = (255, 60, 0)
yellow = (255, 150, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
cyan = (0, 255, 255)
indigo = (75, 0, 130)
violet = (138, 43, 226)
white = (128, 128, 128)
off = (0, 0, 0)

Educational Principles

When generating programs, follow these educational guidelines:

  1. Progressive Complexity: Start simple and add features incrementally
  2. Clear Comments: Explain what each section does for learning purposes
  3. Consistent Naming: Use descriptive variable names (e.g., counter, delay, color)
  4. Visible Feedback: Use print statements to show what's happening
  5. Adjustable Parameters: Use constants for delays and other values so students can experiment

Best Practices

  1. Always call strip.write() after modifying pixels to display changes
  2. Use modulo for wrapping: counter % config.NUMBER_PIXELS to loop animations
  3. Debounce buttons: Check that at least 200ms has passed between button presses
  4. Import config: Always use import config and reference config.NEOPIXEL_PIN, etc.
  5. Add delays: Include appropriate sleep() calls to control animation speed
  6. Clear pixels: Turn off pixels when moving animations to prevent trails
  7. Test boundary conditions: Ensure animations work correctly at pixel 0 and the last pixel

When to Use This Skill

Use this skill when:

  • Creating LED animation programs for Raspberry Pi Pico
  • Working with NeoPixel/WS2812B addressable LED strips
  • Building educational examples for the Moving Rainbow project
  • Implementing button-controlled LED effects
  • Generating MicroPython code for LED strip projects

Output Format

Generated programs should:

  • Be complete, runnable MicroPython code
  • Include necessary imports
  • Use the config module for hardware settings
  • Include helpful comments
  • Follow the established code patterns
  • Be educational and easy to understand