Arduino TFT Rainbow Noise Display: 5 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Vi skabte dette regnbue projekt ved hjælp af forskellige 'støj' teknikker, som skaber kontrollerede tilfældige effekter. Ved at tilføje noget farve kan der frembringes en regnbueeffekt. Den bruger en Arduino Nano og en 128x128 OLED -skærm. Vi viste effekterne ved hjælp af TFT -biblioteket. Vi brugte også nogle forskellige komponenter såsom et brødbræt og et par ledninger.

Trin 1: Ledningsføring

Den mest grundlæggende opgave var ledningen af OLED til Arduino. Vi sluttede GND og VCC til de respektive busser på brødbrættet; SCL til digital pin 13; SDA til digital pin 11; RES til digital pin 8; DC til digital pin 9; CS til digital pin 10 og til sidst BL til 3.3V på Arduino. Ved hjælp af 5v- og GND -benene fra Arduino kunne vi drive hele brødbrættet.

Trin 2: Glat støj

Efter initialisering af kravene til TFT -skærmen. For at skabe den glatte støjeffekt havde vi først brug for en grundlæggende støjfunktion. Dette returnerer en relativt tilfældig værdi mellem 0 og 1 baseret på de x- og y -værdier, der er indsendt. Det er vigtigt at bemærke, at en computer aldrig kan producere et virkelig tilfældigt resultat, og denne tilfældighed opnås blot ved at ændre tallet så meget som muligt, derfor de meget store tal i ligningen.

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); }

Vi 'glatter' derefter støjen med en anden funktion. Dette opnås ved at producere en værdi, der ikke kun er baseret på resultatet fra den koordinat, der blev sendt til funktionen, men også de omgivende koordinater. Som et resultat af dette producerer koordinater i nærheden af hinanden en lignende værdi.

float smoothNoise (float x, float y) {float fractX = x - (int) x; flydefraktY = 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; flydeværdi = 0,0f; værdi += fractX * fractY * støj (x1, y1); værdi += (1 - fraktX) * fraktY * støj (x2, y1); værdi += fractX * (1 - fractY) * støj (x1, y2); værdi += (1 - fraktX) * (1 - fraktY) * støj (x2, y2); returværdi; }

Trin 3: Effekter ved brug af glat støj

Med dette skabte vi to effekter. For at gøre dette sløjfede vi gennem hver pixel på OLED og tog en tilfældig støjværdi baseret på x- og y -koordinaterne for disse pixels. Den første af disse effekter producerede vi ved at bruge den genererede værdi til at vælge en farve og farve den pixel med den førnævnte farve. Den anden effekt blev produceret på en lignende måde, men vi multiplicerede også farven med den genererede støjværdi. Dette gav mønsteret en mere skraveret effekt. Den anvendte kode er vist herunder:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; hvis (støjende) setNoisyColour (farver [absNoise], støj); ellers setBlockColour (farver [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (farve farve, float noise) {TFTscreen.stroke (farve.rød * støj, farve.green * støj, farve.blå * støj); } void setBlockColour (farve farve) {TFTscreen.stroke (farve.rød, farve.green, farve.blå); }

Trin 4: Tilfældige gradienteffekter

Der er to effekter, der producerer en tilfældig gradient. Den første effekt placerer pixels i forhold til deres rgb -farve, hvilket langsomt gengiver et gradientmønster på skærmen. Den anden bruger de samme farvede pixels som den første, men placerer dem i en fast rækkefølge, hvilket skaber en diagonal gradient langs skærmen.

Her er den første (baseret på farverne):

void Noise1 () {for (int z = 0; z <3; z ++) {TFTscreen.baggrund (0, 0, 0); int CurrentColour [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = CurrentColour [z] [0]; G = CurrentColour [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); hvis (R_Lower = 255) {R_Higher = 254; } int R_Offset = random (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); hvis (G_Lower = 255) {G_Higher = 254; } int G_Offset = tilfældig (G_Lower, G_Higher); int B_Low = B - ((x + y) / 4); hvis (B_Lower <1) {B_Lower = 0; } int B_Højere = B + ((x + y) / 4); hvis (B_Højere> = 255) {B_Højere = 254; } int B_Offset = random (B_Lower, B_Higher); int mult = 2; hvis (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))); }}}}

Og den anden (den mere ordnede effekt):

void Noise4 () {for (int z = 0; z <3; z ++) {TFTscreen.baggrund (0, 0, 0); int CurrentColour [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = CurrentColour [z] [0]; G = CurrentColour [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); hvis (R_Lower = 255) {R_Higher = 254; } int R_Offset = random (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); hvis (G_Lower = 255) {G_Higher = 254; } int G_Offset = tilfældig (G_Lower, G_Higher); int B_Low = B - ((x + y) / 4); hvis (B_Lower <1) {B_Lower = 0; } int B_Højere = B + ((x + y) / 4); hvis (B_Højere> = 255) {B_Højere = 254; } int B_Offset = random (B_Lower, B_Higher); int mult = 2; hvis (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

Trin 5: Det endelige resultat

Til sidst kombinerede vi disse effekter til en slags 'diasshow' af regnbuer. For at opnå dette kaldte vi simpelthen hver funktion efter den anden i et stykke loop:

mens (true) {Noise2n3 (false); Noise2n3 (sand); TFTscreen.baggrund (0, 0, 0); Støj1 (); Støj4 (); }