473 lines
15 KiB
C++
473 lines
15 KiB
C++
/*
|
|
* Library for driving digital RGB(W) LEDs using the ESP32's RMT peripheral
|
|
*
|
|
* Modifications Copyright (c) 2017-2019 Martin F. Falatic
|
|
*
|
|
* Portions modified using FastLED's ClocklessController as a reference
|
|
* Copyright (c) 2018 Samuel Z. Guyer
|
|
* Copyright (c) 2017 Thomas Basler
|
|
*
|
|
* Based on public domain code created 19 Nov 2016 by Chris Osborn <fozztexx@fozztexx.com>
|
|
* http://insentricity.com
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "esp32_digital_led_lib.h"
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if defined(ARDUINO)
|
|
#include "esp32-hal.h"
|
|
#include "esp_intr.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/rmt.h"
|
|
#include "driver/periph_ctrl.h"
|
|
#include "freertos/semphr.h"
|
|
#include "soc/rmt_struct.h"
|
|
#elif defined(ESP_PLATFORM)
|
|
#include <esp_intr.h>
|
|
#include <driver/gpio.h>
|
|
#include <driver/rmt.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/semphr.h>
|
|
#include <soc/dport_reg.h>
|
|
#include <soc/gpio_sig_map.h>
|
|
#include <soc/rmt_struct.h>
|
|
#include <stdio.h>
|
|
#include <string.h> // memset, memcpy, etc. live here!
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
|
|
|
|
#if DEBUG_ESP32_DIGITAL_LED_LIB
|
|
extern char * digitalLeds_debugBuffer;
|
|
extern int digitalLeds_debugBufferSz;
|
|
#endif
|
|
|
|
static DRAM_ATTR const uint16_t MAX_PULSES = 32; // A channel has a 64 "pulse" buffer - we use half per pass
|
|
static DRAM_ATTR const uint16_t DIVIDER = 4; // 8 still seems to work, but timings become marginal
|
|
static DRAM_ATTR const double RMT_DURATION_NS = 12.5; // Minimum time of a single RMT duration based on clock ns
|
|
|
|
|
|
// Considering the RMT_INT_RAW_REG (raw int status) and RMT_INT_ST_REG (masked int status) registers (each 32-bit):
|
|
// Where op = {raw, st, ena, clr} and n = {0..7}
|
|
// Every three bits = RMT.int_<op>.ch<n>_tx_end, RMT.int_<op>.ch<n>_rx_end, RMT.int_<op>.ch<n>_err
|
|
// The final 8 bits are RMT.int_<op>.ch<n>_tx_thr_event
|
|
|
|
// LUT for mapping bits in RMT.int_<op>.ch<n>_tx_thr_event
|
|
static DRAM_ATTR const uint32_t tx_thr_event_offsets [] = {
|
|
static_cast<uint32_t>(1) << (24 + 0),
|
|
static_cast<uint32_t>(1) << (24 + 1),
|
|
static_cast<uint32_t>(1) << (24 + 2),
|
|
static_cast<uint32_t>(1) << (24 + 3),
|
|
static_cast<uint32_t>(1) << (24 + 4),
|
|
static_cast<uint32_t>(1) << (24 + 5),
|
|
static_cast<uint32_t>(1) << (24 + 6),
|
|
static_cast<uint32_t>(1) << (24 + 7),
|
|
};
|
|
|
|
// LUT for mapping bits in RMT.int_<op>.ch<n>_tx_end
|
|
static DRAM_ATTR const uint32_t tx_end_offsets [] = {
|
|
static_cast<uint32_t>(1) << (0 + 0) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 1) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 2) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 3) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 4) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 5) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 6) * 3,
|
|
static_cast<uint32_t>(1) << (0 + 7) * 3,
|
|
};
|
|
|
|
typedef union {
|
|
struct {
|
|
uint32_t duration0:15;
|
|
uint32_t level0:1;
|
|
uint32_t duration1:15;
|
|
uint32_t level1:1;
|
|
};
|
|
uint32_t val;
|
|
} rmtPulsePair;
|
|
|
|
typedef struct {
|
|
uint8_t * buf_data;
|
|
uint16_t buf_pos, buf_len, buf_half, buf_isDirty;
|
|
rmtPulsePair pulsePairMap[2];
|
|
bool isProcessing;
|
|
} digitalLeds_stateData;
|
|
|
|
double randDouble()
|
|
{
|
|
return double(esp_random()>>16) / (UINT16_MAX + 1);
|
|
}
|
|
|
|
pixelColor_t adjustByUniformFactor(pixelColor_t * color, double adjFactor) {
|
|
color->r = uint8_t(color->r * (1.0 - adjFactor));
|
|
color->g = uint8_t(color->g * (1.0 - adjFactor));
|
|
color->b = uint8_t(color->b * (1.0 - adjFactor));
|
|
color->w = uint8_t(color->w * (1.0 - adjFactor));
|
|
return *color;
|
|
}
|
|
|
|
|
|
const static int MAX_RMT_CHANNELS = 8;
|
|
static strand_t * strandDataPtrs[MAX_RMT_CHANNELS] = {nullptr}; // Indexed by RMT channel
|
|
|
|
// Forward declarations of local functions
|
|
static void copyHalfBlockToRmt(strand_t * pStrand);
|
|
static void rmtInterruptHandler(void *arg);
|
|
|
|
|
|
static xSemaphoreHandle gRmtSem = nullptr;
|
|
static intr_handle_t gRmtIntrHandle = nullptr;
|
|
|
|
static int gToProcess = 0;
|
|
|
|
|
|
#if defined(ARDUINO) && ARDUINO >= 100
|
|
void espPinMode(int pinNum, int pinDir) {
|
|
// Enable GPIO32 or 33 as output. Device-dependent
|
|
// (only works if these aren't used for external XTAL).
|
|
// https://esp32.com/viewtopic.php?t=9151#p38282
|
|
if (pinNum == 32 || pinNum == 33) {
|
|
uint64_t gpioBitMask = (pinNum == 32) ? 1ULL<<GPIO_NUM_32 : 1ULL<<GPIO_NUM_33;
|
|
gpio_mode_t gpioMode = (pinDir == OUTPUT) ? GPIO_MODE_OUTPUT : GPIO_MODE_INPUT;
|
|
gpio_config_t io_conf;
|
|
io_conf.intr_type = GPIO_INTR_DISABLE;
|
|
io_conf.mode = gpioMode;
|
|
io_conf.pin_bit_mask = gpioBitMask;
|
|
io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
|
|
io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
|
|
gpio_config(&io_conf);
|
|
}
|
|
else {
|
|
pinMode(pinNum, pinDir);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
void gpioSetup(int gpioNum, int gpioMode, int gpioVal) {
|
|
#if defined(ARDUINO) && ARDUINO >= 100
|
|
espPinMode(gpioNum, gpioMode);
|
|
digitalWrite (gpioNum, gpioVal);
|
|
#elif defined(ESP_PLATFORM)
|
|
gpio_num_t gpioNumNative = static_cast<gpio_num_t>(gpioNum);
|
|
gpio_mode_t gpioModeNative = static_cast<gpio_mode_t>(gpioMode);
|
|
gpio_pad_select_gpio(gpioNumNative);
|
|
gpio_set_direction(gpioNumNative, gpioModeNative);
|
|
gpio_set_level(gpioNumNative, gpioVal);
|
|
#endif
|
|
}
|
|
|
|
|
|
int digitalLeds_initDriver()
|
|
{
|
|
#if DEBUG_ESP32_DIGITAL_LED_LIB
|
|
snprintf(digitalLeds_debugBuffer, digitalLeds_debugBufferSz, "digitalLeds_initDriver\n");
|
|
#endif
|
|
|
|
esp_err_t rc = ESP_OK;
|
|
|
|
if (gRmtIntrHandle == nullptr) { // Only on first run
|
|
// Sem is created here
|
|
gRmtSem = xSemaphoreCreateBinary();
|
|
xSemaphoreGive(gRmtSem);
|
|
rc = esp_intr_alloc(ETS_RMT_INTR_SOURCE, 0, rmtInterruptHandler, nullptr, &gRmtIntrHandle);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
int digitalLeds_addStrands(strand_t * strands [], int numStrands)
|
|
{
|
|
for (int i = 0; i < numStrands; i++) {
|
|
int rmtChannel = strands[i]->rmtChannel;
|
|
strand_t * pStrand = strands[i];
|
|
strandDataPtrs[rmtChannel] = pStrand;
|
|
|
|
ledParams_t ledParams = ledParamsAll[pStrand->ledType];
|
|
|
|
pStrand->pixels = static_cast<pixelColor_t*>(malloc(pStrand->numPixels * sizeof(pixelColor_t)));
|
|
if (pStrand->pixels == nullptr) {
|
|
return -1;
|
|
}
|
|
|
|
pStrand->_stateVars = static_cast<digitalLeds_stateData*>(malloc(sizeof(digitalLeds_stateData)));
|
|
if (pStrand->_stateVars == nullptr) {
|
|
return -2;
|
|
}
|
|
digitalLeds_stateData * pState = static_cast<digitalLeds_stateData*>(pStrand->_stateVars);
|
|
|
|
pState->buf_len = (pStrand->numPixels * ledParams.bytesPerPixel);
|
|
pState->buf_data = static_cast<uint8_t*>(malloc(pState->buf_len));
|
|
if (pState->buf_data == nullptr) {
|
|
return -3;
|
|
}
|
|
|
|
// RMT configuration for transmission
|
|
rmt_config_t rmt_tx;
|
|
rmt_tx.channel = static_cast<rmt_channel_t>(rmtChannel);
|
|
rmt_tx.gpio_num = static_cast<gpio_num_t>(pStrand->gpioNum);
|
|
rmt_tx.rmt_mode = RMT_MODE_TX;
|
|
rmt_tx.mem_block_num = 1;
|
|
rmt_tx.clk_div = DIVIDER;
|
|
rmt_tx.tx_config.loop_en = false;
|
|
rmt_tx.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
|
|
rmt_tx.tx_config.carrier_en = false;
|
|
rmt_tx.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
|
|
rmt_tx.tx_config.idle_output_en = true;
|
|
rmt_config(&rmt_tx);
|
|
|
|
// RMT config for transmitting a '0' bit val to this LED strand
|
|
pState->pulsePairMap[0].level0 = 1;
|
|
pState->pulsePairMap[0].level1 = 0;
|
|
pState->pulsePairMap[0].duration0 = ledParams.T0H / (RMT_DURATION_NS * DIVIDER);
|
|
pState->pulsePairMap[0].duration1 = ledParams.T0L / (RMT_DURATION_NS * DIVIDER);
|
|
|
|
// RMT config for transmitting a '0' bit val to this LED strand
|
|
pState->pulsePairMap[1].level0 = 1;
|
|
pState->pulsePairMap[1].level1 = 0;
|
|
pState->pulsePairMap[1].duration0 = ledParams.T1H / (RMT_DURATION_NS * DIVIDER);
|
|
pState->pulsePairMap[1].duration1 = ledParams.T1L / (RMT_DURATION_NS * DIVIDER);
|
|
|
|
pState->isProcessing = false;
|
|
|
|
// Set interrupts
|
|
rmt_set_tx_thr_intr_en(static_cast<rmt_channel_t>(rmtChannel), true, MAX_PULSES); // sets rmt_set_tx_wrap_en and RMT.tx_lim_ch<n>.limit
|
|
}
|
|
|
|
digitalLeds_resetPixels(strands, numStrands);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int digitalLeds_removeStrands(strand_t * strands [], int numStrands)
|
|
{
|
|
digitalLeds_resetPixels(strands, numStrands);
|
|
|
|
for (int i = 0; i < numStrands; i++) {
|
|
int rmtChannel = strands[i]->rmtChannel;
|
|
strand_t * pStrand = strandDataPtrs[rmtChannel];
|
|
if (pStrand) {
|
|
strandDataPtrs[rmtChannel] = nullptr;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int digitalLeds_resetPixels(strand_t * strands [], int numStrands)
|
|
{
|
|
// TODO: The input is strands for convenience - the point is to get indicies of strands to draw
|
|
// Could just pass the channel numbers, but would it be slower to construct that list?
|
|
|
|
for (int i = 0; i < numStrands; i++) {
|
|
int rmtChannel = strands[i]->rmtChannel;
|
|
strand_t * pStrand = strandDataPtrs[rmtChannel];
|
|
memset(pStrand->pixels, 0, pStrand->numPixels * sizeof(pixelColor_t));
|
|
}
|
|
|
|
digitalLeds_drawPixels(strands, numStrands);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int IRAM_ATTR digitalLeds_drawPixels(strand_t * strands [], int numStrands)
|
|
{
|
|
// TODO: The input is strands for convenience - the point is to get indicies of strands to draw
|
|
// Could just pass the channel numbers, but would it be slower to construct that list?
|
|
|
|
if (numStrands == 0) {
|
|
return 0;
|
|
}
|
|
|
|
gToProcess = numStrands;
|
|
|
|
xSemaphoreTake(gRmtSem, portMAX_DELAY);
|
|
|
|
for (int i = 0; i < numStrands; i++) {
|
|
int rmtChannel = strands[i]->rmtChannel;
|
|
strand_t * pStrand = strandDataPtrs[rmtChannel];
|
|
|
|
digitalLeds_stateData * pState = static_cast<digitalLeds_stateData*>(pStrand->_stateVars);
|
|
ledParams_t ledParams = ledParamsAll[pStrand->ledType];
|
|
|
|
pState->isProcessing = true;
|
|
|
|
// Pack pixels into transmission buffer
|
|
if (ledParams.bytesPerPixel == 3) {
|
|
for (uint16_t i = 0; i < pStrand->numPixels; i++) {
|
|
// Color order is translated from RGB to GRB
|
|
pState->buf_data[0 + i * 3] = pStrand->pixels[i].g;
|
|
pState->buf_data[1 + i * 3] = pStrand->pixels[i].r;
|
|
pState->buf_data[2 + i * 3] = pStrand->pixels[i].b;
|
|
}
|
|
}
|
|
else if (ledParams.bytesPerPixel == 4) {
|
|
for (uint16_t i = 0; i < pStrand->numPixels; i++) {
|
|
// Color order is translated from RGBW to GRBW
|
|
pState->buf_data[0 + i * 4] = pStrand->pixels[i].g;
|
|
pState->buf_data[1 + i * 4] = pStrand->pixels[i].r;
|
|
pState->buf_data[2 + i * 4] = pStrand->pixels[i].b;
|
|
pState->buf_data[3 + i * 4] = pStrand->pixels[i].w;
|
|
}
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
|
|
pState->buf_pos = 0;
|
|
pState->buf_half = 0;
|
|
|
|
rmt_set_tx_intr_en(static_cast<rmt_channel_t>(rmtChannel), true);
|
|
|
|
copyHalfBlockToRmt(pStrand);
|
|
if (pState->buf_pos < pState->buf_len) { // Fill the other half of the buffer block
|
|
copyHalfBlockToRmt(pStrand);
|
|
}
|
|
|
|
// Starts RMT, which will end up giving us the semaphore back
|
|
// Immediately starts transmitting
|
|
rmt_set_tx_intr_en(static_cast<rmt_channel_t>(rmtChannel), true);
|
|
rmt_tx_start(static_cast<rmt_channel_t>(rmtChannel), true);
|
|
}
|
|
|
|
// Give back semaphore after drawing is done
|
|
xSemaphoreTake(gRmtSem, portMAX_DELAY);
|
|
xSemaphoreGive(gRmtSem);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static IRAM_ATTR void copyHalfBlockToRmt(strand_t * pStrand)
|
|
{
|
|
// This fills half an RMT block
|
|
// When wraparound is happening, we want to keep the inactive half of the RMT block filled
|
|
digitalLeds_stateData * pState = static_cast<digitalLeds_stateData*>(pStrand->_stateVars);
|
|
ledParams_t ledParams = ledParamsAll[pStrand->ledType];
|
|
|
|
uint16_t i, j, offset, len, byteval;
|
|
|
|
offset = pState->buf_half * MAX_PULSES;
|
|
pState->buf_half = !pState->buf_half;
|
|
|
|
len = pState->buf_len - pState->buf_pos;
|
|
if (len > (MAX_PULSES / 8))
|
|
len = (MAX_PULSES / 8);
|
|
|
|
if (!len) {
|
|
if (!pState->buf_isDirty) {
|
|
return;
|
|
}
|
|
// Clear the channel's data block and return
|
|
for (i = 0; i < MAX_PULSES; i++) {
|
|
RMTMEM.chan[pStrand->rmtChannel].data32[i + offset].val = 0;
|
|
}
|
|
pState->buf_isDirty = 0;
|
|
return;
|
|
}
|
|
pState->buf_isDirty = 1;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
byteval = pState->buf_data[i + pState->buf_pos];
|
|
|
|
// Shift bits out, MSB first, setting RMTMEM.chan[n].data32[x] to
|
|
// the rmtPulsePair value corresponding to the buffered bit value
|
|
for (j = 0; j < 8; j++, byteval <<= 1) {
|
|
int bitval = (byteval >> 7) & 0x01;
|
|
int data32_idx = i * 8 + offset + j;
|
|
RMTMEM.chan[pStrand->rmtChannel].data32[data32_idx].val = pState->pulsePairMap[bitval].val;
|
|
}
|
|
|
|
// Handle the reset bit by stretching duration1 for the final bit in the stream
|
|
if (i + pState->buf_pos == pState->buf_len - 1) {
|
|
RMTMEM.chan[pStrand->rmtChannel].data32[i * 8 + offset + 7].duration1 =
|
|
ledParams.TRS / (RMT_DURATION_NS * DIVIDER);
|
|
}
|
|
}
|
|
|
|
// Clear the remainder of the channel's data not set above
|
|
for (i *= 8; i < MAX_PULSES; i++) {
|
|
RMTMEM.chan[pStrand->rmtChannel].data32[i + offset].val = 0;
|
|
}
|
|
|
|
pState->buf_pos += len;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
static IRAM_ATTR void rmtInterruptHandler(void *arg)
|
|
{
|
|
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
|
|
|
|
for (int rmtChannel = 0; rmtChannel < MAX_RMT_CHANNELS; rmtChannel++) {
|
|
strand_t * pStrand = strandDataPtrs[rmtChannel];
|
|
if (pStrand == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
digitalLeds_stateData * pState = static_cast<digitalLeds_stateData*>(pStrand->_stateVars);
|
|
if (!pState->isProcessing) {
|
|
continue;
|
|
}
|
|
|
|
if (RMT.int_st.val & tx_thr_event_offsets[rmtChannel]) {
|
|
// We got an RMT.int_st.ch<n>_tx_thr_event interrupt because RMT.tx_lim_ch<n>.limit was crossed
|
|
RMT.int_clr.val |= tx_thr_event_offsets[rmtChannel]; // set RMT.int_clr.ch<n>_tx_thr_event (reset interrupt bit)
|
|
copyHalfBlockToRmt(pStrand);
|
|
}
|
|
else if (RMT.int_st.val & tx_end_offsets[rmtChannel]) {
|
|
// We got an RMT.int_st.ch<n>_tx_end interrupt with a zero-length entry which means we're done
|
|
RMT.int_clr.val |= tx_end_offsets[rmtChannel]; // set RMT.int_clr.ch<n>_tx_end (reset interrupt bit)
|
|
//gpio_matrix_out(static_cast<gpio_num_t>(pStrand->gpioNum), 0x100, 0, 0); // only useful if rmt_config keeps getting called
|
|
pState->isProcessing = false;
|
|
gToProcess--;
|
|
if (gToProcess == 0) {
|
|
xSemaphoreGiveFromISR(gRmtSem, &xHigherPriorityTaskWoken);
|
|
if (xHigherPriorityTaskWoken == pdTRUE) { // Perform cleanup if we're all done
|
|
portYIELD_FROM_ISR();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//**************************************************************************//
|