Published February 10, 2025

ESP-C3 NeoPixels with RMT & BLE

Connect 10 neoPixel strips to an ESP32-C3 RISC-V MCU using the RMT peripheral.

IntermediateWork in progress150

Things used in this project

Hardware components

ESP32-C3

This project was developed using the SuperMini Board. Also available from eBay and AliExpress.

Software apps and online services

Espressif-IDE

Eclipse based IDE doe the ESP32 family- One of the best factory supported IDEs.

Story

If you have read my previous explorations on the subject of attaching NEOpixel strips to RISC-V MCUs, you will find a change in this project. Rather than using SPI to send the data stream to the strip we will use a peripheral that is rather unique to the ESP line of MCUs. Espressif calls it the RMT peripheral (short for remote control). This may seem surprising as we normally think of a remote control as an output device. But, the RMT is much more than a mechanism for generating remote control pulses to be fed to an IR LED. It is basically a generic method of bit-bashing any serial encoding onto a bit stream. It is very flexible, Espressif gives examples for 1-Wire, music buzzer and stepper motors as well as "led_strip" which we will be exploring here. As an added bonus we will explore the use of the RNG peripheral - the Random Number Generator - to make one of the animations cuter.

As with most of my Explorations this will be published before it's completion so check back often until this sentence disappears.

OverView:

The deliverable we wish to produce is the ability to connect at least 10 neoPixel strips to the tiny ESP32-C3 SuperMini board. Each strip will be able to display it's own separate sequence of pixels. We will go further and allow up to 5 different animation on each strip. All of this action will be provided by freeRTOS.

We will be using only a single instance of RMT (there are only 2) to encode the bitstream for each strip. We will explore the use of the GPIO matrix to switch the RMT output, in turn, to each of the different GPIOs to which the strips are connected.

This exploration was conducted using the Espressif-IDE which is essential for under the hood work on ESP MCUs. Their manufacturer support is 2nd to none.

I uploaded the complete project to CanHobby. It is too big for github. Just create a separate directory called rmtOS and unzip it into that dir. Then open the dir as a workspace with the ESP-IDE.

WorkFlow:

We begin with app_main() which starts by setting up the RMT peripheral with rmt_setup() followed by setting up each individual strip by calling strip_setup() which binds it to a strip struct which is specified in NEO.h. We then setup the individual parameters for each animation which are part of the struct.

We then create the show task which is the scanner that goes through each strip in turn, redirecting the bitstream to the corresponding GPIO pin. From a software point of view each strip is a buffer in memory. These buffers are modified by the animation tasks. Each of these tasks is created in the last lines of app_main().

RNG

The RNG basically uses electronic noise read by an ADC connected to nothing to generate the entropy to fuel the random algorithm. We don't need to do any setup, it is done by the bootloader. Neither do we need to be reading system registers - Espressif provides an implementation of the getrandom() standard Linux system call. We see the usage in the anim2() animation.

BLE

As I threatened in the comments I have added BlueTooth Low Energy control to this project. I am using the Serial BlueTooth Terminal Andriod APP to add some remote control for our NEOpixels. BLE is a relatively complex protocol so it is beyond the scope of this Exploration to discuss all of the software in detail. BLE uses a type of client/server paradigm which can confuse us. In this project the device running the APP is considered as the client and our ESP-C3 and it's firmware as the server. The BLE framework is broken up into a somewhat bewildering array of services, profiles, attributes and characteristics. A server could be offering several services, some of which are predefined, but others may be custom. In our case we will be defining a Serial Port Profile (SPP) service, which is what the APP expects to find. Most of the code given in the example is taken from the Espressif spp_server example. I have named the profile as "CanHobby NeoPixels". It should be noted that BLE makes extensive us of UUIDs when naming service, attributes, characteristics etc. We do not need to acquire any of our own - we are using the predefined SPP profile. We will be using the Read Client feature to retrieve commands from the app to control tasks and animations in our code.

I need to make the disclaimer that this exploration is just that - a superficial example of how to accomplish this task - rather than a full blown application. It is up to the user to embellish with their own animations and possible control structures to integrate with the BLE APP.

In it's present form we see 4 tasks running animations on 3 strips. Strip 0 and 1 are running sample animations for the Espressif example which feature the use of sine functions to get smooth continuous variations of colour and intensity. I have included some much simpler animation for purposes of illustration. The animD and animD1 both run on the same strip, but in different segments so we can visualize the usage of segments. Their parameters are setup just before the tasks are created. Throughout the code we use strip structure to hold the parameters for each strip. There is an array of 5 segments, each of which can hold 9 parameters. The parameters do not have fixed names, although there is a set of logical definitions if we wish to use them for code readability.

Using the APP - If there are no other devices offering the SPP protocol near you the APP should default to connecting to our server. Just make sure we are on the BLE tab as opposed to BT Classic and hit the connect icon near the top. The APP should display connection success and we are ready to control our strips.

The BLE commands are divided into task and animation controls. They are very simple ACSII strings to make for easier parsing.

Task Control:

- Sx - Suspends Task #x (task # is in [ ] at the end of the TaskCreate call).

-Rx - Resumes a suspended task.

Animation Control:

- bxyz - changes strip 'x', segment 'y' brightness to 'z'.

Hint: z = Zero clears the strip, z = letter 'O' is max brightness.

- cxyz - changes strip 'x', segment 'y' to colour 'z'.

eg. "c010" will change the animation color to BLUE.

- dxyz - changes strip 'x', segment 'y' animation delay to 'z'.

Hint: z = Zero is very fast, z = letter 'O' is the slowest.

-C - clear.

If you find that the effects of a command seem to be incomplete, it is better to Suspend the task before issuing the command and then resume the task - alternatively just re-issue the command.

Note these control strings totally depend on the particular animation. The Espressif example animations will not act as expected.

I uploaded the complete BLE project to CanHobby. It is too big for github. Just create a separate directory called BLE and unzip it into that dir. Then open the dir as a workspace with the ESP-IDE.

Happy Exploring!!

CanHobby

remember - if you are looking to make your own PCBs with SMD/SMT technology there is no better provider than...

my PCB supplier

void show( void *arg ) {
	
uint8_t Stp = 0;
stps[0] = &NEO0;
stps[1] = &NEO1;
stps[2] = &NEO1;

ESP_LOGI( TAG, "Show Task starting" );
// printf("Show: len = %d, gpio = %d, name = %s\n", stps[Stp]->len, stps[Stp]->gpio, stps[Stp]->name );
  
while( 1 ) {
	
	for( Stp = 0; Stp < NUM_STRIPS; Stp++ ) {

	REG_WRITE( GPIO_FUNC0_OUT_SEL_CFG_REG + ( Stp * 4 ), 51 );	
     ESP_ERROR_CHECK( rmt_transmit( led_chan, encoder, stps[Stp]->pixels, NEO0.len * 3, &tx_cfg ));
     ESP_ERROR_CHECK(rmt_tx_wait_all_done( led_chan, portMAX_DELAY));
   	REG_WRITE( GPIO_FUNC0_OUT_SEL_CFG_REG + ( Stp * 4 ), 128 );

        }  //  end STPs
             vTaskDelay(pdMS_TO_TICKS(EXAMPLE_FRAME_DURATION_MS));
    }
}

/** NEO.h
 *  Created on: Oct. 17, 2024
 *  Updated on: Dec. 19, 2024
 *  Author: CanHobby.ca
 */

#ifndef USER_NEO_H_
#define USER_NEO_H_

#define NUM_STRIPS 3

#include "stdbool.h"
#include "stdlib.h"
#include "stdint.h"
#include "driver/rmt_tx.h"

#define START 0
#define END   1
#define SIZE  2
#define YY	  3
#define BRT	  4
#define DLY	  5
// #define FWD   1

#define FALSE 0
#define TRUE  1
// #define DMA	  FALSE // TRUE  //  FALSE

#define MAX_LEN    144 // Length of longest strip

//  We aren't using C++ but we will use this object for each strip
typedef struct {
	gpio_num_t gpio;
	uint8_t *pixels;
	uint16_t  len;
	uint8_t   segs[5][9]; // up to 5 segments with 9 static parameters
	char	 *name;
} strip;

#define RED 0x000400	// GRB  format
#define RDD 0x00FF00
#define grn 0x800000
#define grN 0x000001
#define GRN 0x030000
#define BLU 0x000005
#define MAG 0x000403
#define YEL 0x030300
#define CYN 0x030005
#define BLK 0x000000
#define WHT 0x040201

// Colour offsets
#define BLUE 2
#define REDD 1
#define GREN 0

#endif /* USER_NEO_H_ */

     
void rmt_setup( ) {
	
	 ESP_LOGI(TAG, "rmt SetUp" );
    
    rmt_tx_channel_config_t tx_chan_config = {
        .clk_src = RMT_CLK_SRC_DEFAULT, // select source clock
        .gpio_num = 0,
        .mem_block_symbols = 64, // increase the block size to reduce LED flickering
        .resolution_hz = RMT_LED_STRIP_RESOLUTION_HZ,
        .trans_queue_depth = 16, // set the number of transactions that can be pending in the background
    };

    ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &led_chan ));
    
 	ESP_LOGI(TAG, "Create simple callback-based encoder");
	encoder = NULL;
 	
 	    const rmt_simple_encoder_config_t simple_encoder_cfg = {
        .callback = encoder_callback
        //Note we don't set min_chunk_size here as the default of 64 is good enough.
    };
    ESP_ERROR_CHECK(rmt_new_simple_encoder(&simple_encoder_cfg, &encoder ));
 	
 	ESP_ERROR_CHECK(rmt_enable( led_chan ));

	tx_cfg.loop_count = 0;
 
}

void anim1( void *arg  ) {

 strip *strp = (strip *)arg;
 uint8_t x, c = GREN, idx = 1;
 uint8_t start =  strp->segs[ idx ][ START ] - 1;
 uint8_t  end  =  strp->segs[ idx ][ END ];

// printf( "anim1 Dly = %d\n", strp->segs[ idx ][ DLY ] ); 
// printf( "anim1 %d : %d, %s [%d] -> %d\n", strp->segs[ idx ][ START ], strp->segs[ idx ][ END ], strp->name, idx, strp->gpio );
 
 ESP_LOGI(TAG, "Start tetis"); 
while(1) {

for( x=start; x<end; x++ ) {

 if( strp->pixels[ x*3 + c%3 ] != 7 ) { strp->pixels[ x*3 + c%3 ] = 7; }
 else { strp->pixels[ x*3 + c%3 ] =  0; }
strp->pixels[ x*3 + c%3 ] =  0;
 c++;
 if( c > 2 ) c = 0;
 	vTaskDelay( strp->segs[ idx ][ DLY ] );
	}
	}
}

void anim2( void *arg  ) {

 strip *strp = (strip *)arg;
 uint8_t x, rn, idx = 0;
static uint8_t start, end;

start = strp->segs[ idx ][ START ] - 1;
 end  = strp->segs[ idx ][ END ];
 
  ESP_LOGI(TAG, "Start anim2");
// printf( "anim2 Dly = %d\n", strp->segs[ idx ][ DLY ] );
// printf( "anim2: %d : %d -- %s [%d] -> %d\n", strp->segs[ idx ][ START ], strp->segs[ idx ][ END ], strp->name, idx, strp->gpio );  

while(1) {

for( x=start; x<end; x++ ) {
	
getrandom( &rn, 1, 0 );  //  get RNG value

// if( strp->pixels[ x*3 + BLUE ] != 17 ) { strp->pixels[ x*3 + BLUE ] = 17; }
// else { strp->pixels[ x*3 + BLUE ] =  0; }

strp->pixels[ x*3 + (rn%3) ] = (rn&0x1f); // &0x2f;

	vTaskDelay( strp->segs[ idx ][ DLY ] );
	}
  }
}

void app_main(void)
{
printf("\nSimple rainbow APP\n");

uint8_t buff;
getrandom( &buff, 1, 0 );
printf("RNG = %d\n", buff & 15 );

rmt_setup();

strip_setup( &NEO0, 15, 0, "neo0" );
strip_setup( &NEO1, 15, 2, "neo1" );

/******  Setup Animation parameters  ********/

NEO0.segs[0][START] = 1;
NEO0.segs[0][END]   = 13;
NEO0.segs[0][DLY]   = 5;

NEO1.segs[1][START] = 3;
NEO1.segs[1][END]   = 14;
NEO1.segs[1][DLY]   = 3;

NEO0.segs[1][START] = 1;
NEO0.segs[1][END]   = 5;
NEO0.segs[1][DLY]   = 15;

NEO0.segs[2][START] = 7;
NEO0.segs[2][END]   = 10;

xTaskCreate( show, "Show", 4048, &NEO0, 9, NULL );
 
 xTaskCreate( anim1, "Anim1", 2824, &NEO1, 5, NULL);
 xTaskCreate( anim2, "Anim2", 2824, &NEO0, 5, NULL);
// xTaskCreate( rainbow, "rbow", 1824, &NEO0, 5, NULL);

}

Credits

CanHobby Explorations

2 projects • 0 followers

Self Taught on MCU hard and software since before PCs existed. Sporadically do videos and blogs, mostly exploring small RISC-V MCUs.

Contact

Thanks to PCBway.

Comments

Please log in or sign up to comment.

ESP-C3 NeoPixels with RMT & BLE

Things used in this project

Hardware components

Software apps and online services

Story

OverView:

WorkFlow:

RNG

BLE

Code

show()

NEO.h

rmt_setup()

strip_setup()

anim1()

anim2()

app_main.c

Credits

CanHobby Explorations

Comments

Embed the widget on your own site

ESP-C3 NeoPixels with RMT & BLE

ESP-C3 NeoPixels with RMT & BLE

Things used in this project

Hardware components

Software apps and online services

Story

OverView:

WorkFlow:

RNG

BLE

Code

show()

NEO.h

rmt_setup()

strip_setup()

anim1()

anim2()

app_main.c

Credits

CanHobby Explorations

Comments

Related channels and tags