Wyświetlacz Arduino TFT Rainbow Noise: 5 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

Ten tęczowy projekt stworzyliśmy przy użyciu różnych technik „szumu”, które tworzą kontrolowane efekty losowe. Dodając trochę koloru, można było uzyskać efekt tęczy. Wykorzystuje Arduino Nano i wyświetlacz OLED 128x128. Efekty pokazaliśmy za pomocą biblioteki TFT. Użyliśmy również różnych elementów, takich jak deska do krojenia chleba i kilka drutów.

Krok 1: Okablowanie

Najbardziej podstawowym zadaniem było podłączenie OLED do Arduino. Podłączyliśmy GND i VCC do odpowiednich szyn na płycie chlebowej; SCL do cyfrowego pinu 13; SDA do pinu cyfrowego 11; RES do cyfrowego pinu 8; DC do pinu cyfrowego 9; CS do cyfrowego pinu 10 i wreszcie BL do 3,3V na Arduino. Za pomocą pinów 5v i GND z Arduino byliśmy w stanie zasilić całą płytkę chleba.

Krok 2: Gładki Hałas

Po zainicjowaniu wymagań dotyczących wyświetlacza TFT. Aby stworzyć efekt gładkiego szumu, potrzebowaliśmy najpierw podstawowej funkcji szumu. Zwraca to względnie losową wartość z zakresu od 0 do 1 na podstawie przekazanych wartości x i y. Należy zauważyć, że komputer nigdy nie może wygenerować prawdziwie losowego wyniku, a tę losowość uzyskuje się jedynie poprzez zmianę liczby tak bardzo, jak to możliwe, stąd bardzo duże liczby w równaniu.

szum pływający (int x, int y){ int n; n = x + y * 57; n += (n << 13) ^ n; zwrot (1,0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824,0); }

Następnie „wygładzamy” hałas inną funkcją. Osiąga się to poprzez wygenerowanie wartości opartej nie tylko na wyniku ze współrzędnej przekazanej do funkcji, ale także na otaczających współrzędnych. W wyniku tego współrzędne znajdujące się blisko siebie dają zbliżoną wartość.

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; wartość zmiennoprzecinkowa = 0,0f; wartość += fractX * fractY * szum(x1, y1); wartość += (1 - fractX) * fractY * szum(x2, y1); wartość += fractX * (1 - fractY) * szum(x1, y2); wartość += (1 - fractX) * (1 - fractY) * szum(x2, y2); zwracana wartość; }

Krok 3: Efekty przy użyciu gładkiego szumu

Dzięki temu stworzyliśmy dwa efekty. Aby to zrobić, zapętliliśmy każdy piksel na OLED i wzięliśmy losową wartość szumu na podstawie współrzędnych x i y tych pikseli. Pierwszy z tych efektów stworzyliśmy, używając wygenerowanej wartości do wybrania koloru i pokolorowania tego piksela wspomnianym kolorem. Drugi efekt został wytworzony w podobny sposób, ale pomnożyliśmy też kolor przez wartość generowanego szumu. Dało to wzórowi bardziej zacieniony efekt. Użyty kod pokazano poniżej:

void Noise2n3(bool Noisy){ for (int y = 0; y < noiseHeight; y++) { for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour(kolory[absNoise], szum); else setBlockColour(kolory[absNoise]); TFTscreen.punkt(x, y); } } } void setNoisyColour(Color color, float noise) { TFTscreen.stroke(kolor.czerwony * szum, kolor.zielony * szum, kolor.niebieski * szum); } void setBlockColour(Kolor koloru) { TFTscreen.stroke(kolor.czerwony, kolor.zielony, kolor.niebieski); }

Krok 4: Losowe efekty gradientowe

Istnieją dwa efekty, które generują losowy gradient. Pierwszy efekt umieszcza piksele w stosunku do ich koloru rgb, powoli renderując na ekranie wzór gradientu. Drugi używa tych samych kolorowych pikseli, co pierwszy, ale umieszcza je w ustalonej kolejności, tworząc ukośny gradient wzdłuż ekranu.

Oto pierwszy (na podstawie kolorów):

void Noise1(){ for(int z = 0; z < 3; z++) { TFTscreen.background (0, 0, 0); int AktualnyKolor[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = BieżącyKolor[z][0]; G = BieżącyKolor[z][1]; B = BieżącyKolor[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) { int R_Dolny = R - ((x + y) / 4); jeśli(R_Niższe = 255) { R_Wyższe = 254; } int R_Offset = random(R_Niższy, R_Wyższy); int G_Dolny = G - ((x + y) / 4); if(G_Niższy = 255) { G_Wyższy = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Dolny = B - ((x + y) / 4); if(B_Dolny <1) { B_Dolny = 0; } int B_Wyższe = B + ((x + y) / 4); if(B_Wyższe>= 255) { B_Wyższe = 254; } int B_Offset = random(B_Lower, B_Higher); mnożnik = 2; jeśli (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 drugi (efekt bardziej uporządkowany):

void Noise4(){ for(int z = 0; z < 3; z++) { TFTscreen.background (0, 0, 0); int AktualnyKolor[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = BieżącyKolor[z][0]; G = BieżącyKolor[z][1]; B = BieżącyKolor[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) { int R_Dolny = R - ((x + y) / 4); jeśli(R_Niższe = 255) { R_Wyższe = 254; } int R_Offset = random(R_Niższy, R_Wyższy); int G_Dolny = G - ((x + y) / 4); if(G_Niższy = 255) { G_Wyższy = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Dolny = B - ((x + y) / 4); if(B_Dolny <1) { B_Dolny = 0; } int B_Wyższe = B + ((x + y) / 4); if(B_Wyższe>= 255) { B_Wyższe = 254; } int B_Offset = random(B_Lower, B_Higher); mnożnik = 2; jeśli (z == 1) mult = 1; TFTscreen.stroke(R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.punkt(x, y); } } } }

Krok 5: Ostateczny wynik

W końcu połączyliśmy te efekty w coś w rodzaju „pokazu slajdów” tęczy. Aby to osiągnąć, po prostu wywołaliśmy każdą funkcję po drugiej w pętli while:

while (prawda) { Szum2n3(fałsz); Szum2n3(prawda); TFTscreen.background(0, 0, 0); Hałas1(); Hałas4(); }