Mokymasis pagrindinio „Arduino“ programavimo - pamoka naujokams

Išbandykite Mūsų Instrumentą, Kaip Pašalinti Problemas





Šioje pamokoje sužinosime, kaip atlikti pagrindinį „Arduino“ programavimą naudojant pavyzdinius kodus ir pavyzdines programas. Ši pamoka gali būti nepaprastai vertingas kursas visiems naujokams, norintiems lengviau suprasti suprantamą pagrindą.

Įvadas

Pagal vikipedija mikrovaldiklis prilygsta mini kompiuteriui, įmontuotam vienos IC lustos viduje, turinčiam savo pagrindinį procesorių, programuojamus įėjimus, atminties ir išvesties periferinius įrenginius.



Mikrovaldiklis tampa toks naudingas vartotojui, nes jame yra įmontuotas procesorius, atminties ir įvesties / išvesties prievadai (dar vadinami GPIO arba bendrosios paskirties įvesties / išvesties kaiščiais), kuriuos vartotojas gali valdyti pagal bet kokias norimas specifikacijas.

Šioje pamokoje dirbsime su „Arduino Uno“ lenta mokydamiesi ir testuodami programas. Aparatinės įrangos surinkimui išbandyti ir integruoti naudosime skydą.



Dabar judėkime greitai ir sužinokime, kaip pradėti naudoti „Arduino“ programavimą.

1.2 Programinės įrangos diegimas („Windows“)

Tam jums reikės prieigos prie interneto, kurį akivaizdžiai turėtumėte savo kompiuteryje. Eikite į šią nuorodą ir atsisiųskite IDE programinę įrangą:

„Windows ZIP“ failas, skirtas ne administratoriaus diegimui

Atsisiuntę atsisiuntimo aplanke rasite „Arduino“ sąrankos piktogramą, kuri atrodytų taip:

arduino atsisiuntimo piktograma

Tai gavę, galite tiesiog dukart spustelėti jį ir įdiegti „Arduino“ integruotą kūrimo aplinką (IDE) į savo kompiuterį. Visą procesą galima vizualizuoti šiame vaizdo įraše:

https://youtu.be/x7AMn1paCeU

1.4 Pradedant nuo mūsų pirmosios grandinės

Prieš pradedant mokytis tikrųjų programavimo būdų, kiekvienam pradedančiajam būtų naudinga pradėti nuo pagrindinio komponento, pvz., LED, ir suprasti, kaip jį prijungti prie „Arduino“.

Kaip žinome, šviesos diodas yra šviesos diodas, turintis poliškumą ir nešvies, jei jis nebus sujungtas su tinkamais tiekimo poliais.

Kitas aspektas, susijęs su šviesos diodais, yra tas, kad šie prietaisai veikia esant silpnai srovei ir gali iškart sugesti, jei tinkamai apskaičiuotas rezistorius nėra įtrauktas į seriją su vienu iš jo kaiščių.

Pagal nykščio taisyklę, 330 omų 1/4 vatai yra idealiai tinkami kiekvienam 5 V įtampos tiekimo įėjimui, kad srovė būtų apribota iki reikalingo saugaus lygio. Todėl 5 V gali būti 330 omų, 10 V - 680 omų ir pan.

Duonos lentos naudojimas surinkimui

Prašome įsitikinti, kad mokate naudoti Bandomoji Lenta prieš išbandydami šiame skyriuje paaiškintą mokymo programą, nes visiems eksperimentams čia naudosime duonos lentą.

Pagrindinę LED jungties sąranką galima pamatyti toliau:

LED su „Arduino“

Aukščiau galite pamatyti 3 pagrindinius komponentus:

  1. 5 mm, 20 mA LED
  2. 330 omų 1/4 vatų rezistorius
  3. An „Arduino“ lenta

Tiesiog surinkite sistemą pagal schemą.

Tada įjunkite 5 V įtampą iš kompiuterio USB į „Arduino“. Kai tik tai padarysite, pamatysite, kad LED dega.

Aš žinau, kad tai gana paprasta, bet visada gera pradėti nuo nulio. Būkite tikri, kai viskas eisis į priekį, jie taps vis įdomesni.

1.5 LED valdymas naudojant „Arduino“

Dabar mes sužinosime, kaip valdyti šviesos diodą naudojant „Arduino“ programą.

Norėdami parašyti programą, kiekvienoje programoje turime turėti bent 2 funkcijas.

Funkcija gali būti suprantama kaip programavimo sakinių serija, kuriai gali būti priskirtas pavadinimas, kaip nurodyta toliau:

  1. sąranka () tai iškviečiama arba vykdoma programos paleidimo metu.
  2. kilpa () tai vadinama arba vykdoma pakartotinai per visą „Arduino“ veikimo laikotarpį.

Todėl, nors ji gali neturėti praktiškų funkcijų, techniškai trumpiausia teisėta „Arduino“ programa gali būti parašyta taip:

Paprasčiausia programa

void setup()
{
}
void loop()
{
}

Galbūt pastebėjote, kad daugeliu programavimo kalbų sistema pradeda rodyti paprastą spausdinimą „Hello, World“ ekrane

Elektroninis šios frazės atitikmuo aiškinant mikrovaldiklį yra mirksintis šviesos diodas įjungtas ir išjungtas.

Tai yra paprasčiausia programa, kurią galima parašyti ir įgyvendinti, kad būtų rodomas teisingas sistemos veikimas.

Pabandysime įgyvendinti ir suprasti procedūrą naudodami šį kodą:

1.2 sąrašas: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Gerai, dabar supraskime, ką reiškia kiekviena kodo eilutė ir kaip ji veikia vykdant funkciją:

const int kPinLed = 13

Tai veikia kaip konstanta, leidžianti mums ją panaudoti viso programavimo kurso metu, nenaudojant faktinės jam nustatytos vertės.

Pagal standartines taisykles tokios konstantos atpažįstamos su pradine raide į . Nors tai nėra privaloma, tai daro viską aiškesnį ir lengvai suprantamą, kai tik norėsite sužinoti kodo informaciją.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Šis kodas sukonfigūruoja konkretų kaištį, prie kurio prijungtas mūsų šviesos diodas. Kitaip tariant, kodas liepia „Arduino“ valdyti šio kaiščio „rašymo“ aspektą, užuot jį „skaitęs“.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Aukščiau nurodytos eilutės nurodo faktinį programos vykdymą. Kodas prasideda užrašant ir perteikiant AUKŠTĄ atitinkamą LED jungtį, įjungiant šviesos diodą.

Čia terminas AUKŠTAS tiesiog reiškia + 5 V gavimą ant atitinkamo „Arduino“ kaiščio. Papildomas terminas LOW paprasčiausiai nurodo nulį arba 0 V ant nurodyto kaiščio.

Tada paskambinsime delay() kurio funkcija yra sukurti vėlavimą per milisekundes (1/1000 sekundės). Kadangi įvedamas skaičius 500, vėluojama įgyvendinti 1/2 sekundės.

Kai tik praeina ši 1/2 sekundė, vykdoma kita eilutė, kuri išjungia šviesos diodą su LOW terminu tame pačiame kaište.

Vėlesnė eilutė vėl generuoja 1/2 sekundės vėlavimą, kad šviesos diodas galėtų išjungti 1/2 sekundės.

Procesas tęsiasi be galo vykdant kodo eilutes, jei tik „Arduino“ yra maitinamas.

Prieš pereidamas į kitą lygį, aš rekomenduoju jums užprogramuoti aukščiau nurodytą kodą ir patikrinti, ar jūs galite tinkamai įdiegti LED ON / OF seką, ar ne.

Kadangi numatytasis „Arduino“ šviesos diodas yra sujungtas su kaiščiu Nr. 13, jis turėtų nedelsdamas reaguoti į pirmiau nurodytą programą ir pradėti mirksėti. Tačiau, jei pastebėsite, kad jūsų išorinis šviesos diodas nemirksi, gali būti, kad jūsų LED yra ryšio sutrikimas, galite pabandyti pakeisti savo šviesos diodo poliškumą ir tikiuosi, kad jis taip pat mirksi.

Galite žaisti su uždelsimo laiku pakeisdami „500“ skaičių į kitą vertę ir suraskite „klausantį“ komandų šviesos diodą ir priverskite jį mirksėti pagal nurodytas vėlavimo vertes.

Tačiau nepamirškite, jei matote, kad šviesos diodas nemirga pastoviu 1 sekundės greičiu, neatsižvelgiant į jūsų vėlavimo laiko pakeitimą, tai gali reikšti, kad kodas neveikia dėl kokios nors klaidos. Nes pagal nutylėjimą „Arduino“ bus užprogramuotas 1 sekundės mirksėjimo greičiu. Todėl šis rodiklis turi skirtis pagal jūsų kodą, kad patvirtintumėte, jog jis veikia tinkamai.

1.7 Komentarai

Aukščiau suprantamų kodų eilutės buvo specialiai parašytos kompiuterio programinei įrangai.

Tačiau norint užtikrinti, kad vartotojas galėtų nurodyti eilučių reikšmę ir jas suprasti, dažnai gali būti naudinga ir protinga paaiškinimą parašyti šalia norimų kodų eilučių.

Jie vadinami komentarus kurie parašyti tik žmonėms ar vartotojams ir yra užkoduoti, kad kompiuteriai galėtų saugiai to nepaisyti.

Šių komentarų kalba parašyta keliais formatais:

  1. Blokinis komentaro stilius, kuriame komentaro aprašymas yra po pradžios simboliu / * ir pabaigos simboliu * /
  2. Tai neturi būti ribojama vienoje eilutėje, o gali būti išplėsta kitoms kitoms eilutėms, atsižvelgiant į komentaro ar aprašo ilgį, kaip parodyta šiame pavyzdyje:

/ * Tai komentaras * /

/ * Taip yra ir tai * /

/ * Ir
* tai
* kaip
* šulinys * /

Norint parašyti greitą vienos eilutės aprašą komentarui, pakanka dviejų pasvirojo // simbolio pradžioje. Tai nurodo kompiuteriui, kad ši eilutė neturi nieko bendra su tikruoju kodu, todėl jos reikia nepaisyti. Pavyzdžiui:

// Tai komentaras, kurio kompiuteriai nepaisys.

Štai pavyzdys:

/*
* 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 Trikčių šalinimas

Jei jums atrodo, kad programoje yra „klaida“ kompiliuojant, ar kokia kita problema, šie patarimai tikriausiai padės jums dar kartą patikrinti kodą, kad atsikratytumėte kliūties.

  1. Jūsų programos kalba bus didžiosios ir mažosios. Pavyzdžiui, išraiška myVar negalima rašyti taip „MyVar“.
  2. Visų rūšių tarpai, kuriuos gali atlikti klaviatūra, galiausiai pateikiami kaip viena tarpo vieta, kurią matote arba suprantate tik jūs, kompiuteris į tai neatsižvelgs. Paprasčiau tariant, bet kokios laisvos vietos neturės jokios įtakos kodo rezultatams.
  3. Kiekvienas kodo blokas turi būti pridėtas kairiais ir dešiniais garbanotais skliaustais, „{“ ir „}“
  4. Skaičių skaitmenų negalima atskirti kableliais. Pavyzdžiui, 1000 negali būti parašyta kaip 1000.
  5. Kiekviena tarp garbanotų skliaustų uždaryta kodo eilutė turi būti baigta kabliataškiu

Sukurti įdomų LED šviesos seką su „Arduino“

Ankstesniame skyriuje mes sužinojome, kaip nuolat mirksėti šviesos diodas ĮJUNGTA / IŠJUNGTAS pastoviu vėlavimo greičiu.

Dabar mes sužinosime, kaip tą patį šviesos diodą galima atlikti skirtingus vėlavimo modelius atnaujinant programos kodą.

Mes nenaudosime išorinio šviesos diodo, verčiau naudokime numatytąjį šviesos diodą, įmontuotą „Arduino“ lentoje prie kaiščio Nr. 13. Šį mažytį SMD LED galite rasti iškart už USB jungties.

2.2 IF teiginių supratimas

Šiame skyriuje sužinosime, kaip valdymo struktūros leidžia mums valdyti atskirus kodus, o kartais net pakartotinai, kaip reikalaujama.

Pareiškimas jei tampa 1-ąja kontrolės struktūra. Šis diegimas parodo, kaip jis naudojamas:

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)
}

Mes pabandysime suprasti aukščiau pateiktą kodą palaipsniui ir sužinoti, kaip tai gali būti naudojama kitoms panašioms egzekucijoms.

Kodai tarp 1 ir 7 eilutės yra visiškai panašūs į mūsų pradinę programą.

Pirmoji modifikacija iš tikrųjų įvyksta 8-oje eilutėje.

int delayTime = 1000

Tai gali būti panašu į 1-osios eilutės kodą, neleidžiant, kad trūksta termino konst.

Taip yra todėl, kad šis kodas nėra konstanta. Vietoj to tai apibrėžiama kaip kintamasis , kuris programavimo metu turi kintamos vertės savybę.

Ankstesniame pavyzdyje galite pamatyti, kad šis kintamasis priskiriamas 1000 vertei. Atminkite, kad tokie kintamieji, kurie yra uždėti skliaustuose, turi būti griežtai rašomi tik garbanotųjų skliaustų porose ir vadinami „vietiniais“ kintamaisiais.

Arba kintamieji, kurie turėtų būti už garbanių skliaustų, kaip antai tie, apie kuriuos dabar diskutuojame, yra pripažįstami „visuotiniais“ ir gali būti vykdomi beveik bet kurioje programos kodo vietoje.

Žengdami į priekį, galite pamatyti, kad kodai tarp 9 ir 11 eilutės taip pat yra panašūs į pirmąją programą, vis dėlto viskas pradeda įdomėti po 11 eilutės. Pažiūrėkime, kaip!

delayTime = delayTime - 100

Šiame kode matome, kad numatytoji reikšmė delayTime yra modifikuojamas atimant iš jo 100.

Reikšmė 100 atimama iš pradinės 1000 vertės, suteikiant jai naują 900 vertę.

Per šį vaizdą bandysime suprasti keletą matematikos operatorių, naudojamų „Arduino“ kalba.

„Arduino Math Operator“ simboliai

Dabar įvertinkime kodus tarp 13 ir 15 eilutės.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

Pagrindinis aukščiau nurodyto kodo tikslas yra užtikrinti, kad šviesos diodas ir toliau mirksėtų be jokių pertraukimų.

Dėl to, kad iš originalo atimama 100 delayTime , jis neleidžia mirksinčiam šviesos diodui pasiekti nulį ir leidžia nuolat mirksėti.

Šiame paveikslėlyje parodyti keli palyginimo operatoriai, kuriuos naudosime savo koduose:

„Arduino“ kodų palyginimo operatorius

Aukščiau pateiktame kode mes galėjome išbandyti kodą kaip if(delayTime == 0)

Tačiau kadangi neigiamas skaičius gali būti vienodai blogas, mes to nepadarėme, ir tai yra rekomenduojama praktika.

Pagalvokite, koks galėjo būti rezultatas, jei iš delayTime bandytume atimti 300, o ne 100?

Taigi dabar galbūt supratote, kad jei delayTime yra užrašytas kaip mažesnis arba lygus nuliui, tada vėlavimo laikas bus grąžintas į pradinį 1000 paveikslą.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Paskutinės 4 kodo eilutės, kaip parodyta aukščiau, tampa atsakingos už LED įjungimą / išjungimą, nuolatinį įjungimą / išjungimą.

Čia galite aiškiai pastebėti, kad užuot naudoję skaičių skaičių, mes naudojome kintamąjį vėlavimo laikui priskirti, kad galėtume jį koreguoti taip, kaip norime, veikiant kodo veikimo laikotarpiui. Tai šaunu, tiesa?

2.3 ELSE pareiškimai

Čia sužinosime, kodėl ir kaip jei terminas gali turėti sąlygą Kitas kad ji nuspręstų situaciją tuo atveju jei teiginys yra klaidingas.

Atsiprašau, jei tai atrodo per daug painu, nesijaudinkite, pabandysime tai suprasti pateikdami šį pavyzdį:

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)
}

Pirmiau galite gerai pamatyti, kad 10-osios eilutės kodas vykdomas tik tada, kai delayTime yra mažesnis arba lygus 100, jei ne, tada vykdomas 13-osios eilutės kodas, tačiau abu kartu niekada negali įvykti, nebus įgyvendintas nei 10-osios, nei 13-osios eilutės kodas, niekada nebus abu.

Galbūt pastebėjote, kad skirtingai nuo to, ką darėme ankstesniame 2.2 skirsnyje, čia mes nelyginome su 0, o palyginti su 100. Taip yra todėl, kad šiame pavyzdyje palyginta PRIEŠ, prieš atimdami 100, priešingai, 2.2 skyriuje, mes palyginome PO atimta. Ar galite pasakyti, kas galėjo atsitikti, jei palygintume 0, o ne 100?

2.4 KADA teiginiai

Į kol teiginys yra gana panašus į jei teiginį, išskyrus tai, kad kodo blokui (kuris gali būti tarp garbanotųjų skliaustų) kartotinai vykdoma, kol sąlygos yra taikomos, ir tai veikia be Kitas pareiškimas.

Šis pavyzdys padės jums tai geriau suprasti

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)
}
}

Ar galite atspėti, ką programuoja aukščiau pateiktas kodas? Na, jis skirtas mirksėti šviesos diodui greičiau ir tada lėčiau.

2.5 Kas yra tiesa ir melas?

Programavimo kalba melagingas reiškia nulį (0). Iš tikrųjų „tiesa“ nenaudojama, o daroma prielaida, kad kai niekas nėra klaidinga, tada viskas, kas įtraukta, yra tiesa.

Tai atrodo šiek tiek keista, tačiau darbą atlieka gana gražiai.

Pabandysime suvokti situaciją pateikdami šį pavyzdį.

Kartais galite susidurti su kodu, nurodytu žemiau:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Tai užkoduota, atrodo, kad šviesos diodų vykdymas leis amžinai važiuoti, nes yra galinga energija.

Tačiau vienas šio tipo kodo trūkumas gali atsirasti, kai netyčia vartotojas vietoj == taiko a =.

Esu tikras, kad jūs jau žinote, kad = reiškia priskyrimą, ty jis naudojamas pažymint kintamajam reikšmę, o a == naudojamas vykdant testą, jei reikšmė buvo ta pati.

Pvz., Tarkime, kad jums reikėjo šviesos diodo, kuris mirksi nuosekliai greičio viršijimo režimu ir kartojasi, tačiau neteisingai naudojote = vietoj ==.

Tada kodas pasirodys toks:

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
}

Klaida priskirs 0 prie delayTime ir ves jei teiginį, kad patikrintumėte, ar 0 teisinga, ar ne. Kadangi 0 nurodo klaidingą, jis manys, kad tai netiesa, ir sustabdys delayTime = 1000 vykdymą, tačiau funkcija delayTime ciklo metu () yra laikomas 0.

Tai atrodo labai nepageidaujama !!

Taigi, visada dar kartą patikrinkite savo programą, kad įsitikintumėte, jog nepadarėte tokių kvailų klaidų.

2.6 Deriniai

Kartais galite pajusti, kad reikia išbandyti kelis dalykus kartu. Panašiai, galbūt norėsite ištirti, ar kintamasis buvo tarp dviejų skaičių. Nors tai galima įgyvendinti naudojant „if“ teiginį kelis kartus, gali būti patogiau naudoti loginius derinius, kad būtų lengviau ir lengviau skaityti.

Loginių terminų derinius galima atlikti naudojant 3 metodus, kaip parodyta šioje lentelėje:

lentelė, kurioje pateikiami „Arduino“ derinimo metodai

Įdomu būtų žinoti, kad NOT operatorius gali dirbti kaip kintamojo, kuris gali būti nurodytas kaip vienas, perjungiklis tiesa arba melagingas (arba LOW arba HIGH).

Šis pavyzdys iliustruoja sąlygą:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Čia ledState bus ŽEMA, o vėliau, kai tik ledState = !ledState, ji pasuks AUKŠTA. Ši kilpa sukels ledState būti AUKŠTU, kai ledState = !ledState yra žemas.

2.7 UŽ teiginius

Dabar bandysime suprasti apie kitą valdymo struktūrą, kuri yra dėl kilpa. Tai gali būti labai patogu, kai norėtumėte ką nors įgyvendinti kelis kartus.

Supraskime tai pateikdami šį pavyzdį:

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
}

Galite rasti kažką unikalaus dėl.

Tai kodas i ++? . Tai naudinga programuotojams, kurie yra gana tingūs ir nori įgyvendinti kodavimą naudodami patogius sparčiuosius klavišus

Ankstesnis terminas yra žinomas kaip sudėtiniai operatoriai, nes jie dirba derindami vieną priskyrimo operatorių su kitu priskyrimo operatoriumi. Populiariausius iš jų galima pavaizduoti šioje lentelėje:

arduino junginio operatoriai

Pastebėsite, kad pareiškime yra 3 posakiai. Jo struktūra yra tokia, kaip parodyta žemiau:

for (statement1conditionstatement2){
// statements
}

Teiginys Nr. 1 atsiranda iškart pradžioje ir tik vieną kartą. Būklė tikrinama kiekvieną kartą ciklo metu. Kai tik yra tiesa garbanotųjų skliaustų viduje vykdomas paskesnis teiginys Nr. 2. A atveju melagingas, sistema pereina prie kito kodo bloko.

Sujungti daugiau šviesos diodų

Gerai, dabar mes pamatysime, kaip mes galime sujungti daugiau LE, kad gautume įdomesnių efektų.

Prijunkite šviesos diodus ir „Arduino“, kaip parodyta žemiau. Raudona viela iš tikrųjų nėra būtina, tačiau kadangi visada yra gera mintis, kad tiekimo bėgeliai būtų įtraukti į duoną, tai yra prasminga.

„Arduino“ kelios LED jungtys

Dabar pataisykime programą, kuri leis mums patikrinti, ar teisingai sukonfigūruota mūsų aparatūra.

Visada rekomenduojama koduoti ir vykdyti mažas programų dalis, kad būtų galima patikrinti, ar atitinkamos aparatinės įrangos laidai yra teisingi, ar ne.

Tai padeda greitai pašalinti galimą klaidą.

Žemiau pateiktame kodo pavyzdyje LED nuo 2 iki 5 pateikiamas konkretus modelis, cikliniu būdu pasukant juos vienas po kito.

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)
}

Kaip pastebėjote, kode nėra nieko blogo, išskyrus tai, kad jis atrodo ilgas ir todėl linkęs į klaidas.

Žinoma, yra geresnių būdų, kaip parašyti aukščiau esantį kodą, kitame skyriuje tai bus atskleista.

2.9 Masyvų pristatymas

Masyvai gali būti kintamųjų grupė, kurią galima indeksuoti indekso numeriais. Šis pavyzdys padės mums tai geriau suprasti.

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 pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

Gerai, dabar pereikime kiekvieną skyrių ir supraskime, kaip jie iš tikrųjų veikia.

const int k_numLEDs = 4

Aukščiau pateiktas kodas apibrėžia, kiek maksimalių elementų mes turime turėti masyve. Šis kodas padeda mums sekančiuose skyriuose užtikrinti, kad viskas būtų parašyta masyve ir nieko nesibaigus masyvui.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Šioje kitoje eilutėje mes nustatėme masyvo struktūrą. Skaičiai skliausteliuose nurodo elementų skaičių masyve. Nors faktinis kiekis galėjo būti parašytas, rašymas kaip konstantos veikia geriau. Reikšmės paprastai gali būti matomos skliausteliuose kableliais ir nurodomos reikšmės masyvui.

Kai rasite masyvą, indeksuotą skaičiumi 0, tai rodo patį pirmąjį masyvo elementą, kaip parodyta code: k_LEDPins is k_LEDPins[0]

Panašiai paskutinis elementas bus rodomas kaip k_LEDPins[3], nes skaičius nuo 0 iki 3 yra 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Aukščiau pateiktas kodas parodo ciklo naudojimą pereinant kiekvieną masyvo elementą ir nustatant juos kaip IŠĖJIMUS. Mes pritaikome laužtinius skliaustus su indeksu, kad pasiektume kiekvieną iš masyvo elementų.

jei jums kyla klausimas, ar galima naudoti kaištį Nr. 2, kad būtų galima prisegti # 5 be masyvų, atsakymas yra „taip“, tai įmanoma. Bet šiame pavyzdyje tai nėra daroma, nes mes to nepadarėme. Tolesniuose skyriuose galite pašalinti masyvo metodą, jei pasirinkti išvesties kaiščiai nėra vienoje linijoje.

Pažvelkime į priekį, pažiūrėkime, ką daro kitas kodo blokas:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Čia kodas eina per kiekvieną šviesos diodą, kad įjungtų juos nuosekliai 100 milisekundžių tarpu ar vėlavimu.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

Naudojant pirmiau pateiktą kodą parodoma, kaip už kilpą galėtų būti naudojamas judėti per kilpą net atvirkštine tvarka.

Jis prasideda nuo k_numLEDs - 1, nes masyvai indeksuojami nuliu. Mes pradedame ne nuo k_LEDPins[4] nes tai sukeltų masyvo finišo kirtimą.

Kodas naudoja> = 0, kad patikrintų, ar pirmasis indekso 0 elementas nėra praleistas ar ignoruojamas.

3 skyrius

Kas yra įvestis

Ar mes išmokome valdyti dalykus naudodami „Arduino“. Šiame skyriuje aptarsime, kaip suvokti realų pasaulį susiejant įvestis iš išorinių parametrų.

3.1 Mygtukų naudojimas

Mes visi žinome, kas yra mygtukas ir kaip jis veikia. Tai yra tam tikras jungiklis arba mygtukas, kuris trumpam sujungia signalą iš vienos grandinės pakopos į kitą, kai jis yra nuspaustas, ir atleidžia signalą, kai jis atleidžiamas.

3.1.1 Vienas mygtukas ir šviesos diodas

sąsajos mygtukas su „Arduino“

Mes sujungsime „Arduino“ mygtuku su „Arduino“, kaip parodyta aukščiau, ir sužinosime pagrindinį sąrankos darbą ir įgyvendinimą.

Nurodytas mygtukas, kuris taip pat vadinamas mikro jungiklio mygtuku, iš viso turi 4 kaiščius (po 2 poras kiekvienoje pusėje). Stumiant, kiekviena kaiščių pora sujungiama viduje ir įgalina jungtį ar laidumą.

Šiame pavyzdyje mes naudojame tik vieną šių smeigtukų ar kontaktų porą, kita pora yra nesvarbi ir todėl ignoruojama.

Tęskime taikydami šį kodą ir patikrinkite, ar jis veikia!

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)
}
}

Čia galite rasti keletą dalykų, kurie atrodo neįprasti. Išsiaiškinkime juos išmintingai.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

Pirmas dalykas, kurį mes darome, yra išspręsti buttonPin kaip ĮVADAS. Na, tai gana elementaru, aš žinau.

Toliau mes paskiriame AUKŠTAS į ĮVADAS kaištis. Jums įdomu, kaip gali būti įmanoma ką nors parašyti įvestyje? Žinoma, tai gali būti įdomu.

Tiesą sakant, priskyrus AUKŠTĄ „Arduino“ įėjimui, įjungiamas vidinis 20 k omų prisitraukimo rezistorius ĮJUNGTAS (LOW šiame kaište jį išjungia).

Kitas klausimas, kuris jums gali kilti, yra tai, kas yra traukiamasis rezistorius. Aš apžvelgiau išsamų pranešimą apie traukiamus rezistorius, kuriuos jūs sužinok čia .

Gerai, einame toliau, dabar pažvelkime į pagrindinį kilpos kodą:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Paspaudus mygtuką, laidinis kaištis sujungiamas su žeme, o tai lemia a MAŽAI prie to kaiščio. Nespaustoje būsenoje laikomas tas pats kaištis AUKŠTAS arba + 5 V per 20K vidinį varžą.

Čia norime, kad „Arduino“ užsidegtų šviesos diodas, kai paspaudžiamas mygtukas (LOW), todėl kiekvienam LOW atsakymui iš mygtuko, kol jis paspaudžiamas, rašome HIGH.

3.1.2 Du mygtukai ir šviesos diodas

Na, galite susimąstyti, kad aukščiau parodytas veiksmas galėjo būti atliktas ir be „Arduino“. Aš suprantu, tačiau tai yra akmuo, kad sužinotumėte, kaip su Arduno galima naudoti mygtuką.

Iki šio momento mes ištyrėme LED kodų įjungimo (AUKŠTAS) arba IŠJUNGIMO (LEMPOS) kodų rašymą.

Dabar pažiūrėkime, kaip šviesos diodų ryškumą būtų galima valdyti naudojant „Arduino“.

Tai gali būti padaryta dviem būdais:

  1. Apribojant šviesos diodo srovės kiekį
  2. Naudojant PWM arba impulsų pločio moduliacija, kai šviesos diodų tiekimas įjungiamas / išjungiamas tam tikru norimu greičiu labai greitai, gaunant vidutinį apšvietimą, kurio intensyvumas priklausytų nuo PWM.

„Arduino“ plokštėje PWM palaikymas prieinamas kaiščiais, pažymėtais tilde (~), kurie yra 3, 4,5,9,10 ir 11 kaiščiai 500Hz (500 kartų per sekundę). Vartotojas gali pateikti bet kokią vertę nuo 0 iki 255, kur 0 reiškia ne HIGH ar ne + 5V, o 255 nurodo Arduino visą laiką gauti HIGH arba + 5V. Norėdami pradėti šias komandas, turėsite pasiekti norimą vertę „analogWrite“ ().

Galite manyti, kad PWM yra x / 255, kur x yra norima reikšmė, kurią norite siųsti per analogWrite().

„Arduino PWM“ valdymas

Nustatykite „Arduino“ ir kitus parametrus, kaip parodyta aukščiau.

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)
}

Čia galite rasti 3 eilutes, kurias reikia šiek tiek paaiškinti.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

Linija: ledBrightness = constrain(ledBrightness, 0, 255) iliustruoja unikalią funkciją „Arduino“ viduje, vadinamą „apriboti“ ().

Šią vidinę funkciją sudaro kodas, panašus į:

int apriboti (int vertė, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Visi kodai, aptarti prieš tai, prasidėjo tuštuma , o tai reiškė nieko negrąžinti (niekinis). Kadangi aukščiau pateiktas kodas prasideda tarpt , kuris rodo, kad jis grąžina sveiką skaičių. Apie tai daugiau aptarsime vėlesniuose skyriuose, šiuo metu tiesiog nepamirškite, kad sveikasis skaičius neturi dalinių dalių.

Teisingai, taigi tai reiškia, kodas: ledBrightness = constrain(ledBrightness, 0, 255) priskiria ledBrightness to be within the range of 0 and 255.

Kitoje eilutėje naudojami analogWrite komandoms „Arduino“ pritaikyti PWM ant pasirinkto kaiščio su norima verte.

Kita eilutė sukuria 20 milisekundžių vėlavimą, tai yra užtikrinti, kad mes nereguliuosime valgio greičiau nei 50 Hz arba 50 kartų per sekundę. Taip yra todėl, kad žmonės gali būti daug lėtesni nei „Arduino“. Taigi, jei vėluojama nedelsti, programa gali priversti mus jaustis, kad paspaudus pirmąjį mygtuką LED išjungtas, o paspaudus antrąjį - įjungtas (pabandykite patys, kad patvirtintumėte).

3.2 Potenciometrai

Judėkime į priekį ir išmokime naudotis potenciometrai su „Arduino“.

Norėdami sužinoti, kaip veikia potenciometras ar puodas, galite tai perskaityti straipsnis .

Naudojant potenciometrą su „Arduino“

Prijunkite parodytus parametrus su „Arduino“, kaip parodyta aukščiau.

Puode bus 3 gnybtai. Vidutinis terminasl bus sujungtas su „ANALOG IN 0“ „Arduino“. Kitus du išorinius gnybtus galima prijungti prie + 5 V ir 0 V maitinimo bėgių.

Programuokime ir patikrinkime rezultatus:

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)
}

Rasite keletą dalykų, kurie gali atrodyti visiškai nauji ir neįtraukti į jokį ankstesnį mūsų kodą.

  1. Pastovioji kPinPot yra priskiriamas A0, kur A yra nuoroda apibūdinti vieną iš analoginių kaiščių. Tačiau A0 taip pat nurodo kaištį Nr. 14, A1 - kaištį Nr. 15 ir t. T., Ir tai leidžia jus naudoti kaip skaitmeninius įėjimus / išvestis tuo atveju, jei trūksta eksperimento kaiščių. Tačiau atminkite, kad negalite naudoti skaitmeninių kaiščių kaip analoginių kaiščių.
  2. Linija: ledBrightness = map(sensorValue, 0, 1023, 0, 255) pristato naują „Arduino“ vidinę funkciją, žinomą kaip žemėlapis (). Ši funkcija perkalibruojama iš nurodyto diapazono į kitą, vadinamą žemėlapis (reikšmė, nuoLow, fromHigh, toLow, toHigh). Tai gali tapti labai svarbu, nes analogueRead išduoda reikšmę 0–1023 diapazone, tačiau „analogWrite“ sugeba priimti vertę nuo 0 iki 255.

Galite pagalvoti, kad kadangi galima reguliuoti šviesos diodo ryškumą per besikeičiantį pasipriešinimą, tam tikslui pakako tiesiog puodo, kodėl „Arduino“ naudojimas. Na, vėlgi, tai tik pamatas, parodantis, kaip puodą galima sukonfigūruoti su „Arduino“.

Jokių problemų, dabar mes padarysime tai, ko negalima padaryti be „Arduino“.

Šiame eksperimente pamatysime, kaip įvairaus puodo pasipriešinimas galėtų būti naudojamas šviesos diodo mirksėjimo greičiui ar greičiui reguliuoti.

Štai programa:

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 Vėlavimo išvengimas ()

Aukščiau pateiktas kodas atrodo gerai, tačiau šviesos diodas negali patikrinti puodo vertės, kol jis praeina kiekvieną pilną ciklą. Ilgesnį vėlavimą šis procesas ilgėja, todėl vartotojas turi laukti, kol pamatys atsakymą į banką, kol jis jį judins. Šio vėlavimo galima išvengti naudojant tam tikrą sumanų programavimą, kad vartotojas galėtų patikrinti vertę be minimalių uždelsimų. Štai kodas.

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)
}
}

Taigi, kas skiriasi aukščiau pateiktame kode? Skirtumas yra šioje eilutėje.

long lastTime = 0

Iki šio skyriaus aptarėme kintamąjį int. Tačiau gali būti daugybė kitų tipų kintamųjų, kuriuos galite pasiekti. Sąrašą galima perskaityti žemiau:

„Arduino“ kintamųjų tipai

Šiuo metu gali būti labai svarbu žinoti, kad norint saugoti palyginti didelius duomenis tarpt kintamasis, galite naudoti terminą ilgas arba a ilgas tarpt.

Čia galite pamatyti dar vieną įdomią funkciją, vadinamą milis ().

Tai sukuria laiko intervalą milisekundėmis, kurias „Arduino“ dirbo nuo pat pradžių (tai bus nustatyta į 0 po kas 50 dienų). Čia jis grįžta ilgas, nes jei jis grįžo tarpt , skaičiuoti ilgus laikotarpius gali būti neįmanoma. Ar galėtumėte tiksliai atsakyti, kiek laiko? Atsakymas yra 32,767 sekundės.

Todėl užuot naudoję atidėjimą (), mes tikriname milis () ir, kai tik pasibaigia konkretus milisekundžių skaičius, mes pakeičiame šviesos diodą. Todėl mes saugome laiką, kurį paskutinį kartą pakeitėme Paskutinį kartą kintamasis, kad jis leistų mums jį patikrinti dar kartą, kai tik norisi.

3.3 RGB šviesos diodai

Iki šiol žaidėme su vienspalviu šviesos diodu. Nors šviesos diodų spalvą būtų galima pakeisti pakeičiant šviesos diodus kita spalva, bet kaip naudoti RGB šviesos diodus pakeisti LED spalvas nekeičiant šviesos diodų?

RGB šviesos diodas iš esmės yra šviesos diodas, turintis raudoną, žalią ir mėlyną šviesos diodus, įterptus ir sujungtus į vieną šviesos diodą. Jis turi vieną bendrą laidą, kuris eina į žemę arba 0 V maitinimo bėgį, o kiti 3 laidai tiekiami su įvairiais PWM teigiamais signalais, kad būtų galima įgyvendinti numatytą spalvų maišymas .

Galite prijungti sąranką, kaip parodyta žemiau:

Valdykite RGB naudodami „Arduino“

Tai gali atrodyti šiek tiek sudėtinga, bet iš tikrųjų tai yra mūsų ankstesnio LED valdymo dizaino, naudojant PWM, kopija.

Štai praktikos programos kodas:

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)
}

Įkėlę šį kodą, tiesiog pažiūrėkite, kaip puodo koregavimas sukuria įdomų šviesos efektą RGB, tai gali būti tikra pramoga.

Pastebėsite, kad kai visi 3 puodai bus perkelti maksimaliai, vietoj baltos spalvos pamatysite raudoną. Taip yra todėl, kad raudona spalva yra ryškiausia tarp 3 spalvų, todėl šioje situacijoje dominuoja. Tačiau galite eksperimentuoti su funkcija žemėlapis () , prieš vykdydami raudoną šviesos diodo dalį, kad būtų sukurta protingesnė pusiausvyra.

Garso įrašas su „Arduino“

Šiame skyriuje sužinosime, kaip pridėti pagrindinį garsą ir muziką prie „Arduino“ sąrankos.

Pamatysime, kaip perjungti signalą į prijungtą garsiakalbį norimu dažniu.

Tiksliau tariant, bus bandoma vidurinė A nata, kuri yra 440 Hz dažnio nata.

Norėdami tai padaryti, mes tiesiog grosime vidurinę A natą ir optimizuosime sinusinės bangos signalą kvadratine banga.

Be to, apskaičiuosime, kiek laiko garsiakalbis gali būti įjungtas, paduodami formulę:

timeDelay = 1 sekundė / 2 x toneFrequency.

timeDelay = 1 sekundė / 2 x 440

timeDelay = 1136 mikrosekundės

4.1 Prijunkime „Arduino“ lentą

Garso efekto naudojimas „Arduino“

4.2 Paprasto užrašo pridėjimas

Mes jau aptarėme apie funkciją delsimas() kur vienetas yra milisekundėmis (sekundė / 1000), tačiau rasite dar vieną funkciją delayMicroseconds() kur vienetas yra mikrosekundėmis, (milisekundė / 1000).

Dabartinei sąrangai mes užprogramuojame kodą, įjungiantį + 5 V įjungtą / išjungtą pasirinktą kaištį, susietą su garsiakalbiu, 440 impulsų per sekundę greičiu.

Prisiminkime, paskutinėje diskusijoje nustatėme numatytos garso natos vertę 1136 mikrosekundės.

Taigi štai tam skirta programa, kuri leis jums išgirsti 440 Hz garso įrašą, kai tik užprogramuosite „arduino“ su prijungtu garsiakalbiu.

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)
}

Naudodamiesi aukščiau pateikta programa, galite padaryti garso įrašą, o tai taip pat reiškia, kad galime sukurti muziką pagal savo pasirinkimą.

Iš kodo suprantame, kad „Arduino“ apima keletą integruotų funkcijų, kurios papildomai prisideda prie muzikos kūrimo.

Pirmasis yra tonas() kuris veikia su 2 elementais kartu su trečiuoju pasirinktiniu elementu, pažymėtu kaip tonas (kaištis, dažnis, trukmė). arba tonas (kaištis, dažnis)

Abi yra skirtos vykdyti jūsų paskirtą laikotarpį.

Nesant laiko, muzika bus tęsiama iki skambučio tonas() bus vykdoma dar kartą arba kol įvykdysite notone ().

Tai turės būti padaryta naudojant uždelsimo funkciją, jei tik pagrindinis dalykas, kurį įgyvendinate, yra muzikos grojimas.

Laiko trukmė gali būti labai svarbi, nes ji leidžia nustatyti laiką, kiek laiko muzika grojama, taigi ar galite laisvai daryti kitus dalykus. Kai tik pasibaigia trukmė, muzika sustoja.

Kita funkcija „noTone“ () tvarko vieną parametrą ir sustabdo pasirinktą toną tam tikram priskirtam kaiščiui.

Savotiškas perspėjimas: bet kada, kai tonas() įdiegta funkcija, PWM funkcija 3 ir 11 kaiščiuose nustos veikti.

Todėl, kai programoje naudojamas garsiakalbio priedas, įsitikinkite, kad nenaudojote minėto kaiščio garsiakalbiams, verčiau išbandykite kitus garsiakalbių tvirtinimo kaiščius.

Gerai, todėl pateikiama programa, skirta muzikai pritaikyti garsiakalbyje, nors tai nėra tikra muzika, o pagrindinė C skalė.

#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)
}

Aukščiau pateiktame kode galbūt pastebėjote ką nors naujo ir tai #apibrėžti .

Šis terminas veikia kaip paieškos ir pakeitimo komanda kompiuteryje, kol atliekamas kompiliavimas.

Kai tik randa pirmą dalyką prieš tarpą, jis pakeičia jį likusia eilutės dalimi (vadinama makrokomandomis).

Taigi šiame pavyzdyje, kai kompiuteris mato PASTABA_E4 tai greitai pakeičia 330 kiekiu.

Norėdami gauti daugiau pastabų ir pritaikyti, galite kreiptis į failą savo USB atmintinėje, pavadintą aikštelės.h , kur daugumą dažnių galima rasti pagal jūsų pageidavimus.

4.4 Muzika su funkcijomis

Aukščiau pateiktas kodas atrodo gerai, bet atrodo, kad pasikartojimų yra daug, turėtų būti koks nors būdas šiems pakartojimams sutrumpinti, tiesa?

Iki šiol dirbome su dviem pagrindinėmis funkcijomis, įtrauktomis į „Arduino“. Dabar gali būti laikas susikurti savo funkcijas.

Kiekviena funkcija turi prasidėti kintamojo tipu, su kuriuo gali būti susieta. Pavyzdžiui, funkcija tuštuma nurodo tipą, kuris nieko negrąžina, todėl vardas negalioja. Atkreipkite dėmesį, kad mes jau aptarėme kintamųjų sąrašą ankstesniuose skyriuose, galbūt norėsite juos nurodyti.

Vadinasi, konkretus funkcijos pavadinimas gauna atvirą skliaustą „(“ po to pateikiamas kableliais atskirtų parametrų sąrašas.

Kiekvienas parametras įgauna savo tipą kartu su pavadinimu ir galiausiai uždaro „)“ skliausteliuose.

Šie parametrai gali būti naudojami funkcijoje kintamųjų pavidalu.

Pažiūrėkime toliau pateiktą pavyzdį, kuriame mes sukuriame funkciją, vadinamą „myTone“ () skirtas sujungti tonas() su delsimas() linijos tokiu būdu, kad funkcija nustos grįžti tol, kol užrašas baigs groti toną.

Mes įdiegiame šias funkcijas ankstesniame kode ir gauname žemiau pateiktą programą, žr. Paskutines eilutes:

#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)
}

Funkcijos gali būti labai patogios, kad programą būtų lengviau suprasti.

Toliau pateikiamas pavyzdys, kai mes galime nurodyti tono, kurį norime žaisti, pasirinkimą dviem masyvais. Vienas masyvas užrašams išlaikyti, kitas - ritmams išlaikyti.

#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 if (notes[i] == 0) {
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)
}

Pirmoje eilutėje aiškiai matote įvadą # įtraukti pareiškimas. Šio teiginio užduotis yra pasiimti visą failą tarp kabučių ir pastatyti jį į # įtraukti pareiškimas. Pagal standartines taisykles jos griežtai laikomos programos pradžioje.

5 skyrius

Temperatūros matavimas

Norint tik prisiminti, prisiminti, užuot iš viso rašius dideles programas, visada išmintinga rašyti ir analizuoti mažas kodų dalis, o tai padeda greitai nustatyti klaidas.

5.1 Serijinis monitorius

Iki šiol aptariami kodai nėra tokie lengvi, kad būtų galima greitai pašalinti triktis. Čia mes stengsimės palengvinti stebėseną ir lengviau išspręsti galimą problemą.

„Arduino“ turi savybę, leidžiančią „susikalbėti“ su kompiuteriu. Galite pastebėti, kad pin0 ir pin1 yra pažymėti kaip RX TX, vienas šalia kito. Šiuos kaiščius iš tikrųjų stebi atskiras „Arduino“ IC, kuris atnaujina juos skaityti per USB kabelį, kol jis prijungtas prie kompiuterio.

Žemiau pateiktame skyriuje rodoma visavertė programa. Prašau pereiti prie jos, vėliau sužinosime apie naujus kodo įrašus. Šis kodas yra tas pats, kas išreikštas 2.2 skirsnyje, išskyrus tai, kad jame yra tam tikrų papildomų duomenų, leidžiančių nustatyti, kam jis užkoduotas.

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)
}

Čia galite nustatyti du naujus dalykus, naują eilutę sąranka () funkcija.

Serial.begin(9600)

Ši eilutė tiesiog išreiškia būtinybę naudoti Serija1 kodą, kad jis būtų užtikrintas 9600 baudų. (čia serijinis nurodo bitai siunčiamas vienas po kito, o baudas reiškia jo siuntimo greitį). Ši baudos vertė ir serijinio monitoriaus viduje (sužinosime vėliau) turi būti lygi, nes kitaip nuosekliojo monitoriaus duomenys parodys šiukšles. 9600 standartas tampa patogesnis naudoti.

Antrasis naujas įrašas yra toks

Serial.print('delayTime = ')
Serial.println(delayTime)

Antroji eilutė rodo, kad paskesnis dalykas, išeinantis iš nuoseklaus prievado, prasidės kitoje eilutėje. Tuo antroji eilutė skiriasi nuo kumščio.

Dar vienas dalykas, kurį galite pamatyti, yra kabutės ('). Tai vadinama eilute, kuri čia bus naudojama tik kaip konstantos, nes tolesnė diskusija šia tema gali būti per daug išsami ir neaprėpiama.

Gerai, dabar mes galime įkelti pirmiau nurodytą kodą į „Arduino“ ir pamatyti, kas atsitiks.

Ką gi, panašu, kad nieko neįvyko, „Arduino“ kaiščio Nr. 13 šviesos diodas mirktelėjo ir sustojo, o „Tx“ šviesos diodas mirksėjo.

Na, taip yra todėl, kad „Serial Monitor“ langas dar nėra sutvarkytas.

Turite spustelėti „Serial Monitor“ langelį savo IDE, kaip parodyta aukščiau. Nepamirškite patikrinti perdavimo greičio, esančio apačioje dešinėje, pagal numatytuosius nustatymus jis turėtų būti 9600 ir atitiks kodą. Jei ne, būtinai pasirinkite 9600.

Šiame vaizdo įraše paaiškinta, kaip tai daroma.

https://youtu.be/ENg8CUyXm10

Dabar eikime į priekį ir sužinokime, kaip pirmiau nurodyta „Serial Monitor“ funkcija gali padėti apdoroti temperatūros matavimas naudojant „Arduino“

IC TMP36 naudosime kaip temperatūros jutiklį, kurio diapazonas yra nuo -40 iki 150 laipsnių Celsijaus.

Sąranką galima pamatyti žemiau:

TMP36 su „Arduino“ temperatūros matavimui

Šis kodas inicijuos temperatūros matavimą nuskaitydamas TMP36 jutiklio išvestį ir nusiųsdamas jį į nuoseklųjį ID monitorių.

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
}

Supraskime kodą iš viršaus.

float temperatureC = getTemperatureC()

Čia galite pamatyti, kad įtraukėme kintamojo tipą plūdė.

Tai yra vienintelis kintamojo tipas, kuriame saugoma viskas, išskyrus sveikus skaičius (skaičius be dešimtainių ar trupmeninių dalių).

Plūduriuojančio kintamojo tikslumas gali būti nuo 6 iki 7 skaitmenų.

Gretimas kodas getTemperatureC() yra mūsų pačių funkcija, matematiškai apskaičiuojanti ir paverčiančią įtampos skirtumą nuo TMP36 jutiklio į Celsijaus laipsnius.

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
}

Kitame kodų skyriuje, nes terminas analogIn() paskirta grąžinti skaičių nuo 1 iki 1023, mums tampa įmanoma įvertinti jutiklio įtampą padauginus rodmenį iš 5 ir tada padalijus iš 1024.

Jutiklis TMP36 nurodytas generuoti 0,5 V esant 0 laipsnių Celsijaus laipsniui, o vėliau generuoja 10 mV kiekvienam Celsijaus laipsnio pakilimui.

Štai apytikslė vertė, kurią galime sukurti atlikdami skaičiavimus:

Arduino temperatūros kalibravimas

Galite laikyti savo pirmąja funkcija, kuri grąžina tam tikrą vertę (atkreipkite dėmesį, kad visos likusios funkcijos iki šiol negrąžino jokios vertės, nes jos buvo tokio tipo tuštuma ).

Galite suprasti, kad norint gauti vertę iš funkcijos, tiesiog reikia pridėti grįžti po kurio yra norimas numeris, kurį norite grąžinti.

Kai sakome grįžti tai reiškia, kad funkcija grąžina atsakymą arba atsakymą, kai tik jis iškviečiamas, kurį galima pritaikyti kintamajam.

Kai tai siunčiama į nuoseklųjį monitorių, rodmenys konvertuojami į Fahrenheitą convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Ši funkcija surenka Celsijaus diapazoną ir paverčia jį pagal Farenheitą.

Norėdami konvertuoti Fahrenheitą į Celsijaus, mes įgyvendiname formulę Farenheitas = 9 / 5 (Celsijaus) + 32.

5.3 LCD sąsaja

Dabar panagrinėkime, kaip sąsają ar prijungti LCD ekranas su „Arduino“, kad galėtumėte gauti reikiamų rezultatų vaizdinį vaizdą.

Savo programoje mes ketiname naudoti 84x48 grafinį LCD ekraną, kurio horizontalus vaizdas yra 84 pikseliai arba taškai, o vertikali skiriamoji geba - 48 pikseliai. Kadangi specialus valdiklis tampa būtinas visiems skystųjų kristalų ekranams, dabartiniame įrenginyje taip pat yra vienas iš jų - PCD8544 valdiklis.

Šioje pamokoje mes sujungsime aukščiau nurodytą LCD modulį su „Arduino“ ir pritaikysime tam tikras procedūras, kad ekrane būtų kuriami tekstiniai pranešimai.

Šiame paveikslėlyje galite rasti išsamią informaciją apie LCD sąsają ir mažą 3,3 V įtampos reguliatorius . Šis reguliatorius yra būtinas, nes LCD yra nurodytas veikti su 3,3 V maitinimo šaltiniu.

Taip pat galite pamatyti 8 kontaktus iš skystųjų kristalų modulio. Pinouto specifikacijas galite sužinoti šioje lentelėje:

Informacija apie LCD ekraną

Dabar pažiūrėkime, kaip mes galime prijungti LCD ekraną ir atitinkamus parametrus su savo „Arduino“. Išsamią informaciją galima pavaizduoti toliau pateiktoje iliustracijoje:

Arduino pagrindinis mokymasis

5.4 Bendravimas su LCD

Nors iš „Arduino“ galima parašyti sudėtingas sąveikas bendraujant su LCD, mes geriau išmoksime, kaip tą padaryti naudojant bibliotekas.

Bibliotekos apima kodų asortimentą, kuriuos galima greitai pritaikyti pasirinktai „Arduino“ programai.

Tai leidžia vartotojui be vargo iškviesti funkciją, neatliekant sudėtingo kodavimo darbo.

5.4.1 Kaip įdiegti biblioteką

Norėdami tai padaryti, turėsite sukurti katalogą, vadinamą bibliotekomis, savo kompiuteryje „Arduino IDE“, kaip paaiškinta čia

5.4.2 Skystųjų kristalų operacijų vykdymas

Kaip ir ankstesnį požiūrį, pirmiausia patikrinsime visą kodą ir bandysime suprasti atskirų eilučių detales.

#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())
}

Eilutėje yra kodas #include

Kodas #include nurodo asmeniniam kompiuteriui surinkti minėtą failą ir pakeisti elementą #include failo turiniu kuriant programą.

Elementas #include gali turėti kampinius skliaustus, kurie nurodo paiešką bibliotekos kataloge, taip pat gali turėti kabučių, rodančių paiešką tame pačiame kataloge, kuriame yra programa.

Vėlesnės kodo eilutės išreiškia LCD ekranus, tada mes parašome naują kintamojo formą:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Čia mes išreiškiame kintamąjį pavadinimu lcd, kurio tipas yra PCD8544, ir nurodome asmeniniam kompiuteriui perregistruoti su „Arduino“ susijusius pinouts.

Šiame procese aprašome kintamąjį asmeniniam kompiuteriui nurodydami, kaip kaištis clk, din, dc ir reset yra susietas su „Arduino“.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

Linija lcd.init() inicijuojamas LCD veikimas. Kai tai bus įvykdyta, kita eilutė nukreipia žymeklį į viršutinę kairę ekrano dalį. Kita sekanti eilutė stengiasi išspausdinti pranešimą „Labas, pasauli“.

Tai atrodo visiškai identiška technikai, kuria mes siuntėme pranešimus per nuoseklųjį monitorių. Vienintelis skirtumas yra kodo lcd.print naudojimas vietoj serijinio.spausdinti.

Kitas kodo blokas iš tikrųjų vadinamas pakartotinai.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Naudojant šią eilutę lcd.setCursor(0,1) užfiksuojame žymeklį prie 0-ojo stulpelio, esančio 1-osios eilutės kairėje, per LCD ekraną.

Kitoje eilutėje naudojamas spartusis klavišas: lcd.print(millis())

Jei prisiminsite, kad mes dirbome su millis() ankstesniuose koduose tą patį galėjome pritaikyti ir per kodus:

long numMillis = millis()
lcd.print(numMillis)

Tačiau dėl to, kad čia nėra laikotarpių milisekundėmis, todėl mes tai įvykdome paprasčiausiai išsiųsdami millis() veikia tiesiogiai lcd.print() .

5.5 Viso dalyko derinimas

Gerai, dabar sujungkime visus kodus, kuriuos išmokome aukščiau, kad sukurtume LCD temperatūros grandinę, ir pažiūrėkime, kaip tai atrodo:

#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
}

Aukščiau pateiktoje programoje viskas atrodo standartiškai, išskyrus funkcijos naudojimą setCursor () . Tai naudojama norint kuo labiau sulygiuoti tekstą aplink ekrano vidurį.

Puiku! Sveikiname, jūs ką tik užprogramavote savo mažą LCD temperatūros indikatorių naudodami „Arduino“.

Praktinės „Arduino“ programos

Kadangi šiuo metu mes išsamiai išnagrinėjome įvairias programavimo technikas, atėjo laikas jas išaiškinti pritaikant keletą naudingų praktinių įgyvendinimų.

Pradėsime nuo jutiklių ir pamatysime, kaip jutiklių prietaisai galėtų būti naudojami su „Arduino“, atlikdami kelis pavyzdinius kodus.

7.1 Įvadas į jutiklius

Šioje pamokoje sužinosime apie įvairiausius jutiklius, kuriuos galima naudoti su „Arduino“. Tai gali būti tokie prietaisai kaip šviesos jutiklis LDR, magnetinis salės efekto jutiklis, pasvirimo jutikliai, vibracijos jutiklis, slėgio jutiklis ir kt.

Pradėsime nuo šviesos jutiklis LDR su „Arduino“, kaip parodyta šioje diagramoje:

naudokite LDR su „Arduino“

Kaip mes visi žinome, LDR yra nuo šviesos priklausantis rezistoriaus įtaisas, kurio varža priklauso nuo jo paviršiaus intensyvumo.

Šviesos intensyvumas yra atvirkščiai proporcingas LDR atsparumo rodmeniui.

Čia sužinosime, kaip ši nuosavybė gali būti integruota su „Arduino“, norint vykdyti naudingą programą:

Visą programos kodą galima vizualizuoti taip, kaip nurodyta toliau:

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 kode naudojami parametrai jau buvo aptarti mūsų kurse, kurį mes išmokome iki šiol. Eilutes galite patikrinti nurodydami atitinkamus skyrius.

Vertės buvo pasirinktos atsitiktinai, jas galite lengvai pakeisti pagal savo pageidavimus.

Pakreipimo jutiklis

Pakreipimo jutiklis yra paprastas įtaisas, kuriuo galima aptikti bet kurio objekto, kuriame jis sumontuotas, pasvirimo veiksmus. Iš esmės prietaiso viduje yra metalinis rutulys, kuris pasisukdamas ritasi per porą kontaktų, sukeldamas laidumą per tuos kontaktus. Šie kontaktai, nutraukiami kaip pakreipimo jungiklio laidai, naudojami su išorine grandine laidumui nustatyti dėl pakreipimo ir aktyvuoti norimą išvesties taikymą.

Dabar pažiūrėkime, kaip pasvirimo jutiklis prietaisas gali būti prijungtas. Žemiau pateiktame paveikslėlyje pateikiama idėja dėl visos konfigūracijos:

intefacing pasvirimo jutiklis su Arduino

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)
}
}

Šiame pavyzdyje numatytasis kaištis Nr. 13 LED naudojamas kaip pakreipimo indikatorius.

Čia aiškiai matote įtraukimo rezistoriaus įtraukimą, gana panašų į tai, ką mes darėme 3.1 skyriuje. Todėl terminas LOW rodo, kad pasvirimo funkcija neveikia.

7.4 „Reed“ jungiklio relė (įjungta miniatiūrinio magneto relė)

Dabar pažiūrėkime, kaip prijungti relės jungiklį ar magnetinio lauko jutiklį su „Arduino“. Nendrių relė yra tam tikras jungiklis, kuris įsijungia arba vykdo, kai šalia jo yra magnetinis laukas ar magnetas. Iš esmės jis turi porą feromagnetinių kontaktų miniatiūrinio stiklo gaubto viduje, kurie jungiasi arba kontaktuoja dėl magnetinio traukimo, kai tik magnetas yra arti jo. Kai taip atsitinka, kontaktų gnybtai rodo laidumą dėl kontaktų uždarymo.

Čia taip pat naudojame kaištį Nr. 13 LED, kad nurodytume atsakymą. Iš šio kaiščio galite prijungti išorinį šviesos diodą, jei to reikia pagal mūsų ankstesnius paaiškinimus.

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)
}
}

Kodo terminai turėtų būti žinomi ir savaime suprantami.

7.5 Vibracijos jutiklis naudojant „Piezo“ keitiklį

Kitoje pavyzdinėje programoje pamatysime, kaip pjezo keitiklis gali būti naudojamas kaip vibracijos jutiklis apšviesti šviesos diodą per „Arduino“.

Pjezo elementas iš tikrųjų yra įtaisas, generuojantis vibraciją ar svyravimus, kai dažnis yra naudojamas jo gnybtuose. Tačiau tas pats pjezo gali būti naudojamas atvirkštiniame procese generuojantis elektrinius impulsus reaguojant į jo kūnui taikomą vibraciją. Ši vibracija gali būti smūgio ar smūgio į pjezo paviršių forma.

Nustatykite „Arduino“ ir pjezo elementą, kaip parodyta kitame paveikslėlyje

naudojant „piezo“ kaip vibracijos jutiklį su „Arduino“

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
}
}

100 slenkstis yra įvestas tik tam, kad įsitikintumėte, jog „Arduino“ reaguoja tik į tikras vibracijas per smūgius, o ne į kitas mažesnes vibracijas, tokias kaip garsūs garsai ar ragai.

A5 kaiščio pasirinkimas nėra privalomas, galite pasirinkti bet kurį kitą analoginį įėjimą pagal savo pageidavimus ir suderindami jį su programos kodu.

Servo variklio naudojimas su „Arduino“

Servovariklis yra nuolatinės srovės variklio tipas, kurį galima pasukti tiksliais kampais, atsižvelgiant į konkretaus pritaikymo poreikį. Tai galima padaryti taikant apskaičiuotą komandą atitinkamiems variklio įėjimams, kad būtų sukurtas tikslus sukimo ar posūkio kampas 180 laipsnių diapazone.

Paprastai servovariklis turi 3 laidus arba įėjimus. Teigiami laidai paprastai yra raudonos spalvos, neigiami arba įžeminimo laidai yra juodi, o komandinis laidas arba signalinis laidas paprastai yra baltos arba geltonos spalvos.

„Arduino“ palengvina servovariklio valdymą per integruotą palaikymo kalbą, todėl valdymas yra labai patogus ir idealus servovarikliams.

Šis pavyzdys parodys mums pagrindinę servo variklio valdymo per „Arduino“ diegimo programą:

„Arduino“ servovariklio valdymas

Kodas pateiktas žemiau:

#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)
}

Čia galime pamatyti porą naujų įrašų. Tas, kuris nurodo pritvirtintą servo laidą, prie kurio kaiščio jis priskirtas. Kitas yra kodas, suteikiantis kaiščiui vertę nuo 0 iki 180, kad būtų galima nustatyti pasukimo kampą ant servo.

Išvada

„Arduino“ tema gali būti be galo ilga, taigi ir už šio straipsnio ribų. Tačiau tikiuosi, kad aukščiau pamoka tikrai turėjo padėti jums išmokti pačių „Arduino“ pagrindų ir suprasti svarbius parametrus per įvairius programų kodus.

Tikimės, kad daugiau informacijos čia gali būti kartkartėmis atnaujinama, kai tik ji yra prieinama.

Tuo tarpu mėgaukitės savo programavimo kursais, „Happy Arduinoing you“!




Pora: Alkoholio detektoriaus matuoklio grandinė naudojant MQ-3 jutiklio modulį Kitas: „Cellphone“ valdoma šunų tiekimo grandinė