Arduino TFT Rainbow Noise Display: 5 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Ezt a szivárványos projektet különböző „zaj” technikák segítségével hoztuk létre, amelyek szabályozott véletlenszerű hatásokat hoznak létre. Némi szín hozzáadásával szivárványos hatás érhető el. Arduino Nano és 128x128 OLED kijelzőt használ. Az effekteket a TFT könyvtár használatával jelenítettük meg. Különféle alkatrészeket is használtunk, például kenyértáblát és néhány vezetéket.

1. lépés: Kábelezés

A legalapvetőbb feladat az OLED és az Arduino csatlakoztatása volt. Csatlakoztattuk a GND -t és a VCC -t a megfelelő buszokhoz a kenyértáblán; SCL a 13 -as digitális tüskéhez; SDA - 11 -es digitális tű; RES a 8. digitális tüskéhez; DC - 9 -es digitális tüske; CS a digitális 10 -es tűre és végül BL -re 3,3 V -ra az Arduino -n. Az Arduino 5v és GND csapjaival a teljes kenyértáblát tápellátni tudtuk.

2. lépés: Sima zaj

A TFT kijelzőre vonatkozó követelmények inicializálása után. A sima zajhatás létrehozásához először egy alapvető zajfunkcióra volt szükségünk. Ez egy viszonylag véletlenszerű értéket ad vissza 0 és 1 között a beadott x és y értékek alapján. Fontos megjegyezni, hogy egy számítógép soha nem tud igazán véletlenszerű eredményt produkálni, és ezt a véletlenszerűséget csak a szám lehető legnagyobb megváltoztatásával lehet elérni, ezért az egyenlet nagyon nagy számai.

lebegési zaj (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); }

Ezután egy másik funkcióval „simítjuk” a zajt. Ezt úgy érjük el, hogy nem csak a függvénybe átadott koordináta eredményén alapuló értéket állítunk elő, hanem a környező koordinátákat is. Ennek eredményeként az egymáshoz közeli koordináták hasonló értéket produkálnak.

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) + zajHeight) % noiseHeight; int x2 = (x1 + noiseWidth - 1) % noiseWidth; int y2 = (y1 + zajHeight - 1) % noiseHeight; úszó érték = 0,0f; érték += fractX * fractY * zaj (x1, y1); érték += (1 - fractX) * fractY * zaj (x2, y1); érték += fractX * (1 - fractY) * zaj (x1, y2); érték += (1 - fractX) * (1 - fractY) * zaj (x2, y2); visszatérési érték; }

3. lépés: Hatások a sima zaj használatával

Ezzel két effektust hoztunk létre. Ehhez végighurkoltuk az OLED minden egyes képpontját, és véletlenszerű zajértéket vettünk e képpontok x és y koordinátái alapján. Ezek közül az első effektust úgy állítottuk elő, hogy a generált értéket használva választottuk ki a színt, és ezt a képpontot a fent említett színnel színeztük. A második effektus hasonló módon jött létre, de a színt is megszoroztuk a generált zajértékkel. Ez árnyaltabb hatást adott a mintának. A használt kód az alábbiakban látható:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Zajos) setNoisyColour (színek [absNoise], zaj); else setBlockColour (színek [absNoise]); TFT -képernyő.pont (x, y); }}} void setNoisyColour (Színes szín, lebegő zaj) {TFTscreen.stroke (szín.piros * zaj, szín.zöld * zaj, szín.kék * zaj); } void setBlockColour (Színes szín) {TFTscreen.stroke (szín.piros, szín.zöld, szín.kék); }

4. lépés: Véletlenszerű színátmenetek

Két effektus véletlenszerű színátmenetet eredményez. Az első effektus a képpontokat az rgb színükhöz viszonyítva helyezi el, lassan gradiens mintázatot adva a képernyőnek. A második ugyanazokat a színes képpontokat használja, mint az első, de rögzített sorrendben helyezi el őket, átlós színátmenetet hozva létre a képernyő mentén.

Íme az első (a színek alapján):

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 = Aktuális szín [z] [0]; G = Aktuális szín [z] [1]; B = Aktuális szín [z] [2]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); ha (R_alsó = 255) {R_magasabb = 254; } int R_Offset = véletlenszerű (R_alsó, R_magasabb); int G_alsó = G - ((x + y) / 4); ha (G_alsó = 255) {G_magasabb = 254; } int G_Offset = véletlenszerű (G_alsó, G_magasabb); int B_alsó = B - ((x + y) / 4); ha (B_alsó <1) {B_alsó = 0; } int B_magasabb = B + ((x + y) / 4); ha (B_magasabb> = 255) {B_magasabb = 254; } int B_Offset = véletlenszerű (B_alsó, B_magasabb); int mult = 2; ha (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))); }}}}

És a második (a rendezettebb hatás):

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 = Aktuális szín [z] [0]; G = Aktuális szín [z] [1]; B = Aktuális szín [z] [2]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); ha (R_alsó = 255) {R_magasabb = 254; } int R_Offset = véletlenszerű (R_alsó, R_magasabb); int G_alsó = G - ((x + y) / 4); ha (G_alsó = 255) {G_magasabb = 254; } int G_Offset = véletlenszerű (G_alsó, G_magasabb); int B_alsó = B - ((x + y) / 4); ha (B_alsó <1) {B_alsó = 0; } int B_magasabb = B + ((x + y) / 4); ha (B_magasabb> = 255) {B_magasabb = 254; } int B_Offset = véletlenszerű (B_alsó, B_magasabb); int mult = 2; ha (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFT -képernyő.pont (x, y); }}}}

5. lépés: A végeredmény

Végül ezeket a hatásokat egyesítettük a szivárványok „diavetítésévé”. Ennek eléréséhez egyszerűen hívtuk az egyes függvényeket a másik után egy ciklusban:

while (igaz) {Noise2n3 (false); Zaj2n3 (igaz); TFTscreen.background (0, 0, 0); Zaj1 (); Zaj4 (); }