Tampilan Kebisingan Pelangi TFT Arduino: 5 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:56

Kami membuat proyek pelangi ini menggunakan berbagai teknik 'noise', yang menciptakan efek acak terkontrol. Dengan menambahkan beberapa warna, efek pelangi dapat dihasilkan. Ini menggunakan Arduino Nano dan layar OLED 128x128. Kami menampilkan efek menggunakan perpustakaan TFT. Kami juga menggunakan beberapa komponen lain-lain seperti papan roti dan beberapa kabel.

Langkah 1: Pengkabelan

Tugas paling dasar adalah pengkabelan OLED ke Arduino. Kami menghubungkan GND dan VCC ke bus masing-masing di papan roti; SCL ke pin digital 13; SDA ke pin digital 11; RES ke pin digital 8; DC ke pin digital 9; CS ke pin digital 10 dan akhirnya BL ke 3.3V di Arduino. Menggunakan pin 5v dan GND dari Arduino, kami dapat memberi daya pada seluruh papan roti.

Langkah 2: Kebisingan Halus

Setelah menginisialisasi persyaratan untuk tampilan TFT. Untuk menciptakan efek noise yang halus, pertama-tama kita membutuhkan fungsi noise dasar. Ini mengembalikan nilai yang relatif acak antara 0 dan 1 berdasarkan nilai x dan y yang dimasukkan. Penting untuk dicatat bahwa komputer tidak pernah dapat menghasilkan hasil yang benar-benar acak, dan keacakan ini hanya dicapai dengan mengubah angka sebanyak mungkin., maka angka yang sangat besar dalam persamaan.

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

Kami kemudian 'menghaluskan' kebisingan dengan fungsi lain. Ini dicapai dengan menghasilkan nilai berdasarkan tidak hanya pada hasil dari koordinat yang diteruskan ke fungsi, tetapi juga koordinat sekitarnya. Akibatnya, koordinat yang berdekatan satu sama lain menghasilkan nilai yang serupa.

float smoothNoise(float x, float y){ float fractX = x - (int) x; float fracY = 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; nilai float = 0,0f; nilai += fracX * fracY * noise(x1, y1); nilai += (1 - fracX) * fracY * noise(x2, y1); nilai += fracX * (1 - fracY) * noise(x1, y2); nilai += (1 - fracX) * (1 - fracY) * noise(x2, y2); nilai kembali; }

Langkah 3: Efek Menggunakan Kebisingan Halus

Dengan ini kami membuat dua efek. Untuk melakukan ini, kami mengulang setiap piksel pada OLED dan mengambil nilai noise acak berdasarkan koordinat x dan y dari piksel ini. Yang pertama dari efek ini kami hasilkan dengan menggunakan nilai yang dihasilkan untuk memilih warna, dan mewarnai piksel itu dengan warna yang disebutkan di atas. Efek kedua dihasilkan dengan cara yang sama, tetapi kami juga mengalikan warna dengan nilai noise yang dihasilkan. Ini memberi pola efek yang lebih teduh. Kode yang digunakan ditunjukkan di bawah ini:

void Noise2n3(bool Noisy){ for (int y = 0; y < noiseHeight; y++) { for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour(colors[absNoise], noise); else setBlockColour(warna[absNoise]); TFTscreen.point(x, y); } } } void setNoisyColour(Warna warna, float noise) { TFTscreen.stroke(color.red * noise, color.green * noise, color.blue * noise); } void setBlockColour(Warna warna) { TFTscreen.stroke(warna.merah, warna.hijau, warna.biru); }

Langkah 4: Efek Gradien Acak

Ada dua efek yang menghasilkan gradien acak. Efek pertama menempatkan piksel dalam kaitannya dengan warna rgb mereka, perlahan-lahan membuat pola gradien ke layar. Yang kedua menggunakan piksel berwarna yang sama seperti yang pertama, tetapi menempatkannya dalam urutan yang tetap, menciptakan gradien diagonal di sepanjang layar.

Ini yang pertama (berdasarkan warna):

void Noise1(){ for(int z = 0; z < 3; z++) { TFTscreen.background(0, 0, 0); int Warna Sekarang[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Warna Saat Ini[z][0]; G = Warna Saat Ini[z][1]; B = Warna Saat Ini[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) { int R_Bawah = R - ((x + y) / 4); if(R_Lebih rendah = 255) { R_Tinggi = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Bawah = G - ((x + y) / 4); if(G_Lebih rendah = 255) { G_Lebih tinggi = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Bawah = B - ((x + y) / 4); if(B_Bawah <1) { B_Bawah = 0; } int B_Tinggi = B + ((x + y) / 4); if(B_Tinggi>= 255) { B_Tinggi = 254; } int B_Offset = random(B_Lower, B_Higher); int banyak = 2; jika (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))); } } } }

Dan yang kedua (efek yang lebih teratur):

void Noise4(){ for(int z = 0; z < 3; z++) { TFTscreen.background(0, 0, 0); int Warna Sekarang[3][3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = Warna Saat Ini[z][0]; G = Warna Saat Ini[z][1]; B = Warna Saat Ini[z][2]; for(int x = 0; x < 128; x++) { for(int y = 0; y < 128; y++) { int R_Bawah = R - ((x + y) / 4); if(R_Lebih rendah = 255) { R_Lebih tinggi = 254; } int R_Offset = random(R_Lower, R_Higher); int G_Bawah = G - ((x + y) / 4); if(G_Lebih rendah = 255) { G_Lebih tinggi = 254; } int G_Offset = random(G_Lower, G_Higher); int B_Bawah = B - ((x + y) / 4); if(B_Bawah <1) { B_Bawah = 0; } int B_Tinggi = B + ((x + y) / 4); if(B_Tinggi>= 255) { B_Tinggi = 254; } int B_Offset = random(B_Lower, B_Higher); int banyak = 2; jika (z == 1) mult = 1; TFTscreen.stroke(R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point(x, y); } } } }

Langkah 5: Hasil Akhir

Pada akhirnya, kami menggabungkan efek ini menjadi semacam 'slideshow' pelangi. Untuk mencapai ini, kami cukup memanggil setiap fungsi setelah yang lain dalam loop sementara:

while (benar) { Noise2n3(salah); Kebisingan2n3(benar); TFTscreen.background(0, 0, 0); Kebisingan1(); Kebisingan4(); }