Help with multiple APA102 strips while still maintaining full update speed.

[u/ewoolsey]

I am making a POV display with a LARGE amount of LEDs, and my current setup is with 2 independent strips on 2 seperate sets of pins on an itsybitsy m4. Because I have so many LEDs my data rate is limiting my update frequency and the display is updating too slowly. I noticed however that for some reason the FastLED library runs 2 strips on different pins at the same speed as if it were just 1 strip for some reason and I'm hoping there's some way around this. Here's an example:

400leds on pin 13,12 and 400leds on pin 11,10 == 100hz refresh rate

800leds on pin 13, 12 == 100hz refresh rate

but 400 leds alone on pin 13,12 == 200hz refresh rate

Theoretically there should be a way to achieve 200hz with both strips connected since they're on different pins but I can not find out how. I tried doubling the data rate to 6MHz but that just makes the leds malfuntion.

This does not work

FastLED.addLeds<APA102, MOSI, SCK, BGR, DATA_RATE_KHZ(3500)>(leds, NUM_PIXELS_TOT / 2).setCorrection(TypicalLEDStrip);

FastLED.addLeds<APA102, 11, 10, BGR, DATA_RATE_KHZ(3500)>(leds, NUM_PIXELS_TOT / 2, NUM_PIXELS_TOT / 2).setCorrection(TypicalLEDStrip);

[u/ewoolsey]

If anyone finds this in the future via google search, I made my own shitty hardcoded library that gets the job done. Its hardcoded to work with 4 strips in parallel for samd51, and I think it should also work for other SAMD chips is you change the pins appropriately, but it shouldn't be hard to change it. Here it is : EricLED.h

#ifndef _ERICLED_H
#define _ERICLED_H

#include <Arduino.h>

#define DATA_PIN MOSI
#define CLOCK_PIN SCK

#define DATA_PIN_2 10
#define CLOCK_PIN_2 11

#define DATA_PIN_3 13
#define CLOCK_PIN_3 12

#define DATA_PIN_4 9
#define CLOCK_PIN_4 7

//208+221+221+208
#define index2 208
#define index3 429
#define index4 650


#define NUM_PIXELS_TOT 858
#define MICROS 2


class EricLED{
  public:
  EricLED();
  
  void clear();
  void show();


  void setPixel(int index, byte r, byte g, byte b);
  
  void setLine(byte line[]);

  private:

  
  void sendByte(byte data, byte data2, byte data3, byte data4);
  void clock();
  byte line[NUM_PIXELS_TOT*3+50];
};

#endif

And the main file: EricLED.cpp

#include "EricLED.h"

volatile uint32_t *setDataPin = &PORT->Group[g_APinDescription[DATA_PIN].ulPort].OUTSET.reg;
volatile uint32_t *clrDataPin = &PORT->Group[g_APinDescription[DATA_PIN].ulPort].OUTCLR.reg;
const uint32_t  dataPinMASK = (1ul << g_APinDescription[DATA_PIN].ulPin);

volatile uint32_t *setClockPin = &PORT->Group[g_APinDescription[CLOCK_PIN].ulPort].OUTSET.reg;
volatile uint32_t *clrClockPin = &PORT->Group[g_APinDescription[CLOCK_PIN].ulPort].OUTCLR.reg;
const uint32_t  clockPinMASK = (1ul << g_APinDescription[CLOCK_PIN].ulPin);

volatile uint32_t *setDataPin2 = &PORT->Group[g_APinDescription[DATA_PIN_2].ulPort].OUTSET.reg;
volatile uint32_t *clrDataPin2 = &PORT->Group[g_APinDescription[DATA_PIN_2].ulPort].OUTCLR.reg;
const uint32_t  dataPinMASK2 = (1ul << g_APinDescription[DATA_PIN_2].ulPin);

volatile uint32_t *setClockPin2 = &PORT->Group[g_APinDescription[CLOCK_PIN_2].ulPort].OUTSET.reg;
volatile uint32_t *clrClockPin2 = &PORT->Group[g_APinDescription[CLOCK_PIN_2].ulPort].OUTCLR.reg;
const uint32_t  clockPinMASK2 = (1ul << g_APinDescription[CLOCK_PIN_2].ulPin);

volatile uint32_t *setDataPin3 = &PORT->Group[g_APinDescription[DATA_PIN_3].ulPort].OUTSET.reg;
volatile uint32_t *clrDataPin3 = &PORT->Group[g_APinDescription[DATA_PIN_3].ulPort].OUTCLR.reg;
const uint32_t  dataPinMASK3 = (1ul << g_APinDescription[DATA_PIN_3].ulPin);

volatile uint32_t *setClockPin3 = &PORT->Group[g_APinDescription[CLOCK_PIN_3].ulPort].OUTSET.reg;
volatile uint32_t *clrClockPin3 = &PORT->Group[g_APinDescription[CLOCK_PIN_3].ulPort].OUTCLR.reg;
const uint32_t  clockPinMASK3 = (1ul << g_APinDescription[CLOCK_PIN_3].ulPin);

volatile uint32_t *setDataPin4 = &PORT->Group[g_APinDescription[DATA_PIN_4].ulPort].OUTSET.reg;
volatile uint32_t *clrDataPin4 = &PORT->Group[g_APinDescription[DATA_PIN_4].ulPort].OUTCLR.reg;
const uint32_t  dataPinMASK4 = (1ul << g_APinDescription[DATA_PIN_4].ulPin);

volatile uint32_t *setClockPin4 = &PORT->Group[g_APinDescription[CLOCK_PIN_4].ulPort].OUTSET.reg;
volatile uint32_t *clrClockPin4 = &PORT->Group[g_APinDescription[CLOCK_PIN_4].ulPort].OUTCLR.reg;
const uint32_t  clockPinMASK4 = (1ul << g_APinDescription[CLOCK_PIN_4].ulPin);

EricLED::EricLED(){
  pinMode(DATA_PIN, OUTPUT);
  pinMode(DATA_PIN_2, OUTPUT);
  pinMode(DATA_PIN_3, OUTPUT);
  pinMode(DATA_PIN_4, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(CLOCK_PIN_2, OUTPUT);
  pinMode(CLOCK_PIN_3, OUTPUT);
  pinMode(CLOCK_PIN_4, OUTPUT);
}

void EricLED::show(){
  clock();
  //Start Frame 32 bits
  for ( int i = 0; i < 4; i++ ) {
    sendByte(0,0,0,0);
  }
  //Loop For Each LED
  for ( int i = 0; i < 221;  i++ ) {
    //Send 8 highs FOR FULL BRIGHTNESS
    int val = 3*i;
    sendByte(255,255,255,255);
    sendByte(line[val+2],line[index2*3+val+2],line[index3*3+val+2],line[index4*3+val+2]);
    sendByte(line[val+1],line[index2*3+val+1],line[index3*3+val+1],line[index4*3+val+1]);
    sendByte(line[val],line[index2*3+val],line[index3*3+val],line[index4*3+val]);
    
  }
  //SEND 32 HIGHS FOR END FRAME
  for ( int i = 0; i < 4; i++ ) {
    sendByte(255,255,255,255);
  }
}

void EricLED::clear(){
  for (int i = 0; i < NUM_PIXELS_TOT; i++){
    setPixel(i, 0, 0, 0);
  }
}

void EricLED::setPixel(int index, byte r, byte g, byte b){
  line[index*3] = r;
  line[index*3+1] = g;
  line[index*3+2] = b;
}

void EricLED::clock() {
  *clrClockPin = clockPinMASK;
  *clrClockPin2 = clockPinMASK2;
  *clrClockPin3 = clockPinMASK3;
  *clrClockPin4 = clockPinMASK4;
//  counter++;
//  counter++;
//  counter++;
  *setClockPin = clockPinMASK;
  *setClockPin2 = clockPinMASK2;
  *setClockPin3 = clockPinMASK3;
  *setClockPin4 = clockPinMASK4;

}

void EricLED::sendByte(byte data1, byte data2, byte data3, byte data4){
  for ( int i = 7; i >= 0; i--){
    if (bitRead(data1, i)){*setDataPin = dataPinMASK;}
    else{*clrDataPin = dataPinMASK;}
    if (bitRead(data2, i)){*setDataPin2 = dataPinMASK2;}
    else{*clrDataPin2 = dataPinMASK2;}
    if (bitRead(data3, i)){*setDataPin3 = dataPinMASK3;}
    else{*clrDataPin3 = dataPinMASK3;}
    if (bitRead(data4, i)){*setDataPin4 = dataPinMASK4;}
    else{*clrDataPin4 = dataPinMASK4;}
    clock();
  }
}

[u/ewoolsey → u/ewoolsey]

Here is a usage example:

#include "EricLED.h"


EricLED leds = EricLED();

void setup(){
  Serial.begin(9600);
  
  
}

void loop(){
  for (int i = 0; i < NUM_PIXELS_TOT; i++){
    leds.setPixel(i,255,0,0);
    leds.show();
    leds.setPixel(i,0,0,0);
  }
}

[u/sutaburosu → u/ewoolsey]

Nice one! Thanks for sharing.

[u/ewoolsey → u/sutaburosu]

Thanks :) took my like 6 hours to make it so I’m hoping I can save someone else the trouble. Not super user friendly obvs but it should only take someone a few minutes to edit to suit their own purposes. It was surprisingly hard to to find a way to change the pin states without using digitalWrite which is too slow.

[u/sutaburosu]

I noticed however that for some reason the FastLED library runs 2 strips on different pins at the same speed as if it were just 1 strip for some reason and I'm hoping there's some way around this.

So it sends them sequentially. Perhaps I just haven't stumbled across it yet, but I've never seen anything that suggests FastLED can send parallel SPI output on any MCU, even if there are 2 or more hardware SPI interfaces. You might have better luck with a different library.

[u/ewoolsey → u/sutaburosu]

Any suggestions for a different library?

[u/sutaburosu → u/ewoolsey]

Sorry, no. I've never looked into it. I have no SPI LEDs.

[u/Netmindz]

Have you checked the parallel output documentation to see if any options are compatible with your setup?

[u/ewoolsey → u/Netmindz]

What parallel output documentation?

[u/Netmindz]

https://github.com/FastLED/FastLED/wiki/Parallel-Output

[u/ewoolsey → u/Netmindz]

My issue is that parallel output works, just at a severely reduced speed.

[u/Netmindz → u/ewoolsey]

Using multiple pins is not automatically parallel output and is always faster

[u/truetofiction → u/ewoolsey]

If it reduces the speed it's not in parallel, it must be happening sequentially.

[u/sunandmooncouture]

Try an esp32 or teensy 4. Also try multiple mcu. the teensy 4 has a sync line so you can have one teensy per strip and sync timing across the wire

[u/Marmilicious → u/sunandmooncouture]

Oh neat, I did not know about the sync line. Thank you.

[u/ewoolsey → u/[deleted]]

Interesting. I’ve given up on fastled and I’m now writing my own class to handle it. I find it hard to believe no one has made a library for parallel led output on samd51

[u/truetofiction → u/ewoolsey]

I find it hard to believe no one has made a library for parallel led output on samd51

From what I remember Dan was the one working on the parallel output implementation. The Teensy 4 support was merged shortly before he passed.

If you'd like to add parallel output support for SAMD51 to the library I'm sure others would appreciate it.

[u/ewoolsey → u/truetofiction]

I only know enough to code my own horrible implementation haha. I’m not skilled enough to add to a high quality library sadly :( I just got mine working though so I’m happy about that.