תצוגת רעש קשת Arduino TFT: 5 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

יצרנו את פרויקט הקשת באמצעות טכניקות 'רעש' שונות, היוצרות אפקטים אקראיים מבוקרים. על ידי הוספת קצת צבע, ניתן לייצר אפקט קשת. הוא משתמש ב- Arduino Nano ובמסך OLED של 128x128. הצגנו את האפקטים באמצעות ספריית TFT. השתמשנו גם בכמה רכיבים שונים כגון לוח לחם וכמה חוטים.

שלב 1: חיווט

המשימה הבסיסית ביותר הייתה חיווט ה- OLED לארדואינו. חיברנו את ה- GND וה- VCC לאוטובוסים המתאימים בלוח הלחם; SCL לסיכה דיגיטלית 13; SDA לסיכה דיגיטלית 11; RES לסיכה דיגיטלית 8; סיכה עד סיכה דיגיטלית 9; CS לפין דיגיטלי 10 ולבסוף BL עד 3.3V בארדואינו. בעזרת סיכות 5v ו- GND מהארדואינו הצלחנו להניע את כל לוח הלחם.

שלב 2: רעש חלק

לאחר אתחול הדרישות לתצוגת TFT. כדי ליצור את אפקט הרעש החלק, היינו צריכים קודם כל פונקציית רעש בסיסית. זה מחזיר ערך אקראי יחסית בין 0 ל -1 על סמך ערכי x ו- y שהועברו פנימה. חשוב לציין כי מחשב לעולם אינו יכול לייצר תוצאה אקראית באמת, ואקראיות זו מושגת רק על ידי שינוי המספר ככל שניתן. ומכאן המספרים הגדולים ביותר במשוואה.

רעש צף (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; צף שבר Y = 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; ערך צף = 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 (צבעים [absNoise], רעש); else setBlockColour (צבעים [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (צבע צבע, רעש צף) {TFTscreen.stroke (colour.red * noise, colour.green * noise, colour.blue * noise); } void setBlockColour (צבע צבע) {TFTscreen.stroke (color.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) 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))); }}}}

והשני (האפקט המסודר יותר):

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) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

שלב 5: התוצאה הסופית

בסופו של דבר, שילבנו את האפקטים הללו למעין "מצגת שקופיות" של קשתות. כדי להשיג זאת, פשוט קראנו לכל פונקציה לאחר השנייה בלולאת זמן:

while (true) {Noise2n3 (false); Noise2n3 (נכון); TFTscreen.background (0, 0, 0); רעש 1 (); רעש 4 (); }