【Arduino】168種傳感器模塊系列實驗（147）---64位WS2812點陣屏

ID:513258 · 發表于 2020-2-29 16:02

本帖最后由 eagler8 于 2020-2-29 16:06 編輯

37款傳感器與模塊的提法，在網絡上廣泛流傳，其實Arduino能夠兼容的傳感器模塊肯定是不止37種的。鑒于本人手頭積累了一些傳感器和執行器模塊，依照實踐出真知（一定要動手做）的理念，以學習和交流為目的，這里準備逐一動手試試做實驗，不管成功與否，都會記錄下來---小小的進步或是搞不定的問題，希望能夠拋磚引玉。

【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十七：64位 WS2812B 8x8 RGB 5050 LED模塊 ws2812s像素點陣屏

ID:513258 · 發表于 2020-2-29 16:05

WS2812B
是一個集控制電路與發光電路于一體的智能外控LED光源。其外型與一個5050LED燈珠相同，每個元件即為一個像素點。像素點內部包含了智能數字接口數據鎖存信號整形放大驅動電路，還包含有高精度的內部振蕩器和12V高壓可編程定電流控制部分，有效保證了像素點光的顏色高度一致。

數據協議采用單線歸零碼的通訊方式，像素點在上電復位以后，DIN端接受從控制器傳輸過來的數據，首先送過來的24bit數據被第一個像素點提取后，送到像素點內部的數據鎖存器，剩余的數據經過內部整形處理電路整形放大后通過DO端口開始轉發輸出給下一個級聯的像素點，每經過一個像素點的傳輸，信號減少24bit。像素點采用自動整形轉發技術，使得該像素點的級聯個數不受信號傳送的限制，僅僅受限信號傳輸速度要求。

LED具有低電壓驅動，環保節能，亮度高，散射角度大，一致性好，超低功率，超長壽命等優點。將控制電路集成于LED上面，電路變得更加簡單，體積小，安裝更加簡便。

ID:513258 · 發表于 2020-2-29 16:18

ID:513258 · 發表于 2020-2-29 16:45

ID:513258 · 發表于 2020-2-29 16:47

ID:513258 · 發表于 2020-2-29 16:48

ID:513258 · 發表于 2020-3-1 08:53

WS2812B主要特點
智能反接保護，電源反接不會損壞IC。
IC控制電路與LED點光源公用一個電源。
控制電路與RGB芯片集成在一個5050封裝的元器件中，構成一個完整的外控像素點。
內置信號整形電路，任何一個像素點收到信號后經過波形整形再輸出，保證線路波形畸變不會累加。
內置上電復位和掉電復位電路。
每個像素點的三基色顏色可實現256級亮度顯示，完成16777216種顏色的全真色彩顯示，掃描頻率不低于400Hz/s。
串行級聯接口，能通過一根信號線完成數據的接收與解碼。
任意兩點傳傳輸距離在不超過5米時無需增加任何電路。
當刷新速率30幀/秒時，級聯數不小于1024點。
數據發送速度可達800Kbps。
光的顏色高度一致，性價比高。

主要應用領域
LED全彩發光字燈串,LED全彩模組， LED全彩軟燈條硬燈條,LED護欄管。
LED點光源,LED像素屏,LED異形屏，各種電子產品，電器設備跑馬燈。

ID:513258 · 發表于 2020-3-1 09:13

名稱：WS2812全彩矩陣LED模塊（64位燈珠）
尺寸：6.5*6.5cm
芯片：WS2812B（內置于LED）
LED：5050封裝RGB全彩高亮
電壓：5V
端口：數字
平臺：Arduino 單片機
控制方式：內置控制芯片，只需一個IO口即可控制

ID:513258 · 發表于 2020-3-1 09:26

模塊電原理圖

ID:513258 · 發表于 2020-3-1 09:34

實驗涉及到的幾個WS2812B相關庫
安裝FastLED庫，工具—管理庫—搜索FastLED—安裝
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
下載learn.adafruit點com/adafruit-neopixel-uberguide/arduino-library-installation

ID:513258 · 發表于 2020-3-1 09:41

ID:513258 · 發表于 2020-3-1 09:45

  程序之一：簡單藍色流水燈
  實驗接線
  Module UNO
  VCC —— 3.3V（希望電流小一些）
  GND —— GND
  DI  ——  D6

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
下載https://learn.adafruit點com/adafruit-neopixel-uberguide/arduino-library-installation
程序之一：簡單藍色流水燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> //16兆赫Adafruit飾品所需
#endif
// Arduino上的哪個插腳與NeoPixels相連？
#define PIN 6
// Arduino上有多少個LED？
#define NUMPIXELS 64
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
#define DELAYVAL 30 //像素之間暫停的時間（毫秒）
void setup() {
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// 特定代碼結束
pixels.begin(); // 初始化neopxel strip對象（必需）
}
void loop() {
pixels.clear(); //將所有像素顏色設置為“關閉”
//一串中的第一個新混合物是0，第二個是1，一直往上
//像素數減1
for (int i = 0; i < NUMPIXELS; i++) { // 對于每個像素......
//Color（）接受RGB值，從0，0，0到255，255，255
//這里我們使用的是中等明亮的藍色：
pixels.setPixelColor(i, pixels.Color(0, 0, 150));
pixels.show(); // 將更新的像素顏色發送到硬件
delay(DELAYVAL); // 在下一個通過循環之前暫停
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 09:51

ID:513258 · 發表于 2020-3-1 10:04

程序之二：粉色單燈流水燈

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
程序之二：粉色單燈流水燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#define PIN 6
#define MAX_LED 64
#define ADD true
#define SUB false
int val = 0;
boolean stat = ADD;
Adafruit_NeoPixel strip = Adafruit_NeoPixel( MAX_LED, PIN, NEO_RGB + NEO_KHZ800 );
void setup()
{
strip.begin(); //初始化Adafruit_NeoPixel；
strip.show(); //顯示所有LED為關狀態;
}
void loop()
{
uint8_t i,a=0;
uint32_t color = strip.Color(0, 150, 150); //選擇所顯示的顏色
while(a<65)
{
for(i=0;i<64;i++)
{
if(i==a) strip.setPixelColor(i, color); //第幾個LED點亮;
else strip.setPixelColor(i, 0); //使其他LED全滅;
}
strip.show(); //是LED顯示所選的顏色;
delay(50); //延時50ms；
a++;
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 10:10

程序之三：四色交替流水燈

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝FastLED庫，工具—管理庫—搜索FastLED—安裝
程序之三：四色交替流水燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <FastLED.h>
#define LED_PIN 6
#define NUM_LEDS 64
CRGB leds[NUM_LEDS];
void setup() {
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
}
void loop() {
for (int i = 0; i <= 63; i++) {
leds[i] = CRGB ( 0, 0, 200);
FastLED.show();
delay(33);
}
for (int i = 63; i >= 0; i--) {
leds[i] = CRGB ( 89, 0, 0);
FastLED.show();
delay(33);
}
for (int i = 0; i <= 63; i++) {
leds[i] = CRGB ( 0, 89, 0);
FastLED.show();
delay(33);
}
for (int i = 63; i >= 0; i--) {
leds[i] = CRGB ( 89, 0, 200);
FastLED.show();
delay(33);
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 10:13

ID:513258 · 發表于 2020-3-1 10:36

程序之四：黑客帝國綠色流水燈

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝FastLED庫，工具—管理庫—搜索FastLED—安裝
安裝Adafruit_NeoPixel庫，
程序之四：黑客帝國綠色流水燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#define PIN 6
#define MAX_LED 64
#define ADD true
#define SUB false
int val = 0;
boolean stat = ADD;
Adafruit_NeoPixel strip = Adafruit_NeoPixel( MAX_LED, PIN, NEO_RGB + NEO_KHZ800 );
void setup()
{
strip.begin();
strip.show();
}
void loop()
{
uint8_t i, a = 0;
uint32_t color = strip.Color(190, 50, 0);
while (a < 65)
{
for (i = 0; i < 64; i++)
{
if (i == a) strip.setPixelColor(i, color);
else strip.setPixelColor(i, 0);
}
strip.show();
delay(25);
a++;
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 10:45

程序之五：RGB傳輸測試滿屏變幻彩燈

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
程序之五：RGB傳輸測試滿屏變幻彩燈
實驗接線
Module UNO
VCC —— 3.3V
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 60
// 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
}

復制代碼

ID:513258 · 發表于 2020-3-1 11:18

本帖最后由 eagler8 于 2020-3-1 11:46 編輯

程序之五：RGB傳輸測試滿屏變幻彩燈視頻（52秒）

鏈接：https://v.youku.com/v_show/id_XNDU2ODQ2MDI0NA==.html

https://v.youku.com/v_show/id_XNDU2ODQ2MDI0NA==.html

ID:513258 · 發表于 2020-3-1 11:31

【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
  實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
  安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
  安裝Adafruit_NeoPixel庫，
  下載:learn.adafruit點com/adafruit-neopixel-uberguide/arduino-library-installation

  程序之六：復合流水彩虹燈
  實驗接線
  Module UNO
  VCC —— 3.3V
  GND —— GND
  DI  ——  D6

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
下載https://learn.adafruit點com/adafruit-neopixel-uberguide/arduino-library-installation
程序之六：復合流水彩虹燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#define PIN 6
#define BRIGHTNESS 64
Adafruit_NeoPixel strip = Adafruit_NeoPixel(64, 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);
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 11:57

程序之七：復合飄逸彩虹滿屏燈

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
下載https://learn.adafruit點com/adafruit-neopixel-uberguide/arduino-library-installation
程序之七：復合飄逸彩虹滿屏燈
實驗接線
Module UNO
VCC —— 3.3V
GND —— GND
DI —— D6
*/
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 6
// 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(64, 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() {
// 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(50);
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), 50); // Red
theaterChase(strip.Color(0, 0, 127), 50); // Blue
rainbow(20);
rainbowCycle(20);
theaterChaseRainbow(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 (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
}
}
}
}
// 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);
}

復制代碼

ID:513258 · 發表于 2020-3-1 12:29

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十六：64位 WS2812B8*8 xRGB 5050 LED模塊 ws2812s像素點陣屏
安裝NeoPixel庫，工具—管理庫—搜索NeoPixel—安裝
安裝Adafruit_NeoPixel庫，
程序之八：復合彩虹滾動流水燈
實驗接線
Module UNO
VCC —— 3.3V
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 64
// 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
}
}
}

復制代碼

ID:513258 · 發表于 2020-3-1 13:08

實驗仿真編程（linkboy3.6）之一

ID:513258 · 發表于 2020-3-1 13:21

本帖最后由 eagler8 于 2020-3-1 14:18 編輯

實驗仿真編程（linkboy3.6）之二

ID:513258 · 發表于 2020-3-1 14:18

實驗仿真編程（linkboy3.6）之三

ID:513258 · 發表于 2020-3-2 18:10

程序之四：黑客帝國綠色流水燈

ID:513258 · 發表于 2020-3-4 16:38

視頻——程序之六：復合流水彩虹燈

https://v.youku.com/v_show/id_XNDU2ODUwMTE2NA==.html

https://v.youku.com/v_show/id_XNDU2ODUwMTE2NA==.html

ID:205113 · 發表于 2025-4-5 12:31

內容詳實，找了很久，就這個帖子最詳細。感謝分享！

帳號		自動登錄	找回密碼
密碼			立即注冊

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

【Arduino】168種傳感器模塊系列實驗（147）---64位WS2812點陣屏