精华内容
下载资源
问答
  • WS2812 RGB灯带控制代码,可移植性强
  • Arduino控制WS2812灯带(灯环)

    千次阅读 多人点赞 2020-12-24 20:17:56
    Arduino控制WS2812灯带(灯环) 1) WS2812WS2812灯带 WS2812灯环 WS2812是一个集控制电路与发光电路于一体的智能外空LED光源。其外形与一个5050LED灯珠相同,每个元件即为一个像素点。像素点内部包含了智能...

    设计者:STCode(公众号同名)

    Arduino控制WS2812灯带(灯环)

    在这里插入图片描述

    1) WS2812灯

    在这里插入图片描述

    WS2812灯带

    在这里插入图片描述WS2812灯环

    WS2812是一个集控制电路与发光电路于一体的智能外空LED光源。其外形与一个5050LED灯珠相同,每个元件即为一个像素点。像素点内部包含了智能数字接口数据锁存信号整形放大电路,还包括有高精度的内部振荡器和可编程电流控制部分,有效保证了像素点的颜色高度一致。
    1) FastLED库
    FastLED 是一款功能强大、简单易用的控制WS2812等LED光带的Arduino第三方库。 目前FastLED是公认的Arduino开发者应用最为广泛的LED控制库之一。

    2) 电路搭建

    在这里插入图片描述在这里插入图片描述

    说明:
    当你要用arduino直接驱动一大堆led或别的外部器件时,各引脚电流很容易超标。arduino官方指标只是语焉不详地提到每个引脚电流不超过40mA,Vcc和地总电流不超过200mA。
    LED控制电路直流电源要求:
    WS2812LED灯带上每一个灯珠都需要60mA左右的电流强度,为了确保灯带正常工作,需要配备的直流电源要能提供充足的电流强度为灯带供电。
    例:一条带有30个灯珠的灯带,如果要为它配备电源则需要直流电源的输出电流强度为1.5安培 ~ 2安培左右。(即如果需要驱动数量较多的灯,可以外接电源,注意要将WS2812灯带与Arduino共地)。

    3) 简单示例

    1-闪烁LED灯带灯珠

    #include "FastLED.h"            // 此示例程序需要使用FastLED库
    #define NUM_LEDS 12             // LED灯珠数量
    #define DATA_PIN 5              // Arduino输出控制信号引脚
    #define LED_TYPE WS2812         // LED灯带型号
    #define COLOR_ORDER GRB         // RGB灯珠中红色、绿色、蓝色LED的排列顺序
     
    uint8_t max_bright = 128;       // LED亮度控制变量,可使用数值为 0 ~ 255, 数值越大则光带亮度越高
    CRGB leds[NUM_LEDS];            // 建立灯带leds
    void setup() { 
      LEDS.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);  // 初始化灯带
      FastLED.setBrightness(max_bright);                            // 设置灯带亮度
    }
     
    void loop() { 
      leds[0] = CRGB::Red;          // 设置灯带中第一个灯珠颜色为红色,leds[0]为第一个灯珠,leds[1]为第二个灯珠
      FastLED.show();               // 更新LED色彩
      delay(500);                   // 等待500毫秒
    leds[0] = CRGB::Black;        // 设置灯带中第一个灯珠熄灭 
      FastLED.show();               // 更新LED色彩
      delay(500);                   // 等待500毫秒
    }
    

    4) 实验效果

    在这里插入图片描述

    5) FastLED其他函数介绍

    ① fillSolid()------将LED灯带设置为同一种颜色

    fill_solid(leds, 12, CRGB::Blue)
    

    上述代码将灯带前12个灯珠颜色设置成蓝色。

    fill_solid(leds+3, 5, CRGB::Green);
    

    上述代码将leds灯带从头数第4个灯珠开始算起的连续5个灯珠设置为绿色。

    ② CRGB()------设置具体某颗灯珠的颜色

    leds[i] = CRGB (252,228,163);
    

    上述代码将第i+1个灯珠的颜色设置成R:251;G:228;B:163的颜色,例如i为4,则设置的为第5颗灯珠的颜色。

    ③ fillRainbow()------将LED灯带设置为渐变彩虹色

    fill_rainbow(leds, 12, beginHue, deltaHue);
    

    上述代码将leds灯带的前12颗led灯设置为彩虹渐变颜色,beginHue为起始色调,deltaHue为相邻LED灯珠的色调差。

    fill_rainbow(leds+3, 12, 0, 1);
    

    上述代码将第4颗开始的连续12颗灯珠设置成渐变彩虹色,,起始色调数为0,相邻两灯珠之间的色调差值为1.

    ④ Fill_gradient_RGB()设置渐变色

    fill_gradient_RGB(leds, 0,CRGB::Blue, 11, CRGB::Green);
    

    上述代码将灯带从头数的12颗灯珠设置为渐变色,灯带其实颜色为蓝色,终端颜色为绿色,中间为两种颜色的渐变色。

    fill_gradient(leds, 0, CHSV(255, 0,255) , 11, CHSV(255,255,0), SHORTEST_HUES);
    

    上述代码将从头数的12颗灯珠设置为渐变色,起始颜色为HSV(255,0,255),终端颜色为HSV(255,255,0),过渡方式为短色调过渡。

    fill_gradient(leds, 0, CHSV(255, 0,255) , 11, CHSV(255,255,0), LONGEST_HUES);
    

    上述代码过渡方式为长色调过渡。

    此外FastLED库还给出了许多直接操作灯珠颜色变化的函数,感兴趣可以仔细研读该库。

    更多创意作品请关注公众号:STCode

    展开全文
  • STM32控制WS2812灯带【含完整代码】

    千次阅读 2021-01-12 11:02:51
    目录STM32控制WS2812灯带灯带信息实现代码引脚对应寄存器信息大全注意点参考资料 STM32控制WS2812灯带 用STM32控制WS2812 RGB灯带的代码资料不多。这里的代码是通过示波器一点一点调整得到的。本着开源原则,和大家...


    STM32控制WS2812灯带【含完整代码】

    用STM32控制WS2812 RGB灯带的代码资料不多。这里的代码是通过示波器一点一点调整得到的。本着开源原则,和大家分享学习。


    灯带信息

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    点击查看完整文档


    实现代码

    核心代码如下:

    // 引脚对应的寄存器(更多信息见下文)
    #define A0_HIGH  GPIOA->BSRR = 1           // A low electrical level. (GPIO_PIN_0: 1)
    #define A0_LOW   GPIOA->BSRR = 65536u      // A high electrical level.(GPIO_PIN_0: 1 << 16u)
    #define A1_HIGH  GPIOA->BSRR = 2           // A low electrical level. (GPIO_PIN_1: 2)
    #define A1_LOW   GPIOA->BSRR = 131072u     // A high electrical level.(GPIO_PIN_1: 2 << 16u)
    #define B12_HIGH GPIOB->BSRR = 4096        // A low electrical level. (GPIO_PIN_12: 4096)
    #define B12_LOW  GPIOB->BSRR = 268435456u  // A high electrical level.(GPIO_PIN_12: 4096 << 16u)
    
    #define HIGH     B12_HIGH   // 持续一个很短时间的高电平
    #define LOW      B12_LOW    // 持续一个很短时间的低电平
    
    // 连续多个HIGH/LOW == 一个HIGH/LOW + delay函数 (卡示波器得到的)
    #define SIG1()     HIGH;HIGH;HIGH; HIGH;HIGH;LOW    // 一个 signal 1.
    #define SIG0()     HIGH;HIGH;LOW;	 LOW;LOW;LOW    // 一个 signal 0.
    
    // 示例颜色 (注意这里的颜色顺序是:高位->低位 —— G->R->B)
    #define RED    0x00ff00
    #define GREEN  0xff0000
    #define BLUE   0x0000ff
    
    #define LED_LEN       144  // 灯带长度
    #define BIT_LEN       24   // 每颗灯对应24位 0/1 signal
    
    uint32_t led_buf[LED_LEN] = { 0 };  // 存储每颗灯的颜色值,范围:[0, 0xffffff].
    
    void sync() {
    	uint32_t bit_buf[LED_LEN * BIT_LEN] = { 0 }; // 将要传输的bit数组
    	
    	for (uint32_t i = 0; i < LED_LEN; ++i) {
    		for (uint32_t j = 0; j < BIT_LEN; ++j) {
    			bit_buf[i * BIT_LEN + j] = (led_buf[i] >> (BIT_LEN - 1 - j)) & 1;  // 高位先传
    		}
    	}
    	
    	__disable_irq();  // 关闭中断
    	
    	for (uint32_t i = 0; i < LED_LEN * BIT_LEN; ++i) {
    		if (bit_buf[i]) {
    			SIG1();
    		} else {
    			SIG0();
    		}
    	}
    	
    	__enable_irq();  // 开启中断
    }
    

    引脚对应寄存器信息大全

    #define GPIO_PIN_0                 ((uint16_t)0x0001)  /* Pin 0 selected    */
    #define GPIO_PIN_1                 ((uint16_t)0x0002)  /* Pin 1 selected    */
    #define GPIO_PIN_2                 ((uint16_t)0x0004)  /* Pin 2 selected    */
    #define GPIO_PIN_3                 ((uint16_t)0x0008)  /* Pin 3 selected    */
    #define GPIO_PIN_4                 ((uint16_t)0x0010)  /* Pin 4 selected    */
    #define GPIO_PIN_5                 ((uint16_t)0x0020)  /* Pin 5 selected    */
    #define GPIO_PIN_6                 ((uint16_t)0x0040)  /* Pin 6 selected    */
    #define GPIO_PIN_7                 ((uint16_t)0x0080)  /* Pin 7 selected    */
    #define GPIO_PIN_8                 ((uint16_t)0x0100)  /* Pin 8 selected    */
    #define GPIO_PIN_9                 ((uint16_t)0x0200)  /* Pin 9 selected    */
    #define GPIO_PIN_10                ((uint16_t)0x0400)  /* Pin 10 selected   */
    #define GPIO_PIN_11                ((uint16_t)0x0800)  /* Pin 11 selected   */
    #define GPIO_PIN_12                ((uint16_t)0x1000)  /* Pin 12 selected   */
    #define GPIO_PIN_13                ((uint16_t)0x2000)  /* Pin 13 selected   */
    #define GPIO_PIN_14                ((uint16_t)0x4000)  /* Pin 14 selected   */
    #define GPIO_PIN_15                ((uint16_t)0x8000)  /* Pin 15 selected   */
    #define GPIO_PIN_All               ((uint16_t)0xFFFF)  /* All pins selected */
    
    GPIOx->BSRR = GPIO_Pin_x;  // 高电平
    GPIOx->BSRR = (uint32_t)GPIO_Pin << 16u;  // 低电平
    

    注意点

    1. 如果不在传输数据过程中停止中断,数据传输会因为被打断而出现误差,导致灯带闪烁,颜色变得离谱。
    2. 传输bit时应该高位先传(详见代码sync()函数),颜色顺序为:高位->低位 —— G->R->B

    完整例程代码下载链接

    点击下载

    参考资料

    WS2812手册
    个人经验

    展开全文
  • esp32 控制ws2812灯带

    2021-10-15 15:23:25
    Arduino pin number (most are valid) // Parameter 3 = pixel type flags, add together as needed: // NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs) // NEO_KHZ400 400 KHz (classic 'v1...

    采用的arduino控制,利用别人写好的模块进行控制
    vs code搜索Adafruit_NeoPixel导入项目中
    代码实现

    
    #include <Adafruit_NeoPixel.h>
    #ifdef __AVR__
      #include <avr/power.h>
    #endif
    
    #define PIN 23
    
    // Parameter 1 = number of pixels in strip
    // Parameter 2 = Arduino pin number (most are valid)
    // Parameter 3 = pixel type flags, add together as needed:
    //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
    //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
    //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
    //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
    //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
    Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);
    
    // IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
    // pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
    // and minimize distance between Arduino and first pixel.  Avoid connecting
    // on a live circuit...if you must, connect GND first.
    
    
    
    // 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);
      }
    }
    
    
    // Input a value 0 to 255 to get a color value.
    // The colours are a transition r - g - b - back to r.
    uint32_t Wheel(byte WheelPos) {
      WheelPos = 255 - WheelPos;
      if(WheelPos < 85) {
        return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
      }
      if(WheelPos < 170) {
        WheelPos -= 85;
        return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
      }
      WheelPos -= 170;
      return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
    }
    
    void rainbow(uint8_t wait) {
      uint16_t i, j;
    
      for(j=0; j<256; j++) {
        for(i=0; i<strip.numPixels(); i++) {
          strip.setPixelColor(i, Wheel((i+j) & 255));
        }
        strip.show();
        delay(wait);
      }
    }
    
    // Slightly different, this makes the rainbow equally distributed throughout
    void rainbowCycle(uint8_t wait) {
      uint16_t i, j;
    
      for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
        for(i=0; i< strip.numPixels(); i++) {
          strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
        }
        strip.show();
        delay(wait);
      }
    }
    
    //Theatre-style crawling lights.
    void theaterChase(uint32_t c, uint8_t wait) {
      for (int j=0; j<10; j++) {  //do 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, c);    //turn every third pixel on
          }
          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
          }
        }
      }
    }
    
    //Theatre-style crawling lights with rainbow effect
    void theaterChaseRainbow(uint8_t wait) {
      for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
        for (int q=0; q < 3; q++) {
          for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
            strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
          }
          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
          }
        }
      }
    }
    
    void clear(){
      for(uint16_t i=0; i<strip.numPixels(); i++) {
        strip.setPixelColor(i, 0); 
        delay(10);
      }
    }
    
    //流星
    void meteor(uint8_t red, uint8_t green, uint8_t blue, uint8_t wait) {
      const uint8_t num = 8;
      uint8_t max_color = red;
      if(green > max_color)
        max_color = green;
      if(blue > max_color)
        max_color = blue;
      uint8_t instance = (max_color-200)/num;
      for(uint16_t i=0; i<strip.numPixels() + num; i++) {
        for(uint8_t j = 0; j < num; j ++){
          if(i - j >= 0 && i - j < strip.numPixels()){
            int red_after = red - (instance * j);
            int green_after = green - (instance * j);
            int blue_after = blue - (instance * j);
            
            if(j>=1){
              red_after -= 200;
              green_after -= 200;
              blue_after -= 200;
            }
            strip.setPixelColor(i - j, strip.Color(red_after >= 0 ? red_after : 0, green_after >= 0 ? green_after : 0, blue_after >= 0 ? blue_after : 0));
          }
        }
        if(i - num >= 0 && i-num < strip.numPixels())
          strip.setPixelColor(i-num, 0); 
    
    
        // if(i >= 0 && i < strip.numPixels())
        //   strip.setPixelColor(i, strip.Color(red, green, blue));
        // if(i - 1 >= 0 && i-1 < strip.numPixels())
        //   strip.setPixelColor(i-1, strip.Color(red - 50 >= 0 ? red - 50 : 0, green - 50 >= 0 ? green - 50 : 0, blue - 50 >= 0 ? blue - 50 : 0));
        // if(i - 2 >= 0 && i-2 < strip.numPixels())
        //   strip.setPixelColor(i-2, strip.Color(red - 100 >= 0 ? red - 100 : 0, green - 100 >= 0 ? green - 100 : 0, blue - 100 >= 0 ? blue - 100 : 0));
        // if(i - 3 >= 0 && i-3 < strip.numPixels())
        //   strip.setPixelColor(i-3, strip.Color(red - 150 >= 0 ? red - 150 : 0, green - 150 >= 0 ? green - 150 : 0, blue - 150 >= 0 ? blue - 150 : 0));
        // if(i - 4 >= 0 && i-4 < strip.numPixels())
        //   strip.setPixelColor(i-4, 0); 
    
        strip.show();
        delay(wait);
      }
    }
    
    void meteor_overturn(uint8_t red, uint8_t green, uint8_t blue, uint8_t wait) {
    
      const uint8_t num = 8;
      uint8_t max_color = red;
      if(green > max_color)
        max_color = green;
      if(blue > max_color)
        max_color = blue;
      uint8_t instance = (max_color-200)/num;
      for(int i=strip.numPixels() - 1; i>=-num; i--) {
        for(uint8_t j = 0; j < num; j ++){
          if(i + j >= 0 && i + j < strip.numPixels()){
            int red_after = red - instance * j;
            int green_after = green - instance *  j;
            int blue_after = blue - instance *  j;
            if(j>=1){
              red_after -= 200;
              green_after -= 200;
              blue_after -= 200;
            }
            strip.setPixelColor(i + j, strip.Color(red_after >= 0 ? red_after : 0, green_after >= 0 ? green_after : 0, blue_after >= 0 ? blue_after : 0));
          }
        }
        if(i + num >= 0 && i+num < strip.numPixels())
          strip.setPixelColor(i+num, 0); 
        // if(i == 10)
        //   delay(5000);
      // for(int i=strip.numPixels() - 1; i>=-4; i--) {
      //   if(i < strip.numPixels() && i >=0)
      //     strip.setPixelColor(i, strip.Color(red, green, blue)); 
      //   if(i + 1 < strip.numPixels() && i+1 >=0)
      //     strip.setPixelColor(i+1, strip.Color(red - 50 >= 0 ? red - 50 : 0, green - 50 >= 0 ? green - 50 : 0, blue - 50 >= 0 ? blue - 50 : 0));
      //   if(i + 2 < strip.numPixels() && i+2 >=0)
      //     strip.setPixelColor(i+2, strip.Color(red - 100 >= 0 ? red - 100 : 0, green - 100 >= 0 ? green - 100 : 0, blue - 100 >= 0 ? blue - 100 : 0));
      //   if(i + 3 < strip.numPixels() && i+3 >=0)
      //     strip.setPixelColor(i+3, strip.Color(red - 150 >= 0 ? red - 150 : 0, green - 150 >= 0 ? green - 150 : 0, blue - 150 >= 0 ? blue - 150 : 0));
      //   if(i + 4 < strip.numPixels() && i+4 >=0)
      //     strip.setPixelColor(i+4, 0);
        strip.show();
        delay(wait);
      }
    }
    
    
    
    
    void setup() {
      // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
      #if defined (__AVR_ATtiny85__)
        if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
      #endif
      // End of trinket special code
    
      strip.begin();
      strip.setBrightness(100);
      strip.show(); // Initialize all pixels to 'off'
    }
    
    void loop() {
      // Some example procedures showing how to display to the pixels:
      // colorWipe(strip.Color(255, 0, 0), 50); // Red
      // colorWipe(strip.Color(0, 255, 0), 50); // Green
      // colorWipe(strip.Color(0, 0, 255), 50); // Blue
    // //colorWipe(strip.Color(0, 0, 0, 255), 50); // White RGBW
    //   // Send a theater pixel chase in...
      // theaterChase(strip.Color(127, 127, 127), 50); // White
      // theaterChase(strip.Color(127, 0, 0), 200); // Red
      // theaterChase(strip.Color(0, 0, 127), 200); // Blue
    
      // rainbow(20);
      // rainbowCycle(20);
      // theaterChaseRainbow(100);
    
      // strip.setPixelColor(1, strip.Color(255, 255, 255)); 
      // strip.setPixelColor(2, strip.Color(100, 100, 100)); 
      // strip.setPixelColor(3, strip.Color(10, 10, 10)); 
      // strip.show();
      clear();
      meteor(255, 0, 0, 20);
      meteor_overturn(255, 0, 0, 20);
    }
    
    

    灯带连接控制io和gnd,我的控制io插在了23上面
    效果来回流星转动,还有其他效果没有调用,代码里面有,可以控制移动时间,总体数量,亮度等参数。

    展开全文
  • wifi智能氛围灯esp8266,ws2812灯带

    千次阅读 2021-07-09 01:20:22
    硬件设备:esp8266nodemcu开发板(32也是可以的),ws2812灯带工3米共90灯珠,电源模块and杜邦线 需要用到blinker库,esp8266支持包,fastled库 点灯科技app界面配置 ;操作方法我就不讲解了。 完整代码 #...

    没有录视频就直接上图吧,还是挺好看的。

     

    硬件设备:esp8266nodemcu开发板(32也是可以的),ws2812灯带工3米共90灯珠,电源模块and杜邦线

    需要用到blinker库,esp8266支持包,fastled库

    点灯科技app界面配置 ;操作方法我就不讲解了。

     完整代码

    #define BLINKER_WIFI
    #include <Blinker.h>
    #define RGB_1 "RGBKey"
    #define BUTTON_1 "ButtonKey"
    #include "FastLED.h"            // 此示例程序需要使用FastLED库
    #define TEXTE_1 "TextKey"
    #define NUM_LEDS 90             // LED灯珠数量
    #define LED_DT 12                // Arduino输出控制信号引脚
    #define LED_TYPE WS2812B         // LED灯带型号
    #define COLOR_ORDER GRB         // RGB灯珠中红色、绿色、蓝色LED的排列顺序
    uint8_t set=1 , set1;
    uint8_t r1=255 ,g1=255 , b1=255 , L1=255  ;
    uint8_t fromcolor=0 , tocolor=255 , h=20;
    CRGB leds[NUM_LEDS];            // 建立光带leds                                 
    uint8_t colorIndex , jiezou=10;
    int a ;
     
    char auth[] = "b1e872088004";
    char ssid[] = "2-19公共wifi";
    char pswd[] = "12345678";
     
    int data[10] ={ 0 , 127 , 213, 40 , 200 , 80, 160, 220 , 100 , 20};
     
    BlinkerButton Button1("guan");
    BlinkerButton Button2("kai");
    BlinkerRGB RGB1("RGB_1");
    BlinkerButton Button3("ok");
    BlinkerSlider Slider1("from");
    BlinkerSlider Slider3("set");
    BlinkerSlider Slider2("to");
    BlinkerSlider Slider4("jiezou");
    BlinkerText Text1(TEXTE_1);   
    void button1_callback(const String & state) {
      BLINKER_LOG("get button state: ", state);
     
      if (state == "tap") 
      {set=0;
        Button1.color("#000000");
        Button1.text("关灯");
        Button2.text("打开白光");
         Button2.print("off");
        Button1.print("off");
        Text1.print("", "");
        Blinker.print("off","off") ;}
    }
    
    void button2_callback(const String & state) {
      BLINKER_LOG("get button state: ", state);
     
        if (state == "tap")
        {set=7;
        Button2.text("白光");
        Button2.print("on");}
    }
    void button3_callback(const String & state) {
        BLINKER_LOG("get button state: ", state);
        
        if (state == "tap")
        {set=set1;
        Button3.text("已确定");
        Button3.print("on");
        }
    }
     
    void slider1_callback(int32_t value)
    {
        BLINKER_LOG("get slider value: ", value);
        fromcolor  = value;
        
    }
     
    void slider2_callback(int32_t value)
    {
        BLINKER_LOG("get slider value: ", value);
        tocolor  = value;
        
    }
    void slider4_callback(int32_t value)
    {
        BLINKER_LOG("get slider value: ", value);
        jiezou  = value;
        
    }
    void slider3_callback(int32_t value)
    {
        BLINKER_LOG("get slider value: ", value);
        set1  = value;
        Button3.text("点我确定");
        Button3.print("on");
        switch(set1){
          case 1 :Text1.print("单色模式", "可通过色盘选择指定颜色,同时可调节对应亮度");
                   Blinker.print("on","ok") ;break;
          case 2 :Text1.print("彩色模式", "可通过两个HSV色调滑块改变颜色,亮度通过色盘调节");
                   Blinker.print("on","ok") ;break; 
          case 3 :Text1.print("单色呼吸灯", "能够自动改变呼吸灯的颜色,灯光节奏滑块调节速度");
                   Blinker.print("on","ok") ;break;
          case 4 :Text1.print("单色呼吸灯", "可以通过调色盘改变呼吸灯颜色 灯光节奏滑块调节速度");
                   Blinker.print("on","ok") ;break;
           case 5 :Text1.print("流水灯", "可自动改变流水灯颜色 灯光节奏滑块调节速度");
                   Blinker.print("on","ok") ;break;
           case 6 :Text1.print("跑马灯", "HSV色调滑块调节颜色,色盘调节亮度 灯光节奏滑块调节速度");
                   Blinker.print("on","ok") ;break;                       
        }    
    }
    void rgb1_callback(uint8_t r_value, uint8_t g_value, 
                        uint8_t b_value, uint8_t bright_value)
    {
        digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
        BLINKER_LOG("R value: ", r_value);
        BLINKER_LOG("G value: ", g_value);
        BLINKER_LOG("B value: ", b_value);
        BLINKER_LOG("Rrightness value: ", bright_value);
        r1 = r_value ;
        g1 = g_value ;
        b1 = b_value ;
        L1 = bright_value;  
          
    } 
    void dataRead(const String & data)
    {
        BLINKER_LOG("Blinker readString: ", data);
     
        Blinker.vibrate();
        
        uint32_t BlinkerTime = millis();
        Blinker.print(BlinkerTime);
        Blinker.print("millis", BlinkerTime);
    }
     
    void setup() {
     
        Serial.begin(115200);  
        
        BLINKER_DEBUG.stream(Serial); 
        // 初始化ws2812B灯带
        LEDS.addLeds<LED_TYPE, LED_DT, COLOR_ORDER>(leds, NUM_LEDS);  
        FastLED.setBrightness(255); 
        // 初始化blinker  
        Blinker.begin(auth , ssid ,pswd); 
          
        Blinker.attachData(dataRead);
        Button1.attach(button1_callback);
        Button2.attach(button2_callback);
        Button3.attach(button3_callback);
       
        RGB1.attach(rgb1_callback);
        Slider1.attach(slider1_callback);
        Slider2.attach(slider2_callback);
        Slider3.attach(slider3_callback);
        Slider4.attach(slider4_callback);
    }
     
    void loop() {
        Blinker.run();
        switch(set){
        case 0 :
          FastLED.clear(); 
          FastLED.show();
          break;
         case 7 :
         fill_solid(leds , NUM_LEDS , CRGB( 255,  61, 62  ));
          FastLED.setBrightness(L1); 
          FastLED.show();
          Blinker.delay(jiezou);
          break;
         case 1 :
          fill_solid(leds , NUM_LEDS , CRGB( r1,  g1, b1  ));
          FastLED.setBrightness(L1); 
          FastLED.show();
          Blinker.delay(jiezou);
          break;
        case 4 :
          for ( int i=30; i <= 255; i++)
           {
             fill_solid(leds , NUM_LEDS , CRGB( r1 ,g1 ,b1  ));
             FastLED.show();
             FastLED.setBrightness(i); 
             Blinker.delay(jiezou);
             Blinker.run();
            }
               for( int m=255 ;m >= 30; m--)
            {
               fill_solid(leds , NUM_LEDS , CRGB( r1 ,g1 ,b1  ));
               FastLED.show();
               FastLED.setBrightness(m); 
               Blinker.delay(jiezou);
               Blinker.run();
            }break;
    
            case 3 :
            h=h+31;
            for (uint8_t i=90; i <= 254 ; i++ ){
              fill_gradient(leds ,0 ,CHSV(h,255,i) ,NUM_LEDS-1, CHSV(h,255,i) , LONGEST_HUES);
              Blinker.run();
             FastLED.show();
             Blinker.delay(jiezou);
             
            }
               for(uint8_t m=254;m >= 90 ; m-- ){
              fill_gradient(leds ,0 ,CHSV(h,255,m) , NUM_LEDS-1 , CHSV(h,255,m) , LONGEST_HUES);
              Blinker.run();
             FastLED.show();
             Blinker.delay(jiezou);
             
            }break;
            case 2 :
            fill_gradient(leds ,0 ,CHSV(fromcolor,255,L1) ,NUM_LEDS-1 , CHSV(tocolor,255,L1) , LONGEST_HUES);
             FastLED.show();
             Blinker.run();
             break;
             case 5 :
               int n;
               uint8_t v ;
            h=h+40;
               for(n=0 ; n<=(NUM_LEDS-1) ;n++ ){
               fill_gradient(leds ,n ,CHSV(h,255,L1) ,n, CHSV(h,255,L1) , LONGEST_HUES);
                  FastLED.show();
                  Blinker.delay(jiezou);
                 Blinker.run();
               }
               for(n=NUM_LEDS-1 ; n>=0;n-- ){
               fill_gradient(leds ,n ,CHSV(h+100,255,L1) ,n, CHSV(h+100,255,L1) , LONGEST_HUES);
                  FastLED.show();
                  Blinker.delay(jiezou);
                 Blinker.run();
               }
              break; 
              case 6 :
              for( uint8_t n=0 ; n <= NUM_LEDS-10 ; n++){
                fill_gradient(leds ,n ,CHSV(fromcolor,255,L1) , n+9 , CHSV(tocolor,255,L1) , SHORTEST_HUES);
               FastLED.show();
               Blinker.delay(jiezou);
               Blinker.run();
               FastLED.clear();
              
               }
                 for( uint8_t  h=NUM_LEDS-1 ;h >= 9 ;h--){
                fill_gradient(leds ,h ,CHSV(fromcolor,255,L1) , h-9 , CHSV(tocolor,255,L1) , SHORTEST_HUES);
               FastLED.show();
               Blinker.delay(jiezou);
              Blinker.run();
               FastLED.clear();
    
               }
              break;
              
             }  
    }

    展开全文
  • #include<SPI.h> //LED 灯珠数量 #define LED_NUMBER 60 //模拟0码 1111 1100 uint8_t CODE0 = 0xFC; //模拟1码 1100 0000 uint8_t CODE1 = 0XC0; void setup() { ... SPI.setClockDivider(SPI_CLO
  • #include<SPI.h> //LED 灯珠数量 #define LED_NUMBER 60 //模拟0码 1111 1100 uint8_t CODE0 = 0xFC; //模拟1码 1100 0000 uint8_t CODE1 = 0XC0; void setup() { ... SPI.setClockDivider(SPI_CLO
  • GPIO13 连接灯带DI。SPI协议。 代码如下 #include<SPI.h> //LED 灯珠数量 #define LED_NUMBER 60 //模拟0码 1111 1100 uint8_t CODE0 = 0xFC; //模拟1码 1100 0000 uint8_t CODE1 = 0XC0; void setup() { ...
  • 这个部分中笔者将使用ESP32的RMT功能控制WS2812/11灯带
  • 树莓派控制WS2812灯带

    千次阅读 2018-11-20 22:49:00
    原文: https://tutorials-raspberrypi.com/connect-control-raspberry-pi-ws2812-rgb-led-strips/ 主要还是它 git clone https://github.com/jgarff/rpi_ws281x 还需要一个工具进行编译 sudo apt install scons ...
  • #STM32+PWM+DMA驱动 WS2812灯带 #文章目录 1.理论: 2代码: 理论: 使用STM32F103C8T6驱动WS2812灯带,每个灯由24位组成三种颜色RGB,每8位控制一种颜色,颜色值0x00-0xFF,WS2812灯带传送数据
  • 这是一个基于STC8的单片机与WS2812B的LED方案一起集成的灯带显示控制方案,STC8通过串口接口其他设备发送过来的显示指令,然后STC8通过单线HDQ通讯与WS2812B模块交互来进行灯带的显示控制。
  • #include<SPI.h> //LED 灯珠数量 #define LED_NUMBER 60 //模拟0码 1111 1100 uint8_t CODE0 = 0xFC; //模拟1码 1100 0000 uint8_t CODE1 = 0XC0; void setup() { SPI.begin();...void g() {
  • #include<SPI.h> //LED 灯珠数量 #define LED_NUMBER 60 //模拟0码 1111 1100 uint8_t CODE0 = 0xFC; //模拟1码 1100 0000 uint8_t CODE1 = 0XC0; void setup() { ... SPI.setClockDivider(SPI_C
  • 该项目设计专为控制RGB LED WS2812B照明设备而设计,电路基于MCU ATmega32u4设计,且内置微型USB。支持Arduino IDE编程,使其独立工作。与其他附加模块不同,该LED照明控制板有自己的电池插座(JST1.0型),允许您以...
  • 基于stm32f103c8t6最小系统板,ws2812灯带,六种模式,由按键或蓝牙app调模式,电位器ad采集互动,0.96寸OLED显示屏显示模式及参数。
  • WS2812灯带程序简介示例程序程序拓展(1)程序拓展(2)拓展程序(3)---fill_solid()函数灯带颜色的设置CHSV颜色设置示例程序拓展(1)程序拓展(2) 简介 关于WS2812的简介看这里...
  • 准备工作1.1 `原理`1.2 `使用的硬件以及硬件连接图`1.3 `开发环境准备“Arduino开发环境“安装ESP8266的扩展“安装blinker Arduino库“安装blinker APP“下载ws2812的驱动库`2. 配置Blinker App的UI界面3.编写...
  • STC15W单片机在33MHz下只用一个引脚来驱动WS2812B灯串,含多个Keil工程文件。 单个红色旋转效果程序 红绿蓝三色旋转效果程序 七彩覆盖/渐变/切换效果程序 双色渐变彩带旋转效果程序 以及一个综合程序。所使用引脚...
  • stm8s003+ws2812控制3RGB

    2020-10-28 15:51:23
    采用stm8s003控制ws2812 实现3个RGB,适配亚博科技树莓派管家,控制风扇转速及RGB颜色。自己编写的固件。
  • 该资源包含了连个文件,分别是.c和.h,可以实现stm32f103c8t6开发板控制24位WS2812 5050RGB灯圈,其中灯个数可随意修改,在拿到文件后不能很好控制RGB灯时,需自行拿逻辑分析仪测出1,0码所需的延时时间。
  • Python TK框架下搭建的上位机界面,通过串口连接Arduino来控制ws2812b灯带!简单,方便,快捷!
  • Arduino控制WS2812灯带(灯环) #include <FastLED.h> #define LED_PIN 13 // Information about the LED strip itself #define NUM_LEDS 24 #define CHIPSET WS2811 #define COLOR_ORDER GRB CRGB leds[NUM...
  • 基于arduino uno + WS2812b RGB灯带单一颜色跑马灯控制程序 有人可能喜欢看单一效果显示的,花样太多了,看着看着审美疲劳。 效果是单一颜色灯,注意点亮,全亮后,又灭,有逐一点亮反复的效果。 Adafruit_NeoPixel ...
  • 基于arduino WS2812b RGB灯带控制程序一

    千次阅读 2021-02-08 21:32:48
    基于arduino WS2812b RGB灯带控制程序 第一套:带渐变效果,跑马灯效果,快闪和慢闪效果等。 NEO_GRB、NEO_RGB、 NEO_RGBW,3个不同任意选择2个组合显示效果不一样,自行测试。 Adafruit_NeoPixel strip(LED_COUNT, ...
  • 其实led灯带的驱动很多都已经商品化了,直接调用标准库就可以很好地玩了,不过很多人可能还是希望能自己点亮一下,体验一下...程序逻辑就是写IO口输出高低电平,WS2812 需要较快的脉冲。 **********特别注意,由于这
  • 部件。 基于 Adafruit 提供的 NeoPixel 60/m strip (neo60M_W) 部分: :
  • Music-Reactive-WS2812B-Arduino:LED灯带WS2812B对通过AUX 3.5毫米插Kong连接的音乐做出React,如在cine-light youtube上所见
  • STM32F103ZE开发板WS2812B RGB灯带调试

    千次阅读 2020-08-26 20:24:12
    WS2812B每一颗灯都由24位控制,分为8位G,8为位R,8位B。从0到0xFF,数值越大那一种颜色越亮。发送的信号根据高低电平的时间分为1,0,和RES信号。103开发板控制IO口翻转实现0、1信号要实现几百ns的翻转,正点原子...
  • 欢迎关注BUG记录知乎专栏和BUG记录公众号,关注BUG记录公众号回复2812获取本文的参考单片机程序以及STM32CubeMx的安装包和库文件微信号:BugRec之前曾写过SPI...,今天我们说一个比较冷门的SPI用法——控制WS2812灯带...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 398
精华内容 159
关键字:

ws2812灯带