API tools faq
paste
Advertisement
Guest User

New_Chipset_V2.h

a guest
Aug 9th, 2023
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 27.90 KB | None | 0 0
raw download clone embed print report
  1. #ifndef __INC_CHIPSETS_H
  2. #define __INC_CHIPSETS_H
  3.  
  4. #include "FastLED.h"
  5. #include "pixeltypes.h"
  6.  
  7. /// @file chipsets.h
  8. /// Contains the bulk of the definitions for the various LED chipsets supported.
  9.  
  10. FASTLED_NAMESPACE_BEGIN
  11.  
  12. /// @defgroup Chipsets LED Chipset Controllers
  13. /// Implementations of ::CLEDController classes for various led chipsets.
  14. ///
  15. /// @{
  16.  
  17. #if defined(ARDUINO) //&& defined(SoftwareSerial_h)
  18.  
  19.  
  20. #if defined(SoftwareSerial_h) || defined(__SoftwareSerial_h)
  21. #include <SoftwareSerial.h>
  22.  
  23. #define HAS_PIXIE
  24.  
  25. /// Adafruit Pixie controller class
  26. /// @tparam DATA_PIN the pin to write data out on
  27. /// @tparam RGB_ORDER the RGB ordering for the LED data
  28. template<uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  29. class PixieController : public CPixelLEDController<RGB_ORDER> {
  30.     SoftwareSerial Serial;
  31.     CMinWait<2000> mWait;
  32.  
  33. public:
  34.     PixieController() : Serial(-1, DATA_PIN) {}
  35.  
  36. protected:
  37.     /// Initialize the controller
  38.     virtual void init() {
  39.         Serial.begin(115200);
  40.         mWait.mark();
  41.     }
  42.  
  43.     /// @copydoc CPixelLEDController::showPixels()
  44.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  45.         mWait.wait();
  46.         while(pixels.has(1)) {
  47.             uint8_t r = pixels.loadAndScale0();
  48.             Serial.write(r);
  49.             uint8_t g = pixels.loadAndScale1();
  50.             Serial.write(g);
  51.             uint8_t b = pixels.loadAndScale2();
  52.             Serial.write(b);
  53.             pixels.advanceData();
  54.             pixels.stepDithering();
  55.         }
  56.         mWait.mark();
  57.     }
  58.  
  59. };
  60.  
  61. // template<SoftwareSerial & STREAM, EOrder RGB_ORDER = RGB>
  62. // class PixieController : public PixieBaseController<STREAM, RGB_ORDER> {
  63. // public:
  64. //  virtual void init() {
  65. //      STREAM.begin(115200);
  66. //  }
  67. // };
  68. #endif
  69. #endif
  70.  
  71. /// @defgroup ClockedChipsets Clocked Chipsets
  72. /// Nominally SPI based, these chipsets have a data and a clock line.
  73. /// @{
  74.  
  75. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  76. //
  77. // LPD8806 controller class - takes data/clock/select pin values (N.B. should take an SPI definition?)
  78. //
  79. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  80.  
  81. /// LPD8806 controller class.
  82. /// @tparam DATA_PIN the data pin for these LEDs
  83. /// @tparam CLOCK_PIN the clock pin for these LEDs
  84. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  85. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(12)
  86. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB,  uint32_t SPI_SPEED = DATA_RATE_MHZ(12) >
  87. class LPD8806Controller : public CPixelLEDController<RGB_ORDER> {
  88.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  89.  
  90.     class LPD8806_ADJUST {
  91.     public:
  92.         // LPD8806 spec wants the high bit of every rgb data byte sent out to be set.
  93.         __attribute__((always_inline)) inline static uint8_t adjust(FASTLED_REGISTER uint8_t data) { return ((data>>1) | 0x80) + ((data && (data<254)) & 0x01); }
  94.         __attribute__((always_inline)) inline static void postBlock(int len) {
  95.             SPI::writeBytesValueRaw(0, ((len*3+63)>>6));
  96.         }
  97.  
  98.     };
  99.  
  100.     SPI mSPI;
  101.  
  102. public:
  103.     LPD8806Controller()  {}
  104.     virtual void init() {
  105.         mSPI.init();
  106.     }
  107.  
  108. protected:
  109.  
  110.     /// @copydoc CPixelLEDController::showPixels()
  111.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  112.         mSPI.template writePixels<0, LPD8806_ADJUST, RGB_ORDER>(pixels);
  113.     }
  114. };
  115.  
  116.  
  117. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  118. //
  119. // WS2801 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
  120. //
  121. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  122.  
  123. /// WS2801 controller class.
  124. /// @tparam DATA_PIN the data pin for these LEDs
  125. /// @tparam CLOCK_PIN the clock pin for these LEDs
  126. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  127. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(1)
  128. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(1)>
  129. class WS2801Controller : public CPixelLEDController<RGB_ORDER> {
  130.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  131.     SPI mSPI;
  132.     CMinWait<1000>  mWaitDelay;
  133.  
  134. public:
  135.     WS2801Controller() {}
  136.  
  137.     /// Initialize the controller
  138.     virtual void init() {
  139.         mSPI.init();
  140.       mWaitDelay.mark();
  141.     }
  142.  
  143. protected:
  144.  
  145.     /// @copydoc CPixelLEDController::showPixels()
  146.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  147.         mWaitDelay.wait();
  148.         mSPI.template writePixels<0, DATA_NOP, RGB_ORDER>(pixels);
  149.         mWaitDelay.mark();
  150.     }
  151. };
  152.  
  153. /// WS2803 controller class.
  154. /// @copydetails WS2801Controller
  155. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(25)>
  156. class WS2803Controller : public WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_SPEED> {};
  157.  
  158. /// LPD6803 controller class (LPD1101).
  159. /// 16 bit (1 bit const "1", 5 bit red, 5 bit green, 5 bit blue).
  160. /// In chip CMODE pin must be set to 1 (inside oscillator mode).
  161. /// @tparam DATA_PIN the data pin for these LEDs
  162. /// @tparam CLOCK_PIN the clock pin for these LEDs
  163. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  164. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(12)
  165. /// @see Datasheet: https://cdn-shop.adafruit.com/datasheets/LPD6803.pdf
  166. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(12)>
  167. class LPD6803Controller : public CPixelLEDController<RGB_ORDER> {
  168.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  169.     SPI mSPI;
  170.  
  171.     void startBoundary() { mSPI.writeByte(0); mSPI.writeByte(0); mSPI.writeByte(0); mSPI.writeByte(0); }
  172.     void endBoundary(int nLeds) { int nDWords = (nLeds/32); do { mSPI.writeByte(0xFF); mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); } while(nDWords--); }
  173.  
  174. public:
  175.     LPD6803Controller() {}
  176.  
  177.     virtual void init() {
  178.         mSPI.init();
  179.     }
  180.  
  181. protected:
  182.     /// @copydoc CPixelLEDController::showPixels()
  183.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  184.         mSPI.select();
  185.  
  186.         startBoundary();
  187.         while(pixels.has(1)) {
  188.             FASTLED_REGISTER uint16_t command;
  189.             command = 0x8000;
  190.             command |= (pixels.loadAndScale0() & 0xF8) << 7; // red is the high 5 bits
  191.             command |= (pixels.loadAndScale1() & 0xF8) << 2; // green is the middle 5 bits
  192.             mSPI.writeByte((command >> 8) & 0xFF);
  193.             command |= pixels.loadAndScale2() >> 3 ; // blue is the low 5 bits
  194.             mSPI.writeByte(command & 0xFF);
  195.  
  196.             pixels.stepDithering();
  197.             pixels.advanceData();
  198.         }
  199.         endBoundary(pixels.size());
  200.         mSPI.waitFully();
  201.         mSPI.release();
  202.     }
  203.  
  204. };
  205.  
  206. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  207. //
  208. // APA102 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
  209. //
  210. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  211.  
  212. /// APA102 controller class.
  213. /// @tparam DATA_PIN the data pin for these LEDs
  214. /// @tparam CLOCK_PIN the clock pin for these LEDs
  215. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  216. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(12)
  217. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(12)>
  218. class APA102Controller : public CPixelLEDController<RGB_ORDER> {
  219.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  220.     SPI mSPI;
  221.  
  222.     void startBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
  223.     void endBoundary(int nLeds) { int nDWords = (nLeds/32); do { mSPI.writeByte(0xFF); mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); } while(nDWords--); }
  224.  
  225.     inline void writeLed(uint8_t brightness, uint8_t b0, uint8_t b1, uint8_t b2) __attribute__((always_inline)) {
  226. #ifdef FASTLED_SPI_BYTE_ONLY
  227.         mSPI.writeByte(0xE0 | brightness);
  228.         mSPI.writeByte(b0);
  229.         mSPI.writeByte(b1);
  230.         mSPI.writeByte(b2);
  231. #else
  232.         uint16_t b = 0xE000 | (brightness << 8) | (uint16_t)b0;
  233.         mSPI.writeWord(b);
  234.         uint16_t w = b1 << 8;
  235.         w |= b2;
  236.         mSPI.writeWord(w);
  237. #endif
  238.     }
  239.  
  240. public:
  241.     APA102Controller() {}
  242.  
  243.     virtual void init() {
  244.         mSPI.init();
  245.     }
  246.  
  247. protected:
  248.     /// @copydoc CPixelLEDController::showPixels()
  249.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  250.         mSPI.select();
  251.  
  252.         uint8_t s0 = pixels.getScale0(), s1 = pixels.getScale1(), s2 = pixels.getScale2();
  253. #if FASTLED_USE_GLOBAL_BRIGHTNESS == 1
  254.         const uint16_t maxBrightness = 0x1F;
  255.         uint16_t brightness = ((((uint16_t)max(max(s0, s1), s2) + 1) * maxBrightness - 1) >> 8) + 1;
  256.         s0 = (maxBrightness * s0 + (brightness >> 1)) / brightness;
  257.         s1 = (maxBrightness * s1 + (brightness >> 1)) / brightness;
  258.         s2 = (maxBrightness * s2 + (brightness >> 1)) / brightness;
  259. #else
  260.         const uint8_t brightness = 0x1F;
  261. #endif
  262.  
  263.         startBoundary();
  264.         while (pixels.has(1)) {
  265.             writeLed(brightness, pixels.loadAndScale0(0, s0), pixels.loadAndScale1(0, s1), pixels.loadAndScale2(0, s2));
  266.             pixels.stepDithering();
  267.             pixels.advanceData();
  268.         }
  269.         endBoundary(pixels.size());
  270.  
  271.         mSPI.waitFully();
  272.         mSPI.release();
  273.     }
  274.  
  275. };
  276.  
  277. /// SK9822 controller class.
  278. /// @tparam DATA_PIN the data pin for these LEDs
  279. /// @tparam CLOCK_PIN the clock pin for these LEDs
  280. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  281. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(24)
  282. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(24)>
  283. class SK9822Controller : public CPixelLEDController<RGB_ORDER> {
  284.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  285.     SPI mSPI;
  286.  
  287.     void startBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
  288.     void endBoundary(int nLeds) { int nLongWords = (nLeds/32); do { mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); } while(nLongWords--); }
  289.  
  290.     inline void writeLed(uint8_t brightness, uint8_t b0, uint8_t b1, uint8_t b2) __attribute__((always_inline)) {
  291. #ifdef FASTLED_SPI_BYTE_ONLY
  292.         mSPI.writeByte(0xE0 | brightness);
  293.         mSPI.writeByte(b0);
  294.         mSPI.writeByte(b1);
  295.         mSPI.writeByte(b2);
  296. #else
  297.         uint16_t b = 0xE000 | (brightness << 8) | (uint16_t)b0;
  298.         mSPI.writeWord(b);
  299.         uint16_t w = b1 << 8;
  300.         w |= b2;
  301.         mSPI.writeWord(w);
  302. #endif
  303.     }
  304.  
  305. public:
  306.     SK9822Controller() {}
  307.  
  308.     virtual void init() {
  309.         mSPI.init();
  310.     }
  311.  
  312. protected:
  313.     /// @copydoc CPixelLEDController::showPixels()
  314.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  315.         mSPI.select();
  316.  
  317.         uint8_t s0 = pixels.getScale0(), s1 = pixels.getScale1(), s2 = pixels.getScale2();
  318. #if FASTLED_USE_GLOBAL_BRIGHTNESS == 1
  319.         const uint16_t maxBrightness = 0x1F;
  320.         uint16_t brightness = ((((uint16_t)max(max(s0, s1), s2) + 1) * maxBrightness - 1) >> 8) + 1;
  321.         s0 = (maxBrightness * s0 + (brightness >> 1)) / brightness;
  322.         s1 = (maxBrightness * s1 + (brightness >> 1)) / brightness;
  323.         s2 = (maxBrightness * s2 + (brightness >> 1)) / brightness;
  324. #else
  325.         const uint8_t brightness = 0x1F;
  326. #endif
  327.  
  328.         startBoundary();
  329.         while (pixels.has(1)) {
  330.             writeLed(brightness, pixels.loadAndScale0(0, s0), pixels.loadAndScale1(0, s1), pixels.loadAndScale2(0, s2));
  331.             pixels.stepDithering();
  332.             pixels.advanceData();
  333.         }
  334.  
  335.         endBoundary(pixels.size());
  336.  
  337.         mSPI.waitFully();
  338.         mSPI.release();
  339.     }
  340.  
  341. };
  342.  
  343.  
  344.  
  345. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  346. //
  347. // P9813 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
  348. //
  349. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  350.  
  351. /// P9813 controller class.
  352. /// @tparam DATA_PIN the data pin for these LEDs
  353. /// @tparam CLOCK_PIN the clock pin for these LEDs
  354. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  355. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(10)
  356. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(10)>
  357. class P9813Controller : public CPixelLEDController<RGB_ORDER> {
  358.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  359.     SPI mSPI;
  360.  
  361.     void writeBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
  362.  
  363.     inline void writeLed(uint8_t r, uint8_t g, uint8_t b) __attribute__((always_inline)) {
  364.         FASTLED_REGISTER uint8_t top = 0xC0 | ((~b & 0xC0) >> 2) | ((~g & 0xC0) >> 4) | ((~r & 0xC0) >> 6);
  365.         mSPI.writeByte(top); mSPI.writeByte(b); mSPI.writeByte(g); mSPI.writeByte(r);
  366.     }
  367.  
  368. public:
  369.     P9813Controller() {}
  370.  
  371.     virtual void init() {
  372.         mSPI.init();
  373.     }
  374.  
  375. protected:
  376.     /// @copydoc CPixelLEDController::showPixels()
  377.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  378.         mSPI.select();
  379.  
  380.         writeBoundary();
  381.         while(pixels.has(1)) {
  382.             writeLed(pixels.loadAndScale0(), pixels.loadAndScale1(), pixels.loadAndScale2());
  383.             pixels.advanceData();
  384.             pixels.stepDithering();
  385.         }
  386.         writeBoundary();
  387.         mSPI.waitFully();
  388.  
  389.         mSPI.release();
  390.     }
  391.  
  392. };
  393.  
  394.  
  395. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  396. //
  397. // SM16716 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
  398. //
  399. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  400.  
  401. /// SM16716 controller class.
  402. /// @tparam DATA_PIN the data pin for these LEDs
  403. /// @tparam CLOCK_PIN the clock pin for these LEDs
  404. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  405. /// @tparam SPI_SPEED the clock divider used for these LEDs.  Set using the ::DATA_RATE_MHZ / ::DATA_RATE_KHZ macros.  Defaults to ::DATA_RATE_MHZ(16)
  406. template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(16)>
  407. class SM16716Controller : public CPixelLEDController<RGB_ORDER> {
  408.     typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
  409.     SPI mSPI;
  410.  
  411.     void writeHeader() {
  412.         // Write out 50 zeros to the spi line (6 blocks of 8 followed by two single bit writes)
  413.         mSPI.select();
  414.         mSPI.template writeBit<0>(0);
  415.         mSPI.writeByte(0);
  416.         mSPI.writeByte(0);
  417.         mSPI.writeByte(0);
  418.         mSPI.template writeBit<0>(0);
  419.         mSPI.writeByte(0);
  420.         mSPI.writeByte(0);
  421.         mSPI.writeByte(0);
  422.         mSPI.waitFully();
  423.         mSPI.release();
  424.     }
  425.  
  426. public:
  427.     SM16716Controller() {}
  428.  
  429.     virtual void init() {
  430.         mSPI.init();
  431.     }
  432.  
  433. protected:
  434.     /// @copydoc CPixelLEDController::showPixels()
  435.     virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
  436.         // Make sure the FLAG_START_BIT flag is set to ensure that an extra 1 bit is sent at the start
  437.         // of each triplet of bytes for rgb data
  438.         // writeHeader();
  439.         mSPI.template writePixels<FLAG_START_BIT, DATA_NOP, RGB_ORDER>( pixels );
  440.         writeHeader();
  441.     }
  442.  
  443. };
  444.  
  445. /// @} ClockedChipsets
  446.  
  447.  
  448. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  449. //
  450. // Clockless template instantiations - see clockless.h for how the timing values are used
  451. //
  452.  
  453. #ifdef FASTLED_HAS_CLOCKLESS
  454. /// @defgroup ClocklessChipsets Clockless Chipsets
  455. /// These chipsets have only a single data line.
  456. ///
  457. /// The clockless chipset controllers use the same base class
  458. /// and the same protocol, but with varying timing periods.
  459. ///
  460. /// These controllers have 3 control points in their cycle for each bit:
  461. ///   @code
  462. ///   At T=0        : the line is raised hi to start a bit
  463. ///   At T=T1       : the line is dropped low to transmit a zero bit
  464. ///   At T=T1+T2    : the line is dropped low to transmit a one bit
  465. ///   At T=T1+T2+T3 : the cycle is concluded (next bit can be sent)
  466. ///   @endcode
  467. ///
  468. /// The units used for T1, T2, and T3 is nanoseconds.  
  469. ///
  470. /// For 8MHz/16MHz/24MHz frequencies, these values are also guaranteed
  471. /// to be integral multiples of an 8MHz clock (125ns increments).
  472. ///
  473. /// @note The base class, ClocklessController, is platform-specific.
  474. /// @{
  475.  
  476. // Allow clock that clockless controller is based on to have different
  477. // frequency than the CPU.
  478. #if !defined(CLOCKLESS_FREQUENCY)
  479.     #define CLOCKLESS_FREQUENCY F_CPU
  480. #endif
  481.  
  482. // We want to force all avr's to use the Trinket controller when running at 8Mhz, because even the 328's at 8Mhz
  483. // need the more tightly defined timeframes.
  484. #if defined(__LGT8F__) || (CLOCKLESS_FREQUENCY == 8000000 || CLOCKLESS_FREQUENCY == 16000000 || CLOCKLESS_FREQUENCY == 24000000) || defined(FASTLED_DOXYGEN) //  || CLOCKLESS_FREQUENCY == 48000000 || CLOCKLESS_FREQUENCY == 96000000) // 125ns/clock
  485.  
  486. /// Frequency multiplier for each clockless data interval.
  487. /// @see Notes in @ref ClocklessChipsets
  488. #define FMUL (CLOCKLESS_FREQUENCY/8000000)
  489.  
  490. /// GE8822 controller class.
  491. /// @copydetails WS2812Controller800Khz
  492. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  493. class GE8822Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER, 4> {};
  494.  
  495. /// LPD1886 controller class.
  496. /// @copydetails WS2812Controller800Khz
  497. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  498. class LPD1886Controller1250Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 3 * FMUL, 2 * FMUL, RGB_ORDER, 4> {};
  499.  
  500. /// LPD1886 controller class.
  501. /// @copydetails WS2812Controller800Khz
  502. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  503. class LPD1886Controller1250Khz_8bit : public ClocklessController<DATA_PIN, 2 * FMUL, 3 * FMUL, 2 * FMUL, RGB_ORDER> {};
  504.  
  505. /// WS2812 controller class @ 800 KHz.
  506. /// @tparam DATA_PIN the data pin for these LEDs
  507. /// @tparam RGB_ORDER the RGB ordering for these LEDs
  508. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  509. class WS2812Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER> {};
  510.  
  511. /// WS2812V5 controller class @ 800 KHz.
  512. /// @copydetails WS2812V5Controller800Khz
  513. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  514. class WS2815V5Controller800Khz : public ClocklessController<DATA_PIN, 1 * FMUL, 4.5 * FMUL, 4.5 * FMUL, RGB_ORDER> {};
  515.  
  516. /// WS2811 controller class @ 800 KHz.
  517. /// @copydetails WS2812Controller800Khz
  518. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  519. ///class WS2811Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {}; /// <<<--- ORIGINAL
  520. class WS2811Controller800Khz : public ClocklessController<DATA_PIN, 1.5 * FMUL, 4.5 * FMUL, 4.5 * FMUL, RGB_ORDER> {};
  521. //class WS2811Controller800Khz : public ClocklessController<DATA_PIN, 2*125, 3*125, 6*125, RGB_ORDER> {};
  522.  
  523. /// DP1903 controller class @ 800 KHz.
  524. /// @copydetails WS2812Controller800Khz
  525. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  526. class DP1903Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 8 * FMUL, 2 * FMUL, RGB_ORDER> {};
  527.  
  528. /// DP1903 controller class @ 400 KHz.
  529. /// @copydetails WS2812Controller800Khz
  530. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  531. class DP1903Controller400Khz : public ClocklessController<DATA_PIN, 4 * FMUL, 16 * FMUL, 4 * FMUL, RGB_ORDER> {};
  532.  
  533. /// WS2813 controller class.
  534. /// @copydetails WS2812Controller800Khz
  535. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>                                                             //not tested
  536. ///class WS2813Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {}; /// <<<--- ORIGINAL
  537. class WS2813Controller : public ClocklessController<DATA_PIN, 1 * FMUL, 4.5 * FMUL, 4.5 * FMUL, RGB_ORDER> {};
  538. //class WS2813Controller : public ClocklessController<DATA_PIN, 1* FMUL, 4.5* FMUL, 6 * FMUL, RGB_ORDER> {};
  539. //class WS2813Controller : public ClocklessController<DATA_PIN, 2*125, 3*125, 6*125, RGB_ORDER> {};
  540.  
  541.  
  542. /// WS2811 controller class @ 400 KHz.
  543. /// @copydetails WS2812Controller800Khz
  544. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  545. class WS2811Controller400Khz : public ClocklessController<DATA_PIN, 4 * FMUL, 10 * FMUL, 6 * FMUL, RGB_ORDER> {};
  546.  
  547. /// SK6822 controller class.
  548. /// @copydetails WS2812Controller800Khz
  549. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  550. class SK6822Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 8 * FMUL, 3 * FMUL, RGB_ORDER> {};
  551.  
  552. /// SM16703 controller class.
  553. /// @copydetails WS2812Controller800Khz
  554. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  555. class SM16703Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {};
  556.  
  557. /// SK6812 controller class.
  558. /// @copydetails WS2812Controller800Khz
  559. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  560. class SK6812Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 3 * FMUL, 4 * FMUL, RGB_ORDER> {};
  561.  
  562. /// UCS1903 controller class @ 400 KHz.
  563. /// @copydetails WS2812Controller800Khz
  564. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  565. class UCS1903Controller400Khz : public ClocklessController<DATA_PIN, 4 * FMUL, 12 * FMUL, 4 * FMUL, RGB_ORDER> {};
  566.  
  567. /// UCS1903B controller class.
  568. /// @copydetails WS2812Controller800Khz
  569. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  570. class UCS1903BController800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 4 * FMUL, 4 * FMUL, RGB_ORDER> {};
  571.  
  572. /// UCS1904 controller class.
  573. /// @copydetails WS2812Controller800Khz
  574. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  575. class UCS1904Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 3 * FMUL, 4 * FMUL, RGB_ORDER> {};
  576.  
  577. /// UCS2903 controller class.
  578. /// @copydetails WS2812Controller800Khz
  579. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  580. class UCS2903Controller : public ClocklessController<DATA_PIN, 2 * FMUL, 6 * FMUL, 2 * FMUL, RGB_ORDER> {};
  581.  
  582. /// TM1809 controller class.
  583. /// @copydetails WS2812Controller800Khz
  584. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  585. class TM1809Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER> {};
  586.  
  587. /// TM1803 controller class.
  588. /// @copydetails WS2812Controller800Khz
  589. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  590. class TM1803Controller400Khz : public ClocklessController<DATA_PIN, 6 * FMUL, 9 * FMUL, 6 * FMUL, RGB_ORDER> {};
  591.  
  592. /// TM1829 controller class.
  593. /// @copydetails WS2812Controller800Khz
  594. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  595. class TM1829Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER, 0, true, 500> {};
  596.  
  597. /// GW6205 controller class @ 400 KHz.
  598. /// @copydetails WS2812Controller800Khz
  599. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  600. class GW6205Controller400Khz : public ClocklessController<DATA_PIN, 6 * FMUL, 7 * FMUL, 6 * FMUL, RGB_ORDER, 4> {};
  601.  
  602. /// UCS1904 controller class @ 800 KHz.
  603. /// @copydetails WS2812Controller800Khz
  604. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  605. class GW6205Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 4 * FMUL, 4 * FMUL, RGB_ORDER, 4> {};
  606.  
  607. /// PL9823 controller class.
  608. /// @copydetails WS2812Controller800Khz
  609. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  610. class PL9823Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 8 * FMUL, 3 * FMUL, RGB_ORDER> {};
  611.  
  612. #else
  613.  
  614. /// Calculates the number of cycles for the clockless chipset (which may differ from CPU cycles)
  615. /// @see ::NS()
  616. #ifdef FASTLED_TEENSY4
  617. // just use raw nanosecond values for the teensy4
  618. #define C_NS(_NS) _NS
  619. #else
  620. #define C_NS(_NS) (((_NS * ((CLOCKLESS_FREQUENCY / 1000000L)) + 999)) / 1000)
  621. #endif
  622.  
  623. // GE8822 - 350ns 660ns 350ns
  624. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  625. class GE8822Controller800Khz : public ClocklessController<DATA_PIN, C_NS(350), C_NS(660), C_NS(350), RGB_ORDER, 4> {};
  626.  
  627. // GW6205@400khz - 800ns, 800ns, 800ns
  628. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  629. class GW6205Controller400Khz : public ClocklessController<DATA_PIN, C_NS(800), C_NS(800), C_NS(800), RGB_ORDER, 4> {};
  630.  
  631. // GW6205@400khz - 400ns, 400ns, 400ns
  632. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  633. class GW6205Controller800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(400), C_NS(400), RGB_ORDER, 4> {};
  634.  
  635. // UCS1903 - 500ns, 1500ns, 500ns
  636. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  637. class UCS1903Controller400Khz : public ClocklessController<DATA_PIN, C_NS(500), C_NS(1500), C_NS(500), RGB_ORDER> {};
  638.  
  639. // UCS1903B - 400ns, 450ns, 450ns
  640. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  641. class UCS1903BController800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(450), C_NS(450), RGB_ORDER> {};
  642.  
  643. // UCS1904 - 400ns, 400ns, 450ns
  644. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  645. class UCS1904Controller800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(400), C_NS(450), RGB_ORDER> {};
  646.  
  647. // UCS2903 - 250ns, 750ns, 250ns
  648. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  649. class UCS2903Controller : public ClocklessController<DATA_PIN, C_NS(250), C_NS(750), C_NS(250), RGB_ORDER> {};
  650.  
  651. // TM1809 - 350ns, 350ns, 550ns
  652. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  653. class TM1809Controller800Khz : public ClocklessController<DATA_PIN, C_NS(350), C_NS(350), C_NS(450), RGB_ORDER> {};
  654.  
  655. // WS2811 - 320ns, 320ns, 640ns
  656. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  657. class WS2811Controller800Khz : public ClocklessController<DATA_PIN, C_NS(320), C_NS(320), C_NS(640), RGB_ORDER> {};
  658.  
  659. // WS2813 - 320ns, 320ns, 640ns
  660. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  661. class WS2813Controller : public ClocklessController<DATA_PIN, C_NS(320), C_NS(320), C_NS(640), RGB_ORDER> {};
  662.  
  663. // WS2812 - 250ns, 625ns, 375ns
  664. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  665. class WS2812Controller800Khz : public ClocklessController<DATA_PIN, C_NS(250), C_NS(625), C_NS(375), RGB_ORDER> {};
  666.  
  667. // WS2811@400khz - 800ns, 800ns, 900ns
  668. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  669. class WS2811Controller400Khz : public ClocklessController<DATA_PIN, C_NS(800), C_NS(800), C_NS(900), RGB_ORDER> {};
  670.  
  671. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  672. class WS2815V5Controller800Khz : public ClocklessController<DATA_PIN, C_NS(220), C_NS(515), C_NS(515), RGB_ORDER> {};
  673.  
  674. // 750NS, 750NS, 750NS
  675. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  676. class TM1803Controller400Khz : public ClocklessController<DATA_PIN, C_NS(700), C_NS(1100), C_NS(700), RGB_ORDER> {};
  677.  
  678. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  679. class TM1829Controller800Khz : public ClocklessController<DATA_PIN, C_NS(340), C_NS(340), C_NS(550), RGB_ORDER, 0, true, 500> {};
  680.  
  681. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  682. class TM1829Controller1600Khz : public ClocklessController<DATA_PIN, C_NS(100), C_NS(300), C_NS(200), RGB_ORDER, 0, true, 500> {};
  683.  
  684. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  685. class LPD1886Controller1250Khz : public ClocklessController<DATA_PIN, C_NS(200), C_NS(400), C_NS(200), RGB_ORDER, 4> {};
  686.  
  687. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  688. class LPD1886Controller1250Khz_8bit : public ClocklessController<DATA_PIN, C_NS(200), C_NS(400), C_NS(200), RGB_ORDER> {};
  689.  
  690.  
  691. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  692. class SK6822Controller : public ClocklessController<DATA_PIN, C_NS(375), C_NS(1000), C_NS(375), RGB_ORDER> {};
  693.  
  694. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  695. class SK6812Controller : public ClocklessController<DATA_PIN, C_NS(300), C_NS(300), C_NS(600), RGB_ORDER> {};
  696.  
  697. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  698. class SM16703Controller : public ClocklessController<DATA_PIN, C_NS(300), C_NS(600), C_NS(300), RGB_ORDER> {};
  699.  
  700. template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
  701. class PL9823Controller : public ClocklessController<DATA_PIN, C_NS(350), C_NS(1010), C_NS(350), RGB_ORDER> {};
  702. #endif
  703. /// @} ClocklessChipsets
  704.  
  705. #endif
  706. /// @} Chipsets
  707.  
  708. FASTLED_NAMESPACE_END
  709.  
  710. #endif
  711.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!