Arduino TFT mavrični hrupni zaslon: 5 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:04

Ta mavrični projekt smo ustvarili z uporabo različnih tehnik "hrupa", ki ustvarjajo nadzorovane naključne učinke. Z dodajanjem barve lahko nastane mavrični učinek. Uporablja Arduino Nano in zaslon OLED velikosti 128x128. Učinke smo prikazali s knjižnico TFT. Uporabili smo tudi različne komponente, kot so deska za kruh in nekaj žic.

1. korak: Ožičenje

Najosnovnejša naloga je bila ožičenje OLED -a na Arduino. GND in VCC smo povezali z ustreznimi vodili na plošči za kruh; SCL na digitalni pin 13; SDA na digitalni pin 11; RES na digitalni pin 8; Enosmerni tok na digitalni pin 9; CS na digitalni pin 10 in končno BL na 3.3V na Arduinu. Z uporabo zatičev 5v in GND iz Arduina smo lahko napajali celotno ploščo za kruh.

2. korak: gladek hrup

Po inicializaciji zahtev za zaslon TFT. Za ustvarjanje gladkega učinka hrupa smo najprej potrebovali osnovno funkcijo hrupa. To vrne sorazmerno naključno vrednost med 0 in 1 glede na prenesene vrednosti x in y. Pomembno je omeniti, da računalnik nikoli ne more dati resnično naključnega rezultata, to naključnost pa dosežemo le s čim večjo spremembo števila, zato zelo velika števila v enačbi.

plavajoči hrup (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); }

Nato z drugo funkcijo 'zgladimo' hrup. To se doseže z ustvarjanjem vrednosti, ki ne temelji le na rezultatu iz koordinate, prenesene v funkcijo, ampak tudi na okoliške koordinate. Zaradi tega koordinate v bližini drug drugega proizvajajo podobno vrednost.

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; plavajoča vrednost = 0,0f; vrednost += fractX * fractY * hrup (x1, y1); vrednost += (1 - fractX) * fractY * hrup (x2, y1); vrednost += fractX * (1 - fractY) * hrup (x1, y2); vrednost += (1 - fractX) * (1 - fractY) * hrup (x2, y2); vrnjena vrednost; }

3. korak: Učinki z uporabo gladkega hrupa

S tem smo ustvarili dva učinka. Če želite to narediti, smo prešli skozi vsako slikovno piko na OLED in vzeli naključno vrednost šuma na podlagi koordinat x in y teh slikovnih pik. Prvi od teh učinkov smo ustvarili z uporabo ustvarjene vrednosti za izbiro barve in obarvali to slikovno piko z omenjeno barvo. Drugi učinek je bil ustvarjen na podoben način, vendar smo tudi barvo pomnožili z ustvarjeno vrednostjo hrupa. To je dalo vzorcu bolj senčen učinek. Uporabljena koda je prikazana spodaj:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour (barve [absNoise], šum); else setBlockColour (barve [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (barvna barva, plavajoči hrup) {TFTscreen.stroke (barva. rdeča * hrup, barva.zelena * hrup, barva.modra * hrup); } void setBlockColour (barvna barva) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

4. korak: Naključni gradientni učinki

Obstajata dva učinka, ki tvorita naključni naklon. Prvi učinek postavlja slikovne pike glede na njihovo barvo rgb in počasi upodablja vzorec gradienta na zaslonu. Drugi uporablja iste barvne pike kot prvi, vendar jih postavi v fiksnem vrstnem redu in ustvari diagonalni naklon vzdolž zaslona.

Tu je prvi (glede na barve):

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 = Trenutna barva [z] [0]; G = Trenutna barva [z] [1]; B = Trenutna barva [z] [2]; za (int x = 0; x <128; x ++) {za (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); če (R_Lower = 255) {R_Higher = 254; } int R_Offset = naključno (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); če (G_Lower = 255) {G_Higher = 254; } int G_Offset = naključno (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); če (B_Lower <1) {B_Lower = 0; } int B_Višja = B + ((x + y) / 4); če (B_Višja> = 255) {B_Višja = 254; } int B_Offset = naključno (B_Lower, B_Higher); int mult = 2; če (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))); }}}}

In drugi (bolj urejen učinek):

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 = Trenutna barva [z] [0]; G = Trenutna barva [z] [1]; B = Trenutna barva [z] [2]; za (int x = 0; x <128; x ++) {za (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); če (R_Lower = 255) {R_Higher = 254; } int R_Offset = naključno (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); če (G_Lower = 255) {G_Higher = 254; } int G_Offset = naključno (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); če (B_Lower <1) {B_Lower = 0; } int B_Višja = B + ((x + y) / 4); če (B_Višja> = 255) {B_Višja = 254; } int B_Offset = naključno (B_Lower, B_Higher); int mult = 2; če (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

5. korak: Končni rezultat

Na koncu smo te učinke združili v nekakšno "diaprojekcijo" mavric. Da bi to dosegli, smo preprosto poklikli vsako funkcijo za drugo v zanki while:

while (true) {Noise2n3 (false); Noise2n3 (res); TFTscreen.background (0, 0, 0); Hrup1 (); Hrup4 (); }