feedc0de/NeoPixelBus
1
0
Fork 0
forked from Makuna/NeoPixelBus
Code Pull Requests Activity

Three four cadences (#827)

Browse Source 
i2s x1, x8, x16 now use a 3 step cadence (33% & 66% pulse width) by default saving 25% memory in DMA buffer.
ESP32 & ESP32S2
This commit is contained in:
Michael Miller
2024-08-25 19:59:32 -07:00
committed by GitHub
parent 4b96e0d666
commit 8a13d6f0f4
10 changed files with 792 additions and 532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/internal/NeoMethods.h
View File

@@ -26,6 +26,9 @@ License along with NeoPixel. If not, see
-------------------------------------------------------------------------*/
#pragma once
// helper constants for method speeds and invert
#include "methods/NeoBits.h"
// Generic Two Wire (clk and data) methods
//
#include "methods/DotStarGenericMethod.h"

13
src/internal/NeoUtil.h
View File

@@ -112,4 +112,17 @@ public:
return (b * 0x0202020202ULL & 0x010884422010ULL) % 1023;
}
*/
template<typename T_TYPE> static void PrintBin(T_TYPE value)
{
const size_t CountBits = sizeof(value) * 8;
const T_TYPE BitMask = 1 << (CountBits - 1);
for (uint8_t bit = 0; bit < CountBits; bit++)
{
Serial.print((value & BitMask) ? "1" : "0");
value <<= 1;
}
}
};

1
src/internal/animations/NeoPixelAnimator.cpp
View File

@@ -25,7 +25,6 @@ License along with NeoPixel. If not, see
-------------------------------------------------------------------------*/
#include <Arduino.h>
#include "NeoPixelBus.h"
#include "NeoPixelAnimator.h"
NeoPixelAnimator::NeoPixelAnimator(uint16_t countAnimations, uint16_t timeScale) :

178
src/internal/methods/Esp32_i2s.c
View File

@@ -67,7 +67,11 @@
#include "esp32-hal.h"
esp_err_t i2sSetClock(uint8_t bus_num, uint8_t div_num, uint8_t div_b, uint8_t div_a, uint8_t bck, uint8_t bits_per_sample);
esp_err_t i2sSetSampleRate(uint8_t bus_num, uint32_t sample_rate, bool parallel_mode, size_t bytes_per_sample);
esp_err_t i2sSetSampleRate(uint8_t bus_num,
uint16_t dmaBitPerDataBit,
uint16_t nsBitSendTime,
bool parallel_mode,
size_t bytesPerSample);
#define MATRIX_DETACH_OUT_SIG 0x100
@@ -144,14 +148,22 @@ inline void dmaItemInit(lldesc_t* item, uint8_t* posData, size_t sizeData, lldes
item->qe.stqe_next = itemNext;
}
bool i2sInitDmaItems(uint8_t bus_num, uint8_t* data, size_t dataSize, bool parallel_mode, size_t bytes_per_sample)
bool i2sInitDmaItems(uint8_t bus_num,
uint8_t* data,
size_t dataSize,
bool parallel_mode,
size_t bytesPerSample)
{
if (bus_num >= NEO_I2S_COUNT)
{
return false;
}
size_t silenceSize = parallel_mode ? I2S_DMA_SILENCE_SIZE * 8 * bytes_per_sample : I2S_DMA_SILENCE_SIZE;
// silenceSize is minimum data size to loop i2s for reset
// it is not the actual reset time, but parallel mode needs
// a bit more time since the data is x8/x16
size_t silenceSize = parallel_mode ?
I2S_DMA_SILENCE_SIZE * 8 * bytesPerSample : I2S_DMA_SILENCE_SIZE;
size_t dmaCount = I2S[bus_num].dma_count;
if (I2S[bus_num].dma_items == NULL)
@@ -240,13 +252,14 @@ esp_err_t i2sSetClock(uint8_t bus_num,
return ESP_FAIL;
}
//log_i("i2sSetClock bus %u, clkm_div_num %u, clk_div_a %u, clk_div_b %u, bck_div_num %u, bits_mod %u",
// bus_num,
// div_num,
// div_a,
// div_b,
// bck,
// bits);
log_i("i2sSetClock bus %u,\n clkm_div_num %u,\n clk_div_a %u,\n clk_div_b %u,\n bck_div_num %u,\n bits_mod %u,\n i2sClkBase %u",
bus_num,
div_num,
div_a,
div_b,
bck,
bits,
I2S_BASE_CLK);
i2s_dev_t* i2s = I2S[bus_num].bus;
@@ -270,9 +283,9 @@ esp_err_t i2sSetClock(uint8_t bus_num,
typeof(i2s->sample_rate_conf) sample_rate_conf;
sample_rate_conf.val = 0;
sample_rate_conf.tx_bck_div_num = bck;
sample_rate_conf.rx_bck_div_num = bck;
// sample_rate_conf.rx_bck_div_num = 4;
sample_rate_conf.tx_bits_mod = bits;
sample_rate_conf.rx_bits_mod = bits;
// sample_rate_conf.rx_bits_mod = bits;
i2s->sample_rate_conf.val = sample_rate_conf.val;
return ESP_OK;
@@ -298,63 +311,39 @@ void i2sSetPins(uint8_t bus_num,
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// S2 only has one bus
//
// single output I2S0O_DATA_OUT23_IDX
// in parallel mode
// 8bit mode : I2S0O_DATA_OUT16_IDX ~I2S0O_DATA_OUT23_IDX
// 16bit mode : I2S0O_DATA_OUT8_IDX ~I2S0O_DATA_OUT23_IDX
// 24bit mode : I2S0O_DATA_OUT0_IDX ~I2S0O_DATA_OUT23_IDX
if (parallel == -1)
i2sSignal = I2S0O_DATA_OUT23_IDX;
if (parallel != -1)
{
i2sSignal = I2S0O_DATA_OUT23_IDX;
}
else if (busSampleSize == 1)
{
i2sSignal = I2S0O_DATA_OUT16_IDX + parallel;
}
else if (busSampleSize == 2)
{
i2sSignal = I2S0O_DATA_OUT8_IDX + parallel;
}
else
{
i2sSignal = I2S0O_DATA_OUT0_IDX + parallel;
i2sSignal -= ((busSampleSize * 8) - 1);
i2sSignal += parallel;
}
#else
if (bus_num == 0)
i2sSignal = I2S0O_DATA_OUT0_IDX;
if (bus_num == 1)
{
// in parallel mode
// 0-7 bits : I2S0O_DATA_OUT16_IDX ~I2S0O_DATA_OUT23_IDX
// 8-15 bits : I2S0O_DATA_OUT8_IDX ~I2S0O_DATA_OUT23_IDX
// 16-23 bits : I2S0O_DATA_OUT0_IDX ~I2S0O_DATA_OUT23_IDX
if (parallel == -1)
{
i2sSignal = I2S0O_DATA_OUT23_IDX;
}
else if (parallel < 8)
{
i2sSignal = I2S0O_DATA_OUT16_IDX + parallel;
}
else if (parallel < 16)
{
i2sSignal = I2S0O_DATA_OUT8_IDX + parallel - 8;
}
else
{
i2sSignal = I2S0O_DATA_OUT0_IDX + parallel - 16;
}
i2sSignal = I2S1O_DATA_OUT0_IDX;
}
if (parallel == -1)
{
i2sSignal += 23; // yup, single channel is on 23
}
else
{
if (parallel == -1)
if (busSampleSize == 2)
{
i2sSignal = I2S1O_DATA_OUT23_IDX;
}
else
{
i2sSignal = I2S1O_DATA_OUT0_IDX + parallel;
i2sSignal += 8; // yup, 16 bits starts at 8
}
i2sSignal += parallel; // add the parallel channel index
}
#endif
//log_i("i2sSetPins bus %u, i2sSignal %u, pin %u, mux %u",
// bus_num,
@@ -365,6 +354,7 @@ void i2sSetPins(uint8_t bus_num,
}
}
/* not used, but left around for reference
void i2sSetClkWsPins(uint8_t bus_num,
int8_t outClk,
bool invertClk,
@@ -400,6 +390,7 @@ void i2sSetClkWsPins(uint8_t bus_num,
gpio_matrix_out(outWs, i2sSignalWs, invertWs, false);
}
}
*/
bool i2sWriteDone(uint8_t bus_num)
{
@@ -413,8 +404,9 @@ bool i2sWriteDone(uint8_t bus_num)
void i2sInit(uint8_t bus_num,
bool parallel_mode,
size_t bytes_per_sample,
uint32_t sample_rate,
size_t bytesPerSample,
uint16_t dmaBitPerDataBit,
uint16_t nsBitSendTime,
i2s_tx_chan_mod_t chan_mod,
i2s_tx_fifo_mod_t fifo_mod,
size_t dma_count,
@@ -430,7 +422,7 @@ void i2sInit(uint8_t bus_num,
I2S_DMA_SILENCE_BLOCK_COUNT_FRONT +
I2S_DMA_SILENCE_BLOCK_COUNT_BACK;
if (!i2sInitDmaItems(bus_num, data, dataSize, parallel_mode, bytes_per_sample))
if (!i2sInitDmaItems(bus_num, data, dataSize, parallel_mode, bytesPerSample))
{
return;
}
@@ -479,7 +471,12 @@ void i2sInit(uint8_t bus_num,
typeof(i2s->conf2) conf2;
conf2.val = 0;
conf2.lcd_en = parallel_mode;
conf2.lcd_tx_wrx2_en = 0; // parallel_mode; // ((parallel_mode) && (bytes_per_sample == 2));
if ((parallel_mode) && (bytesPerSample == 1))
{
conf2.lcd_tx_wrx2_en = 1;
conf2.lcd_tx_sdx2_en = 0;
}
i2s->conf2.val = conf2.val;
}
@@ -501,11 +498,11 @@ void i2sInit(uint8_t bus_num,
typeof(i2s->fifo_conf) fifo_conf;
fifo_conf.val = 0;
fifo_conf.rx_fifo_mod_force_en = 0;
// fifo_conf.rx_fifo_mod_force_en = 1; //?
fifo_conf.tx_fifo_mod_force_en = 1;
fifo_conf.tx_fifo_mod = fifo_mod; // 0-right&left channel;1-one channel
fifo_conf.rx_fifo_mod = fifo_mod; // 0-right&left channel;1-one channel
fifo_conf.rx_data_num = 32; //Thresholds.
// fifo_conf.rx_fifo_mod = fifo_mod; // 0-right&left channel;1-one channel
// fifo_conf.rx_data_num = 32; //Thresholds.
fifo_conf.tx_data_num = 32;
i2s->fifo_conf.val = fifo_conf.val;
@@ -515,8 +512,8 @@ void i2sInit(uint8_t bus_num,
typeof(i2s->conf1) conf1;
conf1.val = 0;
conf1.tx_pcm_conf = 1;
conf1.rx_pcm_bypass = 1;
// conf1.tx_pcm_conf = 1;
// conf1.rx_pcm_bypass = 1;
conf1.tx_stop_en = 0;
conf1.tx_pcm_bypass = 1;
@@ -527,7 +524,7 @@ void i2sInit(uint8_t bus_num,
typeof(i2s->conf_chan) conf_chan;
conf_chan.val = 0;
conf_chan.tx_chan_mod = chan_mod; // 0-two channel;1-right;2-left;3-righ;4-left
conf_chan.rx_chan_mod = chan_mod; // 0-two channel;1-right;2-left;3-righ;4-left
// conf_chan.rx_chan_mod = chan_mod; // 0-two channel;1-right;2-left;3-righ;4-left
i2s->conf_chan.val = conf_chan.val;
}
@@ -535,19 +532,28 @@ void i2sInit(uint8_t bus_num,
typeof(i2s->conf) conf;
conf.val = 0;
conf.tx_msb_shift = !parallel_mode; // 0:DAC/PCM, 1:I2S
conf.tx_right_first = 0; // parallel_mode?;
conf.tx_right_first = 1; // parallel_mode? but no?
conf.tx_short_sync = 0;
// conf.tx_msb_right = 1;
#if defined(CONFIG_IDF_TARGET_ESP32S2)
conf.tx_dma_equal = parallel_mode;
#endif
i2s->conf.val = conf.val;
}
i2s->timing.val = 0;
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
i2s->pdm_conf.rx_pdm_en = 0;
// i2s->pdm_conf.rx_pdm_en = 0;
i2s->pdm_conf.tx_pdm_en = 0;
#endif
i2sSetSampleRate(bus_num, sample_rate, parallel_mode, bytes_per_sample);
i2sSetSampleRate(bus_num,
dmaBitPerDataBit,
nsBitSendTime,
parallel_mode,
bytesPerSample);
/* */
//Reset FIFO/DMA -> needed? Doesn't dma_reset/fifo_reset do this?
@@ -602,28 +608,34 @@ void i2sDeinit(uint8_t bus_num)
}
esp_err_t i2sSetSampleRate(uint8_t bus_num,
uint32_t rate,
uint16_t dmaBitPerDataBit,
uint16_t nsBitSendTime,
bool parallel_mode,
size_t bytes_per_sample)
size_t bytesPerSample)
{
const double I2sClkMhz = (double)I2S_BASE_CLK / 1000000; // 160000000 = 160.0
const size_t bits_per_sample = bytesPerSample * 8;
if (bus_num >= NEO_I2S_COUNT)
{
return ESP_FAIL;
}
uint8_t bck = 8;
uint8_t bck = 4; // must be 2+ due to ESP32S2 adjustment below
double clkSampleAdj = 1.0;
// parallel mode needs a higher sample rate
//
if (parallel_mode)
if (!parallel_mode)
{
rate *= bytes_per_sample;
#if defined(CONFIG_IDF_TARGET_ESP32S2)
bck *= bytes_per_sample;
#endif
// non-parallel uses two values in the sample
// so the clock calcs need to adjust for this
// as it makes output faster
clkSampleAdj *= 2.0;
}
double clkmdiv = (double)I2S_BASE_CLK / (rate * 256.0);
double clkmdiv = (double)nsBitSendTime / bytesPerSample / dmaBitPerDataBit / bck / 1000.0 * I2sClkMhz * clkSampleAdj;
if (clkmdiv > 256.0)
{
@@ -634,12 +646,20 @@ esp_err_t i2sSetSampleRate(uint8_t bus_num,
{
log_e("rate is too fast, clkmdiv = %f (%u, %u, %u)",
clkmdiv,
rate,
nsBitSendTime,
parallel_mode,
bytes_per_sample);
bytesPerSample);
return ESP_FAIL;
}
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// ESP32S2 is just different
if (parallel_mode && bytesPerSample == 1)
{
bck /= 2;
}
#endif
// calc integer and franctional for more precise timing
//
uint8_t clkmInteger = clkmdiv;
@@ -654,7 +674,7 @@ esp_err_t i2sSetSampleRate(uint8_t bus_num,
divB,
divA,
bck,
bytes_per_sample * 8);
bits_per_sample);
return ESP_OK;
}

5
src/internal/methods/Esp32_i2s.h
View File

@@ -34,7 +34,8 @@ typedef enum {
void i2sInit(uint8_t bus_num,
bool parallel_mode,
size_t bytes_per_sample,
uint32_t sample_rate,
uint16_t dmaBitPerDataBit,
uint16_t nsBitSendTime,
i2s_tx_chan_mod_t chan_mod,
i2s_tx_fifo_mod_t fifo_mod,
size_t dma_count,
@@ -46,11 +47,13 @@ void i2sSetPins(uint8_t bus_num,
int8_t parallel,
int8_t busSampleSize,
bool invert);
/*
void i2sSetClkWsPins(uint8_t bus_num,
int8_t outClk,
bool invertClk,
int8_t outWs,
bool invertWs);
*/
bool i2sWrite(uint8_t bus_num);
bool i2sWriteDone(uint8_t bus_num);
#ifdef NEOPIXELBUS_I2S_DEBUG

10
src/internal/methods/FractionClk.c
View File

@@ -26,16 +26,18 @@ License along with NeoPixel. If not, see
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include "stdlib.h"
// UnitDecimalToFractionClks
// Given unit decimal (floating point value less than 1.0),
// return a fraction numerator and denomenator that closesly matches that
// return a fraction numerator and denominator that closely matches that
//
// resultN - the address of the variable to place the numerator result
// resultD - the address of the variable to place the denomenator result
// unitDecimal - the decimal value that is less than 1.0 and greater than/eaual 0.0
// accuracy - the accuracy needed to match for a fractionals (0.000001 is a good start)
// resultD - the address of the variable to place the denominator result
// unitDecimal - the decimal value that is less than 1.0 and greater than/equal 0.0
// accuracy - the accuracy needed to match for a fractional (0.000001 is a good start)
//
void UnitDecimalToFractionClks(uint8_t* resultN,
uint8_t* resultD,

103
src/internal/methods/NeoBits.h Normal file
View File

@@ -0,0 +1,103 @@
#pragma once
/*-------------------------------------------------------------------------
NeoPixel library helper functions for Methods.
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus 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.
NeoPixelBus 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 NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
// --------------------------------------------------------
class NeoBitsSpeedWs2812x
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 300;
};
class NeoBitsSpeedWs2805
{
public:
const static uint16_t BitSendTimeNs = 1125;
const static uint16_t ResetTimeUs = 300; // spec is 280, intentionally longer for compatiblity use
};
class NeoBitsSpeedSk6812
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 80;
};
class NeoBitsSpeedTm1814
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoBitsSpeedTm1914
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoBitsSpeedTm1829
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoBitsSpeed800Kbps
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 50;
};
class NeoBitsSpeed400Kbps
{
public:
const static uint16_t BitSendTimeNs = 2500;
const static uint16_t ResetTimeUs = 50;
};
class NeoBitsSpeedApa106
{
public:
const static uint16_t BitSendTimeNs = 1710;
const static uint16_t ResetTimeUs = 50;
};
//---------------------------------------------------------
class NeoBitsNotInverted
{
public:
const static bool Inverted = false;
};
class NeoBitsInverted
{
public:
const static bool Inverted = true;
};

358
src/internal/methods/NeoEsp32I2sMethod.h
View File

@@ -36,81 +36,6 @@ extern "C"
#include "Esp32_i2s.h"
}
const uint16_t c_dmaBytesPerPixelBytes = 4;
// --------------------------------------------------------
class NeoEsp32I2sSpeedWs2812x
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 300;
};
class NeoEsp32I2sSpeedWs2805
{
public:
const static uint32_t I2sSampleRate = 114678; // 917431 hz / 8 = 114678
const static uint16_t ByteSendTimeUs = 9;
const static uint16_t ResetTimeUs = 300; // spec is 280, intentionally longer for compatiblity use
};
class NeoEsp32I2sSpeedSk6812
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 80;
};
class NeoEsp32I2sSpeedTm1814
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32I2sSpeedTm1914
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32I2sSpeedTm1829
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32I2sSpeed800Kbps
{
public:
const static uint32_t I2sSampleRate = 100000;
const static uint16_t ByteSendTimeUs = 10;
const static uint16_t ResetTimeUs = 50;
};
class NeoEsp32I2sSpeed400Kbps
{
public:
const static uint32_t I2sSampleRate = 50000;
const static uint16_t ByteSendTimeUs = 20;
const static uint16_t ResetTimeUs = 50;
};
class NeoEsp32I2sSpeedApa106
{
public:
const static uint32_t I2sSampleRate = 72960; // 588,235 hz / 8 = 73,529 sample rate
const static uint16_t ByteSendTimeUs = 14;
const static uint16_t ResetTimeUs = 50;
};
// --------------------------------------------------------
class NeoEsp32I2sBusZero
{
@@ -142,20 +67,116 @@ public:
};
// --------------------------------------------------------
class NeoEsp32I2sNotInverted
// 4 step cadence, so pulses are 1/4 and 3/4 of pulse width
//
class NeoEsp32I2sCadence4Step
{
public:
const static bool Inverted = false;
const static size_t DmaBitsPerPixelBit = 4; // 4 step cadence, matches encoding
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData)
{
const uint16_t bitpatterns[16] =
{
0b1000100010001000, 0b1000100010001110, 0b1000100011101000, 0b1000100011101110,
0b1000111010001000, 0b1000111010001110, 0b1000111011101000, 0b1000111011101110,
0b1110100010001000, 0b1110100010001110, 0b1110100011101000, 0b1110100011101110,
0b1110111010001000, 0b1110111010001110, 0b1110111011101000, 0b1110111011101110,
};
uint16_t* pDma = reinterpret_cast<uint16_t*>(dmaBuffer);
const uint8_t* pEnd = data + sizeData;
for (const uint8_t* pSrc = data; pSrc < pEnd; pSrc++)
{
*(pDma++) = bitpatterns[((*pSrc) >> 4) & 0x0f];
*(pDma++) = bitpatterns[((*pSrc) & 0x0f)];
}
}
};
class NeoEsp32I2sInverted
// fedc ba98 7654 3210
// 0000 0000 0000 0000
// 111
// 3 step cadence, so pulses are 1/3 and 2/3 of pulse width
//
class NeoEsp32I2sCadence3Step
{
public:
const static bool Inverted = true;
const static size_t DmaBitsPerPixelBit = 3; // 3 step cadence, matches encoding
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData)
{
const uint16_t OneBit = 0b00000110;
const uint16_t ZeroBit = 0b00000100;
const uint8_t SrcBitMask = 0x80;
const size_t BitsInSample = sizeof(uint16_t) * 8;
uint16_t* pDma = reinterpret_cast<uint16_t*>(dmaBuffer);
uint16_t dmaValue = 0;
uint8_t destBitsLeft = BitsInSample;
const uint8_t* pSrc = data;
const uint8_t* pEnd = pSrc + sizeData;
while (pSrc < pEnd)
{
uint8_t value = *(pSrc++);
for (uint8_t bitSrc = 0; bitSrc < 8; bitSrc++)
{
const uint16_t Bit = ((value & SrcBitMask) ? OneBit : ZeroBit);
if (destBitsLeft > 3)
{
destBitsLeft -= 3;
dmaValue |= Bit << destBitsLeft;
#if defined(NEO_DEBUG_DUMP_I2S_BUFFER)
NeoUtil::PrintBin<uint32_t>(dmaValue);
Serial.print(" < ");
Serial.println(destBitsLeft);
#endif
}
else if (destBitsLeft <= 3)
{
uint8_t bitSplit = (3 - destBitsLeft);
dmaValue |= Bit >> bitSplit;
#if defined(NEO_DEBUG_DUMP_I2S_BUFFER)
NeoUtil::PrintBin<uint32_t>(dmaValue);
Serial.print(" > ");
Serial.println(bitSplit);
#endif
// next dma value, store and reset
*(pDma++) = dmaValue;
dmaValue = 0;
destBitsLeft = BitsInSample - bitSplit;
if (bitSplit)
{
dmaValue |= Bit << destBitsLeft;
}
#if defined(NEO_DEBUG_DUMP_I2S_BUFFER)
NeoUtil::PrintBin<uint32_t>(dmaValue);
Serial.print(" v ");
Serial.println(bitSplit);
#endif
}
// Next
value <<= 1;
}
}
// store the remaining bits
*pDma++ = dmaValue;
}
};
// --------------------------------------------------------
template<typename T_SPEED, typename T_BUS, typename T_INVERT> class NeoEsp32I2sMethodBase
template<typename T_SPEED, typename T_BUS, typename T_INVERT, typename T_CADENCE> class NeoEsp32I2sMethodBase
{
public:
typedef NeoNoSettings SettingsObject;
@@ -203,7 +224,8 @@ public:
i2sInit(_bus.I2sBusNumber,
false,
2, // bytes per sample
T_SPEED::I2sSampleRate,
T_CADENCE::DmaBitsPerPixelBit,
T_SPEED::BitSendTimeNs,
I2S_CHAN_STEREO,
I2S_FIFO_16BIT_DUAL,
dmaBlockCount,
@@ -220,7 +242,36 @@ public:
yield();
}
FillBuffers();
T_CADENCE::EncodeIntoDma(_i2sBuffer, _data, _sizeData);
#if defined(NEO_DEBUG_DUMP_I2S_BUFFER)
// dump the is2buffer
uint8_t* pDma = _i2sBuffer;
uint8_t* pEnd = pDma + _i2sBufferSize;
size_t index = 0;
Serial.println();
Serial.println("NeoEspI2sMethod - i2sBufferDump: ");
while (pDma < pEnd)
{
uint8_t value = *pDma;
// a single bit pulse of data
if ((index % 4) == 0)
{
Serial.println();
}
NeoUtil::PrintBin<uint8_t>(value);
Serial.print(" ");
pDma++;
index++;
}
Serial.println();
#endif // NEO_DEBUG_DUMP_I2S_BUFFER
i2sWrite(_bus.I2sBusNumber);
}
@@ -263,9 +314,9 @@ private:
// must have a 4 byte aligned buffer for i2s
// since the reset/silence at the end is used for looping
// it also needs to 4 byte aligned
size_t dmaSettingsSize = c_dmaBytesPerPixelBytes * settingsSize;
size_t dmaPixelSize = c_dmaBytesPerPixelBytes * pixelSize;
size_t resetSize = NeoUtil::RoundUp(c_dmaBytesPerPixelBytes * T_SPEED::ResetTimeUs / T_SPEED::ByteSendTimeUs, 4);
size_t dmaSettingsSize = T_CADENCE::DmaBitsPerPixelBit * settingsSize;
size_t dmaPixelSize = T_CADENCE::DmaBitsPerPixelBit * pixelSize;
size_t resetSize = NeoUtil::RoundUp(T_CADENCE::DmaBitsPerPixelBit * T_SPEED::ResetTimeUs / (T_SPEED::BitSendTimeNs * 8 / 1000), 4);
_i2sBufferSize = NeoUtil::RoundUp(pixelCount * dmaPixelSize + dmaSettingsSize, 4) +
resetSize;
@@ -276,93 +327,86 @@ private:
memset(_i2sBuffer, 0x00, _i2sBufferSize);
}
void FillBuffers()
{
const uint16_t bitpatterns[16] =
{
0b1000100010001000, 0b1000100010001110, 0b1000100011101000, 0b1000100011101110,
0b1000111010001000, 0b1000111010001110, 0b1000111011101000, 0b1000111011101110,
0b1110100010001000, 0b1110100010001110, 0b1110100011101000, 0b1110100011101110,
0b1110111010001000, 0b1110111010001110, 0b1110111011101000, 0b1110111011101110,
};
uint16_t* pDma = reinterpret_cast<uint16_t*>(_i2sBuffer);
uint8_t* pEnd = _data + _sizeData;
for (uint8_t* pPixel = _data; pPixel < pEnd; pPixel++)
{
*(pDma++) = bitpatterns[((*pPixel) & 0x0f)];
*(pDma++) = bitpatterns[((*pPixel) >> 4) & 0x0f];
}
}
};
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Ws2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Ws2805Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Sk6812Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Tm1814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Tm1829Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Tm1914Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Apa106Method;
#if defined(NPB_CONF_4STEP_CADENCE)
typedef NeoEsp32I2sCadence4Step NeoEsp32I2sCadence;
#else
typedef NeoEsp32I2sCadence3Step NeoEsp32I2sCadence;
#endif
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Ws2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Ws2805Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Sk6812Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1814Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1829Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1914Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Apa106Method;
typedef NeoEsp32I2s0Ws2805Method NeoEsp32I2s0Ws2814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Ws2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0SWs2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Sk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Tm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Tm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusZero, NeoEsp32I2sNotInverted> NeoEsp32I2s0Tm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusZero, NeoEsp32I2sInverted> NeoEsp32I2s0Apa106InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Ws2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0SWs2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Sk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusZero, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Tm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusZero, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s0Apa106InvertedMethod;
typedef NeoEsp32I2s0SWs2805InvertedMethod NeoEsp32I2s0SWs2814InvertedMethod;
#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
// (SOC_I2S_NUM == 2)
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Ws2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Ws2805Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Sk6812Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Tm1814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Tm1829Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Tm1914Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Apa106Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Ws2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Ws2805Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Sk6812Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1814Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1829Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1914Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Apa106Method;
typedef NeoEsp32I2s1Ws2805Method NeoEsp32I2s1Ws2814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Ws2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Ws2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Sk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Tm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Tm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusOne, NeoEsp32I2sNotInverted> NeoEsp32I2s1Tm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusOne, NeoEsp32I2sInverted> NeoEsp32I2s1Apa106InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Ws2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Ws2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Sk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusOne, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Tm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusOne, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2s1Apa106InvertedMethod;
typedef NeoEsp32I2s1Ws2805InvertedMethod NeoEsp32I2s1Ws2814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNWs2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNWs2805Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNSk6812Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNTm1814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNTm1829Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNTm1914Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sN800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sN400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNApa106Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNWs2812xMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNWs2805Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNSk6812Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1814Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1829Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1914Method;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sN800KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sN400KbpsMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNApa106Method;
typedef NeoEsp32I2sNWs2805Method NeoEsp32I2sNWs2814Method;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNWs2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNWs2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNSk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNTm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNTm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2sBusN, NeoEsp32I2sNotInverted> NeoEsp32I2sNTm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sN800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sN400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2sBusN, NeoEsp32I2sInverted> NeoEsp32I2sNApa106InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNWs2812xInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNWs2805InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNSk6812InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1814InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1829InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2sBusN, NeoBitsNotInverted, NeoEsp32I2sCadence> NeoEsp32I2sNTm1914InvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sN800KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sN400KbpsInvertedMethod;
typedef NeoEsp32I2sMethodBase<NeoBitsSpeedApa106, NeoEsp32I2sBusN, NeoBitsInverted, NeoEsp32I2sCadence> NeoEsp32I2sNApa106InvertedMethod;
typedef NeoEsp32I2sNWs2805InvertedMethod NeoEsp32I2sNWs2814InvertedMethod;
#endif
@@ -370,7 +414,7 @@ typedef NeoEsp32I2sNWs2805InvertedMethod NeoEsp32I2sNWs2814InvertedMethod;
#if !defined(NEOPIXEL_ESP32_RMT_DEFAULT) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
// I2s Bus 1 method is the default method for Esp32
// Esp32 S2 & C3 & S3 will use RMT as the default allways
// Esp32 S2 & C3 & S3 will use RMT as the default always
typedef NeoEsp32I2s1Ws2812xMethod NeoWs2813Method;
typedef NeoEsp32I2s1Ws2812xMethod NeoWs2812xMethod;
typedef NeoEsp32I2s1800KbpsMethod NeoWs2812Method;

487
src/internal/methods/NeoEsp32I2sXMethod.h
View File

@@ -48,26 +48,153 @@ extern "C"
// 0123456789abcdef
// efcdab8967452301
// 3 step cadence, so pulses are 1/3 and 2/3 of pulse width
//
// true size of mux channel, 8 bit
//
class NeoEspI2sMuxBusSize8Bit
class NeoEspI2sMuxBusSize8Bit3Step
{
public:
NeoEspI2sMuxBusSize8Bit() {};
NeoEspI2sMuxBusSize8Bit3Step() {};
const static size_t MuxBusDataSize = 1;
const static size_t DmaBitsPerPixelBit = 4; // 4 step cadence, matches endcoding
const static size_t DmaBitsPerPixelBit = 3; // 3 step cadence, matches encoding
// by using a 3 step cadence, the dma data can't be updated with a single OR operation as
// its value resides across a non-uint16_t aligned 3 element type, so it requires two separate OR
// operations to update a single pixel bit, the last element can be skipped as its always 0
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData, uint8_t muxId)
{
uint8_t* pDma = dmaBuffer;
const uint8_t* pValue = data;
const uint8_t* pEnd = pValue + sizeData;
const uint8_t muxBit = 0x1 << muxId;
#if defined(CONFIG_IDF_TARGET_ESP32S2)
const uint8_t offsetMap[] = { 0, 1, 2, 3 }; // i2s sample is two 16bit values
#else
const uint8_t offsetMap[] = { 2,3,0,1 }; // i2s sample is two 16bit values
#endif
uint8_t offset = 0;
while (pValue < pEnd)
{
uint8_t value = *(pValue++);
for (uint8_t bit = 0; bit < 8; bit++)
{
// first cadence step init to 1
pDma[offsetMap[offset]] |= muxBit;
offset++;
if (offset > 3)
{
offset %= 4;
pDma += 4;
}
// second cadence step set based on bit
if (value & 0x80)
{
pDma[offsetMap[offset]] |= muxBit;
}
// last cadence step already init to 0, skip it
offset += 2;
if (offset > 3)
{
offset %= 4;
pDma += 4;
}
// Next
value <<= 1;
}
}
}
};
// 3 step cadence, so pulses are 1/3 and 2/3 of pulse width
//
class NeoEspI2sMuxBusSize16Bit3Step
{
public:
NeoEspI2sMuxBusSize16Bit3Step() {};
const static size_t MuxBusDataSize = 2;
const static size_t DmaBitsPerPixelBit = 3; // 3 step cadence, matches encoding
// by using a 3 step cadence, the dma data can't be updated with a single OR operation as
// its value resides across a non-uint32_t aligned 3 element type, so it requires two seperate OR
// operations to update a single pixel bit, the last element can be skipped as its always 0
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData, uint8_t muxId)
{
uint16_t* pDma = reinterpret_cast<uint16_t*>(dmaBuffer);
const uint8_t* pValue = data;
const uint8_t* pEnd = pValue + sizeData;
const uint16_t muxBit = 0x1 << muxId;
#if defined(CONFIG_IDF_TARGET_ESP32S2)
const uint8_t offsetMap[] = { 0, 1, 2, 3 }; // i2s sample is two 16bit values
#else
const uint8_t offsetMap[] = { 1, 0, 3, 2 }; // i2s sample is two 16bit values
#endif
uint8_t offset = 0;
while (pValue < pEnd)
{
uint8_t value = *(pValue++);
for (uint8_t bit = 0; bit < 8; bit++)
{
// first cadence step init to 1
pDma[offsetMap[offset]] |= muxBit;
offset++;
if (offset > 3)
{
offset %= 4;
pDma += 4;
}
// second cadence step set based on bit
if (value & 0x80)
{
pDma[offsetMap[offset]] |= muxBit;
}
offset++;
// last cadence step already 0, skip it
offset++;
if (offset > 3)
{
offset %= 4;
pDma += 4;
}
// Next
value <<= 1;
}
}
}
};
// 4 step cadence, so pulses are 1/4 and 3/4 of pulse width
//
class NeoEspI2sMuxBusSize8Bit4Step
{
public:
NeoEspI2sMuxBusSize8Bit4Step() {};
const static size_t MuxBusDataSize = 1;
const static size_t DmaBitsPerPixelBit = 4; // 4 step cadence, matches encoding
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData, uint8_t muxId)
{
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// 1234 - order
// 3412 = actual due to endianness
// 00000001
const uint32_t EncodedZeroBit = 0x00000100;
// 00010101
const uint32_t EncodedOneBit = 0x01000101;
const uint32_t EncodedZeroBit = 0x00000001;
const uint32_t EncodedOneBit = 0x00010101;
#else
// 8 channel bits layout for DMA 32bit value
// note, right to left
@@ -106,78 +233,38 @@ public:
}
};
// 4 step cadence, so pulses are 1/4 and 3/4 of pulse width
//
// true size of mux channel, 16 bit
//
class NeoEspI2sMuxBusSize16Bit
class NeoEspI2sMuxBusSize16Bit4Step
{
public:
NeoEspI2sMuxBusSize16Bit() {};
NeoEspI2sMuxBusSize16Bit4Step() {};
const static size_t MuxBusDataSize = 2;
const static size_t DmaBitsPerPixelBit = 4; // 4 step cadence, matches endcoding
const static size_t DmaBitsPerPixelBit = 4; // 4 step cadence, matches encoding
static void EncodeIntoDma(uint8_t* dmaBuffer, const uint8_t* data, size_t sizeData, uint8_t muxId)
{
#if defined(CONFIG_IDF_TARGET_ESP32S2)
const uint64_t EncodedZeroBit64 = 0x0000000000000001;
const uint64_t EncodedOneBit64 = 0x0000000100010001;
#else
// 1234 5678 - order
// 3412 7856 = actual due to endianness
// not swap 0000000000000001
const uint64_t EncodedZeroBit64 = 0x0000000000010000;
// no swap 0000000100010001
const uint64_t EncodedOneBit64 = 0x0001000000010001;
// can be shifted by 8!
#endif
Fillx16(dmaBuffer,
data,
sizeData,
muxId,
EncodedZeroBit64,
EncodedOneBit64);
#else
// 16 channel bits layout for DMA 64bit value
// note, right to left, destination is 32bit chunks
// due to indianness between peripheral and cpu,
// bytes within the words are swapped and words within dwords
// in the literal constants
// { } { }
// 0123 4567 89ab cdef - order of bytes in literal constant
// efcd ab89 6745 2301 - order of memory on ESP32 due to Endianness
// 6745 2301 efcd ab89 - 32bit dest means only map using 32bits so swap upper and lower
//
// Due to final bit locations, can't shift encoded one bit
// either left more than 7 or right more than 7 so we have to
// split the updates and use different encodings
if (muxId < 8)
{
// endian + dest swap 0000000000000001
const uint64_t EncodedZeroBit64 = 0x0000000001000000;
// endian + dest swap 0000000100010001
const uint64_t EncodedOneBit64 = 0x0100000001000100;
// cant be shifted by 8!
Fillx16(dmaBuffer,
data,
sizeData,
muxId,
EncodedZeroBit64,
EncodedOneBit64);
}
else
{
// endian + dest swap 0000000000000001
// then pre shift by 8 0000000000000100
const uint64_t EncodedZeroBit64 = 0x0000000000010000;
// endian + dest swap 0000000100010001
// then pre shift by 8 0000010001000100
const uint64_t EncodedOneBit64 = 0x0001000000010001;
Fillx16(dmaBuffer,
data,
sizeData,
muxId - 8, // preshifted
EncodedZeroBit64,
EncodedOneBit64);
}
#endif
}
protected:
@@ -189,13 +276,14 @@ protected:
const uint64_t EncodedOneBit64)
{
uint64_t* pDma64 = reinterpret_cast<uint64_t*>(dmaBuffer);
const uint8_t* pEnd = data + sizeData;
const uint8_t* pSrc = data;
const uint8_t* pEnd = pSrc + sizeData;
const uint64_t OneBit = EncodedOneBit64 << muxShift;
const uint64_t ZeroBit = EncodedZeroBit64 << muxShift;
for (const uint8_t* pPixel = data; pPixel < pEnd; pPixel++)
while (pSrc < pEnd)
{
uint8_t value = *pPixel;
uint8_t value = *(pSrc++);
for (uint8_t bit = 0; bit < 8; bit++)
{
@@ -206,6 +294,7 @@ protected:
value <<= 1;
}
}
}
};
@@ -213,7 +302,7 @@ protected:
// tracks mux channels used and if updated
//
// T_FLAG - type used to store bit flags, UINT8_t for 8 channels, UINT16_t for 16
// T_MUXSIZE - true size of mux channel = NeoEspI2sMuxBusSize8Bit or NeoEspI2sMuxBusSize16Bit
// T_MUXSIZE - true size of mux channel = NeoEspI2sMuxBusSize8Bit4Step or NeoEspI2sMuxBusSize16Bit4Step
//
template<typename T_FLAG, typename T_MUXSIZE>
class NeoEspI2sMuxMap : public T_MUXSIZE
@@ -334,7 +423,7 @@ public:
{
}
void Construct(const uint8_t busNumber, uint32_t i2sSampleRate)
void Construct(const uint8_t busNumber, uint16_t nsBitSendTime)
{
// construct only once on first time called
if (I2sBuffer == nullptr)
@@ -364,12 +453,13 @@ public:
i2sInit(busNumber,
true,
T_MUXMAP::MuxBusDataSize,
i2sSampleRate,
T_MUXMAP::DmaBitsPerPixelBit,
nsBitSendTime,
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// using these modes on ESP32S2 actually allows it to function
// in both x8 and x16
I2S_CHAN_STEREO,
I2S_FIFO_16BIT_DUAL,
I2S_CHAN_RIGHT_TO_LEFT,
I2S_FIFO_16BIT_SINGLE, // I2S_FIFO_32BIT_SINGLE
#else
// but they won't work on ESP32 in parallel mode, but these will
I2S_CHAN_RIGHT_TO_LEFT,
@@ -403,6 +493,38 @@ public:
{
if (MuxMap.IsAllMuxBusesUpdated())
{
#if defined(NEO_DEBUG_DUMP_I2S_BUFFER)
// dump the is2buffer
uint8_t* pDma = I2sBuffer;
uint8_t* pEnd = pDma + I2sBufferSize;
size_t index = 0;
Serial.println();
Serial.println("NeoEspI2sMonoBuffContext - i2sBufferDump: ");
while (pDma < pEnd)
{
uint8_t value = *pDma;
// a single bit pulse of data
if ((index % (T_MUXMAP::DmaBitsPerPixelBit * T_MUXMAP::MuxBusDataSize)) == 0)
{
Serial.println();
}
for (uint8_t bit = 0; bit < 8; bit++)
{
Serial.print((value & 0x80) ? "1" : "0");
value <<= 1;
}
Serial.print(" ");
pDma++;
index++;
}
Serial.println();
#endif // NEO_DEBUG_DUMP_I2S_BUFFER
MuxMap.ResetMuxBusesUpdated();
i2sWrite(i2sBusNumber);
}
@@ -424,7 +546,7 @@ public:
// so the buffer must be cleared first
if (MuxMap.IsNoMuxBusesUpdate())
{
// clear all the data in preperation for each mux channel to add
// clear all the data in preparation for each mux channel to add
memset(I2sBuffer, 0x00, I2sBufferSize);
}
@@ -462,21 +584,18 @@ public:
// but without it presence they get zeroed far too late
NeoEspI2sDblBuffContext()
//:
//I2sBufferSize(0),
//I2sBuffer(nullptr),
//I2sEditBuffer(nullptr),
//MuxMap()
{
}
void Construct(const uint8_t busNumber, uint32_t i2sSampleRate)
void Construct(const uint8_t busNumber, uint16_t nsBitSendTime)
{
// construct only once on first time called
if (I2sBuffer == nullptr)
{
// MuxMap.MaxBusDataSize = max size in bytes of a single channel
// DmaBitsPerPixelBit = how many dma bits/byte are needed for each source (pixel) bit/byte
// T_MUXMAP::MuxBusDataSize = the true size of data for selected mux mode (not exposed size as i2s0 only supports 16bit mode)
// T_MUXMAP::MuxBusDataSize = the true size of data for selected mux mode (not exposed size as
// i2s0 only supports 16bit mode)
I2sBufferSize = MuxMap.MaxBusDataSize * 8 * T_MUXMAP::DmaBitsPerPixelBit * T_MUXMAP::MuxBusDataSize;
// must have a 4 byte aligned buffer for i2s
@@ -507,12 +626,13 @@ public:
i2sInit(busNumber,
true,
T_MUXMAP::MuxBusDataSize,
i2sSampleRate,
T_MUXMAP::DmaBitsPerPixelBit,
nsBitSendTime,
#if defined(CONFIG_IDF_TARGET_ESP32S2)
// using these modes on ESP32S2 actually allows it to function
// in both x8 and x16
I2S_CHAN_STEREO,
I2S_FIFO_16BIT_DUAL,
I2S_CHAN_RIGHT_TO_LEFT,
I2S_FIFO_16BIT_SINGLE,
#else
// but they won't work on ESP32 in parallel mode, but these will
I2S_CHAN_RIGHT_TO_LEFT,
@@ -610,9 +730,9 @@ public:
_muxId = s_context.MuxMap.RegisterNewMuxBus(dataSize);
}
void Initialize(uint8_t pin, uint32_t i2sSampleRate, bool invert)
void Initialize(uint8_t pin, uint16_t nsBitSendTime, bool invert)
{
s_context.Construct(T_BUS::I2sBusNumber, i2sSampleRate);
s_context.Construct(T_BUS::I2sBusNumber, nsBitSendTime);
i2sSetPins(T_BUS::I2sBusNumber, pin, _muxId, s_context.MuxMap.MuxBusDataSize, invert);
}
@@ -660,9 +780,9 @@ template<typename T_BUSCONTEXT, typename T_BUS> T_BUSCONTEXT NeoEsp32I2sMuxBus<T
//
// wrapping layer of the i2s mux bus as a NeoMethod
//
// T_SPEED - NeoEsp32I2sSpeed* (ex NeoEsp32I2sSpeedWs2812x) used to define output signal form
// T_SPEED - NeoBitsSpeed* (ex NeoBitsSpeedWs2812x) used to define output signal form
// T_BUS - NeoEsp32I2sMuxBus, the bus to use
// T_INVERT - NeoEsp32I2sNotInverted or NeoEsp32I2sInverted, will invert output signal
// T_INVERT - NeoBitsNotInverted or NeoBitsInverted, will invert output signal
//
template<typename T_SPEED, typename T_BUS, typename T_INVERT>
class NeoEsp32I2sXMethodBase
@@ -675,7 +795,7 @@ public:
_pin(pin),
_bus()
{
_bus.RegisterNewMuxBus(_sizeData + T_SPEED::ResetTimeUs / T_SPEED::ByteSendTimeUs);
_bus.RegisterNewMuxBus(_sizeData + T_SPEED::ResetTimeUs / (T_SPEED::BitSendTimeNs * 8 / 1000));
}
~NeoEsp32I2sXMethodBase()
@@ -697,7 +817,7 @@ public:
void Initialize()
{
_bus.Initialize(_pin, T_SPEED::I2sSampleRate, T_INVERT::Inverted);
_bus.Initialize(_pin, T_SPEED::BitSendTimeNs, T_INVERT::Inverted);
_data = static_cast<uint8_t*>(malloc(_sizeData));
if (_data == nullptr)
@@ -743,41 +863,70 @@ private:
uint8_t* _data; // Holds LED color values
};
#if defined(NPB_CONF_4STEP_CADENCE)
//------------------------------------
#if defined(CONFIG_IDF_TARGET_ESP32S2)
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit4Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit4Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit>>, NeoEsp32I2sBusZero> NeoEsp32I2s0DblMux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit4Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0DblMux8Bus;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s0DblMux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8DblWs2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0DblMux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8DblWs2812xMethod;
#else
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize16Bit>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize16Bit4Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit4Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit4Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit4Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit>>, NeoEsp32I2sBusOne> NeoEsp32I2s1DblMux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit4Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1DblMux8Bus;
#endif
#else // NPB_CONF_3STEP_CADENCE
//------------------------------------
#if defined(CONFIG_IDF_TARGET_ESP32S2)
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit3Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit3Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit3Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0DblMux8Bus;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0DblMux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8DblWs2812xMethod;
#else
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize16Bit3Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit3Step>>, NeoEsp32I2sBusZero> NeoEsp32I2s0Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit3Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux8Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sMonoBuffContext<NeoEspI2sMuxMap<uint16_t, NeoEspI2sMuxBusSize16Bit3Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1Mux16Bus;
typedef NeoEsp32I2sMuxBus<NeoEspI2sDblBuffContext<NeoEspI2sMuxMap<uint8_t, NeoEspI2sMuxBusSize8Bit3Step>>, NeoEsp32I2sBusOne> NeoEsp32I2s1DblMux8Bus;
#endif
#endif
// NORMAL
//
// I2s0x8
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Apa106Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Apa106Method;
typedef NeoEsp32I2s0X8Ws2805Method NeoEsp32I2s0X8Ws2814Method;
typedef NeoEsp32I2s0X8Ws2812xMethod NeoEsp32I2s0X8Ws2813Method;
@@ -788,15 +937,15 @@ typedef NeoEsp32I2s0X8800KbpsMethod NeoEsp32I2s0X8Ws2812Method;
typedef NeoEsp32I2s0X8Sk6812Method NeoEsp32I2s0X8Lc8812Method;
// I2s0x16
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Apa106Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Apa106Method;
typedef NeoEsp32I2s0X16Ws2805Method NeoEsp32I2s0X16Ws2814Method;
typedef NeoEsp32I2s0X16Ws2812xMethod NeoEsp32I2s0X16Ws2813Method;
@@ -809,17 +958,17 @@ typedef NeoEsp32I2s0X16Sk6812Method NeoEsp32I2s0X16Lc8812Method;
#if !defined(CONFIG_IDF_TARGET_ESP32S2)
// I2s1x8
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s1DblMux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8DblWs2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s1DblMux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8DblWs2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Apa106Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Apa106Method;
typedef NeoEsp32I2s1X8Ws2805Method NeoEsp32I2s1X8Ws2814Method;
typedef NeoEsp32I2s1X8Ws2812xMethod NeoEsp32I2s1X8Ws2813Method;
@@ -830,15 +979,15 @@ typedef NeoEsp32I2s1X8800KbpsMethod NeoEsp32I2s1X8Ws2812Method;
typedef NeoEsp32I2s1X8Sk6812Method NeoEsp32I2s1X8Lc8812Method;
// I2s1x16
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Apa106Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Ws2812xMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Ws2805Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Sk6812Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Tm1814Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Tm1829Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Tm1914Method;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16800KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16400KbpsMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Apa106Method;
typedef NeoEsp32I2s1X16Ws2805Method NeoEsp32I2s1X16Ws2814Method;
typedef NeoEsp32I2s1X16Ws2812xMethod NeoEsp32I2s1X16Ws2813Method;
@@ -854,15 +1003,15 @@ typedef NeoEsp32I2s1X16Sk6812Method NeoEsp32I2s1X16Lc8812Method;
// INVERTED
//
// I2s0x8 INVERTED
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X8Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s0Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X8Apa106InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s0Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s0X8Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s0Mux8Bus, NeoBitsInverted> NeoEsp32I2s0X8Apa106InvertedMethod;
typedef NeoEsp32I2s0X8Ws2805InvertedMethod NeoEsp32I2s0X8Ws2814InvertedMethod;
typedef NeoEsp32I2s0X8Ws2812xInvertedMethod NeoEsp32I2s0X8Ws2813InvertedMethod;
@@ -874,15 +1023,15 @@ typedef NeoEsp32I2s0X8Sk6812InvertedMethod NeoEsp32I2s0X8Lc8812InvertedMethod;
// I2s0x16 INVERTED
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s0X16Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s0Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s0X16Apa106InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s0Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s0X16Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s0Mux16Bus, NeoBitsInverted> NeoEsp32I2s0X16Apa106InvertedMethod;
typedef NeoEsp32I2s0X16Ws2805InvertedMethod NeoEsp32I2s0X16Ws2814InvertedMethod;
typedef NeoEsp32I2s0X16Ws2812xInvertedMethod NeoEsp32I2s0X16Ws2813InvertedMethod;
@@ -895,15 +1044,15 @@ typedef NeoEsp32I2s0X16Sk6812InvertedMethod NeoEsp32I2s0X16Lc8812InvertedMethod
#if !defined(CONFIG_IDF_TARGET_ESP32S2)
// I2s1x8 INVERTED
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X8Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s1Mux8Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X8Apa106InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s1Mux8Bus, NeoBitsNotInverted> NeoEsp32I2s1X8Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s1Mux8Bus, NeoBitsInverted> NeoEsp32I2s1X8Apa106InvertedMethod;
typedef NeoEsp32I2s1X8Ws2805InvertedMethod NeoEsp32I2s1X8Ws2814InvertedMethod;
typedef NeoEsp32I2s1X8Ws2812xInvertedMethod NeoEsp32I2s1X8Ws2813InvertedMethod;
@@ -914,15 +1063,15 @@ typedef NeoEsp32I2s1X8800KbpsInvertedMethod NeoEsp32I2s1X8Ws2812InvertedMethod;
typedef NeoEsp32I2s1X8Sk6812InvertedMethod NeoEsp32I2s1X8Lc8812InvertedMethod;
// I2s1x16 INVERTED
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2812x, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedWs2805, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedSk6812, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1814, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1829, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedTm1914, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sNotInverted> NeoEsp32I2s1X16Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed800Kbps, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeed400Kbps, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoEsp32I2sSpeedApa106, NeoEsp32I2s1Mux16Bus, NeoEsp32I2sInverted> NeoEsp32I2s1X16Apa106InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Ws2812xInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedWs2805, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Ws2805InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedSk6812, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Sk6812InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1814, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Tm1814InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1829, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Tm1829InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedTm1914, NeoEsp32I2s1Mux16Bus, NeoBitsNotInverted> NeoEsp32I2s1X16Tm1914InvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16800KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16400KbpsInvertedMethod;
typedef NeoEsp32I2sXMethodBase<NeoBitsSpeedApa106, NeoEsp32I2s1Mux16Bus, NeoBitsInverted> NeoEsp32I2s1X16Apa106InvertedMethod;
typedef NeoEsp32I2s1X16Ws2805InvertedMethod NeoEsp32I2s1X16Ws2814InvertedMethod;
typedef NeoEsp32I2s1X16Ws2812xInvertedMethod NeoEsp32I2s1X16Ws2813InvertedMethod;

166
src/internal/methods/NeoEsp32LcdXMethod.h
View File

@@ -43,6 +43,7 @@ extern "C"
//
// true size of mux channel, 8 bit
// 3 step cadence, so pulses are 1/3 and 2/3 of pulse width
//
class NeoEspLcdMuxBusSize8Bit
{
@@ -72,14 +73,14 @@ public:
// first cadence step init to 1
*(pDma++) |= muxBit;
// second candence step set based on bit
// second cadence step set based on bit
if (value & 0x80)
{
*(pDma) |= muxBit;
}
pDma++;
// last candence step already init to 0, skip it
// last cadence step already init to 0, skip it
pDma++;
// Next
@@ -91,6 +92,7 @@ public:
//
// true size of mux channel, 16 bit
// 3 step cadence, so pulses are 1/3 and 2/3 of pulse width
//
class NeoEspLcdMuxBusSize16Bit
{
@@ -119,14 +121,14 @@ public:
// first cadence step init to 1
*(pDma++) |= muxBit;
// second candence step set based on bit
// second cadence step set based on bit
if (value & 0x80)
{
*(pDma) |= muxBit;
}
pDma++;
// last candence step already init to 0, skip it
// last cadence step already init to 0, skip it
pDma++;
// Next
@@ -251,7 +253,6 @@ static IRAM_ATTR bool dma_callback(gdma_channel_handle_t dma_chan,
// Manages the underlying I2S details including the buffer
// This creates only a actively sending back buffer,
// Note that the back buffer must be DMA memory, a limited resource
// Assumes a 3 step candence, so pulses are 1/3 and 2/3 of pulse width
//
// T_MUXMAP - NeoEspLcdMuxMap - tracking class for mux state
//
@@ -590,9 +591,9 @@ template<typename T_BUSCONTEXT> T_BUSCONTEXT NeoEsp32LcdMuxBus<T_BUSCONTEXT>::s_
//
// wrapping layer of the lcd mux bus as a NeoMethod
//
// T_SPEED - NeoEsp32LcdSpeed* (ex NeoEsp32LcdSpeedWs2812x) used to define output signal form
// T_SPEED - NeoBitsSpeed* (ex NeoBitsSpeedWs2812x) used to define output signal form
// T_BUS - NeoEsp32LcdMuxBus, the bus to use
// T_INVERT - NeoEsp32LcdNotInverted or NeoEsp32LcdInverted, will invert output signal
// T_INVERT - NeoBitsNotInverted or NeoBitsInverted, will invert output signal
//
template<typename T_SPEED, typename T_BUS, typename T_INVERT>
class NeoEsp32LcdXMethodBase
@@ -605,7 +606,7 @@ public:
_pin(pin),
_bus()
{
size_t numResetBytes = T_SPEED::ResetTimeUs / (T_SPEED::BitSendTimeNs*8/1000);
size_t numResetBytes = T_SPEED::ResetTimeUs / (T_SPEED::BitSendTimeNs * 8 / 1000);
_bus.RegisterNewMuxBus(_sizeData + numResetBytes);
}
@@ -680,95 +681,18 @@ private:
typedef NeoEsp32LcdMuxBus<NeoEspLcdMonoBuffContext<NeoEspLcdMuxMap<uint8_t, NeoEspLcdMuxBusSize8Bit>>> NeoEsp32LcdMux8Bus;
typedef NeoEsp32LcdMuxBus<NeoEspLcdMonoBuffContext<NeoEspLcdMuxMap<uint16_t, NeoEspLcdMuxBusSize16Bit>>> NeoEsp32LcdMux16Bus;
// --------------------------------------------------------
class NeoEsp32LcdSpeedWs2812x
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 300;
};
class NeoEsp32LcdSpeeWs2805
{
public:
const static uint16_t BitSendTimeNs = 1125;
const static uint16_t ResetTimeUs = 300; // spec is 280, intentionally longer for compatiblity use
};
class NeoEsp32LcdSpeeSk6812
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 80;
};
class NeoEsp32LcdSpeeTm1814
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32LcdSpeeTm1914
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32LcdSpeeTm1829
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 200;
};
class NeoEsp32LcdSpee800Kbps
{
public:
const static uint16_t BitSendTimeNs = 1250;
const static uint16_t ResetTimeUs = 50;
};
class NeoEsp32LcdSpee400Kbps
{
public:
const static uint16_t BitSendTimeNs = 2500;
const static uint16_t ResetTimeUs = 50;
};
class NeoEsp32LcdSpeeApa106
{
public:
const static uint16_t BitSendTimeNs = 1710;
const static uint16_t ResetTimeUs = 50;
};
//---------------------------------------------------------
class NeoEsp32LcdNotInverted
{
public:
const static bool Inverted = false;
};
class NeoEsp32LcdInverted
{
public:
const static bool Inverted = true;
};
//--------------------------------------------------------
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeedWs2812x, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Ws2812xMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeWs2805, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Ws2805Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeSk6812, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Sk6812Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1814, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Tm1814Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1914, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Tm1829Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1829, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Tm1914Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee800Kbps, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8800KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee400Kbps, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8400KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeApa106, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Apa106Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedWs2812x, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Ws2812xMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedWs2805, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Ws2805Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedSk6812, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Sk6812Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1814, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Tm1814Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1914, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Tm1829Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1829, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Tm1914Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8800KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8400KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedApa106, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Apa106Method;
typedef NeoEsp32LcdX8Ws2805Method NeoEsp32LcdX8Ws2814Method;
typedef NeoEsp32LcdX8Ws2812xMethod NeoEsp32LcdX8Ws2813Method;
@@ -778,15 +702,15 @@ typedef NeoEsp32LcdX8Ws2812xMethod NeoEsp32LcdX8Ws2816Method;
typedef NeoEsp32LcdX8800KbpsMethod NeoEsp32LcdX8Ws2812Method;
typedef NeoEsp32LcdX8Sk6812Method NeoEsp32LcdX8Lc8812Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeedWs2812x, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Ws2812xMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeWs2805, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Ws2805Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeSk6812, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Sk6812Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1814, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Tm1814Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1914, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Tm1829Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1829, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Tm1914Method;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee800Kbps, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16800KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee400Kbps, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16400KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeApa106, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Apa106Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeeddWs2812x, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Ws2812xMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedWs2805, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Ws2805Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedSk6812, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Sk6812Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1814, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Tm1814Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1914, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Tm1829Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1829, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Tm1914Method;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16800KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16400KbpsMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedApa106, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Apa106Method;
typedef NeoEsp32LcdX16Ws2805Method NeoEsp32LcdX16Ws2814Method;
typedef NeoEsp32LcdX16Ws2812xMethod NeoEsp32LcdX16Ws2813Method;
@@ -798,15 +722,15 @@ typedef NeoEsp32LcdX16Sk6812Method NeoEsp32LcdX16Lc8812Method;
//--------------------------------------------------------
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeedWs2812x, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Ws2812xInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeWs2805, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Ws2805InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeSk6812, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Sk6812InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1814, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Tm1814InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1914, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Tm1829InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1829, NeoEsp32LcdMux8Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX8Tm1914InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee800Kbps, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8800KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee400Kbps, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8400KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeApa106, NeoEsp32LcdMux8Bus, NeoEsp32LcdInverted> NeoEsp32LcdX8Apa106InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeeddWs2812x, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Ws2812xInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedWs2805, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Ws2805InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedSk6812, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Sk6812InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1814, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Tm1814InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1914, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Tm1829InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1829, NeoEsp32LcdMux8Bus, NeoBitsNotInverted> NeoEsp32LcdX8Tm1914InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8800KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8400KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedApa106, NeoEsp32LcdMux8Bus, NeoBitsInverted> NeoEsp32LcdX8Apa106InvertedMethod;
typedef NeoEsp32LcdX8Ws2805InvertedMethod NeoEsp32LcdX8Ws2814InvertedMethod;
typedef NeoEsp32LcdX8Ws2812xInvertedMethod NeoEsp32LcdX8Ws2813InvertedMethod;
@@ -816,15 +740,15 @@ typedef NeoEsp32LcdX8Ws2812xInvertedMethod NeoEsp32LcdX8Ws2816InvertedMethod;
typedef NeoEsp32LcdX8800KbpsInvertedMethod NeoEsp32LcdX8Ws2812InvertedMethod;
typedef NeoEsp32LcdX8Sk6812InvertedMethod NeoEsp32LcdX8Lc8812InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeedWs2812x, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Ws2812xInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeWs2805, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Ws2805InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeSk6812, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Sk6812InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1814, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Tm1814InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1914, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Tm1829InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeTm1829, NeoEsp32LcdMux16Bus, NeoEsp32LcdNotInverted> NeoEsp32LcdX16Tm1914InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee800Kbps, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16800KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpee400Kbps, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16400KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoEsp32LcdSpeeApa106, NeoEsp32LcdMux16Bus, NeoEsp32LcdInverted> NeoEsp32LcdX16Apa106InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeeddWs2812x, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Ws2812xInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedWs2805, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Ws2805InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedSk6812, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Sk6812InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1814, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Tm1814InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1914, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Tm1829InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedTm1829, NeoEsp32LcdMux16Bus, NeoBitsNotInverted> NeoEsp32LcdX16Tm1914InvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed800Kbps, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16800KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeed400Kbps, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16400KbpsInvertedMethod;
typedef NeoEsp32LcdXMethodBase<NeoBitsSpeedApa106, NeoEsp32LcdMux16Bus, NeoBitsInverted> NeoEsp32LcdX16Apa106InvertedMethod;
typedef NeoEsp32LcdX16Ws2805InvertedMethod NeoEsp32LcdX16Ws2814InvertedMethod;
typedef NeoEsp32LcdX16Ws2812xInvertedMethod NeoEsp32LcdX16Ws2813InvertedMethod;