Arduino TFT Rainbow Noise ჩვენება: 5 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

ჩვენ შევქმენით ეს ცისარტყელას პროექტი სხვადასხვა 'ხმაურის' ტექნიკის გამოყენებით, რაც ქმნის კონტროლირებად შემთხვევით ეფექტებს. გარკვეული ფერის დამატებით შესაძლებელია ცისარტყელას ეფექტის შექმნა. ის იყენებს Arduino Nano- ს და 128x128 OLED ეკრანს. ჩვენ ვაჩვენეთ ეფექტები TFT ბიბლიოთეკის გამოყენებით. ჩვენ ასევე გამოვიყენეთ სხვადასხვა კომპონენტები, როგორიცაა პურის დაფა და რამდენიმე მავთული.

ნაბიჯი 1: გაყვანილობა

ყველაზე ძირითადი ამოცანა იყო OLED– ის გაყვანილობა არდუინოსთან. ჩვენ დავუკავშირდით GND და VCC პურის დაფაზე არსებულ შესაბამის ავტობუსებს; SCL ციფრულ პინზე 13; SDA ციფრული პინზე 11; RES ციფრულ პინზე 8; DC ციფრულ პინზე 9; CS ციფრულ პინზე 10 და ბოლოს BL to 3.3V არდუინოზე. არდუინოს 5v და GND ქინძისთავების გამოყენებით ჩვენ შევძელით მთელი პურის დაფის ჩართვა.

ნაბიჯი 2: გლუვი ხმაური

TFT ეკრანის მოთხოვნების ინიციალიზაციის შემდეგ. ხმაურის გლუვი ეფექტის შესაქმნელად, ჩვენ პირველ რიგში გვჭირდება ხმაურის ძირითადი ფუნქცია. ეს აბრუნებს შედარებით შემთხვევით მნიშვნელობას 0 -დან 1 -მდე, გადატანილი x და y მნიშვნელობებით. მნიშვნელოვანია აღინიშნოს, რომ კომპიუტერი ვერასოდეს გამოიღებს ჭეშმარიტად შემთხვევით შედეგს და ეს შემთხვევითობა მიიღწევა მხოლოდ რიცხვის მაქსიმალურად შეცვლით, აქედან გამომდინარე ძალიან დიდი რიცხვები განტოლებაში.

float ხმაური (int x, int y) {int n; n = x + y * 57; n += (n << 13) ^ n; დაბრუნება (1.0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); }

ჩვენ შემდეგ 'შევასწორებთ' ხმაურს სხვა ფუნქციით. ეს მიიღწევა მნიშვნელობის გამომუშავებით, რომელიც ეფუძნება არა მხოლოდ ფუნქციაში გადატანილი კოორდინატის შედეგს, არამედ მის მიმდებარე კოორდინატებსაც. შედეგად, კოორდინატები ერთმანეთთან ახლოს აწარმოებენ მსგავს მნიშვნელობას.

float smoothNoise (float x, float y) {float fractX = x - (int) x; float fractY = y - (int) y; int x1 = ((int) (x) + ხმაური სიგანე) % ხმაური სიგანე; int y1 = ((int) (y) + ხმაური სიმაღლე) % ხმაური სიმაღლე; int x2 = (x1 + ხმაური სიგანე - 1) % ხმაური სიგანე; int y2 = (y1 + ხმაური სიმაღლე - 1) % ხმაური სიმაღლე; მცურავი მნიშვნელობა = 0.0f; მნიშვნელობა += fractX * fractY * ხმაური (x1, y1); მნიშვნელობა += (1 - fractX) * fractY * ხმაური (x2, y1); მნიშვნელობა += fractX * (1 - fractY) * ხმაური (x1, y2); მნიშვნელობა += (1 - fractX) * (1 - fractY) * ხმაური (x2, y2); დაბრუნების ღირებულება; }

ნაბიჯი 3: ეფექტები გლუვი ხმაურის გამოყენებით

ამით ჩვენ შევქმენით ორი ეფექტი. ამისათვის ჩვენ შემოვიარეთ OLED თითოეული პიქსელი და მივიღეთ ხმაურის შემთხვევითი მნიშვნელობა ამ პიქსელების x და y კოორდინატებზე დაყრდნობით. ამ ეფექტებიდან პირველი ჩვენ წარმოვადგინეთ გენერირებული მნიშვნელობის გამოყენებით ფერის დასაკრეფად და გავაფერადეთ ეს პიქსელი ზემოხსენებული ფერით. მეორე ეფექტი შეიქმნა ანალოგიურად, მაგრამ ჩვენ ასევე გავამრავლეთ ფერი წარმოქმნილი ხმაურის მნიშვნელობით. ამან ნიმუშს უფრო დაჩრდილული ეფექტი მისცა. გამოყენებული კოდი ნაჩვენებია ქვემოთ:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; თუ (ხმაურიანი) setNoisyColour (ფერები [აბს ხმაური], ხმაური); else setBlockColour (ფერები [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (ფერი ფერი, float ხმაური) {TFTscreen.stroke (colour.red * ხმაური, colour.green * ხმაური, colour.blue * ხმაური); } void setBlockColour (ფერი ფერი) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

ნაბიჯი 4: შემთხვევითი გრადიენტის ეფექტები

არსებობს ორი ეფექტი, რომელიც წარმოქმნის შემთხვევით გრადიენტს. პირველი ეფექტი ათავსებს პიქსელებს მათ rgb ფერსთან მიმართებაში, ნელ -ნელა ეკრანზე ახდენს გრადიენტის შაბლონს. მეორე იყენებს იმავე ფერის პიქსელს, როგორც პირველს, მაგრამ ათავსებს მათ ფიქსირებულ თანმიმდევრობაში, ქმნის ეკრანის გასწვრივ დიაგონალურ გრადიენტს.

აქ არის პირველი (ფერებიდან გამომდინარე):

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]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); თუ (R_Lower = 255) {R_Higher = 254; } int R_Offset = შემთხვევითი (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); თუ (G_Lower = 255) {G_Higher = 254; } int G_Offset = შემთხვევითი (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); თუ (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); თუ (B_Higher> = 255) {B_Higher = 254; } int B_Offset = შემთხვევითი (B_Lower, B_Higher); int mult = 2; თუ (z == 1) მულტი = 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))); }}}}

და მეორე (უფრო მოწესრიგებული ეფექტი):

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]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x+y) / 4); თუ (R_Lower = 255) {R_Higher = 254; } int R_Offset = შემთხვევითი (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); თუ (G_Lower = 255) {G_Higher = 254; } int G_Offset = შემთხვევითი (G_Lower, G_Higher); int B_Lower = B - ((x + y) / 4); თუ (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); თუ (B_Higher> = 255) {B_Higher = 254; } int B_Offset = შემთხვევითი (B_Lower, B_Higher); int mult = 2; თუ (z == 1) მულტი = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

ნაბიჯი 5: საბოლოო შედეგი

საბოლოოდ, ჩვენ გავაერთიანეთ ეს ეფექტები ცისარტყელას ერთგვარ „სლაიდშოუში“. ამის მისაღწევად, ჩვენ უბრალოდ ვუწოდეთ თითოეულ ფუნქციას ერთმანეთის მიყოლებით მარყუჟში:

ხოლო (ჭეშმარიტი) {ხმაური 2n3 (ყალბი); ხმაური 2n3 (მართალია); TFTscreen.background (0, 0, 0); ხმაური 1 (); ხმაური 4 (); }