Display del rumore arcobaleno TFT Arduino: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Abbiamo creato questo progetto arcobaleno utilizzando varie tecniche di "rumore", che creano effetti casuali controllati. Aggiungendo un po' di colore, si potrebbe produrre un effetto arcobaleno. Utilizza un Arduino Nano e un display OLED 128x128. Abbiamo visualizzato gli effetti utilizzando la libreria TFT. Abbiamo anche usato alcuni componenti vari come una breadboard e alcuni fili.

Passaggio 1: cablaggio

Il compito più elementare era il cablaggio dell'OLED all'Arduino. Abbiamo collegato GND e VCC ai rispettivi bus sulla breadboard; SCL al pin 13 digitale; SDA al pin digitale 11; RES al pin digitale 8; DC al pin digitale 9; CS al pin 10 digitale e infine BL a 3.3V su Arduino. Usando i pin 5v e GND di Arduino siamo stati in grado di alimentare l'intera breadboard.

Passaggio 2: rumore uniforme

Dopo aver inizializzato i requisiti per il display TFT. Per creare l'effetto di rumore uniforme, avevamo prima bisogno di una funzione di rumore di base. Questo restituisce un valore relativamente casuale tra 0 e 1 in base ai valori x e y passati. È importante notare che un computer non può mai produrre un risultato veramente casuale e questa casualità si ottiene semplicemente cambiando il numero il più possibile, quindi i numeri molto grandi nell'equazione.

rumore float (int x, int y){ int n; n = x + y * 57; n += (n << 13) ^ n; ritorno (1.0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); }

Quindi "attenuiamo" il rumore con un'altra funzione. Ciò si ottiene producendo un valore basato non solo sul risultato della coordinata passata alla funzione, ma anche sulle coordinate circostanti. Di conseguenza, le coordinate vicine tra loro producono un valore simile.

float smoothNoise(float x, float y){ float fractX = x - (int) x; float fractY = y - (int) y; int x1 = ((int) (x) + noiseWidth) % noiseWidth; int y1 = ((int) (y) + noiseHeight) % noiseHeight; int x2 = (x1 + noiseWidth - 1) % noiseWidth; int y2 = (y1 + noiseHeight - 1) % noiseHeight; valore float = 0.0f; valore += fractX * fractY * noise(x1, y1); valore += (1 - fractX) * fractY * noise(x2, y1); valore += fractX * (1 - fractY) * rumore(x1, y2); valore += (1 - fractX) * (1 - fractY) * rumore(x2, y2); valore di ritorno; }

Passaggio 3: effetti che utilizzano il rumore uniforme

Con questo abbiamo creato due effetti. Per fare ciò, abbiamo eseguito il loop di ciascun pixel sull'OLED e preso un valore di rumore casuale basato sulle coordinate x e y di questi pixel. Il primo di questi effetti l'abbiamo prodotto usando il valore generato per scegliere un colore e colorato quel pixel con il colore sopra menzionato. Il secondo effetto è stato prodotto in modo simile, ma abbiamo anche moltiplicato il colore per il valore del rumore generato. Ciò ha conferito al motivo un effetto più sfumato. Il codice utilizzato è mostrato di seguito:

void Noise2n3(bool Noisy){ for (int y = 0; y < noiseHeight; y++) { for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour(colours[absNoise], noise); else setBlockColour(colours[absNoise]); TFTscreen.point(x, y); } } } void setNoisyColour(Colour color, float noise) { TFTscreen.stroke(colour.red * noise, color.green * noise, color.blue * noise); } void setBlockColour(Colore colore) { TFTscreen.stroke(colore.rosso, colore.verde, colore.blu); }

Passaggio 4: effetti sfumati casuali

Ci sono due effetti che producono un gradiente casuale. Il primo effetto posiziona i pixel in relazione al loro colore rgb, rendendo lentamente uno schema sfumato sullo schermo. Il secondo utilizza gli stessi pixel colorati del primo, ma li dispone in un ordine fisso, creando un gradiente diagonale lungo lo schermo.

Ecco il primo (in base ai colori):

void Noise1(){ for(int z = 0; z < 3; z++) { TFTscreen.background(0, 0, 0); int CurrentColour[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = ColoreAttuale[z][0]; G = ColoreAttuale[z][1]; B = ColoreAttuale[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_Inferiore = 255) { R_Inferiore = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Inferiore = G - ((x + y) / 4); if(G_Inferiore = 255) { G_Inferiore = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); if(B_Inferiore <1) { B_Inferiore = 0; } int B_Più alto = B + ((x + y) / 4); if(B_Higher>= 255) { B_Higher = 254; } int B_Offset = random(B_Lower, B_Higher); int multi = 2; se (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))); } } } }

E il secondo (l'effetto più ordinato):

void Noise4(){ for(int z = 0; z < 3; z++) { TFTscreen.background(0, 0, 0); int CurrentColour[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = ColoreAttuale[z][0]; G = ColoreAttuale[z][1]; B = ColoreAttuale[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_Inferiore = 255) { R_Inferiore = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Inferiore = G - ((x + y) / 4); if(G_Inferiore = 255) { G_Inferiore = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); if(B_Inferiore <1) { B_Inferiore = 0; } int B_Più alto = B + ((x + y) / 4); if(B_Higher>= 255) { B_Higher = 254; } int B_Offset = random(B_Lower, B_Higher); int multi = 2; se (z == 1) mult = 1; TFTscreen.stroke(R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point(x, y); } } } }

Passaggio 5: il risultato finale

Alla fine, abbiamo combinato questi effetti in una sorta di 'slideshow' di arcobaleni. Per ottenere ciò, abbiamo semplicemente chiamato ogni funzione dopo l'altra in un ciclo while:

while (vero) { Noise2n3(falso); Rumore2n3(vero); TFTscreen.background(0, 0, 0); Rumore1(); Rumore4(); }