Arduino-perusohjelmoinnin oppiminen - opas uusille tulokkaille

Tässä opetusohjelmassa opitaan, miten Arduino-perusohjelmointi tehdään esimerkkikoodien ja esimerkkiohjelmien avulla. Tämä opetusohjelma voi olla erittäin arvokas kurssi kaikille uusille tulokkaille, jotka haluavat ymmärtää perusteet helposti, ymmärrettävällä kielellä.

Johdanto

Mukaan wikipedia mikro-ohjain vastaa yhden IC-sirun sisään rakennettua minitietokonetta, jolla on oma ydinprosessori, ohjelmoitavat tulot, muisti ja lähtölaitteet.

Mikrokontrollerista tulee niin hyödyllinen käyttäjälle, koska se tarjoaa sisäänrakennetun prosessorin, muistin ja tulo- / lähtöportit (joita kutsutaan myös GPIO: ksi tai yleiskäyttöisiksi tulo- / lähtöliittimiksi), joita käyttäjä voi ohjata haluttujen spesifikaatioiden mukaisesti.

Tässä opetusohjelmassa työskentelemme Arduino Uno -taulun kanssa ohjelmien oppimiseksi ja testaamiseksi. Laitteistokokoonpanon testaamiseen ja integrointiin käytämme leipälevyä.

Siirrytään nyt nopeasti ja opitaan aloittamaan Arduino-ohjelmointi.

1.2 Ohjelmiston asentaminen (Windows)

Tätä varten tarvitset pääsyn Internetiin, joka tietysti sinulla olisi tietokoneellasi. Siirry seuraavaan linkkiin ja lataa IDE-ohjelmisto:

Windowsin ZIP-tiedosto ei-järjestelmänvalvojan asennukseen

Lataamisen jälkeen löydät latauskansiosta Arduino-asetuskuvakkeen, joka näyttäisi tältä:

Kun saat tämän, voit yksinkertaisesti kaksoisnapsauttaa sitä ja asentaa Arduino Integrated Development Environment (IDE) tietokoneellesi. Koko prosessi voidaan visualisoida seuraavassa videossa:

1.4 Aloitetaan ensimmäisestä piiristä

Ennen kuin aloitamme varsinaisten ohjelmointitekniikoiden oppimisen, jokaiselle aloittelijalle olisi hyödyllistä aloittaa peruskomponentilla, kuten LEDillä, ja ymmärtää kuinka yhdistää se Arduinoon.

Kuten tiedämme, LED on valodiodi, jolla on napaisuus ja joka ei syty, ellei sitä ole kytketty oikeisiin syöttöpylväisiin.

Toinen LED-valaisimien näkökohta on, että nämä laitteet toimivat matalalla virralla ja voivat vahingoittua välittömästi, jos asianmukaisesti laskettua vastusta ei sisälly sarjaan yhden nastansa kanssa.

Nyrkkisääntönä 330 ohmin 1/4 watti on varsin ihanteellinen jokaista 5 V: n nousua varten syöttötulossa virran rajoittamiseksi vaaditulle turvalliselle tasolle. Siksi 5 V: lle se voi olla 330 ohmia, 10 V: lle se voi olla 680 ohmia ja niin edelleen.

Leipälevyn käyttö kokoonpanossa

Varmista, että osaat käyttää a leipälauta ennen tässä luvussa selitetyn opetusohjelman kokeilemista, koska käytämme leipälevyä kaikkiin kokeisiin täällä.

LED-yhteyden perusasetukset voidaan nähdä alla:

Näet yllä 3 peruskomponenttia:

1. 5 mm: n, 20 mA: n LED
2. 330 ohmin 1/4 watin vastus
3. An Arduino-lauta

Kokoa vain järjestelmä kaavion mukaisesti.

Liitä seuraavaksi 5 V tietokoneen USB-laitteelta Arduinoon. Heti kun teet tämän, näet LED-valon syttyvän.

Tiedän, että se on melko yksinkertainen, mutta on aina hyvä aloittaa alusta. Voit olla varma, että asiat alkavat tulla yhä mielenkiintoisemmiksi eteenpäin.

1.5 LEDien hallinta Arduinolla

Nyt opimme hallitsemaan LEDiä Arduino-ohjelmalla.

Ohjelman kirjoittamiseksi meillä on oltava vähintään 2 toimintoa kussakin ohjelmassa.

Funktio voidaan ymmärtää sarjana ohjelmointilausekkeita, joille voidaan antaa nimi, kuten alla on esitetty:

1. perustaa() tämä kutsutaan tai suoritetaan ohjelman käynnistyksen aikana.
2. silmukka () tätä kutsutaan tai suoritetaan toistuvasti koko Arduinon toiminta-ajan.

Siksi, vaikka sillä ei ehkä ole käytännön toimintoja, teknisesti lyhin laillinen Arduino-ohjelma voidaan kirjoittaa seuraavasti:

Yksinkertaisin ohjelma

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

Olet ehkä huomannut, että monilla ohjelmointikielillä järjestelmä alkaa näyttämällä yksinkertainen tulos 'Hello, World' näytöllä

Tämän lauseen elektroninen vastine mikrokontrollerin tulkinnassa on vilkkua LED-merkkivalo PÄÄLLÄ ja POIS.

Tämä on yksinkertaisin ohjelma, jonka voi kirjoittaa ja toteuttaa osoittamaan järjestelmän moitteetonta toimintaa.

Yritämme toteuttaa ja ymmärtää menettely seuraavan koodinpätkän avulla:

Listaus 1.2: led1 / led1.pde

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

OK, nyt ymmärretään, mitä koodin kukin rivi tarkoittaa ja miten se toimii toiminnon suorittamiseksi:

const int kPinLed = 13

Tämä toimii kuin vakio, jonka avulla voimme käyttää sitä koko ohjelmointikurssin aikana tarvitsematta käyttää sitä vastaan ​​asetettua todellista arvoa.

Vakiosääntöjen mukaan tällaiset vakiot tunnistetaan alkukirjaimella että . Vaikka tämä ei ole pakollista, se tekee asioista selkeämpiä ja helposti ymmärrettäviä aina, kun haluat käydä läpi kooditiedot.

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

Tämä koodi määrittää tietyn nastan, johon LEDimme on kytketty. Toisin sanoen koodi käskee Arduinoa hallitsemaan tämän nastan 'kirjoittamisen' aspektia sen sijaan, että 'lukisi' sitä.

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

Yllä olevat rivit osoittavat sovelluksen todellisen suorituksen. Koodi aloitetaan kirjoittamalla ja suorittamalla HIGH ulos asiaankuuluvasta LED-liitännästä kytkemällä LED päälle.

Tässä termi KORKEA tarkoittaa yksinkertaisesti + 5 V: n saamista Arduinon kyseiseen tapiin. Täydentävä termi LOW osoittaa yksinkertaisesti nollan tai 0 V: n osoitetulla tapilla.

Seuraavaksi soitamme delay() jonka tehtävänä on luoda viive millisekuntien (1/1000 sekunnin) kautta. Koska luku 500 syötetään, toteutettu viive on 1/2 sekuntia.

Heti kun tämä 1/2 sekuntia on kulunut umpeen, suoritetaan seuraava rivi, joka sammuttaa LEDin samassa nastassa olevalla LOW-termillä.

Seuraava linja tuottaa jälleen 1/2 sekunnin viiveen, jotta LED pysyy POIS PÄÄLTÄ 1/2 sekunnin ajan.

Ja prosessi jatkuu loputtomasti suorittamalla koodirivit, kunhan Arduinoa pidetään virtana.

Ennen kuin siirryt seuraavalle tasolle, suosittelen, että ohjelmoit yllä olevan koodin ja tarkistat, pystytkö ottamaan LED ON / OF -sekvenssin oikein vai ei.

Koska Arduinon oletus-LED on kytketty tapiin # 13, sen pitäisi välittömästi reagoida yllä olevaan ohjelmaan ja alkaa vilkkua. Jos kuitenkin havaitset, että ulkoinen LED-merkkivalo ei vilku, LED-laitteessasi voi olla yhteysvirhe, voit yrittää kääntää ledin napaisuuden ja toivottavasti nähdä myös sen vilkkuvan.

Voit pelata viiveaikalla muuttamalla '500' -luvun johonkin muuhun arvoon ja etsimällä LEDin 'kuuntelevan' komentoja ja saamalla sen vilkkumaan määritettyjen viiveiden mukaisesti.

Muista kuitenkin, että jos LED-merkkivalo ei vilku vakiona 1 sekunnin nopeudella viiveajan muutoksesta riippumatta, se saattaa osoittaa, että koodi ei toimi jonkin virheen takia. Koska oletuksena Arduino ohjelmoidaan 1 sekunnin vilkkumisnopeudella. Siksi tämän nopeuden on vaihdeltava koodisi avulla, jotta voit varmistaa, että se toimii oikein.

1.7 Kommentit

Yllä ymmärretyt koodirivit kirjoitettiin nimenomaan tietokoneohjelmistoa varten.

Kuitenkin sen varmistamiseksi, että käyttäjä pystyy viittaamaan rivien merkitykseen ja ymmärtämään ne, voi usein olla hyödyllistä ja järkevää kirjoittaa selitys haluttujen koodirivien viereen.

Näitä kutsutaan kommentteja jotka on kirjoitettu vain ihmisille tai käyttäjille ja jotka on koodattu, jotta tietokoneet voivat sivuuttaa sen turvallisesti.

Näiden kommenttien kieli kirjoitetaan muutamassa muodossa:

1. Kommentin lohkotyyli, jossa kommentin kuvaus on aloitusmerkin / * ja loppusymbolin * / alla.
2. Tämän ei tarvitse rajoittaa yhdellä rivillä, vaan se voidaan laajentaa seuraavalle seuraavalle riville kommentin tai kuvauksen pituudesta riippuen, kuten seuraavassa esimerkissä esitetään:

/ * Tämä on kommentti * /

/ * Niin on tämä * /

/ * Ja
* Tämä
* kuten
* hyvin */

Nopean yhden rivin kuvauksen kirjoittamiseen kommentille riittää, että alussa on kaksi kauttaviivaa // -symboli. Tämä kertoo tietokoneelle, että tällä rivillä ei ole mitään tekemistä todellisen koodin kanssa, ja se on jätettävä huomiotta. Esimerkiksi:

// Tämä on kommentti, jonka tietokoneet jättävät huomiotta.

Tässä on esimerkki viitteestä:

/*
* 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 Vianetsintä

Jos huomaat, että ohjelmassasi on 'virhe' käännöksen aikana, tai jokin muu ongelma, seuraavat vinkit auttavat sinua todennäköisesti tarkistamaan koodisi päästäksesi eroon esteestä.

1. Ohjelmakielesi erottelee kirjainkoon. Esimerkiksi lauseke myVar ei voi kirjoittaa nimellä MyVar.
2. Kaikenlaiset välilyönnit, jotka näppäimistö voi suorittaa, renderöidään lopulta yhtenä tilana, ja vain sinä näet tai ymmärrät sen, tietokone ei ota tätä huomioon. Yksinkertaisesti sanottuna kaikenlaisilla vapailla tiloilla ei ole mitään vaikutusta koodituloksiin.
3. Jokainen koodilohko on suljettava vasemmalla ja oikealla kiharalla sululla, '{' ja '}'
4. Numeronumeroita ei tule erottaa pilkuilla. Esimerkiksi 1000 ei saa kirjoittaa 1000: ksi.
5. Jokaisen kiharoiden sulkujen väliin suljetun koodirivin on oltava lopussa puolipisteellä

Mielenkiintoisen LED-valosekvenssin luominen Arduinolla

Edellisessä luvussa opimme, kuinka LED-merkkivalo vilkkuu jatkuvasti ON / OFF tasaisella viiveellä.

Nyt opimme, kuinka erilaiset viivemallit voidaan suorittaa samalla LEDillä päivittämällä ohjelmakoodi.

Emme käytä ulkoista LEDiä, vaan pikemminkin Arduino-korttiin sisäänrakennettua oletus-LEDiä tapissa # 13. Löydät tämän pienen SMD-LEDin suoraan USB-liitännän takaa.

2.2 IF-lausuntojen ymmärtäminen

Tässä osassa opitaan, kuinka ohjausrakenteet antavat meille mahdollisuuden suorittaa yksittäisiä koodeja ja joskus jopa toistuvasti tarpeen mukaan.

Lausunto jos tulee ensimmäinen ohjausrakenne. Seuraava toteutus osoittaa, miten sitä käytetään:

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

Yritämme ymmärtää yllä olevan koodin vaiheittain ja oppia, miten sitä voidaan käyttää muissa vastaavissa teloituksissa.

1. ja 7. rivin väliset koodit ovat täsmälleen samanlaisia ​​kuin alkuperäinen ohjelma.

Ensimmäinen muutos tapahtuu itse asiassa 8. rivillä.

int delayTime = 1000

Löydät tämän olevan samanlainen kuin 1. rivin koodi, estäen sen, että siitä puuttuu termi vakio

Tämä johtuu yksinkertaisesti siitä, että tämä koodi ei ole vakio. Sen sijaan tämä määritellään a muuttuja , jolla on muuttuvan arvon ominaisuus ohjelmoinnin aikana.

Yllä olevasta esimerkistä näet, että tämä muuttuja on määritetty arvoksi 1000. Muista, että sellaiset muuttujat, jotka on suljettu sulkeissa, on kirjoitettava tiukasti vain kihara-suluissa, ja niihin viitataan nimellä 'paikalliset' muuttujat.

Vaihtoehtoisesti muuttujat, joiden oletetaan olevan kiharoiden sulkujen ulkopuolella, kuten nyt keskustelemme, tunnistetaan 'globaaleiksi' ja ne voidaan suorittaa melkein missä tahansa ohjelmakoodissa.

Edetessä näet, että rivien 9 ja 11 väliset koodit ovat myös samanlaisia ​​kuin ensimmäinen ohjelma, silti asiat alkavat kiinnostaa rivin 11 jälkeen. Katsotaan miten!

delayTime = delayTime - 100

Tässä koodissa näemme, että oletusarvo viiveaika muunnetaan vähentämällä siitä 100.

Merkitys 100 vähennetään sen alkuperäisestä arvosta 1000, jolloin se saa uuden arvon 900.

Seuraavan kuvan avulla yritämme ymmärtää muutamia matduoperaattoreista, joita käytetään arduino-kielellä.

Arvioidaan nyt rivien 13 ja 15 väliset koodit.

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

Edellä olevan koodin päätavoitteena on varmistaa, että LED vilkkuu edelleen keskeytyksettä.

Johtuu siitä, että 100 on vähennetty alkuperäisestä viiveaika , se estää LED-valon vilkkumisen saavuttamasta nollaa ja antaa vilkkumisen jatkua jatkuvasti.

Seuraava kuva näyttää muutaman vertailuoperaattorin, joita käytämme koodeissamme:

Yllä olevassa koodissamme olisimme voineet testata koodin olevan if(delayTime == 0).

Koska negatiivinen luku voi olla yhtä huono, emme kuitenkaan menneet siihen, ja tämä on suositeltava käytäntö.

Ajattele, mikä olisi voinut olla lopputulos, jos yritämme vähentää 300: sta 100: n sijasta delayTime?

Joten nyt olet ehkä tajunnut, että jos delayTime on kirjoitettu pienemmäksi tai yhtä suureksi kuin nolla, viiveaika asetetaan takaisin alkuperäiseen kuvaan 1000.

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

Koodin neljä viimeistä riviä, kuten yllä on esitetty, ovat vastuussa LEDin kytkemisestä päälle / pois, päälle / pois jatkuvasti.

Täällä voit selvästi huomata, että lukumäärän käyttämisen sijaan olemme käyttäneet muuttujaa viiveajan osoittamiseen, jotta voimme säätää sitä haluamallamme koodin toiminta-ajanjaksolla. Se on hienoa, eikö?

2.3 MUUT lausunnot

Täältä opimme miksi ja miten jos termillä voi olla lauseke muu jotta se päättää tilanteen tilanteessa jos väite on väärä.

Olen pahoillani, jos se kuulostaa liian hämmentävältä, älä huoli, yritämme ymmärtää sen seuraavalla esimerkillä:

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

Edellä olevasta näet, että 10. rivillä koodi suoritetaan vain, kun delayTime on pienempi tai yhtä suuri kuin 100, ellei niin, 13. rivin koodi suoritetaan, mutta molempia yhdessä ei voi koskaan tapahtua, joko 10. tai 13. rivin koodi toteutetaan, ei molempia.

Olet ehkä huomannut, että toisin kuin mitä teimme edellisessä osassa 2.2, tässä ei verrattu nollaan, vaan 100: een. Tämä johtuu siitä, että tässä esimerkissä verrattiin ENNEN kuin vähennimme 100, päinvastoin osiossa 2.2, verrattiin JÄLKEEN vähennetty. Voitteko kertoa, mitä olisi voinut tapahtua, jos vertaisimme nollaa 100: n sijasta?

2.4 MITEN Lausunnot

TO sillä aikaa lausunto on melko samanlainen kuin jos lausunto, paitsi totuus, että se aiheuttaa toistuvan suorituksen koodilohkolle (joka voi olla kiharoiden sulkeiden välissä) niin kauan kuin ehdot ovat voimassa, ja tämä toimii ilman muu lausunto.

Seuraava esimerkki auttaa sinua ymmärtämään tämän paremmin

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

Voitteko arvata, mitä yllä oleva koodi on ohjelmoitu tekemään? No, se on suunniteltu vilkuttamaan LEDiä nopeammin ja sitten hitaammin.

2.5 Mikä on totta ja väärää?

Ohjelmointikielellä väärä viittaa nollaan (0). Oikeastaan ​​'totta' ei käytetä, sen sijaan oletetaan, että kun mikään ei ole väärää, niin kaikki, mikä on mukana, on totta.

Se näyttää vähän oudolta, mutta tekee työn melko hienosti.

Yritämme tarttua tilanteeseen seuraavan esimerkin avulla.

Joskus saatat kohdata alla olevan koodin:

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

Tämä on koodattu näyttää siltä, ​​että LED-suoritus jatkaa pyöräilyä ikuisesti, koska virtaa on saatavilla.

Yksi tämäntyyppisen koodin haittapuoli saattaa kuitenkin syntyä, kun vahingossa käyttäjä käyttää = =: n sijaan =.

Olen varma, että tiedät jo, että = tarkoittaa tehtävää, eli sitä käytetään osoittamaan valittu arvo muuttujaksi, kun taas a == käytetään pakottamaan testi, jos arvo oli sama.

Oletetaan esimerkiksi, että tarvitsit LEDin vilkkumaan peräkkäin ylinopeuksisella kuviolla ja toistuvasti, mutta väärin käytit = =: n sijasta ==.

Koodi näyttäisi tällöin näin:

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
}

Virhe antaa 0: lle delayTime ja johtaa jos lauseke tarkistaa, onko 0 tosi vai ei. Koska 0 viittaa väärään, se ajattelee, että se ei ole totta, ja lopettaa delayTime = 1000: n täytäntöönpanon, mutta sen sijaan funktio delayTime pidetään 0: lla silmukan () aikana.

Tämä näyttää erittäin ei-toivotulta!

Joten tarkista aina ohjelmasi varmistaaksesi, ettet ole tehnyt niin typeriä virheitä.

2.6 Yhdistelmät

Joskus saatat tuntea tarvetta testata useita asioita yhdessä. Kuten, saatat haluta tutkia, oliko muuttuja kahden numeron välillä. Vaikka tämä voidaan toteuttaa käyttämällä if-käskyä useita kertoja, voi olla helpompaa käyttää loogisia yhdistelmiä lukemisen parantamiseksi ja helpottamiseksi.

Yhdistelmien toteuttaminen loogisilla termeillä voidaan tehdä kolmella menetelmällä, kuten seuraavassa taulukossa on esitetty:

Olisi mielenkiintoista tietää, että NOT-operaattori voi toimia vaihtajana muuttujalle, joka voidaan nimetä joko totta tai väärä (tai MATALA tai KORKEA).

Seuraava esimerkki kuvaa ehtoa:

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

Täällä ledState on alhainen, ja myöhemmin heti ledState = !ledState, se muuttuu KORKEA. Seuraava silmukka aiheuttaa ledState olla KORKEA, kun ledState = !ledState on matala.

2.7 Lausekkeille

Yritämme nyt ymmärtää toista ohjausrakennetta, joka on varten silmukka. Tämä voi olla erittäin kätevää, kun haluat toteuttaa jotain useita kertoja.

Ymmärretään tämä seuraavalla esimerkillä:

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
}

Löydät jotain ainutlaatuista linjasta varten.

Se on koodi i ++? . Tämä on hyödyllistä ohjelmoijille, jotka ovat melko laiskoja ja haluavat toteuttaa koodauksen kätevillä pikakuvakkeilla

Yllä oleva termi tunnetaan yhdistelmäoperaattoreina, koska ne tekevät työn yhdistämällä yksi tehtäväoperaattori toisen tehtävänoperaattorin kanssa. Suosituimmat näistä voidaan visualisoida seuraavassa taulukossa:

Löydät, että for-lauseessa on 3 alilausetta. Se on rakennettu alla esitetyllä tavalla:

for (statement1conditionstatement2){
// statements
}

Lausunto nro 1 esiintyy heti alussa ja vain kerran. Kunto testataan joka kerta silmukan aikana. Aina kun se on totta kiharoiden sulkujen sisällä seuraava lausunto nro 2 pannaan täytäntöön. Jos kyseessä on a väärä, järjestelmä hyppää seuraavaan koodilohkoon.

Lisää LEDejä

OK, nyt näemme, kuinka voimme yhdistää useamman LE: n, jotta saisimme mielenkiintoisempia vaikutuksia.

Liitä LEDit ja Arduino alla olevan kuvan mukaisesti. Punainen johto ei todellakaan ole välttämätön, mutta koska aina on hyvä ajatus, että molemmat syöttökiskot sisältyvät leipälautaan, perustuksella on järkeä.

Korjataan nyt ohjelma, jonka avulla voimme tarkistaa, onko laitteistomme konfiguroitu oikein vai ei.

On aina suositeltavaa koodata ja suorittaa ohjelmien pienet bitit vaiheittain tarkistaaksesi, ovatko vastaavat laitteistot kytketty oikein vai ei.

Tämä auttaa mahdollisen virheen vianmäärityksessä nopeasti.

Alla oleva koodiesimerkki antaa LEDille 2 - 5 tietyn kuvion kääntämällä niitä peräkkäin syklisesti.

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

Kuten huomaat, koodissa ei ole mitään vikaa, paitsi että se näyttää pitkältä ja siksi alttiina virheille.

Tietenkin on olemassa parempia tapoja kirjoittaa yllä oleva koodi, seuraava osa paljastaa sen.

2.9 Matriisien esittely

Taulukot voivat olla muuttujien ryhmä, joka voidaan indeksoida indeksinumeroilla. Seuraava esimerkki auttaa meitä ymmärtämään sen paremmin.

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

Selvä, käydään nyt läpi kaikki osat ja ymmärretään, miten ne todella toimivat.

const int k_numLEDs = 4

Yllä oleva koodi määrittelee, kuinka monta maksimielementtiä meidän pitäisi olla taulukossa. Tämä koodi auttaa meitä seuraavissa osioissa varmistamaan, että kaikki on kirjoitettu taulukkoon eikä mitään, kun taulukko päättyy.

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

Tässä seuraavassa rivissä perustettiin matriisirakenne. Suluissa olevat numerot osoittavat matriisin elementtien lukumäärän. Tosiasiallinen määrä olisi voitu kirjoittaa, mutta vakiona kirjoittaminen toimii paremmin. Arvot näkyvät yleensä suluissa pilkuilla, ja ne merkitsevät taulukon arvot.

Kun löydät taulukon, joka on indeksoitu numerolla 0, tämä osoittaa ryhmän ensimmäisen elementin, kuten kuvassa code: k_LEDPins is k_LEDPins[0]

Vastaavasti viimeinen elementti näytetään muodossa k_LEDPins[3], koska määrä 0: sta 3: een on 4.

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

Yllä oleva koodi osoittaa silmukan käytön kunkin matriisielementin läpi ja asettamaan ne LÄHTÖiksi. Toteutamme hakasulkeet hakemiston kanssa päästäkseen ryhmän kaikkiin elementteihin.

jos mietit, onko mahdollista käyttää nastaa # 2 nastaa # 5 ilman matriiseja, vastaus on kyllä, se on mahdollista. Mutta tässä esimerkissä sitä ei tehdä, koska emme tehneet sitä tällä tavalla. Seuraavissa osissa voit poistaa matriisilähestymisen, jos valitut lähtönastat eivät ole linjassa.

Edetessä katsotaan, mitä seuraava koodilohko tekee:

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

Tässä koodi kulkee kunkin LEDin läpi kytkeäksesi ne päälle peräkkäin 100 millisekunnin välein tai viiveellä.

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

Yllä olevan koodin käyttäminen osoittaa kuinka silmukalle voitaisiin käyttää liikkumaan silmukan läpi jopa päinvastaisessa järjestyksessä.

Se alkaa k_numLEDs - 1: sta, koska taulukot on indeksoitu nollaan. Emme aloita k_LEDPins[4] -kohdasta koska se johtaisi matriisin lopun ylittämiseen.

Koodi käyttää> = 0 tarkistaakseen, että indeksin 0 ensimmäistä elementtiä ei jätetä huomiotta.

Luku 3

Mikä on tulo

Joten olemmeko oppineet käyttämään asioita Arduinolla. Tässä luvussa keskustelemme siitä, miten aistia todellista maailmaa yhdistämällä ulkoisten parametrien tulot.

3.1 Painikkeiden käyttö

Me kaikki tiedämme, mikä on painike ja miten se toimii. Se on eräänlainen kytkin tai painike, joka yhdistää signaalin yhdestä piirivaiheesta toiseen hetkellisesti, kun se on masentuneessa tilassa, ja rikkoo signaalin, kun se vapautetaan.

3.1.1 Yksi painike ja LED

Yhdistämme Arduinon painikkeella Arduinon kanssa yllä esitettyjen yksityiskohtien mukaisesti ja opimme asennuksen perustyön ja toteutuksen.

Ilmoitetulla painikkeella, jota kutsutaan myös mikrokytkimen painikkeeksi, on yhteensä 4 nastaa (2 paria kummallakin puolella). Työnnettäessä kukin nastapari liitetään sisäisesti ja mahdollistaa yhteyden tai johtumisen niiden yli.

Tässä esimerkissä käytämme vain yhtä paria näistä nastoista tai koskettimista, toisella parilla ei ole merkitystä ja jätetään siksi huomiotta.

Jatketaan seuraavaa koodia ja tarkistetaan, että se toimii!

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

Täältä löydät muutamia asioita, jotka näyttävät epätavallisilta. Selvitetään heidät vaiheittain.

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

Ensimmäinen asia, jonka teemme, on korjata buttonPin kuten TULO. No, se on melko yksinkertaista, tiedän.

Seuraavaksi annamme KORKEA että TULO tappi. Ihmettelet, miten voi olla mahdollista kirjoittaa mitään syötteeseen? Toki, tämä voi olla mielenkiintoista.

Oikeastaan ​​HIGH-arvon määrittäminen Arduino-tuloon vaihtaa sisäisen 20 k Ohmin vetovastuksen PÄÄLLE (tämän tapin LOW-arvo vaihtaa sen pois päältä).

Toinen kysymys, joka saatat olla, on mikä on vastus. Olen katsonut kattavan viestin vetovastuksista, jotka sinä oppia se täältä .

OK, siirrymme eteenpäin, katsotaanpa nyt pääpiirikoodia:

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

Kun painat painiketta, langallinen tappi liitetään maahan, mikä tekee a MATALA siihen tappi. Ja vaikka puristamattomassa tilassa samaa nastaa pidetään KORKEA tai + 5 V 20 K: n sisäisen vastuksen kautta.

Täällä haluamme, että Arduino syttyy LED-valoon, kun painetaan painiketta (LOW), ja siksi kirjoitamme HIGH-tuloksi jokaiselle LOW-vastaukselle painikkeesta, kun sitä painetaan.

3.1.2 Kaksi painiketta ja LED

Saatat ihmetellä, että yllä esitetty toiminto olisi voitu tehdä myös ilman Arduinoa. Ymmärrän kuitenkin, että tämä on jyrkkä kivi oppia, kuinka painonappia voidaan käyttää Ardunon kanssa.

Tähän asti olemme tutkineet koodien kirjoittamista joko kytkemään PÄÄLLE (KORKEA) tai pois päältä (LOW) LED.

Katsotaan nyt, kuinka LED-valon kirkkautta voitaisiin hallita Arduinolla.

Se voidaan tehdä kahdella tavalla:

1. Rajoittamalla virran määrä LEDiin
2. Käyttämällä PWM tai pulssinleveyden modulointi, jossa LEDin syöttö kytketään päälle / pois päältä / pois halutulla nopeudella erittäin nopeasti, jolloin saadaan keskimääräinen valaistus, jonka voimakkuus riippuu PWM: stä.

Arduino-kortissa PWM-tuki on saatavana tildellä (~) merkittyille nastoille, jotka ovat nastat 3, 4,5,9,10 ja 11) 500 Hz: n taajuudella (500 kertaa sekunnissa). Käyttäjä pystyy antamaan minkä tahansa arvon välillä 0–255, jossa 0 viittaa arvoon HIGH tai ei + 5V, ja 255 käskee Arduinoa saamaan HIGH tai + 5V koko ajan. Näiden komentojen aloittamiseksi sinun on käytettävä analogWrite () -ohjelmaa halutulla arvolla.

Voit olettaa, että PWM on x / 255, jossa x on haluttu arvo, jonka haluat lähettää analogWrite() -palvelun kautta.

Määritä Arduino ja muut parametrit yllä esitetyllä tavalla.

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

Täältä löydät 3 riviä, jotka tarvitsevat selitystä.

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

Rivi: ledBrightness = constrain(ledBrightness, 0, 255) kuvaa ainutlaatuista toimintoa Arduinossa, joka tunnetaan nimellä constrain ().

Tämä sisäinen toiminto sisältää koodin, joka muistuttaa seuraavaa:

int rajoittaa (int arvo, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Kaikki ennen tätä keskustellut koodit alkoivat mitätön , mikä tarkoitti sitä, ettei palautettu mitään (mitätön). Yllä oleva koodi alkaa int , mikä osoittaa, että se palauttaa kokonaisluvun. Keskustelemme lisää myöhemmissä osioissa, muista tällä hetkellä vain, että kokonaisluvulla ei ole murto-osia.

Oikein, joten tämä tarkoittaa, koodi: ledBrightness = constrain(ledBrightness, 0, 255) määrittää ledBrightness to be within the range of 0 and 255.

Seuraava rivi käyttää analogWrite käskee Arduinon käyttämään PWM: ää valitulla tapilla halutulla arvolla.

Seuraava rivi luo 20 millisekunnin viiveen, tällä varmistetaan, että emme säädä ruokaa nopeammin kuin 50 Hz tai 50 kertaa sekunnissa. Tämä johtuu siitä, että ihmiset voivat olla paljon hitaampia kuin Arduino. Näin ollen jos viivettä ei tehdä, ohjelma voi saada meidät tuntemaan, että ensimmäisen painikkeen painaminen kytkee LED: n pois päältä ja toisen painikkeen painaminen kytkee sen päälle (vahvista itse kokeilemalla).

3.2 Potentiometrit

Mennään eteenpäin ja opitaan käyttämään potentiometrit Arduinolla.

Jos haluat tietää, miten potentiometri tai potti toimii, voit lukea tämän artikla .

Yhdistä esitetyt parametrit Arduino-laitteeseesi yllä esitetyllä tavalla.

Potissa on 3 liitintä. Keskimmäinen terminasli muodostaa yhteyden Arduinon ANALOG IN 0: een. Kaksi muuta ulkoliitintä voidaan liittää + 5 V: n ja 0 V: n syöttökiskoihin.

Ohjelmoidaan ja tarkistetaan tulokset:

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

Löydät pari asiaa, jotka saattavat näyttää aivan uusilta ja joita ei sisälly mihinkään aikaisempiin koodeihimme.

1. Vakio kPinPot Määritetään A0: ksi, missä A on pikakuvake yhden analogisen nastan kuvaamiseksi. Kuitenkin A0 viittaa myös tapiin # 14, A1 liittimeen # 15 ja niin edelleen, ja näiden avulla voit käyttää digitaalisia tuloja / ulostuloja siltä varalta, että nastat loppuvat kokeiluun. Muista kuitenkin, että et voi käyttää digitaalisia nastoja analogisina nastoina.
2. Rivi: ledBrightness = map(sensorValue, 0, 1023, 0, 255) esittelee uuden sisätoiminnon Arduinossa kartta(). Tämä ominaisuus kalibroi uudelleen tietyltä alueelta toiselle, jota kutsutaan nimellä kartta (arvo, mistäLow, fromHigh, toLow, toHigh). Tästä voi tulla ratkaiseva, koska analogueRead antaa arvon välillä 0-1023, mutta analogWrite pystyy hyväksymään arvon välillä 0-255.

Saatat ajatella, että koska LED-valon kirkkautta on mahdollista säätää muuttuvalla vastuksella, yksinkertaisesti potti olisi voinut olla riittävä tähän tarkoitukseen, miksi Arduinon käyttö. No, jälleen kerran se on vain perusta, näyttää kuinka potti voidaan määrittää Arduinolla.

Ei ongelmia, nyt teemme jotain, jota ei voida tehdä ilman Arduinoa.

Tässä kokeessa näemme, kuinka potin vaihtelevaa vastusta voitaisiin käyttää ledin vilkkumisnopeuden tai -nopeuden säätämiseen.

Tässä on ohjelma:

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 Viivästymisen välttäminen ()

Yllä oleva koodi näyttää hyvältä, mutta LED ei pysty tarkistamaan potin arvoa, ennen kuin se käy läpi koko täyden jakson. Pidempien viiveiden vuoksi tämä prosessi pidentyy, ja käyttäjän on odotettava potin vastausta, kun hän siirtää sitä. Tämä viive voidaan välttää älykkäällä ohjelmoinnilla, jotta käyttäjä voi tarkistaa arvon ilman pienimpiä viiveitä. Tässä koodi.

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

Joten mikä on erilaista yllä olevassa koodissa? Seuraava rivi tekee eron.

long lastTime = 0

Tähän osioon asti olemme keskustelleet muuttujasta int. Saatat kuitenkin käyttää useita muita tyypin muuttujia. Luettelon voi lukea alla:

Tällä hetkellä voi olla vain ratkaisevaa tietää, että suhteellisen suurten lukujen tallentamiseksi int muuttuja, voit käyttää termiä pitkä tai a pitkä int.

Täällä voit nähdä toisen mielenkiintoisen toiminnon nimeltä millis ().

Tämä tuottaa ajanjakson millisekunteina, jonka Arduino työskenteli toimintansa aikana alusta alkaen (tämä palautuu arvoon 0 50 päivän välein). Täällä se palauttaa pitkän, koska jos se palasi int , pitkien jaksojen laskenta ei ehkä ole mahdollista. Voitteko vastata tarkalleen kuinka kauan? Vastaus on 32,767 sekuntia.

Siksi viiveen () käyttämisen sijaan tarkistamme millis (), ja heti kun tietty määrä millisekunteja loppuu, vaihdamme LED-merkkivaloa. Näin ollen tallennamme ajan, jolloin muutimme sitä viimeksi lastTime muuttuja niin, että sen avulla voimme tarkistaa sen uudelleen aina kun halutaan.

3.3 RGB-LEDit

Toistaiseksi olemme soittaneet yksivärisellä LEDillä. Vaikka LED-väriä voitaisiin muuttaa korvaamalla LED toisella värillä, mutta entä RGB-LEDien käyttö vaihtaa LED-värejä muuttamatta LED-valoja?

RGB-LED on periaatteessa LED, jossa on punainen, vihreä ja sininen LED-valot upotettuna ja yhdistettynä yhdeksi LED-valoksi. Sillä on yksi yhteinen johto, joka menee maahan tai 0 V: n syöttökiskoon, kun taas muille 3 johdolle syötetään monipuolisia PWM-positiivisia signaaleja suunnitellun toteuttamiseksi värien sekoittaminen .

Voit kytkeä kokoonpanon alla olevan kuvan mukaisesti:

Se voi näyttää hieman monimutkaiselta, mutta itse asiassa se on kopio aikaisemmasta LED-ohjaussuunnittelustamme, joka käyttää PWM: ää.

Tässä on harjoitusohjelmakoodi:

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

Kun olet ladannut tämän koodin, katso vain, kuinka potin säädöt luovat mielenkiintoisen valotehosteen RGB: lle, se voi olla todella hauskaa.

Tulet huomaamaan, että kun kaikkia 3 pottia siirretään maksimiasennoissa, näet valkoisen värin sijaan punaisen. Tämä johtuu siitä, että punainen väri on näkyvin kolmen värin joukossa ja hallitsee siksi tässä tilanteessa. Voit kuitenkin kokeilla toimintoa kartta() , ennen sen suorittamista LEDin punaiseen osaan järkevämmän tasapainon luomiseksi.

Ääni Arduinon kanssa

Tässä osassa opitaan, miten perusääni ja musiikki lisätään Arduino-kokoonpanoon.

Näemme, kuinka signaali vaihdetaan kytkettyyn kaiuttimeen halutulla taajuudella.

Tarkemmin sanottuna kokeillaan keskimmäistä A-nuottia, joka on 440 Hz: n taajuus.

Tätä varten soitamme yksinkertaisesti keskimmäisen A-nuotin ja optimoimme siniaaltosignaalin neliöaallolla.

Laskemme myös ajan, jonka kaiutin voi olla päällä, haastamalla kaavan:

timeDelay = 1 sekunti / 2 x toneFrequency.

timeDelay = 1 sekunti / 2 x 440

timeDelay = 1136 mikrosekuntia

4.1 Liitetään Arduino-kortti

4.2 Yksinkertaisen muistiinpanon lisääminen

Olemme jo keskustelleet toiminnosta viive() missä yksikkö on millisekunteina (sekunti / 1000), löydät kuitenkin vielä toisen toiminnon delayMicroseconds() missä yksikkö on mikrosekunnissa (millisekuntia / 1000).

Nykyistä asetusta varten ohjelmoimme koodin kytkemään + 5 V PÄÄLLE / POIS valitulle nastalle, joka on kytketty kaiuttimeen, nopeudella 440 pulssia sekunnissa.

Palautetaan mieleen, että viimeisessä keskustelussa määritimme suunnitellulle äänimuistille arvon 1136 mikrosekuntia.

Joten tässä on ohjelma tähän, jonka avulla voit kuulla 440 Hz: n äänimuistiinpanon heti, kun ohjelmoit arduinon kaiuttimella.

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

Yllä olevalla sovelluksella on mahdollista tehdä äänimuistiinpano, mikä tarkoittaa myös sitä, että voimme luoda musiikkia oman valintamme mukaan.

Koodista ymmärrämme, että Arduino sisältää pari integroitua toimintoa, jotka lisäksi myötävaikuttavat musiikin luomiseen.

Ensimmäinen on sävy() joka toimii 2 elementin kanssa kolmannen valinnaisen elementin kanssa, nimeltään sävy (tappi, taajuus, kesto). tai ääni (tappi, taajuus)

Molemmat on nimetty suorittamaan vastaava määräaika, jonka olet määrittänyt.

Määräajan puuttuessa musiikkia jatketaan soittoon asti sävy() suoritetaan uudelleen tai kunnes suoritat ei yksikään ().

Tämä on tehtävä viivetoiminnolla, jos musiikin toisto on ainoa perustavanlaatuinen asia, jonka olet toteuttamassa.

Ajan kesto voi olla ratkaiseva, koska se antaa ajan, kuinka kauan musiikkia toistetaan, joten voitko vapaasti tehdä muita asioita. Heti kun kesto päättyy, musiikki lakkaa.

Seuraava toiminto ei yksikään () käsittelee yhden parametrin ja pysäyttää valitun äänen tietyllä määritetyllä tapilla.

Erityinen varoitus: milloin tahansa milloin sävy() toiminto on otettu käyttöön, nastojen 3 ja 11 PWM-toiminto lakkaa toimimasta.

Siksi aina, kun kaiutinliitettä käytetään ohjelmassa, varmista, ettet käytä mainittua nastaa kaiuttimiin, vaan kokeile joitain muita nastoja kaiuttimen kiinnitykseen.

OK, joten tässä on ohjelma musiikin toteuttamiseksi kaiuttimessa, vaikka se ei ole oikea musiikki, vaan perusasteikon C-nuotti.

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

Yllä olevassa koodissa olet ehkä huomannut jotain uutta ja se on #määritellä .

Tämä termi toimii kuten haku ja korvaa -komento tietokoneelle kääntämisen aikana.

Aina kun se löytää ensimmäisen välilyönnin, se korvaa sen rivin jäljellä olevalla osalla (kutsutaan makroiksi).

Joten tässä esimerkissä, kun tietokone näkee HUOMAUTUS_E4 se korvaa sen nopeasti määrällä 330.

Lisää muistiinpanoja ja mukautuksia varten voit viitata USB-muistitikun tiedostoon sävelet. h , josta suurin osa taajuuksista löytyi mieltymyksesi mukaan.

4.4 Musiikki toiminnoilla

Yllä oleva koodi näyttää hyvältä, mutta näyttää siltä, ​​että siinä on paljon toistoja, näiden toistojen lyhentämiseen pitäisi olla jokin menetelmä, eikö?

Toistaiseksi olemme työskennelleet kahden keskeisen toiminnon kanssa, jotka sisältyvät Arduinoon. Nyt voi olla aika luoda omat toiminnot.

Jokaisen funktion on aloitettava muuttujan tyypillä, johon se voidaan liittää. Esimerkiksi toiminto mitätön viittaa tyyppiin, joka ei palauta mitään, joten nimi on mitätön. Huomaa, että olemme jo keskustelleet muuttujien luettelosta aiemmissa osioissamme, voit halutessasi viitata niihin.

Näin ollen tietty funktion nimi saa avoimen sulun '(' jota seuraa luettelo pilkuilla erotetuista parametreista.

Kukin parametri saa tyypin, nimen ja lopuksi sulkeutumisen ')' sulkeet.

Näitä parametreja voidaan käyttää funktion sisällä muuttujien muodossa.

Katsotaanpa alla oleva esimerkki, jossa kehitetään funktio nimeltä meidänTone () suunniteltu sulauttamaan sävy() kanssa viive() riviä siten, että toiminto palaa takaisin, kunnes nuotin toisto on päättynyt.

Toteutamme nämä toiminnot edellisessä koodissamme ja saamme alla olevan ohjelman, katso viimeiset rivit:

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

Toiminnot voivat olla erittäin käteviä helpottamaan ohjelman ymmärtämistä.

Seuraava on esimerkki, jossa voimme määrittää toistettavan äänen valinnan kahdella matriisilla. Yksi matriisi muistiinpanojen säilyttämiseksi, toinen tahdit.

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

Ensimmäisen rivin voit selvästi nähdä #sisältää lausunto. Tämän lausunnon tehtävänä on poimia koko tiedosto lainausmerkkien väliltä ja sijoittaa se #sisältää lausunto. Vakiosääntöjen mukaisesti nämä asetetaan tiukasti ohjelman alkuun.

Luku 5

Lämpötilan mittaaminen

Ainoastaan ​​muistaa, muista, että suurten ohjelmien kirjoittamisen sijaan on aina viisasta kirjoittaa ja analysoida pieniä osia koodeista, mikä auttaa havaitsemaan virheet nopeasti.

5.1 Sarjamonitori

Tähän asti keskustelemamme koodit eivät näytä olevan niin helppoja nopean vianmäärityksen mahdollistamiseksi. Tässä yritämme tehdä asioista helpompia seurattavaksi ja helpottaa mahdollisen ongelman ratkaisemista.

Arduinossa on ominaisuus, jonka avulla se voi 'puhua takaisin' tietokoneen kanssa. Saatat huomata, että nastat 0 ja nasta 1 on merkitty RX ja TX vierekkäin. Näitä nastoja seuraa itse asiassa erillinen IC Arduinossa, joka päivittää ne lukemaan USB-kaapelin kautta, kun se on kytketty tietokoneeseen.

Seuraavassa osiossa näkyy täysimittainen ohjelma, mene vaikka, opimme koodin uusista merkinnöistä sen jälkeen. Tämä koodi on sama kuin lauseke 2.2 lukuun ottamatta sitä tosiasiaa, että se sisältää joitain ylimääräisiä tietoja, jotta voimme tunnistaa, mihin se on koodattu.

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

Voit tunnistaa kaksi uutta asiaa, uuden rivin perustaa() toiminto.

Serial.begin(9600)

Tämä rivi yksinkertaisesti ilmaisee tarpeen käyttää Sarja1 koodia pakottaaksesi sen 9600 baudilla. (tässä sarjassa viitataan bittiä lähetetään yksi toisensa jälkeen, ja baud tarkoittaa nopeutta, jolla se lähetetään). Tämän baudiarvon ja sarjamonitorin sisäisen arvon (opimme tämän myöhemmin) on oltava yhtä suuria, muuten sarjamittarin tiedot näyttävät roskaa. 9600 vakiona on entistä kätevämpää käyttää.

Toinen uusi kohta on seuraava

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

Tässä toinen rivi ehdottaa, että seuraava sarjaportista tuleva asia alkaa seuraavalla rivillä. Siten toinen rivi eroaa nyrkkilinjasta.

Vielä yksi asia, jonka näet, ovat lainausmerkit ('). Tätä kutsutaan merkkijonoksi, jota käytetään tässä vain vakioiden tavoin, koska jatkuva keskustelu tästä aiheesta voi olla liian monimutkainen ja laajuuden ulkopuolella.

OK, voimme nyt ladata yllä olevan koodin Arduinoon ja nähdä, mitä tapahtuu.

Mitä, valitettavasti mitään ei näytä tapahtuneen, Arduino-nastan nro 13 LED vilkkuu ja pysähtyi, kun taas Tx-LED pysyi vilkkumassa.

No, koska Serial Monitor -ikkuna ei ole vielä korjattu.

Sinun on napsautettava IDE: n Serial Monitor -ruutua yllä esitetyllä tavalla. Älä unohda tarkistaa oikeassa alakulmassa olevaa siirtonopeutta, oletuksena sen on oltava 9600, ja se vastaa koodia. Jos se ei ole, valitse 9600.

Seuraava videoleike selittää, miten se tehdään.

Siirrytään nyt eteenpäin ja opitaan, kuinka yllä oleva Serial Monitor -ominaisuus voi auttaa käsittelemään lämpötilan mittaus Arduinolla

Käytämme IC TMP36: ta lämpötila-anturina, jonka alue on -40-150 astetta.

Asennus näkyy alla:

Seuraava koodi aloittaa lämpötilan mittauksen lukemalla TMP36-anturin ulostulon ja lähettämällä ne ID-sarjavalvontaan.

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
}

Ymmärretään koodi ylhäältä.

float temperatureC = getTemperatureC()

Täältä näet, että olemme sisällyttäneet muuttujatyypin kellua.

Tämä on ainoa muuttujatyyppi, joka tallentaa kaiken paitsi kokonaisluvut (luvut ilman desimaali- tai murto-osia).

Kelluvamuuttujan tarkkuus voi olla korkeintaan 6–7 numeroa.

Viereinen koodi getTemperatureC() on oma toimintomme, joka laskee matemaattisesti ja muuntaa havaitun jännite-eron TMP36-anturista celsiusasteiksi.

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
}

Koodien seuraavassa osiossa termi analogIn() on määritetty palauttamaan luku välillä 1-1023, on mahdollista, että voimme arvioida anturin jännitteen kertomalla lukemamme 5: llä ja jakamalla sen sitten 1024: llä.

Anturin TMP36 on määritelty tuottavan 0,5 V 0 ° C: n lämpötilassa ja sen jälkeen 10 mV jokaiselle yksittäiselle celsiusasteen nousulle.

Tässä on arvio, jonka voimme tuottaa laskelmien avulla:

Voit pitää ensimmäisenä funktiona, joka palauttaa jonkin verran arvoa (huomaa, että kaikki jäljellä olevat toiminnot eivät ole palauttaneet arvoa, koska ne ovat olleet tyyppiä mitätön ).

Voit ymmärtää, että saadaksesi arvon funktiosta, sinun tarvitsee vain lisätä palata ja sen jälkeen haluamasi numero, jonka haluat palauttaa.

Kun sanomme palata se tarkoittaa, että funktio palauttaa vastauksen tai vastauksen aina, kun sitä kutsutaan, jota voidaan soveltaa muuttujaan.

Kun tämä lähetetään Serial Monitoriin, lukema muunnetaan Fahrenheitiksi läpi convertToF ().

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

Tämä toiminto nostaa Celsius-alueen ja muuntaa sen Fahrenheitiksi.

Fahrenheitin muuntamiseksi Celsiukseksi toteutamme kaavan Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Nestekidenäytön liittäminen yhteen

Tutkitaan nyt kuinka liittää tai yhdistää LCD-näyttö Arduinon kanssa visuaalisen näytön saamiseksi vaadituille lähtöille.

Sovelluksessamme aiomme käyttää 84x48 -kokoista graafista LCD-näyttöä, jolla on 84 pikseliä tai pisteitä vaakasuunnassa ja 48 pikselin pystysuuntaista resoluutiota. Koska omistettu ohjain on välttämätön kaikille LCD-näytöille, nykyinen laite sisältää myös sen PCD8544-ohjaimen muodossa.

Tässä opetusohjelmassa yhdistämme yllä mainitun LCD-moduulin Arduinoon ja sovellamme tiettyjä rutiineja tekstiviestien luomiseen näytölle.

Seuraavasta kuvasta löydät yksityiskohtia nestekidenäytön liitännöistä sekä pienen 3,3 V: n jännitesäädin . Tämä säädin on välttämätön, koska nestekidenäyttö on määritelty toimimaan 3,3 V: n virtalähteen kanssa.

Näet myös 8 pinoutia LCD-moduulista, pinout-määritykset voidaan tutkia seuraavasta taulukosta:

Katsotaan nyt, kuinka voimme liittää nestekidenäytön ja tarvittavat parametrit Arduinoon. Yksityiskohdat voidaan visualisoida alla olevassa kuvassa:

5.4 Viestintä nestekidenäytölle

Vaikka Arduinolta on mahdollista kirjoittaa monimutkaisia ​​yhteistoimintoja LCD-näytön kanssa, opimme mieluummin tekemään saman kirjastojen avulla.

Kirjastot sisältävät valikoiman koodeja, joita voidaan käyttää nopeasti valittuun Arduino-ohjelmaan.

Tämän avulla käyttäjä voi soittaa toimintoon vaivattomasti tarvitsematta käydä läpi monimutkaista koodausta.

5.4.1 Kuinka kirjasto asennetaan

Tätä varten sinun on luotava hakemisto nimeltä kirjastot tietokoneellesi Arduino IDE, kuten selitettiin tässä

5.4.2 LCD-toimintojen toteuttaminen

Aivan kuten edellisessä lähestymistavassa, tarkistamme ensin koko koodin ja yritämme sitten ymmärtää yksittäisten rivien yksityiskohdat.

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

Rivi sisältää koodin #include

Koodi #include kehottaa tietokonetta noutamaan mainitun tiedoston ja korvaamaan #include -elementin tiedoston sisällöllä ohjelman kokoamisen aikana.

Elementillä #include voi olla kulmasulkeet, jotka ilmaisevat hakemisen kirjastohakemistosta, tai vaihtoehtoisesti siinä voi olla lainausmerkit, jotka osoittavat etsinnän samasta hakemistosta, jossa ohjelma sijaitsee.

Seuraavat koodirivit ilmaisevat LCD-pinoutit, ja sitten kirjoitamme uuden muodon muuttujan:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Tässä ilmaistaan ​​muuttuja nimellä lcd, jonka tyyppi on PCD8544, ja käskemme PC: tä luokittelemaan Arduinoon liittyvät pinoutit.

Tässä prosessissa kuvataan muuttuja PC: lle käskemällä, kuinka pin clk, din, dc ja reset ovat yhteydessä Arduinoon.

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

Rivi lcd.init() alustaa nestekidenäytön toiminnan. Kun tämä on suoritettu, seuraava rivi pakottaa kohdistimen näytön vasempaan yläkulmaan. Ja seuraava seuraava rivi pyrkii tulostamaan viestin 'Hei, maailma'.

Tämä näyttää melko identtiseltä tekniikalta, jolla lähetimme viestejä sarjavalvojan kautta. Ainoa ero on koodin lcd.print käyttö serial.print sijasta.

Seuraava koodilohko kutsutaan itse asiassa toistuvasti.

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

Tämän rivin käyttäminen lcd.setCursor(0,1) kiinnitämme kohdistimen 1. rivin vasemmassa reunassa olevaan 0. sarakkeeseen nestekidenäytön yli.

Seuraava rivi käyttää pikakuvaketta: lcd.print(millis())

Jos muistat, että olemme tehneet yhteistyötä millis() aikaisemmissa koodeissamme olisimme voineet soveltaa samaa tässäkin koodien kautta:

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

Koska tässä ei kuitenkaan ole kyse millisekuntien ajanjaksoista, saavutamme sen yksinkertaisesti lähettämällä millis() toimii suoraan lcd.print() .

5.5 Koko asian yhdistäminen

OK, nyt yhdistetään kaikki yllä oppimamme koodit LCD-lämpötilapiirin tekemiseksi, ja katsotaanpa, miltä se näyttää:

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

Kaikki näyttää yllä olevan ohjelman vakiona, paitsi toiminnon käyttö setCursor () . Tätä käytetään tekstin kohdistamiseen niin pitkälle kuin mahdollista näytön keskikohdan ympärille.

Loistava! Ja onnittelut, olet juuri ohjelmoinut oman pienen LCD-lämpötilanilmaisimen Arduinolla.

Käytännölliset Arduino-sovellukset

Koska tässä vaiheessa olemme käsittäneet kattavasti eri ohjelmointitekniikat yksityiskohtaisesti, on aika selvittää ne soveltamalla niitä muutamaan hyödylliseen käytännön toteutukseen.

Aloitamme antureista ja katsomme, kuinka anturilaitteita voitaisiin käyttää Arduinon kanssa suorittamalla muutama esimerkkikoodi.

7.1 Johdanto antureihin

Tässä opetusohjelmassa opitaan monenlaisista antureista, joita voidaan käyttää Arduinon kanssa. Näitä voivat olla laitteet, kuten valotunnistin LDR, magneettinen saliefektianturi, kallistustunnistimet, tärinäanturi, paineanturi jne.

Aloitamme valotunnistin LDR Arduinon kanssa, kuten kuvassa i, seuraava kaavio:

Kuten me kaikki tiedämme, LDR on valosta riippuvainen vastuslaite, jonka vastus riippuu sen pinnalla tapahtuvan ympäristön voimakkuudesta.

Valon voimakkuus on kääntäen verrannollinen LDR: n resistanssilukemaan.

Täältä opit, kuinka tämä ominaisuus voidaan integroida Arduinoon hyödyllisen sovelluksen suorittamiseksi:

Koko ohjelmakoodi voidaan visualisoida seuraavasti:

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

Kaikki koodissa käytetyt parametrit on jo käsitelty kurssillamme, jonka olemme oppineet tähän mennessä. Voit tarkistaa rivit viittaamalla asiaankuuluviin osiin.

Arvot valittiin satunnaisesti, voit helposti muuttaa omien mieltymystesi mukaan.

Kallistusanturi

Kallistustunnistin on yksinkertainen laite, jota voidaan käyttää kallistustoiminnan havaitsemiseen missä tahansa esineessä, johon se on asennettu. Laitteen sisällä on pohjimmiltaan metallipallo, joka kallistuessa rullautuu kosketusparin yli aiheuttaen johtavuuden näiden koskettimien yli. Näitä koskettimia, jotka päätetään kallistuskytkimen johtimina, käytetään ulkoisen piirin kanssa kallistustoiminnasta johtuvan johtamisen havaitsemiseksi ja halutun ulostulosovelluksen aktivoimiseksi.

Katsotaan nyt miten kallistusanturi laite voidaan kytkeä. Alla oleva kuva antaa meille käsityksen koko kokoonpanosta:

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

Tässä esimerkissä oletusnastan # 13 LEDiä käytetään kallistuksen ilmaisimena.

Voit selvästi nähdä vetovastuksen sisällyttämisen tähän, melko samanlainen kuin teimme kohdassa 3.1. Siksi termi LOW osoittaa, että kallistustoimintoa ei käynnistetä.

7.4 Reed-kytkimen rele (pienoismagneettiaktivoitu rele)

Katsotaan nyt, kuinka kytkeä relekytkin tai magneettikenttäanturi Arduinoon. Ruokorele on eräänlainen kytkin, joka aktivoituu tai johtaa, kun magneettikenttä tai magneetti tuodaan sen lähelle. Pohjimmiltaan siinä on pari ferromagneettista kosketinta pienoiskoossa olevan lasikotelon sisällä, jotka yhdistyvät tai joutuvat kosketuksiin magneettisen vetämisen takia aina, kun magneetti on sen välittömässä läheisyydessä. Kun näin tapahtuu, koskettimien liittimet osoittavat johtavuutta koskettimien sulkemisen vuoksi.

Tässäkin käytämme tapin # 13 LED: ää vastauksen osoittamiseen. Voit liittää ulkoisen LEDin tästä nastasta tarvittaessa aikaisempien selitysten mukaisesti.

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

Kooditermien tulisi olla tuttuja ja itsestään selviä.

7.5 Tärinäanturi Piezo-kaikuanturilla

Seuraavassa esimerkkiohjelmassa näemme, miten a pietsoanturi voidaan käyttää värähtelyanturina LEDin valaisemiseen Arduinon kautta.

Pietsosielementti on itse asiassa laite, joka tuottaa värähtelyä tai värähtelyä, kun taajuus kohdistetaan sen liittimiin. Samaa pietsoa voitaisiin kuitenkin käyttää käänteisessä prosessissa tuottaa sähköisiä pulsseja vastauksena kehoon kohdistettuun tärinään. Tämä tärinä voi olla koputuksen tai osuman muodossa pietson pinnalle.

Asenna Arduino ja pietsoelementti seuraavan kuvan mukaisesti

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

Kynnysarvo 100 otetaan käyttöön vain sen varmistamiseksi, että Arduino reagoi vain aitoon tärinään kolhun kautta eikä muihin pienempiin tärinöihin, kuten koviin ääniin tai sarviin.

A5-nastan valinta ei ole pakollista, voit valita minkä tahansa muun analogitulon mieltymystesi mukaan ja sovittamalla sen ohjelmakoodiin.

Servomoottorin käyttö Arduinon kanssa

Servomoottori on eräänlainen tasavirtamoottori, jota voidaan pyörittää tarkkoihin kulmiin tietyn sovelluksen tarpeen mukaan. Se voidaan tehdä soveltamalla laskettua komentoa moottorin asiaankuuluviin tuloihin tarkan pyörimis- tai kääntökulman tuottamiseksi moottorin 180 asteen alueella.

Tyypillisesti servomoottorissa on 3 johtoa tai tuloa. Positiiviset johdot ovat normaalisti punaisia, negatiiviset tai maadoitusjohdot ovat mustia, mikä komento- tai merkinantojohto on normaalisti valkoista tai keltaista.

Arduino helpottaa servomoottorin ohjausta sisäänrakennetun tukikielen avulla, mikä tekee ohjaamisesta erittäin kätevää ja ihanteellista servomoottoreille.

Seuraava esimerkki näyttää meille perusasennusohjelman servomoottorin ohjauksen toteuttamiseksi Arduinon kautta:

Koodi on annettu alla:

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

Näemme pari uutta merkintää täältä. Yksi, joka kertoo kiinnitetyn servojohdon mihin piniin se on osoitettu. Toinen on koodi, joka antaa nastalle arvon välillä 0 - 180, kiertokulman määrittämiseksi servolla.

Johtopäätös

Arduino-aihe voi olla äärettömän pitkä ja siten tämän artikkelin laajuuden ulkopuolella. Toivon kuitenkin, että yllä olevan opetusohjelman olisi pitänyt varmasti auttaa sinua oppimaan Arduinon perusteet ja ymmärtämään tärkeät parametrit eri esimerkkisovelluskoodien avulla.

Toivottavasti lisää tietoa saatetaan päivittää ajoittain täältä, aina kun se on saatavilla.

Sillä välin nauti ohjelmointikurssistasi, Hyvää Arduinoingia sinulle !!