零知开源——玩转WS2812B灯条模块

PCB56242069 2025-02-19 213

电子说

1.3w人已加入

描述

WS2812RGB灯带

通过零知标准开发板平台上驱动WS2812RGB灯珠，包括WS2812B的供电电压、接线和代码实现。通过创建延时函数和设置级联数据，实现对RGB灯珠的控制，展示了从关闭到开启不同颜色以及跑马灯、呼吸灯和彩虹灯等效果。

一、工具原料

电脑、Windows系统

零知开发板

Micro-usb线

WS2812RGB灯

二、硬件连接

零知标准开发板	WS2812B
5V	VCC
GND	GND
11	Din

硬件连接示意图

实际连接

三、方法步骤

1、打开零知实验室软件开发工具，然后新建项目，输入代码

2、将库文件解压放到库文件存放的目录下

3、选择端口进行编译，然后上传到开发板中。

引用库文件WS2812B.h

#include < WS2812B.h >  // 引入用于控制WS2812B LED灯带的库
 
#define NUM_LEDS 9  // 定义灯带上的LED数量
 
#define DELAYVAL 500 // 定义延迟时间（单位：毫秒），用于在不同效果之间的暂停时间
 
/*
 * 注意：该库使用SPI1进行数据传输
 * 将WS2812B的数据信号输入引脚连接到开发板的MOSI引脚。
 */
WS2812B strip = WS2812B(NUM_LEDS);  // 创建一个WS2812B对象，用于控制灯带

设置SPI、点亮不同效果的RGB灯

 // 请注意。库中并不真正支持Gamma，它只是在本例中使用的一些函数需要Gamma时才包含
uint8_t LEDGamma[] = {
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };

void setup() 
{
  strip.begin();// 设置SPI
  strip.show();// 清除strip，因为默认情况下条带数据设置为所有LED关闭。
 // strip.setBrightness(8);
}

void loop() {
    // 实现不同的灯光效果
    colorWipe(strip.Color(0, 255, 0), 20);  // 使用绿色逐个点亮灯带
    colorWipe(strip.Color(255, 0, 0), 20); // 使用红色逐个点亮灯带
    colorWipe(strip.Color(0, 0, 255), 20); // 使用蓝色逐个点亮灯带
    rainbow(10);                          // 显示彩虹渐变效果
    rainbowCycle(10);  // 显示循环的彩虹效果

    theaterChase(strip.Color(255, 0, 0), 20);  
    theaterChase(strip.Color(0, 255, 0), 20);
    theaterChase(strip.Color(0, 0, 255), 20);  
    theaterChaseRainbow(10);                

    whiteOverRainbow(20, 75, 5);  // 白光覆盖在彩虹效果上
    fullWhite();                  // 将灯带上的所有LED点亮为白光
    delay(250);                   // 暂停250毫秒
    rainbowFade2White(3, 3, 1);   // 彩虹效果逐渐过渡到白光
    theaterChaseWhiteAndOff(DELAYVAL); // 实现白光追逐与关闭的效果
    delay(250);

    flowingLight(100); // 实现流动光效果，速度为100ms

    breathLight(255, 50); // PWM呼吸灯效果

}

将呼吸灯、彩虹灯和流水灯等功能的库函数封装

void breathLight(uint8_t maxBrightness, uint8_t speed) {
    // 实现PWM呼吸灯效果
    for (uint8_t brightness = 0; brightness <= maxBrightness; brightness++) {
        for (uint16_t i = 0; i < strip.numPixels(); i++) {
            // 设置每个LED的颜色，使用伽马校正后的亮度值
            strip.setPixelColor(i, strip.Color(LEDGamma[brightness], LEDGamma[brightness], LEDGamma[brightness]));
        }
        strip.show();
        delay(speed); // 延迟以实现亮度变化
    }
    for (uint8_t brightness = maxBrightness; brightness > 0; brightness--) {
        for (uint16_t i = 0; i < strip.numPixels(); i++) {
            strip.setPixelColor(i, strip.Color(LEDGamma[brightness], LEDGamma[brightness], LEDGamma[brightness]));
        }
        strip.show();
        delay(speed);
    }
}

void flowingLight(uint8_t speed) {
  // 实现流动光效果
  uint16_t index = 0;        // 记录当前流动的索引
  uint8_t currentColor = 0;  // 记录当前的颜色（红、绿、蓝）

  while (true) {
    for (uint16_t i = 0; i < NUM_LEDS; i++) {
      // 根据当前索引计算目标索引
      uint16_t targetIndex = (i + index) % NUM_LEDS;
     
      switch (currentColor) {
        case 0:
          strip.setPixelColor(targetIndex, strip.Color(255, 0, 0)); //  设置为红色
          break;
        case 1:
          strip.setPixelColor(targetIndex, strip.Color(0, 255, 0)); //  设置为绿色
          break;
        case 2:
          strip.setPixelColor(targetIndex, strip.Color(0, 0, 255)); //  设置为蓝色
          break;
      }

      strip.setPixelColor(i, strip.Color(0, 0, 0)); // 将之前的LED关闭
     
      strip.show();
      delay(speed);// 设置流动光的速度
    }
   
   // 切换到下一个颜色
    currentColor = (currentColor + 1) % 3;
   
     // 增加索引，实现流动效果
    index++;
    if (index >= NUM_LEDS) {
      index = 0; //重置索引
    }
  }
}

void theaterChaseWhiteAndOff(uint8_t wait) {
  for (int j = 0; j < 10; j++) {  // 10 cycles of chasing
    for (int q = 0; q < 3; q++) {
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, (j % 2 == 0 ? strip.Color(128, 0, 128) : 0));
      }
      strip.show();
      delay(wait);
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0);  // Turn every third pixel off
      }
    }
  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) 
{
  for(uint16_t i=0; i< strip.numPixels(); i++) 
  {
      strip.setPixelColor(i, c);
      strip.show();
      delay(wait);
  }
}

// rainbow 函数: 实现彩虹效果的灯带动画
// 参数:
//   wait: 每次更新彩虹效果的等待时间（毫秒）
void rainbow(uint8_t wait) {
    uint16_t i, j;

    // 外层循环控制彩虹的移动效果
    for(j = 0; j < 256; j++) {
        // 内层循环逐个像素更新颜色
        for(i = 0; i < strip.numPixels(); i++) {
            // 通过 Wheel 函数生成彩虹颜色
            strip.setPixelColor(i, Wheel((i + j) & 255));
        }
        strip.show(); // 更新灯带显示
        delay(wait);  // 等待一段时间
    }
}

// rainbowCycle 函数: 实现彩虹效果循环播放，每个像素显示的颜色均匀分布
// 参数:
//   wait: 每次更新动画的等待时间（毫秒）
void rainbowCycle(uint8_t wait) {
    uint16_t i, j;

    // 外层循环控制彩虹的循环次数，5次完整循环
    for(j = 0; j < 256 * 5; j++) {
        // 内层循环更新每个像素的颜色
        for(i = 0; i < strip.numPixels(); i++) {
            // 使用 Wheel 函数计算彩虹颜色，保证均匀分布
            strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
        }
        strip.show(); // 更新灯带显示
        delay(wait);  // 等待一段时间
    }
}

// Wheel 函数: 根据输入值生成渐变的 RGB 颜色
// 参数:
//   WheelPos: 输入值（范围 0-255），表示颜色的渐变位置
// 返回值:
//   对应的 RGB 颜色值（以 32 位整数形式表示）
uint32_t Wheel(byte WheelPos) {
    if(WheelPos < 85) {
        // 红色逐渐变为绿色
        return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
    } else if(WheelPos < 170) {
        // 绿色逐渐变为蓝色
        WheelPos -= 85;
        return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    } else {
        // 蓝色逐渐变为红色
        WheelPos -= 170;
        return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
    }
}

// theaterChase 函数: 实现戏剧风格的爬行灯效果，每三个像素作为一个循环
// 参数:
//   c: 颜色值（RGB 格式）
//   wait: 每次更新动画的等待时间（毫秒）
void theaterChase(uint32_t c, uint8_t wait) {
    // 外层循环控制效果的整体循环次数
    for(int j = 0; j < 10; j++) { 
        // 中间循环负责调整动画的偏移量
        for(int q = 0; q < 3; q++) {
            // 内层循环设置每第三个像素的颜色
            for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
                strip.setPixelColor(i + q, c); // 设置当前像素为指定颜色
            }
            strip.show(); // 更新灯带显示
            delay(wait);  // 等待一段时间

            // 关闭每第三个像素
            for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
                strip.setPixelColor(i + q, 0);
            }
        }
    }
}

// theaterChaseRainbow 函数: 实现戏剧风格的彩虹爬行灯效果
// 参数:
//   wait: 每次更新动画的等待时间（毫秒）
void theaterChaseRainbow(uint8_t wait) {
    // 外层循环控制颜色的变化
    for(int j = 0; j < 256; j++) { 
        // 中间循环控制动画的偏移
        for(int q = 0; q < 3; q++) {
            // 内层循环设置每第三个像素的彩虹颜色
            for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
                strip.setPixelColor(i + q, Wheel((i + j) % 255));
            }
            strip.show(); // 更新灯带显示
            delay(wait);  // 等待一段时间

            // 关闭每第三个像素
            for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
                strip.setPixelColor(i + q, 0);
            }
        }
    }
}

void pulseWhite(uint8_t wait) {
  // 功能：实现白色脉冲效果
  // 参数：wait - 每次更新动画的等待时间（毫秒）

  for(int j = 0; j < 256 ; j++){ // 亮度从0渐变至255
    for(uint16_t i=0; i< strip.numPixels(); i++) {
      // 设置每个LED的颜色，亮度根据j的值变化
      strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
    }  
    delay(wait);
    strip.show();
  }

  for(int j = 255; j >= 0 ; j--){ // 亮度从255渐变回0
    for(uint16_t i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
    }
    delay(wait);
    strip.show();
  }
}

void rainbowFade2White(uint8_t wait, int rainbowLoops, int whiteLoops) {
  // 功能：先显示彩虹效果，然后逐渐过渡到白色
  // 参数：
  //   wait - 每次更新动画的等待时间（毫秒）
  //   rainbowLoops - 彩虹循环次数
  //   whiteLoops - 白色循环次数

  float fadeMax = 100.0;
  int fadeVal = 0;
  uint32_t wheelVal;
  int redVal, greenVal, blueVal;

  for(int k = 0 ; k < rainbowLoops ; k ++){ // 循环执行彩虹效果
    for(int j=0; j< 256; j++) {
      for(int i=0; i< strip.numPixels(); i++) {
        wheelVal = Wheel(((i * 256 / strip.numPixels()) + j) & 255);
        // 逐步调整RGB值以实现渐变效果
        redVal = red(wheelVal) * float(fadeVal/fadeMax);
        greenVal = green(wheelVal) * float(fadeVal/fadeMax);
        blueVal = blue(wheelVal) * float(fadeVal/fadeMax);
        strip.setPixelColor( i, strip.Color( redVal, greenVal, blueVal ) );
      }
      if(k == 0 && fadeVal < fadeMax-1) {
        // 第一次循环，亮度逐渐增加
        fadeVal++;
      } else if(k == rainbowLoops - 1 && j > 255 - fadeMax){
        // 最后一次循环，亮度逐渐减少
        fadeVal--;
      }
      strip.show();
      delay(wait);
    }
  }
 
  delay(500);

  for(int k = 0 ; k < whiteLoops ; k ++){ // 循环执行白色渐变效果
    for(int j = 0; j < 256 ; j++){
      for(uint16_t i=0; i < strip.numPixels(); i++) {
        strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
      }
      strip.show();
      delay(wait);
    }
    delay(2000);
    for(int j = 255; j >= 0 ; j--){
      for(uint16_t i=0; i < strip.numPixels(); i++) {
        strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
      }
      strip.show();
      delay(wait);
    }
  }
}


void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) {
  // 功能：在彩虹背景上叠加白色的流动效果
  // 参数：
  //   wait - 动画更新间隔
  //   whiteSpeed - 白色流动速度
  //   whiteLength - 白色光束长度
  if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;

  int head = whiteLength - 1;
  int tail = 0;

  int loops = 3;
  int loopNum = 0;

  static unsigned long lastTime = 0;


  while(true){
    for(int j=0; j< 256; j++) {
      for(uint16_t i=0; i< strip.numPixels(); i++) {
        if((i >= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){
          // 如果在白色光束范围内，设置为白色
          strip.setPixelColor(i, strip.Color(255,255,255 ) );
        }
        else{
           // 否则，根据j值设置彩虹颜色
          strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
        }
        
      }

      if(millis() - lastTime > whiteSpeed) {
        head++;
        tail++;
        if(head == strip.numPixels()){
          loopNum++;
        }
        lastTime = millis();
      }

      if(loopNum == loops) return;
    
      head%=strip.numPixels();
      tail%=strip.numPixels();
        strip.show();
        delay(wait);
    }
  } 
}

void fullWhite() {
  // 功能：点亮所有LED为白色
  for(uint16_t i=0; i< strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 255, 255 ) );
  }
  strip.show();
}

// red 函数: 提取颜色值中的红色分量
// 参数:
//   c: RGB 颜色值（32 位整数）
// 返回值:
//   红色分量（0-255）
uint8_t red(uint32_t c) {
    return (c > > 16);
}

// green 函数: 提取颜色值中的绿色分量
// 参数:
//   c: RGB 颜色值（32 位整数）
// 返回值:
//   绿色分量（0-255）
uint8_t green(uint32_t c) {
    return (c > > 8);
}

// blue 函数: 提取颜色值中的蓝色分量
// 参数:
//   c: RGB 颜色值（32 位整数）
// 返回值:
//   蓝色分量（0-255）
uint8_t blue(uint32_t c) {
    return (c);
}

四、成果展示

将上述代码验证后上传到零知板，就可以看到测试结果，实现流水灯、彩虹灯和呼吸灯等效果

https://live.csdn.net/v/435823?spm=1001.2014.3001.5501

审核编辑黄宇

打开APP阅读更多精彩内容