Az alap Arduino programozás elsajátítása - oktatóanyag az újonnan érkezők számára

Ebben az oktatóanyagban megtanuljuk, hogyan kell elvégezni az alapvető Arduino programozást példakódok és mintaprogramok segítségével. Ez a bemutató rendkívül értékes tanfolyam lehet mindazoknak az újonnan érkezőknek, akik könnyed, érthető nyelven szeretnék megismerni az alapokat.

Bevezetés

Alapján wikipédia a mikrovezérlő egyenértékű az egyetlen IC chipbe épített mini számítógéppel, amelynek saját processzora, programozható bemenetei, memóriája és kimeneti perifériái vannak.

A mikrovezérlő annyira hasznos lesz a felhasználó számára, mivel beépített processzort, memóriát és bemeneti / kimeneti portokat kínál (GPIO-nak vagy általános célú bemeneti / kimeneti csapoknak is nevezik), amelyeket a felhasználó a kívánt specifikációknak megfelelően vezérelhet.

Ebben az oktatóanyagban egy Arduino Uno táblával fogunk együttműködni a programok megtanulása és tesztelése céljából. A hardveres összeállítás teszteléséhez és integrálásához kenyérlemezt fogunk használni.

Most haladjunk gyorsan és tanuljuk meg, hogyan kezdjünk el egy Arduino programozással.

1.2 A szoftver telepítése (Windows)

Ehhez hozzáférésre van szüksége az internethez, amely nyilvánvalóan a számítógépén lenne. Kérjük, lépjen a következő linkre, és töltse le az IDE szoftvert:

Windows ZIP fájl nem adminisztrációs telepítéshez

A letöltés után megtalálja a letöltési mappában az Arduino beállítási ikont, amely így néz ki:

Miután ezt megkapta, egyszerűen kattintson rá duplán, és telepítse az Arduino Integrated Development Environment (IDE) programot a számítógépére. A teljes folyamat a következő videóban jeleníthető meg:

1.4 Kezdve az első áramkörrel

Mielőtt elkezdenénk megtanulni a tényleges programozási technikákat, minden újonc számára hasznos lehet egy alapkomponenssel kezdeni, például egy LED-del, és megérteni, hogyan lehet összekapcsolni egy Arduino-val.

Mint tudjuk, a LED egy fénykibocsátó dióda, amelynek polaritása van, és nem világít, ha nincs csatlakoztatva a megfelelő táposzlopokhoz.

A LED-ek másik szempontja, hogy ezek az eszközök alacsony árammal működnek, és azonnal megsérülhetnek, ha egy megfelelően kiszámított ellenállást nem sorozatosan tartalmaznak az egyik csapjával.

Alapszabályként egy 330 ohmos 1/4 watt ideális minden 5V-os tápbemeneti emelkedésre, hogy az áramot a szükséges biztonságos szintre korlátozza. Ezért 5V esetén 330 ohm lehet, 10V esetén 680 ohm és így tovább.

Kenyérlemez használata az összeszereléshez

Kérjük, ellenőrizze, hogy tudja-e használni a kenyérdeszka az ebben a fejezetben ismertetett oktatóanyag kipróbálása előtt, mivel itt minden kísérlethez kenyérlemezt használunk.

Az alapvető LED-kapcsolatok beállítása alább látható:

Három alapkomponens látható fent:

1. 5 mm-es, 20 mA-es LED
2. egy 330 ohmos 1/4 wattos ellenállás
3. An Arduino Board

Csak állítsa össze a rendszert az ábra szerint.

Ezután csatlakoztassa az 5 V-ot a számítógép USB-jéről az Arduino-hoz. Amint ezt megteszi, látni fogja a LED világítását.

Tudom, hogy ez elég alap, de mindig jó a nulláról kezdeni. Biztos lehet benne, hogy a dolgok egyre érdekesebbek lesznek, ahogy haladunk előre.

1.5 LED vezérlése Arduino-val

Most megtanuljuk, hogyan kell irányítani a LED-et Arduino programmal.

Program írásához minden programban legalább 2 funkcióval kell rendelkeznünk.

A függvény alatt programozási utasítások sorozatát érthetjük, amelyekhez név rendelhető, az alábbiak szerint:

1. beállít() ezt meghívják vagy végrehajtják a program indításakor.
2. hurok() ezt ismételten hívják vagy hajtják végre az Arduino teljes működési ideje alatt.

Ezért, bár lehet, hogy nincs gyakorlati funkciója, technikailag a legrövidebb legitim Arduino program írható a következőképpen:

A legegyszerűbb program

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

Lehet, hogy észrevette, hogy a programozási nyelvek számos részén a rendszer egy egyszerű 'Hello, World' nyomtatással kezdi a kijelzőt

Ennek a kifejezésnek az elektronikus megfelelője a mikrovezérlő értelmezésében a LED BE és KI villogása.

Ez a legalapvetőbb program, amelyet ki lehet írni és megvalósítani a rendszer megfelelő működésének jelzésére.

Megpróbáljuk megvalósítani és megérteni az eljárást a következő kódrészleten keresztül:

1.2. Lista: led1 / led1.pde

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

Rendben, most értsük meg, mit jelentenek a kód egyes sorai és hogyan működik a függvény végrehajtása:

const int kPinLed = 13

Ez úgy működik, mint egy állandó, amely lehetővé teszi számunkra, hogy a teljes programozási tanfolyam alatt használjuk, anélkül, hogy a vele szemben beállított tényleges értéket kellene használni.

A standard szabályok szerint az ilyen állandókat a kezdőbetűvel ismerjük fel nak nek . Bár ez nem kötelező, világosabbá és könnyebben érthetővé teszi a dolgokat, amikor csak kedve támad átnézni a kód részleteit.

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

Ez a kód konfigurálja azt a konkrét csapot, amelyhez a LED-jünk csatlakozik. Más szavakkal, a kód arra utasítja az Arduino-t, hogy az „olvasás” helyett irányítsa ezen a tűn az „írás” szempontot.

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

A fenti sorok jelzik az alkalmazás tényleges végrehajtását. A kód azzal kezdődik, hogy HIGH-t ír ki és renderel ki a megfelelő LED-kapcsolaton, bekapcsolva a LED-et.

Itt a HIGH kifejezés egyszerűen azt jelenti, hogy + 5V-t kap az Arduino érintett tűjére. A LOW komplementer kifejezés egyszerűen nulla vagy 0V értéket jelöl a kijelölt csapon.

Ezután hívjuk a delay() amelynek feladata késleltetést létrehozni ezredmásodperceken keresztül (1/1000 másodperc). Mivel az 500-as értéket megadtuk, a végrehajtott késés 1/2 másodpercig fog tartani.

Amint ez az 1/2 másodperc lejár, a következő sor kerül végrehajtásra, amely kikapcsolja a LED-et a LOW kifejezéssel ugyanazon a csapon.

A következő sor ismét generálja az 1/2 másodperces késleltetést annak érdekében, hogy a LED 1/2 másodpercig kialszik.

És a folyamat végtelenül folytatódik a kódsorok végrehajtásával, mindaddig, amíg az Arduino energiát táplálja.

Mielőtt továbblépne a következő szintre, azt javasoljuk, hogy kérjük, programozza be a fenti kódot, és ellenőrizze, hogy megfelelően tudja-e végrehajtani a LED ON / OF szekvenciát.

Mivel az Arduino alapértelmezett LED-je a # 13-as csatlakozóval van összekötve, azonnal reagálnia kell a fenti programra, és villognia kell. Ha azonban úgy találja, hogy a külső LED nem villog, akkor lehet, hogy kapcsolódási hiba van a LED-del, megpróbálhatja megfordítani a LED polaritását, és remélhetőleg azt is látja, hogy villog.

A késleltetési idővel úgy játszhat, hogy megváltoztatja az „500” értéket valamilyen más értékre, és megtalálja a LED-t, amely „meghallgatja” a parancsokat, és a megadott késleltetési értékeknek megfelelően villogni kezd.

De ne feledje, ha látja, hogy a LED nem villog állandó 1 másodperces sebességgel, függetlenül a késleltetési idő megváltoztatásától, ez azt jelezheti, hogy a kód valamilyen hiba miatt nem működik. Mivel alapértelmezés szerint az Arduino 1 másodperces villogási sebességgel lesz programozva. Ezért ennek az aránynak változnia kell a kóddal a helyes működés megerősítéséhez.

1.7 Megjegyzések

A fent megértett kódsorokat kifejezetten a számítógépes szoftverhez írták.

Annak érdekében azonban, hogy a felhasználó képes legyen hivatkozni a sorok értelmére és megérteni azokat, gyakran hasznos és ésszerű lehet a magyarázatot a kívánt kódsorok mellé írni.

Ezeket ún Hozzászólások amelyeket csak emberi vagy felhasználói hivatkozásra írtak, és kódolva vannak, hogy a számítógépek biztonságosan figyelmen kívül hagyhassák.

A megjegyzések nyelve néhány formátumban íródott:

1. A megjegyzés blokkstílusa, ahol a megjegyzés leírása a kezdő szimbólum / * és a befejező szimbólum * / alatt található
2. Ennek nem kell egy sorban korlátozódnia, inkább kibővíthető a következő következő sorokra, a megjegyzés vagy a leírás hosszától függően, amint az a következő példában látható:

/ * Ez egy megjegyzés * /

/ * Így van ez * /

/ * És
* ezt
* as
* jól */

Gyors egysoros leírás írásához egy megjegyzéshez elegendő két perjel // szimbólum az elején. Ez azt mondja a számítógépnek, hogy ennek a sornak semmi köze a tényleges kódhoz, ezért figyelmen kívül kell hagyni. Például:

// Ezt a megjegyzést a számítógépek figyelmen kívül hagyják.

Íme egy példa referenciaként:

/*
* 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 Hibaelhárítás

Ha úgy találja, hogy programja fordítás közben „hibát” mutat, vagy más probléma merül fel, az alábbi tippek valószínűleg segítenek a kód újbóli ellenőrzésében, hogy megszabaduljon az akadálytól.

1. A program nyelve megkülönbözteti a kis- és nagybetűket. Például a kifejezés myVar nem írható úgy MyVar.
2. Mindenféle szóköz, amelyet a billentyűzet gépelésével végre lehet hajtani, végül egyetlen szóközként jelenik meg, és csak Ön látja vagy érti, a számítógép ezt nem fogja figyelembe venni. Leegyszerűsítve: a szabad helyek semmilyen módon nem befolyásolják a kód eredményeit.
3. Minden kódblokkot bal és jobb göndör zárójelekkel kell ellátni, „{” és '}'
4. A számjegyeket nem szabad vesszővel elválasztani. Például az 1000-et nem írhatjuk 1000-nek.
5. A göndör zárójelek közé zárt minden kódsort pontosvesszővel kell befejezni

Érdekes LED-es fénysorrend létrehozása az Arduino-val

Előző fejezetünkben megtanultuk, hogyan kell folyamatosan villogni egy LED-et ON / OFF állandó késleltetési sebesség mellett.

Most megtudjuk, hogyan lehet különböző késleltetési mintákat futtatni ugyanazon a LED-en a programkód frissítésével.

Nem használunk külső LED-et, inkább az Arduino táblába beépített alapértelmezett LED-et használjuk a 13. tűnél. Ez az apró SMD LED közvetlenül az USB csatlakozó mögött található.

2.2 Az IF nyilatkozatok megértése

Ebben a szakaszban megtudhatjuk, hogy a vezérlési struktúrák hogyan képesek futtatni az egyedi kódokat, sőt, szükség esetén akár ismétlődően is.

Az állítás ha válik az 1. ellenőrzési struktúrává. A következő megvalósítás bemutatja annak használatát:

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

Megpróbáljuk lépésről lépésre megérteni a fenti kódot, és megtanuljuk, hogyan lehet ezt felhasználni más hasonló végrehajtásokhoz.

Az 1. és 7. sor közötti kódok pontosan hasonlítanak a kezdeti programunkhoz.

Az első módosítás valójában a 8. vonalon történik.

int delayTime = 1000

Megtalálhatja, hogy ez hasonló az 1. sor kódjához, kizárva, hogy hiányzik a kifejezés konst.

Ez egyszerűen azért van, mert ez a kód nem állandó. Ehelyett ez a változó , amely a programozás során változó értékű tulajdonsággal rendelkezik.

A fenti példában láthatja, hogy ennek a változónak 1000-es értéket tulajdonítanak. Ne feledje, hogy a göndör zárójelbe tett változókat szigorúan csak göndör zárójel-párokba kell írni, és „helyi” változóknak nevezik őket.

Alternatív megoldásként azok a változók, amelyek állítólag göndör zárójelben vannak, mint amilyenről most beszélünk, „globálisnak” tekinthetők, és szinte bárhová végrehajthatók egy programkódon belül.

Előre haladva láthatja, hogy a 9. és 11. sor közötti kódok is hasonlóak az első programhoz, mindazonáltal a dolgok érdekessé válnak a 11. sor után. Lássuk, hogyan!

delayTime = delayTime - 100

Ebben a kódban azt látjuk, hogy a késési idő módosul, kivonva belőle 100-at.

A 100 jelentése levonásra kerül az eredeti 1000 értékből, ezzel új 900 értéket biztosítva.

A következő képen megpróbálunk megérteni néhány Arduino nyelven használt matematikai operátort.

Most értékeljük a 13. és 15. sor közötti kódokat.

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

A fenti kóddarab fő célja annak biztosítása, hogy a LED továbbra is fennakadás nélkül villogjon.

Annak a ténynek köszönhetően, hogy 100-at vonnak le az eredetiről késési idő , megakadályozza, hogy a LED villogjon, és elérje a villogást.

Az alábbi kép néhány összehasonlító operátort mutat be, amelyeket a kódjainkban használnánk:

A fenti kódunkban tesztelhettük volna, hogy a kód if(delayTime == 0)

Mivel azonban negatív szám lehet egyformán rossz, ezért nem mentünk rá, és ez egy ajánlott gyakorlat.

Gondoljon arra, mi lett volna az eredménye, ha megpróbálunk 100 helyett 300-at levonni a delayTime

Tehát most rájött, hogy ha a delayTime kisebb vagy egyenlő, mint a nulla, akkor a késleltetési időt az eredeti 1000-es értékre állítanánk vissza.

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

A kód utolsó 4 sora a fent látható módon felelőssé válik a LED folyamatos be- és kikapcsolásáért, be- / kikapcsolásáért.

Itt egyértelműen észreveheti, hogy számos ábra használata helyett változót használtunk a késleltetési idő hozzárendeléséhez, hogy a kód működési ideje alatt tetszés szerint beállíthassuk. Ez klassz, igaz?

2.3 ELSE nyilatkozatok

Itt megtudhatjuk, miért és hogyan ha kifejezés tartalmazhat záradékot más hogy ez döntse el a helyzetet abban az esetben ha állítás hamis.

Sajnálom, ha ez túl zavarónak tűnik, ne aggódjon, megpróbáljuk megérteni a következő példával:

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

A fentiekből jól látható, hogy a 10. sorban a kód csak akkor hajtódik végre, amikor a delayTime 100-nál kisebb vagy egyenlő, ha nem, akkor a 13. sor kódja végrehajtásra kerül, de mindkettő együtt soha nem történhet meg, vagy a 10., vagy a 13. sor kód kerül végrehajtásra, soha nem mindkettő.

Lehet, hogy észrevette, hogy az előző 2.2. Szakaszban leírtakkal ellentétben itt nem a 0-val, hanem a 100-zal hasonlítottunk össze. Ez azért van, mert ebben a példában összehasonlítottuk azelőtt, hogy levontunk 100-at, ellentétben a 2.2-es szakaszban, mi UTÁN kivonva. Meg tudnád mondani, mi történhetett, ha 100 helyett 0-at hasonlítottunk volna össze?

2.4 MIKOR állítások

NAK NEK míg állítás meglehetősen hasonló ha kivéve azt az igazságot, hogy ismételt végrehajtást okoz egy kódblokknak (amely göndör zárójelek között lehet), amíg a feltételek érvényesek, és ez más nyilatkozat.

A következő példa segít jobban megérteni ezt

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

Kitalálhatja, hogy mire van programozva a fenti kód? Nos, úgy tervezték, hogy gyorsabban, majd lassabban villogjon a LED.

2.5 Mi az igaz és hamis?

A programozási nyelvben hamis nulla értékre (0) utal. Valójában nem az „igaz” szót használják, hanem azt feltételezik, hogy ha semmi sem hamis, akkor minden, ami benne van, igaz.

Kicsit furcsának tűnik, azonban nagyon szépen végzi a munkát.

A következő példán keresztül megpróbáljuk megérteni a helyzetet.

Előfordulhat, hogy találkozol egy kóddal az alábbiak szerint:

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

Ez úgy van kódolva, hogy a LED végrehajtása örökké folytatja a kerékpározást, mivel hosszú energia áll rendelkezésre.

Ennek a kódtípusnak azonban egy hátránya merülhet fel, ha véletlenül a felhasználó az = helyett állítja be az = értéket.

Biztos vagyok benne, hogy már tudja, hogy a = egy hozzárendelést jelent, vagyis egy kiválasztott értéket változónak jelöl, míg az a == -t egy teszt végrehajtására használják, ha az érték azonos volt.

Például tegyük fel, hogy szükség van egy LED-re, hogy szekvenciálisan gyorsított mintával és ismétlődően villogjon, de helytelenül használta az = értéket a == helyett.

A kód ekkor a következőképpen jelenik meg:

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
}

A hiba 0-t fog rendelni a delayTime -hoz, és a -hoz vezet ha utasítás annak ellenőrzésére, hogy 0 igaz-e vagy sem. Mivel a 0 hamisra utal, azt fogja hinni, hogy nem igaz, és leállítja a delayTime = 1000 végrehajtását, ehelyett azonban a delayTime a ciklus () folyamán 0-nál tartják.

Ez nagyon nemkívánatosnak tűnik !!

Tehát mindig ellenőrizze a programot, hogy megbizonyosodjon róla, hogy nem követett el ilyen ostoba hibákat.

2.6 Kombinációk

Néha szükségét érezheti annak, hogy több dolgot együtt teszteljen. Például érdemes megvizsgálni, hogy egy változó két szám között volt-e. Bár ez megvalósítható az if utasítás többszörösével, kényelmesebb lehet logikai kombinációkat használni a jobb és könnyebb olvasás érdekében.

A logikai kifejezések kombinációinak megvalósítása 3 módszerrel történhet, amint azt a következő táblázat mutatja:

Érdekes lenne tudni, hogy a NOT operátor kapcsolóként működhet egy olyan változó számára, amelyet bármelyiknek kijelölhetünk igaz vagy hamis (vagy LOW vagy HIGH).

A következő példa szemlélteti a feltételt:

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

Itt a ledState LOW lesz, majd amint ledState = !ledState, HIGH lesz. A következő hurok ledState -t okoz hogy MAGAS legyen, amikor ledState = !ledState alacsony.

2.7 FOR nyilatkozatok

Most megpróbálunk megérteni egy másik vezérlési struktúrát, amely a mert hurok. Ez nagyon hasznos lehet, ha valamit többször is meg akar valósítani.

Értsük meg ezt a következő példával:

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
}

A sorban találhat valami egyedit mert.

Ez a kód i ++? . Ez hasznos azoknak a programozóknak, akik meglehetősen lusták, és kényelmes parancsikonok segítségével szeretnék megvalósítani a kódolást

A fenti kifejezés összetett operátorok néven ismert, mivel azt a feladatot végzik, hogy az egyik hozzárendelési operátort összekapcsolják egy másik hozzárendelési operátorral. Ezek közül a legnépszerűbbeket a következő táblázat szemlélteti:

Megállapítja, hogy egy for utasításban 3 almondat található. Az alábbi felépítésű:

for (statement1conditionstatement2){
// statements
}

Az 1. állítás rögtön az elején és csak egyszer fordul elő. Az állapotot a hurok során minden alkalommal tesztelik. Amikor csak van igaz a göndör zárójelben a következő 2. állítás érvényesül. A hamis, a rendszer a következő kódblokkra ugrik.

További LED-ek csatlakoztatása

OK, most meglátjuk, hogyan tudunk több LE-t összekapcsolni az érdekesebb effektusok elérése érdekében.

Kérjük, csatlakoztassa a LED-eket és az Arduino-t az alábbiak szerint. A piros vezetékre valójában nincs szükség, de mivel mindig jó ötlet, ha mindkét ellátó sín a kenyérlapba kerül, a telepítésnek van értelme.

Javítsunk ki egy programot, amely lehetővé teszi számunkra, hogy ellenőrizzük, hogy a hardverünk megfelelően van-e konfigurálva.

Mindig ajánlott a programok kis bitjeit kódolni és futtatni, lépésről lépésre ellenőrizni, hogy a megfelelő hardver megfelelően van-e bekötve.

Ez segít az esetleges hibák gyors elhárításában.

Az alábbi kódpélda a 2–5 LED-eknek egy meghatározott mintát biztosít, azáltal, hogy ciklikusan egymás után forgatja őket.

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

Amint észreveheti, a kóddal nincs semmi baj, kivéve azt a tényt, hogy hosszúnak tűnik és ezért hajlamos a hibákra.

Természetesen vannak jobb módszerek a fenti kód megírására, a következő szakasz felfedi.

2.9 Tömbök bemutatása

A tömbök változók csoportja lehetnek, amelyek indexszámmal indexelhetők. A következő példa segít jobban megérteni.

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, most nézzük át az egyes szakaszokat, és értsük meg, hogyan működnek valójában.

const int k_numLEDs = 4

A fenti kód meghatározza, hogy mekkora maximális elem van a tömbben. Ez a kód a következő szakaszokban segít abban, hogy minden a tömbön belül legyen megírva, és semmi ne legyen, miután a tömb véget ér.

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

Ebben a következő sorban állítottuk fel a tömb struktúrát. A zárójelben lévő számok a tömbben található elemek számát jelzik. Bár a tényleges mennyiséget meg lehetett volna írni, az állandóként való írás jobban működik. Az értékek általában a zárójelben vesszővel láthatók, és az értékeket a tömbhöz jelölik.

Ha talál egy tömböt, amelynek indexe 0, akkor ez a tömb legelső elemét jelzi, amint azt a code: k_LEDPins is k_LEDPins[0]

Hasonlóképpen az utolsó elem k_LEDPins[3] -ként jelenik meg, mivel a 0 és 3 közötti érték 4.

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

A fenti kód bemutatja a hurok használatát az egyes tömbelemek végigviteléhez és OUTPUTS-ként történő beállításához. Szögletes zárójeleket alkalmazunk az index mellett, hogy elérjük a tömb egyes elemeit.

ha kíváncsi arra, hogy lehet-e használni a # 2-es tűt az # 5-ös rögzítésére tömbök nélkül, a válasz igen, lehetséges. De ebben a példában ez nem történik meg, mert mi nem így tettük. A következő szakaszokban kiküszöbölheti a tömb megközelítést, ha a kiválasztott kimeneti csapok nincsenek egy vonalban.

Előre haladva nézzük meg, mit csinál a következő kódblokk:

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

Itt a kód az egyes LED-eken keresztül halad, és egymás után bekapcsolja őket 100 milliszekundumos réssel vagy késéssel.

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

A fenti kód használata megmutatja, hogy a hurokhoz fordított sorrendben is felhasználható lenne a hurkon.

A k_numLEDs - 1 -tól kezdődik, mert a tömbök nulla indexelésűek. Nem a k_LEDPins[4] pontról indulunk mert ez a tömb céljának átlépését eredményezné.

A kód a> = 0 értéket használja annak ellenőrzésére, hogy a 0. index első elemét ne hagyják ki vagy hagyják figyelmen kívül.

3. fejezet

Mi a bemenet

Tehát megtanultuk, hogyan kell működtetni a dolgokat az Arduino használatával. Ebben a fejezetben megvitatjuk, hogyan lehet érzékelni a valós világot a külső paraméterekből származó bemenetek összekapcsolásával.

3.1 Nyomógombok használata

Mindannyian tudjuk, hogy mi a nyomógomb és hogyan működik. Ez egyfajta kapcsoló vagy gomb, amely a jelet az egyik áramkör fokozatáról a másikra pillanatok alatt összeköti, miközben az lenyomott állapotban van, és feloldásakor megszakítja a jelet.

3.1.1 Egy gomb és egy LED

Csatlakoztatjuk az Arduino-t egy nyomógombbal az Arduino-val a fent bemutatott részletek szerint, és megtanuljuk a beállítás alapvető működését és megvalósítását.

A jelzett nyomógombnak, amelyet mikrokapcsoló nyomógombnak is neveznek, összesen 4 csap van (mindkét oldalon 2 pár). Lökéskor minden csappár belsejében csatlakozik, és lehetővé teszi a kapcsolatot vagy a vezetést rajtuk keresztül.

Ebben a példában csak ezeknek a csapoknak vagy érintkezőknek a párját használjuk, a másik pár irreleváns, ezért figyelmen kívül hagyja.

Folytassuk a következő kód alkalmazását, és ellenőrizzük, hogy működik-e!

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

Találhat itt néhány dolgot, amelyek szokatlannak tűnnek. Találjuk ki őket lépésről lépésre.

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

Az első dolog, amit csinálunk, az a javítás buttonPin mint a BEMENET. Nos, ez elég alap, tudom.

Ezután hozzárendeljük MAGAS hoz BEMENET csap. Csoda, hogyan lehet bármit írni a bemenetre? Persze, érdekes lehet.

Valójában a HIGH hozzárendelése egy Arduino bemenethez egy 20 k Ohmos belső ellenállást kapcsol be BE (egy LOW ezen a csapon kikapcsolja).

Egy másik kérdés, hogy mi lehet a felhúzható ellenállás. Átfogó bejegyzést ismertettem a felhúzható ellenállásokról, amelyet ön tanulja meg itt .

OK, továbblépve, most nézzük meg a fő hurok kódot:

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

Amikor megnyomja a nyomógombot, a vezetékes csap csatlakozik a földhöz, ami a ALACSONY ahhoz a csaphoz. És miközben nem tömörített állapotban ugyanazt a csapot tartják MAGAS vagy + 5V a 20K belső felhúzási ellenálláson keresztül.

Itt azt akarjuk, hogy az Arduino világítson a LED-en, amikor megnyomják a nyomógombot (LOW), ezért HIGH-t írunk a kimenethez a LOW minden egyes válaszához a nyomógombról, miközben nyomva van.

3.1.2 Két gomb és egy LED

Nos, elgondolkodhat azon, hogy a fent bemutatott műveletet Arduino nélkül is meg lehetett volna valósítani. Megértem, azonban ez egy meredek kő, amely megtanulja, hogyan lehet nyomógombot használni Ardunóval.

Eddig a pontig tanulmányoztuk a LED bekapcsolásának (HIGH) vagy a OFF (LOW) kikapcsolásának kódjait.

Most nézzük meg, hogyan lehet a LED fényerejét szabályozni egy Arduino segítségével.

Két módszerrel történhet:

1. Az áram mennyiségének a LED-re korlátozásával
2. Használva PWM vagy impulzusszélesség-moduláció, amelyben a LED táplálása valamilyen kívánt sebességgel be- / kikapcsol, nagyon gyorsan, átlagos megvilágítást eredményezve, amelynek intenzitása a PWM-től függ.

Az Arduino táblában a PWM támogatás a tildével (~) megjelölt csapokhoz érhető el, amelyek a 3., 4,5,9,10 és 11. tűk 500 Hz-en (másodpercenként 500-szor). A felhasználó bármilyen értéket megadhat 0 és 255 között, ahol a 0 nem HIGH-ra vagy nem + 5 V-re vonatkozik, és 255 azt mondja az Arduinónak, hogy mindig HIGH vagy + 5 V-ot kapjon. A parancsok elindításához el kell érnie az analWrite () elemet a kívánt értékkel.

Feltételezheti, hogy a PWM értéke x / 255, ahol x a kívánt érték, amelyet a analogWrite() kapcsolaton keresztül szeretne elküldeni.

Állítsa be az Arduino és más paramétereket a fentiek szerint.

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

Itt találhat 3 sort, amelyek magyarázatra szorulnak.

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

A sor: ledBrightness = constrain(ledBrightness, 0, 255) egy egyedi funkciót mutat be az Arduino-n belül, amelyet a constrain () néven ismerünk.

Ez a belső funkció a következőkhöz hasonló kódot tartalmaz:

int kényszer (int érték, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Az ezt megelőzően megvitatott összes kód a következővel kezdődött: üres , ami azt jelentette, hogy nem adtam vissza semmit (semmis). Míg a fenti kód kezdődik int , ami azt jelzi, hogy egész számot ad vissza. A későbbi szakaszokban még többet megbeszélünk, pillanatnyilag ne felejtsük el, hogy egy egész számnak nincsenek tört részei.

Helyes, tehát ez azt jelenti, a kód: ledBrightness = constrain(ledBrightness, 0, 255) hozzárendeli a ledBrightness to be within the range of 0 and 255

A következő sor analogWrite -t alkalmaz parancsot ad az Arduino-nak, hogy a kiválasztott csapon adja meg a kívánt értékkel a PWM-et.

A következő sor 20 milliszekundumos késleltetést eredményez, ez annak biztosítására szolgál, hogy az ételt ne állítsuk be 50 Hz-nél gyorsabban vagy másodpercenként 50-szer. Az emberek ugyanis sokkal lassabbak lehetnek, mint egy Arduino. Ennélfogva, ha a késleltetés nem történik meg, a program úgy érezheti, hogy az első gomb megnyomásával a LED kikapcsol, a második gomb pedig BE (a megerősítéshez próbáld ki te is).

3.2 Potenciométerek

Haladjunk előre, és tanuljuk meg a használatát potenciométerek Arduino-val.

Ha szeretné tudni, hogy a potenciométer vagy egy edény hogyan működik, olvassa el ezt cikk .

Csatlakoztassa a bemutatott paramétereket az Arduino készülékéhez a fentiek szerint.

Egy banknak 3 terminálja lesz. A középső terminál összekapcsolódik az ANALOG IN 0-val az Arduino-n. A másik két külső kivezetés + 5V és 0V tápvezetékekhez csatlakozhat.

Programozzuk és nézzük meg az eredményeket:

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

Talál egy pár dolgot, amelyek teljesen újnak tűnhetnek, és nem szerepelnek korábbi kódjainkban.

1. Az állandó kPinPot A0-ként van jelölve, ahol A jelentése az analóg csapok egyikének leírására szolgáló parancsikon. Az A0 azonban utal a # 14-es, az A1-re a # 15-re és így tovább, és ezek lehetővé teszik, hogy digitális bemenetekként / bemenetekként használják, ha kifogytak a csapokból egy kísérlethez. De ne feledje, hogy nem használhat digitális tűket analóg csapokként.
2. A sor: ledBrightness = map(sensorValue, 0, 1023, 0, 255) új belső funkciót mutat be Arduino néven térkép(). Ez a szolgáltatás újból kalibrál egy adott tartományból egy másikba, amelyet úgy neveznek térkép (érték, fromLow, fromHigh, toLow, toHigh). Ez elengedhetetlenné válhat, mivel analogueRead 0-1023 közötti értéket ad ki, de az analogWrite képes elfogadni 0-255 értéket.

Gondolhatja, hogy mivel a LED fényerejét változó ellenállással lehet szabályozni, egyszerűen egy edény elegendő lehetett a célhoz, miért használja az Arduino-t. Nos, megint csak ez az alap, annak bemutatása, hogyan lehet egy bankot konfigurálni egy Arduino-val.

Semmi probléma, most olyat fogunk tenni, amit Arduino nélkül nem lehet megtenni.

Ebben a kísérletben meglátjuk, hogyan lehet egy fazék változó ellenállását felhasználni a LED villogási sebességének vagy sebességének szabályozásához.

Itt van a program:

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 A késés elkerülése ()

A fenti kód jól néz ki, de a LED nem tudja ellenőrizni a pot értékét, amíg át nem megy minden teljes ciklust. Hosszabb késések esetén ez a folyamat hosszabbá válik, a felhasználónak meg kell várnia, amíg meglátja a pot válaszát, miközben mozog. Ezt a késleltetést néhány intelligens programozással el lehet kerülni, így a felhasználó minimális késedelem nélkül ellenőrizheti az értéket. Itt a kód.

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

Tehát mi különbözik a fenti kódtól? A különbséget a következő sor adja.

long lastTime = 0

E szakaszig megvitattuk az int változót. Lehet azonban még számos más típusú változó, amelyekhez hozzáférhet. A lista alább olvasható:

Jelenleg csak döntő fontosságú lehet tudni, hogy a viszonylag nagy számok tárolásához a int változó, használhatja a kifejezést hosszú vagy a hosszú int.

Itt egy másik érdekes funkciót láthatunk millisz ().

Ez milliszekundumokban állítja elő az időtartamot, amelyet az Arduino működése során kezdettől fogva dolgozott (ez 50 nap után 0-ra áll vissza). Itt hosszút ad vissza, mert ha visszatért int , előfordulhat, hogy a hosszú ideig történő számlálás nem lehetséges. Tudna pontosan válaszolni, hogy meddig? A válasz 32,767 másodperc.

Ezért a delay () helyett a millis () értékeket ellenőrizzük, és amint a megadott milliszekundumok száma elfogy, megváltoztatjuk a LED-et. Következésképpen azt az időt tároljuk, amelyben utoljára változtattunk utoljára változó, így lehetővé teszi számunkra, hogy bármikor újra ellenőrizzük.

3.3 RGB LED-ek

Eddig egyetlen színű LED-del játszottunk. Bár a LED színe megváltoztatható a LED cseréjével egy másik színnel, de mit szólna az RGB LED-ek használatához a LED színek megváltoztatásához a LED-ek cseréje nélkül?

Az RGB LED alapvetően egy LED, amelynek piros, zöld és kék LED-je van beágyazva és egyetlen LED-be egyesítve. Egy közös vezetéke van, amely a földre vagy a 0V tápvezetékre megy, míg a másik 3 vezetékre diverzifikált PWM pozitív jeleket táplálnak a tervezett színkeverés .

A beállítást az alábbiak szerint vezetheti be:

Lehet, hogy kissé összetettnek tűnik, de valójában a PWM-et használó korábbi LED-vezérlésünk mása.

Itt van egy gyakorlati programkód:

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

A kód feltöltése után csak nézze meg, hogyan hoznak létre a pot beállítások érdekes fényhatást az RGB-n, ez igazi szórakozás lehet.

Megállapítja, hogy amikor mind a 3 edény maximális helyzetbe kerül, fehér szín helyett pirosat fog látni. Ennek oka, hogy a vörös szín a legkiemelkedőbb a 3 szín között, ezért dominál ebben a helyzetben. Ugyanakkor kísérletezhet a funkcióval térkép() , mielőtt végrehajtaná a LED piros részén, ésszerűbb egyensúly megteremtése érdekében.

Hang Arduino-val

Ebben a szakaszban megtudhatjuk, hogyan adhatunk hozzá alaphangot és zenét az Arduino beállításához.

Meglátjuk, hogyan lehet jelet kapcsolni egy csatlakoztatott hangszóróra a kívánt frekvenciával.

Pontosabban egy középső A hangot próbálunk ki, amely egy 440 Hz frekvenciájú hang.

Ehhez egyszerűen eljátszunk egy középső A hangot, és négyzetes hullámmal optimalizáljuk a szinuszjelet.

Azt is kiszámoljuk, hogy egy hangszóró mennyi ideig maradhat BE állapotban, ha bepereljük a képletet:

timeDelay = 1 másodperc / 2 x toneFrequency.

timeDelay = 1 másodperc / 2 x 440

timeDelay = 1136 mikroszekundum

4.1 Csatlakoztassuk az Arduino táblát

4.2 Egyszerű megjegyzés hozzáadása

A funkcióról már tárgyaltunk késleltetés() ahol az egység ezredmásodpercekben (másodperc / 1000) van, azonban talál még egy funkciót delayMicroseconds() ahol az egység mikroszekundumokban van, (milliszekundum / 1000).

A jelenlegi beállításhoz programozunk egy kódot, amely + 5V BE / KI kapcsolást biztosít a kiválasztott, a hangszóróhoz kapcsolt tűn, másodpercenként 440 impulzus sebességgel.

Emlékezzünk vissza, hogy az utolsó beszélgetés során meghatároztuk a tervezett hangjegyzet értékét 1136 mikroszekundum.

Tehát itt van ennek a programja, amely lehetővé teszi, hogy 440 Hz-es hangjegyzetet halljon, amint az arduino-t csatlakoztatott hangszóróval programozza.

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

A fenti alkalmazással hangjegyzet készíthető, ami azt is jelenti, hogy saját választásunk szerint zenét készíthetünk.

A kódból megértjük, hogy az Arduino tartalmaz pár integrált funkciót, amelyek emellett hozzájárulnak a zene létrehozásához.

Az első az hang () amely 2 elemmel működik együtt egy 3. opcionális elemmel együtt, amelyet hang (tű, gyakoriság, időtartam). vagy hang (pin, frekvencia)

Mindkettő az Ön által kijelölt időtartam végrehajtására van kijelölve.

Időszak hiányában a zene a hívásig folytatódik hang () újra végrehajtásra kerül, vagy amíg végre nem hajtja nem egy ().

Ezt késleltetési funkcióval kell megtenni, ha a zene lejátszása az egyetlen alapvető dolog, amelyet megvalósít.

Az időtartam döntő lehet, mivel lehetővé teszi, hogy időt biztosítson a zene lejátszási idejére, így szabadon tehet más dolgokat is. Amint az időtartam lejár, a zene leáll.

A következő funkció nem egy () egyetlen paramétert kezel és leállítja a kiválasztott hangot egy adott hozzárendelt csapon.

Különös figyelmeztetés: Bármikor, amikor hang () funkció megvalósult, a PWM funkció a 3-as és 11-es lábakon leáll.

Ezért amikor a programban hangszóró-mellékletet használnak, ügyeljen arra, hogy ne használja az említett csapot a hangszórókhoz, ehelyett próbáljon ki néhány más csapot a hangszóró-melléklethez.

Rendben, tehát itt van egy program a zene hangszórón történő végrehajtására, bár ez nem egy igazi zene, inkább egy bázis skála C hang.

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

Lehet, hogy a fenti kódban valami újat vett észre, és ez az #define .

Ez a kifejezés úgy működik, mint egy keresési és helyettesítési parancs a számítógépen a fordítás közben.

Amikor megtalálja az elsőt egy szóköz előtt, kicseréli a sor fennmaradó részével (makrókkal).

Tehát ebben a példában, amikor a számítógép lát NOTE_E4 gyorsan felváltja a 330 mennyiséget.

További megjegyzéseket és testreszabást az USB-meghajtón található fájlra hivatkozhat hangmagasságok.h , ahol a legtöbb frekvencia megtalálható az Ön preferenciája szerint.

4.4 Zene funkciókkal

A fenti kód jól néz ki, de úgy tűnik, hogy sokszor megismétlődik. Kellene valami módszer az ismétlések lerövidítésére, nem?

Eddig két alapvető funkcióval dolgoztunk, amelyek az Arduino-hoz tartoznak. Itt az ideje, hogy létrehozzuk saját funkcióinkat.

Minden függvénynek a változó típusával kell kezdődnie, amelyhez társítható. Például a függvény üres olyan típusra utal, amely semmit sem ad vissza, ezért a név érvénytelen. Megjegyzés: Korábbi szakaszainkban már tárgyaltunk egy változó listát, érdemes hivatkozni ezekre.

Következésképpen az adott függvény neve nyitott zárójelet kap '(' amelyet vesszővel elválasztott paraméterek listája követ.

Mindegyik paraméter megkapja a típusát egy névvel együtt, végül pedig egy bezárással ')' zárójel.

Ezek a paraméterek a függvényen belül változók formájában alkalmazhatók.

Lássunk egy példát az alábbiakban, ahol kifejlesztjük az ún ourTone () célja a hang () val vel késleltetés() vonalak, oly módon, hogy a funkció visszatérjen addig, amíg a hang nem fejezi be a hang lejátszását.

Ezeket a funkciókat az előző kódunkban valósítjuk meg, és megkapjuk az alábbi programot, lásd az utolsó sorokat:

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

A funkciók rendkívül hasznosak lehetnek a program könnyebb megértése érdekében.

Az alábbiakban bemutatunk egy példát, ahol két tömb segítségével tudjuk meghatározni a lejátszani kívánt hangválasztást. Az egyik tömb a hangjegyek megtartására, a másik az ütemek megtartására.

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

Az első soron jól látható a #include nyilatkozat. Ennek a kijelentésnek az a feladata, hogy a teljes fájlt felvegye az idézőjelek közé, és a #include nyilatkozat. A szokásos szabályok szerint ezeket szigorúan a program elején kell elhelyezni.

5. fejezet

Hőmérséklet mérése

Csak emlékeztetni, emlékezni a nagy programok teljes írása helyett, mindig bölcs dolog kis kódrészeket írni és elemezni, ami segít a hibák gyors felderítésében.

5.1 Soros monitor

A megbeszélt kódok mindeddig nem tűnnek olyan könnyedén a gyors hibaelhárításhoz. Itt megpróbáljuk megkönnyíteni a nyomon követést és a lehetséges problémák könnyebb megoldását.

Az Arduino rendelkezik egy olyan funkcióval, amely lehetővé teszi a „visszacsatolást” a számítógéppel. Megfigyelhető, hogy a pin0 és pin1 egymás mellett RX és TX jelöléssel vannak ellátva. Ezeket a csapokat egy külön IC követi nyomon az Arduino-n belül, amely frissíti őket az USB-kábel olvasására, miközben a számítógéphez van csatlakoztatva.

Az alábbi szakasz egy teljes értékű programot mutat be, kérjük, menjen át rajta, később megtudjuk a kód új bejegyzéseit. Ez a kód megegyezik a kifejezett 2.2 szakasszal, kivéve azt a tényt, hogy tartalmaz néhány extra adatot annak lehetővé tételéhez, hogy azonosítsuk, mire kódoltuk.

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

Itt két új dolgot lehet azonosítani, egy új sort a beállít() funkció.

Serial.begin(9600)

Ez a vonal egyszerűen kifejezi a Sorozat1 kódot 9600 baud használatával. (itt a sorozat a bitek egymás után küldi, és a baud azt az elküldési sebességet jelenti). Ennek és a soros monitoron belüli értéknek (ezt később megtudjuk) egyenlőnek kell lennie, különben a soros monitor adatai szemetet mutatnak. A 9600, ami a szabvány, kényelmesebbé válik.

A második új bejegyzés a következő

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

Itt a második sor azt sugallja, hogy a soros portból kijövő következő dolog a következő soron kezdődik. Így különbözik a második vonal az ökölvonaltól.

Még egy dolog, amit láthat, az idézőjelek ('). Ezt sztringnek nevezik, amelyet itt csak az állandókhoz hasonlóan fognak használni, mert a témával kapcsolatos további vita túl bonyolult és túl terjedhet.

Rendben, most feltölthetjük a fenti kódot az Arduinoba, és megnézhetjük, mi történik.

Mi történt, úgy tűnik, semmi sem történt, az Arduino # 13-as tűs LED villogott és leállt, míg a Tx LED továbbra is villogott.

Nos, ez azért van, mert a Serial Monitor ablak még nincs javítva.

Az IDE-ben a Serial Monitor mezőre kell kattintania, a fentiek szerint. Ne felejtse el ellenőrizni a jobb alsó sarokban található adatátviteli sebességet, alapértelmezés szerint 9600-nak kell lennie, és meg fog egyezni a kóddal. Ha nem feltétlenül válassza a 9600 lehetőséget.

A következő videoklip elmagyarázza, hogyan történik.

Most lépjünk előre, és tanuljuk meg, hogyan segítheti a fenti Serial Monitor szolgáltatás a feldolgozását a hőmérséklet mérése az Arduino segítségével

Az IC TMP36-ot használjuk hőmérséklet-érzékelőként, amelynek tartománya -40 és 150 Celsius fok között van.

A beállítás alább látható:

A következő kód elindítja a hőmérséklet mérését a TMP36 érzékelő kimenetének kiolvasásával és az ID soros monitorának történő elküldésével.

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
}

Értsük meg a kódot felülről.

float temperatureC = getTemperatureC()

Itt láthatja, hogy felvettük a változó típust úszó.

Ez az egyetlen változótípus, amely az egész számok kivételével mindent tárol (tizedes vagy tört rész nélküli számok).

A lebegő változó pontossága legfeljebb 6-7 számjegy lehet.

A szomszédos kód getTemperatureC() a saját függvényünk, amely matematikailag kiszámítja és átalakítja a TMP36 érzékelő érzékelt feszültségkülönbségét Celsius fokra.

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
}

A kódok következő szakaszában a analogIn() kifejezés óta az 1 és 1023 közötti értékek visszaadásához van hozzárendelve, lehetővé válik számunkra, hogy felmérjük az érzékelő feszültségét úgy, hogy az olvasásunkat megszorozzuk 5-tel, majd elosztjuk 1024-vel.

A TMP36 érzékelő meg van határozva, hogy 0,5 V-ot hozzon létre 0 Celsius-fokon, majd 10mV-ot generál minden egyes Celsius-fok-emelkedéshez.

Itt van a közelítés, amelyet a számításokkal elő tudunk állítani:

Az első függvénynek tekintheti, amely valamilyen értéket ad vissza (vegye figyelembe, hogy az összes többi függvény eddig nem adott értéket, mivel a típus üres ).

Megértheti, hogy ahhoz, hogy értéket kapjon egy függvényből, egyszerűen hozzá kell adnia Visszatérés utána a visszatérni kívánt szám.

Amikor azt mondjuk Visszatérés ez azt jelenti, hogy a függvény választ vagy választ ad vissza, amikor meghívják, és amely alkalmazható egy változóra.

Amikor ezt elküldi a soros monitornak, az olvasás Fahrenheit értékre konvertálódik convertToF ().

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

Ez a függvény felveszi a Celsius-tartományt és átalakítja azt Fahrenheit-re.

A Fahrenheit Celsiusra konvertálásához megvalósítjuk a képletet Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Az LCD összekapcsolása

Most vizsgáljuk meg, hogyan kell egy interfészt összekapcsolni vagy összekapcsolni LCD kijelzö az Arduino-val a szükséges kimenetek vizuális megjelenítéséhez.

Alkalmazásunkban egy 84x48-as grafikus LCD-t fogunk alkalmazni, amelynek vízszintesen 84 pixelje vagy pontjai vannak, és függőleges felbontása 48 pixel. Mivel egy dedikált vezérlő elengedhetetlenné válik az összes LCD számára, a jelenlegi eszköz PCD8544 vezérlő formájában is beépíti.

Ebben az oktatóanyagban a fenti LCD-modult összekapcsoljuk az Arduinóval, és bizonyos rutinokat alkalmazunk a szöveges üzenetek létrehozására a kijelzőn.

A következő ábrán részleteket találhat az LCD interfészéről, valamint egy kicsi 3,3 V feszültségszabályozó . Erre a szabályozóra azért van szükség, mert az LCD-t 3,3 V-os tápellátással működtetik.

Az LCD modulból 8 pinout is látható, a pinout specifikációi a következő táblázatból tanulmányozhatók:

Most nézzük meg, hogyan tudjuk összekapcsolni az LCD-t és a vonatkozó paramétereket az Arduino-val. A részletek az alábbi ábrán láthatók:

5.4 Kommunikáció az LCD-vel

Bár az Arduino-tól lehet bonyolult összefoglalókat írni az LCD-vel való interakcióhoz, inkább megtanuljuk, hogyan kell ugyanezt csinálni a könyvtárak segítségével.

A könyvtárak számos olyan kódot tartalmaznak, amelyek gyorsan alkalmazhatók egy kiválasztott Arduino programhoz.

Ez lehetővé teszi a felhasználó számára, hogy könnyedén hívjon egy funkciót anélkül, hogy komplex kódolási munkálatokat kellene elvégeznie.

5.4.1 Hogyan telepítsük a könyvtárat

Ehhez létre kell hoznia a könyvtárak nevű könyvtárat az Arduino IDE számítógépén, amint azt elmagyarázta itt

5.4.2 Az LCD műveletek végrehajtása

Csakúgy, mint korábbi megközelítésünk, először megvizsgáljuk a teljes kódot, majd megpróbáljuk megérteni az egyes sorok részleteit.

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

A sor tartalmazza a #include kódot

A #include kód utasítja a számítógépet, hogy vegye fel az említett fájlt, és a program összeállítása során cserélje le az #include elemet a fájl tartalmára.

Az #include elem tartalmazhat szögletes zárójeleket, amelyek a könyvtár könyvtárában történő keresést jelzik, vagy alternatívaként idézőjeleket is, amelyek azt jelzik, hogy ugyanabban a könyvtárban keresnek, amelyben a program található.

A következő kódsorok kifejezik az LCD tűket, majd egy új változót írunk:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Itt egy PCD8544 típusú lcd nevű változót fejezünk ki, és utasítjuk a PC-t, hogy az Arduino-hoz társított pinoutjait osztályozza.

Ebben a folyamatban leírjuk a változót a PC-nek azzal az utasítással, hogy a pin clk, din, dc és reset hogyan kapcsolódnak az Arduino-hoz.

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

A vonal lcd.init() inicializálja az LCD működését. Miután ez végrehajtásra került, a következő sor egy kurzort hajt végre a kijelző bal felső sarkában. A következő sor pedig erőfeszítéseket tesz a „Hello, World” üzenet kinyomtatására.

Ez teljesen megegyezik azzal a technikával, amelyben üzeneteket küldtünk a soros monitoron keresztül. Az egyetlen különbség a lcd.print kód használata soros.nyomtatás helyett.

A következő kódblokkot valójában ismétlődőnek hívják.

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

Ennek a sornak a használata lcd.setCursor(0,1) rögzítjük a kurzort a 0. oszlophoz, az 1. sor bal szélén, az LCD kijelző felett.

A következő sor egy parancsikont alkalmaz: lcd.print(millis())

Ha felidézi, hogy együtt dolgoztunk a millis() korábbi kódjainkban itt is alkalmazhattuk volna ugyanezt a kódokon keresztül:

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

Mivel azonban itt nem szerepelnek milliszekundumos periódusok, ezért egyszerűen millis() közvetlenül a lcd.print() .

5.5 Az egész egyesítése

Rendben, most egyesítsük az összes kódot, amelyet fentebb megtanultunk az LCD hőmérsékleti áramkör elkészítéséhez, és nézzük meg, hogyan néz ki:

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

A fenti programban minden normálisnak tűnik, a funkció használata kivételével setCursor () . Ezt arra használják, hogy a szöveget a kijelző közepe felé a lehető legnagyobb mértékben igazítsa.

Nagy! És gratulálok, az Arduino segítségével most beprogramozta a saját kis LCD-hőmérsékletjelzőjét.

Praktikus Arduino alkalmazások

Mivel ezen a ponton átfogóan áttekintettük a különféle programozási technikákat, itt az ideje, hogy néhány hasznos gyakorlati megvalósításra felhasználva átgondoljuk őket.

Kezdjük az érzékelőkkel, és megnézzük, hogyan lehetne használni az érzékelőeszközöket az Arduinóval néhány példakód végrehajtásával.

7.1 Bevezetés az érzékelőkhöz

Ebben az oktatóanyagban megismerhetjük az Arduino-val használható szenzorok sokféleségét. Ide tartozhatnak olyan eszközök, mint az LDR fényérzékelő, a mágneses csarnokhatás-érzékelő, a dőlésérzékelők, a vibrációs érzékelő, a nyomásérzékelő stb.

Kezdjük a. Interfészével fényérzékelő LDR az Arduino-val, az i ábra szerint:

Mint mindannyian tudjuk, az LDR egy fénytől függő ellenállású eszköz, amelynek ellenállása a felszínén bekövetkező környezeti beesés intenzitásától függ.

A fény intenzitása fordítottan arányos az LDR ellenállási értékével.

Itt megtudhatjuk, hogyan lehet ezt a tulajdonságot integrálni az Arduino-val egy hasznos alkalmazás futtatásához:

A teljes programkód az alábbiak szerint vizualizálható:

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

A kódban használt összes paramétert már megtanultuk a tanfolyamunk során, amelyet eddig megtanultunk. A sorokat a vonatkozó szakaszokra hivatkozva ellenőrizheti.

Az értékeket véletlenszerűen választottuk ki, könnyen megváltoztathatja saját preferenciáinak megfelelően.

Dőlésérzékelő

A dőlésérzékelő egy egyszerű eszköz, amely bármely dőlésszög detektálására alkalmas bármely objektumon, ahová telepítve van. A készülék belsejében alapvetően egy fémes golyó van, amely billentéskor egy érintkezõpár fölé gördül, és vezetést okoz ezen érintkezõkön. Ezeket az érintkezőket, amelyek a billenőkapcsoló vezetőiként szűnnek meg, egy külső áramkörrel együtt használják a billenési művelet miatti vezetés detektálására és a kívánt kimeneti alkalmazás aktiválására.

Most nézzük meg, hogy a dőlésérzékelő eszközt fel lehet vezetni. Az alábbi kép ötletet ad a teljes konfigurációról:

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

Ebben a példában az alapértelmezett # 13 tűs LED használatos dőlésjelzőként.

Jól látható, hogy itt van a felhúzható ellenállás, hasonlóan ahhoz, amit a 3.1 szakaszban tettünk. Ezért a LOW kifejezés azt jelzi, hogy a tilt funkció nem vált be.

7.4 Reed kapcsoló relé (miniatűr mágnes aktivált relé)

Most nézzük meg, hogyan lehet egy relekapcsolót vagy egy mágneses mező érzékelőt összekapcsolni az Arduino-val. A nád relé egy olyan kapcsoló, amely akkor mûködik vagy vezet, ha mágneses tér vagy mágnes kerül a közelébe. Alapvetően egy ferromágneses érintkezővel rendelkezik egy miniatűr üvegházban, amelyek a mágneses húzás következtében csatlakoznak vagy lépnek kapcsolatba, amikor a mágnes közvetlen közelében van. Amikor ez megtörténik, az érintkezők kivezetései az érintkezők bezáródása miatt vezetést mutatnak.

Itt is a # 13 tű LED-et használjuk a válasz jelzésére. Csatlakoztathat egy külső LED-et erről a tűről, ha szükséges, korábbi magyarázataink szerint.

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

A kódkifejezéseknek ismerősnek és magától értetődőnek kell lenniük.

7.5 Rezgésérzékelő Piezo átalakítóval

A következő mintaprogramban meglátjuk, hogy a piezo jelátalakító használható rezgésérzékelőként egy LED megvilágítására az Arduino-n keresztül.

A piezoelem tulajdonképpen olyan eszköz, amely rezgést vagy rezgést generál, ha frekvenciát alkalmaznak a kapcsain. Ugyanakkor ugyanaz a piezo használható a fordított eljárásban a elektromos impulzusokat generál a testén alkalmazott rezgésre reagálva. Ez a rezgés lehet kopogás vagy ütés formájában a piezo felületén.

Állítsa be az Arduino és egy piezo elemet a következő ábra szerint

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

A 100-as küszöbértéket csak azért vezetik be, hogy megbizonyosodjon arról, hogy az Arduino csak az eredeti rezgésekre reagál-e ütésekkel, és nem más kisebb rezgésekre, mint például a hangos hangok vagy a kürtök.

Az A5 tű kiválasztása nem kötelező, kiválaszthat bármilyen más analóg bemenetet az Ön preferenciája szerint és a programkódba illesztve.

Servo Motor használata az Arduino-val

A szervomotor egyfajta egyenáramú motor, amelyet pontos szögekbe lehet forgatni, az adott alkalmazás igényeinek megfelelően. Megtehető úgy, hogy egy kiszámított parancsot alkalmaz a motor megfelelő bemeneteire, hogy a motoron 180 fokos tartományon belül pontos forgási vagy fordulási szöget érjünk el.

A szervomotor általában 3 vezetékkel vagy bemenettel rendelkezik. A pozitív vezetékek általában piros színűek, a negatív vagy a földelő vezetékek fekete színűek, amelyek a parancsnoki vezeték vagy a jelzővezeték általában fehér vagy sárga színűek.

Az Arduino a beépített támogató nyelv révén megkönnyíti a szervomotor vezérlését, ami a vezérlést nagyon kényelmessé és ideálissá teszi a szervomotorok számára.

A következő példa bemutatja az alapbeállítási programot a szervomotor vezérlésének az Arduino segítségével történő megvalósításához:

A kód az alábbiakban található:

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

Pár új bejegyzést itt láthatunk. Az egyik, amely megmondja a szervo csatlakoztatott vezetékét, hogy milyen csaphoz van hozzárendelve. A másik az a kód, amely a csapnak 0 és 180 közötti értéket ad meg a szervo forgásszögének meghatározásához.

Következtetés

Az Arduino tantárgy végtelenül hosszú lehet, ezért meghaladhatja a cikk kereteit. Remélem azonban, hogy a fenti oktatóanyagnak minden bizonnyal hozzá kellett volna járulnia az Arduino alapjainak elsajátításához és a fontos paraméterek megértéséhez a különféle példakódok segítségével.

Remélhetőleg több információt időről időre frissíteni lehet itt, amikor csak elérhető.

Addig is élvezze a programozási tanfolyamot, Boldog Arduinoingot neked !!