Picolight

A project where I try to create as good a project as possible for handling LED lights on the Raspberry Pico.

The idea is to create one as fast and versatile as possible.

This is done by creating algorithms that require virtually no memory, and have very high refresh rates.

Basic overview

The main concepts of the whole project are:

Pattern Module

The main driver of a particular type of LED theme. This could be rainbow or snake or similar.
Pattern Data

Instance of Pattern Module attributes, randomly calculated once at Pattern Module start.
Pattern Intensity

Used when creating Pattern Data. Advices random attributes on behavior.
Pattern Data Creator

Creates Pattern Data. Takes parameters number of lights (len), and intensity.
Pattern Data Destroyer

Handles freeing of memory allocated by Pattern Data Creator.
Frame Data

Frame attributes, created once at beginning of frame (time of first light in loop).

Caches values which are common between multiple pixels.
Frame Creator

Creates Frame Data. Takes parameters number of lights (len) and time (t).
Frame Destroyer

Handles the freeing of memory allocated by Frame Creator.
Pattern Executor

Does final calculations that are then return a HsiaColor pixel.

Pixels are streamed as much as possible, so to not keep them in memory. Refresh rate is only limit.

How the rendering pipeline can work

Simple

Enter main() (picolight.c)
Enter endless loop which calls execute_for_led_pin (in theory we could have multiple pins/strips, but not yet fully implemented)
Run pattern_execute, send along current time (pattern.c)
If a next pattern has been set, then initialize that pattern
- Get the pattern module, run its Data Creator.
- Save the data to global state (this hinders multiple strips, for now)
Get current pattern module
Create Frame Data based on current time
Run loop over each LED light index
Run Pattern Executor, sending along light index, Pattern Data, Frame Data and default Pattern Printer
Do whatever inside the executor, but as extremely few calculations as possible
Return output pixel as HsiaColor
Calls the final target, be it to the Pico pin or to elsewhere
After all pixels are printed, destroy Frame Data
Repeat from 3. over and over

Complex

What can be done at 9. is to send along to one or multiple other Pattern Modules. This way we can create composite patterns. A somewhat simplified example is the Snakes module, which just prints multiple snakes.

static inline HsiaColor executor(uint16_t i, void *dataPtr, void *framePtr)
{
    data_struct *data = dataPtr;
    frame_struct *frame = framePtr;

    HsiaColor a = data->snakeModule->executor(i, data->snake1data, frame->frame1);
    HsiaColor b = data->snakeModule->executor(i, data->snake2data, frame->frame2);

    return math_average_hsia(&a, &b);
}

Future plans