prosolis
469b321a40
Raspberry Pi supply is unreliable, and Circle is Broadcom-only - there is no Allwinner or Rockchip support anywhere in its tree, so an Orange Pi is not a board swap but a restart on an unproven base. RP2040/RP2350 is the better answer: available, ~$4, and a better fit for this job than the Zero ever was. Structure. All the visualizer logic moves to src/ and is now platform-independent, depending only on ILEDStrip (four methods) with MIDI pushed in via OnMIDIPacket(). Each platform supplies a backend and a main loop. The Circle build is unchanged in behaviour and still produces both kernel images. Pico backend: - WS2812B from a PIO state machine, which clocks the 1.25us bit cell directly rather than faking it with 8 SPI bytes per data bit as the Circle build must. - TinyUSB MIDI 1.0 device. Enumerates as an ordinary ALSA port, as the Circle gadget does. Packet framing comes from the USB MIDI Code Index Number rather than being re-derived. - Mount, unmount, suspend and resume all clear held notes, so a chord held when the host goes away cannot stay lit. - Latch spacing is enforced against a timestamp, so a caller cannot start a frame inside the WS2812B reset window. Verified: builds clean for both pico (RP2040, 30052 bytes) and pico2 (RP2350, 28284 bytes), no warnings from project sources, and the Circle build still produces kernel.img and kernel7.img. Tests pass across nine configurations. Incidental findings. PIO frees both hardware SPI blocks; on a Pi Zero Circle exposes only one SPI master (DEVICES=1 for RASPPI<4) and the WS2812B driver monopolises it, so a display and the strip could not coexist there. RP2040/ RP2350 also support USB host and, on the W variants, BLE via btstack - both of which section 3a records as impossible on Circle. Also documents a known limitation found while looking at calibration: the note-to-LED map is linear in semitone index, but a keybed is not. 52 white keys span the same 1222mm, making one white key ~3.38 LEDs rather than 2. The error drifts within each octave, worst at F, by up to ~0.87 LEDs (~6mm) even after an optimal offset and scale. A geometric map would remove it. Not yet implemented. Claude-Session: https://claude.ai/code/session_01TVCB25LBsmeteWvaSMz4Ne
109 lines
2.3 KiB
C++
109 lines
2.3 KiB
C++
//
|
|
// picostrip.cpp
|
|
//
|
|
#include "picostrip.h"
|
|
#include "ws2812.pio.h"
|
|
#include "pico/stdlib.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
// WS2812B bit cell is 1.25us; the PIO program spends 10 cycles per bit.
|
|
static const float WS2812_FREQ = 800000.0f;
|
|
|
|
// Datasheet reset is >50us of low. 300us is the commonly used safe value and
|
|
// costs nothing at this frame rate.
|
|
static const uint64_t WS2812_RESET_US = 300;
|
|
|
|
CPicoLEDStrip::CPicoLEDStrip (unsigned nLEDCount, unsigned nPin)
|
|
: m_nLEDCount (nLEDCount),
|
|
m_nPin (nPin),
|
|
m_pBuffer (nullptr),
|
|
m_PIO (nullptr),
|
|
m_nSM (0),
|
|
m_nOffset (0),
|
|
m_bInitialized (false),
|
|
m_nLastFrameUs (0)
|
|
{
|
|
}
|
|
|
|
CPicoLEDStrip::~CPicoLEDStrip (void)
|
|
{
|
|
free (m_pBuffer);
|
|
m_pBuffer = nullptr;
|
|
}
|
|
|
|
bool CPicoLEDStrip::Initialize (void)
|
|
{
|
|
m_pBuffer = (uint32_t *) calloc (m_nLEDCount, sizeof (uint32_t));
|
|
if (m_pBuffer == nullptr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Let the SDK place the program on whichever PIO block has room, so
|
|
// this cannot collide with anything else added later.
|
|
if (!pio_claim_free_sm_and_add_program_for_gpio_range (
|
|
&ws2812_program, &m_PIO, &m_nSM, &m_nOffset, m_nPin, 1, true))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ws2812_program_init (m_PIO, m_nSM, m_nOffset, m_nPin, WS2812_FREQ);
|
|
|
|
m_bInitialized = true;
|
|
m_nLastFrameUs = time_us_64 ();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CPicoLEDStrip::SetLED (unsigned nIndex, uint8_t nRed, uint8_t nGreen, uint8_t nBlue)
|
|
{
|
|
if (nIndex >= m_nLEDCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// WS2812B wants GRB. The PIO shifts out MSB first with a 24-bit
|
|
// threshold, so the triple is left-justified in the word.
|
|
m_pBuffer[nIndex] = ((uint32_t) nGreen << 24)
|
|
| ((uint32_t) nRed << 16)
|
|
| ((uint32_t) nBlue << 8);
|
|
}
|
|
|
|
void CPicoLEDStrip::WaitForLatch (void)
|
|
{
|
|
uint64_t nElapsed = time_us_64 () - m_nLastFrameUs;
|
|
if (nElapsed < WS2812_RESET_US)
|
|
{
|
|
busy_wait_us (WS2812_RESET_US - nElapsed);
|
|
}
|
|
}
|
|
|
|
bool CPicoLEDStrip::Update (void)
|
|
{
|
|
if (!m_bInitialized)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
WaitForLatch ();
|
|
|
|
for (unsigned i = 0; i < m_nLEDCount; i++)
|
|
{
|
|
// Blocking push. The FIFO drains at 800kbit/s, so this paces the
|
|
// loop naturally and needs no DMA at this strip length.
|
|
pio_sm_put_blocking (m_PIO, m_nSM, m_pBuffer[i]);
|
|
}
|
|
|
|
m_nLastFrameUs = time_us_64 ();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPicoLEDStrip::Blackout (void)
|
|
{
|
|
memset (m_pBuffer, 0, m_nLEDCount * sizeof (uint32_t));
|
|
|
|
return Update ();
|
|
}
|