Lumitronix_Iflex_Pro_Workshop
Library to interact with the iFlexPro
NeoEsp8266UartMethod.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2 LumitronixIFlex library helper functions for Esp8266 UART hardware
3 
4 Written by Michael C. Miller.
5 
6 I invest time and resources providing this open source code,
7 please support me by dontating (see https://github.com/Makuna)
8 
9 -------------------------------------------------------------------------
10 This file is part of the LUMITRONIX_iFlex_Workshop library.
11 
12 LumitronixIFlexBus is free software: you can redistribute it and/or modify
13 it under the terms of the GNU Lesser General Public License as
14 published by the Free Software Foundation, either version 3 of
15 the License, or (at your option) any later version.
16 
17 LumitronixIFlexBus is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU Lesser General Public License for more details.
21 
22 You should have received a copy of the GNU Lesser General Public
23 License along with LumitronixIFlex. If not, see
24 <http://www.gnu.org/licenses/>.
25 -------------------------------------------------------------------------*/
26 
27 #pragma once
28 
29 #ifdef ARDUINO_ARCH_ESP8266
30 
31 // this template method class is used to track the data being sent on the uart
32 // when using the default serial ISR installed by the core
33 // used with NeoEsp8266Uart and NeoEsp8266AsyncUart classes
34 //
35 class NeoEsp8266UartContext
36 {
37 public:
38  // Gets the number of bytes waiting in the TX FIFO
39  static inline uint8_t IRAM_ATTR GetTxFifoLength(uint8_t uartNum)
40  {
41  return (USS(uartNum) >> USTXC) & 0xff;
42  }
43  // Append a byte to the TX FIFO
44  static inline void IRAM_ATTR Enqueue(uint8_t uartNum, uint8_t value)
45  {
46  USF(uartNum) = value;
47  }
48 
49  static const volatile uint8_t* IRAM_ATTR FillUartFifo(uint8_t uartNum,
50  const volatile uint8_t* start,
51  const volatile uint8_t* end);
52 };
53 
54 // this template method class is used to track the data being sent on the uart
55 // when using our own UART ISR
56 // used with NeoEsp8266Uart and NeoEsp8266AsyncUart classes
57 //
58 class NeoEsp8266UartInterruptContext : NeoEsp8266UartContext
59 {
60 public:
61  NeoEsp8266UartInterruptContext() :
62  _asyncBuff(nullptr),
63  _asyncBuffEnd(nullptr)
64  {
65  }
66 
67  bool IsSending()
68  {
69  return (_asyncBuff != _asyncBuffEnd);
70  }
71 
72  void StartSending(uint8_t uartNum, uint8_t* start, uint8_t* end);
73  void Attach(uint8_t uartNum);
74  void Detach(uint8_t uartNum);
75 
76 private:
77  volatile const uint8_t* _asyncBuff;
78  volatile const uint8_t* _asyncBuffEnd;
79  volatile static NeoEsp8266UartInterruptContext* s_uartInteruptContext[2];
80 
81  static void IRAM_ATTR Isr(void* param, void* exceptionFrame);
82 };
83 
84 // this template feature class is used a base for all others and contains
85 // common methods
86 //
87 class UartFeatureBase
88 {
89 protected:
90  static void ConfigUart(uint8_t uartNum, bool invert)
91  {
92  // clear all invert bits
93  USC0(uartNum) &= ~((1 << UCDTRI) | (1 << UCRTSI) | (1 << UCTXI) | (1 << UCDSRI) | (1 << UCCTSI) | (1 << UCRXI));
94 
95  if (!invert)
96  {
97  // For normal operations,
98  // Invert the TX voltage associated with logic level so:
99  // - A logic level 0 will generate a Vcc signal
100  // - A logic level 1 will generate a Gnd signal
101  USC0(uartNum) |= (1 << UCTXI);
102  }
103  }
104 };
105 
106 // this template feature class is used to define the specifics for uart0
107 // used with NeoEsp8266Uart and NeoEsp8266AsyncUart classes
108 //
109 class UartFeature0 : UartFeatureBase
110 {
111 public:
112  static const uint32_t Index = 0;
113  static void Init(uint32_t baud, bool invert)
114  {
115  // Configure the serial line with 1 start bit (0), 6 data bits and 1 stop bit (1)
116  Serial.begin(baud, SERIAL_6N1, SERIAL_TX_ONLY);
117  ConfigUart(Index, invert);
118  }
119 };
120 
121 // this template feature class is used to define the specifics for uart1
122 // used with NeoEsp8266Uart and NeoEsp8266AsyncUart classes
123 //
124 class UartFeature1 : UartFeatureBase
125 {
126 public:
127  static const uint32_t Index = 1;
128  static void Init(uint32_t baud, bool invert)
129  {
130  // Configure the serial line with 1 start bit (0), 6 data bits and 1 stop bit (1)
131  Serial1.begin(baud, SERIAL_6N1, SERIAL_TX_ONLY);
132  ConfigUart(Index, invert);
133  }
134 };
135 
136 // this template method class is used a base for all others and contains
137 // common properties and methods
138 //
139 // used by NeoEsp8266Uart and NeoEsp8266AsyncUart
140 //
141 class NeoEsp8266UartBase
142 {
143 protected:
144  const size_t _sizeData; // Size of '_data' buffer below
145  uint8_t* _data; // Holds LED color values
146  uint32_t _startTime; // Microsecond count when last update started
147 
148  NeoEsp8266UartBase(uint16_t pixelCount, size_t elementSize, size_t settingsSize) :
149  _sizeData(pixelCount * elementSize + settingsSize)
150  {
151  _data = static_cast<uint8_t*>(malloc(_sizeData));
152  // data cleared later in Begin()
153  }
154 
155  ~NeoEsp8266UartBase()
156  {
157  free(_data);
158  }
159 
160 };
161 
162 // this template method class is used to glue uart feature and context for
163 // synchronous uart method
164 //
165 // used by NeoEsp8266UartMethodBase
166 // T_UARTFEATURE - (UartFeature0 | UartFeature1)
167 // T_UARTCONTEXT - (NeoEsp8266UartContext | NeoEsp8266UartInterruptContext)
168 //
169 template<typename T_UARTFEATURE, typename T_UARTCONTEXT> class NeoEsp8266Uart : public NeoEsp8266UartBase
170 {
171 protected:
172  NeoEsp8266Uart(uint16_t pixelCount, size_t elementSize, size_t settingsSize) :
173  NeoEsp8266UartBase(pixelCount, elementSize, settingsSize)
174  {
175  }
176 
177  ~NeoEsp8266Uart()
178  {
179  // Wait until the TX fifo is empty. This way we avoid broken frames
180  // when destroying & creating a LumitronixIFlexBus to change its length.
181  while (T_UARTCONTEXT::GetTxFifoLength(T_UARTFEATURE::Index) > 0)
182  {
183  yield();
184  }
185  }
186 
187  void InitializeUart(uint32_t uartBaud, bool invert)
188  {
189  T_UARTFEATURE::Init(uartBaud, invert);
190  }
191 
192  void UpdateUart(bool)
193  {
194  // Since the UART can finish sending queued bytes in the FIFO in
195  // the background, instead of waiting for the FIFO to flush
196  // we annotate the start time of the frame so we can calculate
197  // when it will finish.
198  _startTime = micros();
199 
200  // Then keep filling the FIFO until done
201  const uint8_t* ptr = _data;
202  const uint8_t* end = ptr + _sizeData;
203  while (ptr != end)
204  {
205  ptr = const_cast<uint8_t*>(T_UARTCONTEXT::FillUartFifo(T_UARTFEATURE::Index, ptr, end));
206  }
207  }
208 };
209 
210 // this template method class is used to glue uart feature and context for
211 // asynchronously uart method
212 //
213 // This UART controller uses two buffers that are swapped in every call to
214 // LumitronixIFlexBus.Show(). One buffer contains the data that is being sent
215 // asynchronosly and another buffer contains the data that will be send
216 // in the next call to LumitronixIFlexBus.Show().
217 //
218 // Therefore, the result of LumitronixIFlexBus.Pixels() is invalidated after
219 // every call to LumitronixIFlexBus.Show() and must not be cached.
220 //
221 // used by NeoEsp8266UartMethodBase
222 // T_UARTFEATURE - (UartFeature0 | UartFeature1)
223 // T_UARTCONTEXT - (NeoEsp8266UartContext | NeoEsp8266UartInterruptContext)
224 //
225 template<typename T_UARTFEATURE, typename T_UARTCONTEXT> class NeoEsp8266AsyncUart : public NeoEsp8266UartBase
226 {
227 protected:
228  NeoEsp8266AsyncUart(uint16_t pixelCount, size_t elementSize, size_t settingsSize) :
229  NeoEsp8266UartBase(pixelCount, elementSize, settingsSize)
230  {
231  _dataSending = static_cast<uint8_t*>(malloc(_sizeData));
232  }
233 
234  ~NeoEsp8266AsyncUart()
235  {
236  // Remember: the UART interrupt can be sending data from _dataSending in the background
237  while (_context.IsSending())
238  {
239  yield();
240  }
241  // detach context, which will disable intr, may disable ISR
242  _context.Detach(T_UARTFEATURE::Index);
243 
244  free(_dataSending);
245  }
246 
247  void IRAM_ATTR InitializeUart(uint32_t uartBaud, bool invert)
248  {
249  T_UARTFEATURE::Init(uartBaud, invert);
250 
251  // attach the context, which will enable the ISR
252  _context.Attach(T_UARTFEATURE::Index);
253  }
254 
255  void UpdateUart(bool maintainBufferConsistency)
256  {
257  // Instruct ESP8266 hardware uart to send the pixels asynchronously
258  _context.StartSending(T_UARTFEATURE::Index,
259  _data,
260  _data + _sizeData);
261 
262  // Annotate when we started to send bytes, so we can calculate when we are ready to send again
263  _startTime = micros();
264 
265  if (maintainBufferConsistency)
266  {
267  // copy editing to sending,
268  // this maintains the contract that "colors present before will
269  // be the same after", otherwise GetPixelColor will be inconsistent
270  memcpy(_dataSending, _data, _sizeData);
271  }
272 
273  // swap so the user can modify without affecting the async operation
274  std::swap(_dataSending, _data);
275  }
276 
277 private:
278  T_UARTCONTEXT _context;
279 
280  uint8_t* _dataSending; // Holds a copy of LED color values taken when UpdateUart began
281 };
282 
283 class NeoEsp8266UartSpeed800KbpsBase
284 {
285 public:
286  static const uint32_t ByteSendTimeUs = 10; // us it takes to send a single pixel element at 800khz speed
287  static const uint32_t UartBaud = 3200000; // 800mhz, 4 serial bytes per NeoByte
288 };
289 
290 // NeoEsp8266UartSpeedWs2813 contains the timing constants used to get LumitronixIFlexBus running with the Ws2813
291 class NeoEsp8266UartSpeedWs2812x : public NeoEsp8266UartSpeed800KbpsBase
292 {
293 public:
294  static const uint32_t ResetTimeUs = 300; // us between data send bursts to reset for next update
295 };
296 
297 class NeoEsp8266UartSpeedSk6812 : public NeoEsp8266UartSpeed800KbpsBase
298 {
299 public:
300  static const uint32_t ResetTimeUs = 80; // us between data send bursts to reset for next update
301 };
302 
303 class NeoEsp8266UartSpeedTm1814 : public NeoEsp8266UartSpeed800KbpsBase
304 {
305 public:
306  static const uint32_t ResetTimeUs = 200; // us between data send bursts to reset for next update
307 };
308 
309 class NeoEsp8266UartSpeedTm1829 : public NeoEsp8266UartSpeed800KbpsBase
310 {
311 public:
312  static const uint32_t ResetTimeUs = 200; // us between data send bursts to reset for next update
313 };
314 
315 // NeoEsp8266UartSpeed800Kbps contains the timing constant used to get LumitronixIFlexBus running at 800Khz
316 class NeoEsp8266UartSpeed800Kbps : public NeoEsp8266UartSpeed800KbpsBase
317 {
318 public:
319  static const uint32_t ResetTimeUs = 50; // us between data send bursts to reset for next update
320 };
321 
322 // NeoEsp8266UartSpeed400Kbps contains the timing constant used to get LumitronixIFlexBus running at 400Khz
323 class NeoEsp8266UartSpeed400Kbps
324 {
325 public:
326  static const uint32_t ByteSendTimeUs = 20; // us it takes to send a single pixel element at 400khz speed
327  static const uint32_t UartBaud = 1600000; // 400mhz, 4 serial bytes per NeoByte
328  static const uint32_t ResetTimeUs = 50; // us between data send bursts to reset for next update
329 };
330 
331 // NeoEsp8266UartSpeedApa106 contains the timing constant used to get LumitronixIFlexBus running for Apa106
332 // Pulse cycle = 1.71 = 1.368 longer than normal, 0.731 slower, NeoEsp8266UartSpeedApa1066
333 class NeoEsp8266UartSpeedApa106
334 {
335 public:
336  static const uint32_t ByteSendTimeUs = 14; // us it takes to send a single pixel element at 400khz speed
337  static const uint32_t UartBaud = 2339181; // APA106 pulse cycle of 1.71us, 4 serial bytes per NeoByte
338  static const uint32_t ResetTimeUs = 50; // us between data send bursts to reset for next update
339 };
340 
341 class NeoEsp8266UartNotInverted
342 {
343 public:
344  const static bool Inverted = false;
345 };
346 
347 class NeoEsp8266UartInverted
348 {
349 public:
350  const static bool Inverted = true;
351 };
352 
353 // NeoEsp8266UartMethodBase is a light shell arround NeoEsp8266Uart or NeoEsp8266AsyncUart that
354 // implements the methods needed to operate as a LumitronixIFlexBus method.
355 //
356 // T_SPEED - (NeoEsp8266UartSpeed*)
357 // T_BASE - (NeoEsp8266Uart | NeoEsp8266AsyncUart)
358 // T_INVERT - (NeoEsp8266UartNotInverted | NeoEsp8266UartInverted)
359 //
360 template<typename T_SPEED, typename T_BASE, typename T_INVERT>
361 class NeoEsp8266UartMethodBase: public T_BASE
362 {
363 public:
364  typedef NeoNoSettings SettingsObject;
365 
366  NeoEsp8266UartMethodBase(uint16_t pixelCount, size_t elementSize, size_t settingsSize)
367  : T_BASE(pixelCount, elementSize, settingsSize)
368  {
369  }
370  NeoEsp8266UartMethodBase([[maybe_unused]] uint8_t pin, uint16_t pixelCount, size_t elementSize, size_t settingsSize)
371  : T_BASE(pixelCount, elementSize, settingsSize)
372  {
373  }
374 
375  bool IsReadyToUpdate() const
376  {
377  uint32_t delta = micros() - this->_startTime;
378  return delta >= getPixelTime() + T_SPEED::ResetTimeUs;
379  }
380 
381  void Initialize()
382  {
383  this->InitializeUart(T_SPEED::UartBaud, T_INVERT::Inverted);
384 
385  // Inverting logic levels can generate a phantom bit in the led strip bus
386  // We need to delay 50+ microseconds the output stream to force a data
387  // latch and discard this bit. Otherwise, that bit would be prepended to
388  // the first frame corrupting it.
389  this->_startTime = micros() - getPixelTime();
390  }
391 
392  void Update(bool maintainBufferConsistency)
393  {
394  // Data latch = 50+ microsecond pause in the output stream. Rather than
395  // put a delay at the end of the function, the ending time is noted and
396  // the function will simply hold off (if needed) on issuing the
397  // subsequent round of data until the latch time has elapsed. This
398  // allows the mainline code to start generating the next frame of data
399  // rather than stalling for the latch.
400  while (!this->IsReadyToUpdate())
401  {
402  yield();
403  }
404  this->UpdateUart(maintainBufferConsistency);
405  }
406 
407  bool AlwaysUpdate()
408  {
409  // this method requires update to be called only if changes to buffer
410  return false;
411  }
412 
413  uint8_t* getData() const
414  {
415  return this->_data;
416  };
417 
418  size_t getDataSize() const
419  {
420  return this->_sizeData;
421  };
422 
423  void applySettings([[maybe_unused]] const SettingsObject& settings)
424  {
425  }
426 
427 private:
428  uint32_t getPixelTime() const
429  {
430  return (T_SPEED::ByteSendTimeUs * this->_sizeData);
431  };
432 };
433 
434 // uart 0
435 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0Ws2812xMethod;
436 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0Sk6812Method;
437 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0Tm1814Method;
438 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0Tm1829Method;
439 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0Apa106Method;
440 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0800KbpsMethod;
441 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0400KbpsMethod;
442 
443 typedef NeoEsp8266Uart0Ws2812xMethod NeoEsp8266Uart0Ws2813Method;
444 typedef NeoEsp8266Uart0800KbpsMethod NeoEsp8266Uart0Ws2812Method;
445 typedef NeoEsp8266Uart0Ws2812xMethod NeoEsp8266Uart0Ws2811Method;
446 typedef NeoEsp8266Uart0Ws2812xMethod NeoEsp8266Uart0Ws2816Method;
447 typedef NeoEsp8266Uart0Tm1814Method NeoEsp8266Uart0Tm1914Method;
448 typedef NeoEsp8266Uart0Sk6812Method NeoEsp8266Uart0Lc8812Method;
449 
450 // uart 1
451 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1Ws2812xMethod;
452 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1Sk6812Method;
453 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1Tm1814Method;
454 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1Tm1829Method;
455 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1Apa106Method;
456 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1800KbpsMethod;
457 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1400KbpsMethod;
458 
459 typedef NeoEsp8266Uart1Ws2812xMethod NeoEsp8266Uart1Ws2813Method;
460 typedef NeoEsp8266Uart1800KbpsMethod NeoEsp8266Uart1Ws2812Method;
461 typedef NeoEsp8266Uart1Ws2812xMethod NeoEsp8266Uart1Ws2811Method;
462 typedef NeoEsp8266Uart1Ws2812xMethod NeoEsp8266Uart1Ws2816Method;
463 typedef NeoEsp8266Uart1Tm1814Method NeoEsp8266Uart1Tm1914Method;
464 typedef NeoEsp8266Uart1Sk6812Method NeoEsp8266Uart1Lc8812Method;
465 
466 // uart 0 async
467 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0Ws2812xMethod;
468 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0Sk6812Method;
469 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0Tm1814Method;
470 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0Tm1829Method;
471 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0Apa106Method;
472 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0800KbpsMethod;
473 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0400KbpsMethod;
474 
475 typedef NeoEsp8266AsyncUart0Ws2812xMethod NeoEsp8266AsyncUart0Ws2813Method;
476 typedef NeoEsp8266AsyncUart0800KbpsMethod NeoEsp8266AsyncUart0Ws2812Method;
477 typedef NeoEsp8266AsyncUart0Ws2812xMethod NeoEsp8266AsyncUart0Ws2811Method;
478 typedef NeoEsp8266AsyncUart0Ws2812xMethod NeoEsp8266AsyncUart0Ws2816Method;
479 typedef NeoEsp8266AsyncUart0Tm1814Method NeoEsp8266AsyncUart0Tm1914Method;
480 typedef NeoEsp8266AsyncUart0Sk6812Method NeoEsp8266AsyncUart0Lc8812Method;
481 
482 // uart 1 async
483 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1Ws2812xMethod;
484 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1Sk6812Method;
485 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1Tm1814Method;
486 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1Tm1829Method;
487 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1Apa106Method;
488 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1800KbpsMethod;
489 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1400KbpsMethod;
490 
491 typedef NeoEsp8266AsyncUart1Ws2812xMethod NeoEsp8266AsyncUart1Ws2813Method;
492 typedef NeoEsp8266AsyncUart1800KbpsMethod NeoEsp8266AsyncUart1Ws2812Method;
493 typedef NeoEsp8266AsyncUart1Ws2812xMethod NeoEsp8266AsyncUart1Ws2811Method;
494 typedef NeoEsp8266AsyncUart1Ws2812xMethod NeoEsp8266AsyncUart1Ws2816Method;
495 typedef NeoEsp8266AsyncUart1Tm1814Method NeoEsp8266AsyncUart1Tm1914Method;
496 typedef NeoEsp8266AsyncUart1Sk6812Method NeoEsp8266AsyncUart1Lc8812Method;
497 
498 // inverted
499 //
500 // uart 0
501 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0Ws2812xInvertedMethod;
502 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0Sk6812InvertedMethod;
503 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0Tm1814InvertedMethod;
504 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart0Tm1829InvertedMethod;
505 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0Apa106InvertedMethod;
506 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0800KbpsInvertedMethod;
507 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266Uart<UartFeature0, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart0400KbpsInvertedMethod;
508 
509 typedef NeoEsp8266Uart0Ws2812xInvertedMethod NeoEsp8266Uart0Ws2813InvertedMethod;
510 typedef NeoEsp8266Uart0800KbpsInvertedMethod NeoEsp8266Uart0Ws2812InvertedMethod;
511 typedef NeoEsp8266Uart0Ws2812xInvertedMethod NeoEsp8266Uart0Ws2811InvertedMethod;
512 typedef NeoEsp8266Uart0Ws2812xInvertedMethod NeoEsp8266Uart0Ws2816InvertedMethod;
513 typedef NeoEsp8266Uart0Tm1814InvertedMethod NeoEsp8266Uart0Tm1914InvertedMethod;
514 typedef NeoEsp8266Uart0Sk6812InvertedMethod NeoEsp8266Uart0Lc8812InvertedMethod;
515 
516 // uart 1
517 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1Ws2812xInvertedMethod;
518 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1Sk6812InvertedMethod;
519 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1Tm1814InvertedMethod;
520 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartNotInverted> NeoEsp8266Uart1Tm1829InvertedMethod;
521 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1Apa106InvertedMethod;
522 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1800KbpsInvertedMethod;
523 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266Uart<UartFeature1, NeoEsp8266UartContext>, NeoEsp8266UartInverted> NeoEsp8266Uart1400KbpsInvertedMethod;
524 
525 typedef NeoEsp8266Uart1Ws2812xInvertedMethod NeoEsp8266Uart1Ws2813InvertedMethod;
526 typedef NeoEsp8266Uart1800KbpsInvertedMethod NeoEsp8266Uart1Ws2812InvertedMethod;
527 typedef NeoEsp8266Uart1Ws2812xInvertedMethod NeoEsp8266Uart1Ws2811InvertedMethod;
528 typedef NeoEsp8266Uart1Ws2812xInvertedMethod NeoEsp8266Uart1Ws2816InvertedMethod;
529 typedef NeoEsp8266Uart1Tm1814InvertedMethod NeoEsp8266Uart1Tm1914InvertedMethod;
530 typedef NeoEsp8266Uart1Sk6812InvertedMethod NeoEsp8266Uart1Lc8812InvertedMethod;
531 
532 // uart 0 async
533 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0Ws2812xInvertedMethod;
534 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0Sk6812InvertedMethod;
535 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0Tm1814InvertedMethod;
536 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart0Tm1829InvertedMethod;
537 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0Apa106InvertedMethod;
538 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0800KbpsInvertedMethod;
539 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266AsyncUart<UartFeature0, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart0400KbpsInvertedMethod;
540 
541 typedef NeoEsp8266AsyncUart0Ws2812xInvertedMethod NeoEsp8266AsyncUart0Ws2813InvertedMethod;
542 typedef NeoEsp8266AsyncUart0800KbpsInvertedMethod NeoEsp8266AsyncUart0Ws2812InvertedMethod;
543 typedef NeoEsp8266AsyncUart0Ws2812xInvertedMethod NeoEsp8266AsyncUart0Ws2811InvertedMethod;
544 typedef NeoEsp8266AsyncUart0Ws2812xInvertedMethod NeoEsp8266AsyncUart0Ws2816InvertedMethod;
545 typedef NeoEsp8266AsyncUart0Tm1814InvertedMethod NeoEsp8266AsyncUart0Tm1914InvertedMethod;
546 typedef NeoEsp8266AsyncUart0Sk6812InvertedMethod NeoEsp8266AsyncUart0Lc8812InvertedMethod;
547 
548 // uart 1 async
549 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedWs2812x, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1Ws2812xInvertedMethod;
550 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedSk6812, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1Sk6812InvertedMethod;
551 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1814, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1Tm1814InvertedMethod;
552 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedTm1829, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartNotInverted> NeoEsp8266AsyncUart1Tm1829InvertedMethod;
553 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeedApa106, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1Apa106InvertedMethod;
554 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed800Kbps, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1800KbpsInvertedMethod;
555 typedef NeoEsp8266UartMethodBase<NeoEsp8266UartSpeed400Kbps, NeoEsp8266AsyncUart<UartFeature1, NeoEsp8266UartInterruptContext>, NeoEsp8266UartInverted> NeoEsp8266AsyncUart1400KbpsInvertedMethod;
556 
557 typedef NeoEsp8266AsyncUart1Ws2812xInvertedMethod NeoEsp8266AsyncUart1Ws2813InvertedMethod;
558 typedef NeoEsp8266AsyncUart1800KbpsInvertedMethod NeoEsp8266AsyncUart1Ws2812InvertedMethod;
559 typedef NeoEsp8266AsyncUart1Ws2812xInvertedMethod NeoEsp8266AsyncUart1Ws2811InvertedMethod;
560 typedef NeoEsp8266AsyncUart1Ws2812xInvertedMethod NeoEsp8266AsyncUart1Ws2816InvertedMethod;
561 typedef NeoEsp8266AsyncUart1Tm1814InvertedMethod NeoEsp8266AsyncUart1Tm1914InvertedMethod;
562 typedef NeoEsp8266AsyncUart1Sk6812InvertedMethod NeoEsp8266AsyncUart1Lc8812InvertedMethod;
563 #endif
564 
Definition: NeoSettings.h:29