Az Arduino LED hangulatkocka javítása (egyszerű) (a videó mellékelve): 4 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

Miután megláttam egy LED kis hangulatkocka projektet, amelyet 'gróf készített, úgy döntöttem, hogy elkészítem a LED Mood Cube továbbfejlesztett változatát. Az én verzióm bonyolultabb lesz, mint az eredeti, mivel valamivel nagyobb lesz, mint az eredeti, két további színe lesz az eredeti kockához képest (sárga és fehér), végtelen számú színforgatás stb. jó projekt lehet a LED -lámpák további használatának gyakorlása azok számára, akik megértették a LED -lámpák és vezetékek csatlakoztatásának koncepcióját.

1. lépés: Anyagok

Íme néhány anyag, amire szükséged lesz a Mood Cube elkészítéséhez:

• Kenyeretábla
• Arduino - (itt van Leonardo)
• Arduino tápegység / USB kábel
• Kenyeretábla
• Jumper vezetékek (sok, 29 vezetéket használtam)
• Piros LED x 2
• Kék LED x 2
• Zöld LED x 2
• Sárga LED x 2
• Fehér LED x 1
• 9 ellenállás
• A doboz elég nagy ahhoz, hogy elférjen a kenyértábla (én cipős dobozt használtam)
• Svájci bicska
• Papír

2. lépés: Kód

Néhány magyarázat az itt megadott kódhoz:

A kódok jóváírása a projektem eredeti forrásához tartozik, mivel a projekt szerkesztője létrehozta ezeket a kódokat. Csak néhányat fejlesztettem azáltal, hogy összetettebbé tettem őket. Egyes kódokban a // 改 szöveg jelenik meg a végén. Ez azt jelenti, hogy ezt a kódot én szerkesztettem, tehát eltér az eredeti forrásomtól.

Van egy verzióm is az Arduino Creator kódjából.

/* A három LED, piros, zöld és kék LED-ek kereszthalványításának kódja (RGB) Az elhalványulások létrehozásához két dolgot kell tennie: 1. Írja le a megjeleníteni kívánt színeket. 2. Sorolja fel, hogy milyen sorrendben szeretné elhalványítani őket.

SZÍN LEÍRÁSA:

A szín csak három százalékos tömb, 0-100, amely a piros, zöld és kék LED-eket vezérli

A piros a piros LED, amikor a kék, a zöld és a zöld nem világít

int piros = {100, 0, 0} Halvány fehér mind a három LED 30% -on int dimWhite = {30, 30, 30} stb.

Az alábbiakban néhány általános színt talál, vagy készítse el saját maga

A RENDELÉS FELSOROLÁSA:

A program fő részében fel kell sorolni, hogy milyen sorrendben szeretnénk megjeleníteni a színeket, pl. crossFade (piros); crossFade (zöld); crossFade (kék);

Ezek a színek ebben a sorrendben jelennek meg, elhalványulnak

az egyik szín és a másik

Ezen kívül 5 opcionális beállítás közül választhat:

1. A kezdeti szín feketére van állítva (tehát az első szín elhalványul), de a kezdeti színt bármilyen más színűre is beállíthatja. 2. A belső ciklus 1020 interakcióra fut; a 'wait' változó beállítja az egyes áthidalások hozzávetőleges időtartamát. Elméletileg a 10 ms -os „várakozás” ~ 10 másodperc keresztfakulást eredményez. A gyakorlatban a többi funkció, amelyet a kód végez, lassan lecsökken ~ 11 másodpercre az asztalon. YMMV. 3. Ha az „ismétlés” értéke 0, akkor a program korlátlan ideig ciklusos. ha egy számra van állítva, akkor a ciklusokat ciklikusan hurkolja, majd megáll a sorozat utolsó színén. (Állítsa a „return” értéket 1 -re, és az utolsó színt feketére, ha azt szeretné, hogy a végén elhalványuljon.) 4. Van egy opcionális „hold” változó, amely ezredmásodpercig passzálja a programot, ha egy szín kész, de mielőtt a következő szín elkezdődne. 5. Ha a hibakeresési kimenetet el szeretné küldeni a soros monitorra, állítsa a DEBUG jelzőt 1 -re.

A program belseje nem bonyolult, de igen

kissé nyűgösek - a belső működést a főhurok alatt ismertetjük.

2007. április, Clay Shirky

*

/ Kimenet

int ylwPin = 5; // Sárga LED, az 5. digitális tűhöz csatlakoztatva // 改 int redPin = 6; // Piros LED, 6 -os digitális tűhöz csatlakoztatva // 改 int grnPin = 7; // Zöld LED, 7 -es digitális tűhöz csatlakoztatva // 改 int bluPin = 8; // Kék LED, 8 -as digitális tűhöz csatlakoztatva // 改 int whiPin = 9; // Fehér LED, 9 -es digitális tűhöz csatlakoztatva // 改 int ylwPin2 = 10; // Sárga LED, 10 -es digitális tűhöz csatlakoztatva // 改 int redPin2 = 11; // Piros LED, digitális 11 -es csaphoz csatlakoztatva // 改 int grnPin2 = 12; // Zöld LED, 12 -es digitális tűhöz csatlakoztatva // 改 int bluPin2 = 13; // Kék LED, a 13 -as digitális tűhöz csatlakoztatva // 改

// Színes tömbök

int fekete [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int fehér [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int piros [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int zöld [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blue [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int sárga [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int lila [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int narancs [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rózsaszín [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; Stb.

// Kezdeti szín beállítása

int redVal = fekete [0]; int grnVal = fekete [1]; int bluVal = fekete [2]; int ylwVal = fekete [3]; // 改 int whiVal = fekete [4]; // 改

int várakozás = 15; // 10 ms belső crossFade delay; növelés lassabb halványodás esetén // 改

int hold = 1; // Választható tartás, ha a szín befejeződött, a következő crossFade előtt // 改 int DEBUG = 1; // DEBUG számláló; ha 1 -re van állítva, visszaírja az értékeket a soros int loopCount = 60 segítségével; // Milyen gyakran kell jelenteni a DEBUG -ot? int ismétlés = 0; // Hányszor kell hurkolni, mielőtt megállunk? (0 a megállás nélkül) // 改 int j = 0; // Hurokszámláló ismétléshez

// Színváltozók inicializálása

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; // 改

// A LED kimenetek beállítása

void setup () {pinMode (redPin, OUTPUT); // beállítja a csapokat kimeneti pinMode -ként (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

if (DEBUG) {// Ha látni szeretnénk a hibakeresési értékeket…

Sorozat.kezdet (9600); //… a soros kimenet beállítása}}

// Fő program: sorolja fel az átfedések sorrendjét

void loop () {crossFade (piros); crossFade (zöld); crossFade (kék); crossFade (sárga); crossFade (fehér); crossFade (rózsaszín); crossFade (lila); crossFade (narancssárga);

ha (ismétlés) {// Véges számú alkalommal hurkolunk?

j += 1; ha (j> = ismétlés) {// Már ott tartunk? kijárat (j); // Ha igen, hagyd abba. }}}

/* ALÁBB EZ A VONAL A MATEMATIKA - NEM KELL VÁLTOZNOD EZT AZ ALAPVETŐKÉRT

A program a következőképpen működik:

Képzeljen el egy keresztfakulást, amely tíz lépésben a piros LED-et 0-10-re, a zöldet 0-5-re, a kéket pedig 10-ről 7-re mozgatja. Szeretnénk számolni a 10 lépést, és növelni vagy csökkenteni a színértékeket egyenletes lépésekben. Képzeljük el, hogy a + jelzi az érték 1 -es emelését, és a - egyenlő annak csökkentésével. A 10 lépéses elhalványulásunk így nézne ki:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + + G + + + + + B - - -

A piros tíz lépésben 0 -ról 10 -re emelkedik, a zöld pedig

0-5 5 lépésben, a kék pedig 10-ről 7-re esik három lépésben.

A valódi programban a színszázalékok átváltásra kerülnek

0-255 értékek, és 1020 lépés van (255*4).

Hogy kitaláljuk, mekkora lépésnek kell lennie egy fel- vagy

az egyik LED-érték lefelé történő kipipálását úgy hívjuk, hogy calcStep (), amely kiszámítja a kezdő és a végérték közötti abszolút rést, majd ezt a rést elosztja 1020-mal, hogy meghatározza az érték módosítása közötti lépés méretét. */

int calcStep (int prevValue, int endValue) {

int lépés = endValue - prevValue; // Mekkora az általános rés? if (lépés) {// Ha nem nulla, lépés = 1020 / lépés; // osztás 1020 -mal} visszatérési lépés; }

/* A következő függvény a calcVal. Amikor a ciklus értéke, i, eléri az egyik színnek megfelelő lépésméretet, 1 -gyel növeli vagy csökkenti a szín értékét. (R, G és B mindegyikét külön számítják ki.) */

int calcVal (int lépés, int val, int i) {

if ((lépés) && i % step == 0) {// Ha a lépés nem nulla, és ideje módosítani az értéket, if (lépés> 0) {// növeli az értéket, ha a lépés pozitív… val += 1; } else if (255. lépés) {val = 255; } else if (val <0) {val = 0; } visszatérési val; }

/* crossFade () a százalékos színeket a -ra konvertálja

0-255 tartományban, majd 1020-szor ciklusozva, ellenőrizve, hogy az értéket minden alkalommal frissíteni kell-e, majd írja be a színértékeket a megfelelő csapokba. */

void crossFade (int szín ) {// 改

// Konvertálás 0-255-re int R = (szín [0] * 255) / 100; int G = (szín [1] * 255) / 100; int B = (szín [2] * 255) / 100; int Y = (szín [3] * 255) / 100; // 改 int W = (szín [4] * 255) /100; // 改

int stepR = calcStep (prevR, R);

int stepG = calcStep (prevG, G); int stepB = calcStep (prevB, B); int stepY = calcStep (előző, Y); // 改 int stepW = calcStep (prevW, W); // 改

for (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = calcVal (stepG, grnVal, i); bluVal = calcVal (lépésB, bluVal, i); ylwVal = számítaniVal (Y lépés, ylwVal, i); // 改 whiVal = calcVal (lépésW, whiVal, i); // 改

analogWrite (redPin, redVal); // Írja be az aktuális értékeket a LED -es érintkezőkbe

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); analogWrite (ylwPin, ylwVal); // 改 analóg Írás (whiPin, whiVal); // 改 analóg Írás (grnPin2, grnVal); // 改 analogWrite (bluPin2, bluVal); // 改 analóg írás (ylwPin2, ylwVal); // 改 analóg Írás (redPin2, redVal); // 改

késleltetés (várakozás); // Szüneteltesd a "várj" ezredmásodpercet, mielőtt folytatod a ciklust

if (DEBUG) {// Ha soros kimenetet szeretnénk, nyomtassuk ki a

if (i == 0 vagy i % loopCount == 0) {// eleje, és minden loopCount szoroz Serial.print ("Loop/RGBYW: #"); Sorozatnyomat (i); Soros.nyomtatás ("|"); Serial.print (redVal); Soros.nyomtatás (" /"); Serial.print (grnVal); Soros.nyomtatás (" /"); Soros.println (bluVal); Soros.nyomtatás (" /"); Soros.println (ylwVal); // 改 Serial.print (" /"); // 改 Serial.println (whiVal); // 改 Serial.print (" /"); // 改} DEBUG += 1; }} // A következő ciklus aktuális értékeinek frissítése prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 delay (hold); // Szünet az opcionális "várakozás" ezredmásodpercig, mielőtt folytatná a ciklust}

3. lépés: Állítsa be

1. Szerezd meg a kenyértáblát.

2. A csatlakoztató vezetékek bemutatója, hogy a LED -lámpa világítani tudjon:

   1. Helyezze a LED -et a kenyértáblára. Helyezze a hosszabb végét balra, a rövidebbet pedig jobbra.
   2. Helyezze az áthidaló vezeték egyik végét egy helyre, amely a LED hosszabb végével azonos sorban van. Helyezze a másik végét a Digital PWM részre. A kód a sárga LED -eket 10 -re és 5 -re, a pirosakat 6 -ra és 11 -re, a kékeket 8 -ra és 13 -ra, a zöldeket 7 -re és 12 -re, végül pedig a fehér LED -eket 9 -re kell csatlakoztatni.
   3. Helyezze az ellenállás egyik végét ugyanabba a sorba a LED rövidebb végével. Helyezze a másik végét valahol közel.
   4. Helyezzen egy másik jumper vezeték végét ugyanabba a sorba az ellenállás végével, amely nem ugyanazon a soron van a LED rövidebb végével. Helyezze a vezeték másik végét a negatív töltéssorra.
   5. Helyezzen egy másik áthidaló vezeték végét a negatív töltéssorra, a másik végét pedig a GND -re.
3. Ismételje meg a 2. lépést 8 -szor, amikor azt szeretné, hogy 9 LED világítson

4. Helyezze a kenyeretáblát a dobozba. Néhány emlékeztető itt:

   1. Tápegységet használtam. Hozzon létre egy kis lyukat a vezetékekhez egy kés segítségével, hogy áthaladjon a dobozon, és csatlakozzon a kenyérsütő táblához.
   2. Győződjön meg arról, hogy a doboz egyik oldala nyitva van. A cipősdoboz egyik oldala már nyitva van. Ha a doboz teljesen le van zárva, vágja le a doboz egyik oldalát, hogy szabad terület legyen.
   3. Fedje le az oldalát semmivel papírral. Ez arra szolgál, hogy a LED -es fények a papíron keresztül világítsanak.