Arduino TFT Rainbow Noise Display - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

Wir haben dieses Regenbogenprojekt mit verschiedenen "Noise"-Techniken erstellt, die kontrollierte Zufallseffekte erzeugen. Durch das Hinzufügen von etwas Farbe könnte ein Regenbogeneffekt erzeugt werden. Es verwendet einen Arduino Nano und ein 128x128 OLED-Display. Wir haben die Effekte mit der TFT-Bibliothek angezeigt. Wir haben auch einige verschiedene Komponenten wie ein Steckbrett und ein paar Drähte verwendet.

Schritt 1: Verkabelung

Die grundlegendste Aufgabe war die Verkabelung der OLED mit dem Arduino. Wir haben GND und VCC mit den entsprechenden Bussen auf dem Steckbrett verbunden; SCL an Digital-Pin 13; SDA auf Digital-Pin 11; RES zu digitalem Pin 8; DC an Digital-Pin 9; CS auf digitalen Pin 10 und schließlich BL auf 3.3V auf dem Arduino. Mit den 5V- und GND-Pins des Arduino konnten wir das gesamte Brotbrett mit Strom versorgen.

Schritt 2: Glattes Rauschen

Nach der Initialisierung der Voraussetzungen für das TFT-Display. Um den glatten Rauscheffekt zu erzeugen, benötigten wir zunächst eine grundlegende Rauschfunktion. Dies gibt einen relativ zufälligen Wert zwischen 0 und 1 zurück, basierend auf den übergebenen x- und y-Werten. Es ist wichtig zu beachten, dass ein Computer niemals ein wirklich zufälliges Ergebnis erzeugen kann und diese Zufälligkeit nur dadurch erreicht wird, dass die Zahl so weit wie möglich geändert wird, daher die sehr großen Zahlen in der Gleichung.

Float-Rauschen (int x, int y) {int n; n = x + y * 57; n += (n << 13) ^ n; zurück (1,0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7ffffff) / 1073741824.0); }

Wir „glätten“das Rauschen dann mit einer anderen Funktion. Dies wird erreicht, indem ein Wert erzeugt wird, der nicht nur auf dem Ergebnis der an die Funktion übergebenen Koordinate, sondern auch auf den umgebenden Koordinaten basiert. Infolgedessen ergeben nahe beieinander liegende Koordinaten einen ähnlichen Wert.

float smoothNoise (float x, float y) { float fractX = x - (int) x; float fractY = y - (int) y; int x1 = ((int) (x) + Rauschbreite) % Rauschbreite; int y1 = ((int) (y) + NoiseHeight) % NoiseHeight; int x2 = (x1 + Rauschbreite - 1) % Rauschbreite; int y2 = (y1 + NoiseHeight - 1) % NoiseHeight; Gleitkommawert = 0.0f; Wert += fractX * fractY * Rauschen (x1, y1); Wert += (1 - fractX) * fractY * Rauschen (x2, y1); Wert += fractX * (1 - fractY) * Rauschen(x1, y2); Wert += (1 - fractX) * (1 - fractY) * Rauschen (x2, y2); Rückgabewert; }

Schritt 3: Effekte mit glattem Rauschen

Damit haben wir zwei Effekte erzeugt. Dazu haben wir jedes Pixel auf der OLED durchlaufen und einen zufälligen Rauschwert basierend auf den x- und y-Koordinaten dieser Pixel genommen. Den ersten dieser Effekte haben wir erzeugt, indem wir den generierten Wert verwendet haben, um eine Farbe auszuwählen, und dieses Pixel mit der oben genannten Farbe gefärbt. Der zweite Effekt wurde auf ähnliche Weise erzeugt, allerdings haben wir die Farbe zusätzlich mit dem erzeugten Rauschwert multipliziert. Dies gab dem Muster einen schattierteren Effekt. Der verwendete Code wird unten angezeigt:

void Noise2n3(bool Noisy) { for (int y = 0; y < noiseHeight; y++) { for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour(Farben[absNoise], Rauschen); else setBlockColour(Farben[absNoise]); TFTscreen.point(x, y); aufrechtzuerhalten. aufrechtzuerhalten. aufrechtzuerhalten. Void setBlockColour (Farbfarbe) { TFTscreen.stroke (Farbe.rot, Farbe.grün, Farbe.blau); }

Schritt 4: Zufällige Farbverlaufseffekte

Es gibt zwei Effekte, die einen zufälligen Farbverlauf erzeugen. Der erste Effekt platziert die Pixel in Relation zu ihrer RGB-Farbe und gibt langsam ein Verlaufsmuster auf dem Bildschirm wieder. Der zweite verwendet die gleichen farbigen Pixel wie der erste, platziert sie jedoch in einer festen Reihenfolge, wodurch ein diagonaler Farbverlauf entlang des Bildschirms entsteht.

Hier ist die erste (basierend auf den Farben):

Void Noise1 () { for (int z = 0; z < 3; z ++) { TFTscreen.background (0, 0, 0); int Aktuelle Farbe[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Aktuelle Farbe[z][0]; G = Aktuelle Farbe[z][1]; B = Aktuelle Farbe[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) {int R_Lower = R - ((x + y) / 4); if(R_Lower = 255) {R_Higher = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); if(G_Lower = 255) {G_Higher = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); if(B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); if(B_Higher>= 255) {B_Higher = 254; } int B_Offset = random(B_Lower, B_Higher); int mult = 2; wenn (z == 1) mult = 1; TFTscreen.stroke(R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point((R_Offset * (B_Offset / 32)), (G_Offset * (B_Offset / 32))); TFTscreen.point((G_Offset * (B_Offset / 32)), (R_Offset * (B_Offset / 32))); TFTscreen.point((B_Offset * (G_Offset / 32)), (R_Offset * (G_Offset / 32))); } } } }

Und der zweite (der geordnetere Effekt):

Void Noise4 () { for (int z = 0; z < 3; z ++) { TFTscreen.background (0, 0, 0); int Aktuelle Farbe[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Aktuelle Farbe[z][0]; G = Aktuelle Farbe[z][1]; B = Aktuelle Farbe[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) {int R_Lower = R - ((x + y) / 4); if(R_Lower = 255) {R_Higher = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); if(G_Lower = 255) {G_Higher = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); if(B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); if(B_Higher>= 255) {B_Higher = 254; } int B_Offset = random(B_Lower, B_Higher); int mult = 2; wenn (z == 1) mult = 1; TFTscreen.stroke(R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point(x, y); } } } }

Schritt 5: Das Endergebnis

Am Ende haben wir diese Effekte zu einer Art „Diashow“von Regenbögen kombiniert. Dazu haben wir einfach jede Funktion nach der anderen in einer while-Schleife aufgerufen:

while (wahr) { Noise2n3 (false); Rauschen2n3(wahr); TFTscreen.background (0, 0, 0); Rauschen1(); Rauschen4(); }