Problema ricezione dati da seriale con FastLED

Sto cercando di controllare una striscia LED tramite la libreria FastLED. Il controllo è effettuato tramite dei comandi trasmessi tramite porta seriale. I comandi sono spediti tramite dei “pacchetti” delimitati da alcuni byte speciali.
Ho utilizzato anche la libreria SoftwareSerial per poter effettuare un debug con facilità. Quindi in realtà i dati per il controllo dei LED sono trasmessi sulla SoftwareSerial, mentre la Serial è utilizzata per il debug e stampa su console i pacchetti ricevuti.
La cosa strana, che ho notato dopo parecchio tempo perso in svariati test, è che la ricezione dei pacchetti avviene in maniera corretta se commento la linea di codice FastLED.show(). Se invece utilizzo anche questo comando, la ricezione dei pacchetti non funziona più e non capisco perché.
Questo è il codice:

#include <FastLED.h>
#include <SoftwareSerial.h>

// #########################
// ###   CONFIGURATION   ###
// #########################

// LED strip
#define LED_PIN     6       // LED pin number
#define NUM_LEDS    300     // number of LEDs on the strip
#define LED_TYPE    WS2812B // type of LEDs
#define COLOR_ORDER GRB     // color order of the strip

// Serial communication (packets receiving)
#define BAUD_RATE 9600  // baud rate for the serial communication
#define SOP 254           // Start Of Packet
#define EOP 255           // End Of Packet
#define MAGIC_BYTE 253    // use this as a special byte to be able to reproduce SOP, EOP and this in the packet
#define MAX_MESSAGE 30    // max length of a packet

// ##### END CONFIGURATION #####

SoftwareSerial mySerial(10,11); // RX, TX

// LED strip variables
byte brightness = 255;    // brightness of the LEDs
CRGB leds[NUM_LEDS];      // state of each LED
byte fps = 50;            // frames per second

// Serial communication variables
byte bytesRecvd = 0;          // number of total bytes received (keeps track where we are in tempBuffer)
byte dataSentNum = 0;         // the number of bytes that the controller device said it sent (DBN)
byte dataRecvCount = 0;       // number of bytes received (just the usefull data, without SOP, EOP, DBN)
byte dataRecvd[MAX_MESSAGE];  // the transmitted data will be saved here
byte tempBuffer[MAX_MESSAGE]; // buffer to store all the coming bytes
boolean inProgress = false;
boolean startFound = false;
boolean allReceived = false;

int selectedEffect;  // current effect

byte effParams[MAX_MESSAGE]; // effect parameters

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  
  digitalWrite(LED_BUILTIN, HIGH);
  delay(3000); // power-up safety delay
  digitalWrite(LED_BUILTIN, LOW);

  // setup the led strip
  FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(brightness);

  Serial.begin(BAUD_RATE); // open bluetooth connection
  mySerial.begin(BAUD_RATE);
  
  selectedEffect = 0;
}

void loop() {
  getSerialData();
  processData();

  switch(selectedEffect) {
    case 0:
      switchOff(); break;
      Serial.println("Mode changed: OFF");
    case 1:
      fixedColor(CRGB(effParams[0], effParams[1], effParams[2])); break;
      Serial.print("Mode changed: FIXED COLOR (");
      Serial.print(effParams[0]);
      Serial.print(",");
      Serial.print(effParams[1]);
      Serial.print(",");
      Serial.print(effParams[2]);
      Serial.println(")");
    default:
      blinkRed(3);
      selectedEffect = 0;
      Serial.println("Mode changed: ERROR");
      break;
  }

  FastLED.show(); // QUESTO È IL COMANDO CHE SEMBRA COMPROMETTERE LA RICEZIONE DEI PACCHETTI
  FastLED.delay(1000 / fps);
}

// ###################################
// ###   COMMUNICATION FUNCTIONS   ###
// ###################################

void getSerialData() {
  // Receives data into tempBuffer[]
  // saves the number of bytes that the PC said it sent (dataSentNum) - which will be in tempBuffer[1]
  // uses decodeHighBytes() to copy data from tempBuffer to dataRecvd[]
  
  // The Arduino program will use the data it finds in dataRecvd[]

  if(mySerial.available() > 0) {
    byte x = mySerial.read();
    if(x == SOP) { 
      bytesRecvd = 0; 
      inProgress = true;
    }
    
    if(inProgress) {
      tempBuffer[bytesRecvd] = x;
      bytesRecvd++;
    }
    
    if(x == EOP) {
      inProgress = false;
      allReceived = true;
      
      // save the number of bytes that were sent
      dataSentNum = tempBuffer[1];  // DBN
      
      decodeHighBytes();
    }
  }
}

void decodeHighBytes() {
  //  copies to dataRecvd[] only the data bytes i.e. excluding the marker bytes and the count byte
  //  and converts any bytes of 253 etc into the intended numbers
  //  Note that bytesRecvd is the total of all the bytes including the markers
  dataRecvCount = 0;
  for(byte n = 2; n < bytesRecvd - 1 ; n++) { // 2 skips the start marker and the count byte, -1 omits the end marker
    byte x = tempBuffer[n];
    if (x == MAGIC_BYTE) {
       n++;
       x += tempBuffer[n];
    }
    dataRecvd[dataRecvCount] = x;
    dataRecvCount++;
  }
}

void processData() {
  // processes the data that is in dataRecvd[]
  if(allReceived) {
    Serial.println("Received:");
    for (byte n = 0; n < dataRecvCount; n++) {
       Serial.print(dataRecvd[n]);
       Serial.print(",");
    }
    Serial.println();
    
    selectedEffect = dataRecvd[0];
    for(byte i = 0; i < dataRecvCount; i++) {
      effParams[i] = dataRecvd[i+1];
    }

    delay(100);
    allReceived = false; 
  }
}
// ####################################

void blinkRed(byte n) {
  for(int i = 0; i < n; i++) {
    fill_solid(leds, NUM_LEDS, CRGB::Red);
    FastLED.show();
    delay(100);
    FastLED.clear();
    FastLED.show();
    delay(100);
  }
}

// ##########################
// ###   LEDS FUNCTIONS   ###
// ##########################

void switchOff() {
  fill_solid(leds, NUM_LEDS, CRGB::Black);
}

void fixedColor(CRGB color) {
  fill_solid(leds, NUM_LEDS, color);
}

**>concy99: ** in conformità al REGOLAMENTO, punto 13, il cross-posting è proibito (anche tra lingue diverse) per cui, il tuo post duplicato nella sezione Inglese del forum è stato rimosso.

Ti prego, per il futuro, di evitare di aprire più post sullo stesso argomento in sezioni differenti del forum. Grazie.

Guglielmo

Non conosco la FastLED, ma se, come le altre librerie (es. Adafruit), durante la trasmissione dei bit alle strisce di LED, per poter rispettare le tempistiche, è costretta a disabilitare gli interrupts, è normale che la SoftwareSerial NON sia in grado di ricevere correttamente i caratteri, dato che, durante la ricezione, utilizza gli interrupts (che, appunto, vengono quasi sicuramente disabilitati durante l'invio dei dati ai LED).

Informazioni più sicure le puoi comunque avere tramite la community di supporto alla fastLED che è su reddit a QUESTO indirizzo.

Guglielmo

gpb01:
**>concy99: **in conformità al REGOLAMENTO, punto 13, il cross-posting è proibito (anche tra lingue diverse) per cui, il tuo post duplicato nella sezione Inglese del forum è stato rimosso.

Ti prego, per il futuro, di evitare di aprire più post sullo stesso argomento in sezioni differenti del forum. Grazie.

Guglielmo

Oh scusate, volevo solo ampliare la cerchia delle persone in grado di rispondermi. Non pensavo fosse vietato anche in lingue diverse. Scusate, ora non lo farò più

gpb01:
Non conosco la FastLED, ma se, come le altre librerie (es. Adafruit), durante la trasmissione dei bit alle strisce di LED, per poter rispettare le tempistiche, è costretta a disabilitare gli interrupts, è normale che la SoftwareSerial NON sia in grado di ricevere correttamente i caratteri, dato che, durante la ricezione, utilizza gli interrupts (che, appunto, vengono quasi sicuramente disabilitati durante l'invio dei dati ai LED).

Informazioni più sicure le puoi comunque avere tramite la community di supporto alla fastLED che è su reddit a QUESTO indirizzo.

Guglielmo

Grazie per la risposta