Animationen
Was dieses Beispiel zeigt
Wie Sie das gesamte Raster animieren, indem Sie es Bild für Bild neu zeichnen. Der Sketch führt in einer Schleife zwei Animationen aus: einen Zeilendurchlauf, der von oben nach unten jeweils eine Zeile aufleuchten lässt, und einen Regenbogen, der jedes Pixel durch ein Farbrad laufen lässt, wobei jedes Pixel gegenüber seinem Nachbarn ein Stück weiter ist.
Verbinden Sie VCC mit 5 V, GND mit GND und DIN mit Pin 6 Ihres Controllers, oder ändern Sie PIN auf den Pin, den Sie verwendet haben.
Der Beispielcode
Dies ist Animations.ino aus der fixierten Bibliothek, genau so, wie sie ausgeliefert wird.
/**
**************************************************
*
* @file Animations.ino
* @brief Demonstrates row sweep and colour-cycle animations on the
* Soldered 8x8 WS2812B LED grid.
*
* Connect the grid data line to PIN below.
*
* @authors Josip Šimun Kuči @ soldered.com
***************************************************/
#include "WS2812Grid-SOLDERED.h"
#define PIN 6
WS2812Grid grid(PIN);
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
// Simple HSV-to-RGB wheel: hue 0–255
static uint32_t colorWheel(uint8_t pos)
{
pos = 255 - pos;
if (pos < 85)
return WS2812Grid::Color(255 - pos * 3, 0, pos * 3);
if (pos < 170)
{
pos -= 85;
return WS2812Grid::Color(0, pos * 3, 255 - pos * 3);
}
pos -= 170;
return WS2812Grid::Color(pos * 3, 255 - pos * 3, 0);
}
// ---------------------------------------------------------------------------
// Animations
// ---------------------------------------------------------------------------
void rowSweep()
{
for (uint8_t y = 0; y < 8; y++)
{
grid.clear();
for (uint8_t x = 0; x < 8; x++)
{
grid.setPixel(x, y, 0, 180, 255);
}
grid.show();
delay(80);
}
}
void rainbowGrid(uint8_t cycles)
{
for (uint8_t c = 0; c < cycles; c++)
{
for (uint16_t hue = 0; hue < 256; hue++)
{
for (uint8_t y = 0; y < 8; y++)
{
for (uint8_t x = 0; x < 8; x++)
{
uint8_t offset = (x + y * 2) & 0xFF;
grid.setPixel(x, y, colorWheel((hue + offset) & 0xFF));
}
}
grid.show();
delay(10);
}
}
}
// ---------------------------------------------------------------------------
// Setup / loop
// ---------------------------------------------------------------------------
void setup()
{
grid.begin();
grid.setBrightness(40);
}
void loop()
{
rowSweep();
delay(200);
rainbowGrid(2);
delay(200);
}
Erwartetes Ergebnis: Der Sketch gibt nichts im Serial Monitor aus. Auf dem Raster leuchtet bei einer Helligkeit von 40 von 255 jede Zeile nacheinander 80 ms lang in der Farbe (0, 180, 255), von der obersten bis zur untersten Zeile. Nach einer Pause von 200 ms durchläuft der Regenbogen die 256 Farben des Rads zweimal, 10 ms pro Schritt, wobei jedes Pixel um seine Spalte plus das Doppelte seiner Zeile auf dem Rad versetzt ist. Nach einer weiteren Pause von 200 ms beginnt die Schleife von vorn.
Verwendete Funktionen
WS2812Grid(uint8_t pin, uint8_t width = 8, uint8_t height = 8)returns WS2812GridErstellt den Raster-Driver für Breite x Höhe LEDs an dem Pin, der mit DIN verbunden ist. Ein Raster hat 8 x 8, das ist der Standard. Übergeben Sie bei mehreren verketteten Rastern die volle Breite und Höhe des Panels.
ReturnsDas Raster-Objekt.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
uint8_t | pin | Arduino-Pin, der mit DIN des Rasters verbunden ist. |
uint8_t | width | Anzahl der Spalten, ein Vielfaches von 8. Standard 8. |
uint8_t | height | Anzahl der Zeilen, ein Vielfaches von 8. Standard 8. |
begin()returns voidInitialisiert den LED-Driver, indem der Datenpin als Ausgang gesetzt wird, löscht dann jedes Pixel und ruft show() auf, sodass das Raster dunkel startet. Rufen Sie es einmal in setup() auf.
ReturnsNichts.
setBrightness(uint8_t b)returns voidLegt die Ausgabehelligkeit für alle LEDs fest. Die Änderung wird beim nächsten show() sichtbar. Sie ist dafür gedacht, einmal in setup() gesetzt zu werden: Die Bibliothek skaliert die gespeicherten Farben, daher geht bei wiederholtem Ändern Farbgenauigkeit verloren.
ReturnsNichts.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
uint8_t | b | Helligkeit, 0 (aus) bis 255 (am hellsten). |
clear()returns voidSetzt jedes Pixel im Speicher auf aus. Die LEDs werden beim nächsten show() dunkel. Der Zeilendurchlauf nutzt es, um die vorherige Zeile zu löschen, bevor die nächste gezeichnet wird.
ReturnsNichts.
setPixel(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b)returns voidSetzt eine LED anhand ihrer Rasterposition auf getrennte Rot-, Grün- und Blauwerte. Eine Position außerhalb des Rasters wird ignoriert. Rufen Sie anschließend show() auf, um die Änderung an die LEDs zu senden.
ReturnsNichts.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
uint8_t | x | Spalte, 0 = links. |
uint8_t | y | Zeile, 0 = oben. |
uint8_t | r | Rot, 0 bis 255. |
uint8_t | g | Grün, 0 bis 255. |
uint8_t | b | Blau, 0 bis 255. |
setPixel(uint8_t x, uint8_t y, uint32_t color)returns voidSetzt eine LED anhand ihrer Rasterposition auf eine gepackte Farbe. Der Regenbogen übergibt den Wert, den colorWheel() mit WS2812Grid::Color() erzeugt. Eine Position außerhalb des Rasters wird ignoriert. Rufen Sie anschließend show() auf, um die Änderung an die LEDs zu senden.
ReturnsNichts.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
uint8_t | x | Spalte, 0 = links. |
uint8_t | y | Zeile, 0 = oben. |
uint32_t | color | Gepackte Farbe, 0x00RRGGBB. |
WS2812Grid::Color(uint8_t r, uint8_t g, uint8_t b)returns uint32_tEine statische Hilfsfunktion, die Rot, Grün und Blau zu einem 32-Bit-Farbwert packt. Die Hilfsfunktion colorWheel() des Sketches verwendet sie, um eine Position auf dem Rad in eine Farbe umzuwandeln.
ReturnsDie gepackte Farbe, (r << 16) | (g << 8) | b.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
uint8_t | r | Rot, 0 bis 255. |
uint8_t | g | Grün, 0 bis 255. |
uint8_t | b | Blau, 0 bis 255. |
show()returns voidSendet die im Speicher gehaltenen Farben an die LEDs. Auf den meisten Boards schaltet sie kurzzeitig die Interrupts ab, um das Signaltiming einzuhalten, sodass millis() und micros() bei jedem Aufruf etwa 30 µs pro LED verlieren.
ReturnsNichts.
Alles zusammengesetzt
Jedes Bild wird auf dieselbe Weise gezeichnet: Ändern Sie die Pixel im Speicher mit clear() und setPixel(), rufen Sie dann einmal show() auf und warten Sie vor dem nächsten Bild. Das delay() nach jedem show() bestimmt die Geschwindigkeit. Ändern Sie also die Werte 80 und 10, um den Zeilendurchlauf oder den Regenbogen schneller oder langsamer zu machen. colorWheel() und die beiden Animationsfunktionen sind Teil des Sketches, nicht der Bibliothek.