Šajā apmācībā mēs uzzinām, kā veikt pamata Arduino programmēšanu, izmantojot kodu piemērus un programmu paraugus. Šī apmācība var būt ārkārtīgi vērtīgs kurss visiem jaunpienācējiem, kuri vēlas apgūt pamatus, izmantojot viegli saprotamu valodu.
Ievads
Pēc vikipēdija mikrokontrolleris ir ekvivalents mini datoram, kas iebūvēts vienā IC mikroshēmā, un kam ir savs kodols procesors, programmējamas ieejas, atmiņa un izvades perifērijas ierīces.
Mikrokontrolleris kļūst tik noderīgs lietotājam, jo tas piedāvā iebūvētu procesoru, atmiņu un ievades / izvades portus (sauktus arī par GPIO vai vispārējas nozīmes ieejas / izvades tapām), kurus lietotājs var kontrolēt atbilstoši jebkurai vēlamajai specifikācijai.
Šajā apmācībā mēs strādāsim ar Arduino Uno dēli programmu apguvei un testēšanai. Aparatūras montāžas testēšanai un integrēšanai mēs izmantosim paneli.
Tagad ātri pārvietosimies un uzzināsim, kā sākt darbu ar Arduino programmēšanu.
1.2 Programmatūras instalēšana (Windows)
Lai to izdarītu, jums būs nepieciešama piekļuve internetam, kuru acīmredzot vēlaties izmantot savā datorā. Lūdzu, dodieties uz šo saiti un lejupielādējiet IDE programmatūru:
Windows ZIP fails, kas nav paredzēts administratora instalēšanai
Pēc lejupielādes lejupielādes mapē atradīsit Arduino iestatīšanas ikonu, kas izskatās šādi:
Kad esat to saņēmis, varat vienkārši veikt dubultklikšķi uz tā un instalēt datorā Arduino Integrated Development Environment (IDE). Visu procesu var vizualizēt šajā video:
https://youtu.be/x7AMn1paCeU1.4 Sākot ar mūsu pirmo trasi
Pirms sākam apgūt faktiskās programmēšanas metodes, visiem iesācējiem būtu lietderīgi sākt ar pamatkomponentu, piemēram, LED, un saprast, kā to savienot ar Arduino.
Kā mēs zinām, LED ir gaismas diode, kurai ir polaritāte un kas neiedegas, ja tā nav savienota ar pareizajiem barošanas poliem.
Vēl viens aspekts ar gaismas diodēm ir tas, ka šīs ierīces darbojas ar zemu strāvu un var uzreiz sabojāt, ja atbilstoši aprēķinātais rezistors nav iekļauts virknē ar vienu no tā tapām.
Pēc īkšķa noteikuma 330 omi 1/4 vati ir diezgan ideāli katram 5 V barošanas ieejas pieaugumam, lai ierobežotu strāvu līdz vajadzīgajam drošajam līmenim. Tāpēc 5V tas var būt 330 omi, 10V var būt 680 omi utt.
Maizes paneļa izmantošana montāžai
Lūdzu, pārliecinieties, vai zināt, kā lietot a maizes dēlis pirms šajā nodaļā izskaidrotās apmācības izmēģināšanas, jo visiem šeit veiktajiem eksperimentiem mēs izmantosim maizes dēli.
LED savienojuma pamata iestatīšanu var redzēt zemāk:
Iepriekš varat redzēt 3 pamatkomponentus:
- 5mm, 20mA LED
- 330 omu 1/4 vatu rezistors
- An Arduino dēlis
Vienkārši samontējiet sistēmu, kā norādīts diagrammā.
Pēc tam pievienojiet 5 V no datora USB uz Arduino. Tiklīdz jūs to izdarīsit, redzēsiet, ka LED iedegas.
Es zinu, ka tas ir diezgan vienkārši, bet vienmēr ir labi sākt no nulles. Esiet drošs, ka, virzoties uz priekšu, lietas sāks kļūt arvien interesantākas.
1.5 LED vadība ar Arduino
Tagad mēs uzzināsim, kā vadīt LED ar Arduino programmu.
Lai rakstītu programmu, katrā programmā jābūt vismaz 2 funkcijām.
Funkciju var saprast kā virkni programmēšanas pārskatu, kuriem var piešķirt nosaukumu, kā norādīts zemāk:
- uzstādīt() tas tiek izsaukts vai izpildīts programmas starta laikā.
- cilpa () tas tiek atkārtoti izsaukts vai izpildīts visā Arduino darbības laikā.
Tāpēc, lai arī tam, iespējams, nav praktiskas funkcionalitātes, tehniski īsāko likumīgo Arduino programmu var rakstīt šādi:
Vienkāršākā programma
void setup()
{
}
void loop()
{
}
Jūs, iespējams, pamanījāt, ka daudzās programmēšanas valodās sistēma sākas ar displeja ekrānā redzamu vienkāršu izdruku “Sveika, pasaule”.
Šīs frāzes elektroniskais ekvivalents mikrokontrolleru interpretācijā ir mirgot gaismas diodes ieslēgšanai un izslēgšanai.
Šī ir visvienkāršākā programma, kuru var uzrakstīt un ieviest, lai norādītu uz sistēmas pareizu darbību.
Mēs mēģināsim ieviest un izprast procedūru, izmantojot šādu koda daļu:
1.2. Saraksts: led1 / led1.pde
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
Labi, tagad sapratīsim, ko nozīmē katra koda rindiņa un kā tā darbojas, lai izpildītu funkciju:
const int kPinLed = 13
Tas darbojas kā konstante, kas ļauj mums to izmantot visa programmēšanas kursa laikā, neizmantojot faktisko vērtību, kas tam ir iestatīta.
Saskaņā ar standarta noteikumiem šādas konstantes tiek atpazītas ar sākuma burtu uz . Lai gan tas nav obligāti, tas padara lietas skaidrākas un saprotamākas ikreiz, kad rodas vēlme iepazīties ar koda detaļām.
void setup()
{
pinMode(kPinLed, OUTPUT)
}
Šis kods konfigurē konkrēto tapu, pie kuras ir piestiprināts mūsu LED. Citiem vārdiem sakot, kods liek Arduino kontrolēt šīs tapas “rakstīšanas” aspektu, nevis “lasīt” to.
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
Iepriekš minētās rindas norāda lietojumprogrammas faktisko izpildi. Kods sākas ar attiecīgā LED savienojuma uzrakstīšanu un pārveidošanu HIGH, ieslēdzot LED.
Šeit termins HIGH vienkārši nozīmē iegūt + 5V uz attiecīgā Arduino tapas. Papildinošais termins LOW vienkārši norāda nulli vai 0V uz norādītās tapas.
Tālāk mēs saucam delay() kuras funkcija ir radīt aizkavi caur milisekundēm (1/1000 sekundes). Tā kā ir ievadīts skaitlis 500, izpildītā aizkave būs 1/2 sekundes.
Tiklīdz šī 1/2 sekunde ir beigusies, tiek izpildīta nākamā rinda, kas izslēdz gaismas diodi ar LOW terminu tajā pašā tapā.
Turpmākā līnija atkal ģenerē 1/2 sekundes aizkavi, lai ļautu LED palikt izslēgtai 1/2 sekundes.
Un process turpinās bezgalīgi, izpildot koda rindas, ja vien Arduino tiek darbināts ar barošanu.
Pirms pāriet uz nākamo līmeni, es iesaku jums ieprogrammēt iepriekš minēto kodu un pārbaudīt, vai jūs spējat pareizi ieviest LED ON / OF secību.
Tā kā noklusējuma gaismas diode Arduino ir savienota ar tapu Nr. 13, tai nekavējoties jāatbild uz iepriekš minēto programmu un jāsāk mirgot. Tomēr, ja atklājat, ka jūsu ārējā gaismas diode nemirgo, iespējams, ar LED ir saistīta savienojuma kļūda, varat mēģināt mainīt sava LED polaritāti un, cerams, redzēt, ka tas arī mirgo.
Jūs varat spēlēt ar aizkaves laiku, mainot skaitli “500” uz kādu citu vērtību un atrodot LED, kas “klausās” komandas un liek tai mirgot atbilstoši norādītajām aizkaves vērtībām.
Bet atcerieties, ja redzat, ka gaismas diode nemirgo ar nemainīgu 1 sekundes ātrumu, neatkarīgi no kavēšanās laika izmaiņām, tas var norādīt, ka kods nedarbojas kādas kļūdas dēļ. Tā kā pēc noklusējuma Arduino tiks ieprogrammēts ar 1 sekundes mirgošanas ātrumu. Tāpēc, lai apstiprinātu tā pareizu darbību, šim ātrumam ir jāmainās ar kodu.
1.7 Komentāri
Kodu rindas, kuras mēs iepriekš sapratām, tika īpaši rakstītas datoru programmatūrai.
Tomēr, lai nodrošinātu, ka lietotājs var atsaukties uz līniju nozīmi un to saprast, bieži vien var būt lietderīgi un saprātīgi paskaidrojumu ierakstīt blakus vēlamajām kodu rindām.
Tos sauc komentārus kas ir rakstīti tikai cilvēkiem vai lietotājiem un ir kodēti, lai ļautu datoriem to droši ignorēt.
Šo komentāru valoda ir rakstīta ar dažiem formātiem:
- Komentāra bloķēšanas stils, kur komentāra apraksts ir pievienots zem sākuma simbola / * un beigu simbola * /
- Tam nav jāierobežo vienā rindā, drīzāk to var attiecināt uz nākamajām nākamajām rindām atkarībā no komentāra vai apraksta garuma, kā parādīts šajā piemērā:
/ * Šis ir komentārs * /
/ * Tā tas ir * /
/* Un
* šo
* kā
* labi * /
Lai rakstītu ātru vienas rindas aprakstu komentāram, pietiek ar diviem slīpsvītras // simboliem sākumā. Tas norāda datoram, ka šai rindai nav nekāda sakara ar faktisko kodu, un tā ir jāignorē. Piemēram:
// Šis ir komentārs, kuru datori ignorēs.
Šeit ir atsauces piemērs:
/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/
/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
1.8 Traucējummeklēšana
Ja sastādīšanas laikā jūsu programmā parādās “kļūda” vai kāda cita problēma, šie padomi, iespējams, palīdzēs jums vēlreiz pārbaudīt kodu, lai atbrīvotos no šķēršļiem.
- Jūsu programmas valoda būs reģistrjutīga. Piemēram izteiciens myVar nevar rakstīt kā MyVar.
- Visu veidu atstarpes, kuras var izpildīt, ievadot tastatūru, galu galā tiek atveidotas kā viena atstarpe, un to redzat vai saprotat tikai jūs, dators to neņems vērā. Vienkārši sakot, jebkura veida brīvās vietas neietekmēs koda rezultātus.
- Katram koda blokam jāpievieno kreisās un labās cirtainās iekavas, “{” un '}'
- Skaitļu ciparus nedrīkst atdalīt ar komatiem. Piemēram, 1000 var nebūt rakstīts kā 1000.
- Katrai koda līnijai, kas atrodas starp cirtainajām iekavām, jābūt pabeigtai ar semikolu
Interesantas LED gaismas secības izveidošana ar Arduino
Iepriekšējā nodaļā mēs uzzinājām, kā nepārtraukti mirgot LED ON / OFF ar pastāvīgu kavēšanās ātrumu.
Tagad mēs uzzināsim, kā vienā un tajā pašā LED var izpildīt dažādus kavēšanās modeļus, jauninot programmas kodu.
Mēs neizmantosim ārēju LED, drīzāk izmantojiet noklusējuma LED, kas iebūvēts Arduino dēlī pie tapas # 13. Šo mazo SMD LED var atrast tieši aiz USB savienotāja.
2.2 IF paziņojumu izpratne
Šajā sadaļā mēs uzzināsim, kā vadības struktūras ļauj mums vadīt atsevišķus kodus un dažreiz pat atkārtoti, kā nepieciešams.
Paziņojums ja kļūst par 1. kontroles struktūru. Šī ieviešana parāda, kā tā tiek izmantota:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
Mēs centīsimies pakāpeniski saprast iepriekš minēto kodu un uzzināt, kā to var izmantot citām līdzīgām izpildēm.
Kodi starp 1. un 7. rindu ir tieši līdzīgi mūsu sākotnējai programmai.
Pirmā modifikācija faktiski notiek 8. līnijā.
int delayTime = 1000
Jūs varat atrast, ka tas ir līdzīgs kodam 1. rindā, neļaujot tam, ka tajā trūkst termina konst.
Tas vienkārši tāpēc, ka šis kods nav konstante. Tā vietā tas tiek definēts kā mainīgais , kam programmēšanas gaitā ir mainīgas vērtības īpašība.
Iepriekš minētajā piemērā varat redzēt, ka šim mainīgajam tiek piešķirta vērtība 1000. Atcerieties, ka šādiem mainīgajiem, kas ir iekļauti cirtainās iekavās, jābūt stingri rakstāmiem tikai cirtaino iekavu pāros un tos sauc par “lokālajiem” mainīgajiem.
Alternatīvi mainīgie, kas, domājams, atrodas ārpus cirtainām iekavām, piemēram, tie, par kuriem mēs tagad runājam, tiek atzīti par 'globāliem', un tos var izpildīt gandrīz visur programmas kodā.
Pārejot uz priekšu, jūs varat redzēt, ka kodi starp 9. un 11. rindiņu arī ir līdzīgi pirmajai programmai, tomēr pēc 11. rindas lietas sāk kļūt interesantas. Paskatīsimies, kā!
delayTime = delayTime - 100
Šajā kodā mēs redzam, ka noklusējuma vērtība delayTime tiek modificēts, no tā atņemot 100.
Nozīme 100 tiek atskaitīta no sākotnējās vērtības 1000, nodrošinot tai jaunu vērtību 900.
Izmantojot šo attēlu, mēs centīsimies izprast dažus matemātikas operatorus, kas tiek izmantoti Arduino valodā.
Tagad novērtēsim kodus starp 13. un 15. rindu.
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
Iepriekš minētā koda galvenais mērķis ir nodrošināt, ka gaismas diode turpina mirgot bez pārtraukumiem.
Sakarā ar to, ka 100 tiek atņemti no oriģināla delayTime , tas neļauj mirgot gaismas diodei sasniegt nulli un ļauj nepārtraukti mirgot.
Šajā attēlā parādīti daži salīdzināšanas operatori, kurus mēs izmantosim savos kodos:
Iepriekš minētajā kodā mēs varētu būt pārbaudījuši kodu kā if(delayTime == 0).
Tomēr, tā kā būt negatīvam skaitlim var būt vienlīdz slikti, mēs to nedarījām, un tā ir ieteicama prakse.
Padomājiet, kāds varētu būt rezultāts, ja mēs mēģinātu no delayTime atskaitīt 300, nevis 100?
Tagad jūs, iespējams, esat sapratuši, ka, ja delayTime ir rakstīts kā mazāks vai vienāds ar nulli, tad aizkaves laiks tiks iestatīts atpakaļ uz sākotnējo skaitli 1000.
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
Pēdējās 4 koda rindiņas, kā parādīts iepriekš, kļūst atbildīgas par LED ieslēgšanu / izslēgšanu, nepārtrauktu ieslēgšanu / izslēgšanu.
Šeit jūs varat skaidri pamanīt, ka tā vietā, lai izmantotu skaitli, mēs esam izmantojuši mainīgo, lai piešķirtu aizkaves laiku, lai mēs to varētu pielāgot pēc vēlēšanās koda darbības periodā. Tas ir forši, vai ne?
2.3. CITI paziņojumi
Šeit mēs uzzināsim, kāpēc un kā ja termiņā var būt klauzula cits lai tā izlemtu situāciju gadījumā ja apgalvojums ir nepatiess.
Man žēl, ja tas izklausās pārāk mulsinoši, neuztraucieties, mēs centīsimies to saprast ar šādu piemēru:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
Iepriekš redzams, ka 10. rindas kods tiek izpildīts tikai tad, kad delayTime ir mazāks vai vienāds ar 100, ja ne, tad tiek izpildīts kods 13. rindā, bet abi kopā nekad nevar notikt, tiks ieviests ne 10., ne 13. līnijas kods, nekad abi.
Jūs, iespējams, pamanījāt, ka atšķirībā no tā, ko mēs darījām iepriekšējā 2.2. Sadaļā, šeit mēs nesalīdzinājām ar 0, drīzāk ar 100. Tas ir tāpēc, ka šajā piemērā salīdzināja PIRMS mēs atņemām 100, pretēji 2.2. Sadaļā, mēs PĒC mums atņemts. Vai jūs varat pateikt, kas varēja notikt, ja mēs salīdzinātu 0, nevis 100?
2.4 KAMĒR paziņojumi
TO kamēr paziņojums ir diezgan līdzīgs ja paziņojumu, izņemot patiesību, ka tas izraisa atkārtotu izpildi koda blokam (kas var būt starp cirtainajām iekavām) tik ilgi, kamēr tiek piemēroti nosacījumi, un tas darbojas bez cits paziņojums, apgalvojums.
Šis piemērs palīdzēs jums to labāk izprast
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}
Vai varat uzminēt, kam ieprogrammēts iepriekš minētais kods? Nu, tas ir paredzēts, lai mirgot LED ātrāk un pēc tam lēnāk.
2.5 Kas ir patiess un nepatiess?
Programmēšanas valodā nepatiesa attiecas uz nulli (0). Patiesībā netiek izmantots “true”, tā vietā tiek pieņemts, ka tad, kad nekas nav melīgs, tad viss, kas ir iekļauts, ir patiess.
Tas izskatās nedaudz dīvaini, tomēr darbu paveic diezgan jauki.
Mēs mēģināsim izprast situāciju, izmantojot šādu piemēru.
Dažreiz jūs varat saskarties ar kodu, kā norādīts zemāk:
while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}
Tas ir kodēts, šķiet, ka LED izpilde turpinās riteņbraukšanu uz visiem laikiem, jo ir pieejama ilgstoša jauda.
Tomēr viens šāda veida koda mīnuss varētu rasties, ja nejauši lietotājs = = vietā lieto a =.
Esmu pārliecināts, ka jūs jau zināt, ka = apzīmē uzdevumu, tas nozīmē, ka to izmanto, lai mainīgajam apzīmētu atlasīto vērtību, savukārt a == tiek izmantots testa izpildei, ja vērtība bija vienāda.
Piemēram, pieņemsim, ka jums vajadzēja, lai LED mirgo ar secīgu ātruma pārsniegšanas modeli un atkārtojas, bet nepareizi izmantojāt =, nevis ==.
Tad kods parādīsies šādi:
int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
Kļūda piešķirs 0 delayTime un novedīs pie ja paziņojums, lai pārbaudītu, vai 0 bija patiesa vai nē. Tā kā 0 norāda uz nepatiesu, tā uzskatīs, ka tā nav taisnība, un pārtrauks delayTime = 1000 izpildi, bet tā vietā funkcija delayTime tiek turēts 0 cilpas laikā ().
Tas izskatās ļoti nevēlami !!
Tāpēc vienmēr pārbaudiet savu programmu, lai pārliecinātos, vai neesat pieļāvis tik dumjš kļūdas.
2.6 Kombinācijas
Dažreiz jūs varat sajust nepieciešamību pārbaudīt vairākas lietas kopā. Tāpat, iespējams, vēlēsities pārbaudīt, vai mainīgais ir bijis starp diviem skaitļiem. Lai gan to var īstenot, izmantojot paziņojumu if vairākas reizes, labākai un ērtākai lasīšanai var būt ērtāk izmantot loģiskās kombinācijas.
Kombināciju ieviešanu loģiskos terminos var veikt ar 3 metodēm, kā parādīts šajā tabulā:
Būtu interesanti uzzināt, ka NOT operators var strādāt kā komutators mainīgajam, kuru var apzīmēt kā vienu vai otru taisnība vai nepatiesa (vai ZEMS vai AUGSTS).
Šis nosacījums ilustrē šo piemēru:
int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}
Šeit ledState būs ZEMS, un pēc tam, tiklīdz ledState = !ledState, tas pagriezīsies AUGSTS. Šī cilpa izraisīs ledState būt AUGSTAM, kad ledState = !ledState ir ZEMS.
2.7 PAR paziņojumiem
Tagad mēs centīsimies izprast citu vadības struktūru, kas ir priekš cilpa. Tas var būt ļoti ērti, ja vēlaties kaut ko ieviest vairākas reizes.
Sapratīsim to ar šādu piemēru:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}
Rindā ar jūs varat atrast kaut ko unikālu priekš.
Tas ir kods i ++? . Tas ir noderīgi programmētājiem, kuri ir diezgan slinki un vēlas ieviest kodēšanu, izmantojot ērtas saīsnes
Iepriekš minētais termins ir pazīstams kā saliktie operatori, jo viņi veic darbu, apvienojot vienu piešķiršanas operatoru ar citu piešķiršanas operatoru. Populārākos no tiem var vizualizēt šajā tabulā:
Jūs atradīsit, ka paziņojumā for ir 3 apakšparaugi. Tas ir strukturēts, kā parādīts zemāk:
for (statement1conditionstatement2){
// statements
}
Paziņojums Nr. 1 notiek pašā sākumā un tikai vienu reizi. Stāvoklis tiek pārbaudīts katru reizi cikla laikā. Kad vien tas ir taisnība krokainajās iekavās tiek izpildīts nākamais paziņojums Nr. 2. Gadījumā, ja nepatiesa, sistēma pāriet uz nākamo koda bloku.
Pievienojot vairāk gaismas diodes
Labi, tagad mēs redzēsim, kā mēs varam savienot lielāku skaitu LE, lai iegūtu interesantākus efektus.
Lūdzu, pievienojiet gaismas diodes un Arduino, kā parādīts zemāk. Sarkanais vads patiesībā nav nepieciešams, taču, tā kā vienmēr ir laba ideja, ja maizes dēlī ir iekļautas abas piegādes sliedes, izveidotajai ierīcei ir jēga.
Tagad salabosim programmu, kas ļaus mums pārbaudīt, vai mūsu aparatūra ir pareizi konfigurēta.
Vienmēr ieteicams kodēt un izpildīt nelielus programmu bitus pa solim, lai pārbaudītu, vai attiecīgās aparatūras ir pareizi savienotas vai nav.
Tas palīdz ātri novērst iespējamo kļūdu.
Zemāk redzamajā kodu piemērā LED 2 līdz 5 ir noteikts paraugs, cikliski pagriežot tos vienu pēc otra.
const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}
Kā jūs pamanāt, kodam nav nekā nepareiza, izņemot faktu, ka tas izskatās garš un tāpēc pakļauts kļūdām.
Protams, ir labāki veidi, kā uzrakstīt iepriekš minēto kodu, nākamajā sadaļā tas tiks atklāts.
2.9. Masīvu ieviešana
Masīvi var būt mainīgo grupa, kuru var indeksēt ar indeksa numuriem. Šis piemērs palīdzēs mums to labāk izprast.
const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i
}
}
void loop()
{
for(int i = 0 i
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}
Labi, tagad apskatīsim katru sadaļu un sapratīsim, kā tās faktiski darbojas.
const int k_numLEDs = 4
Iepriekš minētais kods nosaka, cik daudz maksimālo elementu mums vajadzētu būt masīvā. Šis kods palīdz mums nākamajās sadaļās pārliecināties, ka viss ir ierakstīts masīvā un nekas, kad masīvs beidzas.
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
Šajā nākamajā rindā mēs izveidojām masīva struktūru. Skaitļi iekavās norāda masīva elementu skaitu. Lai gan faktisko daudzumu varēja uzrakstīt, rakstīšana kā konstantes darbojas labāk. Vērtības parasti var redzēt iekavas iekšpusē ar komatiem, un tās norāda masīvam.
Atrodot masīvu, kas indeksēts ar skaitli 0, tas norāda masīva pirmo elementu, kā parādīts code: k_LEDPins is k_LEDPins[0]
Līdzīgi pēdējais elements tiks parādīts kā k_LEDPins[3], jo skaitlis no 0 līdz 3 ir 4.
void setup()
{
for(int i = 0 i
}
}
Iepriekš minētais kods parāda cilpas izmantošanu, lai veiktu katru masīva elementu un iestatītu tos kā OUTPUTS. Mēs ieviešam kvadrātiekavas kopā ar indeksu, lai sasniegtu katru no masīva elementiem.
ja jūs domājat, vai ir iespējams izmantot tapu # 2, lai piespraustu # 5 bez masīviem, atbilde ir jā, tas ir iespējams. Bet šajā piemērā tas netiek darīts, jo mēs to nedarījām tādā veidā. Turpmākajās sadaļās varat izslēgt masīva pieeju, ja atlasītās izvades tapas nav vienā līnijā.
Pārejot uz priekšu, redzēsim, ko dara nākamais koda bloks:
for(int i = 0 i
delay(100)
}
Šeit kods iet caur katru no LED, lai tos secīgi ieslēgtu ar atstarpi vai kavēšanos 100 milisekundes.
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
Izmantojot iepriekš minēto kodu, parādīts, kā par cilpu varētu izmantot, lai pārvietotos pa cilpu pat apgrieztā secībā.
Tas sākas no k_numLEDs - 1, jo masīvi ir indeksēti ar nulli. Mēs nesākam no k_LEDPins[4] jo tas novestu pie masīva finiša šķērsošanas.
Kods izmanto> = 0, lai pārbaudītu, vai indeksā 0 pirmais elements netiek palaists garām vai ignorēts.
3. nodaļa
Kas ir ievads
Tātad, vai mēs esam iemācījušies vadīt lietas, izmantojot Arduino. Šajā nodaļā mēs apspriedīsim, kā sajust reālo pasauli, saskaroties ar ieejām no ārējiem parametriem.
3.1 Spiedpogu izmantošana
Mēs visi zinām, kas ir spiedpoga un kā tā darbojas. Tas ir sava veida slēdzis vai poga, kas īslaicīgi savieno signālu no vienas ķēdes pakāpes ar otru, kamēr tas ir nomākts, un, atlaižot, pārtrauc signālu.
3.1.1 Viena poga un gaismas diode
Mēs savienosim Arduino ar spiedpogu ar Arduino, kā norādīts iepriekš parādītajā detaļā, un uzzināsim iestatīšanas pamatdarbību un ieviešanu.
Norādītajai spiedpogai, ko dēvē arī par mikroslēdža spiedpogu, kopumā ir 4 tapas (2 pāri katrā pusē). Nospiežot, katrs tapu pāris tiek savienots iekšpusē un nodrošina savienojumu vai vadīšanu pāri tiem.
Šajā piemērā mēs izmantojam tikai vienu šo tapu vai kontaktu pāri, otram pārim nav nozīmes, tāpēc tas tiek ignorēts.
Turpināsim piemērot šo kodu un pārbaudīt, vai tas darbojas!
const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
Šeit jūs varat atrast dažas lietas, kas izskatās neparasti. Izdomāsim tos gudri.
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
Pirmā lieta, ko mēs darām, ir salabot buttonPin kā IEVADE. Nu, tas ir diezgan vienkārši, es zinu.
Tālāk mēs piešķiram AUGSTS uz IEVADE piespraust. Jūs brīnums, kā var būt iespējams kaut ko uzrakstīt pie ievades? Protams, tas var būt interesanti.
Faktiski, piešķirot AUGSTU Arduino ieejai, tiek ieslēgts iekšējais 20 k omu pievilkšanas rezistors IESLĒGTS (LOW šajā tapā to izslēdz).
Vēl viens jautājums, kas jums varētu būt, ir kāds ir pievilkšanas rezistors. Esmu aplūkojis visaptverošu ziņu par pievilkšanas rezistoriem, ko jūs iemācies to šeit .
Labi, pārejot tālāk, tagad apskatīsim galveno cilpu kodu:
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
Nospiežot spiedpogu, vadu tapa tiek savienota ar zemi, kas padara a ZEMS uz to tapu. Un, kamēr tas nav saspiests, tiek turēta tā pati tapa AUGSTS vai + 5V caur 20K iekšējo pievilkšanas rezistoru.
Šeit mēs vēlamies, lai Arduino iedegtos gaismas diode, kad tiek nospiesta spiedpoga (LOW), tāpēc katrai LOW atbildei no spiedpogas, kamēr tā tiek nospiesta, izejai ierakstām HIGH.
3.1.2 Divas pogas un gaismas diode
Nu, jūs varētu domāt, ka iepriekš parādīto darbību varēja izdarīt arī bez Arduino. Es saprotu, tomēr tas ir akmeņains akmens, lai uzzinātu, kā spiedpogu var izmantot ar Arduno.
Līdz šim brīdim mēs esam izpētījuši kodu rakstīšanu vai nu ieslēgt (HIGH), vai izslēgt (LOW) LED.
Tagad redzēsim, kā LED spilgtumu varēja kontrolēt ar Arduino.
To var izdarīt, izmantojot divas metodes:
- Ierobežojot strāvas daudzumu līdz LED
- Izmantojot PWM vai impulsa platuma modulācija, kurā LED piegāde tiek ļoti ātri ieslēgta / izslēgta ar vēlamo ātrumu, radot vidējo apgaismojumu, kura intensitāte būtu atkarīga no PWM.
Arduino dēlī PWM atbalsts ir pieejams tapām, kas apzīmētas ar tildi (~), kas ir tapas 3, 4,5,9,10 un 11) 500 Hz frekvencē (500 reizes sekundē). Lietotājs var norādīt jebkuru vērtību no 0 līdz 255, kur 0 norāda ne uz HIGH, ne uz + 5V, un 255 saka Arduino visu laiku iegūt HIGH vai + 5V. Lai sāktu šīs komandas, jums būs jāpiekļūst analogWrite () ar vēlamo vērtību.
Varat pieņemt, ka PWM ir x / 255, kur x ir vēlamā vērtība, kuru vēlaties nosūtīt, izmantojot analogWrite()
Iestatiet Arduino un citus parametrus, kā parādīts iepriekš.
const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}
Šeit jūs varat atrast 3 rindiņas, kurām nepieciešams zināms paskaidrojums.
ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)
Līnija: ledBrightness = constrain(ledBrightness, 0, 255) ilustrē unikālu funkciju Arduino, kas pazīstama kā constrain ().
Šī iekšējā funkcija ietver kodu, kas ir līdzīgs šādam:
int ierobežot (int vērtība, int min, int max) {
if(value > max){
value = max
}
if(value
}
return value
}
Visi kodi, kas tika apspriesti pirms šī, sākās ar spēkā neesošs , kas nozīmēja neko neatdot (spēkā neesošu). Tā kā iepriekšējais kods sākas ar int , kas norāda, ka tas atgriež veselu skaitli. Mēs par to vairāk apspriedīsim nākamajās sadaļās, šobrīd vienkārši atcerieties, ka veselam skaitlim nav daļēju daļu.
Pareizi, tāpēc tas nozīmē kodu: ledBrightness = constrain(ledBrightness, 0, 255) piešķir ledBrightness to be within the range of 0 and 255.
Nākamajā rindā strādā analogWrite lai komandas Arduino izvēlētajā tapā norādītu PWM ar vēlamo vērtību.
Nākamā rinda rada 20 milisekunžu aizkavi, tas ir, lai nodrošinātu, ka mēs nepielāgojam ēdienu ātrāk par 50 Hz vai 50 reizes sekundē. Tas ir tāpēc, ka cilvēki var būt daudz lēnāki nekā Arduino. Tādējādi, ja kavēšanās netiek veikta, programma varētu likt mums sajust, ka, nospiežot pirmo pogu, LED ir izslēgts un nospiežot otro taustiņu, tas ir IESLĒGTS (izmēģiniet pats, lai apstiprinātu).
3.2 Potenciometri
Ejam uz priekšu un uzzinām, kā to izmantot potenciometri ar Arduino.
Lai uzzinātu, kā darbojas potenciometrs vai katls, varat to izlasīt rakstu .
Savienojiet parādītos parametrus ar Arduino, kā parādīts iepriekš.
Katlā būs 3 spailes. Vidējais terminasls ar Arduino savienosies ar ANALOG IN 0. Pārējos divus ārējos spailes var savienot ar + 5V un 0V barošanas sliedēm.
Programmēsim un pārbaudīsim rezultātus:
const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}
Jūs atradīsit dažas lietas, kas var izskatīties pilnīgi jaunas un nav iekļautas nevienā no mūsu iepriekšējiem kodiem.
- Pastāvīgā
kPinPottiek piešķirts kā A0, kur A ir saīsne, lai aprakstītu vienu no analogajām tapām. Tomēr A0 attiecas arī uz tapu Nr. 14, A1 uz tapu Nr. 15 un tā tālāk, un tie ļauj izmantot kā digitālās ieejas / izejas, ja eksperimentam pietrūkst kontaktu. Bet atcerieties, ka digitālās tapas nevar izmantot kā analogās tapas. - Līnija:
ledBrightness = map(sensorValue, 0, 1023, 0, 255)piedāvā jaunu iekšējo funkciju Arduino, kas pazīstama kā karte (). Šī funkcija atkārtoti kalibrē no noteiktā diapazona uz citu, ko sauc par karte (vērtība, noLow, fromHigh, toLow, toHigh). Tas var kļūt izšķiroši, joanalogueReadizsniedz vērtību diapazonā no 0 līdz 1023, bet analogWrite spēj pieņemt vērtību no 0 līdz 255.
Jūs domājat, ka, tā kā ir iespējams kontrolēt gaismas diodes spilgtumu, mainoties pretestībai, šim nolūkam varēja pietikt ar podu, kāpēc izmantot Arduino. Nu, atkal tas ir tikai pamats, lai parādītu, kā podu varētu konfigurēt ar Arduino.
Nav problēmu, tagad mēs darīsim kaut ko tādu, ko nevar izdarīt bez Arduino.
Šajā eksperimentā mēs redzēsim, kā katla mainīgo pretestību varētu izmantot, lai kontrolētu gaismas diode mirgošanas ātrumu vai ātrumu.
Lūk, programma:
const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}
3.2.3 Izvairīšanās no kavēšanās ()
Iepriekš minētais kods izskatās labi, bet gaismas diode nespēj pārbaudīt pot vērtību, kamēr tā neiziet cauri katram pilnam ciklam. Ilgākas kavēšanās gadījumā šis process kļūst ilgāks. Lietotājam ir jāgaida, lai redzētu pot atbildi, kamēr viņš to pārvieto. Šo aizkavēšanos var novērst, izmantojot kādu viedu programmēšanu, lai tas ļautu lietotājam pārbaudīt vērtību bez minimālas kavēšanās. Lūk, kods.
const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}
Tātad, kas atšķiras iepriekš minētajā kodā? Atšķirība ir nākamajā rindā.
long lastTime = 0
Līdz šai sadaļai mēs esam apsprieduši mainīgo int. Tomēr var būt daudz vairāk veidu mainīgo, kuriem varat piekļūt. Sarakstu var lasīt zemāk:
Pašlaik var būt tikai svarīgi zināt, ka, lai uzglabātu salīdzinoši lielu skaitu int mainīgais, jūs varētu izmantot terminu ilgi vai a ilgi int.
Šeit jūs varat redzēt vēl vienu interesantu funkciju, ko sauc milis ().
Tas rada laika intervālu milisekundēs, ko Arduino strādāja darbības laikā no sākuma (tas tiks atiestatīts uz 0 pēc katrām 50 dienām). Šeit tas atgriežas ilgi, jo, ja tas atgriezās int , skaitīšana uz ilgu laiku var nebūt iespējama. Vai jūs varētu precīzi atbildēt, cik ilgi? Atbilde ir 32,767 sekundes.
Tāpēc, tā vietā, lai izmantotu aizkavi (), mēs pārbaudām milis (), un, tiklīdz konkrētais milisekunžu skaits beidzas, mēs mainām gaismas diode. Līdz ar to mēs glabājam laiku, kad to mainījām pēdējoreiz pēdējo reizi mainīgais, lai tas ļautu mums to pārbaudīt vēlreiz, kad vien vēlaties.
3.3 RGB gaismas diodes
Līdz šim mēs spēlējām ar vienas krāsas LED. Lai gan LED krāsu varēja mainīt, aizstājot LED ar citu krāsu, bet kā būtu ar RGB LED izmantošanu lai mainītu LED krāsas nemainot gaismas diodes?
RGB gaismas diodis būtībā ir gaismas diode ar sarkanu, zaļu un zilu LED, kas ir iestrādāta un apvienota vienā LED. Tam ir viens kopīgs vads, kas nonāk zemē vai 0V barošanas sliedē, bet pārējie 3 vadi tiek baroti ar daudzveidīgiem PWM pozitīviem signāliem, lai īstenotu paredzēto krāsu sajaukšana .
Jūs varat pieslēgt iestatīšanu, kā parādīts zemāk:
Tas var izskatīties nedaudz sarežģīts, bet patiesībā tas ir mūsu agrākā LED vadības dizaina kopija, izmantojot PWM.
Šeit ir prakses programmas kods:
const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}
Pēc šī koda augšupielādes vienkārši redziet, kā katla korekcijas rada interesantu gaismas efektu uz RGB, tas var būt īsts prieks.
Jūs atradīsit, ka tad, kad visi 3 podi tiek pārvietoti maksimāli, baltas krāsas vietā jūs redzēsiet sarkanu. Tas ir tāpēc, ka sarkanā krāsa ir visizcilākā starp 3 krāsām un tāpēc dominē šajā situācijā. Tomēr jūs varat eksperimentēt ar šo funkciju karte () , pirms to izpildāt sarkanajā gaismas diodes daļā, lai izveidotu saprātīgāku līdzsvaru.
Audio ar Arduino
Šajā sadaļā mēs uzzināsim, kā pievienot pamata skaņu un mūziku Arduino iestatījumam.
Mēs redzēsim, kā pārslēgt signālu uz pievienoto skaļruni ar vēlamo frekvenci.
Pareizāk sakot, tiks izmēģināta vidējā piezīme, kas ir 440 Hz frekvences piezīme.
Lai to izdarītu, mēs vienkārši atskaņosim vidējo A piezīmi un optimizēsim sinusa viļņa signālu ar kvadrātveida viļņu.
Mēs arī aprēķināsim, cik ilgi skaļrunis var palikt ieslēgts, iesūdzot šo formulu:
timeDelay = 1 sekunde / 2 x toneFrequency.
timeDelay = 1 sekunde / 2 x 440
timeDelay = 1136 mikrosekundes
4.1 Saķersim Arduino dēli
4.2 Vienkāršas piezīmes pievienošana
Mēs jau esam apsprieduši par funkciju kavēšanās () kur vienība ir milisekundēs (sekunde / 1000), tomēr jūs atradīsit vēl vienu funkciju delayMicroseconds() kur vienība atrodas mikrosekundēs (milisekundes / 1000).
Pašreizējai uzstādīšanai mēs ieprogrammējam kodu, lai ieslēgtu / izslēgtu + 5 V izvēlētajā tapā, kas savienota ar skaļruni, ar ātrumu 440 impulsi sekundē.
Atgādināsim, ka pēdējā diskusijā paredzētajai audio piezīmei mēs noteicām vērtību 1136 mikrosekundes.
Tātad, lūk, šim nolūkam paredzēta programma, kas ļaus dzirdēt 440 Hz audio piezīmi, tiklīdz programmējat arduino ar pievienotu skaļruni.
const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}
Izmantojot iepriekš minēto lietojumprogrammu, ir iespējams izveidot audio piezīmi, kas arī nozīmē, ka mēs varam izveidot mūziku pēc savas izvēles.
Pēc koda mēs saprotam, ka Arduino ietver pāris integrētas funkcijas, kas papildus veicina mūzikas radīšanu.
Pirmais ir tonis () kas darbojas ar 2 elementiem kopā ar trešo izvēles elementu, kas apzīmēts kā tonis (piespraude, biežums, ilgums). vai tonis (piespraude, frekvence)
Abi ir paredzēti, lai izpildītu atbilstošo laika periodu, kuru esat noteicis.
Ja nav laika perioda, mūzikas atskaņošana turpinās līdz zvanam tonis () tiek izpildīts vēlreiz vai līdz izpildei notone ().
Tas būs jādara, izmantojot aizkaves funkciju, ja mūzikas atskaņošana ir vienīgā būtiskā lieta, ko jūs īstenojat.
Laika ilgumam var būt izšķiroša nozīme, jo tas ļauj noteikt laiku, cik ilgi mūzika tiek atskaņota, tāpēc vai jūs varat brīvi darīt citas lietas. Tiklīdz ilgums zaudē spēku, mūzika apstājas.
Nākamā funkcija noTone () apstrādā vienu parametru un aptur izvēlēto signālu konkrētajā piešķirtajā tapā.
Īpatnējs brīdinājums: Jebkurā laikā tonis () funkcija ir ieviesta, PWM funkcija uz tapām 3 un 11 pārstās darboties.
Tāpēc ikreiz, kad programmā tiek izmantots skaļruņu stiprinājums, pārliecinieties, ka skaļruņiem neizmantojat minēto tapu, tā vietā izmēģiniet citus skaļruņu piestiprināšanas tapas.
Labi, tāpēc šeit ir programma mūzikas ieviešanai skaļrunī, lai gan tā nav īsta mūzika, drīzāk bāzes skalas C piezīme.
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
Iepriekš minētajā kodā jūs, iespējams, pamanījāt kaut ko jaunu, un tas arī ir #define .
Kamēr tiek veikta kompilēšana, šis termins darbojas kā datora meklēšana un aizstāšana.
Ikreiz, kad tā atrod pirmo lietu pirms atstarpes, tā aizstāj to ar atlikušo līnijas daļu (sauktu par makro).
Tātad šajā piemērā, kad dators redz PIEZĪME_E4 tas to ātri aizstāj ar daudzumu 330.
Lai iegūtu vairāk piezīmju un pielāgošanu, varat atsaukties uz failu savā USB zibatmiņā ar nosaukumu piķi.h , kur lielāko daļu frekvenču var atrast pēc jūsu izvēles.
4.4 Mūzika ar funkcijām
Iepriekš redzamais kods izskatās labi, bet, šķiet, ir daudz atkārtojumu, vai vajadzētu izmantot kādu metodi, lai saīsinātu šos atkārtojumus, vai ne?
Līdz šim mēs esam strādājuši ar divām būtiskām funkcijām, kas iekļautas Arduino. Tagad varētu būt laiks, kad mēs izveidojām savas funkcijas.
Katrai funkcijai jāsākas ar mainīgā tipu, ar kuru tā var būt saistīta. Piemēram, funkcija spēkā neesošs attiecas uz tipu, kas neko neatgriež, tāpēc nosaukums nav derīgs. Ņemiet vērā, ka iepriekšējās sadaļās mēs jau esam apsprieduši mainīgo sarakstu, iespējams, vēlēsities tos atsaukties.
Līdz ar to konkrētais funkcijas nosaukums tiek atvērts iekavās '(' kam seko komatu atdalīto parametru saraksts.
Katrs parametrs iegūst savu tipu kopā ar nosaukumu un, visbeidzot, aizvēršanu ')' iekavas.
Šos parametrus var izmantot funkcijas ietvaros mainīgo formā.
Apskatīsim piemēru zemāk, kur mēs izstrādājam funkciju, ko sauc ourTone () paredzēts apvienot tonis () ar kavēšanās () līnijas tādā veidā, ka funkcija vairs neatgriežas, kamēr piezīme nav pabeigusi signāla atskaņošanu.
Mēs ieviešam šīs funkcijas mūsu iepriekšējā kodā un iegūstam zemāk esošo programmu, skatiet pēdējās rindas:
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}
Funkcijas var būt ļoti noderīgas, lai padarītu programmu vieglāk saprotamu.
Šis ir piemērs, kur mēs varam norādīt toņa izvēli, kuru vēlaties atskaņot, izmantojot divus masīvus. Viens masīvs notu saglabāšanai, otrs sitienu saglabāšanai.
#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}
Pirmajā rindā jūs varat skaidri redzēt ievadu # iekļaut paziņojums, apgalvojums. Šī paziņojuma uzdevums ir uzņemt visu failu starp pēdiņām un ievietot to # iekļaut paziņojums, apgalvojums. Saskaņā ar standarta noteikumiem tie ir stingri ievietoti programmas sākumā.
5. nodaļa
Temperatūras mērīšana
Vienkārši, lai atcerētos un atcerētos, tā vietā, lai rakstītu lielas programmas, vienmēr ir prātīgi rakstīt un analizēt nelielas kodu daļas, kas palīdz ātri atklāt kļūdas.
5.1 Seriālais monitors
Līdz šim mūsu apspriestie kodi nav tik viegli, lai iespējotu ātru problēmu novēršanu. Šeit mēs centīsimies atvieglot uzraudzībai un iespējamās problēmas vienkāršāku risināšanu.
Arduino ir funkcija, kas tai ļauj “runāt atpakaļ” ar datoru. Var novērot, ka pin0 un pin1 ir atzīmētas kā RX TX blakus viena otrai. Šīs tapas faktiski izseko atsevišķs IC Arduino, kas tos jaunina, lai lasītu pa USB kabeli, kamēr tas ir pievienots datoram.
Šajā sadaļā ir parādīta pilnvērtīga programma. Lūdzu, dodieties uz to, un pēc tam mēs uzzināsim par jaunajiem ierakstiem kodā. Šis kods ir tas pats, kas izteikts 2.2. Sadaļā, izņemot to, ka tajā ir iekļauti daži papildu dati, lai mēs varētu identificēt, kam tas ir kodēts.
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
Šeit varat identificēt divas jaunas lietas, jaunu rindiņu uzstādīt() funkciju.
Serial.begin(9600)
Šī līnija vienkārši izsaka nepieciešamību izmantot Seriāls1 kodu, lai to izpildītu ar 9600 baudu. (šeit sērija attiecas uz biti tiek nosūtīts viens pēc otra, un baud nozīmē ātrumu, kādā tas tiek nosūtīts). Šai un sērijveida monitora vērtībai (to uzzināsim vēlāk) jābūt vienādai, pretējā gadījumā sērijveida monitora dati parādīs atkritumus. 9600 kā standarts kļūst ērtāk lietojams.
Otrais jaunais ieraksts ir šāds
Serial.print('delayTime = ')
Serial.println(delayTime)
Šeit otrā rinda liek domāt, ka nākamā lieta, kas nāk no sērijas porta, sāksies nākamajā rindā. Tieši tā otrā līnija atšķiras no dūres līnijas.
Vēl viena lieta, ko varat redzēt, ir pēdiņas ('). To sauc par virkni, kuru šeit izmantos tikai kā konstantes, jo turpmāka diskusija par šo tēmu var būt pārāk sarežģīta un ārpus darbības jomas.
Labi, tagad mēs varam augšupielādēt iepriekš minēto kodu Arduino un redzēt, kas notiek.
Kas, diemžēl, šķiet, ka nekas nav noticis, Arduino pin # 13 LED mirgo un apstājās, bet Tx LED palika mirgot.
Nu, tas ir tāpēc, ka Serial Monitor logs vēl nav izlabots.
Jums ir jānoklikšķina uz Serial Monitor lodziņa jūsu IDE, kā parādīts iepriekš. Neaizmirstiet pārbaudīt pārraides ātrumu, kas atrodas apakšējā labajā stūrī. Pēc noklusējuma tam jābūt 9600, un tas atbildīs kodam. Ja tā nav, noteikti atlasiet 9600.
Šajā videoklipā ir paskaidrots, kā tas tiek darīts.
https://youtu.be/ENg8CUyXm10Tagad virzīsimies uz priekšu un uzzināsim, kā iepriekšminētā Serial Monitor funkcija var palīdzēt apstrādāt temperatūras mērīšana, izmantojot Arduino
Mēs izmantosim IC TMP36 kā temperatūras sensoru, kura diapazons ir no -40 līdz 150 grādiem pēc Celsija.
Iestatījumu var redzēt zemāk:
Šis kods sāks temperatūras mērīšanu, nolasot TMP36 sensora izvadi un nosūtot tos uz ID sērijveida monitoru.
const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
Sapratīsim kodu no augšas.
float temperatureC = getTemperatureC()
Šeit jūs varat redzēt, ka esam iekļāvuši mainīgā tipu peldēt.
Šis ir vienīgais mainīgā tips, kurā tiek glabāts viss, izņemot veselos skaitļus (skaitļus bez decimāldaļām vai daļām).
Peldošā mainīgā precizitāte var būt līdz 6 līdz 7 cipariem.
Blakus esošais kods getTemperatureC() ir mūsu pašu funkcija, kas matemātiski aprēķina un pārveido uztverto sprieguma starpību no TMP36 sensora grādos pēc Celsija.
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
Kodu nākamajā sadaļā kopš termina analogIn() ir piešķirts, lai atgrieztu skaitli no 1 līdz 1023, mums kļūst iespējams novērtēt sensora spriegumu, reizinot mūsu rādījumu ar 5 un pēc tam dalot to ar 1024.
Sensors TMP36 ir noteikts, lai radītu 0,5 V 0 grādos pēc Celsija, un pēc tam ģenerē 10 mV katram atsevišķam Celsija grāda pieaugumam.
Lūk, aptuvenais lielums, ko mēs varam iegūt, izmantojot aprēķinus:
Jūs varat uzskatīt par savu pirmo funkciju, kas atgriež kādu vērtību (ņemiet vērā, ka visas līdz šim atlikušās funkcijas neatgrieza nevienu vērtību, jo tās bija šāda veida spēkā neesošs ).
Jūs varat saprast, ka, lai iegūtu funkcijas vērtību, jums vienkārši jāpievieno atgriešanās seko vēlamais numurs, kuru vēlaties atgriezt.
Kad mēs sakām atgriešanās tas nozīmē, ka funkcija atgriež atbildi vai atbildi ikreiz, kad tā tiek izsaukta, ko varētu piemērot mainīgajam.
Kad tas tiek nosūtīts uz sērijas monitoru, rādījums tiek pārveidots par Fārenheitu convertToF ().
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
Šī funkcija uzņem Celsija diapazonu un pārvērš to pēc Fārenheita.
Lai pārvērstu Fārenheitu par Celsija, mēs ieviešam formulu Farenheits = 9 / 5 (pēc Celsija) + 32.
5.3 LCD saskarne
Tagad izpētīsim, kā saskarni vai savienot LCD displejs ar Arduino, lai iegūtu vizuālu displeju nepieciešamajām izejām.
Mūsu lietojumprogrammā mēs izmantosim 84x48 grafisku LCD, ar 84 pikseļiem vai punktiem horizontāli un 48 pikseļu vertikālu izšķirtspēju. Tā kā īpašs kontrolieris kļūst obligāts visiem LCD, pašreizējā ierīce to iekļauj arī PCD8544 kontroliera veidā.
Šajā apmācībā mēs savienosim iepriekš norādīto LCD moduli ar Arduino un izmantosim noteiktas kārtības, lai displejā izveidotu īsziņas.
Šajā attēlā varat atrast sīkāku informāciju par LCD saskarni, kā arī nelielu 3,3 V sprieguma regulators . Šis regulators ir nepieciešams, jo LCD ir norādīts darbam ar 3,3 V barošanu.
No LCD moduļa var redzēt arī 8 kontaktligzdas. Piezīmju specifikācijas var izpētīt šajā tabulā:
Tagad redzēsim, kā mēs varam savienot LCD un attiecīgos parametrus ar mūsu Arduino. Sīkāku informāciju var vizualizēt zemāk redzamajā attēlā:
5.4 Saziņa ar LCD
Lai gan no Arduino ir iespējams rakstīt sarežģītas mijiedarbības ar LCD, mēs drīzāk iemācīsimies to izdarīt, izmantojot bibliotēkas.
Bibliotēkas ietver kodu sortimentu, kurus var ātri pielietot izvēlētajai Arduino programmai.
Tas ļauj lietotājam bez piepūles izsaukt funkciju, neveicot sarežģītu kodēšanas darbu.
5.4.1 Kā instalēt bibliotēku
Lai to izdarītu, datorā Arduino IDE jums būs jāizveido direktorija ar nosaukumu bibliotēkas, kā paskaidrots šeit
5.4.2 LCD darbību īstenošana
Tāpat kā mūsu iepriekšējā pieeja, mēs vispirms pārbaudīsim visu kodu un pēc tam mēģināsim saprast atsevišķu līniju detaļas.
#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}
Rindā ir kods #include
Kods #include liek personāldatoram programmas sastādīšanas laikā uzņemt minēto failu un aizstāt elementu #include ar faila saturu.
Elementam #include var būt leņķa iekavas, kas norāda meklēšanu bibliotēkas direktorijā, vai arī pēdiņas, kas norāda meklēšanu tajā pašā direktorijā, kurā atrodas programma.
Turpmākās koda rindas izsaka LCD pinouts, un pēc tam mēs uzrakstām jaunu mainīgā formu:
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
Šeit mēs izsakām mainīgo ar nosaukumu lcd, kura tips ir PCD8544, un dodam norādījumus personālajam datoram pārvērtēt ar Arduino saistītos pinouts.
Šajā procesā mēs aprakstām mainīgo PC, norādot, kā pin clk, din, dc un reset tiek mijiedarboti ar Arduino.
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
Līnija lcd.init() inicializē LCD darbību. Kad tas ir izpildīts, nākamā rinda piespiež kursoru displeja augšējā kreisajā stūrī. Nākamā nākamā rinda cenšas izdrukāt ziņojumu “Sveika, pasaule”.
Tas izskatās diezgan identisks tehnikai, kādā mēs nosūtījām ziņojumus, izmantojot seriālo monitoru. Vienīgā atšķirība ir koda lcd.print izmantošana sērijas.drukas vietā.
Nākamo koda bloku faktiski sauc atkārtoti.
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}
Izmantojot šo rindu lcd.setCursor(0,1) mēs fiksējam kursoru 0. kolonnā 1. rindas tālu kreisajā pusē virs LCD displeja.
Nākamajā rindā tiek izmantots saīsne: lcd.print(millis())
Ja atceraties, ka esam sadarbojušies ar millis() savos agrākajos kodos mēs būtu varējuši to piemērot arī šeit, izmantojot kodus:
long numMillis = millis()
lcd.print(numMillis)
Tomēr, tā kā šeit nav iesaistīti laika periodi milisekundēs, mēs to paveicam, vienkārši nosūtot millis() darbojas tieši uz lcd.print() .
5.5. Visa lietas apvienošana
Labi, tagad apvienosim visus kodus, kurus mēs iemācījāmies, lai izveidotu LCD temperatūras ķēdi, un redzēsim, kā tas izskatās:
#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
Iepriekš minētajā programmā viss izskatās standarta, izņemot funkcijas izmantošanu setCursor () . Tas tiek izmantots, lai tekstu pēc iespējas vairāk izlīdzinātu ap displeja centru.
Lieliski! Un apsveicu, jūs tikko ieprogrammējāt savu mazo LCD temperatūras indikatoru, izmantojot Arduino.
Praktiskas Arduino lietojumprogrammas
Tā kā šajā brīdī mēs esam detalizēti aplūkojuši dažādas programmēšanas tehnikas, ir pienācis laiks tos pilnībā izpētīt, pielietojot tos dažām noderīgām praktiskām ieviešanām.
Mēs sāksim ar sensoriem un redzēsim, kā sensoru ierīces varētu izmantot ar Arduino, izpildot dažus kodu kodus.
7.1 Ievads sensoros
Šajā apmācībā mēs uzzināsim par visdažādākajiem sensoriem, kurus varētu izmantot ar Arduino. Tās var ietvert tādas ierīces kā gaismas sensors LDR, magnētiskais zāles efekta sensors, slīpuma sensori, vibrācijas sensors, spiediena sensors utt.
Mēs sāksim ar saskarni gaismas sensors LDR ar Arduino, kā parādīts i, šī diagramma:
Kā mēs visi zinām, LDR ir no gaismas atkarīga rezistora ierīce, kuras pretestība ir atkarīga no apkārtējās vides intensitātes uz tās virsmas.
Gaismas intensitāte ir apgriezti proporcionāla LDR pretestības rādījumam.
Šeit mēs uzzināsim, kā šo īpašumu var integrēt Arduino, lai izpildītu noderīgu lietojumprogrammu:
Pilnu programmas kodu var vizualizēt, kā norādīts zemāk:
const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}
Visi kodā izmantotie parametri jau ir apspriesti mūsu kursā, kuru mēs esam iemācījušies līdz šim. Jūs varat pārbaudīt līnijas, atsaucoties uz attiecīgajām sadaļām.
Vērtības tika izvēlētas nejauši, jūs varat viegli mainīt atbilstoši savām vēlmēm.
Slīpuma sensors
Slīpuma sensors ir vienkārša ierīce, kuru var izmantot, lai noteiktu slīpuma darbību uz jebkura objekta, kur tas ir uzstādīts. Ierīces iekšpusē pamatā ir metāla bumba, kas, noliekot, ripo pāri kontaktu pārim, izraisot vadību pāri šiem kontaktiem. Šie kontakti, kas tiek izbeigti kā slīpuma slēdža vadi, tiek izmantoti ar ārēju ķēdi, lai noteiktu vadību sasvēršanās dēļ un aktivizētu vēlamo izvades lietojumu.
Tagad redzēsim, kā slīpuma sensors ierīci var pieslēgt. Zemāk esošais attēls sniedz mums priekšstatu par pilnīgu konfigurāciju:
const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}
Šajā piemērā kā slīpuma indikators tiek izmantots noklusējuma tapas Nr. 13 LED.
Šeit jūs varat skaidri redzēt pievilkšanas rezistora iekļaušanu, kas ir diezgan līdzīgs tam, ko mēs darījām 3.1. Sadaļā. Tāpēc termins LOW norāda, ka slīpuma funkcija nav aktivizēta.
7.4 Reed Switch relejs (ar miniatūru magnētu aktivizēts relejs)
Tagad redzēsim, kā ar Arduino piesaistīt releja slēdzi vai magnētiskā lauka sensoru. Niedru relejs ir sava veida slēdzis, kas aktivizējas vai vada, kad tam tuvojas magnētiskais lauks vai magnēts. Būtībā tam ir pāris feromagnētisku kontaktu miniatūras stikla korpusa iekšpusē, kas savienojas vai nonāk saskarē magnētiskās vilkmes dēļ ikreiz, kad magnēts atrodas tā tiešā tuvumā. Kad tas notiek, kontaktu spailes parāda vadītspēju kontaktu aizvēršanās dēļ.
Arī šeit mēs izmantojam tapu # 13, lai norādītu atbildi. Ja nepieciešams, varat pieslēgt ārēju gaismas diodi no šīs tapas saskaņā ar mūsu iepriekšējiem paskaidrojumiem.
const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
Kodu terminiem jābūt pazīstamiem un pašsaprotamiem.
7.5 Vibrācijas sensors, izmantojot Pjezo pārveidotāju
Nākamajā paraugprogrammā mēs redzēsim, kā a pjezo pārveidotājs var izmantot kā vibrācijas sensoru, lai apgaismotu LED caur Arduino.
Pjezo elements faktiski ir ierīce, kas rada vibrāciju vai svārstības, kad frekvence tiek pielietota pāri tā spailēm. Tomēr to pašu pjezo var izmantot reversajā procesā ģenerējot elektriskos impulsus reaģējot uz vibrāciju, kas uzlikta uz ķermeņa. Šī vibrācija var būt sitiena vai sitiena veidā uz pjezo virsmas.
Iestatiet Arduino un pjezoelementu, kā norādīts nākamajā attēlā
const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}
Slieksnis 100 tiek ieviests tikai tāpēc, lai pārliecinātos, ka Arduino reaģē tikai uz patiesajām vibrācijām, izmantojot sitienus, nevis uz citām mazākām vibrācijām, piemēram, no skaļām skaņām vai ragiem.
A5 kontakta izvēle nav obligāta, jūs varat izvēlēties jebkuras citas analogās ieejas atbilstoši savai izvēlei un saskaņojot to ar programmas kodu.
Servo motora izmantošana ar Arduino
Servomotors ir līdzstrāvas motora tips, kuru var pagriezt līdz precīziem leņķiem atbilstoši konkrēta pielietojuma vajadzībām. To var izdarīt, piemērojot aprēķinātu komandu attiecīgajām motora ieejām, lai iegūtu precīzu rotācijas vai pagrieziena leņķi motora 180 grādu diapazonā.
Parasti servomotoram ir 3 vadi vai ieejas. Pozitīvie vadi parasti ir sarkanā krāsā, negatīvie vai iezemētie vadi ir melni, bet komandvads vai signālvads parasti ir baltā vai dzeltenā krāsā.
Arduino atvieglo servomotora vadību, izmantojot iebūvētu atbalsta valodu, kas padara vadību ļoti ērtu un ideālu servomotoriem.
Šis piemērs parādīs pamata iestatīšanas programmu servomotora vadības ieviešanai, izmantojot Arduino:
Kods ir norādīts zemāk:
#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}
Šeit mēs varam redzēt pāris jaunus ierakstus. Tāds, kurš piestiprinātajam servo vadam izstāsta, kādai tapai tas ir piešķirts. Otrs ir kods, kas nodrošina tapas vērtību starp 0 un 180, lai noteiktu servo rotācijas leņķi.
Secinājums
Arduino tēma var būt bezgalīgi ilga, un tāpēc ārpus šī raksta darbības jomas. Tomēr es ceru, ka iepriekš minētajai apmācībai noteikti vajadzēja palīdzēt jums apgūt pašus Arduino pamatus un izprast svarīgos parametrus, izmantojot dažādus lietojumprogrammu kodus.
Cerams, ka šeit laiku pa laikam tiks atjaunināta vairāk informācijas, kad vien tā būs pieejama.
Pa to laiku izbaudiet savu programmēšanas kursu, Priecīgu Arduinoing jums !!
Pāri: Alkohola detektora skaitītāja ķēde, izmantojot MQ-3 sensora moduli Nākamais: Mobilā tālruņa kontrolēta suņu padeves ķēde
