Pag-aaral ng Pangunahing Programming ng Arduino - Tutorial para sa Mga Bago

Sa tutorial na ito natututunan namin kung paano gawin ang pangunahing programa ng Arduino sa pamamagitan ng mga halimbawang code at sample na programa. Ang tutorial na ito ay maaaring maging isang napakahalagang kurso para sa lahat ng mga bagong dating na nais na maunawaan ang mga pangunahing kaalaman sa pamamagitan ng madali, naiintindihan na wika.

Panimula

Ayon kay wikipedia ang isang microcontroller ay katumbas ng isang mini computer na built sa loob ng isang solong IC chip, pagkakaroon ng sarili nitong core processor, programmable input, memory at output peripherals.

Ang isang microcontroller ay naging kapaki-pakinabang para sa isang gumagamit dahil nag-aalok ito ng built-in na processor, memory at input / output port (tinatawag ding GPIO o mga pin na pangkalahatang input / output) na maaari naming makontrol ng gumagamit ayon sa anumang nais na mga pagtutukoy.

Sa tutorial na ito ay gagana kami sa isang Arduino Uno board para sa pag-aaral at pagsubok ng mga programa. Para sa pagsubok at pagsasama ng pagpupulong ng hardware gagamitin namin ang isang breadboard.

Ngayon lumipat tayo nang mabilis at alamin kung paano makapagsimula sa isang programa ng Arduino.

1.2 Pag-install ng Software (Windows)

Para sa mga ito kailangan mo ng pag-access sa internet, na malinaw naman na magkakaroon ka sa iyong computer. Mangyaring pumunta sa sumusunod na link at i-download ang software ng IDE:

Windows ZIP file para sa pag-install na hindi admin

Matapos ang pag-download ay makikita mo ang icon ng pag-setup ng Arduino sa folder ng pag-download, na magiging ganito:

Sa sandaling makuha mo ito, maaari mo lamang i-double click dito at mai-install ang Arduino the Integrated Development Environment (IDE) sa iyong computer. Ang kumpletong proseso ay maaaring mailarawan sa sumusunod na video:

1.4 Simula sa aming First Circuit

Bago namin simulang alamin ang aktwal na mga diskarte sa pagprograma, para sa anumang newbie magiging kapaki-pakinabang upang magsimula sa isang pangunahing sangkap tulad ng isang LED, at maunawaan kung paano ito ikonekta sa isang Arduino.

Tulad ng alam natin ang isang LED ay isang light emitting diode na may polarity at hindi magpapailaw kung hindi ito konektado sa tamang mga poste ng supply.

Ang isa pang aspeto sa mga LED ay ang mga aparatong ito na gumagana nang may mababang kasalukuyang at maaaring mapinsala kaagad kung ang isang naaangkop na kinakalkula na risistor ay hindi kasama sa serye na may isa sa mga pin nito.

Bilang patakaran ng hinlalaki, ang isang 330 ohm 1/4 watt ay lubos na perpekto para sa bawat pagtaas ng 5V sa input ng supply upang limitahan ang kasalukuyang sa isang kinakailangang ligtas na antas. Samakatuwid para sa 5V maaaring ito ay 330 ohms, para sa 10V maaaring ito ay 680 ohms at iba pa.

Paggamit ng Breadboard para sa Assembly

Mangyaring tiyaking alam mo kung paano gamitin ang a breadboard bago subukan ang paliwanag na ipinaliwanag sa kabanatang ito, dahil gagamit kami ng isang breadboard para sa lahat ng mga eksperimento dito.

Ang pangunahing pag-setup ng koneksyon ng LED ay maaaring masaksihan sa ibaba:

Maaari mong makita ang 3 pangunahing mga bahagi sa itaas:

1. Isang 5mm, 20mA LED
2. isang 330 ohm 1/4 watt risistor
3. Isang Lupon ng Arduino

Ipunin lamang ang system ayon sa diagram.

Susunod, isaksak ang 5V mula sa computer USB papunta sa Arduino. Sa sandaling gawin mo ito makikita mo ang pag-iilaw ng LED.

Alam kong medyo basic iyon, ngunit palaging mahusay na magsimula mula sa simula. Makatitiyak na ang mga bagay ay magsisimulang makakuha ng higit pa at mas kawili-wili habang sumusulong tayo.

1.5 Pagkontrol sa LED na may Arduino

Ngayon matututunan namin kung paano makontrol ang isang LED na may isang Arduino na programa.

Upang magsulat ng isang programa kailangan nating magkaroon ng hindi bababa sa 2 mga pagpapaandar sa bawat programa.

Ang isang pagpapaandar ay maaaring maunawaan bilang isang serye ng mga pahayag sa programa na maaaring italaga sa isang pangalan, tulad ng ibinigay sa ibaba:

1. setup () ito ay tinatawag o naisakatuparan sa pagsisimula ng programa.
2. loop () ito ay tinatawag o paulit-ulit na ginagawa sa buong panahon ng pagpapatakbo ng Arduino.

Samakatuwid, kahit na wala itong praktikal na pag-andar, sa teknikal ang isang pinakamaikling lehitimong programa ng Arduino ay maaaring maisulat bilang:

Pinakasimpleng Program

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

Maaaring napansin mo na sa marami sa mga wika ng programa, nagsisimula ang system sa pamamagitan ng pagpapakita ng isang simpleng print, 'Hello, World' sa display screen

Ang katumbas na elektronikong para sa pariralang ito sa pagbibigay kahulugan ng microcontroller ay upang magpikit ng isang LED ON at OFF.

Ito ang pinaka pangunahing programa na maaaring isulat at ipatupad ng isa upang ipahiwatig ang isang wastong paggana ng system.

Susubukan naming ipatupad at maunawaan ang pamamaraan sa pamamagitan ng sumusunod na piraso ng code:

Listahan 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, maintindihan natin ngayon kung ano ang ibig sabihin ng bawat linya ng code at kung paano ito gumagana upang maisagawa ang pagpapaandar:

const int kPinLed = 13

Gumagana ito tulad ng isang pare-pareho na nagbibigay-daan sa amin upang magamit ito sa panahon ng kumpletong kurso sa programa, nang hindi kinakailangan ng paggamit ng aktwal na halaga na itinakda laban dito.

Alinsunod sa mga pamantayang patakaran tulad ng mga pare-pareho ay kinikilala sa panimulang liham sa . Bagaman hindi ito sapilitan, ginagawang mas malinaw at madaling maunawaan ang mga bagay sa tuwing nais mong dumaan sa mga detalye ng code.

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

Ang code na ito ay nag-configure ng tukoy na pin kung saan naka-hook ang aming LED. Sa madaling salita, sinabi ng code sa Arduino na kontrolin ang aspeto ng 'pagsulat' sa pin na ito, sa halip na 'basahin' ito.

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

Ang mga linya sa itaas ay nagpapahiwatig ng aktwal na pagpapatupad ng application. Ang code ay nagsisimula sa pamamagitan ng pagsulat at pag-render ng isang TAAS sa kaugnay na koneksyon ng LED, na ON ang LED.

Dito, ang term na TAAS ay nangangahulugang pagkuha ng + 5V sa nag-aalala na pin ng Arduino. Ang pantulong na term na LOW ay nagpapahiwatig lamang ng isang zero o 0V sa itinalagang pin.

Susunod, tumatawag kami delay() na ang pagpapaandar ay upang lumikha ng isang pagkaantala sa pamamagitan ng milliseconds (1 / 1000th ng isang segundo). Dahil ang pigura 500 ay ipinasok, ang pagkaantala na ipinatupad ay magiging para sa isang 1/2 segundo.

Sa sandaling natapos ang 1/2 segundo na ito, ang susunod na linya ay naisakatuparan na lumiliko sa LED OFF na may MABABANG termino sa parehong pin.

Ang kasunod na linya ay muling bumubuo ng 1/2 segundong pagkaantala, upang payagan ang LED na manatiling OFF sa loob ng 1/2 segundo.

At ang proseso ay nagpapatuloy nang walang hanggan sa pamamagitan ng pagpapatupad ng mga linya ng code, basta ang Arduino ay pinananatiling pinalakas.

Bago magpatuloy sa susunod na antas, inirerekumenda ko sa iyo na mangyaring programa ang code sa itaas at suriin kung maaari mong ipatupad nang tama ang LED ON / OF na pagkakasunud-sunod o hindi.

Dahil ang default na LED sa Arduino ay konektado sa pin # 13, dapat itong agad na tumugon sa programa sa itaas at simulang flashing. Gayunpaman, kung nakita mo ang iyong panlabas na LED na hindi kumikislap pagkatapos ay maaaring may isang pagkakamali sa koneksyon sa iyong LED, maaari mong subukang baligtarin ang polarity ng iyong LED at sana makita mong kumikislap din ito.

Maaari mong i-play ang oras ng pagkaantala sa pamamagitan ng pagbabago ng '500' na numero sa ilang ibang halaga at hanapin ang LED na 'pakikinig' sa mga utos at sanhi ito upang mag-flash ayon sa tinukoy na mga halaga ng pagkaantala.

Ngunit tandaan, kung nakikita mo ang LED na hindi kumikislap na may pare-pareho na 1 segundo na rate, anuman ang iyong pag-aayos ng oras ng pagkaantala, maaaring ipahiwatig na ang code ay hindi gumagana dahil sa ilang pagkakamali. Dahil sa pamamagitan ng default ang Arduino ay mai-program na may isang 1 segundo na flashing rate. Samakatuwid ang rate na ito ay dapat na magkakaiba-iba sa pamamagitan ng iyong code para sa pagkumpirma ng wastong pagtatrabaho.

1.7 Mga Komento

Ang mga linya ng mga code na naintindihan namin sa itaas ay partikular na nakasulat para sa software ng computer.

Gayunpaman, upang matiyak na ang gumagamit ay maaaring mag-refer sa kahulugan ng mga linya at maunawaan ang mga ito, madalas na maaaring maging kapaki-pakinabang at matino upang isulat ang paliwanag sa tabi ng nais na mga linya ng mga code.

Ang mga ito ay tinawag mga komento na nakasulat para sa sangguniang pantao o gumagamit lamang, at naka-code upang paganahin ang mga computer na ito nang ligtas.

Ang wika ng mga komentong ito ay nakasulat sa isang pares ng mga format:

1. Ang istilo ng block ng komento, kung saan ang paglalarawan ng komento ay nakapaloob sa ilalim ng simulang simbolo / * at simbolo ng pagtatapos * /
2. Hindi nito kailangang paghigpitan sa isang linya sa halip ay maaaring mapalawak sa susunod na mga kasunod na linya depende sa haba ng komento o paglalarawan, tulad ng ipinakita sa sumusunod na halimbawa:

/ * Ito ay isang komento * /

/ * Ganoon din ito * /

/ * At
* ito
* bilang
* well * /

Para sa pagsusulat ng mabilis na solong paglalarawan ng linya para sa isang komento, ang dalawang simbolo ng slash // sa simula ay nagiging sapat. Sinasabi nito sa computer na ang linya na ito ay walang kinalaman sa aktwal na code, at dapat itong balewalain. Halimbawa:

// Ito ay isang komento kung aling mga computer ang hindi papansinin.

Narito ang isang halimbawa para sa sanggunian:

/*
* 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 Pag-troubleshoot

Kung nakita mo ang iyong programa na nagpapakita ng isang 'error' habang nag-iipon, o ilang iba pang isyu, ang mga sumusunod na tip ay maaaring makatulong sa iyo na muling suriin ang iyong code na mapupuksa ang sagabal.

1. Magiging sensitibo sa kaso ang wika ng iyong programa. Halimbawa ang ekspresyon myVar hindi maisusulat bilang MyVar.
2. Lahat ng mga uri ng puting puwang na maaaring maipatupad ng iyong pagta-type sa keyboard, sa huli ay nai-render bilang isang solong puwang, at nakikita mo o naiintindihan mo lamang, hindi ito isasaalang-alang ng computer. Nang simple, ang mga libreng puwang ng anumang uri ay hindi magkakaroon ng anumang epekto sa mga resulta ng code.
3. Ang bawat bloke ng code ay dapat na nakapaloob sa kaliwa at kanang mga kulot na bracket, '{' at '}'
4. Ang mga numero ng numero ay hindi dapat paghiwalayin ng mga kuwit. Halimbawa, ang 1000 ay maaaring hindi maisulat bilang 1,000.
5. Ang bawat linya ng code na nakapaloob sa pagitan ng mga kulot na bracket ay dapat tapusin sa isang kalahating titik

Lumilikha ng Kagiliw-giliw na LED Light Sequence kasama ang Arduino

Sa aming nakaraang kabanata natutunan namin kung paano magpikit ng isang LED ON / OFF na patuloy na may isang pare-pareho na rate ng pagkaantala.

Ngayon matututunan natin kung paano maaaring isagawa ang iba't ibang mga pattern ng pagkaantala sa parehong LED sa pamamagitan ng pag-upgrade ng code ng programa.

Hindi kami gagamit ng isang panlabas na LED, sa halip ay gagamitin ang default na LED na naka-built sa Arduino board sa pin # 13. Mahahanap mo ang maliit na SMD LED na nasa likuran lamang ng konektor ng USB.

2.2 Pag-unawa sa Mga Pahayag ng KUNG

Sa seksyong ito matututunan natin kung paano tayo pinapagana ng mga istruktura ng kontrol upang magpatakbo ng mga indibidwal na code, at kung minsan kahit paulit-ulit, kung kinakailangan.

Ang pahayag kung nagiging unang istraktura ng kontrol. Ipinapakita ng sumusunod na pagpapatupad kung paano ito ginagamit:

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

Susubukan naming maunawaan ang nasa itaas ng code sa hakbang-hakbang at alamin kung paano ito magagamit para sa iba pang mga katulad na pagpapatupad.

Ang mga code sa pagitan ng ika-1 at ika-7 na linya ay eksaktong kapareho ng aming paunang programa.

Ang unang pagbabago ay talagang nangyayari sa ika-8 linya.

int delayTime = 1000

Mahahanap mo ito upang maging katulad ng code sa unang linya, na humahadlang sa katotohanan na nawawala ang termino Const.

Ito ay dahil lamang sa, ang code na ito ay hindi isang pare-pareho. Sa halip ito ay tinukoy bilang isang variable , na mayroong pag-aari ng isang variable na halaga sa kurso ng programa.

Sa halimbawa sa itaas maaari mong makita na ang variable na ito ay maiugnay sa isang halagang 1000. Tandaan, ang mga naturang variable na nakapaloob sa loob ng mga kulot na bracket ay dapat na mahigpit na nakasulat sa loob ng mga pares ng mga kulot na bracket lamang, at tinutukoy bilang 'lokal' na mga variable.

Bilang kahalili, ang mga variable na dapat ay nasa labas ng mga kulot na braket, tulad ng tinatalakay natin ngayon ay kinikilala bilang 'pandaigdigan', at maaaring maipatupad kahit saan man sa loob ng isang code ng programa.

Sa pagsulong, makikita mo na ang mga code sa pagitan ng linya 9 at 11 ay katulad din sa unang programa, gayunpaman ang mga bagay ay nagsisimulang maging kawili-wili pagkatapos ng linya 11. Tingnan natin kung paano!

delayTime = delayTime - 100

Sa code na ito nakikita natin na ang default na halaga ng antala ng Oras ay binago sa pamamagitan ng pagbawas ng 100 mula rito.

Ang ibig sabihin ng 100 ay binabawas mula sa paunang halagang 1000, na nagbibigay dito ng isang bagong halagang 900.

Sa pamamagitan ng sumusunod na imahe susubukan naming maunawaan ang ilan sa mga operator ng Math na ginamit sa wikang Arduino.

Suriin natin ngayon ang mga code sa pagitan ng linya 13 hanggang 15.

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

Ang pangunahing layunin ng piraso ng code sa itaas ay upang matiyak na ang LED ay patuloy na kumikislap nang walang anumang pagkakagambala.

Dahil sa ang katunayan na ang 100 ay binabawas mula sa orihinal antala ng Oras , pinipigilan nito ang LED na kumikislap mula sa pag-abot sa zero at pinapayagan ang blinking na magpatuloy.

Ipinapakita ng sumusunod na imahe ang ilang mga operator ng paghahambing na gagamitin namin sa aming mga code:

Sa aming code sa itaas, maaari naming masubukan ang code na maging if(delayTime == 0).

Gayunpaman, dahil ang pagiging negatibo ng tayahin ay maaaring pantay na masama, hindi namin ito pinuntahan, at ito ay isang inirekumendang kasanayan.

Isipin kung ano ang maaaring maging kinalabasan kung susubukan naming ibawas ang 300 sa halip na 100 mula sa delayTime?

Kaya ngayon maaari mong napagtanto na kung ang delayTime ay nakasulat bilang mas mababa o katumbas ng zero, kung gayon ang oras ng pagkaantala ay maitatakda pabalik sa orihinal na numero 1000.

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

Ang huling 4 na linya ng code tulad ng ipinapakita sa itaas ay naging responsable para sa pagpapatuloy ng LED ON / OFF, ON / OFF na patuloy.

Dito maaari mong malinaw na mapansin na sa halip na gumamit ng isang bilang, gumamit kami ng isang variable para sa pagtatalaga ng oras ng pagkaantala upang maiayos namin ito ayon sa nais namin sa panahon ng pagpapatakbo ng code. Astig yan diba

2.3 Iba Pang Mga Pahayag

Malalaman dito kung bakit at paano ang an kung term ay maaaring magkaroon ng isang sugnay iba pa upang mapagpasyahan nito ang sitwasyon kung sakali kung ang pahayag ay hindi totoo.

Humihingi ako ng paumanhin kung masyadong nakakalito iyon, huwag mag-alala, susubukan naming maunawaan ito sa sumusunod na halimbawa:

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

Sa itaas makikita mo rin na sa ika-10 linya ng code ay naisakatuparan lamang kapag ang delayTime ay mas mababa o katumbas ng 100, kung hindi pagkatapos ang code sa ika-13 linya ay naisakatuparan, ngunit pareho ang magkasama ay hindi maaaring mangyari, alinman sa ika-10 linya o ang ika-13 na linya ng code ay ipatupad, hindi kailanman pareho.

Maaaring napansin mo na hindi katulad ng ginawa namin sa aming nakaraang seksyon 2.2, narito hindi kami naghahambing sa 0, sa halip ay inihambing sa 100. Ito ay sapagkat sa halimbawang ito kumpara BAGO kami nagbawas ng 100, kontrabida sa seksyon 2.2, inihambing namin MATAPOS namin binawas Maaari mo bang sabihin kung ano ang maaaring nangyari kung ihambing namin ang 0 sa halip na 100?

2.4 HABANG pahayag

SA habang pahayag ay medyo katulad sa kung pahayag, maliban sa katotohanan na sanhi ito ng paulit-ulit na pagpapatupad sa isang bloke ng code (na maaaring nasa pagitan ng mga kulot na bracket) sa sobrang haba ng mga kondisyon na nalalapat, at gumagana ito nang walang iba pa pahayag.

Ang sumusunod na halimbawa ay makakatulong sa iyo upang higit na maunawaan ito

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

Mahulaan mo ba kung ano ang na-program sa itaas na code na dapat gawin? Kaya, ito ay dinisenyo upang kumurap ng mas mabilis ang LED at pagkatapos ay mas mabagal.

2.5 Ano ang totoo at hindi totoo?

Sa programa ng wika, hindi totoo tumutukoy sa zero (0). Tunay na 'totoo' ay hindi ginagamit, sa halip ay ipinapalagay na kapag walang mali, kung gayon lahat ng isinama ay totoo.

Mukha itong kakaiba subalit ginagawa nito nang maayos ang trabaho.

Susubukan naming maunawaan ang sitwasyon sa pamamagitan ng sumusunod na halimbawa.

Maaari kang makakita ng minsan sa isang code tulad ng ibinigay sa ibaba:

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

Ito ay naka-code na mukhang ang pagpapatupad ng LED ay panatilihin ang pagbibisikleta magpakailanman, hangga't magagamit ang haba ng kuryente.

Gayunpaman, maaaring lumitaw ang isang kabiguan ng ganitong uri ng code kapag hindi sinasadya na naglapat ang gumagamit ng isang = sa halip na ==.

Sigurado akong alam mo na = nangangahulugan ng isang takdang-aralin, nangangahulugang ginagamit ito upang italaga ang isang napiling halaga sa isang variable, habang ang isang == ay ginagamit para sa pagpapatupad ng isang pagsubok kung ang halaga ay pareho.

Halimbawa halimbawang kinakailangan mo ng isang LED upang mag-flash na may sunud-sunod na pagmamaneho ng pattern at paulit-ulit, ngunit maling ginamit ang isang = sa halip na ==.

Ang code ay lilitaw sa ganito:

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
}

Ang pagkakamali ay magtatalaga ng 0 sa delayTime, at hahantong sa kung pahayag upang suriin kung ang 0 ay totoo o hindi. Dahil ang 0 ay tumutukoy sa hindi totoo, iisipin nitong hindi ito totoo, at ititigil ang pagpapatupad ng delayTime = 1000, ngunit sa halip ang pagpapaandar delayTime ay gaganapin sa 0 sa panahon ng kurso ng loop ().

Mukhang napaka-hindi kanais-nais !!

Kaya, laging suriin ang iyong programa upang matiyak na hindi ka nakagawa ng anumang mga nakakalokong pagkakamali.

2.6 Mga Kumbinasyon

Minsan maaari mong maramdaman ang pangangailangan ng pagsubok ng maraming bagay nang magkasama. Tulad ng, maaari mong suriin kung ang isang variable ay nasa pagitan ng dalawang numero. Habang maaaring maipatupad ito gamit ang kung pahayag na maraming beses, maaaring mas madaling gamitin ang mga lohikal na kumbinasyon para sa mas mahusay at madaling pagbasa.

Ang pagpapatupad ng mga kumbinasyon sa mga lohikal na termino ay maaaring gawin sa 3 mga pamamaraan, tulad ng ipinakita sa sumusunod na talahanayan:

Nakatutuwang malaman na ang HINDI operator ay maaaring gumana bilang isang switch para sa isang variable na maaaring itinalaga upang maging alinman totoo o hindi totoo (o mababa o mataas).

Ang sumusunod na halimbawa ay naglalarawan ng kondisyon:

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

Narito ang ledState ay magiging Mababa, at pagkatapos ay sa lalong madaling ledState = !ledState, ito ay magiging TAAS. Ang sumusunod na loop ay magiging sanhi ng ledState maging TAAS kapag ledState = !ledState Ay mababa.

2.7 PARA SA mga pahayag

Ngayon susubukan naming maunawaan ang tungkol sa isa pang istraktura ng kontrol na kung saan ay a para sa loop Maaari itong maging napaka madaling gamiting kung nais mong magpatupad ng maraming bagay nang maraming beses.

Unawain natin ito sa sumusunod na halimbawa:

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
}

Maaari kang makahanap ng isang kakaibang bagay sa linya para sa

Ito ang code ako ++? . Kapaki-pakinabang ito para sa mga programmer na tinatamad at nais na ipatupad ang pag-coding sa pamamagitan ng mga maginhawang mga shortcut

Ang termino sa itaas ay kilala bilang mga operator ng tambalan, dahil ginagawa nila ang gawain ng pagsasama-sama ng isang operator ng pagtatalaga sa isa pang operator ng pagtatalaga. Ang pinakatanyag sa mga ito ay maaaring mailarawan sa sumusunod na talahanayan:

Malalaman mo na mayroong 3 mga sub-pahayag sa isang para sa pahayag. Ito ay nakabalangkas tulad ng ipinakita sa ibaba:

for (statement1conditionstatement2){
// statements
}

Ang pahayag na # 1 ay nangyayari mismo sa simula at isang beses lamang. Ang kondisyon ay nasubok sa bawat oras sa kurso ng loop. Kailan man ito totoo sa loob ng mga kulot na bracket, ang kasunod na pahayag na # 2 ay ipinatupad. Sa kaso ng a hindi totoo, ang system ay tumalon sa susunod na bloke ng code.

Pagkonekta ng Higit pang mga LED

OK, makikita natin ngayon kung paano namin makokonekta ang mas maraming bilang ng LED para sa pagkuha ng mas kawili-wiling mga epekto.

Mangyaring ikonekta ang mga LED at ang Arduino tulad ng ipinakita sa ibaba. Ang pulang kawad ay talagang hindi kinakailangan, ngunit dahil palaging isang magandang ideya na isama ang parehong mga riles ng suplay sa breadboard na itinakda ng set up.

Ngayon ay ayusin natin ang isang programa na magbibigay-daan sa amin upang suriin kung ang aming hardware ay na-configure nang tama o hindi.

Palaging inirerekumenda na mag-code at magpatupad ng maliliit na piraso ng mga programa na hakbang na matalino upang suriin kung ang mga kaukulang hardwares ay naka-wire nang tama o hindi.

Nakatutulong ito sa pag-troubleshoot ng isang posibleng error nang mabilis.

Ang halimbawa ng code sa ibaba ay nagbibigay sa LED 2 hanggang 5 ng isang tukoy na pattern sa pamamagitan ng pag-on ng mga ito nang sunud-sunod sa isang paikot na paraan.

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

Tulad ng napansin mo, walang mali sa code, maliban sa katotohanang mukhang mahaba ito at samakatuwid madaling kapitan ng pagkakamali.

Siyempre may mga mas mahusay na paraan upang isulat ang code sa itaas, ibubunyag ito ng sumusunod na seksyon.

2.9 Pagpapakilala ng Mga Aray

Ang mga array ay maaaring isang pangkat ng mga variable na maaaring ma-index sa mga numero ng index. Ang sumusunod na halimbawa ay makakatulong sa amin upang higit na maunawaan ito.

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

OK, ngayon dumaan tayo sa bawat seksyon at maunawaan kung paano talaga sila gumagana.

const int k_numLEDs = 4

Tinutukoy ng code sa itaas kung gaano karaming mga maximum na elemento ang dapat nating magkaroon sa array. Tinutulungan kami ng code na ito sa mga kasunod na seksyon upang matiyak na ang lahat ay nakasulat sa loob ng isang array at wala nang natapos ang array.

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

Sa susunod na linya na ito ay na-set up namin ang istraktura ng array. Ang mga numero sa loob ng bracket ay nagpapahiwatig ng bilang ng mga elemento sa array. Bagaman, ang aktwal na dami ay maaaring naisulat, ang pagsusulat bilang pare-pareho ay mas mahusay na gumagana. Ang mga halaga ay maaaring makita sa loob ng bracket na may mga kuwit at itinalaga ang mga halaga sa array.

Kapag nakakita ka ng isang naka-index na array na may bilang na 0, ipinapahiwatig nito ang pinakaunang elemento sa array, tulad ng ipinakita sa code: k_LEDPins is k_LEDPins[0].

Katulad nito ang huling elemento ay ipapakita bilang k_LEDPins[3], dahil ang bilang mula0 hanggang 3 ay 4.

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

Ipinapakita ng code sa itaas ang paggamit ng loop para sa pagpapatuloy sa bawat elemento ng array at para sa pagtatakda sa kanila bilang mga OUTPUTS. Nagpapatupad kami ng mga square bracket kasama ang index upang maabot ang bawat isa sa mga elemento sa array.

kung nagtataka ka kung posible na gumamit ng pin # 2 upang i-pin ang # 5 nang walang mga array, ang sagot ay oo, posible. Ngunit sa halimbawang ito hindi ito ginagawa dahil hindi namin ito ginawa sa paraang iyon. Sa mga sumusunod na seksyon maaari mong alisin ang diskarte ng array kung ang napiling mga output pin ay wala sa linya.

Sa pagsulong, tingnan natin kung ano ang susunod na bloke ng code:

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

Narito ang code na nagpapatuloy sa bawat isa sa LED upang ilipat ang mga ito SA sunud-sunod na may isang puwang o pagkaantala ng 100 millisecond.

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

Ang paggamit ng code sa itaas ay nagpapakita kung paano ang aplikasyon ng para sa loop ay maaaring magamit upang ilipat sa pamamagitan ng loop kahit na sa reverse order.

Nagsisimula ito mula sa k_numLEDs - 1 dahil ang mga array ay zero index. Hindi kami nagsisimula sa k_LEDPins[4] dahil magreresulta sa pagtawid sa pagtatapos ng array.

Gumagamit ang code ng> = 0 upang suriin upang ang unang elemento sa index 0 ay hindi napalampas o hindi pinansin.

Kabanata 3

Ano ang isang Input

Natutunan din natin kung paano patakbuhin ang mga bagay gamit ang Arduino. Sa kabanatang ito tatalakayin natin kung paano maiintindihan ang totoong mundo sa pamamagitan ng pag-interfacing ng mga input mula sa panlabas na mga parameter.

3.1 Paggamit ng Pushbuttons

Alam nating lahat kung ano ang isang push-button at kung paano ito gumagana. Ito ay isang uri ng switch o pindutan na nag-uugnay sa isang senyas mula sa isang yugto ng circuit patungo sa isa pang pansamantalang habang nasa kondisyon ito na nalulumbay, at sinisira ang signal kapag inilabas.

3.1.1 Isang pindutan at isang LED

Ikonekta namin ang Arduino gamit ang isang push-button na may Arduino ayon sa ipinakita sa itaas na mga detalye at matutunan ang pangunahing pagtatrabaho at pagpapatupad ng pag-set up.

Ang ipinahiwatig na pindutan ng itulak na tinatawag ding micro switch push button, mayroong 4 na mga pin sa kabuuan (2 pares sa bawat panig). Kapag tinulak, ang bawat pares ng mga pin ay sumali sa loob at isang paganahin ang isang koneksyon o pagpapadaloy sa kanila.

Sa halimbawang ito gumagamit kami ng isang pares lamang ng mga pin o contact na ito, ang iba pang pares ay walang katuturan at samakatuwid ay hindi pinansin.

Magpatuloy tayo sa paglalapat ng sumusunod na code at suriin itong gumagana!

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

Maaari kang makahanap ng ilang mga bagay na mukhang hindi pangkaraniwan dito. Alamin natin ang mga ito sa hakbang na matalino.

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

Ang unang bagay na ginagawa namin ay ayusin ang buttonPin bilang ang INPUT Sa gayon basic na iyon, alam ko.

Susunod, nagtatalaga kami TAAS sa INPUT pin Nagtataka ka, paano posible na magsulat ng anupaman sa pag-input? Oo naman, maaaring maging kawili-wili ito.

Sa totoo lang, ang pagtatalaga ng isang TAAS sa isang input ng Arduino ay nagpapalipat-lipat sa isang panloob na 20k Ohm pull-up risistor ON (isang MABABA sa pin na ito ang nag-toggle nito OFF).

Ang isa pang tanong na maaari mong gawin ay kung ano ang isang pull-up risistor. Saklaw ko ang isang komprehensibong post sa mga pull-up resistor na iyo alamin mo dito .

OK, magpatuloy, ngayon tingnan natin ang pangunahing loop code:

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

Kapag pinindot mo ang pindutan ng push, ang wired pin ay konektado sa lupa, na naglalagay ng a MABABA sa pin na iyon At habang nasa hindi naka-compress na kondisyon ang parehong pin ay gaganapin sa TAAS o + 5V sa pamamagitan ng 20K panloob na pull-up risistor.

Dito nais namin ang Arduino upang magaan ang LED kapag ang push button ay pinindot (LOW), samakatuwid ay nagsusulat kami ng TAAS para sa output para sa bawat tugon ng isang LOW mula sa push button, habang pinindot ito.

3.1.2 Dalawang mga pindutan at isang LED

Sa gayon, maaari kang magtaka na ang ipinakitang pagkilos sa itaas ay maaaring magawa nang walang Arduino din. Naiintindihan ko, gayunpaman ito ay isang matarik na bato upang malaman kung paano magagamit ang pindutan ng push sa Arduno.

Hanggang sa puntong ito, pinag-aralan namin ang pagsulat ng mga code para sa alinman sa switch ON (HATAAS) o paglipat ng OFF (LOW) ng isang LED.

Ngayon tingnan natin kung paano maaaring kontrolin ang liwanag ng LED gamit ang isang Arduino.

Maaari itong gawin gamit ang dalawang pamamaraan:

1. Sa pamamagitan ng paghihigpit sa dami ng kasalukuyang sa LED
2. Sa pamamagitan ng paggamit PWM o modulate ng lapad ng pulso, kung saan ang supply sa LED ay nakabukas ON / OFF sa ilang nais na rate nang napakabilis, na gumagawa ng isang average na pag-iilaw na ang intensity ay depende sa PWM.

Sa isang Arduino board ang suporta ng PWM ay magagamit sa mga pin na minarkahan ng isang tilde (~), na kung saan ay mga pin 3, 4,5,9,10 at 11) sa 500Hz (500 beses sa isang segundo). Nagagawa ng gumagamit na magbigay ng anumang halaga sa pagitan ng 0 at 255, kung saan ang 0 ay tumutukoy sa walang TAAS o hindi + 5V, at sinabi ng 255 sa Arduino na kumuha ng isang TAAS o + 5V sa lahat ng oras. Para sa pagpapasimuno ng mga utos na ito kakailanganin mong i-access ang analogWrite () na may nais na halaga.

Maaari mong ipalagay na ang PWM ay x / 255 kung saan ang x ang nais na halagang nais mong ipadala sa pamamagitan ng analogWrite().

I-setup ang Arduino at iba pang mga parameter tulad ng ipinakita sa itaas.

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

Maaari kang makahanap ng 3 mga linya dito na nangangailangan ng ilang paliwanag.

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

Ang linya: ledBrightness = constrain(ledBrightness, 0, 255) naglalarawan ng isang natatanging pagpapaandar sa loob ng Arduino na kilala bilang constrain ().

Ang panloob na pagpapaandar na ito ay naglalaman ng code na katulad sa mga sumusunod:

int constrain (int halaga, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Lahat ng mga code na tinalakay bago ito ay nagsimula sa walang bisa , na nangangahulugang hindi ibabalik ang anumang (walang bisa). Sapagkat ang code sa itaas ay nagsisimula sa int , na nagpapahiwatig na nagbabalik ito ng isang integer. Tatalakayin namin ang higit pa tungkol sa mga susunod na seksyon, sa sandaling ito ay tandaan lamang na ang isang integer ay walang anumang mga praksyonal na bahagi.

Tama, kaya ipinapahiwatig nito, ang code: ledBrightness = constrain(ledBrightness, 0, 255) itinalaga ang ledBrightness to be within the range of 0 and 255.

Gumagamit ang susunod na linya analogWrite upang utusan ang Arduino na mag-aplay ng PWM sa napiling pin na may nais na halaga.

Ang susunod na linya ay lumilikha ng pagkaantala ng 20 milliseconds, ito ay upang matiyak na hindi namin ayusin ang ate na mas mabilis kaysa sa 50 Hz o 50 beses sa isang segundo. Ito ay dahil ang mga tao ay maaaring maging mas mabagal kaysa sa isang Arduino. Samakatuwid kung ang pagkaantala ay hindi nagawa ng programa ay maaaring iparamdam sa atin na ang pagpindot sa unang pindutan ay nakabukas ang LED OFF at pagpindot sa pangalawang pindutan na naka-ON (subukan ito mismo upang kumpirmahin).

3.2 Mga Potensyal

Unahan natin at alamin kung paano gamitin potentiometers kasama si Arduino.

Upang malaman kung paano gumagana ang potensyomiter o isang palayok, maaari mo itong basahin artikulo .

Ikonekta ang ipinakitang mga parameter sa iyong Arduino tulad ng ipinakita sa itaas.

Ang isang palayok ay magkakaroon ng 3 mga terminal. Ang gitnang terminasl ay kumokonekta sa ANALOG IN 0 sa Arduino. Ang iba pang dalawang mga panlabas na terminal ay maaaring konektado sa + 5V at 0V riles ng suplay.

Programin natin at suriin ang mga resulta:

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

Mahahanap mo ang isang pares ng mga bagay na maaaring magmukhang ganap at hindi kasama sa alinman sa aming mga naunang code.

1. Ang pare-pareho kPinPot ay itinalaga bilang A0, kung saan ang A ay ang shortcut upang ilarawan ang isa sa mga analogue pin. Gayunpaman ang A0 ay tumutukoy din sa pin # 14, A1 sa pin # 15 at iba pa, at pinapayagan kang magamit bilang mga digital input / ouput kung sakaling maubusan ka ng mga pin para sa isang eksperimento. Ngunit tandaan na hindi mo maaaring gamitin ang mga digital na pin bilang mga analogue pin.
2. Ang linya: ledBrightness = map(sensorValue, 0, 1023, 0, 255) nagtatanghal ng isang bagong pagpapaandar sa loob sa Arduino na kilala bilang mapa (). Ang tampok na ito ay muling nag-calibrate mula sa isang naibigay na saklaw patungo sa isa pa, na tinatawag na bilang mapa (halaga, mula sa Mababa, mula sa Mataas, toLow, saHigh). Maaari itong maging mahalaga simula pa analogueRead nagbibigay ng isang halaga sa loob ng saklaw ng 0-1023, ngunit ang analogWrite ay maaaring tumanggap ng isang halaga mula 0-255.

Maaari mong isipin, na dahil posible na kontrolin ang ningning ng isang LED sa pamamagitan ng isang pagbabago ng paglaban, ang isang palayok lamang ay maaaring sapat para sa hangarin, bakit ang paggamit ng Arduino. Sa gayon, muli itong pundasyon lamang, upang maipakita kung paano mai-configure ang isang palayok sa isang Arduino.

Walang mga isyu, ngayon ay gagawa kami ng isang bagay na hindi magagawa nang walang isang Arduino.

Sa eksperimentong ito makikita natin kung paano maaaring magamit ang iba't ibang paglaban ng isang palayok para sa pagkontrol sa bilis ng bilis o rate ng isang LED.

Narito ang 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 Pag-iwas sa pagkaantala ()

Ang code sa itaas ay mukhang maganda, ngunit hindi masuri ng LED ang halaga ng palayok hanggang sa dumaan ito sa bawat buong siklo. Para sa mas matagal na pagkaantala ang proseso na ito ay nakakakuha ng mas matagal ang gumagamit ay maghintay upang makita ang tugon sa palayok habang ilipat niya ito. Ang pagkaantala na ito ay maiiwasan sa pamamagitan ng ilang matalinong pagprograma, upang payagan ang gumagamit na suriin ang halaga nang walang minimum na pagkaantala. Narito ang code.

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

Kaya't ano ang kakaiba sa itaas na code? Ito ang sumusunod na linya na gumagawa ng pagkakaiba.

long lastTime = 0

Hanggang sa seksyong ito, tinalakay namin ang tungkol sa variable int. Gayunpaman, maaaring maraming iba pang mga variable ng uri na maaari mong ma-access. Ang listahan ay maaaring basahin sa ibaba:

Kasalukuyan, maaaring mahalaga lamang na malaman na para sa pag-iimbak ng medyo malaking bilang para sa int variable, maaari mong gamitin ang term mahaba o a mahaba int.

Dito maaari mong makita ang isa pang kawili-wiling pag-andar na tinatawag millis ().

Gumagawa ito ng tagal ng panahon sa mga millisecond na nagtrabaho ang Arduino sa kurso ng operasyon nito mula sa simula (ito ay i-reset sa 0 pagkatapos ng bawat 50 araw). Dito ito nagbabalik ng matagal dahil kung bumalik ito int , ang pagbibilang nang mahabang panahon ay maaaring hindi posible. Maaari mo bang sagutin nang eksakto kung gaano katagal? Ang sagot ay 32.767 segundo.

Samakatuwid sa halip na gumamit ng pagkaantala (), suriin namin ang millis (), at sa lalong madaling natapos ang partikular na bilang ng mga milliseconds ay binago namin ang LED. Dahil dito ay iniimbak natin ang oras kung kailan natin ito pinalitan huling beses variable, upang pinapayagan kaming suriin itong muli kahit kailan ninanais.

3.3 RGB LEDs

Sa ngayon nilalaro namin ang isang solong kulay na LED. Bagaman ang kulay ng LED ay maaaring mabago sa pamamagitan ng pagpapalit ng LED ng isa pang kulay, ngunit paano ang tungkol sa paggamit ng RGB LEDs upang baguhin ang mga kulay ng LED nang hindi binabago ang mga LED?

Ang isang RGB LED ay karaniwang isang LED na mayroong isang pula, berde, at asul na LED na naka-embed at pinagsama sa isang solong LED. Mayroon itong isang karaniwang tingga na pupunta sa lupa o 0V supply rail habang ang iba pang 3 na lead ay pinakain ng sari-saring positibong signal ng PWM para sa pagpapatupad ng nilalayon paghahalo ng kulay .

Maaari mong i-wire ang set up tulad ng ipinakita sa ibaba:

Maaari itong tumingin ng isang maliit na kumplikado, ngunit sa totoo lang ito ay isang kopya ng aming naunang disenyo ng kontrol sa LED gamit ang PWM.

Narito ang isang code ng programa sa pagsasanay:

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

Matapos i-upload ang code na ito, tingnan lamang kung paano lumilikha ang mga pagsasaayos ng palayok ng mga kagiliw-giliw na light effect sa RGB, maaari itong maging isang tunay na kasiyahan.

Malalaman mo na kapag ang lahat ng 3 kaldero ay inilipat maximum na posisyon, sa halip na isang puting kulay makikita mo ang pula. Ito ay dahil ang pulang kulay ay ang pinaka kilalang sa 3 mga kulay at samakatuwid ay nangingibabaw sa sitwasyong ito. Gayunpaman maaari kang mag-eksperimento sa pagpapaandar mapa () , bago ito ipatupad sa pulang bahagi ng LED, upang makalikha ng isang mas makatwirang balanse.

Audio kasama si Arduino

Sa seksyong ito matututunan namin kung paano magdagdag ng pangunahing tunog at musika sa isang pag-setup ng Arduino.

Makikita natin kung paano lumipat ng isang senyas sa isang konektadong speaker na may nais na dalas.

Upang maging mas tumpak, isang gitnang isang tala ang susubukan, na kung saan ay isang tala ng dalas na 440 Hz.

Upang magawa ito, simpleng i-play namin ang isang gitnang tala, at i-optimize ang signal ng sine wave na may square wave.

Gayundin, makakalkula namin ang dami ng oras na maaaring manatiling ON ng isang loudspeaker sa pamamagitan ng pag-demanda sa formula:

timeDelay = 1 segundo / 2 x tonoFrequency.

timeDelay = 1 segundo / 2 x 440

timeDelay = 1136 microseconds

4.1 I-hook up natin ang Arduino Board

4.2 Pagdaragdag ng isang simpleng tala

Tinalakay na natin ang tungkol sa pagpapaandar antala () kung saan ang yunit ay nasa milliseconds (segundo / 1000), subalit makakahanap ka pa ng isa pang pagpapaandar delayMicroseconds() kung saan ang yunit ay nasa microseconds, (millisecond / 1000).

Para sa kasalukuyang pag-set up, pinaprograma namin ang isang code upang ilipat + 5V ON / OFF sa napiling pin na naka-link sa speaker, sa rate na 440 pulso bawat segundo.

Alalahanin, sa huling talakayan natukoy namin ang halagang 1136 microsecond para sa inilaan na tala ng audio.

Kaya narito ang programa para dito, na magpapahintulot sa iyo na makarinig ng isang tala ng audio na 440 Hz sa sandaling mai-program mo ang arduino na may koneksyong speaker.

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

Gamit ang application sa itaas posible na gumawa ng isang audio note, na nangangahulugang maaari rin kaming lumikha ng isang musika ayon sa aming sariling pagpipilian.

Mula sa code na nauunawaan namin na ang Arduino ay nagsasama ng isang pares ng mga pinagsamang pag-andar na karagdagan na nag-aambag sa paglikha ng musika.

Ang una ay tono () na gumagana sa 2 mga elemento kasama ang isang ika-3 opsyonal na elemento, na itinalaga bilang tono (pin, dalas, tagal). o tono (pin, dalas)

Parehong itinalaga upang magpatupad ng kani-kanilang tagal ng panahon na itinalaga mo.

Sa kawalan ng isang tagal ng panahon, magpapatuloy ang pagtugtog ng musika hanggang sa tawag tono () ay naisakatuparan muli, o hanggang sa maipatupad mo napansin ().

Kakailanganin itong gawin gamit ang isang pagpapaandar na pagka-antala kung sakaling ang pag-play ng musika ang tanging pangunahing bagay na iyong ipinapatupad.

Ang tagal ng oras ay maaaring maging mahalaga dahil pinapayagan nito ang pagbibigay ng oras para sa kung gaano katagal pinatugtog ang musika, kaya maaari kang malayang gumawa ng iba pang mga bagay. Sa sandaling mawala ang tagal, titigil ang musika.

Ang susunod na pagpapaandar noTone () humahawak ng isang solong parameter at ihihinto ang napiling tono sa isang partikular na itinalagang pin.

Isang kakaibang babala: Anumang oras kailan tono () ipinatupad ang pagpapaandar, ang pagpapaandar ng PWM sa pin 3 at 11 ay titigil sa pagpapatakbo.

Samakatuwid tuwing ginagamit ang isang attachment ng speaker sa programa, tiyaking hindi gagamitin ang nabanggit na pin para sa mga nagsasalita, sa halip ay subukan ang ilang iba pang mga pin para sa attachment ng speaker.

OK kaya narito ang programa para sa pagpapatupad ng musika sa isang speaker, bagaman hindi ito isang totoong musika sa halip isang batayan ng tala ng C.

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

Sa code sa itaas maaaring napansin mo ang isang bago at iyon # tukuyin .

Gumagana ang term na ito tulad ng isang paghahanap at palitan ang utos para sa computer habang ginagawa ang pag-iipon.

Kailan man makita ang unang bagay bago ang isang puwang, pinalitan ito nito ng natitirang bahagi ng linya (tinatawag na macros).

Kaya sa loob ng halimbawang ito kapag nakikita ng computer TANDAAN_E4 mabilis nitong pinalitan ito ng dami ng 330.

Para sa higit pang mga tala at pagpapasadya maaari kang mag-refer sa isang file sa iyong USB stick na pinangalanan pitches.h , kung saan ang karamihan sa mga frequency ay maaaring matagpuan para sa iyong kagustuhan.

4.4 Musika na may mga pagpapaandar

Ang code sa itaas ay mukhang maganda, ngunit tila may paraan ng maraming mga pag-uulit, dapat mayroong ilang paraan upang paikliin ang mga pag-uulit na ito, tama?

Sa ngayon nagtrabaho kami kasama ang dalawang mahahalagang pag-andar na kasama sa Arduino. Ngayon ay maaaring oras na lumikha kami ng aming sariling mga pag-andar.

Ang bawat pagpapaandar ay dapat magsimula sa uri ng variable na maaaring nauugnay dito. Halimbawa ang pagpapaandar walang bisa tumutukoy sa uri na walang ibinabalik mula rito ang pangalan ay walang bisa. Tandaan, napag-usapan na namin ang isang listahan ng variable sa aming mga naunang mga seksyon, baka gusto mong i-refer ang mga iyon.

Dahil dito, ang partikular na pangalan ng pag-andar ay nakakakuha ng isang bukas na panaklong '(' sinundan ng isang listahan ng mga hiwalay na parameter ng kuwit.

Ang bawat isa sa parameter ay nakakakuha ng uri nito kasama ang isang pangalan, at sa wakas ay isang malapit ')' panaklong

Ang mga parameter na ito ay maaaring mailapat sa loob ng pag-andar sa anyo ng mga variable.

Tingnan natin ang isang halimbawa sa ibaba kung saan nagkakaroon kami ng isang pagpapaandar na tinawag ourTone () idinisenyo upang pagsamahin ang tono () kasama antala () mga linya, sa isang paraan na ang pag-andar ay tumitigil sa pagbabalik hanggang sa natapos ng tala ang pag-play ng tono.

Ipinatupad namin ang mga pagpapaandar na ito sa aming nakaraang code, at makuha ang program sa ibaba, tingnan ang mga huling linya:

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

Ang mga pagpapaandar ay maaaring maging lubhang madaling gamiting gawing mas madaling maunawaan ang isang programa.

Ang sumusunod ay isang halimbawa kung saan maaari naming tukuyin ang pagpipilian ng tono na gusto naming i-play gamit ang dalawang mga array. Isang hanay para sa pagpapanatili ng mga tala, ang iba pa ay panatilihin ang mga beats.

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

Malinaw mong nakikita sa unang linya ang pagpapakilala ng # isama pahayag. Ang gawain ng pahayag na ito ay upang kunin ang buong file sa pagitan ng mga quote at ilagay ito sa posisyon ng # isama pahayag. Alinsunod sa mga pamantayang patakaran ang mga ito ay mahigpit na inilalagay sa pagsisimula ng programa.

Kabanata 5

Pagsukat ng Temperatura

Upang maalala lamang, alalahanin sa halip na magsulat ng kabuuan ng malalaking programa, palaging matalino na isulat at pag-aralan ang maliliit na bahagi ng mga code, na makakatulong sa mabilis na pag-track ng mga pagkakamali.

5.1 Serial Monitor

Hanggang ngayon, ang mga code na tinalakay namin ay hindi lilitaw na mas madali upang paganahin ang mabilis na pag-troubleshoot. Dito susubukan naming gawing mas madali ang mga bagay para sa pagsubaybay at mas madaling paglutas ng isang posibleng problema.

Ang Arduino ay may isang tampok na nagbibigay-daan sa ito upang 'makipag-usap muli' sa computer. Maaari kang mapansin na ang pin0 at pin1 ay minarkahan bilang RX isang TX sa tabi ng bawat isa. Ang mga pin na ito ay talagang sinusubaybayan ng isang magkahiwalay na IC sa loob ng Arduino na ina-upgrade ang mga ito upang mabasa sa kable ng USB habang naka-plug ito sa PC.

Ang seksyon sa ibaba ay nagpapakita ng isang buong programa, mangyaring pumunta kahit na, matututunan namin ang tungkol sa mga bagong entry sa code pagkatapos. Ang code na ito ay kapareho ng ipinahayag na seksyon 2.2 maliban sa katotohanan na nagsasama ito ng ilang dagdag na data para sa pagpapahintulot sa amin na makilala kung ano ang naka-code para rito.

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

Maaari mong makilala ang dalawang bagong bagay dito, isang bagong linya sa setup () pagpapaandar

Serial.begin(9600)

Ipinapahayag lamang ng linyang ito ang pangangailangan ng paggamit ng Serial1 code upang ipatupad ito sa 9600 baud. (narito ang tumutukoy sa serial mga piraso nagpadala ng sunud-sunod, at ang baud ay nangangahulugang ang rate kung saan ito ipinadala). Ang halaga ng baud na ito at ang nasa loob ng serial monitor (malalaman natin ito sa paglaon) ay dapat na pantay, o kung hindi man ang data sa serial monitor ay magpapakita ng basura. Ang pagiging pamantayan ng 9600 ay nagiging mas maginhawa upang magamit.

Ang pangalawang bagong entry ay ang mga sumusunod

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

Dito ipinahihiwatig ng pangalawang linya na ang kasunod na bagay na lalabas mula sa serial port ay magsisimula sa susunod na linya. Iyon ang pagkakaiba ng pangalawang linya mula sa linya ng kamao.

Isa pang bagay na nakikita mo ang mga quote ('). Kilala ito bilang isang string, na gagamitin lamang tulad ng mga pare-pareho dito, dahil ang karagdagang talakayan sa paksang ito ay maaaring masyadong detalyado at lampas sa saklaw.

OK, maaari na nating mai-upload ang code sa itaas sa Arduino at makita kung ano ang mangyayari.

Ano, oops tila walang nangyari, ang Arduino pin # 13 LED ay kumurap at tumigil, habang ang Tx LED ay nanatiling kumikislap.

Kaya, iyon ay dahil ang window ng Serial Monitor ay hindi pa naayos.

Kailangan mong mag-click sa Serial Monitor box sa iyong IDE tulad ng ipinakita sa itaas. Huwag kalimutan na suriin ang rate ng baud na matatagpuan sa kanang ibaba, bilang default dapat itong 9600, at tutugma sa code. Kung hindi ito siguraduhin na pumili ng 9600.

Ipinapaliwanag ng sumusunod na video clip kung paano ito ginagawa.

Sumulong muna tayo at alamin kung paano makakatulong ang tampok na Serial Monitor sa itaas para sa pagproseso ng pagsukat ng Temperatura gamit ang Arduino

Gagamitin namin ang IC TMP36 bilang sensor ng temperatura, pagkakaroon ng saklaw na -40 hanggang 150 degree Celsius.

Makikita ang pag-setup sa ibaba:

Sisimulan ng sumusunod na code ang pagsukat ng temperatura sa pamamagitan ng pagbabasa ng output mula sa sensor ng TMP36, at sa pamamagitan ng pagpapadala sa kanila sa serial monitor ng ID.

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
}

Unawain natin ang code mula sa itaas.

float temperatureC = getTemperatureC()

Makikita mo rito na isinama namin ang uri ng variable lumutang.

Ito ang nag-iisang uri ng variable na nagtatampok ng pagtatago ng lahat maliban sa mga bilang ng integer (mga numero na walang mga decimal at praksyonal na bahagi).

Ang katumpakan mula sa isang variable ng float ay maaaring hanggang sa 6 hanggang 7 na mga digit.

Ang magkadugtong na code getTemperatureC() ay ang aming sariling pag-andar na matematika kinakalkula at binabago ang pagkakaiba ng sensed boltahe mula sa sensor ng TMP36 sa degree Celsius.

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
}

Sa susunod na seksyon ng mga code, dahil ang term analogIn() ay itinalaga upang ibalik ang isang numero sa pagitan ng 1 hanggang 1023, posible para sa amin na masuri ang boltahe mula sa sensor sa pamamagitan ng pagpaparami ng aming pagbabasa ng 5 at pagkatapos ay paghatiin ito ng 1024.

Ang sensor na TMP36 ay tinukoy upang makabuo ng isang 0.5V sa 0 degree Celsius, at pagkatapos ay bumubuo ng 10mV para sa bawat solong pagtaas sa degree Celsius.

Narito ang approximation na nagagawa naming makabuo sa pamamagitan ng mga kalkulasyon:

Maaari mong isaalang-alang na maging ang iyong unang pag-andar na nagbabalik ng ilang halaga (tandaan na ang lahat ng natitirang mga pagpapaandar sa ngayon ay hindi nagbalik ng anumang halaga mula nang sila ay nasa uri. walang bisa ).

Maaari mong maunawaan na upang makakuha ng isang halaga mula sa isang pagpapaandar, kailangan mo lamang idagdag bumalik ka sinundan ng nais na numero na nais mong ibalik.

Kapag sinabi natin bumalik ka nangangahulugan ito na ang function ay nagbabalik ng isang tugon o isang tugon tuwing ito ay tinawag, na maaaring mailapat sa isang variable.

Kapag ipinadala ito sa Serial Monitor, ang pagbabasa ay na-convert sa Fahrenheit sa pamamagitan ng convertToF ().

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

Kinukuha ng pagpapaandar na ito ang saklaw ng Celsius at binago ito sa Fahrenheit.

Para sa pag-convert sa Fahrenheit sa Celsius ipinapatupad namin ang formula Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Interfacing ng isang LCD

Pag-aralan natin ngayon kung paano i-interface o ikonekta ang isang LCD display kasama ang Arduino para sa pagkuha ng visual display para sa mga kinakailangang output.

Sa aming aplikasyon ay gagamitin namin ang isang 84x48 grapikong LCD, pagkakaroon ng isang 84 pixel o mga tuldok nang pahalang, at 48 na pixel na patayong resolusyon. Dahil ang isang dedikadong tagapamahala ay naging kinakailangan para sa lahat ng mga LCD, ang kasalukuyang aparato ay nagsasama rin ng isa sa anyo ng PCD8544 controller.

Sa tutorial na ito, ikonekta namin ang tinukoy sa itaas na module ng LCD sa Arduino, at ilalapat ang ilang mga gawain upang lumikha ng mga text message sa display.

Sa sumusunod na figure maaari kang makahanap ng mga detalye tungkol sa interfacing ng LCD, kasama ang isang maliit 3.3V boltahe regulator . Ang regulator na ito ay kinakailangan dahil ang LCD ay tinukoy upang gumana sa isang supply ng 3.3V.

Maaari mo ring makita ang 8 pinout mula sa module ng LCD, ang mga pagtutukoy ng pinout ay maaaring pag-aralan mula sa sumusunod na talahanayan:

Tingnan natin ngayon kung paano natin maiugnay ang LCD at ang mga nauugnay na parameter sa aming Arduino. Ang mga detalye ay maaaring mailarawan sa ipinakitang ilustrasyon sa ibaba:

5.4 Nakikipag-usap sa LCD

Bagaman posible na magsulat ng mga detalyadong coeds para sa pakikipag-ugnay sa LCD mula sa Arduino, mas matutunan namin kung paano gawin ang pareho gamit ang mga aklatan.

Ang mga aklatan ay binubuo ng iba't ibang mga code na maaaring mabilis na mailapat para sa isang napiling programa ng Arduino.

Pinapayagan nito ang gumagamit na tumawag sa isang pagpapaandar nang walang kahirap-hirap nang hindi kinakailangang dumaan sa kumplikadong gawain sa pag-coding.

5.4.1 Paano I-install ang library

Para sa mga ito kailangan mong lumikha ng isang direktoryo na tinatawag na mga aklatan sa iyong computer Arduino IDE, tulad ng ipinaliwanag dito

5.4.2 Pagpapatupad ng LCD Operations

Tulad ng aming nakaraang diskarte, susuriin muna namin ang buong code at pagkatapos ay subukang unawain ang mga detalye ng mga indibidwal na linya.

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

Kasama sa linya ang code #include

Inuutusan ng code na #include ang PC na kunin ang nabanggit na file at palitan ang elemento na #include ng mga nilalaman ng file sa panahon ng pag-iipon ng programa.

Ang elemento na #include ay maaaring magtaglay ng mga bracket ng anggulo na nagsasaad ng paghahanap sa direktoryo ng library, bilang kahalili maaari din itong magtaglay ng mga quote na nagsasaad ng paghahanap sa loob ng parehong direktoryo na matatagpuan ang programa.

Ang mga kasunod na linya ng code ay nagpapahayag ng mga LCD pinout, at pagkatapos ay nagsusulat kami ng isang bagong anyo ng variable:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Dito ipinapahayag namin ang isang variable na may pangalang lcd na mayroong uri na PCD8544 at nagtuturo sa PC na muling pagsasaayos ng mga pinout na nauugnay sa Arduino.

Sa prosesong ito inilalarawan namin ang variable sa PC sa pamamagitan ng pagtuturo kung paano ang pin clk, din, dc, at reset ay nakakonekta sa Arduino.

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

Ang linya lcd.init() pinasimulan ang pagpapatakbo ng LCD. Sa sandaling ito ay naisakatuparan, ang susunod na linya ay nagpapatupad ng isang cursor sa kaliwang itaas ng display. At ang susunod na kasunod na linya ay nagsisikap na mai-print ang mensaheng 'Hello, World'.

Mukha itong magkapareho sa pamamaraan kung saan kami nagpadala ng mga mensahe sa serial monitor. Ang pagkakaiba lamang sa paggamit ng code lcd.print sa halip na serial.print.

Ang susunod na bloke ng code ay talagang tinatawag na paulit-ulit.

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

Gamit ang linyang ito lcd.setCursor(0,1) inaayos namin ang cursor sa 0th na haligi sa kaliwang kaliwa ng ika-1 hilera, sa ibabaw ng LCD display.

Gumagamit ang susunod na linya ng isang shortcut: lcd.print(millis())

Kung maaalala mong nakipagtulungan kami sa millis() sa aming mga naunang code, maaaring mailapat din namin ang pareho dito sa pamamagitan ng mga code:

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

Gayunpaman dahil sa ang katunayan na dito walang mga tagal ng oras sa millisecond ay kasangkot, samakatuwid nagawa namin ito sa pamamagitan lamang ng pagpapadala millis() direktang pag-andar sa lcd.print() .

5.5 Pinagsasama ang Buong Bagay

OK, ngayon pagsamahin natin ang lahat ng mga code na natutunan sa itaas para sa paggawa ng LCD temperatura circuit, at tingnan natin kung paano ito nakikita:

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

Ang lahat ay mukhang pamantayan sa programa sa itaas, maliban sa paggamit ng pagpapaandar setCursor () . Ginagawa ito upang ihanay ang teksto hangga't maaari sa paligid ng gitna ng display.

Malaki! At congrats, na-program mo lang ang iyong sariling maliit na tagapagpahiwatig ng temperatura ng LCD gamit ang Arduino.

Praktikal na Aplikasyon ng Arduino

Dahil, sa puntong ito na masaklaw namin ang saklaw ng iba't ibang mga diskarte sa programa nang detalyado, oras na upang mailabas ang mga ito sa pamamagitan ng paglalapat ng mga ito para sa ilang kapaki-pakinabang na praktikal na pagpapatupad.

Magsisimula kami sa mga sensor at makikita kung paano magagamit ang mga sensor device sa Arduino sa pamamagitan ng pagpapatupad ng ilang mga sample code.

7.1 Panimula sa Sensors

Sa tutorial na ito matututunan natin ang tungkol sa iba't ibang uri ng mga sensor na maaaring magamit sa Arduino. Maaaring kabilang dito ang mga aparato tulad ng light sensor LDR, magnetic hall effect sensor, ikiling sensor, vibration sensor, pressure sensor atbp.

Magsisimula kami sa interfacing ng light sensor LDR kasama ang Arduino, tulad ng ipinapakita i ang sumusunod na diagram:

Tulad ng alam nating lahat, ang LDR ay isang light dependant resistor device na ang resistensya ay nakasalalay sa tindi ng ambient na insidente sa ibabaw nito.

Ang tindi ng ilaw ay baligtad na proporsyonal sa pagbabasa ng paglaban ng LDR.

Malalaman dito kung paano maaaring maisama ang pag-aari na ito sa Arduino para sa pagpapatupad ng isang kapaki-pakinabang na application:

Ang kumpletong code ng programa ay maaaring mailarawan tulad ng ibinigay sa ibaba:

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

Ang lahat ng mga parameter na ginamit sa code ay napag-usapan na sa aming kurso na natutunan namin sa ngayon. Maaari mong suriin ang mga linya sa pamamagitan ng pag-refer sa mga nauugnay na seksyon.

Ang mga halaga ay pinili nang sapalaran, madali mong mababago ayon sa iyong sariling mga kagustuhan.

Ikiling Sensor

Ang isang ikiling sensor ay isang simpleng aparato na maaaring magamit upang makita ang isang pagkilos na ikiling sa anumang bagay kung saan ito naka-install. Ang aparato ay karaniwang may isang metal na bola sa loob, na kung saan sa pagtagilid ay gumulong sa isang pares ng mga contact na nagiging sanhi ng isang pagpapadaloy sa mga contact na iyon. Ang mga contact na ito ay winakasan bilang mga lead ng tilt switch, ay ginagamit ng isang panlabas na circuit para sa pagtuklas ng pagpapadaloy dahil sa isang pagkiling na aksyon at paganahin ang nais na application ng output.

Ngayon tingnan natin kung paano a ikiling sensor Maaaring i-wire ang aparato. Ang imahe sa ibaba ay nagbibigay sa amin ng isang ideya tungkol sa kumpletong pagsasaayos:

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

Sa halimbawang ito ang default na pin # 13 LED ay ginagamit bilang tagapagpahiwatig ng ikiling.

Malinaw mong nakikita ang pagsasama ng pull-up risistor dito, katulad ng ginawa namin sa seksyon 3.1. Samakatuwid ang term na LOW ay nagpapahiwatig na ang tilt function ay hindi na-trigger.

7.4 Reed Switch Relay (Miniature Magnet Activated Relay)

Tingnan natin ngayon kung paano mag-hook up ng isang relay switch o isang magnetic field sensor na may Arduino. Ang isang reed relay ay isang uri ng switch na kung saan ay nagpapagana o nagsasagawa kapag ang isang magnetic field o isang magnet ay dinala malapit dito. Karaniwan mayroon itong isang pares ng mga contact na ferromagnetic sa loob ng isang maliit na enclosure ng baso na sumali o makipag-ugnay dahil sa magnetikong paghila tuwing may isang magnet na malapit sa kanya. Kapag nangyari ito ang mga terminal ng mga contact ay nagpapakita ng pagpapadaloy dahil sa pagsasara ng mga contact.

Dito din ginagamit namin ang pin # 13 LED para sa nagpapahiwatig ng tugon. Maaari mong ikonekta ang isang panlabas na LED mula sa pin na ito kung kinakailangan ayon sa aming naunang mga paliwanag.

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

Ang mga tuntunin sa code ay dapat pamilyar at nagpapaliwanag sa sarili.

7.5 Vibration sensor gamit ang Piezo Transducer

Sa susunod na sample na programa makikita natin kung paano a piezo transducer maaaring magamit bilang isang panginginig ng boses sensor upang maipaliwanag ang isang LED sa pamamagitan ng Arduino.

Ang isang elemento ng piezo talaga ay isang aparato na bumubuo ng panginginig ng boses o pag-oscillation kapag ang isang dalas ay inilapat sa mga terminal nito. Gayunpaman ang parehong piezo ay maaaring magamit sa reverse proseso para sa pagbuo ng mga de-kuryenteng pulso bilang tugon sa panginginig na inilapat sa katawan nito. Ang panginginig na ito ay maaaring sa anyo ng isang katok o hit sa ibabaw ng piezo.

I-setup ang Arduino at isang elemento ng piezo tulad ng ibinigay sa sumusunod na figure

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

Ang threshold 100 ay ipinakilala upang matiyak lamang na ang Arduino ay tumutugon lamang sa tunay na mga panginginig sa pamamagitan ng mga katok, at hindi iba pang mas maliliit na panginginig tulad ng mula sa malalakas na tunog, o mga sungay.

Ang pagpili ng A5 pin ay hindi sapilitan, maaari kang pumili ng anumang iba pang mga input ng analogue ayon sa iyong kagustuhan at sa pamamagitan ng pagtutugma nito sa code ng programa.

Paggamit ng Servo Motor na may Arduino

Ang isang servo motor ay isang uri ng DC motor na maaaring paikutin upang tumpak na mga anggulo ayon sa pangangailangan ng isang partikular na aplikasyon. Maaari itong magawa sa pamamagitan ng paglalapat ng isang kinakalkula na utos sa mga nauugnay na input ng motor upang makabuo ng isang tumpak na pag-ikot o pag-ikot ng anggulo sa loob ng 180 degree range sa motor.

Kadalasan ang isang servo motor ay may 3 mga wire o input. Ang mga positibong wires ay normal na pula ang kulay, ang negatibo o ground wire ay itim, na ang command wire o ang signaling wire ay karaniwang puti o dilaw sa kulay.

Pinapabilis ng Arduino ang kontrol ng servo motor sa pamamagitan ng built in na suporta na wika na ginagawang napaka-maginhawa at perpekto para sa mga motor ng servo.

Ipapakita sa amin ng sumusunod na halimbawa ang pangunahing programa sa pag-set up para sa pagpapatupad ng control ng servo motor sa pamamagitan ng Arduino:

Ang code ay ibinigay sa ibaba:

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

Maaari naming makita ang isang pares ng mga bagong entry dito. Isa na nagsasabi sa nakakabit na kawad ng servo sa kung anong itinalaga nitong pin. Ang isa pa ay ang code na nagbibigay ng pin ng halaga sa pagitan ng 0 at 180, para sa pagtukoy ng anggulo ng pag-ikot sa servo.

Konklusyon

Ang paksang Arduino ay maaaring mahaba ang haba, at samakatuwid ay lampas sa saklaw ng artikulong ito. Gayunpaman, umaasa ako na ang tutorial sa itaas ay dapat na tiyak na nakatulong sa iyo upang malaman ang mga pangunahing kaalaman sa Arduino, at maunawaan ang mga mahahalagang parameter sa pamamagitan ng iba't ibang mga halimbawang mga code ng aplikasyon.

Sana mas maraming impormasyon ay maaaring mai-update paminsan-minsan dito, tuwing ito ay magagamit.

Pansamantala tangkilikin ang iyong kurso sa programa, Maligayang Arduinoing sa iyo !!