În acest experiment, adăugăm o porțiune de luminozitate LED-ului cu un buton și o reducem cu celălalt.

LISTA DE PĂRȚI PENTRU EXPERIMENT

- 1 placă Arduino Uno;

- 1 panou fara lipit;

- 2 butoane de ceas;

- 1 rezistor cu valoarea nominala de 220 Ohmi;

- 1 LED;

- 7 fire tată-tată.

SCHEMA DE CIRCUIT

DIAGRAMĂ PE PLATĂ

NOTĂ

• Dacă reluați circuitul din experimentul anterior, rețineți că de data aceasta trebuie să conectăm LED-ul la un port care acceptă PWM.

SCHIȚĂ

#define PLUS_BUTTON_PIN 2 #define MINUS_BUTTON_PIN 3 #define LED_PIN 9 int luminozitate = 100; boolean plusUp = adevărat; boolean minusUp = adevărat; void setup() ( pinMode(LED_PIN, OUTPUT); pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP); pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP); ) void loop() ( analogWrite(LED_PIN, brightness); // răspunde la clicuri folosind funcția plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35); minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35); ) // Funcție proprie cu 3 parametri: numărul pinului cu butonul // (buttonPin), starea înainte de verificare (wasUp) ) și gradația // a luminozității când faceți clic pe butonul (delta). Funcția returnează // (întoarcere în engleză) înapoi starea nouă, actuală a butonului boolean handleClick(int buttonPin, boolean wasUp, int delta) ( boolean isUp = digitalRead(buttonPin); if (wasUp && !isUp) ( delay(10) ); isUp = digitalRead(buttonPin); // dacă a existat un clic, modificați luminozitatea de la 0 la 255 dacă (!isUp) luminozitate = constrain(luminozitate + delta, 0, 255); ) return isUp; // returnează valoarea înapoi la codul apelantului)

EXPLICAȚII PENTRU COD

• Putem folosi nu numai funcții încorporate, ci și să ne creăm propriile funcții. Acest lucru este justificat atunci când trebuie să repetăm ​​aceleași acțiuni în locuri diferite din cod sau, de exemplu, trebuie să efectuăm aceleași acțiuni pe date diferite, ca în acest caz: procesăm semnalul de la porturile digitale 2 și 3.
• Vă puteți defini propriile funcții oriunde în cod, în afara codului altor funcții. În exemplul nostru, am definit o funcție după buclă .
• Pentru a ne defini propria funcție avem nevoie de:
  • Declarați ce tip de date va returna. În cazul nostru este boolean. Dacă funcția efectuează doar unele acțiuni și nu returnează nicio valoare, utilizați cuvântul cheie gol
  • Atribuiți funcției un nume - identificator. Aici se aplică aceleași reguli ca și atunci când se numesc variabile și constante. Funcțiile sunt denumite în același stil likeVariables .
  • În paranteze, enumerați parametrii trecuți funcției, indicând tipul fiecăruia. Aceasta este o declarație de variabile care sunt vizibile în cadrul funcției nou create și numai în cadrul acesteia. De exemplu, dacă în acest experiment încercăm să accesăm a fost Sus sau este sus din buclă() Vom primi un mesaj de eroare de la compilator. La fel, variabilele declarate în buclă, nu sunt vizibile pentru alte funcții, dar valorile lor pot fi transmise ca parametri.
  • Între o pereche de acolade, scrieți codul executat de funcție
  • Dacă funcția trebuie să returneze o valoare, utilizați cuvântul cheie întoarcere specificați ce valoare să returnați. Această valoare trebuie să fie de tipul pe care l-am declarat
• Așa-numitele variabile globale, de ex. Variabilele care pot fi accesate din orice funcție sunt de obicei declarate la începutul programului. În cazul nostru, asta este luminozitatea .
• În interiorul funcției pe care am creat-o handleClick Același lucru se întâmplă ca și în experiment.
• Deoarece cu un pas de creștere a luminozității de 35, după cel mult opt ​​clicuri consecutive pe unul dintre butoane, valoarea expresiei luminozitate + delta va ieși în afara intervalului . Folosind funcția constrânge limităm valorile permise pentru variabilă luminozitatea limitele intervalului specificate.
• În exprimare plusUp = handleClick(PLUS_BUTTON_ PIN , plusSup, +35) accesăm variabila plusUp de două ori. Deoarece = pune valoarea operandului din dreapta în cel din stânga, mai întâi calculând ce va reveni handleClick. Deci când îi dăm plusUp ca parametru, are încă valoarea veche calculată în timpul ultimului apel handleClick .
• Interior handleClick calculăm noua valoare a luminozității LED-ului și o scriem într-o variabilă globală luminozitatea, care la fiecare iterație buclă tocmai a trecut la analogWrite .

ÎNTREBĂRI PENTRU A VA TESTĂ

1. Ce înseamnă cuvântul cheie? gol ?
2. Cum se comportă un program atunci când o variabilă este menționată din diferite părți ale operatorului de atribuire = ?

SARCINI PENTRU SOLUȚIE INDEPENDENTĂ

1. Modificați codul astfel încât treapta de schimbare a luminozității să fie ajustată într-un singur loc.
2. Creați o altă funcție și reluați codul, astfel încât o funcție să fie responsabilă pentru urmărirea tastelor, iar alta să fie responsabilă pentru calcularea luminozității LED-ului și returnarea acestuia la analogWrite .

​

Cum se nasc programele

Acesta va fi un articol ușor neobișnuit, în care voi încerca nu doar să arăt un cod gata făcut care face ceva, ci voi arăta cum se naște un dispozitiv și firmware-ul pentru acesta. Ne vom uita la logica programului și la cum să construim această logică.

Astăzi vom rezolva următoarea problemă: există 2 LED-uri, acestea trebuie conectate la Arduino și ar trebui implementată capacitatea de a regla luminozitatea luminii lor.

Să începem!

În primul rând, trebuie să ne gândim la cum va arăta dispozitivul nostru și la ce va trebui să-l implementăm. Trebuie să ajustăm luminozitatea LED-urilor cu ceva și să vedem în ce mod funcționează LED-urile în prezent. Pentru aceasta, Scutul LCD la care ne-am uitat în ultimul articol este grozav.

Acum trebuie doar să conectăm LED-urile, așa-numitul Bradboard este grozav pentru asta, este o chestie de plastic (nu știu cum să-i mai numesc) în care poți conecta firele de la Arduino și alte componente electronice fără lipire, ceea ce este foarte convenabil atunci când nu știi exact cum va funcționa Dispozitivul sau circuitul terminat are nevoie doar de câteva lansări pentru a arăta. Chinezii nitează un număr mare de soiuri, eu personal îl folosesc pe acesta:

Pentru a înțelege mai ușor cum funcționează în interior, voi atașa o diagramă a conexiunilor interne:

Conectarea LED-urilor laArduino

Mulți vor spune acum: ce este atât de greu la conectarea unui LED, este un bec! Și vor greși, un LED este departe de a fi un simplu bec, ci un dispozitiv de iluminat cu semiconductor. Care nu este alimentat de tensiune ca un bec obișnuit, ci de curent, iar dacă curentul depășește valorile admise, LED-ul va începe să se degradeze, luminozitatea acestuia va scădea, ceea ce va deveni vizibil după ceva timp, în funcție de puterea lui. curentul fiind străpuns, sau chiar arde instantaneu.

Cum să evitați deteriorarea LED-urilor din cauza curentului ridicat? Totul este foarte simplu: trebuie să utilizați un rezistor de limitare a curentului, care trebuie calculat pentru fiecare LED în funcție de caracteristicile acestuia. Calcularea rezistențelor pentru un LED este un subiect pentru un articol separat, iar astăzi nu vom aprofunda acest subiect, deoarece cel mai probabil nu cunoașteți caracteristicile LED-ului pe care l-ați găsit undeva. În acest caz, folosesc o regulă mică: dacă LED-ul nu este luminos, atunci îl alimentez printr-un rezistor cu o rezistență de 220 până la 400 ohmi, în funcție de ce rezistență a fost la îndemână. Principalul lucru de reținut este că mai mult este mai bine decât mai puțin. Cu o rezistență mai mare decât necesită LED-ul, pur și simplu va arde mai slab decât în ​​mod normal.

Acum trebuie să decidem cum să reglam luminozitatea LED-ului; pentru aceasta puteți utiliza rezistențe variabile, care în principiu vor elimina reglarea interactivă și, prin urmare, nu vom folosi această metodă în acest articol. Vom folosi PWM implementat pe placa Arduino.

Ce este PWM

PWM (modularea lățimii impulsului) este o modificare a ciclului de lucru al unui semnal pe o anumită perioadă de timp. Semnalul de compensare are următoarea formă în comparație cu un semnal constant:

În această imagine, 100% din ciclul de funcționare este absența PWM ca atare, semnalul merge fără modificări, ca și cum ieșirea ar fi fost pur și simplu conectată la 5 volți.

Ciclul de lucru 0% este absența oricărui semnal, ca și cum firul nu ar fi conectat nicăieri.

Modurile de funcționare rămase implică comutarea rapidă a modurilor de funcționare, ceea ce face ca LED-ul să clipească cu o viteză mare, neobservat pentru ochiul uman (de 100 de ori pe secundă), ceea ce îl face să ardă cu luminozitate incompletă. Arduino, in functie de versiunea chipului folosit, are un numar diferit de iesiri PWM, pe placa sunt marcate cu semnul ~ din articolul anterior stim ca acestea sunt 6 iesiri 3, 5, 6, 9, 10, și 11, vom folosi pinii 10 și 11.

Să conectăm în sfârșit LED-urile la placă. Ne punem scutul lcd pe Arduino și asamblam următorul circuit pentru care avem nevoie de un brainboard, 2 LED-uri, 2 rezistențe de 250 ohmi și 3-4 fire tată-tată. Diagrama va arăta astfel:

Și nu uitați că LED-ul are o polaritate, piciorul lung sau strâmb al LED-ului (ca în diagramă) este un plus care este conectat printr-un rezistor.

Aici voi termina probabil prima parte a articolului; în a doua parte vom lucra la elaborarea logicii de lucru și la scrierea codului programului. Toate cele bune!

Funcția analogWrite() este folosită pentru a atenua LED-ul și pentru a-l aprinde treptat.

AnalogWrite folosește Pulse Width Modulation (PWM), care permite pornirea/oprirea pinului digital la viteză mare, generând un efect de amortizare.

Ce vei avea nevoie pentru proiect

• Placa Arduino
• Breadboard
• Dioda electro luminiscenta
• rezistor de 220 ohmi

Schema de conectare a LED-ului la Arduino

Conectați anodul (picior mai lung, pozitiv) al LED-ului la pinul digital 9 al plăcii Arduino printr-un rezistor de 220 ohmi. Conectați catodul (picior mai scurt, încărcat negativ) la masă.

Schema circuitului unui LED conectat la Arduino

Opțiune de scut cu LED pentru Arduino

Descrierea programului pentru Arduino

După declararea pinului 9 ca ledPin, corpul funcției setup() nu trebuie să fie completat.

Funcția analogWrite() pe care o veți folosi în bucla principală necesită două argumente: unul pentru a specifica pinul în care să scrieți și unul pentru a afișa valoarea PWM care este scrisă.

Pentru a aprinde treptat și a opri LED-ul, crește treptat valoarea PWM de la 0 la 255, apoi înapoi la 0 pentru a finaliza ciclul. În schița de mai jos, valoarea PWM este utilizată pentru o variabilă numită luminozitate. De fiecare dată când bucla se termină, aceasta crește valoarea variabilei.

Dacă luminozitatea își atinge valoarea limită (0 sau 255), fadeAmount își schimbă valoarea în negativă. Cu alte cuvinte, dacă fadeAmount este 5, valoarea sa se schimbă la -5. La următoarea iterație a buclei, acest lucru face ca variabila de luminozitate să se schimbe.

analogWrite() permite ca valoarea PWM să se schimbe rapid, astfel încât întârzierea de la sfârșitul schiței să controleze rata de dezintegrare. Încercați să modificați valoarea întârzierii și vedeți cum funcționează programul.

Schiță pentru Arduino IDE

Acest exemplu arată cum se asigură atenuarea pinului 9 folosind funcția analogWrite().

int led = 9; // pin la care este conectat LED-ul

int luminozitate = 0; // Luminozitatea LED-ului

int fadeAmount = 5; // cât să măresc luminozitatea LED-ului

// funcția de configurare rulează o dată după repornirea plăcii:

// declară pinul 9 ca ieșire:

pinMode(led, OUTPUT);

// bucla se repetă la nesfârșit:

// setează luminozitatea pinului 9:

analogWrite(led, luminozitate);

// schimbați luminozitatea la următoarea iterație folosind o buclă:

luminozitate = luminozitate + fadeAmount;

// schimbă valoarea de atenuare la una similară cu semnul opus la valorile limită:

dacă (luminozitate == 0 || luminozitate == 255) (

fadeAmount = -fadeAmount ;

// întârziere de 30 pentru a urmări efectul de estompare

Și să încercăm să finalizăm o nouă sarcină. Cred că toată lumea a văzut ghirlande de afișare de Anul Nou în care LED-urile clipesc lin. Să zicem că vrem să facem așa ceva.
Ne-am uitat deja la funcția digitalWrite() și știm că valoarea pe care o scrie poate fi de două opțiuni - mare sau scăzută. În acest caz, funcția analogWrite() ne va ajuta. „Formulările” funcțiilor diferă doar în prefixele inițiale, deci sunt ușor de reținut.

Funcția analogWrite(), ca și digitalWrite(), conține două argumente între paranteze și funcționează pe același principiu verbal: „unde, ce”. Principala diferență este capacitatea de a înregistra o gamă largă de valori în loc de valorile obișnuite LOW sau HIGH. Acest lucru ne va permite să reglam luminozitatea LED-ului. Principala notă de reținut este că această funcție funcționează numai pentru anumite contacte. Aceste ace sunt marcate cu simbolul „~”. Acest simbol indică faptul că acesta este un contact PWM. PWM (modularea lățimii pulsului) sună ca PWM (modulație a lățimii pulsului) în rusă. Principiul de funcționare se bazează pe modificarea duratei pulsului. Grafic, acest lucru poate fi descris astfel:

Să încercăm să ne dăm seama cum funcționează, uitându-ne la un exemplu simplu. Pentru a face acest lucru, trebuie să conectați LED-ul la contactul PWM printr-un rezistor de 150 ohmi și să „conectați” un program simplu în Arduino. Schema de conectare și codul de schiță sunt prezentate mai jos:

void setup()
{
pinMode(led,OUTPUT);
}

buclă goală ()
{
for(int i=0; i<=255; i++)
{
analogWrite(led,i);
întârziere (10);
}
pentru(int i=255; i>=0; i--)
{
analogWrite(led,i);
întârziere (10);
}
}

Cred că codul este în general clar, dar trebuie să acordăm puțină atenție buclei for(). Există așa ceva ca permisiunea. Deoarece lucrăm cu rezoluție de 8 biți (asta va fi discutată puțin mai târziu), valoarea minimă va fi 0, iar maxima va fi 255. La sfârșitul fiecărei iterații, setăm întârzierea la 10 ms.

Să ne întoarcem la diagrama din lecția anterioară și să încercăm să facem o ghirlandă similară folosind funcția analogWrite().

int buttonPin = 2;
int pini = (3,5,6,9,10,11);

boolean lastButton = LOW;
curent booleanButton = LOW;
boolean enable = fals;

void setup()
{
pinMode(buttonPin, INPUT);
for(int mode = 0; mode<= 5; mode++) pinMode(pins, OUTPUT);
}

boolean debounce (boolean ultimul)
{
curent boolean = digitalRead(buttonPin);
dacă (ultimul != curent)
{
întârziere(5);
curent = digitalRead(buttonPin);
}
curent de retur;
}

buclă goală ()
{
currentButton = debounce(lastButton);
if(lastButton == LOW && currentButton == HIGH)
{
enable = !enable;
}

Dacă (activați == adevărat)
{
pentru (int i=0; i<=5; i++)
{
pentru (int luminozitate = 0; luminozitate<= 255; brightness++)
{
întârziere(1);
}
întârziere (40);
}
pentru (int i=0; i<=5; i++)
{
pentru (luminozitate int = 255; luminozitate >= 0; luminozitate--)
{
analogWrite(pini[i], luminozitate);
întârziere(1);
}
întârziere (40);
}
}

Dacă (activați == fals)
{
for(int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}

LastButton = curentButton;
}

Sper că acest articol ți-a fost de folos. În următorul tutorial ne vom uita la întreruperile din Arduino și vom obține rezultatul dorit.

Acum să ne uităm la LED-ul multicolor, care este adesea numit prin abreviere: LED RGB. RGB este o abreviere care înseamnă: roșu - roșu, verde - verde, albastru - albastru. Adică, trei LED-uri separate sunt plasate în interiorul acestui dispozitiv. În funcție de tip, un LED RGB poate avea un catod comun sau un anod comun.

1. Amestecarea culorilor

2. Conectarea unui LED RGB la Arduino

3. Program pentru controlul unui LED RGB

4. Șapte culori ale curcubeului

• roșu
• roșu + verde = galben
• verde
• verde + albastru = albastru deschis
• albastru
• albastru + roșu = violet

5. Schimbarea lină a culorii

Sarcini

1. Indicator de temperatură. Să adăugăm un termistor la circuit și să-l conectăm la intrarea analogică. LED-ul ar trebui să-și schimbe culoarea în funcție de temperatura termistorului. Cu cât temperatura este mai scăzută, cu atât culoarea este mai albastră și cu cât temperatura este mai mare, cu atât mai mult roșu.
2. Lampa RGB cu regulator. Să adăugăm trei rezistențe variabile la circuit și să le conectăm la intrările analogice. Programul ar trebui să citească continuu valorile rezistenței și să schimbe culoarea componentei LED RGB corespunzătoare.