Arduino TFT Rainbow Noise Display: 5 vaihetta

2024 Kirjoittaja: John Day | [email protected]. Viimeksi muokattu: 2024-01-30 09:01

Loimme tämän sateenkaariprojektin käyttämällä erilaisia "kohina" -tekniikoita, jotka luovat kontrolloituja satunnaistehosteita. Lisäämällä väriä saatiin aikaan sateenkaariefekti. Se käyttää Arduino Nanoa ja 128 x 128 OLED -näyttöä. Näytimme tehosteet TFT -kirjaston avulla. Käytimme myös joitain sekalaisia komponentteja, kuten leipätaulua ja muutamia johtoja.

Vaihe 1: Johdotus

Perustehtävä oli OLED -johdotus Arduinoon. Yhdistimme GND: n ja VCC: n vastaaviin väyliin leipälevyllä; SCL digitaaliseen nastaan 13; SDA digitaaliseen nastaan 11; RES digitaaliseen nastaan 8; DC -digitaalitappi 9; CS digitaaliseen nastaan 10 ja lopulta BL 3,3 V: iin Arduinolla. Arduinon 5v- ja GND -nastojen avulla saimme virtaa koko leipälevylle.

Vaihe 2: Tasainen melu

Kun TFT -näytön vaatimukset on alustettu. Tasaisen kohinan luomiseksi tarvitsimme ensin peruskohinatoiminnon. Tämä palauttaa suhteellisen satunnaisen arvon välillä 0 ja 1 syötettyjen x- ja y -arvojen perusteella. On tärkeää huomata, että tietokone ei voi koskaan tuottaa todella satunnaista tulosta, ja tämä satunnaisuus saavutetaan vain muuttamalla lukua mahdollisimman paljon, siis yhtälön erittäin suuret luvut.

kelluva melu (int x, int y) {int n; n = x + y * 57; n += (n << 13) ^ n; paluu (1,0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); }

Tasoitamme sitten kohinaa toisella toiminnolla. Tämä saavutetaan tuottamalla arvo, joka perustuu paitsi funktioon syötetyn koordinaatin tulokseen myös ympäröiviin koordinaatteihin. Tämän seurauksena toistensa lähellä olevat koordinaatit tuottavat samanlaisen arvon.

float smoothNoise (float x, float y) {float fractX = x - (int) x; kellukemurtumaY = y - (int) y; int x1 = ((int) (x) + kohinaleveys) % kohinaleveys; int y1 = ((int) (y) + meluKorkeus) % kohinaaKorkeus; int x2 = (x1 + kohinaleveys - 1) kohinaleveys %; int y2 = (y1 + noiseHeight - 1) % noiseHeight; kelluva arvo = 0,0f; arvo += fractX * fractY * kohina (x1, y1); arvo += (1 - fractX) * fractY * kohina (x2, y1); arvo += fractX * (1 - fractY) * kohina (x1, y2); arvo += (1 - fractX) * (1 - fractY) * kohina (x2, y2); palautusarvo; }

Vaihe 3: Tehosteet tasaisen kohinan avulla

Tämän avulla loimme kaksi tehostetta. Tätä varten selasimme jokaisen OLED -pikselin läpi ja otimme satunnaisen kohina -arvon näiden pikselien x- ja y -koordinaattien perusteella. Ensimmäinen näistä tehosteista tuotettiin käyttämällä generoitua arvoa värin valitsemiseksi ja värjäsi pikselin edellä mainitulla värillä. Toinen vaikutus tehtiin samalla tavalla, mutta kerroimme myös värin syntyneellä kohina -arvolla. Tämä antoi kuviolle tummemman vaikutelman. Käytetty koodi on esitetty alla:

tyhjä Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour (värit [absNoise], kohina); else setBlockColour (värit [absNoise]); TFT -näyttö.piste (x, y); }}} void setNoisyColour (värin väri, kelluva kohina) {TFTscreen.stroke (väri.punainen * kohina, väri.vihreä * melu, väri.sininen * kohina); } void setBlockColour (värin väri) {TFT -näyttö.viiva (väri.punainen, väri.vihreä, väri.sininen); }

Vaihe 4: Satunnaiset kaltevuusvaikutukset

On kaksi tehostetta, jotka tuottavat satunnaisen kaltevuuden. Ensimmäinen tehoste asettaa pikselit suhteessa niiden rgb -väriin ja tekee näytöstä hitaasti kaltevuuskuvion. Toinen käyttää samoja värillisiä pikseleitä kuin ensimmäinen, mutta sijoittaa ne kiinteään järjestykseen ja luo diagonaalisen kaltevuuden pitkin näyttöä.

Tässä ensimmäinen (värien perusteella):

void Noise1 () {for (int z = 0; z <3; z ++) {TFTscreen.background (0, 0, 0); int Nykyinen väri [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Nykyinen väri [z] [0]; G = Nykyinen väri [z] [1]; B = Nykyinen väri [z] [2]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); jos (R_Lower = 255) {R_Higher = 254; } int R_Offset = satunnainen (R_Lower, R_Higher); int G_Alempi = G - ((x + y) / 4); jos (G_Lower = 255) {G_Higher = 254; } int G_Offset = satunnainen (G_Lower, G_Higher); int B_Alempi = B - ((x + y) / 4); jos (B_Alempi <1) {B_Alempi = 0; } int B_Korkeampi = B + ((x + y) / 4); jos (B_Higher> = 255) {B_Higher = 254; } int B_Offset = satunnainen (B_Lower, B_Higher); int mult = 2; jos (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFT -näyttö.piste ((R_Offset * (B_Offset / 32)), (G_Offset * (B_Offset / 32))); TFT -näyttö.piste (((G_Offset * (B_Offset / 32)), (R_Offset * (B_Offset / 32))); TFT -näyttö.piste ((B_Offset * (G_Offset / 32)), (R_Offset * (G_Offset / 32))); }}}}

Ja toinen (järjestelmällisempi vaikutus):

void Noise4 () {for (int z = 0; z <3; z ++) {TFTscreen.background (0, 0, 0); int Nykyinen väri [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Nykyinen väri [z] [0]; G = Nykyinen väri [z] [1]; B = Nykyinen väri [z] [2]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); jos (R_Lower = 255) {R_Higher = 254; } int R_Offset = satunnainen (R_Lower, R_Higher); int G_Alempi = G - ((x + y) / 4); jos (G_Alempi = 255) {G_Korkea = 254; } int G_Offset = satunnainen (G_Lower, G_Higher); int B_Alempi = B - ((x + y) / 4); jos (B_Alempi <1) {B_Alempi = 0; } int B_Korkea = B + ((x + y) / 4); jos (B_Higher> = 255) {B_Higher = 254; } int B_Offset = satunnainen (B_Lower, B_Higher); int mult = 2; jos (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFT -näyttö.piste (x, y); }}}}

Vaihe 5: Lopputulos

Lopulta yhdistimme nämä tehosteet eräänlaiseksi sateenkaarien "diaesitykseksi". Tämän saavuttamiseksi kutsuimme yksinkertaisesti jokaisen funktion peräkkäin jonkin aikaa:

while (tosi) {Noise2n3 (false); Noise2n3 (totta); TFT -näyttö. Tausta (0, 0, 0); Melu1 (); Melu4 (); }