Paparan Kebisingan Pelangi Arduino TFT: 5 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:09

Kami membuat projek pelangi ini dengan menggunakan pelbagai teknik 'noise', yang menghasilkan kesan rawak terkawal. Dengan menambahkan sedikit warna, kesan pelangi dapat dihasilkan. Ia menggunakan Arduino Nano dan paparan OLED 128x128. Kami memaparkan kesan menggunakan perpustakaan TFT. Kami juga menggunakan beberapa komponen lain seperti papan roti dan beberapa wayar.

Langkah 1: Pendawaian

Tugas yang paling asas adalah pendawaian OLED ke Arduino. Kami menghubungkan GND dan VCC ke bas 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 hingga 3.3V di Arduino. Dengan menggunakan pin 5v dan GND dari Arduino, kami dapat menghidupkan keseluruhan papan roti.

Langkah 2: Bising yang lancar

Setelah memulakan keperluan untuk paparan TFT. Untuk mewujudkan kesan bunyi yang lancar, pertama kami memerlukan fungsi bunyi asas. Ini mengembalikan nilai yang agak rawak antara 0 dan 1 berdasarkan nilai x dan y yang dilewatkan. Penting untuk diperhatikan bahawa komputer tidak dapat menghasilkan hasil yang benar-benar rawak, dan keacakan ini hanya dapat dicapai dengan mengubah bilangan sebanyak mungkin, oleh itu bilangan yang sangat besar dalam persamaan.

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

Kami kemudian 'melancarkan' bunyi dengan fungsi lain. Ini dicapai dengan menghasilkan nilai berdasarkan bukan hanya pada hasil dari koordinat yang dimasukkan ke dalam fungsi, tetapi juga koordinat di sekitarnya. Hasilnya, koordinat yang berdekatan antara satu sama lain menghasilkan nilai yang serupa.

float smoothNoise (float x, float y) {float fractX = x - (int) x; terapung pecahanY = 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 apungan = 0.0f; nilai + = bunyi fractX * fractY * (x1, y1); nilai + = (1 - fractX) * bunyi fractY * (x2, y1); nilai + = fractX * (1 - fractY) * bunyi (x1, y2); nilai + = (1 - fractX) * (1 - fractY) * bunyi (x2, y2); nilai pulangan; }

Langkah 3: Kesan Menggunakan Kebisingan Halus

Dengan ini kami mencipta dua kesan. Untuk melakukan ini, kami melingkar setiap piksel pada OLED dan mengambil nilai bunyi rawak berdasarkan koordinat x dan y piksel ini. Kesan pertama yang kami hasilkan dengan menggunakan nilai yang dihasilkan untuk memilih warna, dan mewarnakan piksel itu dengan warna yang disebutkan di atas. Kesan kedua dihasilkan dengan cara yang serupa, tetapi kami juga menggandakan warna dengan nilai bunyi yang dihasilkan. Ini memberi corak kesan yang lebih teduh. Kod yang digunakan ditunjukkan di bawah:

batal Noise2n3 (bool Noisy) {untuk (int y = 0; y <noiseHeight; y ++) {untuk (int x = 0; x 8) absNoise = 8; jika (Noisy) setNoisyColour (warna [absNoise], bunyi); setBlockColour yang lain (warna [absNoise]); TFTscreen.point (x, y); }}} batal setNoisyColour (Warna warna, bunyi apung) {TFTscreen.stroke (warna. red * noise, colour.green * noise, colour.blue * noise); } batal setBlockColour (Warna warna) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

Langkah 4: Kesan Kecerunan Rawak

Terdapat dua kesan yang menghasilkan kecerunan secara rawak. Kesan pertama meletakkan piksel berkaitan dengan warna rgbnya, perlahan-lahan memberikan corak kecerunan ke layar. Yang kedua menggunakan piksel berwarna yang sama dengan yang pertama, tetapi menempatkannya dalam urutan tetap, membuat kecerunan pepenjuru di sepanjang layar.

Inilah yang pertama (berdasarkan warna):

batal Noise1 () {untuk (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 = Warna Semasa [z] [0]; G = Warna Semasa [z] [1]; B = Warna Semasa [z] [2]; untuk (int x = 0; x <128; x ++) {untuk (int y = 0; y <128; y ++) {int R_Lower = R - ((x + y) / 4); jika (R_Lower = 255) {R_Higher = 254; } int R_Offset = rawak (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); jika (G_Lower = 255) {G_Higher = 254; } int G_Offset = rawak (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); jika (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); jika (B_Higher> = 255) {B_Higher = 254; } int B_Offset = rawak (B_Lower, B_Higher); int mult = 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 (kesan yang lebih teratur):

batal Noise4 () {untuk (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 = Warna Semasa [z] [0]; G = Warna Semasa [z] [1]; B = Warna Semasa [z] [2]; untuk (int x = 0; x <128; x ++) {untuk (int y = 0; y <128; y ++) {int R_Lower = R - ((x + y) / 4); jika (R_Lower = 255) {R_Higher = 254; } int R_Offset = rawak (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); jika (G_Lower = 255) {G_Higher = 254; } int G_Offset = rawak (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); jika (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); jika (B_Higher> = 255) {B_Higher = 254; } int B_Offset = rawak (B_Lower, B_Higher); int mult = 2; jika (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

Langkah 5: Keputusan Akhir

Pada akhirnya, kami menggabungkan kesan ini menjadi semacam 'tayangan slaid' pelangi. Untuk mencapainya, kami hanya memanggil setiap fungsi demi satu dalam gelung sementara:

sementara (benar) {Noise2n3 (false); Kebisingan2n3 (benar); TFTscreen.background (0, 0, 0); Bunyi1 (); Bunyi4 (); }