ws2812b on nano 7strip ?max pixels

Other Hardware LEDs and Multiplexing
1

Hi i got a setup on a nano using 7stripes of 42neopix workes fine on direct programming
using the simplescroll example from here

as always people want bigger as me 2

i found
FastLED -> LEDMatrix-LEDText
woudt fit my futhere needs

QUESTION
How many Pixels per Stripe ((7Stripes)) can the NANO cope with on Memory
or is it calculated on the Fly
the MAX i woudt go is 7x300pixel

and the max display effect woudt be a full Rainbow moving along
or a Text displayd with every second letter inverted 7x5 Font one row (1pixel horizontal 7 Vertical) offset

CAN This be done ?

did not find a answer here in the forum search
THANK You

2

Each pixel requires 3 bytes of ram memory. Nano has 2048 bytes. But some bytes are reserved, and your sketch will need some ram for other purposes. So perhaps 80x7.

3

can i use a external RAM eeprom things like that im not that hard programmer to do

4

bmbbsr:
How many Pixels per Stripe ((7Stripes)) can the NANO cope with on Memory
or is it calculated on the Fly
the MAX i woudt go is 7x300pixel

Answer: both is possible. It depends on what you want to do.
Using memory limits your led numbers but makes response quicker. I ran out at around 200 leds.
Calculating on the fly will make response slow, especially if many leds need to be changed at one time. But the led numbers possible is increased greatly.

In the christmas lighting thread i have my codes for on the fly calculation using neopixel. I rely on the fact that the ws28xx chips maintain the last color until being told otherwise. So each pass i only change the required few pixels. This gives a slim code with little memory requirements. But it takes up a lot of processing time once the leds that need to be changed are increased too much....running 15 led changes per pass my code runs 2ms. Using 2100 leds a full pass will take about 300ms....if you are happy with a 3hz refresh rate you might be able to cope with it. (I dont know how large the memory demand for the fastled running on 2100 lights is is, this might be the limiting factor).

I would take a look at the newer nano 33 series. They have 8x the clockrate and 2mb memory....that will open your door to snappy response even with cloggy codes....

5

thanks most here take a ESP32 now
at the cost efficancy
or more teeny3.2

6

One can use a devie like the ALITOVE WS2812B WS2811 SPI Signal Amplifier Repeater, which connects to the MicroCOntroller via SPI and talks to multiple groupings of LEDs, extending the number of LEDs one can use.

7

Idahowalker:
extending the number of LEDs one can use.

Not if ram memory is the limiting factor.

8

It is possible to drive a 7 x 300 pixel display with a nano, but its unlikely anyone has written a library for that, so you will have to handle more of the programming yourself. FastLED does allow for running multiple LED strips using a common pixel buffer, so you only need enough memory for 300 LEDs, plus a bit of overhead for each strip.

Here is a sample code to scroll text, I believe it will work, but only have a single strip to test with so cannot see the full effect here. The fastest refresh rate I've been able to achieve is around 150mS, but it varies with the exact pixel pattern being displayed, so I've included a timer to set the refresh at a fixed rate of 200mS.

#include <FastLED.h>

//ASCII code from <space> through <delete>
//decimal 32 to 127
//hex 0x20 to 0x7F

//font borrowed from github.com/bigjosh/MacroMarquee

const uint8_t Font5x7[][5] PROGMEM = {
0x00,0x00,0x00,0x00,0x00,// <space> 
0x00,0x00,0xfa,0x00,0x00,// !
0x00,0xe0,0x00,0xe0,0x00,// "
0x28,0xfe,0x28,0xfe,0x28,// #
0x24,0x54,0xfe,0x54,0x48,// $
0xc4,0xc8,0x10,0x26,0x46,// %
0x6c,0x92,0xaa,0x44,0x0a,// &
0x00,0xa0,0xc0,0x00,0x00,// '
0x00,0x38,0x44,0x82,0x00,// (
0x00,0x82,0x44,0x38,0x00,// )
0x10,0x54,0x38,0x54,0x10,// *
0x10,0x10,0x7c,0x10,0x10,// +
0x00,0x0a,0x0c,0x00,0x00,// ,
0x10,0x10,0x10,0x10,0x10,// -
0x00,0x06,0x06,0x00,0x00,// .
0x04,0x08,0x10,0x20,0x40,// /
0x7c,0x8a,0x92,0xa2,0x7c,// 0
0x00,0x42,0xfe,0x02,0x00,// 1
0x42,0x86,0x8a,0x92,0x62,// 2
0x84,0x82,0xa2,0xd2,0x8c,// 3
0x18,0x28,0x48,0xfe,0x08,// 4
0xe4,0xa2,0xa2,0xa2,0x9c,// 5
0x3c,0x52,0x92,0x92,0x0c,// 6
0x80,0x8e,0x90,0xa0,0xc0,// 7
0x6c,0x92,0x92,0x92,0x6c,// 8
0x60,0x92,0x92,0x94,0x78,// 9
0x00,0x6c,0x6c,0x00,0x00,// :
0x00,0x6a,0x6c,0x00,0x00,// ;
0x00,0x10,0x28,0x44,0x82,// <
0x28,0x28,0x28,0x28,0x28,// =
0x82,0x44,0x28,0x10,0x00,// >
0x40,0x80,0x8a,0x90,0x60,// ?
0x4c,0x92,0x9e,0x82,0x7c,// @
0x7e,0x88,0x88,0x88,0x7e,// A
0xfe,0x92,0x92,0x92,0x6c,// B
0x7c,0x82,0x82,0x82,0x44,// C
0xfe,0x82,0x82,0x44,0x38,// D
0xfe,0x92,0x92,0x92,0x82,// E
0xfe,0x90,0x90,0x80,0x80,// F
0x7c,0x82,0x82,0x8a,0x4c,// G
0xfe,0x10,0x10,0x10,0xfe,// H
0x00,0x82,0xfe,0x82,0x00,// I
0x04,0x02,0x82,0xfc,0x80,// J
0xfe,0x10,0x28,0x44,0x82,// K
0xfe,0x02,0x02,0x02,0x02,// L
0xfe,0x40,0x20,0x40,0xfe,// M
0xfe,0x20,0x10,0x08,0xfe,// N
0x7c,0x82,0x82,0x82,0x7c,// O
0xfe,0x90,0x90,0x90,0x60,// P
0x7c,0x82,0x8a,0x84,0x7a,// Q
0xfe,0x90,0x98,0x94,0x62,// R
0x62,0x92,0x92,0x92,0x8c,// S
0x80,0x80,0xfe,0x80,0x80,// T
0xfc,0x02,0x02,0x02,0xfc,// U
0xf8,0x04,0x02,0x04,0xf8,// V
0xfe,0x04,0x18,0x04,0xfe,// W
0xc6,0x28,0x10,0x28,0xc6,// X
0xc0,0x20,0x1e,0x20,0xc0,// Y
0x86,0x8a,0x92,0xa2,0xc2,// Z
0x00,0x00,0xfe,0x82,0x82,// [
0x40,0x20,0x10,0x08,0x04,// (backslash)
0x82,0x82,0xfe,0x00,0x00,// ]
0x20,0x40,0x80,0x40,0x20,// ^
0x02,0x02,0x02,0x02,0x02,// _
0x00,0x80,0x40,0x20,0x00,// `
0x04,0x2a,0x2a,0x2a,0x1e,// a
0xfe,0x12,0x22,0x22,0x1c,// b
0x1c,0x22,0x22,0x22,0x04,// c
0x1c,0x22,0x22,0x12,0xfe,// d
0x1c,0x2a,0x2a,0x2a,0x18,// e
0x10,0x7e,0x90,0x80,0x40,// f
0x10,0x28,0x2a,0x2a,0x3c,// g
0xfe,0x10,0x20,0x20,0x1e,// h
0x00,0x22,0xbe,0x02,0x00,// i
0x04,0x02,0x22,0xbc,0x00,// j
0x00,0xfe,0x08,0x14,0x22,// k
0x00,0x82,0xfe,0x02,0x00,// l
0x3e,0x20,0x18,0x20,0x1e,// m
0x3e,0x10,0x20,0x20,0x1e,// n
0x1c,0x22,0x22,0x22,0x1c,// o
0x3e,0x28,0x28,0x28,0x10,// p
0x10,0x28,0x28,0x18,0x3e,// q
0x3e,0x10,0x20,0x20,0x10,// r
0x12,0x2a,0x2a,0x2a,0x04,// s
0x20,0xfc,0x22,0x02,0x04,// t
0x3c,0x02,0x02,0x04,0x3e,// u
0x38,0x04,0x02,0x04,0x38,// v
0x3c,0x02,0x0c,0x02,0x3c,// w
0x22,0x14,0x08,0x14,0x22,// x
0x30,0x0a,0x0a,0x0a,0x3c,// y
0x22,0x26,0x2a,0x32,0x22,// z
0x00,0x10,0x6c,0x82,0x00,// {
0x00,0x00,0xfe,0x00,0x00,// |
0x00,0x82,0x6c,0x10,0x00,// }
0x10,0x10,0x54,0x38,0x10,// ~
0x10,0x38,0x54,0x10,0x10,// <delete>
};

const uint16_t NUM_LEDS = 300; //300 LEDs per strip
const uint8_t NUM_STRIPS = 7; //7 strips
const uint8_t ledRow0 = 2; //each strip connects to a different output pin
const uint8_t ledRow1 = 3; //would be better to use an array, but FastLED.addLeds requires a pin number
const uint8_t ledRow2 = 4;
const uint8_t ledRow3 = 5;
const uint8_t ledRow4 = 6;
const uint8_t ledRow5 = 7;
const uint8_t ledRow6 = 8;

CRGB leds[NUM_LEDS]; //single pixel buffer shared by all the LED strips
uint8_t gBrightness = 128; //have to control the global brightness manually

char scrollText[64] = "This is a test 0123";
unsigned long currentMillis;
unsigned long startMillis;
unsigned long scrollDelay = 200u;

byte asciiPattern;
uint32_t textColor = CRGB::Orange;
int textLength;
int textStartPosition;
int scrollCharacter;

void setup() {
  //Serial.begin(57600);
  FastLED.addLeds<WS2812, ledRow0, GRB>(leds, NUM_LEDS); //GRB may be incorrect for your LEDs
  FastLED.addLeds<WS2812, ledRow1, GRB>(leds, NUM_LEDS); //may need to be changed to RGB
  FastLED.addLeds<WS2812, ledRow2, GRB>(leds, NUM_LEDS);
  FastLED.addLeds<WS2812, ledRow3, GRB>(leds, NUM_LEDS);
  FastLED.addLeds<WS2812, ledRow4, GRB>(leds, NUM_LEDS);
  FastLED.addLeds<WS2812, ledRow5, GRB>(leds, NUM_LEDS);
  FastLED.addLeds<WS2812, ledRow6, GRB>(leds, NUM_LEDS);

  textLength = strlen(scrollText); //number of characters to scroll
  textStartPosition = NUM_LEDS + 1; // start text off the right edge of display
}

void loop() {
  currentMillis = millis();
  if ((currentMillis - startMillis) >= scrollDelay) {
    startMillis = currentMillis;
    for (byte ledRow = 0; ledRow < NUM_STRIPS; ledRow++) {
      FastLED.clear(); //turn off all LEDs in buffer
      for (int i = 0; i < NUM_LEDS; i++) {
        if (i >= textStartPosition) {
          scrollCharacter = (i - textStartPosition) / 6;
          if ((i - textStartPosition) - (scrollCharacter * 6) != 5) {
            if (scrollCharacter < strlen(scrollText)) {
              asciiPattern = pgm_read_byte(&Font5x7[scrollText[scrollCharacter] - 0x20][(i - textStartPosition) % 6]);
              if (bitRead(asciiPattern, 7 - ledRow) == 1) {
                leds[i] = textColor; //turn on pixel
              }
            }
          }
        }
      }
      FastLED[ledRow].showLeds(gBrightness);
    }
    textStartPosition--;
    if ((textStartPosition + textLength * 6) < 0 ) {
      textStartPosition = NUM_LEDS + 1;
    }
  }
}
9

I rely on the fact that the ws28xx chips maintain the last color until being told otherwise. So each pass i only change the required few pixels

You are mistaken about how ws28xx work. You must completely update the entire string to update even a single led.

10

PaulRB:
You are mistaken about how ws28xx work. You must completely update the entire string to update even a single led.

Yes and no. You must run the FastLED.show() function for changes to take effect, but LEDs that were not changed during a loop maintain their last color until being assigned a new one....

11

Miniflyer:
Yes and no. You must run the FastLED.show() function for changes to take effect, but LEDs that were not changed during a loop maintain their last color until being assigned a new one....

No. FastLED.show() updates all LEDs in the strip. If they receive the same data as previously, they will show the same colour. But all LEDs in the strip receive new data each time FastLED.show() is called. Your stretch may be able to save some time by not updating the data for some LEDs, but the data must still be transmitted in full to the strip, so FastLED.show() always executes at the same speed, regardless of how many LEDs have changed or not changed. Put another way, the time taken to execute FastLED.show() depends on the number of LEDs in the strip, not the number of LEDs that have changed colour.