stm32单片机控制ws2812 灯

stm32单片机可以通过其内部的GPIO引脚控制ws2812灯。ws2812灯是一种基于Neopixel的RGB LED，它可以通过一根串行数据线进行控制。控制ws2812灯的主要方法包括通过发送特定的序列来控制灯的亮度、颜色和模式。

在stm32单片机上，我们可以选择一个合适的GPIO引脚，并将其设置为输出模式。然后，我们可以使用stm32的硬件定时器和中断来确保产生正确的时间序列来控制ws2812灯。

在控制ws2812灯时，我们需要生成适当的时序信号。通常，ws2812灯使用高电平信号表示逻辑1，低电平信号表示逻辑0。我们可以使用定时器来产生相应的时序信号，并设置适当的时间间隔以确保正确的数据传输。

在代码实现上，我们需要确定每个像素的RGB值，并将其编码为一个24位的数据。然后，我们将数据逐位传输到ws2812灯上，通过控制数据引脚的电平来发送数据。发送数据的速率和时序要满足ws2812灯的要求。

使用stm32单片机控制ws2812灯可以实现各种灯光效果，比如颜色渐变、闪烁、呼吸等。可以根据具体需求编写相应的代码来实现特定的灯光效果。

总结起来，通过使用stm32单片机的GPIO引脚、定时器和中断，我们可以控制ws2812灯的亮度、颜色和模式。这样我们就可以实现各种有趣的灯光效果，并为我们的项目增添视觉效果。

相关问题

来一套基于STM32单片机控制WS2812实现20种灯光效果的代码

以下是基于STM32单片机控制WS2812实现20种灯光效果的代码，其中使用了STM32 HAL库和WS2812库。

#include "main.h"
#include "ws2812.h"

#define LED_COUNT 10 //LED灯的数量
#define DELAY 100 //延时时间

//定义灯光效果模式枚举类型
enum LightMode {
  MODE_RED = 0,
  MODE_GREEN,
  MODE_BLUE,
  MODE_WHITE,
  MODE_YELLOW,
  MODE_PURPLE,
  MODE_CYAN,
  MODE_RAINBOW,
  MODE_BOUNCE,
  MODE_FADE,
  MODE_SPARKLE,
  MODE_SPARKLE_FADE,
  MODE_COLOR_WIPE,
  MODE_THEATER_CHASE,
  MODE_THEATER_CHASE_RAINBOW,
  MODE_FIRE,
  MODE_TWINKLE,
  MODE_TWINKLE_RANDOM,
  MODE_RUNNING_LIGHTS,
  MODE_COLOR_ORGAN,
  MODE_NUM
};

//定义颜色结构体
typedef struct {
  uint8_t red;
  uint8_t green;
  uint8_t blue;
} Color;

//定义灯光效果函数
void red(void);
void green(void);
void blue(void);
void white(void);
void yellow(void);
void purple(void);
void cyan(void);
void rainbow(void);
void bounce(void);
void fade(void);
void sparkle(void);
void sparkleFade(void);
void colorWipe(Color c);
void theaterChase(Color c);
void theaterChaseRainbow(void);
void fire(void);
void twinkle(void);
void twinkleRandom(void);
void runningLights(void);
void colorOrgan(void);

//定义颜色数组
Color colors[MODE_NUM] = {
  {255, 0, 0}, //红色
  {0, 255, 0}, //绿色
  {0, 0, 255}, //蓝色
  {255, 255, 255}, //白色
  {255, 255, 0}, //黄色
  {255, 0, 255}, //紫色
  {0, 255, 255}, //青色
};

//定义全局变量
Color leds[LED_COUNT];
uint8_t mode = MODE_RED;

int main(void) {
  //初始化
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_TIM2_Init();
  MX_USART1_UART_Init();
  
  //初始化WS2812
  ws2812_init(LED_COUNT, TIM2);
  
  //设置颜色
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  
  //循环执行灯光效果
  while (1) {
    switch (mode) {
      case MODE_RED:
        red();
        break;
      case MODE_GREEN:
        green();
        break;
      case MODE_BLUE:
        blue();
        break;
      case MODE_WHITE:
        white();
        break;
      case MODE_YELLOW:
        yellow();
        break;
      case MODE_PURPLE:
        purple();
        break;
      case MODE_CYAN:
        cyan();
        break;
      case MODE_RAINBOW:
        rainbow();
        break;
      case MODE_BOUNCE:
        bounce();
        break;
      case MODE_FADE:
        fade();
        break;
      case MODE_SPARKLE:
        sparkle();
        break;
      case MODE_SPARKLE_FADE:
        sparkleFade();
        break;
      case MODE_COLOR_WIPE:
        colorWipe(colors[mode % MODE_NUM]);
        break;
      case MODE_THEATER_CHASE:
        theaterChase(colors[mode % MODE_NUM]);
        break;
      case MODE_THEATER_CHASE_RAINBOW:
        theaterChaseRainbow();
        break;
      case MODE_FIRE:
        fire();
        break;
      case MODE_TWINKLE:
        twinkle();
        break;
      case MODE_TWINKLE_RANDOM:
        twinkleRandom();
        break;
      case MODE_RUNNING_LIGHTS:
        runningLights();
        break;
      case MODE_COLOR_ORGAN:
        colorOrgan();
        break;
    }
    HAL_Delay(DELAY);
  }
}

//红色灯光效果
void red(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 255;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  ws2812_show(leds, LED_COUNT);
}

//绿色灯光效果
void green(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 255;
    leds[i].blue = 0;
  }
  ws2812_show(leds, LED_COUNT);
}

//蓝色灯光效果
void blue(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
}

//白色灯光效果
void white(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 255;
    leds[i].green = 255;
    leds[i].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
}

//黄色灯光效果
void yellow(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 255;
    leds[i].green = 255;
    leds[i].blue = 0;
  }
  ws2812_show(leds, LED_COUNT);
}

//紫色灯光效果
void purple(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 255;
    leds[i].green = 0;
    leds[i].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
}

//青色灯光效果
void cyan(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 255;
    leds[i].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
}

//彩虹灯光效果
void rainbow(void) {
  for (int i = 0; i < LED_COUNT; i++) {
    int hue = (i * 256 / LED_COUNT) % 256;
    Color c = {0, 0, 0};
    for (int j = 0; j < 3; j++) {
      int x = (hue + j * 256 / 3) % 256;
      if (x < 85) {
        c.red = 255 - x * 3;
        c.green = x * 3;
      } else if (x < 170) {
        x -= 85;
        c.green = 255 - x * 3;
        c.blue = x * 3;
      } else {
        x -= 170;
        c.blue = 255 - x * 3;
        c.red = x * 3;
      }
      leds[i] = c;
    }
  }
  ws2812_show(leds, LED_COUNT);
}

//弹跳灯光效果
void bounce(void) {
  static int position = 0;
  static int direction = 1;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  leds[position].red = 255;
  leds[position].green = 255;
  leds[position].blue = 255;
  ws2812_show(leds, LED_COUNT);
  position += direction;
  if (position == LED_COUNT - 1 || position == 0) {
    direction = -direction;
  }
}

//渐变灯光效果
void fade(void) {
  static int hue = 0;
  Color c = {0, 0, 0};
  for (int i = 0; i < LED_COUNT; i++) {
    int x = (i * 256 / LED_COUNT + hue) % 256;
    if (x < 85) {
      c.red = x * 3;
      c.green = 255 - x * 3;
    } else if (x < 170) {
      x -= 85;
      c.green = x * 3;
      c.blue = 255 - x * 3;
    } else {
      x -= 170;
      c.blue = x * 3;
      c.red = 255 - x * 3;
    }
    leds[i] = c;
  }
  ws2812_show(leds, LED_COUNT);
  hue += 4;
}

//闪烁灯光效果
void sparkle(void) {
  static int index = 0;
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  if (count == 0) {
    index = rand() % LED_COUNT;
    leds[index].red = 255;
    leds[index].green = 255;
    leds[index].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
  }
}

//闪烁渐变灯光效果
void sparkleFade(void) {
  static int index = 0;
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  if (count == 0) {
    index = rand() % LED_COUNT;
  }
  Color c = {0, 0, 0};
  int x = (count * 256 / 10) % 256;
  if (x < 85) {
    c.red = x * 3;
    c.green = 255 - x * 3;
  } else if (x < 170) {
    x -= 85;
    c.green = x * 3;
    c.blue = 255 - x * 3;
  } else {
    x -= 170;
    c.blue = x * 3;
    c.red = 255 - x * 3;
  }
  leds[index] = c;
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
  }
}

//颜色填充灯光效果
void colorWipe(Color c) {
  static int index = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  leds[index] = c;
  ws2812_show(leds, LED_COUNT);
  index++;
  if (index == LED_COUNT) {
    index = 0;
    mode++;
  }
}

//剧院追逐灯光效果
void theaterChase(Color c) {
  static int index = 0;
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  if (count == 0) {
    leds[index] = c;
    leds[(index + 1) % LED_COUNT] = c;
    leds[(index + 2) % LED_COUNT] = c;
  }
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
    index++;
    if (index == LED_COUNT) {
      index = 0;
      mode++;
    }
  }
}

//剧院追逐彩虹灯光效果
void theaterChaseRainbow(void) {
  static int index = 0;
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  if (count == 0) {
    leds[index] = colors[index % MODE_NUM];
    leds[(index + 1) % LED_COUNT] = colors[index % MODE_NUM];
    leds[(index + 2) % LED_COUNT] = colors[index % MODE_NUM];
  }
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
    index++;
    if (index == LED_COUNT) {
      index = 0;
      mode++;
    }
  }
}

//火焰灯光效果
void fire(void) {
  static int heat[LED_COUNT];
  for (int i = 0; i < LED_COUNT; i++) {
    heat[i] = heat[i] - rand() % 20;
    if (heat[i] < 0) {
      heat[i] = 0;
    }
    if (heat[i] > 255) {
      heat[i] = 255;
    }
    Color c = {0, 0, 0};
    int x = heat[i] / 32;
    if (x == 3) {
      c.red = 255;
      c.green = 255;
      c.blue = 255;
    } else if (x == 2) {
      c.red = 255;
      c.green = 128;
      c.blue = 0;
    } else if (x == 1) {
      c.red = 255;
      c.green = 0;
      c.blue = 0;
    }
    leds[i] = c;
  }
  ws2812_show(leds, LED_COUNT);
}

//闪烁星光灯光效果
void twinkle(void) {
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  for (int i = 0; i < 2; i++) {
    int index = rand() % LED_COUNT;
    leds[index].red = 255;
    leds[index].green = 255;
    leds[index].blue = 255;
  }
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
    mode++;
  }
}

//闪烁星光随机颜色灯光效果
void twinkleRandom(void) {
  static int count = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  for (int i = 0; i < 2; i++) {
    int index = rand() % LED_COUNT;
    leds[index].red = rand() % 256;
    leds[index].green = rand() % 256;
    leds[index].blue = rand() % 256;
  }
  ws2812_show(leds, LED_COUNT);
  count++;
  if (count >= 10) {
    count = 0;
    mode++;
  }
}

//流光灯光效果
void runningLights(void) {
  static int position = 0;
  static int hue = 0;
  for (int i = 0; i < LED_COUNT; i++) {
    int x = (i * 256 / LED_COUNT + hue) % 256;
    if (x < 85) {
      leds[i].red = x * 3;
      leds[i].green = 255 - x * 3;
    } else if (x < 170) {
      x -= 85;
      leds[i].green = x * 3;
      leds[i].blue = 255 - x * 3;
    } else {
      x -= 170;
      leds[i].blue = x * 3;
      leds[i].red = 255 - x * 3;
    }
  }
  leds[position].red = 0;
  leds[position].green = 0;
  leds[position].blue = 0;
  position++;
  if (position == LED_COUNT) {
    position = 0;
  }
  ws2812_show(leds, LED_COUNT);
  hue += 4;
}

//音乐灯光效果
void colorOrgan(void) {
  uint16_t samples[32];
  for (int i = 0; i < 32; i++) {
    samples[i] = rand() % 4096;
  }
  for (int i = 0; i < LED_COUNT; i++) {
    leds[i].red = 0;
    leds[i].green = 0;
    leds[i].blue = 0;
  }
  for (int i = 0; i < LED_COUNT; i++) {
    int sum = 0;
    for (int j = 0; j < 4; j++) {
      sum += samples[i * 4 + j];
    }
    int value = sum / 16;
    if (value > 255) {
      value = 255;
    }
    leds[i

来一套基于STM32单片机控制WS2812实现10种灯光效果的代码

好的，以下是基于STM32单片机控制WS2812实现10种灯光效果的代码，仅供参考：

#include "stm32f10x.h"

/*********** WS2812灯带控制IO口配置 ***********/
#define WS2812_GPIO_PORT  GPIOB
#define WS2812_GPIO_PIN   GPIO_Pin_0

/*********** WS2812灯带控制参数配置 ***********/
#define LED_NUM           10           // 灯珠数量
#define COLOR_NUM         3            // 颜色数量
#define LED_TOTAL         (LED_NUM * COLOR_NUM)  // 灯总数
#define RESET_TIME        300          // 重置时间（单位：us）

/*********** 颜色定义 ***********/
#define RED               0xFF0000     // 红色
#define GREEN             0x00FF00     // 绿色
#define BLUE              0x0000FF     // 蓝色
#define YELLOW            0xFFFF00     // 黄色
#define MAGENTA           0xFF00FF     // 品红
#define CYAN              0x00FFFF     // 青色
#define WHITE             0xFFFFFF     // 白色
#define BLACK             0x000000     // 黑色

/*********** 函数声明 ***********/
void delay_us(uint32_t us);
void WS2812_SendData(uint32_t data);
void WS2812_SendColor(uint32_t color);
void WS2812_SendDataArray(uint32_t *array, uint16_t len);
void WS2812_SetAllColor(uint32_t color);
void WS2812_Rainbow();
void WS2812_FadeInOut(uint32_t c, uint8_t wait);
void WS2812_TheaterChaseRainbow(uint8_t wait);
void WS2812_RainbowCycle(uint8_t wait);
void WS2812_TheaterChase(uint32_t c, uint8_t wait);

/*********** 主函数 ***********/
int main(void)
{
    uint32_t color;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);   // 使能GPIOB时钟
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = WS2812_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(WS2812_GPIO_PORT, &GPIO_InitStructure);       // 配置GPIO口

    while (1)
    {
        WS2812_SetAllColor(RED);            // 灯带全亮红色
        delay_us(RESET_TIME);               // 重置时间
        WS2812_SetAllColor(GREEN);          // 灯带全亮绿色
        delay_us(RESET_TIME);               // 重置时间
        WS2812_SetAllColor(BLUE);           // 灯带全亮蓝色
        delay_us(RESET_TIME);               // 重置时间

        color = YELLOW;
        WS2812_FadeInOut(color, 50);        // 呼吸黄色
        WS2812_FadeInOut(color, 50);
        WS2812_FadeInOut(color, 50);
        
        WS2812_Rainbow();                   // 彩虹效果

        color = CYAN;
        WS2812_TheaterChase(color, 50);     // 彩虹跑道
        color = MAGENTA;
        WS2812_TheaterChase(color, 50);
        color = YELLOW;
        WS2812_TheaterChase(color, 50);

        WS2812_RainbowCycle(20);            // 彩虹循环

        WS2812_TheaterChaseRainbow(50);     // 彩虹跑道
    }
}

/*********** 延时函数 ***********/
void delay_us(uint32_t us)
{
    while(us--)
    {
        __NOP();
        __NOP();
    }
}

/*********** 发送数据函数 ***********/
void WS2812_SendData(uint32_t data)
{
    uint8_t i;

    for(i = 0; i < 24; i++)
    {
        if(data & 0x800000)
        {
            WS2812_GPIO_PORT->BSRR = WS2812_GPIO_PIN;
            delay_us(0.7);
            WS2812_GPIO_PORT->BRR = WS2812_GPIO_PIN;
            delay_us(0.6);
        }
        else
        {
            WS2812_GPIO_PORT->BSRR = WS2812_GPIO_PIN;
            delay_us(0.35);
            WS2812_GPIO_PORT->BRR = WS2812_GPIO_PIN;
            delay_us(0.8);
        }
        data <<= 1;
    }
}

/*********** 发送颜色函数 ***********/
void WS2812_SendColor(uint32_t color)
{
    uint8_t i;
    for(i = 0; i < 8; i++)
    {
        if(color & 0x80)
        {
            WS2812_GPIO_PORT->BSRR = WS2812_GPIO_PIN;
            delay_us(0.7);
            WS2812_GPIO_PORT->BRR = WS2812_GPIO_PIN;
            delay_us(0.6);
        }
        else
        {
            WS2812_GPIO_PORT->BSRR = WS2812_GPIO_PIN;
            delay_us(0.35);
            WS2812_GPIO_PORT->BRR = WS2812_GPIO_PIN;
            delay_us(0.8);
        }
        color <<= 1;
    }
}

/*********** 发送数据数组函数 ***********/
void WS2812_SendDataArray(uint32_t *array, uint16_t len)
{
    uint16_t i;
    for(i = 0; i < len; i++)
    {
        WS2812_SendColor(array[i]);
    }
}

/*********** 设置所有灯珠颜色函数 ***********/
void WS2812_SetAllColor(uint32_t color)
{
    uint32_t array[LED_TOTAL];
    uint16_t i;
    for(i = 0; i < LED_NUM; i++)
    {
        array[i * COLOR_NUM] = color;
        array[i * COLOR_NUM + 1] = color;
        array[i * COLOR_NUM + 2] = color;
    }
    WS2812_SendDataArray(array, LED_TOTAL);
}

/*********** 彩虹效果函数 ***********/
void WS2812_Rainbow()
{
    uint32_t array[LED_TOTAL];
    uint16_t i, j;
    uint8_t r, g, b;

    for(j = 0; j < 256; j++)         // hue
    {
        for(i = 0; i < LED_NUM; i++)
        {
            HsvToRgb(j, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(j + 128, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM + 1] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(j + 64, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM + 2] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;
        }
        WS2812_SendDataArray(array, LED_TOTAL);
        delay_us(20000);
    }
}

/*********** 呼吸效果函数 ***********/
void WS2812_FadeInOut(uint32_t c, uint8_t wait)
{
    uint8_t r, g, b;
    uint16_t i, j;

    for(j = 0; j < 256; j++)
    {
        r = (c & 0xFF0000) >> 16;
        g = (c & 0x00FF00) >> 8;
        b = (c & 0x0000FF);

        for(i = 0; i < LED_NUM; i++)
        {
            WS2812_SendColor(((uint32_t)r * j / 255) << 16 | ((uint32_t)g * j / 255) << 8 | ((uint32_t)b * j / 255));
        }
        delay_us(wait * 1000 / 256);
    }

    for(j = 255; j > 0; j--)
    {
        r = (c & 0xFF0000) >> 16;
        g = (c & 0x00FF00) >> 8;
        b = (c & 0x0000FF);

        for(i = 0; i < LED_NUM; i++)
        {
            WS2812_SendColor(((uint32_t)r * j / 255) << 16 | ((uint32_t)g * j / 255) << 8 | ((uint32_t)b * j / 255));
        }
        delay_us(wait * 1000 / 256);
    }
}

/*********** 彩虹跑道函数 ***********/
void WS2812_TheaterChaseRainbow(uint8_t wait)
{
    uint32_t array[LED_TOTAL];
    uint16_t i, j;
    uint8_t r, g, b;

    for(j = 0; j < 256; j++)         // hue
    {
        for(i = 0; i < LED_NUM; i += 3)
        {
            HsvToRgb(j, 255, 255, &r, &g, &b);
            array[i] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(j + 128, 255, 255, &r, &g, &b);
            array[i + 1] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(j + 64, 255, 255, &r, &g, &b);
            array[i + 2] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;
        }
        WS2812_SendDataArray(array, LED_TOTAL);
        delay_us(wait * 1000);
    }
}

/*********** 彩虹循环函数 ***********/
void WS2812_RainbowCycle(uint8_t wait)
{
    uint32_t array[LED_TOTAL];
    uint16_t i, j;
    uint8_t r, g, b;

    for(j = 0; j < 256 * 5; j++)         // 5 cycles of all colors on wheel
    {
        for(i = 0; i < LED_NUM; i++)
        {
            HsvToRgb(((i * 256 / LED_NUM) + j) & 255, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(((i * 256 / LED_NUM) + j + 128) & 255, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM + 1] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;

            HsvToRgb(((i * 256 / LED_NUM) + j + 64) & 255, 255, 255, &r, &g, &b);
            array[i * COLOR_NUM + 2] = (uint32_t)g << 16 | (uint32_t)r << 8 | b;
        }
        WS2812_SendDataArray(array, LED_TOTAL);
        delay_us(wait * 1000);
    }
}

/*********** 彩虹跑道函数 ***********/
void WS2812_TheaterChase(uint32_t c, uint8_t wait)
{
    uint32_t array[LED_TOTAL];
    uint16_t i, j;

    for(j = 0; j < 10; j++)         // do 10 cycles of chasing
    {
        for(i = 0; i < LED_NUM; i += 3)
        {
            array[i * COLOR_NUM] = c;
            array[i * COLOR_NUM + 1] = c;
            array[i * COLOR_NUM + 2] = c;
        }
        WS2812_SendDataArray(array, LED_TOTAL);
        delay_us(wait * 1000);

        for(i = 0; i < LED_NUM; i += 3)
        {
            array[i * COLOR_NUM] = 0;
            array[i * COLOR_NUM + 1] = 0;
            array[i * COLOR_NUM + 2] = 0;
        }
        WS2812_SendDataArray(array, LED_TOTAL);
    }
}

/*********** HSV转RGB函数 ***********/
void HsvToRgb(uint16_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *g, uint8_t *b)
{
    uint8_t region, remainder, p, q, t;

    if(s == 0)
    {
        *r = v;
        *g = v;
        *b = v;
        return;
    }

    region = h / 43;
    remainder = (h - (region * 43)) * 6;

    p = (v * (255 - s)) >> 8;
    q = (v * (255 - ((s * remainder) >> 8))) >> 8;
    t = (v * (255 - ((s * (255 - remainder)) >> 8))) >> 8;

    switch(region)
    {
        case 0:
            *r = v;
            *g = t;
            *b = p;
            break;
        case 1:
            *r = q;
            *g = v;
            *b = p;
            break;
        case 2:
            *r = p;
            *g = v;
            *b = t;
            break;
        case 3:
            *r = p;
            *g = q;
            *b = v;
            break;
        case 4:
            *r = t;
            *g = p;
            *b = v;
            break;
        default:
            *r = v;
            *g = p;
            *b = q;
            break;
    }
}

由于代码较长，注释也比较详细，这里就不做过多解释了。