Is there a way to Speed this Up?

[FlightDataRecorder]

This is a test program to learn how to use the Library, not my final program.

But is there a way to speed up the execution of this program on an RP2040? i.e. using Hardware SPI or something?

//          --=[ RP2040 Test ]=---
// Test_RP2040.ino

/*************************************************************************************************/
// Includes
#include <NeoPixelBus.h>
/*************************************************************************************************/
//  Defines

/*************************************************************************************************/
// Global Constants
const static int iBAUD_RATE = 9600;
const static int iPIXEL_COUNT = 300;      // # Pixels in a 5 Meter strip (at 60 Pixels per Meter.)
const static int iPIXEL_PIN_LEFT = 15;    // Treat as const
const static int iPIXEL_PIN_RIGHT = 16;   // Treat ss const
const static NeoGamma<NeoGammaTableMethod> ngtm;

/*************************************************************************************************/
// Global Variables
static NeoPixelBus<NeoRgbwFeature, Rp2040x4Pio1Sk6812Method> npbLeft(iPIXEL_COUNT, iPIXEL_PIN_LEFT); // note: RGBW and Sk6812 and smaller strip
static NeoPixelBus<NeoRgbwFeature, Rp2040x4Pio1Sk6812Method> npbRight(iPIXEL_COUNT, iPIXEL_PIN_RIGHT); // note: RgBW and Sk6812 and smaller strip

/*************************************************************************************************/
void setup() {
  while (!Serial) {
    delay(1);
  }
  delay(1000);
  Serial.begin(iBAUD_RATE);
  Serial.println("\t\t---=[ Test_RP2040 ]=---");

  npbLeft.Begin();
  npbRight.Begin();
  npbLeft.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, 0)));
  npbRight.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, 0)));
  npbLeft.Show(true);
  npbRight.Show(true);

  Serial.println("Calling ColorTest()");
  ColorTest();
}

/*************************************************************************************************/
void loop() { ; }
/*************************************************************************************************/
/*************************************************************************************************/
/*************************************************************************************************/
// Purpose: Easy Test while installing Strip Lights.
void ColorTest() {
  static unsigned long ulStartTime = 0L;
  static unsigned long ulStopTime = 0L;
  
  while(true) {
    ulStartTime = micros();

    // Red
    Serial.print("Red, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(y, 0, 0, 0)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(y, 0, 0, 0)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }

    // Green
    Serial.print("Green, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(0, y, 0, 0)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(0, y, 0, 0)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }

    // Blue
    Serial.print("Blue, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(0, 0, y, 0)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(0, 0, y, 0)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }

    // White
    Serial.print("White, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, y)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, y)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }

    // White+RGB
    Serial.print("White+RGB, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(y, y, y, y)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(y, y, y, y)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }

    // Black
    Serial.print("Black, ");
    for(int y=0 ; y<255 ; y++) {
      npbLeft.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, 0)));
      npbRight.ClearTo(ngtm.Correct(RgbwColor(0, 0, 0, 0)));
      npbLeft.Show(false);
      npbRight.Show(false);
    }
    ulStopTime = micros();
    Serial.println(ulStopTime-ulStartTime);
  }
}
/*************************************************************************************************/

Output shows:

        Red, Green, Blue, White, White+RGB, Black, 18492183
        Red, Green, Blue, White, White+RGB, Black, 18492214
        Red, Green, Blue, White, White+RGB, Black, 18492126

It takes ~18.5 seconds to make 1800 changes.
    (60 Pixels per Meter in a 5 Meter Strip, * 6 Colors (R, G, B, W, W+RGB, Black).)
    (18.5 / 1800 = 0.010277778 Seconds, or about 10 updates a second.)

Also I'm using RGBW everywhere, which should take parameters in the order Red, Green, Blue, White,
but when I run it Green shows up first, followed by Red; it appears that the Red & Green are reversed.

Is there a way to make the intensity appear more linear?  i.e. 0x7F7F7F7F appears half as bright as 0xFFFFFFFF.

Thanks

[Makuna]

For speed testing, DO NOT put Serial.print() calls inside your speed test loop. They are extremely slow compared to what you are doing. Just capture the timing and print it outside your time capture area.

Show will block until the last send is complete. Once it starts to send the current frame you requested, the method returns and sends it in the background so you can prepare the next frame while it sends it out (this Async functionality is only available on some platforms, but the RP2040 is one of them). The send protocol of 300 pixels is ~1.25us per bit, so 300 pixels * 4 bytes (RGBW) * 8 bits * 1.24us = 11,904us. Plus the 300us reset time required between sends and a little overhead to copy data, should be around 13 to 14ms. Everything else is your sketch preparing the next frame.
*Note, in your case, its each "set" of shows, since they are sent in parallel together after the last show of your pair.

For the non-linear intensity, this is how the LEDs work, and you can use the NeoPixelBusLg or the correct use of the NeoGamma classes to provide the "normalization" so it looks linear.
I am confused how this line even compiles in your sketch as its not the correct use of NeoGamma class.

const static NeoGamma ngtm;

The NeoGamma class requires a template specializer and doesn't have a default one; so, this should fail the compile step. It should be.

const static NeoGamma<NeoGammaTableMethod> ngtm;

Many examples demonstrate the correct use.

Is there a reason you are using the Gamma feature outside of just using NeoPixelBusLg?
For speed, use this definition of it...

NeoPixelBusLg<NeoGrbwFeature, Rp2040x4Pio1Sk6812Method, NeoGammaTableMethod> strip(PixelCount, PixelPin);

For the color order issue, use a different feature. You are using NeoRgbwFeature, it sounds like you need to use NeoGrbwFeature. Grb order is very common and many of the samples use this one. It still takes a RgbwColor object, but it translates the order for you.

[FlightDataRecorder]

Makuna;

    Thanks so much for your quick reply!

    I removed Serial.print from measured time (made no measurable difference.)

    You asked "Is there a reason you are using the Gamma feature outside of just using NeoPixelBusLg?"
    Well, that's because I don't know WTF I'm doing.

    I'm now using NeoPixelBusLg<NeoGrbwFeature, Rp2040x4Pio1Sk6812Method, NeoGammaTableMethod> strip(PixelCount, `PixelPin); 
and it seems that I still need to use ngtm.Correct to appear linear.
    Q: Is that correct or should it be linear without calling that?


    Thanks again!
    Ken_S.

[Makuna]

If you are using NeoPixelBusLg, then you don't need to do any Gamma correction. Its already being done inside the NeoPixelBusLg.

The best way to test linear is to blend from black {0,0,0} to a solid green color {0,255,0} across the complete strip. Our eyes are more sensitive to green than red or blue. Then look at the strip in whole to see if it's not linear. Include a photo.

    for(int pixel=0 ; pixel<iPIXEL_COUNT ; pixel++) 
    {
      RgbwColor color = RgbwColor.LinearBlend({0,0,0,0}, {0,255,0,0}, (float)iPIXEL_COUNT / pixel);
      npbLeft.SetPixelColor(pixel, color);
    }
    npbLeft.Show(false);