diff --git a/examples/NeoPixelAnimation/NeoPixelAnimation.ino b/examples/NeoPixelAnimation/NeoPixelAnimation.ino index 289a845..66b4d4a 100644 --- a/examples/NeoPixelAnimation/NeoPixelAnimation.ino +++ b/examples/NeoPixelAnimation/NeoPixelAnimation.ino @@ -26,14 +26,13 @@ const uint16_t PixelCount = 4; // make sure to set this to the number of pixels const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignored for Esp8266 NeoPixelBus strip(PixelCount, PixelPin); -// For Esp8266, the Pin is ignored and it uses GPIO3. +// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use. // There are other Esp8266 alternative methods that provide more pin options, but also have // other side effects. -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod also ignores the pin parameter and uses GPI02 -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod will work with all but pin 16, but is not stable with WiFi -// being active +//NeoPixelBus strip(PixelCount); +// +// NeoEsp8266Uart800KbpsMethod uses GPI02 instead + // NeoPixel animation time management object NeoPixelAnimator animations(PixelCount, NEO_CENTISECONDS); diff --git a/examples/NeoPixelBitmap/NeoPixelBitmap.ino b/examples/NeoPixelBitmap/NeoPixelBitmap.ino index 39c2f25..56071b2 100644 --- a/examples/NeoPixelBitmap/NeoPixelBitmap.ino +++ b/examples/NeoPixelBitmap/NeoPixelBitmap.ino @@ -24,6 +24,8 @@ const uint16_t PixelPin = 2; const uint16_t AnimCount = 1; // we only need one NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); NeoPixelAnimator animations(AnimCount); // NeoPixel animation management object // our NeoBitmapFile will use the same color feature as NeoPixelBus and diff --git a/examples/NeoPixelBufferCylon/NeoPixelBufferCylon.ino b/examples/NeoPixelBufferCylon/NeoPixelBufferCylon.ino index a68660f..34b97f2 100644 --- a/examples/NeoPixelBufferCylon/NeoPixelBufferCylon.ino +++ b/examples/NeoPixelBufferCylon/NeoPixelBufferCylon.ino @@ -23,6 +23,8 @@ const uint16_t PixelPin = 2; const uint16_t AnimCount = 1; // we only need one NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); NeoPixelAnimator animations(AnimCount); // NeoPixel animation management object // sprite sheet stored in progmem using the same pixel feature as the NeoPixelBus diff --git a/examples/NeoPixelCylon/NeoPixelCylon.ino b/examples/NeoPixelCylon/NeoPixelCylon.ino index 71b230d..4eec443 100644 --- a/examples/NeoPixelCylon/NeoPixelCylon.ino +++ b/examples/NeoPixelCylon/NeoPixelCylon.ino @@ -15,6 +15,8 @@ const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignore const RgbColor CylonEyeColor(HtmlColor(0x7f0000)); NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); NeoPixelAnimator animations(2); // only ever need 2 animations diff --git a/examples/NeoPixelFunFadeInOut/NeoPixelFunFadeInOut.ino b/examples/NeoPixelFunFadeInOut/NeoPixelFunFadeInOut.ino index 9774469..45e66ec 100644 --- a/examples/NeoPixelFunFadeInOut/NeoPixelFunFadeInOut.ino +++ b/examples/NeoPixelFunFadeInOut/NeoPixelFunFadeInOut.ino @@ -13,14 +13,12 @@ const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignore const uint8_t AnimationChannels = 1; // we only need one as all the pixels are animated at once NeoPixelBus strip(PixelCount, PixelPin); -// For Esp8266, the Pin is ignored and it uses GPIO3. +// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use. // There are other Esp8266 alternative methods that provide more pin options, but also have // other side effects. -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod also ignores the pin parameter and uses GPI02 -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod will work with all but pin 16, but is not stable with WiFi -// being active +//NeoPixelBus strip(PixelCount); +// +// NeoEsp8266Uart800KbpsMethod uses GPI02 instead NeoPixelAnimator animations(AnimationChannels); // NeoPixel animation management object diff --git a/examples/NeoPixelFunLoop/NeoPixelFunLoop.ino b/examples/NeoPixelFunLoop/NeoPixelFunLoop.ino index 60f6bc7..3dea4c0 100644 --- a/examples/NeoPixelFunLoop/NeoPixelFunLoop.ino +++ b/examples/NeoPixelFunLoop/NeoPixelFunLoop.ino @@ -26,14 +26,12 @@ const uint16_t NextPixelMoveDuration = 1000 / PixelCount; // how fast we move th NeoGamma colorGamma; // for any fade animations, best to correct gamma NeoPixelBus strip(PixelCount, PixelPin); -// For Esp8266, the Pin is ignored and it uses GPIO3. +// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use. // There are other Esp8266 alternative methods that provide more pin options, but also have // other side effects. -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod also ignores the pin parameter and uses GPI02 -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266BitBang800KbpsMethod will work with all but pin 16, but is not stable with WiFi -// being active +//NeoPixelBus strip(PixelCount); +// +// NeoEsp8266Uart800KbpsMethod uses GPI02 instead // what is stored for state is specific to the need, in this case, the colors and // the pixel to animate; diff --git a/examples/NeoPixelFunRandomChange/NeoPixelFunRandomChange.ino b/examples/NeoPixelFunRandomChange/NeoPixelFunRandomChange.ino index afc8c47..17d6b6a 100644 --- a/examples/NeoPixelFunRandomChange/NeoPixelFunRandomChange.ino +++ b/examples/NeoPixelFunRandomChange/NeoPixelFunRandomChange.ino @@ -11,14 +11,12 @@ const uint16_t PixelCount = 16; // make sure to set this to the number of pixels const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignored for Esp8266 NeoPixelBus strip(PixelCount, PixelPin); -// For Esp8266, the Pin is ignored and it uses GPIO3. +// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use. // There are other Esp8266 alternative methods that provide more pin options, but also have // other side effects. -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod also ignores the pin parameter and uses GPI02 -//NeoPixelBus strip(PixelCount, PixelPin); -// NeoEsp8266Uart800KbpsMethod will work with all but pin 16, but is not stable with WiFi -// being active +//NeoPixelBus strip(PixelCount); +// +// NeoEsp8266Uart800KbpsMethod uses GPI02 instead NeoPixelAnimator animations(PixelCount); // NeoPixel animation management object diff --git a/examples/NeoPixelGamma/NeoPixelGamma.ino b/examples/NeoPixelGamma/NeoPixelGamma.ino index a0487c0..3ed9152 100644 --- a/examples/NeoPixelGamma/NeoPixelGamma.ino +++ b/examples/NeoPixelGamma/NeoPixelGamma.ino @@ -16,6 +16,8 @@ const uint16_t PixelCount = 16; // make sure to set this to the number of pixels const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignored for Esp8266 NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); // uncomment only one of these to compare memory use or speed // diff --git a/examples/NeoPixelMosaicTest/NeoPixelMosaicTest.ino b/examples/NeoPixelMosaicTest/NeoPixelMosaicTest.ino index 3c21c33..2f6500c 100644 --- a/examples/NeoPixelMosaicTest/NeoPixelMosaicTest.ino +++ b/examples/NeoPixelMosaicTest/NeoPixelMosaicTest.ino @@ -36,8 +36,8 @@ NeoMosaic mosaic( TileHeight); NeoPixelBus strip(PixelCount, PixelPin); -//NeoPixelBus strip(PixelCount, PixelPin); -//NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); RgbColor red(128, 0, 0); RgbColor green(0, 128, 0); diff --git a/examples/NeoPixelRotateLoop/NeoPixelRotateLoop.ino b/examples/NeoPixelRotateLoop/NeoPixelRotateLoop.ino index 84edb74..bdc9af7 100644 --- a/examples/NeoPixelRotateLoop/NeoPixelRotateLoop.ino +++ b/examples/NeoPixelRotateLoop/NeoPixelRotateLoop.ino @@ -19,7 +19,8 @@ const float MaxLightness = 0.4f; // max lightness at the head of the tail (0.5f NeoGamma colorGamma; // for any fade animations, best to correct gamma NeoPixelBus strip(PixelCount, PixelPin); -//NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); NeoPixelAnimator animations(AnimCount); // NeoPixel animation management object diff --git a/examples/NeoPixelTest/NeoPixelTest.ino b/examples/NeoPixelTest/NeoPixelTest.ino index a45a87b..6d323b8 100644 --- a/examples/NeoPixelTest/NeoPixelTest.ino +++ b/examples/NeoPixelTest/NeoPixelTest.ino @@ -22,6 +22,13 @@ const uint8_t PixelPin = 2; // make sure to set this to the correct pin, ignore NeoPixelBus strip(PixelCount, PixelPin); //NeoPixelBus strip(PixelCount, PixelPin); +// For Esp8266, the Pin is omitted and it uses GPIO3 due to DMA hardware use. +// There are other Esp8266 alternative methods that provide more pin options, but also have +// other side effects. +//NeoPixelBus strip(PixelCount); +// +// NeoEsp8266Uart800KbpsMethod uses GPI02 instead + // You can also use one of these for Esp8266, // each having their own restrictions // diff --git a/examples/NeoPixelTilesTest/NeoPixelTilesTest.ino b/examples/NeoPixelTilesTest/NeoPixelTilesTest.ino index 41d8208..1dfc645 100644 --- a/examples/NeoPixelTilesTest/NeoPixelTilesTest.ino +++ b/examples/NeoPixelTilesTest/NeoPixelTilesTest.ino @@ -42,6 +42,8 @@ NeoTiles tiles( NeoPixelBus strip(PixelCount, PixelPin); //NeoPixelBus strip(PixelCount, PixelPin); //NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); RgbColor red(128, 0, 0); RgbColor green(0, 128, 0); diff --git a/examples/NeoPixelTopologyTest/NeoPixelTopologyTest.ino b/examples/NeoPixelTopologyTest/NeoPixelTopologyTest.ino index cd20055..2071abb 100644 --- a/examples/NeoPixelTopologyTest/NeoPixelTopologyTest.ino +++ b/examples/NeoPixelTopologyTest/NeoPixelTopologyTest.ino @@ -31,6 +31,8 @@ NeoTopology topo(PanelWidth, PanelHeight); NeoPixelBus strip(PixelCount, PixelPin); //NeoPixelBus strip(PixelCount, PixelPin); //NeoPixelBus strip(PixelCount, PixelPin); +// for esp8266 omit the pin +//NeoPixelBus strip(PixelCount); RgbColor red(128, 0, 0); RgbColor green(0, 128, 0); diff --git a/library.json b/library.json index 6ba6b3e..813702f 100644 --- a/library.json +++ b/library.json @@ -1,14 +1,14 @@ { "name": "NeoPixelBus", "keywords": "NeoPixel, WS2811, WS2812, SK6812, DotStar, ADA102, RGB, RGBW", - "description": "A library that makes controlling NeoPixels (WS2811, WS2812 & SK6812) and DotStars (ADA102) easy. Supports most Arduino platforms. Support for RGBW pixels. Includes seperate RgbColor, RgbwColor, HslColor, and HsbColor objects. Includes an animator class that helps create asyncronous animations. For Esp8266 it has three methods of sending data, DMA, UART, and Bit Bang.", + "description": "A library that makes controlling NeoPixels (WS2811, WS2812 & SK6812) and DotStars (ADA102) easy. Supports most Arduino platforms. Support for RGBW pixels. Includes seperate RgbColor, RgbwColor, HslColor, and HsbColor objects. Includes an animator class that helps create asyncronous animations. For Esp8266 it has three methods of sending NeoPixel data, DMA, UART, and Bit Bang; and two methods of sending DotStar data, hardware SPI and software SPI.", "homepage": "https://github.com/Makuna/NeoPixelBus/wiki", "repository": { "type": "git", "url": "https://github.com/Makuna/NeoPixelBus" }, - "version": "2.2.0", + "version": "2.2.1", "frameworks": "arduino", "platforms": "*" } diff --git a/library.properties b/library.properties index 3eaf38d..dee89d1 100644 --- a/library.properties +++ b/library.properties @@ -1,9 +1,9 @@ name=NeoPixelBus by Makuna -version=2.2.0 +version=2.2.1 author=Michael C. Miller (makuna@live.com) maintainer=Michael C. Miller (makuna@live.com) sentence=A library that makes controlling NeoPixels (WS2811, WS2812 & SK6812) and DotStars (ADA102) easy. -paragraph=Supports most Arduino platforms, and especially Esp8266. Support for RGBW pixels. Includes seperate RgbColor, RgbwColor, HslColor, and HsbColor objects. Includes an animator class that helps create asyncronous animations. Supports Matrix layout of pixels. Includes Gamma corretion object. For Esp8266 it has three methods of sending data, DMA, UART, and Bit Bang. +paragraph=Supports most Arduino platforms, and especially Esp8266. Support for RGBW pixels. Includes seperate RgbColor, RgbwColor, HslColor, and HsbColor objects. Includes an animator class that helps create asyncronous animations. Supports Matrix layout of pixels. Includes Gamma corretion object. For Esp8266 it has three methods of sending NeoPixel data, DMA, UART, and Bit Bang; and two methods of sending DotStar data, hardware SPI and software SPI. category=Display url=https://github.com/Makuna/NeoPixelBus/wiki architectures=* \ No newline at end of file diff --git a/src/internal/DotStarColorFeatures.h b/src/internal/DotStarColorFeatures.h index 3895844..bc97765 100644 --- a/src/internal/DotStarColorFeatures.h +++ b/src/internal/DotStarColorFeatures.h @@ -26,6 +26,73 @@ License along with NeoPixel. If not, see -------------------------------------------------------------------------*/ #pragma once +class DotStar3Elements +{ +public: + static const size_t PixelSize = 4; // still requires 4 to be sent + + static uint8_t* getPixelAddress(uint8_t* pPixels, uint16_t indexPixel) + { + return pPixels + indexPixel * PixelSize; + } + static const uint8_t* getPixelAddress(const uint8_t* pPixels, uint16_t indexPixel) + { + return pPixels + indexPixel * PixelSize; + } + + static void replicatePixel(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count) + { + uint8_t* pEnd = pPixelDest + (count * PixelSize); + while (pPixelDest < pEnd) + { + *pPixelDest++ = pPixelSrc[0]; + *pPixelDest++ = pPixelSrc[1]; + *pPixelDest++ = pPixelSrc[2]; + *pPixelDest++ = pPixelSrc[3]; + } + } + + static void movePixelsInc(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count) + { + uint8_t* pEnd = pPixelDest + (count * PixelSize); + while (pPixelDest < pEnd) + { + *pPixelDest++ = *pPixelSrc++; + *pPixelDest++ = *pPixelSrc++; + *pPixelDest++ = *pPixelSrc++; + *pPixelDest++ = *pPixelSrc++; + } + } + + static void movePixelsInc_P(uint8_t* pPixelDest, PGM_VOID_P pPixelSrc, uint16_t count) + { + uint8_t* pEnd = pPixelDest + (count * PixelSize); + const uint8_t* pSrc = (const uint8_t*)pPixelSrc; + while (pPixelDest < pEnd) + { + *pPixelDest++ = pgm_read_byte(pSrc++); + *pPixelDest++ = pgm_read_byte(pSrc++); + *pPixelDest++ = pgm_read_byte(pSrc++); + *pPixelDest++ = pgm_read_byte(pSrc++); + } + } + + static void movePixelsDec(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count) + { + uint8_t* pDestBack = pPixelDest + (count * PixelSize); + const uint8_t* pSrcBack = pPixelSrc + (count * PixelSize); + while (pDestBack > pPixelDest) + { + *--pDestBack = *--pSrcBack; + *--pDestBack = *--pSrcBack; + *--pDestBack = *--pSrcBack; + *--pDestBack = *--pSrcBack; + } + } + + typedef RgbColor ColorObject; +}; + class DotStar4Elements { public: @@ -93,7 +160,7 @@ public: typedef RgbwColor ColorObject; }; -class DotStarBgrFeature : public DotStar4Elements +class DotStarBgrFeature : public DotStar3Elements { public: static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color) @@ -175,17 +242,17 @@ public: }; -class DotStarWbgrFeature : public DotStar4Elements +class DotStarGrbFeature : public DotStar3Elements { public: static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color) { uint8_t* p = getPixelAddress(pPixels, indexPixel); - *p++ = color.W; - *p++ = color.B; + *p++ = 0xff; // upper three bits are always 111 and brightness at max *p++ = color.G; - *p = color.R; + *p++ = color.R; + *p = color.B; } static ColorObject retrievePixelColor(uint8_t* pPixels, uint16_t indexPixel) @@ -193,10 +260,10 @@ public: ColorObject color; uint8_t* p = getPixelAddress(pPixels, indexPixel); - color.W = *p++; - color.B = *p++; + p++; // ignore the first byte color.G = *p++; - color.R = *p; + color.R = *p++; + color.B = *p; return color; } @@ -206,11 +273,54 @@ public: ColorObject color; const uint8_t* p = getPixelAddress((const uint8_t*)pPixels, indexPixel); - color.W = pgm_read_byte(p++); - color.B = pgm_read_byte(p++); + pgm_read_byte(p++); // ignore the first byte color.G = pgm_read_byte(p++); - color.R = pgm_read_byte(p); + color.R = pgm_read_byte(p++); + color.B = pgm_read_byte(p); return color; } + }; + +class DotStarLgrbFeature : public DotStar4Elements +{ +public: + static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color) + { + uint8_t* p = getPixelAddress(pPixels, indexPixel); + + *p++ = 0xE0 | min(color.W, 31); // upper three bits are always 111 + *p++ = color.G; + *p++ = color.R; + *p = color.B; + } + + static ColorObject retrievePixelColor(uint8_t* pPixels, uint16_t indexPixel) + { + ColorObject color; + uint8_t* p = getPixelAddress(pPixels, indexPixel); + + color.W = (*p++) & 0x1F; // mask out upper three bits + color.G = *p++; + color.R = *p++; + color.B = *p; + + return color; + } + + static ColorObject retrievePixelColor_P(PGM_VOID_P pPixels, uint16_t indexPixel) + { + ColorObject color; + const uint8_t* p = getPixelAddress((const uint8_t*)pPixels, indexPixel); + + color.W = pgm_read_byte(p++) & 0x1F; // mask out upper three bits + color.G = pgm_read_byte(p++); + color.R = pgm_read_byte(p++); + color.B = pgm_read_byte(p); + + return color; + } + +}; + diff --git a/src/internal/DotStarSpiMethod.h b/src/internal/DotStarSpiMethod.h index 40a0acf..a029d22 100644 --- a/src/internal/DotStarSpiMethod.h +++ b/src/internal/DotStarSpiMethod.h @@ -54,7 +54,7 @@ public: SPI.begin(); #if defined(ARDUINO_ARCH_ESP8266) - SPI.setFrequency(8000000L); + SPI.setFrequency(20000000L); #elif defined(ARDUINO_ARCH_AVR) SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz (6 MHz on Pro Trinket 3V) #else diff --git a/src/internal/NeoEsp8266DmaMethod.h b/src/internal/NeoEsp8266DmaMethod.h index 60f9c30..04ad9c6 100644 --- a/src/internal/NeoEsp8266DmaMethod.h +++ b/src/internal/NeoEsp8266DmaMethod.h @@ -91,7 +91,7 @@ const uint8_t c_I2sPin = 3; // due to I2S hardware, the pin used is restricted t template class NeoEsp8266DmaMethodBase { public: - NeoEsp8266DmaMethodBase(uint8_t pin, uint16_t pixelCount, size_t elementSize) + NeoEsp8266DmaMethodBase(uint16_t pixelCount, size_t elementSize) { uint16_t dmaPixelSize = c_dmaBytesPerPixelBytes * elementSize; diff --git a/src/internal/NeoEsp8266UartMethod.cpp b/src/internal/NeoEsp8266UartMethod.cpp index 96e62eb..d680244 100644 --- a/src/internal/NeoEsp8266UartMethod.cpp +++ b/src/internal/NeoEsp8266UartMethod.cpp @@ -54,7 +54,7 @@ static inline void enqueue(uint8_t byte) static const uint8_t* esp8266_uart1_async_buf; static const uint8_t* esp8266_uart1_async_buf_end; -NeoEsp8266Uart::NeoEsp8266Uart(uint8_t pin, uint16_t pixelCount, size_t elementSize) +NeoEsp8266Uart::NeoEsp8266Uart(uint16_t pixelCount, size_t elementSize) { _sizePixels = pixelCount * elementSize; _pixels = (uint8_t*)malloc(_sizePixels); @@ -130,8 +130,8 @@ const uint8_t* ICACHE_RAM_ATTR NeoEsp8266Uart::FillUartFifo(const uint8_t* pixel return pixels; } -NeoEsp8266AsyncUart::NeoEsp8266AsyncUart(uint8_t pin, uint16_t pixelCount, size_t elementSize) - : NeoEsp8266Uart(pin, pixelCount, elementSize) +NeoEsp8266AsyncUart::NeoEsp8266AsyncUart(uint16_t pixelCount, size_t elementSize) + : NeoEsp8266Uart(pixelCount, elementSize) { _asyncPixels = (uint8_t*)malloc(_sizePixels); } diff --git a/src/internal/NeoEsp8266UartMethod.h b/src/internal/NeoEsp8266UartMethod.h index 3c17fd9..873645a 100644 --- a/src/internal/NeoEsp8266UartMethod.h +++ b/src/internal/NeoEsp8266UartMethod.h @@ -34,7 +34,7 @@ License along with NeoPixel. If not, see class NeoEsp8266Uart { protected: - NeoEsp8266Uart(uint8_t pin, uint16_t pixelCount, size_t elementSize); + NeoEsp8266Uart(uint16_t pixelCount, size_t elementSize); ~NeoEsp8266Uart(); @@ -61,7 +61,7 @@ protected: class NeoEsp8266AsyncUart: public NeoEsp8266Uart { protected: - NeoEsp8266AsyncUart(uint8_t pin, uint16_t pixelCount, size_t elementSize); + NeoEsp8266AsyncUart(uint16_t pixelCount, size_t elementSize); ~NeoEsp8266AsyncUart(); @@ -97,8 +97,8 @@ template class NeoEsp8266UartMethodBase: public T_BASE { public: - NeoEsp8266UartMethodBase(uint8_t pin, uint16_t pixelCount, size_t elementSize) - : T_BASE(pin, pixelCount, elementSize) + NeoEsp8266UartMethodBase(uint16_t pixelCount, size_t elementSize) + : T_BASE(pixelCount, elementSize) { }