ARGB.c

/**
 *******************************************
 * @file    ARGB.c
 * @author  Dmitriy Semenov / Crazy_Geeks
 * @link    https://crazygeeks.ru
 * @version 3.00
 * @date    06-Oct-2025
 * @brief   ARGB驱动源文件（可寻址RGB LED）
 * @note    针对多条独立配置的LED灯带进行优化
 *******************************************
 */

 #include "ARGB.h"
 #include "math.h"
 #include "string.h"
 
 // ARGB实例链表头指针
 static ARGB_HandleTypeDef *ARGB_ListHead = NULL;
 
 /**
  * @brief 8位缩放函数
  * @param x 输入值
  * @param scale 缩放因子
  * @return 缩放后的值
  */
 static inline uint8_t scale8(uint8_t x, uint8_t scale) {
   return ((uint16_t)x * scale) >> 8;
 }
 
 /**
  * @brief HSV转RGB颜色空间转换
  * @param hsv HSV颜色结构体
  * @param[out] rgb RGB颜色结构体指针
  */
 static void HSV2RGB(ARGB_HSV hsv, ARGB_RGB *rgb) {
   if (hsv.s == 0) {
     rgb->r = rgb->g = rgb->b = hsv.v;
     return;
   }
 
   float h = (float)hsv.h / 255;
   float s = (float)hsv.s / 255;
   float v = (float)hsv.v / 255;
 
   int i = (int)floorf(h * 6);
   float f = h * 6 - (float)i;
   uint8_t p = (uint8_t)(v * (1 - s) * 255.0);
   uint8_t q = (uint8_t)(v * (1 - f * s) * 255.0);
   uint8_t t = (uint8_t)(v * (1 - (1 - f) * s) * 255.0);
 
   switch (i % 6) {
   case 0:
     rgb->r = hsv.v, rgb->g = t, rgb->b = p;
     break;
   case 1:
     rgb->r = q, rgb->g = hsv.v, rgb->b = p;
     break;
   case 2:
     rgb->r = p, rgb->g = hsv.v, rgb->b = t;
     break;
   case 3:
     rgb->r = p, rgb->g = q, rgb->b = hsv.v;
     break;
   case 4:
     rgb->r = t, rgb->g = p, rgb->b = hsv.v;
     break;
   default:
     rgb->r = hsv.v, rgb->g = p, rgb->b = q;
     break;
   }
 }
 
 /**
  * @brief 注册ARGB实例到链表
  * @param hargb ARGB句柄指针
  */
 static void ARGB_RegisterInstance(ARGB_HandleTypeDef *hargb) {
   if (hargb == NULL)
     return;
   hargb->next = ARGB_ListHead;
   ARGB_ListHead = hargb;
 }
 
 /**
  * @brief 从链表注销ARGB实例
  * @param hargb ARGB句柄指针
  */
 static void ARGB_UnregisterInstance(ARGB_HandleTypeDef *hargb) {
   if (hargb == NULL)
     return;
   ARGB_HandleTypeDef **pp = &ARGB_ListHead;
   while (*pp) {
     if (*pp == hargb) {
       *pp = hargb->next;
       hargb->next = NULL;
       return;
     }
     pp = &((*pp)->next);
   }
 }
 
 /**
  * @brief 通过DMA句柄查找ARGB实例
  * @param hdma DMA句柄指针
  * @return ARGB句柄指针，未找到则返回NULL
  */
 static ARGB_HandleTypeDef *ARGB_FindInstance(DMA_HandleTypeDef *hdma) {
   for (ARGB_HandleTypeDef *p = ARGB_ListHead; p != NULL; p = p->next) {
     if (p->hdma == hdma)
       return p;
   }
   return NULL;
 }
 
 /**
  * @brief 获取定时器DMA ID
  * @param channel 定时器通道
  * @return DMA ID
  */
 static uint32_t ARGB_GetTimDmaId(uint32_t channel) {
   switch (channel) {
   case TIM_CHANNEL_1:
     return TIM_DMA_ID_CC1;
   case TIM_CHANNEL_2:
     return TIM_DMA_ID_CC2;
   case TIM_CHANNEL_3:
     return TIM_DMA_ID_CC3;
   case TIM_CHANNEL_4:
     return TIM_DMA_ID_CC4;
   default:
     return TIM_DMA_ID_CC1;
   }
 }
 
 /**
  * @brief 获取定时器DMA CC标志
  * @param channel 定时器通道
  * @return DMA CC标志
  */
 static uint32_t ARGB_GetTimDmaCc(uint32_t channel) {
   switch (channel) {
   case TIM_CHANNEL_1:
     return TIM_DMA_CC1;
   case TIM_CHANNEL_2:
     return TIM_DMA_CC2;
   case TIM_CHANNEL_3:
     return TIM_DMA_CC3;
   case TIM_CHANNEL_4:
     return TIM_DMA_CC4;
   default:
     return TIM_DMA_CC1;
   }
 }
 
 /**
  * @brief 获取CCR寄存器地址
  * @param tim 定时器外设指针
  * @param channel 定时器通道
  * @return CCR寄存器地址
  */
 static volatile uint32_t *ARGB_GetCcrAddress(TIM_TypeDef *tim,
                                              uint32_t channel) {
   switch (channel) {
   case TIM_CHANNEL_1:
     return &tim->CCR1;
   case TIM_CHANNEL_2:
     return &tim->CCR2;
   case TIM_CHANNEL_3:
     return &tim->CCR3;
   case TIM_CHANNEL_4:
     return &tim->CCR4;
   default:
     return &tim->CCR1;
   }
 }
 
 /**
  * @brief 设置PWM值到缓冲区
  * @param hargb ARGB句柄指针
  * @param index 缓冲区索引
  * @param value PWM值
  */
 static void ARGB_SetPWMValue(ARGB_HandleTypeDef *hargb, uint16_t index,
                              uint8_t value) {
   switch (hargb->dma_size) {
   case ARGB_DMA_BYTE:
     ((volatile uint8_t *)hargb->pwm_buf)[index] = value;
     break;
   case ARGB_DMA_HWORD:
     ((volatile uint16_t *)hargb->pwm_buf)[index] = value;
     break;
   case ARGB_DMA_WORD:
     ((volatile uint32_t *)hargb->pwm_buf)[index] = value;
     break;
   }
 }
 
 /**
  * @brief DMA传输完成回调函数
  * @param hdma DMA句柄指针
  * @note 填充PWM缓冲区的后半部分或发送RET信号
  */
 static void ARGB_TIM_DMADelayPulseCplt(DMA_HandleTypeDef *hdma) {
   TIM_HandleTypeDef *htim =
       (TIM_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
   if (htim == NULL)
     return;
 
   ARGB_HandleTypeDef *hargb = ARGB_FindInstance(hdma);
   if (hargb == NULL)
     return;
   if (hargb->buf_counter == 0)
     return;
 
   // 设置通道状态
   if (hdma == htim->hdma[TIM_DMA_ID_CC1]) {
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1;
     if (hdma->Init.Mode == DMA_NORMAL) {
       TIM_CHANNEL_STATE_SET(htim, TIM_CHANNEL_1, HAL_TIM_CHANNEL_STATE_READY);
     }
   } else if (hdma == htim->hdma[TIM_DMA_ID_CC2]) {
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2;
     if (hdma->Init.Mode == DMA_NORMAL) {
       TIM_CHANNEL_STATE_SET(htim, TIM_CHANNEL_2, HAL_TIM_CHANNEL_STATE_READY);
     }
   } else if (hdma == htim->hdma[TIM_DMA_ID_CC3]) {
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3;
     if (hdma->Init.Mode == DMA_NORMAL) {
       TIM_CHANNEL_STATE_SET(htim, TIM_CHANNEL_3, HAL_TIM_CHANNEL_STATE_READY);
     }
   } else if (hdma == htim->hdma[TIM_DMA_ID_CC4]) {
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4;
     if (hdma->Init.Mode == DMA_NORMAL) {
       TIM_CHANNEL_STATE_SET(htim, TIM_CHANNEL_4, HAL_TIM_CHANNEL_STATE_READY);
     }
   }
 
   // 数据传输阶段
   if (hargb->buf_counter < hargb->num_pixels) {
     // 填充缓冲区后半部分
     uint16_t base_idx = hargb->bytes_per_pixel * hargb->buf_counter;
     uint16_t half_buf = hargb->pwm_buf_len / 2;
 
     for (uint8_t byte_idx = 0; byte_idx < hargb->bytes_per_pixel; byte_idx++) {
       for (uint8_t bit = 0; bit < 8; bit++) {
         uint8_t pwm_val = ((hargb->rgb_buf[base_idx + byte_idx] << bit) & 0x80)
                               ? hargb->pwm_hi
                               : hargb->pwm_lo;
         ARGB_SetPWMValue(hargb, half_buf + byte_idx * 8 + bit, pwm_val);
       }
     }
     hargb->buf_counter++;
   } else if (hargb->buf_counter < hargb->num_pixels + 2) {
     // RET复位信号传输 - 清空后半部分
     uint16_t half_buf_len = hargb->pwm_buf_len / 2;
     uint16_t element_size = ARGB_DMA_ELEM_SIZE(hargb->dma_size);
     void *second_half_ptr =
         (void *)((uint8_t *)hargb->pwm_buf + half_buf_len * element_size);
     memset(second_half_ptr, 0, half_buf_len * element_size);
     hargb->buf_counter++;
   } else {
     // 传输结束
     hargb->buf_counter = 0;
 
     __HAL_TIM_DISABLE_DMA(htim, hargb->dma_cc);
     (void)HAL_DMA_Abort_IT(htim->hdma[hargb->dma_id]);
 
     if (IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET) {
       __HAL_TIM_MOE_DISABLE(htim);
     }
 
     __HAL_TIM_DISABLE(htim);
     TIM_CHANNEL_STATE_SET(htim, hargb->tim_channel,
                           HAL_TIM_CHANNEL_STATE_READY);
     hargb->state = ARGB_READY;
   }
 
   htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
 }
 
 /**
  * @brief DMA半传输完成回调函数
  * @param hdma DMA句柄指针
  * @note 填充PWM缓冲区的前半部分或发送RET信号
  */
 static void ARGB_TIM_DMADelayPulseHalfCplt(DMA_HandleTypeDef *hdma) {
   TIM_HandleTypeDef *htim =
       (TIM_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
   if (htim == NULL)
     return;
 
   ARGB_HandleTypeDef *hargb = ARGB_FindInstance(hdma);
   if (hargb == NULL)
     return;
   if (hargb->buf_counter == 0)
     return;
 
   // 数据传输阶段
   if (hargb->buf_counter < hargb->num_pixels) {
     // 填充缓冲区前半部分
     uint16_t base_idx = hargb->bytes_per_pixel * hargb->buf_counter;
 
     for (uint8_t byte_idx = 0; byte_idx < hargb->bytes_per_pixel; byte_idx++) {
       for (uint8_t bit = 0; bit < 8; bit++) {
         uint8_t pwm_val = ((hargb->rgb_buf[base_idx + byte_idx] << bit) & 0x80)
                               ? hargb->pwm_hi
                               : hargb->pwm_lo;
         ARGB_SetPWMValue(hargb, byte_idx * 8 + bit, pwm_val);
       }
     }
     hargb->buf_counter++;
   } else if (hargb->buf_counter < hargb->num_pixels + 2) {
     // RET复位信号传输 - 清空前半部分
     uint16_t half_buf_len = hargb->pwm_buf_len / 2;
     uint16_t element_size = ARGB_DMA_ELEM_SIZE(hargb->dma_size);
     memset((void *)hargb->pwm_buf, 0, half_buf_len * element_size);
     hargb->buf_counter++;
   }
 }
 
 /**
  * @brief 初始化定时器和预分频器用于LED灯带
  * @param[in] hargb ARGB句柄指针
  * @param[in] htim 定时器句柄指针
  * @param[in] hdma DMA句柄指针
  * @param[in] tim_channel 定时器通道 (TIM_CHANNEL_1/2/3/4)
  * @param[in] num_pixels 灯带中的像素数量
  * @param[in] led_type LED灯带类型
  * @param[in] dma_size DMA传输大小
  * @param[in] use_gamma 启用伽马校正 (0或1)
  * @param[in] rgb_buf RGB缓冲区指针（静态模式）/ malloc函数（动态模式）
  * @param[in] pwm_buf PWM缓冲区指针（静态模式）/ free函数（动态模式）
  * @return ARGB_STATE 状态
  */
 ARGB_STATE ARGB_Init(ARGB_HandleTypeDef *hargb, TIM_HandleTypeDef *htim,
                      DMA_HandleTypeDef *hdma, uint32_t tim_channel,
                      uint16_t num_pixels, ARGB_LED_TYPE led_type,
                      ARGB_DMA_SIZE dma_size, uint8_t use_gamma,
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
                      ARGB_Malloc malloc, ARGB_Free free
 #else
                      uint8_t *rgb_buf, void *pwm_buf
 #endif
 ) {
 
   if (hargb == NULL || htim == NULL || hdma == NULL || num_pixels == 0) {
     return ARGB_PARAM_ERR;
   }
 
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
   if (malloc == NULL || free == NULL) {
     return ARGB_PARAM_ERR;
   }
 #else
   if (rgb_buf == NULL || pwm_buf == NULL) {
     return ARGB_PARAM_ERR;
   }
 #endif
 
   // 初始化句柄
   hargb->htim = htim;
   hargb->hdma = hdma;
   hargb->tim_channel = tim_channel;
   hargb->num_pixels = num_pixels;
   hargb->led_type = led_type;
   hargb->dma_size = dma_size;
   hargb->use_gamma = use_gamma;
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
   hargb->malloc = malloc;
   hargb->free = free;
 #endif
   hargb->brightness = 255;
   hargb->state = ARGB_READY;
   hargb->buf_counter = 0;
   hargb->next = NULL;
 
   // 缓存定时器/DMA参数（只计算一次）
   hargb->dma_id = ARGB_GetTimDmaId(tim_channel);
   hargb->dma_cc = ARGB_GetTimDmaCc(tim_channel);
   hargb->ccr_addr = ARGB_GetCcrAddress(htim->Instance, tim_channel);
 
   // 根据LED类型计算缓冲区大小
   hargb->bytes_per_pixel = ARGB_BYTES_PER_PIXEL(led_type);
   hargb->pwm_buf_len =
       hargb->bytes_per_pixel * 8 * 2; // 字节数 * 8位 * 2个LED
   hargb->rgb_buf_size = num_pixels * hargb->bytes_per_pixel;
 
   // 分配RGB缓冲区
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
   hargb->rgb_buf = (volatile uint8_t *)hargb->malloc(hargb->rgb_buf_size);
   if (hargb->rgb_buf == NULL) {
     return ARGB_MEM_ERR;
   }
 #else
   hargb->rgb_buf = rgb_buf;
 #endif
   memset((void *)hargb->rgb_buf, 0, hargb->rgb_buf_size);
 
   // 根据DMA大小分配PWM缓冲区
   uint16_t pwm_buf_bytes = hargb->pwm_buf_len * ARGB_DMA_ELEM_SIZE(dma_size);
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
   hargb->pwm_buf = hargb->malloc(pwm_buf_bytes);
   if (hargb->pwm_buf == NULL) {
     hargb->free((void *)hargb->rgb_buf);
     hargb->rgb_buf = NULL;
     return ARGB_MEM_ERR;
   }
 #else
   hargb->pwm_buf = pwm_buf;
 #endif
   memset((void *)hargb->pwm_buf, 0, pwm_buf_bytes);
 
   /* 自动计算定时器参数 */
   uint32_t APBfq;
 
   // 根据定时器实例确定APB总线
   if (htim->Instance == TIM1
 #ifdef TIM8
       || htim->Instance == TIM8
 #endif
 #ifdef TIM9
       || htim->Instance == TIM9
 #endif
 #ifdef TIM10
       || htim->Instance == TIM10
 #endif
 #ifdef TIM11
       || htim->Instance == TIM11
 #endif
   ) {
     APBfq = HAL_RCC_GetPCLK2Freq();
     APBfq *= (RCC->CFGR & RCC_CFGR_PPRE2) == 0 ? 1 : 2;
   } else {
     APBfq = HAL_RCC_GetPCLK1Freq();
     APBfq *= (RCC->CFGR & RCC_CFGR_PPRE1) == 0 ? 1 : 2;
   }
 
   // 根据LED类型设置频率
   if (led_type == ARGB_WS2811S) {
     APBfq /= (uint32_t)(400 * 1000); // 400 KHz - 2.5us
   } else {
     APBfq /= (uint32_t)(800 * 1000); // 800 KHz - 1.25us
   }
 
   htim->Instance->PSC = 0;
   htim->Instance->ARR = (uint16_t)(APBfq - 1);
   htim->Instance->EGR = 1;
 
   // 根据LED类型设置PWM时序值
   switch (led_type) {
   case ARGB_WS2811F:
   case ARGB_WS2811S:
     hargb->pwm_hi = (uint8_t)(APBfq * 0.48) - 1; // 48% - 0.60us
     hargb->pwm_lo = (uint8_t)(APBfq * 0.20) - 1; // 20% - 0.25us
     break;
   case ARGB_WS2812:
     hargb->pwm_hi = (uint8_t)(APBfq * 0.56) - 1; // 56% - 0.70us
     hargb->pwm_lo = (uint8_t)(APBfq * 0.28) - 1; // 28% - 0.35us
     break;
   case ARGB_SK6812:
     hargb->pwm_hi = (uint8_t)(APBfq * 0.48) - 1; // 48% - 0.60us
     hargb->pwm_lo = (uint8_t)(APBfq * 0.24) - 1; // 24% - 0.30us
     break;
   }
 
   hargb->state = ARGB_READY;
   TIM_CCxChannelCmd(htim->Instance, tim_channel, TIM_CCx_ENABLE);
 
   // 注册此实例用于DMA回调
   ARGB_RegisterInstance(hargb);
 
   HAL_Delay(1);
   return ARGB_OK;
 }
 
 /**
  * @brief 反初始化LED灯带
  * @param[in] hargb ARGB句柄指针
  */
 void ARGB_DeInit(ARGB_HandleTypeDef *hargb) {
   if (hargb == NULL)
     return;
 
   // 如果正在运行则停止DMA
   if (hargb->state == ARGB_BUSY) {
     __HAL_TIM_DISABLE_DMA(hargb->htim, hargb->dma_cc);
     HAL_DMA_Abort(hargb->htim->hdma[hargb->dma_id]);
     __HAL_TIM_DISABLE(hargb->htim);
   }
 
   // 释放缓冲区
   if (hargb->rgb_buf != NULL) {
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
     hargb->free((void *)hargb->rgb_buf);
 #endif
     hargb->rgb_buf = NULL;
   }
   if (hargb->pwm_buf != NULL) {
 #ifdef ARGB_USE_DYNAMIC_BUFFERS
     hargb->free((void *)hargb->pwm_buf);
 #endif
     hargb->pwm_buf = NULL;
   }
 
   // 注销实例
   ARGB_UnregisterInstance(hargb);
 
   hargb->state = ARGB_READY;
 }
 
 /**
  * @brief 清空所有LED（设置为黑色0,0,0）
  * @param[in] hargb ARGB句柄指针
  */
 void ARGB_Clear(ARGB_HandleTypeDef *hargb) {
   ARGB_FillRGB(hargb, (ARGB_RGB){0, 0, 0});
   if (hargb->led_type == ARGB_SK6812) {
     ARGB_FillWhite(hargb, 0);
   }
 }
 
 /**
  * @brief 设置全局LED亮度
  * @param[in] hargb ARGB句柄指针
  * @param[in] br 亮度值 [0..255]
  */
 void ARGB_SetBrightness(ARGB_HandleTypeDef *hargb, uint8_t br) {
   hargb->brightness = br;
 }
 
 /**
  * @brief 按索引设置LED的RGB颜色
  * @param[in] hargb ARGB句柄指针
  * @param[in] i LED位置索引
  * @param[in] color RGB颜色结构体
  */
 void ARGB_SetRGB(ARGB_HandleTypeDef *hargb, uint16_t i, ARGB_RGB color) {
   // 溢出保护
   if (i >= hargb->num_pixels) {
     uint16_t _i = i / hargb->num_pixels;
     i -= _i * hargb->num_pixels;
   }
 
   // 应用亮度
   color.r /= 256 / ((uint16_t)hargb->brightness + 1);
   color.g /= 256 / ((uint16_t)hargb->brightness + 1);
   color.b /= 256 / ((uint16_t)hargb->brightness + 1);
 
   // 如果启用则应用伽马校正
   if (hargb->use_gamma) {
     color.g = scale8(color.g, 0xB0);
     color.b = scale8(color.b, 0xF0);
   }
 
   // 根据LED类型确定子像素顺序
   uint8_t subp1, subp2, subp3;
   if (hargb->led_type == ARGB_SK6812 || hargb->led_type == ARGB_WS2811F ||
       hargb->led_type == ARGB_WS2811S) {
     // RGB顺序
     subp1 = color.r;
     subp2 = color.g;
     subp3 = color.b;
   } else {
     // GRB顺序 (WS2812)
     subp1 = color.g;
     subp2 = color.r;
     subp3 = color.b;
   }
 
   // 写入缓冲区
   uint16_t base_idx = hargb->bytes_per_pixel * i;
   hargb->rgb_buf[base_idx] = subp1;
   hargb->rgb_buf[base_idx + 1] = subp2;
   hargb->rgb_buf[base_idx + 2] = subp3;
 }
 
 /**
  * @brief 按索引设置LED的HSV颜色
  * @param[in] hargb ARGB句柄指针
  * @param[in] i LED位置索引
  * @param[in] hsv HSV颜色结构体
  */
 void ARGB_SetHSV(ARGB_HandleTypeDef *hargb, uint16_t i, ARGB_HSV hsv) {
   ARGB_RGB color;
   HSV2RGB(hsv, &color);
   ARGB_SetRGB(hargb, i, color);
 }
 
 /**
  * @brief 按索引设置灯带中的白光分量
  * @param[in] hargb ARGB句柄指针
  * @param[in] i LED位置索引
  * @param[in] w 白光值 [0..255]
  * @note 仅SK6812支持白光通道
  */
 void ARGB_SetWhite(ARGB_HandleTypeDef *hargb, uint16_t i, uint8_t w) {
   if (hargb->led_type != ARGB_SK6812) {
     return; // 只有SK6812有白光通道
   }
 
   w /= 256 / ((uint16_t)hargb->brightness + 1);
   hargb->rgb_buf[hargb->bytes_per_pixel * i + 3] = w;
 }
 
 /**
  * @brief 用RGB颜色填充所有LED
  * @param[in] hargb ARGB句柄指针
  * @param[in] color RGB颜色结构体
  */
 void ARGB_FillRGB(ARGB_HandleTypeDef *hargb, ARGB_RGB color) {
   for (uint16_t i = 0; i < hargb->num_pixels; i++) {
     ARGB_SetRGB(hargb, i, color);
   }
 }
 
 /**
  * @brief 用HSV颜色填充所有LED
  * @param[in] hargb ARGB句柄指针
  * @param[in] hsv HSV颜色结构体
  */
 void ARGB_FillHSV(ARGB_HandleTypeDef *hargb, ARGB_HSV hsv) {
   ARGB_RGB color;
   HSV2RGB(hsv, &color);
   ARGB_FillRGB(hargb, color);
 }
 
 /**
  * @brief 设置灯带中所有LED的白光分量
  * @param[in] hargb ARGB句柄指针
  * @param[in] w 白光值 [0..255]
  * @note 仅SK6812支持白光通道
  */
 void ARGB_FillWhite(ARGB_HandleTypeDef *hargb, uint8_t w) {
   if (hargb->led_type != ARGB_SK6812) {
     return;
   }
   for (uint16_t i = 0; i < hargb->num_pixels; i++) {
     ARGB_SetWhite(hargb, i, w);
   }
 }
 
 /**
  * @brief 获取当前DMA状态
  * @param[in] hargb ARGB句柄指针
  * @return ARGB_STATE 状态枚举
  */
 ARGB_STATE ARGB_Ready(ARGB_HandleTypeDef *hargb) { return hargb->state; }
 
 /**
  * @brief 更新灯带显示
  * @param[in] hargb ARGB句柄指针
  * @return ARGB_STATE 状态枚举
  * @note 启动DMA传输将缓冲区数据发送到LED灯带
  */
 ARGB_STATE ARGB_Show(ARGB_HandleTypeDef *hargb) {
   hargb->state = ARGB_BUSY;
 
   if (hargb->buf_counter != 0 || hargb->hdma->State != HAL_DMA_STATE_READY) {
     return ARGB_BUSY;
   }
 
   // 从第一个值填充首次传输
   uint8_t num_init_bytes = ARGB_BYTES_PER_PIXEL(hargb->led_type) * 2;
   for (uint8_t byte_idx = 0; byte_idx < num_init_bytes; byte_idx++) {
     for (uint8_t bit = 0; bit < 8; bit++) {
       uint8_t pwm_val = ((hargb->rgb_buf[byte_idx] << bit) & 0x80)
                             ? hargb->pwm_hi
                             : hargb->pwm_lo;
       ARGB_SetPWMValue(hargb, byte_idx * 8 + bit, pwm_val);
     }
   }
 
   HAL_StatusTypeDef DMA_Send_Stat = HAL_ERROR;
 
   while (DMA_Send_Stat != HAL_OK) {
     if (TIM_CHANNEL_STATE_GET(hargb->htim, hargb->tim_channel) ==
         HAL_TIM_CHANNEL_STATE_BUSY) {
       DMA_Send_Stat = HAL_BUSY;
       continue;
     } else if (TIM_CHANNEL_STATE_GET(hargb->htim, hargb->tim_channel) ==
                HAL_TIM_CHANNEL_STATE_READY) {
       TIM_CHANNEL_STATE_SET(hargb->htim, hargb->tim_channel,
                             HAL_TIM_CHANNEL_STATE_BUSY);
     } else {
       DMA_Send_Stat = HAL_ERROR;
       continue;
     }
 
     hargb->htim->hdma[hargb->dma_id]->XferCpltCallback =
         ARGB_TIM_DMADelayPulseCplt;
     hargb->htim->hdma[hargb->dma_id]->XferHalfCpltCallback =
         ARGB_TIM_DMADelayPulseHalfCplt;
     hargb->htim->hdma[hargb->dma_id]->XferErrorCallback = TIM_DMAError;
 
     if (HAL_DMA_Start_IT(hargb->htim->hdma[hargb->dma_id],
                          (uint32_t)hargb->pwm_buf, (uint32_t)hargb->ccr_addr,
                          hargb->pwm_buf_len) != HAL_OK) {
       DMA_Send_Stat = HAL_ERROR;
       continue;
     }
 
     __HAL_TIM_ENABLE_DMA(hargb->htim, hargb->dma_cc);
 
     if (IS_TIM_BREAK_INSTANCE(hargb->htim->Instance) != RESET)
       __HAL_TIM_MOE_ENABLE(hargb->htim);
 
     if (IS_TIM_SLAVE_INSTANCE(hargb->htim->Instance)) {
       uint32_t tmpsmcr = hargb->htim->Instance->SMCR & TIM_SMCR_SMS;
       if (!IS_TIM_SLAVEMODE_TRIGGER_ENABLED(tmpsmcr))
         __HAL_TIM_ENABLE(hargb->htim);
     } else {
       __HAL_TIM_ENABLE(hargb->htim);
     }
 
     DMA_Send_Stat = HAL_OK;
   }
 
   hargb->buf_counter = 2;
   return ARGB_OK;
 }