Serious flickering problems on ESP32-C3

[berkut0]

I have done some research and am convinced that the problem is with FastLED. I have tried different versions from 3.5 to 3.7.1 and the same problem. The same problem seems to migrate across repositories. (it looks like rainbow flashes, increasing with increasing brightness and having a barely noticeable periodicity on the strip)

What I've tried:

1. I first noticed this behaviour with wled. I thought it might be a specific behaviour of wled.

2. Then I tried Adalight-FastLED and got exactly the same behaviour.

3. I tried compiling with other versions of FastLED or with a library I got directly from github.

All a complete failure.

You don't need to remind me about 'power' and 'ground', the problem is ONLY with FastLED. I think there is another library involved in the wled operation and only the USB transfer somehow involves FastLED.
This is all about the Esp32-c3 board.

[zackees]

What's your LED type?

Please post your code.

[berkut0]

What's your LED type?

WS2812-like strip

Please post your code.

Just this code compiled to ESP32-C3:
https://github.com/dmadison/Adalight-FastLED

CODE

/*
 *  Project     Adalight FastLED
 *  @author     David Madison
 *  @link       github.com/dmadison/Adalight-FastLED
 *  @license    LGPL - Copyright (c) 2017 David Madison
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <Arduino.h>

// --- General Settings
const uint16_t 
	Num_Leds   =  80;         // strip length
const uint8_t
	Brightness =  255;        // maximum brightness

// --- FastLED Setings
#define LED_TYPE     WS2812B  // led strip type for FastLED
#define COLOR_ORDER  GRB      // color order for bitbang
#define PIN_DATA     6        // led data output pin
// #define PIN_CLOCK  7       // led data clock pin (uncomment if you're using a 4-wire LED type)

// --- Serial Settings
const unsigned long
	SerialSpeed    = 115200;  // serial port speed
const uint16_t
	SerialTimeout  = 60;      // time before LEDs are shut off if no data (in seconds), 0 to disable

// --- Optional Settings (uncomment to add)
#define SERIAL_FLUSH          // Serial buffer cleared on LED latch
// #define CLEAR_ON_START     // LEDs are cleared on reset

// --- Debug Settings (uncomment to add)
// #define DEBUG_LED 13       // toggles the Arduino's built-in LED on header match
// #define DEBUG_FPS 8        // enables a pulse on LED latch

// --------------------------------------------------------------------

#include <FastLED.h>

CRGB leds[Num_Leds];
uint8_t * ledsRaw = (uint8_t *)leds;

// A 'magic word' (along with LED count & checksum) precedes each block
// of LED data; this assists the microcontroller in syncing up with the
// host-side software and properly issuing the latch (host I/O is
// likely buffered, making usleep() unreliable for latch). You may see
// an initial glitchy frame or two until the two come into alignment.
// The magic word can be whatever sequence you like, but each character
// should be unique, and frequent pixel values like 0 and 255 are
// avoided -- fewer false positives. The host software will need to
// generate a compatible header: immediately following the magic word
// are three bytes: a 16-bit count of the number of LEDs (high byte
// first) followed by a simple checksum value (high byte XOR low byte
// XOR 0x55). LED data follows, 3 bytes per LED, in order R, G, B,
// where 0 = off and 255 = max brightness.

const uint8_t magic[] = {
	'A','d','a'};
#define MAGICSIZE  sizeof(magic)

// Check values are header byte # - 1, as they are indexed from 0
#define HICHECK    (MAGICSIZE)
#define LOCHECK    (MAGICSIZE + 1)
#define CHECKSUM   (MAGICSIZE + 2)

enum processModes_t {Header, Data} mode = Header;

int16_t c;  // current byte, must support -1 if no data available
uint16_t outPos;  // current byte index in the LED array
uint32_t bytesRemaining;  // count of bytes yet received, set by checksum
unsigned long t, lastByteTime, lastAckTime;  // millisecond timestamps

void headerMode();
void dataMode();
void timeouts();

// Macros initialized
#ifdef SERIAL_FLUSH
	#undef SERIAL_FLUSH
	#define SERIAL_FLUSH while(Serial.available() > 0) { Serial.read(); }
#else
	#define SERIAL_FLUSH
#endif

#ifdef DEBUG_LED
	#define ON  1
	#define OFF 0

	#define D_LED(x) do {digitalWrite(DEBUG_LED, x);} while(0)
#else
	#define D_LED(x)
#endif

#ifdef DEBUG_FPS
	#define D_FPS do {digitalWrite(DEBUG_FPS, HIGH); digitalWrite(DEBUG_FPS, LOW);} while (0)
#else
	#define D_FPS
#endif

void setup(){
	#ifdef DEBUG_LED
		pinMode(DEBUG_LED, OUTPUT);
		digitalWrite(DEBUG_LED, LOW);
	#endif

	#ifdef DEBUG_FPS
		pinMode(DEBUG_FPS, OUTPUT);
	#endif

	#if defined(PIN_CLOCK) && defined(PIN_DATA)
		FastLED.addLeds<LED_TYPE, PIN_DATA, PIN_CLOCK, COLOR_ORDER>(leds, Num_Leds);
	#elif defined(PIN_DATA)
		FastLED.addLeds<LED_TYPE, PIN_DATA, COLOR_ORDER>(leds, Num_Leds);
	#else
		#error "No LED output pins defined. Check your settings at the top."
	#endif
	
	FastLED.setBrightness(Brightness);

	#ifdef CLEAR_ON_START
		FastLED.show();
	#endif

	Serial.begin(SerialSpeed);
	Serial.print("Ada\n"); // Send ACK string to host

	lastByteTime = lastAckTime = millis(); // Set initial counters
}

void loop(){ 
	t = millis(); // Save current time

	// If there is new serial data
	if((c = Serial.read()) >= 0){
		lastByteTime = lastAckTime = t; // Reset timeout counters

		switch(mode) {
			case Header:
				headerMode();
				break;
			case Data:
				dataMode();
				break;
		}
	}
	else {
		// No new data
		timeouts();
	}
}

void headerMode(){
	static uint8_t
		headPos,
		hi, lo, chk;

	if(headPos < MAGICSIZE){
		// Check if magic word matches
		if(c == magic[headPos]) {headPos++;}
		else {headPos = 0;}
	}
	else{
		// Magic word matches! Now verify checksum
		switch(headPos){
			case HICHECK:
				hi = c;
				headPos++;
				break;
			case LOCHECK:
				lo = c;
				headPos++;
				break;
			case CHECKSUM:
				chk = c;
				if(chk == (hi ^ lo ^ 0x55)) {
					// Checksum looks valid. Get 16-bit LED count, add 1
					// (# LEDs is always > 0) and multiply by 3 for R,G,B.
					D_LED(ON);
					bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
					outPos = 0;
					memset(leds, 0, Num_Leds * sizeof(struct CRGB));
					mode = Data; // Proceed to latch wait mode
				}
				headPos = 0; // Reset header position regardless of checksum result
				break;
		}
	}
}

void dataMode(){
	// If LED data is not full
	if (outPos < sizeof(leds)){
		ledsRaw[outPos++] = c; // Issue next byte
	}
	bytesRemaining--;
 
	if(bytesRemaining == 0) {
		// End of data -- issue latch:
		mode = Header; // Begin next header search
		FastLED.show();
		D_FPS;
		D_LED(OFF);
		SERIAL_FLUSH;
	}
}

void timeouts(){
	// No data received. If this persists, send an ACK packet
	// to host once every second to alert it to our presence.
	if((t - lastAckTime) >= 1000) {
		Serial.print("Ada\n"); // Send ACK string to host
		lastAckTime = t; // Reset counter

		// If no data received for an extended time, turn off all LEDs.
		if(SerialTimeout != 0 && (t - lastByteTime) >= (uint32_t) SerialTimeout * 1000) {
			memset(leds, 0, Num_Leds * sizeof(struct CRGB)); //filling Led array by zeroes
			FastLED.show();
			mode = Header;
			lastByteTime = t; // Reset counter
		}
	}
}

Same behaviour on WLED compiled on ESP32-C3:
https://github.com/Aircoookie/WLED
(I should emphasise the USB only, which probably copies the code above, but otherwise wled works correctly)

[zackees]

Can you do me a favor and try your project with the Adafruit Neopixel and report if that works? I've been toying around with the idea of bringing in a subset of their library as a WS2812 controller type.

[zackees]

This probably has to do with the RMT driver on the ESP32 flavors. We use a DMA like engine to push out the data. There's rumor that Adafruit already has figured out how to do it correctly.

[berkut0]

Can you do me a favor and try your project with the Adafruit Neopixel and report if that works? I've been toying around with the idea of bringing in a subset of their library as a WS2812 controller type.

I made a Frankenstein's monster by crossing FastLED and another library, NeopixelBus (by makuna). Unfortunately, the result is exactly the same.

Frankenstein's Code

/*
 *  Project     Adalight FastLED
 *  @author     David Madison
 *  @link       github.com/dmadison/Adalight-FastLED
 *  @license    LGPL - Copyright (c) 2017 David Madison
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#include <Arduino.h>

// --- General Settings
const uint16_t
  Num_Leds = 300;  // strip length
const uint8_t
  Brightness = 255;  // maximum brightness

// --- FastLED Setings
#define LED_TYPE WS2812B  // led strip type for FastLED
#define COLOR_ORDER GRB   // color order for bitbang
#define PIN_DATA 6        // led data output pin
// #define PIN_CLOCK  7       // led data clock pin (uncomment if you're using a 4-wire LED type)

// --- Serial Settings
const unsigned long
  SerialSpeed = 115200;  // serial port speed
const uint16_t
  SerialTimeout = 60;  // time before LEDs are shut off if no data (in seconds), 0 to disable

// --- Optional Settings (uncomment to add)
#define SERIAL_FLUSH  // Serial buffer cleared on LED latch
// #define CLEAR_ON_START     // LEDs are cleared on reset

// --- Debug Settings (uncomment to add)
// #define DEBUG_LED 13       // toggles the Arduino's built-in LED on header match
// #define DEBUG_FPS 8        // enables a pulse on LED latch

// --------------------------------------------------------------------

#include <NeoPixelBus.h>
NeoPixelBus<NeoGrbFeature, NeoWs2812xMethod> strip(Num_Leds, PIN_DATA);

#include <FastLED.h>
// #include <Adafruit_NeoPixel.h>

// Adafruit_NeoPixel pixels(Num_Leds, PIN_DATA, NEO_GRB + NEO_KHZ800);
// struct CRBG{

// }

CRGB leds[Num_Leds];
uint8_t *ledsRaw = (uint8_t *)leds;

// A 'magic word' (along with LED count & checksum) precedes each block
// of LED data; this assists the microcontroller in syncing up with the
// host-side software and properly issuing the latch (host I/O is
// likely buffered, making usleep() unreliable for latch). You may see
// an initial glitchy frame or two until the two come into alignment.
// The magic word can be whatever sequence you like, but each character
// should be unique, and frequent pixel values like 0 and 255 are
// avoided -- fewer false positives. The host software will need to
// generate a compatible header: immediately following the magic word
// are three bytes: a 16-bit count of the number of LEDs (high byte
// first) followed by a simple checksum value (high byte XOR low byte
// XOR 0x55). LED data follows, 3 bytes per LED, in order R, G, B,
// where 0 = off and 255 = max brightness.

const uint8_t magic[] = {
  'A', 'd', 'a'
};
#define MAGICSIZE sizeof(magic)

// Check values are header byte # - 1, as they are indexed from 0
#define HICHECK (MAGICSIZE)
#define LOCHECK (MAGICSIZE + 1)
#define CHECKSUM (MAGICSIZE + 2)

enum processModes_t { Header,
                      Data } mode = Header;

int16_t c;                                   // current byte, must support -1 if no data available
uint16_t outPos;                             // current byte index in the LED array
uint32_t bytesRemaining;                     // count of bytes yet received, set by checksum
unsigned long t, lastByteTime, lastAckTime;  // millisecond timestamps

void headerMode();
void dataMode();
void timeouts();

// Macros initialized
#ifdef SERIAL_FLUSH
#undef SERIAL_FLUSH
#define SERIAL_FLUSH \
  while (Serial.available() > 0) { Serial.read(); }
#else
#define SERIAL_FLUSH
#endif

#ifdef DEBUG_LED
#define ON 1
#define OFF 0

#define D_LED(x) \
  do { digitalWrite(DEBUG_LED, x); } while (0)
#else
#define D_LED(x)
#endif

#ifdef DEBUG_FPS
#define D_FPS \
  do { \
    digitalWrite(DEBUG_FPS, HIGH); \
    digitalWrite(DEBUG_FPS, LOW); \
  } while (0)
#else
#define D_FPS
#endif

void show() {
  for (int i=0; i<Num_Leds; i++) {
    uint8_t r = leds[i].r;
    uint8_t g = leds[i].g;
    uint8_t b = leds[i].b;
    RgbColor c = RgbColor(r, g, b);
    strip.SetPixelColor(i, c);
  }
  strip.Show();
}

void setup() {
#ifdef DEBUG_LED
  pinMode(DEBUG_LED, OUTPUT);
  digitalWrite(DEBUG_LED, LOW);
#endif

#ifdef DEBUG_FPS
  pinMode(DEBUG_FPS, OUTPUT);
#endif

// #if defined(PIN_CLOCK) && defined(PIN_DATA)
//   FastLED.addLeds<LED_TYPE, PIN_DATA, PIN_CLOCK, COLOR_ORDER>(leds, Num_Leds);
// #elif defined(PIN_DATA)
//   FastLED.addLeds<LED_TYPE, PIN_DATA, COLOR_ORDER>(leds, Num_Leds);
// #else
// #error "No LED output pins defined. Check your settings at the top."
// #endif

  // FastLED.setBrightness(Brightness);
strip.Begin();
#ifdef CLEAR_ON_START
  // FastLED.show();
  show();
#endif

  Serial.begin(SerialSpeed);
  Serial.print("Ada\n");  // Send ACK string to host

  lastByteTime = lastAckTime = millis();  // Set initial counters
}


void loop() {
  t = millis();  // Save current time

  // If there is new serial data
  if ((c = Serial.read()) >= 0) {
    lastByteTime = lastAckTime = t;  // Reset timeout counters

    switch (mode) {
      case Header:
        headerMode();
        break;
      case Data:
        dataMode();
        break;
    }
  } else {
    // No new data
    timeouts();
  }
}

void headerMode() {
  static uint8_t
    headPos,
    hi, lo, chk;

  if (headPos < MAGICSIZE) {
    // Check if magic word matches
    if (c == magic[headPos]) {
      headPos++;
    } else {
      headPos = 0;
    }
  } else {
    // Magic word matches! Now verify checksum
    switch (headPos) {
      case HICHECK:
        hi = c;
        headPos++;
        break;
      case LOCHECK:
        lo = c;
        headPos++;
        break;
      case CHECKSUM:
        chk = c;
        if (chk == (hi ^ lo ^ 0x55)) {
          // Checksum looks valid. Get 16-bit LED count, add 1
          // (# LEDs is always > 0) and multiply by 3 for R,G,B.
          D_LED(ON);
          bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
          outPos = 0;
          // memset(leds, 0, Num_Leds * sizeof(struct CRGB));
          mode = Data;  // Proceed to latch wait mode
        }
        headPos = 0;  // Reset header position regardless of checksum result
        break;
    }
  }
}

void dataMode() {
  // If LED data is not full
  if (outPos < sizeof(leds)) {
    ledsRaw[outPos++] = c;  // Issue next byte
  }
  bytesRemaining--;

  if (bytesRemaining == 0) {
    // End of data -- issue latch:
    mode = Header;  // Begin next header search
    // FastLED.show();
    show();
    D_FPS;
    D_LED(OFF);
    SERIAL_FLUSH;
  }
}

void timeouts() {
  // No data received. If this persists, send an ACK packet
  // to host once every second to alert it to our presence.
  if ((t - lastAckTime) >= 1000) {
    Serial.print("Ada\n");  // Send ACK string to host
    lastAckTime = t;        // Reset counter

    // If no data received for an extended time, turn off all LEDs.
    if (SerialTimeout != 0 && (t - lastByteTime) >= (uint32_t)SerialTimeout * 1000) {
      memset(leds, 0, Num_Leds * sizeof(struct CRGB));  //filling Led array by zeroes
      // FastLED.show();
      show();
      mode = Header;
      lastByteTime = t;  // Reset counter
    }
  }
}

Unfortunately I can't test the classic library Neopixel by Adafruit any more. Maybe much later. It was a bit urgent.

[zackees]

You are trying to bang out the WS data via the serial port yes?

[berkut0]

@zackees Adalight is a protocol. It forms a data packet that is sent through the COM port. Yes, essentially the data is sent through the serial port. The operation of the data output to the WS chips should not be affected. Specifically in this case, I replaced the board with an RP2040 based board and compiling the original Adalight FastLED code worked without any changes to the code.

[vincentbraillard]

Any idea? same issues with same settings

[berkut0]

Maybe related:
#1515
#1349

But changes in v3.6.0 do not solve the problem in that case
I tried 3.6.0 by the way, it compiles with errors in general, this is fixed later, but in other versions the problem persists.

[zackees]

RMT driver in Arduino 3.2.1+ uses the platform esp-idf 5.1 toolchain. This broke the RMT driver.

The RMT driver was built on the the idf 4.x toolchain and works.

Arduino IDE can be downgraded back to idf 4.x, and so can PlatformIO

[artkeller]

@zackees: Do you think that this RMT problem is the reason for the runtime error on ESP32-C3: “E (79) rmt(legacy): CONFLICT! driver_ng is not allowed to be used with the legacy driver” when I include FastLED and declare a normal IO port (e.g. pinMode(PORT, OUTPUT). The code runs normally without FastLED.

[zackees]

Yes, this is from the esp-idf v5.1 update to the arduino core.

What is happening is that many boards are using the new RMT library to connect to a possible WS2812 status led, thus initializing the new RMT driver. For some reason both the new RMT driver and the legacy RMT driver cannot both be initialized in the same program or you get this crash.

Many other led projects are dealing with the same issue.

[artkeller]

@zackees Thanks - I'm facing the issue with the FastLED library and ESP32 Next Generation (S2, S3, C3, etc.) due to driver incompatibilities between IDF4 and IDF5.1. I've seen discussions about this problem, but it seems like a concrete solution hasn't been reached yet.

As a responsible developer, I'm interested in understanding the best approach to address this issue. Are there any known workarounds or potential fixes that the community has discovered?

I've looked into the FastLED code and the crash warnings. This problem is likely impacting many projects. I'd appreciate insights from the Arduino, Espressif, and Adafruit teams, as well as any relevant community discussions.

Is there a coordinated effort to resolve this incompatibility between FastLED and ESP32 Next Generation? I'm particularly interested in finding a solution that allows for both ESP32 Next Generation and ESP32 Legacy devices to coexist in the same system, along with normal GPIO functionality.

What is the real blocking point? I have tried to switch the new rmt driver back to the old one (rmt_driver_install(RMT_CHANNEL_0, 0, 0), and compiler -DESP32_ARDUINO_NO_RGB_BUILTIN, etc.) - no success. Why can't FastLED, for example, be adapted under esp-idf v5.1? I did not understand it.

Thank you for your time and expertise.

[zackees]

FastLED can be adapted to use the new idf 5.1 driver and it will be much better for it as the new driver is designed to push large blocks of RMT-encoded data even when the interrupt is shut off for large amounts of time due to wifi interrupts and flash writing.

The IDF 4.x RMT encoder that @samguyer implemented has two modes, a stream encoding mode that simply copies the RGB buffer (re-ordered) and then stream encodes it on a tight interrupt two symbols at a time, if memory serves correct. This works fine when wifi is not running. When wifi runs this interrupt doesn't fire fast enough, (50uS) and the ws2812 will reset, which causes the flashing/flickering behavior.

The other mode that we have for the 4.x RMT driver is allocate-everything-upfront for the RMT buffer and populate it. This requires a ton of memory but the benefit is that no interrupt is needed to stream encode, as everything is already encoded.

The reason we haven't done the new RMT driver is because it's non-trivial and the FastLED codebase in this area was tightly coupled between the FastLED interface wrapper and the RMT driver itself. I've spent the last week making the wrapper portion dead simple and pushing implementation details into the RMT driver and the *.cpp file where it belongs.

At this stage we are pretty much ready for the new IDF 5.1 RMT driver to be implemented.

I'll gladly accept a patch from anyone that chooses to do this.

I've made the FastLED codebase extremely easy to start developing on. At this point you can just fork, clone locally and then hit the compile button and the default blink demo will compile to s3 using idf 5.1.

There are some caveats though like the idf 4.4 RMT driver runs all the RMT devices in parallel during show(), and this behavior needs to be preserved in the new idf 5.1 driver. So this behavior needs to be preserved. However the "allocate everything up front" part of the idf 4.4 driver probably doesn't have to be implemented on the first pass for the 5.1 driver migration because the amount of buffering in the 5.1 RMT driver seems to have vastly improved.

[samguyer]

I'm going to set aside some time to understand the changes to the ESP-IDF, but I think the truth is that they don't change the fundamental underlying problem. A lot of the code I wrote in the current RMT driver is essentially taken from the internal implementation of Espressif's driver -- they aren't doing anything substantially different in terms of responding to interrupts and filling the buffers. The big difference in FastLED is that we service up to 8 outgoing channels at a time, allowing for a significant amount of parallelism.