Afișaj Arduino TFT Rainbow Noise: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Am creat acest proiect curcubeu folosind diverse tehnici de „zgomot”, care creează efecte aleatorii controlate. Prin adăugarea unor culori, s-ar putea produce un efect curcubeu. Folosește un Arduino Nano și un ecran OLED de 128x128. Am afișat efectele folosind biblioteca TFT. De asemenea, am folosit câteva componente diverse, cum ar fi o placă de pâine și câteva fire.

Pasul 1: Cablare

Sarcina cea mai de bază a fost conectarea OLED la Arduino. Am conectat GND și VCC la autobuzele respective de pe placa de pâine; SCL la pinul digital 13; SDA la pinul digital 11; RES la pinul digital 8; DC la pinul digital 9; CS la pinul digital 10 și în cele din urmă BL la 3,3V pe Arduino. Folosind pinii 5v și GND de la Arduino am reușit să alimentăm întreaga placă de pâine.

Pasul 2: Zgomot neted

După inițializarea cerințelor pentru afișajul TFT. Pentru a crea un efect de zgomot lin, am avut nevoie mai întâi de o funcție de zgomot de bază. Aceasta returnează o valoare relativ aleatorie între 0 și 1 pe baza valorilor x și y transmise. Este important de reținut că un computer nu poate produce niciodată un rezultat cu adevărat aleatoriu, iar această aleatorie este atinsă doar prin schimbarea numărului cât mai mult posibil, de unde și numerele foarte mari din ecuație.

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

Apoi „netezim” zgomotul cu o altă funcție. Acest lucru se realizează prin producerea unei valori bazate nu numai pe rezultatul din coordonatele trecute în funcție, ci și pe coordonatele din jur. Ca urmare, coordonatele apropiate unele de altele produc o valoare similară.

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; valoare float = 0,0f; valoare + = fractX * fractY * zgomot (x1, y1); valoare + = (1 - fractX) * fractY * zgomot (x2, y1); valoare + = fractX * (1 - fractY) * zgomot (x1, y2); valoare + = (1 - fractX) * (1 - fractY) * zgomot (x2, y2); valoare returnată; }

Pasul 3: Efecte folosind zgomot neted

Cu aceasta am creat două efecte. Pentru a face acest lucru, am parcurs fiecare pixel de pe OLED și am luat o valoare aleatorie a zgomotului pe baza coordonatelor x și y ale acestor pixeli. Primul dintre aceste efecte l-am produs folosind valoarea generată pentru a alege o culoare și am colorat acel pixel cu culoarea menționată mai sus. Al doilea efect a fost produs într-un mod similar, dar am înmulțit și culoarea cu valoarea zgomotului generat. Acest lucru a dat modelului un efect mai umbrit. Codul utilizat este prezentat mai jos:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour (culori [absNoise], zgomot); else setBlockColour (culori [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (Color color, float noise) {TFTscreen.stroke (colour.red * noise, colour.green * noise, colour.blue * noise); } void setBlockColour (Color color) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

Pasul 4: Efecte gradiente aleatorii

Există două efecte care produc un gradient aleatoriu. Primul efect plasează pixelii în raport cu culoarea lor rgb, redând încet un model de gradient pe ecran. Al doilea folosește aceiași pixeli colorați ca primul, dar îi plasează într-o ordine fixă, creând un gradient diagonal de-a lungul ecranului.

Iată prima (bazată pe culori):

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 = CurrentColour [z] [0]; G = ColorCurrent [z] [1]; B = CurrentColour [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_Mai jos = B - ((x + y) / 4); if (B_Mai jos <1) {B_Mai jos = 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; if (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))); }}}}

Și al doilea (efectul mai ordonat):

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 = CurrentColour [z] [0]; G = ColorCurrent [z] [1]; B = CurrentColour [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_Mai jos = B - ((x + y) / 4); if (B_Mai jos <1) {B_Mai jos = 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; if (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

Pasul 5: Rezultatul final

În cele din urmă, am combinat aceste efecte într-un fel de „prezentare” de curcubee. Pentru a realiza acest lucru, am numit pur și simplu fiecare funcție după cealaltă într-o buclă while:

while (adevărat) {Noise2n3 (fals); Noise2n3 (adevărat); TFTscreen.background (0, 0, 0); Noise1 (); Noise4 (); }