logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

ws2812_pwm.c (17874B)

    

  1. #include "ws2812.h"
  2. #include "gpio.h"
  3. #include "chibios_config.h"
  5. // ======== DEPRECATED DEFINES - DO NOT USE ========
  6. #ifdef WS2812_DMA_STREAM
  7. #    define WS2812_PWM_DMA_STREAM WS2812_DMA_STREAM
  8. #endif
  9. #ifdef WS2812_DMA_CHANNEL
  10. #    define WS2812_PWM_DMA_CHANNEL WS2812_DMA_CHANNEL
  11. #endif
  12. #ifdef WS2812_DMAMUX_ID
  13. #    define WS2812_PWM_DMAMUX_ID WS2812_DMAMUX_ID
  14. #endif
  15. // ========
  17. /* Adapted from https://github.com/joewa/WS2812-LED-Driver_ChibiOS/ */
  19. #ifdef WS2812_RGBW
  20. #    define WS2812_CHANNELS 4
  21. #else
  22. #    define WS2812_CHANNELS 3
  23. #endif
  25. #ifndef WS2812_PWM_DRIVER
  26. #    define WS2812_PWM_DRIVER PWMD2 // TIMx
  27. #endif
  28. #ifndef WS2812_PWM_CHANNEL
  29. #    define WS2812_PWM_CHANNEL 2 // Channel
  30. #endif
  31. #ifndef WS2812_PWM_PAL_MODE
  32. #    define WS2812_PWM_PAL_MODE 2 // DI Pin's alternate function value
  33. #endif
  34. #ifndef WS2812_PWM_DMA_STREAM
  35. #    define WS2812_PWM_DMA_STREAM STM32_DMA1_STREAM2 // DMA Stream for TIMx_UP
  36. #endif
  37. #ifndef WS2812_PWM_DMA_CHANNEL
  38. #    define WS2812_PWM_DMA_CHANNEL 2 // DMA Channel for TIMx_UP
  39. #endif
  40. #if (STM32_DMA_SUPPORTS_DMAMUX == TRUE) && !defined(WS2812_PWM_DMAMUX_ID)
  41. #    error "please consult your MCU's datasheet and specify in your config.h: #define WS2812_PWM_DMAMUX_ID STM32_DMAMUX1_TIM?_UP"
  42. #endif
  43. #if (AT32_DMA_SUPPORTS_DMAMUX == TRUE) && !defined(WS2812_PWM_DMAMUX_CHANNEL) && !defined(WS2812_PWM_DMAMUX_ID)
  44. #    error "please consult your MCU's datasheet and specify in your config.h: #define WS2812_PWM_DMAMUX_CHANNEL 1, #define WS2812_PWM_DMAMUX_ID AT32_DMAMUX_TMR?_OVERFLOW"
  45. #endif
  47. /* Summarize https://www.st.com/resource/en/application_note/an4013-stm32-crossseries-timer-overview-stmicroelectronics.pdf to
  48.  * figure out if we are using a 32bit timer. This is needed to setup the DMA controller correctly.
  49.  * Ignore STM32H7XX and STM32U5XX as they are not supported by ChibiOS.
  50.  */
  51. #if !defined(STM32F1XX) && !defined(STM32L0XX) && !defined(STM32L1XX)
  52. #    define WS2812_PWM_TIMER_32BIT_PWMD2 1
  53. #endif
  54. #if !defined(STM32F1XX)
  55. #    define WS2812_PWM_TIMER_32BIT_PWMD5 1
  56. #endif
  57. #define WS2812_CONCAT1(a, b) a##b
  58. #define WS2812_CONCAT(a, b) WS2812_CONCAT1(a, b)
  59. #if WS2812_CONCAT(WS2812_PWM_TIMER_32BIT_, WS2812_PWM_DRIVER)
  60. #    define WS2812_PWM_TIMER_32BIT
  61. #endif
  63. #ifndef WS2812_PWM_COMPLEMENTARY_OUTPUT
  64. #    define WS2812_PWM_OUTPUT_MODE PWM_OUTPUT_ACTIVE_HIGH
  65. #else
  66. #    define WS2812_PWM_OUTPUT_MODE PWM_COMPLEMENTARY_OUTPUT_ACTIVE_HIGH
  67. #endif
  69. // Push Pull or Open Drain Configuration
  70. // Default Push Pull
  71. #ifndef WS2812_EXTERNAL_PULLUP
  72. #    if defined(USE_GPIOV1)
  73. #        define WS2812_OUTPUT_MODE PAL_MODE_ALTERNATE_PUSHPULL
  74. #    else
  75. #        define WS2812_OUTPUT_MODE PAL_MODE_ALTERNATE(WS2812_PWM_PAL_MODE) | PAL_OUTPUT_TYPE_PUSHPULL | PAL_OUTPUT_SPEED_HIGHEST | PAL_PUPDR_FLOATING
  76. #    endif
  77. #else
  78. #    if defined(USE_GPIOV1)
  79. #        define WS2812_OUTPUT_MODE PAL_MODE_ALTERNATE_OPENDRAIN
  80. #    else
  81. #        define WS2812_OUTPUT_MODE PAL_MODE_ALTERNATE(WS2812_PWM_PAL_MODE) | PAL_OUTPUT_TYPE_OPENDRAIN | PAL_OUTPUT_SPEED_HIGHEST | PAL_PUPDR_FLOATING
  82. #    endif
  83. #endif
  85. // Default is 800000Hz, which has a period of 1.25us
  86. #ifndef WS2812_PWM_FREQUENCY
  87. #    define WS2812_PWM_FREQUENCY (1000000000 / WS2812_TIMING)
  88. #endif
  90. /* --- PRIVATE CONSTANTS ---------------------------------------------------- */
  92. #define WS2812_PWM_TICK_FREQUENCY (CPU_CLOCK / 2)                            /**< Clock frequency of PWM ticks, must be valid with respect to system clock! */
  93. #define WS2812_PWM_PERIOD (WS2812_PWM_TICK_FREQUENCY / WS2812_PWM_FREQUENCY) /**< Clock period in PWM ticks. */
  95. /**
  96.  * @brief   Number of bit-periods to hold the data line low at the end of a frame
  97.  *
  98.  * The reset period for each frame is defined in WS2812_TRST_US.
  99.  * Calculate the number of zeroes to add at the end assuming 1.25 uS/bit:
  100.  */
  101. #define WS2812_COLOR_BITS (WS2812_CHANNELS * 8)
  102. #define WS2812_RESET_BIT_N (1000 * WS2812_TRST_US / WS2812_TIMING)
  103. #define WS2812_COLOR_BIT_N (WS2812_LED_COUNT * WS2812_COLOR_BITS) /**< Number of data bits */
  104. #define WS2812_BIT_N (WS2812_COLOR_BIT_N + WS2812_RESET_BIT_N)    /**< Total number of bits in a frame */
  106. /**
  107.  * @brief   High period for a zero, in ticks
  108.  */
  109. #define WS2812_DUTYCYCLE_0 (WS2812_PWM_TICK_FREQUENCY / (1000000000 / WS2812_T0H))
  110. #if (WS2812_DUTYCYCLE_0 > 255)
  111. #    error WS2812 PWM driver: High period for a 0 is more than a byte
  112. #endif
  114. /**
  115.  * @brief   High period for a one, in ticks
  116.  */
  117. #define WS2812_DUTYCYCLE_1 (WS2812_PWM_TICK_FREQUENCY / (1000000000 / WS2812_T1H))
  118. #if (WS2812_DUTYCYCLE_1 > 255)
  119. #    error WS2812 PWM driver: High period for a 1 is more than a byte
  120. #endif
  122. /* --- PRIVATE MACROS ------------------------------------------------------- */
  124. /**
  125.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given bit
  126.  *
  127.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  128.  * @param[in] byte:                 The byte number [0, 2]
  129.  * @param[in] bit:                  The bit number [0, 7]
  130.  *
  131.  * @return                          The bit index
  132.  */
  133. #define WS2812_BIT(led, byte, bit) (WS2812_COLOR_BITS * (led) + 8 * (byte) + (7 - (bit)))
  135. #if (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_GRB)
  136. /**
  137.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given red bit
  138.  *
  139.  * @note    The red byte is the middle byte in the color packet
  140.  *
  141.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  142.  * @param[in] bit:                  The bit number [0, 7]
  143.  *
  144.  * @return                          The bit index
  145.  */
  146. #    define WS2812_RED_BIT(led, bit) WS2812_BIT((led), 1, (bit))
  148. /**
  149.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given green bit
  150.  *
  151.  * @note    The red byte is the first byte in the color packet
  152.  *
  153.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  154.  * @param[in] bit:                  The bit number [0, 7]
  155.  *
  156.  * @return                          The bit index
  157.  */
  158. #    define WS2812_GREEN_BIT(led, bit) WS2812_BIT((led), 0, (bit))
  160. /**
  161.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given blue bit
  162.  *
  163.  * @note    The red byte is the last byte in the color packet
  164.  *
  165.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  166.  * @param[in] bit:                  The bit index [0, 7]
  167.  *
  168.  * @return                          The bit index
  169.  */
  170. #    define WS2812_BLUE_BIT(led, bit) WS2812_BIT((led), 2, (bit))
  172. #elif (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_RGB)
  173. /**
  174.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given red bit
  175.  *
  176.  * @note    The red byte is the middle byte in the color packet
  177.  *
  178.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  179.  * @param[in] bit:                  The bit number [0, 7]
  180.  *
  181.  * @return                          The bit index
  182.  */
  183. #    define WS2812_RED_BIT(led, bit) WS2812_BIT((led), 0, (bit))
  185. /**
  186.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given green bit
  187.  *
  188.  * @note    The red byte is the first byte in the color packet
  189.  *
  190.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  191.  * @param[in] bit:                  The bit number [0, 7]
  192.  *
  193.  * @return                          The bit index
  194.  */
  195. #    define WS2812_GREEN_BIT(led, bit) WS2812_BIT((led), 1, (bit))
  197. /**
  198.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given blue bit
  199.  *
  200.  * @note    The red byte is the last byte in the color packet
  201.  *
  202.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  203.  * @param[in] bit:                  The bit index [0, 7]
  204.  *
  205.  * @return                          The bit index
  206.  */
  207. #    define WS2812_BLUE_BIT(led, bit) WS2812_BIT((led), 2, (bit))
  209. #elif (WS2812_BYTE_ORDER == WS2812_BYTE_ORDER_BGR)
  210. /**
  211.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given red bit
  212.  *
  213.  * @note    The red byte is the middle byte in the color packet
  214.  *
  215.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  216.  * @param[in] bit:                  The bit number [0, 7]
  217.  *
  218.  * @return                          The bit index
  219.  */
  220. #    define WS2812_RED_BIT(led, bit) WS2812_BIT((led), 2, (bit))
  222. /**
  223.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given green bit
  224.  *
  225.  * @note    The red byte is the first byte in the color packet
  226.  *
  227.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  228.  * @param[in] bit:                  The bit number [0, 7]
  229.  *
  230.  * @return                          The bit index
  231.  */
  232. #    define WS2812_GREEN_BIT(led, bit) WS2812_BIT((led), 1, (bit))
  234. /**
  235.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given blue bit
  236.  *
  237.  * @note    The red byte is the last byte in the color packet
  238.  *
  239.  * @param[in] led:                  The led index [0, @ref WS2812_LED_COUNT)
  240.  * @param[in] bit:                  The bit index [0, 7]
  241.  *
  242.  * @return                          The bit index
  243.  */
  244. #    define WS2812_BLUE_BIT(led, bit) WS2812_BIT((led), 0, (bit))
  245. #endif
  247. #ifdef WS2812_RGBW
  248. /**
  249.  * @brief   Determine the index in @ref ws2812_frame_buffer "the frame buffer" of a given white bit
  250.  *
  251.  * @note    The white byte is the last byte in the color packet
  252.  *
  253.  * @param[in] led:                  The led index [0, @ref WS2812_LED_N)
  254.  * @param[in] bit:                  The bit index [0, 7]
  255.  *
  256.  * @return                          The bit index
  257.  */
  258. #    define WS2812_WHITE_BIT(led, bit) WS2812_BIT((led), 3, (bit))
  259. #endif
  261. /* --- PRIVATE VARIABLES ---------------------------------------------------- */
  263. // STM32F2XX, STM32F4XX and STM32F7XX do NOT zero pad DMA transfers of unequal data width. Buffer width must match TIMx CCR.
  264. // For all other STM32 DMA transfer will automatically zero pad. We only need to set the right peripheral width.
  265. #if defined(STM32F2XX) || defined(STM32F4XX) || defined(STM32F7XX)
  266. #    if defined(WS2812_PWM_TIMER_32BIT)
  267. #        define WS2812_PWM_DMA_MEMORY_WIDTH STM32_DMA_CR_MSIZE_WORD
  268. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH STM32_DMA_CR_PSIZE_WORD
  269. typedef uint32_t ws2812_buffer_t;
  270. #    else
  271. #        define WS2812_PWM_DMA_MEMORY_WIDTH STM32_DMA_CR_MSIZE_HWORD
  272. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH STM32_DMA_CR_PSIZE_HWORD
  273. typedef uint16_t ws2812_buffer_t;
  274. #    endif
  275. #elif defined(AT32F415)
  276. #    define WS2812_PWM_DMA_MEMORY_WIDTH AT32_DMA_CCTRL_MWIDTH_BYTE
  277. #    if defined(WS2812_PWM_TIMER_32BIT)
  278. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH AT32_DMA_CCTRL_PWIDTH_WORD
  279. #    else
  280. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH AT32_DMA_CCTRL_PWIDTH_HWORD
  281. #    endif
  282. typedef uint8_t ws2812_buffer_t;
  283. #else
  284. #    define WS2812_PWM_DMA_MEMORY_WIDTH STM32_DMA_CR_MSIZE_BYTE
  285. #    if defined(WS2812_PWM_TIMER_32BIT)
  286. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH STM32_DMA_CR_PSIZE_WORD
  287. #    else
  288. #        define WS2812_PWM_DMA_PERIPHERAL_WIDTH STM32_DMA_CR_PSIZE_HWORD
  289. #    endif
  290. typedef uint8_t ws2812_buffer_t;
  291. #endif
  293. static ws2812_buffer_t ws2812_frame_buffer[WS2812_BIT_N + 1]; /**< Buffer for a frame */
  295. /* --- PUBLIC FUNCTIONS ----------------------------------------------------- */
  296. /*
  297.  * Gedanke: Double-buffer type transactions: double buffer transfers using two memory pointers for
  298.  * the memory (while the DMA is reading/writing from/to a buffer, the application can
  299.  * write/read to/from the other buffer).
  300.  */
  302. void ws2812_init(void) {
  303.     // Initialize led frame buffer
  304.     uint32_t i;
  305.     for (i = 0; i < WS2812_COLOR_BIT_N; i++)
  306.         ws2812_frame_buffer[i] = WS2812_DUTYCYCLE_0; // All color bits are zero duty cycle
  307.     for (i = 0; i < WS2812_RESET_BIT_N; i++)
  308.         ws2812_frame_buffer[i + WS2812_COLOR_BIT_N] = 0; // All reset bits are zero
  310.     palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE);
  312.     // PWM Configuration
  313.     //#pragma GCC diagnostic ignored "-Woverride-init"  // Turn off override-init warning for this struct. We use the overriding ability to set a "default" channel config
  314.     static const PWMConfig ws2812_pwm_config = {
  315.         .frequency = WS2812_PWM_TICK_FREQUENCY,
  316.         .period    = WS2812_PWM_PERIOD, // Mit dieser Periode wird UDE-Event erzeugt und ein neuer Wert (Länge WS2812_BIT_N) vom DMA ins CCR geschrieben
  317.         .callback  = NULL,
  318.         .channels =
  319.             {
  320.                 [0 ... 3]                = {.mode = PWM_OUTPUT_DISABLED, .callback = NULL},    // Channels default to disabled
  321.                 [WS2812_PWM_CHANNEL - 1] = {.mode = WS2812_PWM_OUTPUT_MODE, .callback = NULL}, // Turn on the channel we care about
  322.             },
  323. #if defined(AT32F415)
  324.         .ctrl2 = 0,
  325.         .iden  = AT32_TMR_IDEN_OVFDEN, // DMA on update event for next period
  326. #else
  327.         .cr2  = 0,
  328.         .dier = TIM_DIER_UDE, // DMA on update event for next period
  329. #endif
  330.     };
  331.     //#pragma GCC diagnostic pop  // Restore command-line warning options
  333.     // Configure DMA
  334.     // dmaInit(); // Joe added this
  335. #if defined(WB32F3G71xx) || defined(WB32FQ95xx)
  336.     dmaStreamAlloc(WS2812_PWM_DMA_STREAM - WB32_DMA_STREAM(0), 10, NULL, NULL);
  337.     dmaStreamSetSource(WS2812_PWM_DMA_STREAM, ws2812_frame_buffer);
  338.     dmaStreamSetDestination(WS2812_PWM_DMA_STREAM, &(WS2812_PWM_DRIVER.tim->CCR[WS2812_PWM_CHANNEL - 1])); // Ziel ist der An-Zeit im Cap-Comp-Register
  339.     dmaStreamSetMode(WS2812_PWM_DMA_STREAM, WB32_DMA_CHCFG_HWHIF(WS2812_PWM_DMA_CHANNEL) | WB32_DMA_CHCFG_DIR_M2P | WB32_DMA_CHCFG_PSIZE_WORD | WB32_DMA_CHCFG_MSIZE_WORD | WB32_DMA_CHCFG_MINC | WB32_DMA_CHCFG_CIRC | WB32_DMA_CHCFG_TCIE | WB32_DMA_CHCFG_PL(3));
  340. #elif defined(AT32F415)
  341.     dmaStreamAlloc(WS2812_PWM_DMA_STREAM - AT32_DMA_STREAM(0), 10, NULL, NULL);
  342.     dmaStreamSetPeripheral(WS2812_PWM_DMA_STREAM, &(WS2812_PWM_DRIVER.tmr->CDT[WS2812_PWM_CHANNEL - 1])); // Ziel ist der An-Zeit im Cap-Comp-Register
  343.     dmaStreamSetMemory0(WS2812_PWM_DMA_STREAM, ws2812_frame_buffer);
  344.     dmaStreamSetMode(WS2812_PWM_DMA_STREAM, AT32_DMA_CCTRL_DTD_M2P | WS2812_PWM_DMA_PERIPHERAL_WIDTH | WS2812_PWM_DMA_MEMORY_WIDTH | AT32_DMA_CCTRL_MINCM | AT32_DMA_CCTRL_LM | AT32_DMA_CCTRL_CHPL(3));
  345. #else
  346.     dmaStreamAlloc(WS2812_PWM_DMA_STREAM - STM32_DMA_STREAM(0), 10, NULL, NULL);
  347.     dmaStreamSetPeripheral(WS2812_PWM_DMA_STREAM, &(WS2812_PWM_DRIVER.tim->CCR[WS2812_PWM_CHANNEL - 1])); // Ziel ist der An-Zeit im Cap-Comp-Register
  348.     dmaStreamSetMemory0(WS2812_PWM_DMA_STREAM, ws2812_frame_buffer);
  349.     dmaStreamSetMode(WS2812_PWM_DMA_STREAM, STM32_DMA_CR_CHSEL(WS2812_PWM_DMA_CHANNEL) | STM32_DMA_CR_DIR_M2P | WS2812_PWM_DMA_PERIPHERAL_WIDTH | WS2812_PWM_DMA_MEMORY_WIDTH | STM32_DMA_CR_MINC | STM32_DMA_CR_CIRC | STM32_DMA_CR_PL(3));
  350. #endif
  351.     dmaStreamSetTransactionSize(WS2812_PWM_DMA_STREAM, WS2812_BIT_N);
  352.     // M2P: Memory 2 Periph; PL: Priority Level
  354. #if (STM32_DMA_SUPPORTS_DMAMUX == TRUE)
  355.     // If the MCU has a DMAMUX we need to assign the correct resource
  356.     dmaSetRequestSource(WS2812_PWM_DMA_STREAM, WS2812_PWM_DMAMUX_ID);
  357. #endif
  359. #if (AT32_DMA_SUPPORTS_DMAMUX == TRUE)
  360.     // If the MCU has a DMAMUX we need to assign the correct resource
  361.     dmaSetRequestSource(WS2812_PWM_DMA_STREAM, WS2812_PWM_DMAMUX_CHANNEL, WS2812_PWM_DMAMUX_ID);
  362. #endif
  364.     // Start DMA
  365.     dmaStreamEnable(WS2812_PWM_DMA_STREAM);
  367.     // Configure PWM
  368.     // NOTE: It's required that preload be enabled on the timer channel CCR register. This is currently enabled in the
  369.     // ChibiOS driver code, so we don't have to do anything special to the timer. If we did, we'd have to start the timer,
  370.     // disable counting, enable the channel, and then make whatever configuration changes we need.
  371.     pwmStart(&WS2812_PWM_DRIVER, &ws2812_pwm_config);
  372.     pwmEnableChannel(&WS2812_PWM_DRIVER, WS2812_PWM_CHANNEL - 1, 0); // Initial period is 0; output will be low until first duty cycle is DMA'd in
  373. }
  375. void ws2812_write_led(uint16_t led_number, uint8_t r, uint8_t g, uint8_t b) {
  376.     // Write color to frame buffer
  377.     for (uint8_t bit = 0; bit < 8; bit++) {
  378.         ws2812_frame_buffer[WS2812_RED_BIT(led_number, bit)]   = ((r >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  379.         ws2812_frame_buffer[WS2812_GREEN_BIT(led_number, bit)] = ((g >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  380.         ws2812_frame_buffer[WS2812_BLUE_BIT(led_number, bit)]  = ((b >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  381.     }
  382. }
  383. void ws2812_write_led_rgbw(uint16_t led_number, uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
  384.     // Write color to frame buffer
  385.     for (uint8_t bit = 0; bit < 8; bit++) {
  386.         ws2812_frame_buffer[WS2812_RED_BIT(led_number, bit)]   = ((r >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  387.         ws2812_frame_buffer[WS2812_GREEN_BIT(led_number, bit)] = ((g >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  388.         ws2812_frame_buffer[WS2812_BLUE_BIT(led_number, bit)]  = ((b >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  389. #ifdef WS2812_RGBW
  390.         ws2812_frame_buffer[WS2812_WHITE_BIT(led_number, bit)] = ((w >> bit) & 0x01) ? WS2812_DUTYCYCLE_1 : WS2812_DUTYCYCLE_0;
  391. #endif
  392.     }
  393. }
  395. ws2812_led_t ws2812_leds[WS2812_LED_COUNT];
  397. void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
  398.     ws2812_leds[index].r = red;
  399.     ws2812_leds[index].g = green;
  400.     ws2812_leds[index].b = blue;
  401. #if defined(WS2812_RGBW)
  402.     ws2812_rgb_to_rgbw(&ws2812_leds[index]);
  403. #endif
  404. }
  406. void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
  407.     for (int i = 0; i < WS2812_LED_COUNT; i++) {
  408.         ws2812_set_color(i, red, green, blue);
  409.     }
  410. }
  412. void ws2812_flush(void) {
  413.     for (int i = 0; i < WS2812_LED_COUNT; i++) {
  414. #if defined(WS2812_RGBW)
  415.         ws2812_write_led_rgbw(i, ws2812_leds[i].r, ws2812_leds[i].g, ws2812_leds[i].b, ws2812_leds[i].w);
  416. #else
  417.         ws2812_write_led(i, ws2812_leds[i].r, ws2812_leds[i].g, ws2812_leds[i].b);
  418. #endif
  419.     }
  420. }