久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

標題: 【Arduino】108種傳感器模塊系列實驗（131）--24位WS2812環(huán)形燈板 [打印本頁]

作者: eagler8 時間: 2019-10-1 06:50
標題: 【Arduino】108種傳感器模塊系列實驗（131）--24位WS2812環(huán)形燈板
37款傳感器與模塊的提法，在網(wǎng)絡上廣泛流傳，其實Arduino能夠兼容的傳感器模塊肯定是不止37種的。鑒于本人手頭積累了一些傳感器和模塊，依照實踐出真知（一定要動手做）的理念，以學習和交流為目的，這里準備逐一動手試試做實驗，不管成功與否，都會記錄下來---小小的進步或是搞不定的問題，希望能夠拋磚引玉。

【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板

作者: eagler8 時間: 2019-10-1 06:52
WS2812
是在尋求一種簡單，可擴展和經(jīng)濟實惠的全彩LED的最新進展。紅色，綠色和藍色LED與驅動器芯片一起集成到通過單線控制的微小表面貼裝封裝中。它們可以單獨使用，鏈接成更長的字符串或組裝成更有趣的形狀因數(shù)。基于WS2812的 LED 驅動器，使用單線控制協(xié)議，可分別尋址RGB彩色像素和色帶。專用LED驅動器芯片的到來帶來了可喜的緩解，減輕了微控制器的繁瑣工作，使人們可以專注于應用與創(chuàng)造。

作者: eagler8 時間: 2019-10-1 07:33

該Adafruit NeoPixel環(huán)包含24個可單獨尋址的RGB LED，這些LED以緊密間隔排列，所有這些均可通過微控制器的單個數(shù)字輸出進行控制。該環(huán)的外徑為2.6英寸（66毫米），可以將多個環(huán)鏈接在一起，使其非常適合為小型機器人或可穿戴電子項目增加光澤。

功能和規(guī)格
24個可單獨尋址的RGB LED（基于SK6812-或WS2812B的NeoPixels）
圓形外徑2.6英寸（66毫米），內徑2.05英寸（52.5毫米）
24位色彩控制（每通道8位PWM）；每像素1680萬種顏色
單線數(shù)字控制接口
工作電壓：5 V
每個RGB LED在5 V時消耗大約50 mA的電流，紅色，綠色和藍色在全亮度下（環(huán)最大為1.2 A）
多個NeoPixel環(huán)可鏈接在一起

作者: eagler8 時間: 2019-10-1 07:40

24位WS2812 5050 RGB LED智能全彩RGB燈環(huán)開發(fā)板, 產(chǎn)品（直徑）：86mm ,重量：6g ,電壓：DC4-7V范圍供電,通信接口：單線通訊

LED驅動芯片WS2812(集成在LED里面）
智能反接保護，電源反接不會損壞IC。
IC控制電路與LED點光源公用一個電源。
控制電路與RGB晶片集成在一個5050封裝的元器件中，構成一個完整的外控圖元點。
內置信號整形電路，任何一個圖元點收到信號后經(jīng)過波形整形再輸出，保證線路波形畸變不會累加。
內置上電重定和掉電重定電路。
每個圖元點的三基色顏色可實現(xiàn)256級亮度顯示，完成16777216種顏色的全真色彩顯示，掃描頻率不低于400Hz/s。
串列級聯(lián)介面，能通過一根信號線完成資料的接收與解碼。
任意兩點傳傳輸距離在不超過5米時無需增加任何電路。
當刷新速率30幀/秒時，級聯(lián)數(shù)不小于1024點。
資料發(fā)送速度可達800Kbps。
光的顏色高度一致，性價比高。

作者: eagler8 時間: 2019-10-1 07:43

5050高亮LED，內置控制芯片，僅需1個IO口即可控制多個LED
芯片內置整形電路，信號畸變不會累計，穩(wěn)定顯示
三基色256級亮度調劑，16萬色真彩顯示效果，掃描頻率不低于400Hz/S
串行連級接口，能通過一根信號線完成數(shù)據(jù)的接收與解碼
高亮LED，光色亮度一致性高
兩端有連級接口(DIN DOUT)，可以串接

WS2813B是一個集控制電路與發(fā)光電路于一體的智慧外控LED光源。其外型與一個5050LED燈珠相同，每個元件即為一個圖元點。圖元點內部包含了智慧數(shù)位介面資料鎖存信號整形放大驅動電路，還包含有高精度的內部振蕩器和12V高壓可編程定電流控制部分，有效保證了圖元點光的顏色高度一致。
資料協(xié)定采用單線歸零碼的通訊方式，圖元點在上電重定以后，DIN端接受從控制器傳輸過來的資料，首先送過來的24bit資料被第一個圖元點提取后，送到圖元點內部的資料鎖存器，剩余的資料經(jīng)過內部整形處理電路整形放大后通過DO埠開始轉發(fā)輸出給下一個級聯(lián)的圖元點，每經(jīng)過一個圖元點的傳輸，信號減少24bit。圖元點采用自動整形轉發(fā)技術，使得該圖元點的級聯(lián)個數(shù)不受信號傳送的限制，僅僅受限信號傳輸速度要求。
LED具有低電壓驅動，環(huán)保節(jié)能，亮度高，散射角度大，一致性好，超低功率，超長壽命等優(yōu)點。將控制電路集成于LED上面，電路變得更加簡單，體積小，安裝更加簡便。

作者: eagler8 時間: 2019-10-1 08:51

連接
LED環(huán)具有四個連接點。

標為GND的引腳為接地引腳，應連接至控制LED的微控制器的接地引腳，也應連接至電源的負極。

標有PWR + 5V的引腳是電源輸入引腳，應連接到合適的電源。5 V的輸入電壓用于為環(huán)供電，當以全亮度輸出白色時，環(huán)上的每個LED在5 V時可消耗高達50 mA的電流。這意味著該環(huán)最多可吸收約1.2 A電流。

標為“ 數(shù)據(jù)輸入 ”的引腳是一個輸入，用于接收控制LED的信號。該引腳應連接至基于SK6812 / WS281x的LED產(chǎn)品的微控制器輸出引腳或信號輸出引腳。

標有“ 數(shù)據(jù)輸出 ”的引腳是可選的。它可以連接到另一個基于SK6812 / WS281x的LED產(chǎn)品的數(shù)據(jù)輸入引腳，以形成一條鏈。

我們的0.1英寸排針可以用來連接環(huán)的四個針，也可以將導線直接焊接到板上。環(huán)并不與任何標頭銷或連接器發(fā)貨。

如果在使用NeoPixels時未采取適當?shù)念A防措施，則很容易損壞它們。通常，對于基于SK6812 / WS2812B的產(chǎn)品，建議在接地線和電源線之間添加至少10 F的電容器，并在微控制器和信號輸入引腳之間添加100Ω至1000Ω的電阻。

作者: eagler8 時間: 2019-10-1 09:00
模塊電原理圖

作者: eagler8 時間: 2019-10-1 09:03
ATTiny85與WS2812 LED環(huán)配合使用示意圖

作者: eagler8 時間: 2019-10-1 10:06
/*
  【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
  實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
  項目一：循環(huán)點亮24位綠色LED
  Module    UNO
  VCC —— 5V
  GND  —— GND
  DI —— D6
*/

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN       6 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 24 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter -- see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

#define DELAYVAL 300 // Time (in milliseconds) to pause between pixels

void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
}

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  // The first NeoPixel in a strand is #0, second is 1, all the way up
  // to the count of pixels minus one.
  for (int i = 0; i < NUMPIXELS; i++) { // For each pixel...

// pixels.Color() takes RGB values, from 0,0,0 up to 255,255,255
// Here we're using a moderately bright green color:
pixels.setPixelColor(i, pixels.Color(0, 150, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop
  }
}

作者: eagler8 時間: 2019-10-1 10:17

作者: eagler8 時間: 2019-10-1 10:33

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目二：循環(huán)快掃24位紅綠藍色LED流水燈
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <FastLED.h>
#define LED_PIN 6
#define NUM_LEDS 24
CRGB leds[NUM_LEDS];
void setup() {
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
}
void loop() {
for (int i = 0; i <= 23; i++) {
leds[i] = CRGB ( 0, 0, 255);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 23; i++) {
leds[i] = CRGB ( 255, 0, 0);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 23; i++) {
leds[i] = CRGB ( 0, 255, 0);
FastLED.show();
delay(40);
}
}

復制代碼

作者: eagler8 時間: 2019-10-1 10:45

作者: eagler8 時間: 2019-10-1 12:00

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目三：使用紅色、綠色和藍色三種參數(shù)將任何LED設置為任何顏色
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <FastLED.h>
#define LED_PIN 6
#define NUM_LEDS 24
CRGB leds[NUM_LEDS];
void setup() {
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
}
void loop() {
leds[0] = CRGB(255, 0, 0);
FastLED.show();
delay(500);
leds[1] = CRGB(0, 255, 0);
FastLED.show();
delay(500);
leds[2] = CRGB(0, 0, 255);
FastLED.show();
delay(500);
leds[5] = CRGB(150, 0, 255);
FastLED.show();
delay(500);
leds[9] = CRGB(255, 200, 20);
FastLED.show();
delay(500);
leds[14] = CRGB(85, 60, 180);
FastLED.show();
delay(500);
leds[19] = CRGB(50, 255, 20);
FastLED.show();
delay(500);
}

復制代碼

作者: eagler8 時間: 2019-10-1 12:07

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目四：流水燈變幻彩虹燈
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#define PIN 6
#define BRIGHTNESS 24
Adafruit_NeoPixel strip = Adafruit_NeoPixel(24, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.setBrightness(BRIGHTNESS);
strip.begin();
strip.show();
}
void loop() {
colorWipe(strip.Color(150, 0, 0), 50); // Red
colorWipe(strip.Color(0, 150, 0), 50); // Green
colorWipe(strip.Color(0, 0, 150), 50); // Blue
colorWipe(strip.Color(150, 150, 150), 50); // BlueWite
rainbowCycle(1);
}
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);
}
}
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);
}
}
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);
}
}
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);
}
}

復制代碼

作者: eagler8 時間: 2019-10-1 12:21

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目五：循環(huán)流水變幻呼吸燈
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
// NeoPixel test program showing use of the WHITE channel for RGBW
// pixels only (won't look correct on regular RGB NeoPixel strips).
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 24
// NeoPixel brightness, 0 (min) to 255 (max)
#define BRIGHTNESS 50
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 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)
void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.
strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}
void loop() {
// Fill along the length of the strip in various colors...
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); // True white (not RGB white)
whiteOverRainbow(75, 5);
pulseWhite(5);
rainbowFade2White(3, 3, 1);
}
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
void whiteOverRainbow(int whiteSpeed, int whiteLength) {
if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;
int head = whiteLength - 1;
int tail = 0;
int loops = 3;
int loopNum = 0;
uint32_t lastTime = millis();
uint32_t firstPixelHue = 0;
for(;;) { // Repeat forever (or until a 'break' or 'return')
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
if(((i >= tail) && (i <= head)) || // If between head & tail...
((tail > head) && ((i >= tail) || (i <= head)))) {
strip.setPixelColor(i, strip.Color(0, 0, 0, 255)); // Set white
} else { // else set rainbow
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
}
strip.show(); // Update strip with new contents
// There's no delay here, it just runs full-tilt until the timer and
// counter combination below runs out.
firstPixelHue += 40; // Advance just a little along the color wheel
if((millis() - lastTime) > whiteSpeed) { // Time to update head/tail?
if(++head >= strip.numPixels()) { // Advance head, wrap around
head = 0;
if(++loopNum >= loops) return;
}
if(++tail >= strip.numPixels()) { // Advance tail, wrap around
tail = 0;
}
lastTime = millis(); // Save time of last movement
}
}
}
void pulseWhite(uint8_t wait) {
for(int j=0; j<256; j++) { // Ramp up from 0 to 255
// Fill entire strip with white at gamma-corrected brightness level 'j':
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
delay(wait);
}
for(int j=255; j>=0; j--) { // Ramp down from 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
delay(wait);
}
}
void rainbowFade2White(int wait, int rainbowLoops, int whiteLoops) {
int fadeVal=0, fadeMax=100;
// Hue of first pixel runs 'rainbowLoops' complete loops through the color
// wheel. Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to rainbowLoops*65536, using steps of 256 so we
// advance around the wheel at a decent clip.
for(uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops*65536;
firstPixelHue += 256) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
uint32_t pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we're using just the three-argument variant, though the
// second value (saturation) is a constant 255.
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue, 255,
255 * fadeVal / fadeMax)));
}
strip.show();
delay(wait);
if(firstPixelHue < 65536) { // First loop,
if(fadeVal < fadeMax) fadeVal++; // fade in
} else if(firstPixelHue >= ((rainbowLoops-1) * 65536)) { // Last loop,
if(fadeVal > 0) fadeVal--; // fade out
} else {
fadeVal = fadeMax; // Interim loop, make sure fade is at max
}
}
for(int k=0; k<whiteLoops; k++) {
for(int j=0; j<256; j++) { // Ramp up 0 to 255
// Fill entire strip with white at gamma-corrected brightness level 'j':
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
}
delay(1000); // Pause 1 second
for(int j=255; j>=0; j--) { // Ramp down 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
strip.show();
}
}
delay(500); // Pause 1/2 second
}

復制代碼

作者: eagler8 時間: 2019-10-1 12:56

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目六：多彩流水燈變幻彩虹燈
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 24
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 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)
// setup() function -- runs once at startup --------------------------------
void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.
strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}
// loop() function -- runs repeatedly as long as board is on ---------------
void loop() {
// Fill along the length of the strip in various colors...
colorWipe(strip.Color(255, 0, 0), 50); // Red
colorWipe(strip.Color( 0, 255, 0), 50); // Green
colorWipe(strip.Color( 0, 0, 255), 50); // Blue
// Do a theater marquee effect in various colors...
theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
theaterChase(strip.Color(127, 0, 0), 50); // Red, half brightness
theaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightness
rainbow(10); // Flowing rainbow cycle along the whole strip
theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}
// Some functions of our own for creating animated effects -----------------
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for (int i = 0; i < strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
for (int a = 0; a < 10; a++) { // Repeat 10 times...
for (int b = 0; b < 3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for (int c = b; c < strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
// Hue of first pixel runs 5 complete loops through the color wheel.
// Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
// means we'll make 5*65536/256 = 1280 passes through this outer loop:
for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {
for (int i = 0; i < strip.numPixels(); i++) { // For each pixel in strip...
// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we're using just the single-argument hue variant. The result
// is passed through strip.gamma32() to provide 'truer' colors
// before assigning to each pixel:
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
int firstPixelHue = 0; // First pixel starts at red (hue 0)
for (int a = 0; a < 30; a++) { // Repeat 30 times...
for (int b = 0; b < 3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in increments of 3...
for (int c = b; c < strip.numPixels(); c += 3) {
// hue of pixel 'c' is offset by an amount to make one full
// revolution of the color wheel (range 65536) along the length
// of the strip (strip.numPixels() steps):
int hue = firstPixelHue + c * 65536L / strip.numPixels();
uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
}
}
}

復制代碼

作者: eagler8 時間: 2019-10-1 13:03

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目七：多彩流水燈變幻彩虹燈之三
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h> //needed for the WS2812
#include <avr/pgmspace.h> //needed for PROGMEM
#define PIN 6 //Pin 1 is DATA In on the bottom Ring
#define BRIGHTNESS 24 // brightness reduced
//Lookup for the Candle light
const unsigned int candles[] PROGMEM =
{
15, 10, 48, 45, 36, 19, 59, 29, 5, 43, 41, 39, 24, 3, 61
};
Adafruit_NeoPixel strip = Adafruit_NeoPixel(24, 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.
void setup() {
pinMode(PIN, OUTPUT);
strip.begin();
strip.setBrightness(BRIGHTNESS); // set brightness
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
tree();
delay(1000);
colorcrazy();
theaterChaseRainbow(50);
comet();
warpdrive();
warpdrive();
rainbowCycle(1);
rainbow(5);
rainbow(5);
rainbow(5);
colorWipe(strip.Color(255, 0, 0), 50); // Red
colorWipe(strip.Color(0, 255, 0), 50); // Green
colorWipe(strip.Color(0, 0, 255), 50); // Blue
//
//
// cometr();
//Tree light:
//
// warpdrive();
//
//
// comet();
/*
// 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
// Send a theater pixel chase in...
theaterChase(strip.Color(127, 127, 127), 50); // White
theaterChase(strip.Color(127, 0, 0), 50); // Red
theaterChase(strip.Color( 0, 0, 127), 50); // Blue
rainbow(20);
rainbowCycle(20);
theaterChaseRainbow(50);
*/
}
//Sub-----------------------------------------------------------------------
//Comet
void comet() {
for (uint16_t i = strip.numPixels(); i > 0; i--) {
strip.setPixelColor(i, strip.Color(0, 0, 255));
fadethemall(10);
fadethemall(10);
}
}
void cometr() {
for (uint16_t i = strip.numPixels(); i > 0; i--) {
strip.setPixelColor(i, strip.Color(255, 0, 0));
fadethemall(10);
fadethemall(10);
}
}
//From top down white pulses
void warpdrive() {
//Top Led
strip.setPixelColor(60, strip.Color(255, 255, 255));
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
//8 Ring
for (int i = 52; i < 60; i++)
{
strip.setPixelColor(i, strip.Color(255, 255, 255));
}
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
//12 Ring
for (int i = 40; i < 52; i++)
{
strip.setPixelColor(i, strip.Color(255, 255, 255));
}
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
//16 Ring
for (int i = 24; i < 40; i++)
{
strip.setPixelColor(i, strip.Color(255, 255, 255));
}
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
//24 Ring
for (int i = 0; i < 24; i++)
{
strip.setPixelColor(i, strip.Color(255, 255, 255));
}
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
//Extra by John Kerr
strip.setPixelColor(60, strip.Color(0, 0, 0));
strip.show();
//fade a bit
for (int i = 0; i < 20; i++)
{
fadethemall(20);
}
}
//This reduces the brightness of all leds
void fadethemall(uint8_t wait) {
for (uint16_t i = 0; i < strip.numPixels(); i++) {
uint32_t color = strip.getPixelColor(i);
int r;
int g;
int b;
r = (uint8_t)(color >> 16);
g = (uint8_t)(color >> 8);
b = (uint8_t)color;
if (r > 0)
{
r = r - 1;
}
else
{
r = 0;
}
if (g > 0)
{
g = g - 1;
}
else
{
g = 0;
}
if (b > 0)
{
b = b - 1;
}
else
{
b = 0;
}
strip.setPixelColor(i, strip.Color(r, g, b));
}
strip.show();
delay(wait);
}
//This drives the WS2812 in a crazy pattern, fun!
void colorcrazy() {
colorWipe(strip.Color(255, 0, 0), 25); // Red
colorWipe(strip.Color(0, 255, 0), 25); // Green
colorWipe(strip.Color(0, 0, 255), 25); // Blue
theaterChaseRainbow(5);
}
//This lights up the tree in green, then add the white "candles"
void tree() {
colorWipe(strip.Color(0, 50, 0), 50); // Green
//light "candles"
//Show the S:
for (int i = 0; i < 16; i++)
{
strip.setPixelColor(pgm_read_word(&candles[i]) - 1, strip.Color(255, 255, 255));
strip.show();
delay(50);
}
}
// 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);
}
}
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 (int i = 0; i < strip.numPixels(); i = i + 3) {
strip.setPixelColor(i + q, c); //turn every third pixel on
}
strip.show();
delay(wait);
for (int 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 (int 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 (int i = 0; i < strip.numPixels(); i = i + 3) {
strip.setPixelColor(i + q, 0); //turn every third pixel off
}
}
}
}
// 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);
} else if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
} else {
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
}

復制代碼

作者: eagler8 時間: 2019-10-1 13:22

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目八：綠色到粉紅色，也沿著環(huán)形移動
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <PololuLedStrip.h>
// Create an ledStrip object and specify the pin it will use.
PololuLedStrip<6> ledStrip;
// Create a buffer for holding the colors (3 bytes per color).
#define LED_COUNT 60
rgb_color colors[LED_COUNT];
void setup()
{
}
void loop()
{
// Update the colors.
byte time = millis() >> 2;
for (uint16_t i = 0; i < LED_COUNT; i++)
{
byte x = time - 8*i;
colors[i] = rgb_color(x, 255 - x, x);
}
// Write the colors to the LED strip.
ledStrip.write(colors, LED_COUNT);
delay(10);
}

復制代碼

作者: eagler8 時間: 2019-10-1 13:26

/*
【Arduino】108種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百三十一：24位 WS2812 5050 RGB LED 內置全彩驅動彩燈圓形開發(fā)板
項目九：一道移動的彩虹
Module UNO
VCC —— 5V
GND —— GND
DI —— D6
*/
#include <PololuLedStrip.h>
// Create an ledStrip object and specify the pin it will use.
PololuLedStrip<6> ledStrip;
// Create a buffer for holding the colors (3 bytes per color).
#define LED_COUNT 60
rgb_color colors[LED_COUNT];
void setup()
{
}
// Converts a color from HSV to RGB.
// h is hue, as a number between 0 and 360.
// s is the saturation, as a number between 0 and 255.
// v is the value, as a number between 0 and 255.
rgb_color hsvToRgb(uint16_t h, uint8_t s, uint8_t v)
{
uint8_t f = (h % 60) * 255 / 60;
uint8_t p = (255 - s) * (uint16_t)v / 255;
uint8_t q = (255 - f * (uint16_t)s / 255) * (uint16_t)v / 255;
uint8_t t = (255 - (255 - f) * (uint16_t)s / 255) * (uint16_t)v / 255;
uint8_t r = 0, g = 0, b = 0;
switch((h / 60) % 6){
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;
case 5: r = v; g = p; b = q; break;
}
return rgb_color(r, g, b);
}
void loop()
{
// Update the colors.
uint16_t time = millis() >> 2;
for(uint16_t i = 0; i < LED_COUNT; i++)
{
byte x = (time >> 2) - (i << 3);
colors[i] = hsvToRgb((uint32_t)x * 359 / 256, 255, 255);
}
// Write the colors to the LED strip.
ledStrip.write(colors, LED_COUNT);
delay(10);
}

復制代碼

作者: eagler8 時間: 2019-10-1 14:40

作者: eagler8 時間: 2019-10-1 14:42

作者: eagler8 時間: 2019-10-1 14:44

作者: eagler8 時間: 2019-10-1 14:45

作者: eagler8 時間: 2019-10-1 14:48

作者: eagler8 時間: 2019-10-1 16:04

作者: eagler8 時間: 2019-10-1 16:19

作者: 891558534 時間: 2020-2-8 14:20
非常經(jīng)典，謝謝

作者: eagler8 時間: 2020-2-8 16:34

891558534 發(fā)表于 2020-2-8 14:20
非常經(jīng)典，謝謝

元宵節(jié)快樂！謝謝鼓勵！

作者: ssw2020 時間: 2020-6-22 09:37
樓主的分享很有意義

作者: eagler8 時間: 2020-10-24 15:44

ssw2020 發(fā)表于 2020-6-22 09:37
樓主的分享很有意義

謝謝鼓勵

作者: 聽風的賬號1111 時間: 2020-12-31 15:36
想問下一直顯示這串代碼錯誤是因為什么？
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);

作者: eagler8 時間: 2021-1-1 15:44

聽風的賬號1111 發(fā)表于 2020-12-31 15:36
想問下一直顯示這串代碼錯誤是因為什么？
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_K ...

那個程序？具體情況請截個圖看看

作者: dj3365191 時間: 2021-1-24 19:09
不好意思，我剛接觸arduino，不知這個錯誤是什么意思，怎么修改，謝謝
stray '#' in program

歡迎光臨 (http://m.zg4o1577.cn/bbs/)