Pagpapabuti ng isang Arduino LED Mood Cube (Simple) (Kasamang Video): 4 na Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Matapos makita ang isang proyekto ng LED maliit na mood cube na nilikha ni 'earl, nagpasya akong gawin ang isang pinabuting bersyon ng LED Mood Cube. Ang aking bersyon ay magiging mas kumplikado kaysa sa orihinal na isa, dahil ito ay magiging bahagyang mas malaki kaysa sa orihinal na isa, may dalawa pang mga kulay na paghahambing sa orihinal na kubo (idinagdag na dilaw at puti), mayroong isang walang katapusang dami ng pag-ikot ng mga kulay, atbp. Ito ay dapat na isang magandang proyekto upang magsanay sa karagdagang paggamit ng mga LED light para sa mga nakakaunawa ng konsepto sa pagkonekta sa mga LED light sa mga wire.

Hakbang 1: Mga Kagamitan

Narito ang ilang mga materyales na kakailanganin mo upang gawin ang Mood Cube na ito:

• Breadboard
• Arduino - (Mayroon akong Leonardo dito)
• Arduino power supply / USB cable
• Breadboard
• Jumper Wires (Marami sa kanila, gumamit ako ng 29 na mga wire)
• Pulang LED x 2
• Blue LED x 2
• Green LED x 2
• Dilaw na LED x 2
• Puting LED x 1
• 9 resistors
• Sapat na malaki ang kahon upang magkasya sa breadboard (Gumamit ako ng isang kahon ng sapatos)
• Utility Knife
• Papel

Hakbang 2: Code

Ang ilang paliwanag para sa code na ibinigay dito:

Ang kredito ng mga code ay papunta sa orihinal na mapagkukunan ng aking proyekto bilang editor ng proyekto na nilikha ang mga code na ito. Pinagbuti ko lang ang ilan sa kanila sa pamamagitan ng paggawa ng mas kumplikado sa kanila. Sa ilang mga code, maaari mong makita ang // 改 sa huli. Nangangahulugan ito na ang code na ito ay na-edit ko, kaya't iba ito sa aking orihinal na mapagkukunan.

Mayroon din akong isang bersyon ng code sa Arduino Creator.

/ * Code para sa cross-fading 3 LEDs, pula, berde at asul (RGB) Upang lumikha ng mga fades, kailangan mong gumawa ng dalawang bagay: 1. Ilarawan ang mga kulay na nais mong ipakita 2. Ilista ang pagkakasunud-sunod na nais mong mawala sa kanila

Paglaraw ng isang Kulay:

Ang isang kulay ay isang array lamang ng tatlong porsyento, 0-100, na kinokontrol ang pula, berde at asul na mga LED

Ang pula ay ang pulang LED nang buo, asul at berde

int red = {100, 0, 0} Ang puting puti ay lahat ng tatlong LED sa 30% int dimWhite = {30, 30, 30} atbp.

Ang ilang mga karaniwang kulay ay ibinibigay sa ibaba, o gumawa ng iyong sarili

LISTING THE ORDER:

Sa pangunahing bahagi ng programa, kailangan mong ilista ang pagkakasunud-sunod na nais mong mga kulay upang lumitaw, hal. crossFade (pula); crossFade (berde); crossFade (asul);

Ang mga kulay na iyon ay lilitaw sa pagkakasunud-sunod na iyon, kumukupas

isang kulay at sa susunod

Bilang karagdagan, mayroong 5 mga opsyonal na setting na maaari mong ayusin:

1. Ang paunang kulay ay nakatakda sa itim (kaya't ang unang kulay ay kumukupas), ngunit maaari mong itakda ang paunang kulay upang maging anumang iba pang kulay 2. Ang panloob na loop ay tumatakbo para sa 1020 mga pakikipag-ugnayan; ang variable na 'maghintay' ay nagtatakda ng tinatayang tagal ng isang solong crossfade. Sa teorya, ang isang 'maghintay' na 10 ms ay dapat gumawa ng isang crossFade na ~ 10 segundo. Sa pagsasagawa, ang iba pang mga pagpapaandar ng code ay gumaganap ng mabagal ito sa ~ 11 segundo sa aking board. YMMV. 3. Kung ang 'ulitin' ay nakatakda sa 0, ang programa ay maiikot nang walang katapusan. kung ito ay nakatakda sa isang numero, ito ay loop ang bilang ng mga beses, pagkatapos ay huminto sa huling kulay sa pagkakasunud-sunod. (Itakda ang 'pagbabalik' sa 1, at gawing itim ang huling kulay kung nais mong mawala ito sa huli.) 4. Mayroong isang opsyonal na variable na 'hold', na kung saan ay ipasa ang programa para sa 'hold' milliseconds kapag ang isang kulay ay kumpleto, ngunit bago magsimula ang susunod na kulay. 5. Itakda ang DEBUG flag sa 1 kung nais mong maipadala ang output ng pag-debug sa serial monitor.

Ang mga panloob na programa ay hindi kumplikado, ngunit sila

ay isang maliit na fussy - ang panloob na workings ay ipinaliwanag sa ibaba ng pangunahing loop.

Abril 2007, Clay Shirky

*

/ Output

int ylwPin = 5; // Yellow LED, konektado sa digital pin 5 // 改 int redPin = 6; // Red LED, konektado sa digital pin 6 // 改 int grnPin = 7; // Green LED, konektado sa digital pin 7 // 改 int bluPin = 8; // Blue LED, konektado sa digital pin 8 // 改 int whiPin = 9; // White LED, konektado sa digital pin 9 // 改 int ylwPin2 = 10; // Yellow LED, konektado sa digital pin 10 // 改 int redPin2 = 11; // Red LED, konektado sa digital pin 11 // 改 int grnPin2 = 12; // Green LED, konektado sa digital pin 12 // 改 int bluPin2 = 13; // Blue LED, konektado sa digital pin 13 // 改

// Mga array ng kulay

int black [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int white [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int red [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int green [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blue [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int yellow [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int purple [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int orange [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // atbp.

// Itakda ang paunang kulay

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

int wait = 15; // 10ms panloob na pagkaantala ng crossFade; dagdagan para sa mas mabagal na pagkupas // 改

int hold = 1; // Opsyonal na paghawak kapag ang isang kulay ay kumpleto, bago ang susunod na crossFade // 改 int DEBUG = 1; // DEBUG counter; kung nakatakda sa 1, susulat ang mga halaga pabalik sa pamamagitan ng serial int loopCount = 60; // Gaano kadalas dapat mag-ulat ang DEBUG? int ulitin = 0; // Gaano karaming beses dapat tayong mag-loop bago huminto? (0 para walang hihinto) // 改 int j = 0; // Loop counter para maulit

// Pinasimulan ang mga variable ng kulay

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

// I-set up ang mga LED output

void setup () {pinMode (redPin, OUTPUT); // nagtatakda ng mga pin bilang output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

kung (DEBUG) {// Kung nais naming makita ang mga halaga para sa pag-debug …

Serial.begin (9600); //… i-set up ang serial ouput}}

// Pangunahing programa: ilista ang pagkakasunud-sunod ng mga crossfade

void loop () {crossFade (pula); crossFade (berde); crossFade (asul); crossFade (dilaw); crossFade (puti); crossFade (pink); crossFade (lila); crossFade (orange);

kung (ulitin) {// Nag-loop ba kami ng isang may hangganan na bilang ng mga beses?

j + = 1; kung (j> = ulitin) {// Nariyan na ba tayo? exit (j); // Kung gayon, huminto. }}}

/ * SA BAWAL NG ITO AY ANG MATH - HINDI MO DAPAT BAGAYIN ITO PARA BASICS

Gumagana ang programa tulad nito:

Pag-isipan ang isang crossfade na gumagalaw sa pulang LED mula 0-10, ang berde mula 0-5, at ang asul mula 10 hanggang 7, sa sampung hakbang. Nais naming bilangin ang 10 mga hakbang at dagdagan o bawasan ang mga halaga ng kulay sa pantay na tumaas na mga pagtaas. Isipin ang isang + nagpapahiwatig ng pagtaas ng isang halaga ng 1, at a - katumbas ng pagbaba nito. Ang aming 10 step fade ay magiging hitsura ng:

1 2 3 4 5 6 7 8 9 10

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

Ang pula ay tumataas mula 0 hanggang 10 sa sampung mga hakbang, ang berde mula sa

0-5 sa 5 mga hakbang, at ang asul ay nahuhulog mula 10 hanggang 7 sa tatlong mga hakbang.

Sa totoong programa, ang mga porsyento ng kulay ay nai-convert sa

Mga halagang 0-255, at mayroong 1020 mga hakbang (255 * 4).

Upang malaman kung gaano kalaki ang isang hakbang na dapat mayroong pagitan ng isang pataas o

down-tick ng isa sa mga halagang LED, tinatawag naming calculStep (), na kinakalkula ang ganap na agwat sa pagitan ng mga halaga ng pagsisimula at pagtatapos, at pagkatapos ay hinahati ang puwang na iyon ng 1020 upang matukoy ang laki ng hakbang sa pagitan ng mga pagsasaayos sa halaga. * /

int calculStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Ano ang pangkalahatang puwang? kung (hakbang) {// Kung hindi non-zero, hakbang = 1020 / hakbang; // hatiin ng 1020} hakbang sa pagbabalik; }

/ * Ang susunod na pag-andar ay calculVal. Kapag ang halaga ng loop, i, naaabot ang laki ng hakbang na naaangkop para sa isa sa mga kulay, pinapataas o binabawasan ang halaga ng kulay na iyon ng 1. (Ang R, G, at B ay magkakalkula nang magkahiwalay.) * /

int calculVal (int step, int val, int i) {

kung ((hakbang) && i% hakbang == 0) {// Kung ang hakbang ay hindi-zero at oras nito upang baguhin ang isang halaga, kung (hakbang> 0) {// dagdagan ang halaga kung positibo ang hakbang… val + = 1; } iba pa kung (hakbang 255) {val = 255; } iba pa kung (val <0) {val = 0; } bumalik val; }

/ * Ang crossFade () ay nagko-convert ng mga kulay ng porsyento sa a

Saklaw ng 0-255, pagkatapos ay mga loop ng 1020 beses, suriin upang makita kung ang halaga ay kailangang i-update sa bawat oras, pagkatapos ay isulat ang mga halaga ng kulay sa mga tamang pin. * /

void crossFade (int color ) {// 改

// convert to 0-255 int R = (color [0] * 255) / 100; int G = (kulay [1] * 255) / 100; int B = (kulay [2] * 255) / 100; int Y = (kulay [3] * 255) / 100; // 改 int W = (kulay [4] * 255) / 100; // 改

int stepR = calculStep (prevR, R);

int stepG = calculStep (prevG, G); int stepB = calculStep (prevB, B); int stepY = calculStep (prevY, Y); // 改 int stepW = calculStep (prevW, W); // 改

para sa (int i = 0; i <= 1020; i ++) {redVal = calculVal (stepR, redVal, i); grnVal = calculVal (stepG, grnVal, i); bluVal = calculVal (stepB, bluVal, i); ylwVal = calculVal (stepY, ylwVal, i); // 改 whiVal = calculVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Sumulat ng kasalukuyang mga halaga sa mga LED pin

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); analogWrite (ylwPin, ylwVal); // 改 analogWrite (whiPin, whiVal); // 改 analogWrite (grnPin2, grnVal); // 改 analogWrite (bluPin2, bluVal); // 改 analogWrite (ylwPin2, ylwVal); // 改 analogWrite (redPin2, redVal); // 改

antala (maghintay); // I-pause para sa 'wait' milliseconds bago ipagpatuloy ang loop

kung (DEBUG) {// Kung nais namin ng serial output, i-print ito sa

kung (i == 0 o i% loopCount == 0) {// simula, at bawat loopCount beses Serial.print ("Loop / RGBYW: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print ("/"); Serial.print (grnVal); Serial.print ("/"); Serial.println (bluVal); Serial.print ("/"); Serial.println (ylwVal); // 改 Serial.print ("/"); // 改 Serial.println (whiVal); // 改 Serial.print ("/"); // 改} DEBUG + = 1; }} // I-update ang kasalukuyang mga halaga para sa susunod na loop prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 antala (hawakan); // I-pause para sa opsyonal na 'wait' milliseconds bago ipagpatuloy ang loop}

Hakbang 3: Mag-set up

1. Kunin ang breadboard.

2. Demo ng pagkonekta ng mga wire upang ang isang LED light ay maaaring lumiwanag:

   1. Ilagay ang LED sa breadboard. Ilagay ang mas mahabang dulo sa kaliwa at ang mas maikling dulo sa kanan.
   2. Ilagay ang isang dulo ng isang jumper wire sa isang lugar na nasa parehong hilera na may mas mahabang dulo ng LED. Ilagay ang kabilang dulo sa seksyong Digital PWM. Tinukoy ng code ang mga dilaw na LED upang maiugnay sa 10 at 5, pula sa 6 at 11, asul hanggang 8 at 13, berde hanggang 7 at 12, at sa wakas puting LED hanggang 9.
   3. Ilagay ang isang dulo ng isang risistor sa parehong hilera na may mas maikling dulo ng LED. Ilagay ang kabilang dulo sa isang lugar na malapit.
   4. Maglagay ng isang dulo ng isa pang wire ng lumulukso na may parehong hilera na may dulo ng risistor na wala sa parehong hilera na may mas maikling dulo ng LED. Ilagay ang kabilang dulo ng kawad sa negatibong hilera ng singil.
   5. Maglagay ng pagtatapos ng isa pang wire ng jumper sa negatibong hilera ng singil at ilagay ang kabilang dulo sa GND.
3. Ulitin ang Hakbang 2 para sa 8 beses hangga't gusto mong lumiwanag ang 9 LEDs

4. Ilagay ang breadboard sa loob ng kahon. Ilang paalala dito:

   1. Gumamit ako ng isang power supply. Lumikha ng isang maliit na butas para sa iyong mga wire gamit ang isang utility na kutsilyo upang dumaan sa kahon at kumonekta sa breadboard.
   2. Tiyaking ang kahon bilang isang panig na bukas. Ang isang kahon ng sapatos ay mayroon nang isang gilid na bukas. Kung ang kahon ay ganap na sarado, gupitin ang isang gilid ng kahon upang gumawa ng isang bukas na puwang.
   3. Takpan ang gilid ng walang papel. Ito ay para sa mga ilaw na LED upang lumiwanag sa pamamagitan ng papel.