Arduino TFT Rainbow Noise Display: 5 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

Ons het hierdie reënboogprojek geskep met behulp van verskillende 'geraas' -tegnieke wat beheerde ewekansige effekte skep. Deur 'n bietjie kleur by te voeg, kan 'n reënboog -effek verkry word. Dit gebruik 'n Arduino Nano en 'n 128x128 OLED -skerm. Ons het die effekte vertoon met behulp van die TFT -biblioteek. Ons het ook 'n paar verskillende komponente gebruik, soos 'n broodbord en 'n paar drade.

Stap 1: Bedrading

Die mees basiese taak was die bedrading van die OLED na die Arduino. Ons het die GND en VCC verbind met die onderskeie busse op die broodbord; SCL na digitale pen 13; SDA na digitale pen 11; RES na digitale pen 8; DC na digitale pen 9; CS na digitale pen 10 en uiteindelik BL tot 3.3V op die Arduino. Deur die 5v- en GND -penne van die Arduino te gebruik, kon ons die hele broodbord aandryf.

Stap 2: Gladde geraas

Na die initialisering van die vereistes vir die TFT -skerm. Om die gladde geraas -effek te skep, het ons eers 'n basiese geraasfunksie nodig gehad. Dit gee 'n relatief ewekansige waarde tussen 0 en 1 op, gebaseer op die x- en y -waardes wat ingegee word. Dit is belangrik om daarop te let dat 'n rekenaar nooit 'n werklik ewekansige resultaat kan lewer nie, en hierdie willekeur word slegs bereik deur die getal soveel as moontlik te verander, vandaar die baie groot getalle in die vergelyking.

float noise (int x, int y) {int n; n = x + y * 57; n += (n << 13) ^ n; opbrengs (1.0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); }

Ons maak die geraas dan glad met 'n ander funksie. Dit word bereik deur 'n waarde te produseer wat nie net gebaseer is op die resultaat van die koördinaat wat in die funksie oorgedra is nie, maar ook op die omliggende koördinate. As gevolg hiervan produseer koördinate naby mekaar 'n soortgelyke waarde.

float smoothNoise (float x, float y) {float fractX = x - (int) x; float fraktY = 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; vlotwaarde = 0.0f; waarde += fractX * fractY * geraas (x1, y1); waarde += (1 - fractX) * fractY * geraas (x2, y1); waarde += fractX * (1 - fractY) * geraas (x1, y2); waarde += (1 - fractX) * (1 - fractY) * geraas (x2, y2); opbrengswaarde; }

Stap 3: Effekte met behulp van gladde geraas

Hiermee het ons twee effekte geskep. Om dit te doen, het ons deur elke pixel op die OLED geloop en 'n ewekansige geraaswaarde geneem op grond van die x- en y -koördinate van hierdie pixels. Die eerste van hierdie effekte het ons verkry deur die gegenereerde waarde te gebruik om 'n kleur te kies, en die pixel gekleur met die voormelde kleur. Die tweede effek is op 'n soortgelyke manier geproduseer, maar ons het ook die kleur vermenigvuldig met die gegenereerde geraaswaarde. Dit het die patroon 'n meer skaduwee -effek gegee. Die gebruikte kode word hieronder getoon:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; as (raserig) setNoisyColour (kleure [absNoise], geraas); anders setBlockColour (kleure [absNoise]); TFTscreen.punt (x, y); }}} void setNoisyColour (kleur kleur, float geraas) {TFTscreen.stroke (colour.red * noise, colour.green * noise, colour.blue * noise); } void setBlockColour (kleur kleur) {TFTscreen.stroke (kleur.rooi, kleur.groen, kleur.blou); }

Stap 4: Willekeurige gradiënt -effekte

Daar is twee effekte wat 'n ewekansige gradiënt produseer. Die eerste effek plaas die pixels in verhouding tot hul rgb -kleur, wat 'n gradiëntpatroon stadig op die skerm gee. Die tweede gebruik dieselfde gekleurde pixels as die eerste, maar plaas dit in 'n vaste volgorde, wat 'n diagonale helling langs die skerm skep.

Hier is die eerste (gebaseer op die kleure):

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 = CurrentColour [z] [0]; G = CurrentColour [z] [1]; B = CurrentColour [z] [2]; vir (int x = 0; x <128; x ++) {vir (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); as (R_Lower = 255) {R_Higher = 254; } int R_Offset = random (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); as (G_Lower = 255) {G_Higher = 254; } int G_Offset = random (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); as (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); as (B_Higher> = 255) {B_Higher = 254; } int B_Offset = random (B_Lower, B_Higher); int mult = 2; as (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)))); }}}}

En die tweede (die meer ordelike effek):

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 = CurrentColour [z] [0]; G = CurrentColour [z] [1]; B = CurrentColour [z] [2]; vir (int x = 0; x <128; x ++) {vir (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); as (R_Lower = 255) {R_Higher = 254; } int R_Offset = random (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); as (G_Lower = 255) {G_Higher = 254; } int G_Offset = random (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); as (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); as (B_Higher> = 255) {B_Higher = 254; } int B_Offset = random (B_Lower, B_Higher); int mult = 2; as (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.punt (x, y); }}}}

Stap 5: Die finale resultaat

Uiteindelik kombineer ons hierdie effekte in 'n soort 'skyfievertoning' van reënboë. Om dit te bereik, het ons elke funksie in 'n ruk lus eenvoudig na die ander genoem:

terwyl (waar) {Noise2n3 (vals); Noise2n3 (waar); TFTscreen.background (0, 0, 0); Geraas1 (); Geraas4 (); }