Arduino funkciók könyvtár. Arduino - irányító üzemeltetők

Ez a szimulátor a Chrome böngészőben a legjobban működik
Nézzük óvatosan Arduino-ra.

Arduino NE. nagy számítógépAmelyhez külső láncok csatlakoztathatók. ATMEGA 328P az Arduino Uno-ban
Ez a fedélzet legnagyobb chipje. Ez a chip programozza a memóriájában tárolt programokat. A programot USB-vel töltheti le arduino használatával. IDE. USB csatlakozó Arduino teljesítményt is biztosít.

Van egy külön tápegység. A táblán két kimenet van, amelyek 5V-ot és 3,3V-ot jeleznek, amelyekre szükség van a hatalom érdekében különböző eszközök. A GND-ként megjelölt névjegyeket is megtalálja, ezek a Föld következtetései (a föld 0b). Az Arduino platformnak 14 digitális következtetése (PIN) is van, amelyek 0 és 13 közötti számokkal vannak jelölve, amelyek külső csomópontokhoz vannak csatlakoztatva, és két magas vagy alacsony (be- vagy kikapcsolás) áll rendelkezésre. Ezek a kapcsolatok kimenetként vagy bemenetként működhetnek, azaz azaz Vagy átszállíthatnak néhány adatot, és kezelhetik a külső eszközöket, vagy adatokat kaphatnak az eszközökről. A táblán lévő következő következtetések A0-A5. Ezek analóg bemenetek, amelyek adatokat kaphatnak különböző érzékelők. Ez különösen kényelmes, ha meg kell mérnie egy bizonyos tartományt, például a hőmérsékletet. Az analóg bemenetek vannak további funkciókamely külön alkalmazható.

Hogyan kell használni hímdíj.

A szekrény szükséges az elemek ideiglenes csatlakoztatásához, ellenőrizze, hogy a készülék hogyan működik, mielőtt összeszednéd.
Az összes alábbi példa a tételre összeszerelve, így gyorsan módosíthatja a diagram módosítását, és újra felhasználhatja az alkatrészeket a forrasztás fagyás nélkül.

Vannak sor lyukak a dumpagolóban, ahol alkatrészeket és vezetékeket helyezhet be. Néhány ilyen lyuk elektromosan kapcsolódik egymáshoz.

A két felső és alsó sor az egész tábla mentén egymás után van csatlakoztatva. Ezeket a rangokat a rendszer táplálására használják. Ez lehet 5V vagy 3,3V, de minden esetben az első dolog, amit meg kell tennie, csatlakoztassa az 5V-ot és a GND-t a dump kártyán, amint az az ábrán látható. Néha ezek a sorkapcsolatok megszakadhatnak a tábla közepén, akkor ha szükséged van rá, akkor csatlakoztathatja őket, amint azt a képen látható.

A fedélzet közepén található maradék lyukakat öt lyukkal csoportosítják. Használják a rendszer részleteit.

Az első dolog, amit a mikrokontrollerünkhöz csatlakoztatunk, egy LED. Az elektromos csatlakozások áramköre látható a képen.

Miért van szükséged egy ellenállás a rendszerben? Ebben az esetben korlátozza az aktuális áramot, amely áthalad a LED-en keresztül. Mindegyik LED egy bizonyos áramra tervezték, és ha ez az áram nagyobb, akkor a LED meghiúsul. Hogy megtudja, hogy a névleges értéknek ellenállás legyen az OHM törvény segítségével. Azok számára, akik nem tudják vagy elfelejtik, a törvény az Ohm azt mondja, hogy a feszültség lineáris függése van. Ezek, annál inkább feszültséget adunk az ellenállásnak, annál nagyobb áramlást folytunk rajta.
V \u003d i * r
Hol V.- az ellenállás különbsége
ÉN.- az ellenálláson keresztüli áram
R.- Ellenállás a megtaláláshoz.
Először meg kell tanulnunk a feszültséget az ellenálláshoz. A legtöbb 3mm vagy 5 mm-es LED, amelyet használni fog, a 3b. Ez azt jelenti, hogy meg kell fizetnünk az ellenállást 5-3 \u003d 2b.

Ezután kiszámítjuk az ellenálláson áthaladó áramot.
A legtöbb 3 és 5 mm-es LED-ek a 20 mA-es áramon teljes fényerőt izzóak. Az áram több, mint ez, lehet, és a jelenlegi alsó ereje csökkenti fényerejüket anélkül, hogy kárt okozna.

Tehát a LED-et az 5V-os láncba szeretnénk bekapcsolni, hogy 20 mA-es áram legyen. Mivel az ellenállás egy láncában minden alkatrész szerepel az ellenálláson is.
Kapunk
2b \u003d 20 mA * r
2b \u003d 0,02a * r
R \u003d 100 ohm
100 ohm Ez a minimális ellenállás, jobb, ha egy kicsit többet használ, mert a LED-ek bizonyos jellemzőkkel rendelkeznek.
BAN BEN ez a példa Használt ellenállás 220 ohm. Csak azért, mert a szerzőnek sok közülük van: Wink :.

Helyezze be a LED-et a fedélzet közepén lévő nyílásokba oly módon, hogy hosszú teljesítménye az ellenállás egyik következtetéseihez kapcsolódik. Az ellenállás második vége 5V-ből van csatlakoztatva, és a második LED kimenet GND-vel van csatlakoztatva. A LED kell világítania.

Kérjük, vegye figyelembe, hogy különbség van a LED csatlakoztatásához. A jelenlegi áramlások hosszabb kimenetről rövidebbek. A diagramban ez képviselhető, hogy az áram a másik oldalra áramlik, ahol a háromszög irányul. Próbáld meg fordítani a LED-et, és látni fogod, hogy nem fog ragyogni.

De hogyan fogja összekapcsolni az ellenállást, egyáltalán nincs különbség. Megfordíthatja, hogy átveszi, vagy megpróbál csatlakozni a LED másik kimenetéhez, nem befolyásolja a rendszer működését. Még mindig korlátozza az áramot a LED-en keresztül.

Anatómia Arduino vázlat.

Az Arduino hívás vázlatos programjai. Két alapvető funkcióból állnak. Funkció beállít. és funkció Hurok.
Ebben a funkcióban megadja az összes alapbeállítást. Milyen következtetéseket fog működni a bemeneten vagy a kimeneten, mely könyvtárakat csatlakoztat, inicializálja a változókat. Funkció Beállít () Csak egyszer kezdődik a vázlat során, amikor a program elindul.
Ez az utóbbi fő funkció beállít (). Valójában ez a program maga is. Ez a funkció végtelen lesz, amíg kikapcsolja a hatalmat.

Arduino villog

Ebben a példában a LED-diagramot az Arduino digitális következtetések egyikéhez csatlakoztatjuk, és bekapcsolja, és letiltja azt a program használatával, valamint számos hasznos funkciót talál.

Ezt a funkciót használják beállít () a program egy része, és az, hogy inicializálja azokat a következtetéseket, amelyeket a bejáratként fog használni (BEMENET) vagyon (Kimenet). Nem tudod olvasni vagy írni az adatokat a PINA-tól, amíg megfelelően telepíti azt pinmode.. Ez a funkciónak két argumentuma van: pinkód- Ez a Pina száma, amelyet használ.

Mód.- Mert a PIN-ot fog működni. A bemeneten (BEMENET) vagyon (Kimenet). A LED gyújtásához jelezzünk egy jelet NAK,-NEK Arduino. Ehhez konfiguráljuk a PIN-kódot a kilépéshez.
- Ez a funkció az állapot beállítására szolgál. (Állapot) Pina. (Pinkód). Két főállapot létezik (általában 3), egy dolog Magas, A fenyő 5V, a másik Alacsony. És a pinea lesz 0b. Ez azt jelenti, hogy meg kell világítanunk a LED-et a Pinea-n, csatlakoztatva a LED-hez, hogy magas szintet állítson be. Magas.

Késleltetés. A program munkáját az MSEK-ben meghatározott időszakra késleltesse.
Az alábbiakban a kód, amely a LED villogását okozza.
// LED BLINK INT LEDPIN \u003d 7; // PIN ARDUINO, amelyhez a VOID SETUP () LED (LEDPIN, kimenet); // Pina Like kimenet telepítése) Void Loop () (Digitalwrite (Ledpin, Magas); // LED késleltetés (1000); // késleltetés 1000 MSEK (1 mp) digitalwrite (Ledpin, alacsony); // kapcsolja ki a késleltetett LED (1000); // várjon 1 másodpercet)

Kis kódok.
Sorok, amelyek "//" -vel kezdődnek Ezekkel a megjegyzésekkel az Arduino figyelmen kívül hagyja őket.
Minden parancs véget ér, ha elfelejtette őket, akkor kapjon hibaüzenetet.

ledpin.- Ez egy változó. A változókat az értékek tárolására szolgáló programokban használják. Ebben a példában változó ledpin. Hozzárendel 7-re, ez a Pina Arduino száma. Amikor a programban Arduino egy változóval rendelkező karakterláncot fog teljesíteni ledpin. A korábban jelzett értéket fogja használni.
Így rögzítés pinmode (Ledpin, kimenet) Hasonló bejegyzések pinmode (7, kimenet).
De az első esetben elegendő ahhoz, hogy megváltoztassa a változót, és minden sorban megváltozik, ahol azt használják, és a második esetben Ön, a változó megváltoztatásához, minden egyes csapatban módosítani kell.

Az első sor jelzi a változó típusát. Az ARDUINO programozáskor fontos mindig kijelenteni a változók típusát. Miközben elég tudni kell Int. A negatív és a pozitív számok bejelentése.
Az alábbiakban a vázlat szimulációja. A rendszer működésének megtekintéséhez kattintson a Start gombra.

A várt módon a LED kialszik, és világít egy másodpercig. Próbálja meg megváltoztatni a késedelmet, hogy hogyan működik.

Több LED-ek vezérlése.

Ebben a példában megtudhatja, hogyan kell több LED-eket kezelni. Ehhez állásba állítsa még 3 LED-t a táblán, és csatlakoztassa azokat az ellenállásokhoz és az Arduino kimeneteihez, az alábbiak szerint.

Annak érdekében, hogy lehetővé tegye és letiltja a LED-eket a fordulóban. Ehhez hasonló programot kell írnia:
// Multi LED villogott LED1pin \u003d 4; INT LED2PIN \u003d 5; int led3pin \u003d 6; int led4pin \u003d 7; Void Setup () (// Pins Pinmode kimenetként (LED1pin, kimenet); Pinmode (LED2pin, kimenet); Pinmode (LED3pin, kimenet); Pinmode (LED4pin, kimenet);) Void Loop () (Digitalwin, High ); // üdvözlő LED-késedelem (1000); // késleltetés 1 sec digitalwrite (LED1pin, alacsony); // excele A késleltetés LED (1000); // késleltetés 1 sec // Ugyanaz a másik 3 LED digitalwrite ( LED2pin, magas); // LED késleltetés (1000); // késleltetés 1 sec digitalwrite (LED2pin, alacsony); // excele A késleltetés LED (1000); // késleltetés 1 sec digitalwrite (LED3pin, magas); // Slash LED késleltetés (1000); // késleltetés 1 sec digitalwrite (LED3pin, alacsony); // kiterjeszti a késleltetett LED-et (1000); // késleltetés 1 sec digitalwrite (LED4pin, magas); // LED késleltetés LED (1000); // Késleltetés 1 sec digitalwrite (LED4pin, alacsony); // kiterjeszti a késleltetést (1000); // késleltetés 1 mp)

Ez a program tökéletesen működik, de ez nem a legreálibb megoldás. A kódot módosítani kell. Annak érdekében, hogy a program működjön, mivel az idő alatt egy designt alkalmazunk.
A ciklusok kényelmesek, ha többször meg kell ismételnie ugyanazt a műveletet. A fent tartott kódban megismételjük a vonalakat

Digitalwrite (LED4pin, magas); Késedelem (1000); Digitalwrite (LED4pin, alacsony); Késedelem (1000);
Teljes vázlat kód a mellékletben (Letöltések: 1384)

LED fényerő beállítása

Néha meg kell változtatnia a LED-ek fényerejét a programban. Ezt a parancs segítségével lehet elvégezni. analogwrite () . Ez a parancs gyorsan magában foglalja és kikapcsolja a LED-et, hogy a szem nem látja ezt a villogást. Ha a LED félidő be van kapcsolva, és a fele kikapcsol, vizuálisan úgy tűnik, hogy a fényereje felét ragyogja. Ezt impulzus modulációnak (PWM vagy pwm angolul) hívják. A PWM gyakran érvényes, mivel egy digitális kód segítségével "analóg" komponens vezérelhető. Nem minden Arduino következtetései alkalmasak e célokra. Csak azokat a következtetéseket, amelyekről az ilyen megjelölés húzódik " ~ ". Látni fogja a 3,5,6,9,10,11 kimenetek mellett.
Csatlakoztassa az egyik LED-eket a PWM egyik következtetéseivel (a szerző megkötése 9). Most futtassa a LED villogását, de először módosítsa a parancsot digitalwrite () a analogwrite (). analogwrite () Két érve van: az első a kimeneti szám, a PWM (0-255) második értéke, a LED-ekre való hivatkozással a lumineszcencia fényereje lesz, és az elektromos motorok forgó sebessége. Az alábbiakban egy példa kód a LED különböző fényerejére.
// Változtassa meg az INT LEDpin \u003d 9; // ehhez a kimenethez, a Void Setup (Pinmode (Ledpin, Kimenet); // PIN-kódot a kimenethez) Void Loop () (ANALOGWRITE (LEDPIN, 255); / Teljes fényerő (255/255 \u003d 1) késleltetés (1000); // szünet 1 sec digitalwrite (Ledpin, alacsony); // Kapcsolja ki a késleltetett LED (1000); // 1. szünetel 1 sec analogwrite (Ledpin, 191); // fényerő a 3/4 (191/255 ~ \u003d 0,75) késleltetés (1000); // 1 sec digitalwrite (Ledpin, alacsony); // Kapcsolja ki a késleltetett LED-et (1000); // PAUSE 1 SEC analogwrite ( Ledpin, 127); // fél fényerő (127/255 ~ \u003d 0,5) késleltetés (1000); // 1 sec digitalwrite (Ledpin, alacsony); // Kapcsolja ki a késleltetett LED-et (1000); // Pause 1 sec Analogwrite (Ledpin, 63); // A fényerő negyede (63/255 ~ \u003d 0,25) késleltetés (1000); // 1 sec digitalwrite (Ledpin, alacsony); // Kapcsolja ki a késleltetési LED-et (1000); // szünet 1 s)

Próbálja meg megváltoztatni a PWM értékét a csapatban analogwrite ()Hogy lássuk, hogyan befolyásolja a fényerőt.
Ezután megtudhatja, hogyan állítsa be a fényerőt simán nullára. Természetesen 255 alkalommal másolhat egy kódot
Analogwrite (ledpin, fényerő); Késleltetés (5); // rövid késleltetés fényerő \u003d fényerő + 1;
De te magad megérted - ez nem lesz praktikus. A leginkább a korábban használt ciklus használata.
A következő példa két ciklust használ, az egyik a 255-től 0-ig terjedő fényerő csökkentésére
mert (int fényerő \u003d 0, fényerő \u003d 0, fényerő -) (analógírás (ledpin, fényerő); késleltetés (5);)
késleltetés (5) A növekedési ütem lassítására és a fényerő csökkentésére használják 5 * 256 \u003d 1280 ms \u003d 1,28 mp.)
Az első sorban használt " fÉNYERŐSSÉG-"Annak érdekében, hogy a fényerő értéke 1-re csökkenjen, minden alkalommal, amikor a ciklust megismételjük. Kérjük, vegye figyelembe, hogy a ciklus mindaddig működik, amíg fényerő\u003e \u003d 0. A jel megváltoztatásával > A jel >= A fényességtartományban 0-at bekapcsoltuk. Ezt a vázlatot az alábbiakban modellezik. // zökkenőmentesen változtatja meg a fényerőt INT LEDpin \u003d 9; // A Void beállítás (Pinmode (Ledpin, kimenet); // PIN inicializálás) void hurok () (// simán növeli a fényerőt (0-255) a (int fényerő \u003d 0, fényerő \u003d 0; fényerő -) (analógírás (Ledpin, fényerő); késleltetés (5);) késleltetés (1000); // 1 sec // zökkenőmentesen csökkentjük a fényerőt (25-0) fényerő \u003d 255, fényerő\u003e \u003d 0, fényerő -) (analógírás (ledpin, fényerő); késleltetés (5);) késleltetés (1000); // 1 sec-re várunk)
Ez nem túl jó, de az ötlet érthető.

RGB LED és Arduino

Az RGB LED valójában három különböző színű LED egy esetben.

Beleértve a különböző fényerővel rendelkező különböző LED-eket, kombinálhat és különböző színeket kaphat. Az Arduino esetében, ahol a fényerő-fokozatok mennyisége 256 256 ^ 3 \u003d 16581375 lehetséges színeket kap. Valójában minden bizonnyal kevesebb lesz.
LED, amelyet egy közös katód használunk. Azok. Mindhárom LED-t konstruktívan összekapcsolják a katódok egy következtetésére. Ezt a következtetést a GND kimenethez csatlakoztatjuk. A fennmaradó következtetések korlátozó ellenállások révén kell kapcsolódniuk a PWM következtetéseihez. A szerző a 9-11 következtetéseket használta. Rendben, az egyes LED-rel külön ellenőrizhető. Az első vázlaton látható, hogy az egyes LED külön-külön engedélyezhető.

// RGB LED - teszt // PIN-kapcsolatok int Red \u003d 9; INT Green \u003d 10; Int blue \u003d 11; VOID SETUP () (PINMODE (piros, kimenet); Pinmode (kék, kimenet); Pinmode (zöld, kimenet);) Void hurok () (// bekapcsolása / kikapcsolása a piros LED digitalwrite (piros, magas); késleltetés ( 500); Digitalwrite (piros, alacsony); késleltetés (500); // bekapcsolja a zöld LED digitalistát (zöld, magas); késleltetés (500); Digitalwrite (zöld, alacsony); késleltetés (500); // / Letiltja a kék digitalwrite LED (kék, magas); Késleltetés (500); Digitalwrite (kék, alacsony); Késleltetés (500);)

A következő példa parancsokat használ analogwrite () És hogy különböző véletlenszerű fényerő értékeket kapj a LED-ek számára. A véletlenszerűen változó különböző színeket fogják látni.
// RGB LED - véletlenszerű színek // PIN-kapcsolatok int Red \u003d 9; INT Green \u003d 10; Int blue \u003d 11; Void Setup () () (PinMode (piros, kimenet); Pinmode (kék, kimenet); Pinmode (zöld, kimenet);) Void hurok () (// Válasszon véletlenszerű szín analógot (piros, véletlen (256)); analógwrite ( Kék, véletlenszerű (256)); analogwrite (zöld, véletlen (256)); késleltetés (1000); // Várjon egy másodpercet)

Véletlen (256)- Visszatérés véletlen szám 0 és 255 között.
A csatolt vázlatfájlban, amely bemutatja a színek sima átmenetét piros és zöld, majd kék, piros, zöld stb. (Letöltések: 381)
A vázlat példája működik, de sok ismétlődő kód van. Egyszerűsítheti a kódot a saját írásával segédfunkcióamely simán megváltoztatja az egyik színt a másikra.
Így fog kinézni: (Letöltések: 414)
Nézzük meg, hogy meghatározzuk az alkatrészek funkcióját. A funkciót hívják fADER. És két érve van. Mindegyik argumentumot vesszővel elválasztja, és a funkció meghatározásának első sorában kijelentette a funkció első sorában: void FADER (INT COLOR1, INT COLOR2). Látod, hogy mindkét argumentumot bejelentették int., és hozzárendelnek neveket color1. és color2. Mint feltételes változók a funkció meghatározásához. Üres. azt jelenti, hogy a funkció nem ad vissza semmilyen értéket, egyszerűen végrehajtja a parancsokat. Ha meg kellett volna írni egy olyan funkciót, amely visszaadta a szorzás eredményét, így úgy néz ki, mint ez:
Int multiplikátor (int number1, int number2) (int termék \u003d szám1 * szám2; visszatérő termék;)
Kérjük, vegye figyelembe, hogyan jelentettük be a típusát int. A visszaadási érték típusát helyett
Üres..
A funkció belsejében az előző vázlatban már használt csapatok csak a következtetések számát helyettesítették color1. és color2.. A funkciót hívják fADER., az érvei kiszámításra kerülnek color1 \u003d piros és color2 \u003d zöld.. Az archívum teljes vázlata funkciók használatával (Letöltések: 313)

Gomb

A következő vázlaton egy gombot használnak a normál nyitott érintkezőkkel, rögzítés nélkül.

Ez azt jelenti, hogy amíg a gombot nem nyomja meg, az áram nem megy keresztül, és a felszabadulás után a gomb visszatér az eredeti pozícióba.
A diagramon a gomb mellett egy ellenállást használnak. Ebben az esetben nem korlátozza az áramot, és a "Húzza fel" a gombot a 0b (GND). Azok. Miközben a gomb nincs megnyomva az Arduino kimeneten, amelyhez csatlakoztatva van, alacsony szinten lesz. A 10 COM-ban használt ellenállás.

// meghatározza az INT Gombpin \u003d 7 gombot; VOID SETUP () (PINMODE (gombpin, bemenet); // inicializálja a csapokat a serial.begin (9600) bemenethez; // inicializálja a soros portot) Void Loop () (IF (DigitalRead (gombpin) \u003d\u003d magas) (// Ha a gombot a serial.println ("préselt") nyomja meg ("préselt"); // Megjeleníti a "préselt" felirat (serial.println ("unprinted"); // egyébként "unpressed")))
Ebben a vázlatban több új csapat.
- Ez a parancs elfogadja a magas értéket (magas szintű) és alacsony (alacsony), amely kimenve, hogy ellenőrizzük. Előre beállítva () Ezt a kimenetet a bemenetre kell konfigurálni.
; // Ha a gombpin a kimeneti szám, ahol a gomb csatlakoztatva van.
A soros port lehetővé teszi, hogy Arduino üzeneteket küldjön egy számítógépre, míg a vezérlő maga végrehajtja a programot. Ez hasznos a program hibakereséséhez, üzenetek küldéséhez más eszközökre vagy alkalmazásokra. Az adatátvitel egy soros porton keresztül történő engedélyezéséhez (UART vagy UART név) segítségével inicializálni kell a beállítás ()

Serial.begin () Csak egy argumentum van az ARDUINO és a számítógép közötti adatátviteli sebesség.
A Sketch egy parancsot használ, amely üzenetet jelenít meg a képernyőn az Arduino IDE (Tools \u003e\u003e soros monitor).
- A tervezés lehetővé teszi, hogy ellenőrizze a program előrehaladását, a dohányzás több csekket egy helyen.
Ha (ha) a digitallead visszatér magas, akkor a monitoron megjelenik a "préselt" szó. Egyébként (máskülönben) a "préselt" szó jelenik meg a monitoron. Most megpróbálhatja be- és kikapcsolni a LED-et a gomb megnyomásával.
// gomb Nyomja meg az észlelést a LED kimeneten INT gombpin \u003d 7; int ledpin \u003d 8; Void Setup () (Pinmode (gombpin, bemenet); // Ezúttal beállítjuk a nyomógombot bemeneti pinmódként (Ledpin, kimenet); serial.begin (9600);) Void Loop () (IF (DigitalRead (gombpin) \u003d \u003d Magas) (digitalwrite (ledpin, magas); serial.println ("préselt");) más (digitalwrite (ledpin, alacsony); serial.println ("unpressed");)

Analóg bemenet.

analógad. Lehetővé teszi, hogy olvassa el az adatokat az egyik analóg Arduino kimenetből, és megjeleníti a 0 (0b) és 1023 (5V) közötti értéket. Ha az analóg bemenet feszültsége 2,5V, akkor nyomtatásra kerül 2,5 / 5 * 1023 \u003d 512
analógad. Csak egy argumentum van egy analóg bemeneti szám (A0-A5). A következő vázlatot potenciométerrel feszültség-olvasási kódot biztosít. Ehhez csatlakoztasson egy váltakozó ellenállást, extrém kimeneteket az 5V és a GND csapokhoz, és az A0 bemenet átlagos kimenete.

Futtassa a következő kódot, és nézze meg a soros monitort, hogyan változik az értékek az ellenállás fogantyújának forgásától függően.
// Analóg bemenet Int Potpin \u003d A0; // Ehhez a PINA-hoz, az üres beállítási () potenciométer központi kimenete ehhez (// Az analóg PIN-kód alapértelmezés szerint csatlakozik a bemenethez, így a soros inicializálásra nincs szükség sorozatosságra. kezdődik (9600);) void hurok () (int potval \u003d analograad (potpin); // Potval a 0 és 1023 serial.println (Potval) közötti szám;)
A következő vázlat ötvözi a nyomógomb tesztjét és a LED fényerejének kikapcsolási vezérlését. A LED bekapcsolja a gombot, és szabályozza a ragyogás fényerejét potenciométer lesz.
// gomb Nyomja meg az észlelést LED kimenettel és változó intenzitás Int gombpin \u003d 7; int ledpin \u003d 9; Int potpin \u003d A0; Void Setup () (Pinmode (buttonpin, bemenet); Pinmode (Ledpin, kimenet); serial.begin (9600);) Void Loop () (IF (DigitalRead (gombpin) \u003d\u003d magas) (// Ha gomb megnyomja az analóg \u003d Analógad (potpin); int Scaledval \u003d Map (analóg, 0, 1023, 0, 255); analógwrite (Ledpin, Scaledval); // Forgassa a LED-et a pot serial.println intenzitásával ("préselt");) (Digitalwrite (Ledpin, Alacsony); // kapcsolja ki, ha a gomb nem prasedn serial.println ("unpressed");)

Minden programozási nyelvnek van egy olyan vezérlőparancsok száma, amely ugyanazon kódot (ciklus) többszörös végrehajtást biztosít, és kiválasztja a megfelelő kódfragmenst (feltételeket) és az aktuális kódfragmentum kilépésének utasításai.

Az ARDUINO-IDE a C / C ++ -ból kölcsönzött a szükséges ellenőrzések nagy részében. Szintaxisuk megegyezik a C. alatt, mi a két szóban leírjuk a szintaxisukat.

Ha az üzemeltető

Az IF operátor lehetővé teszi a program konkrét fragmentumának elvégzését, az adott állapot vizsgálatának eredményétől függően. Ha az állapot végrehajtásra kerül, akkor a programkód végrehajtásra kerül, ha az állapot nincs végrehajtva, a programkód hiányzik. Az IF parancs szintaxisa a következő:

Ha (állapot) (utasítás1, oktatás2;)

Az állapot bármely, a függvény által visszaküldött változó vagy érték összehasonlítása. A feltételek fő kritériuma, ha a válasz mindig vagy igazság (igaz) vagy hamis (hamis) kell lennie. Példák az IF operátor feltételeire:

Ha (A! \u003d 2) () ha (x<10) { } if(znak==’B’) { }

Az állapoton belül kitűzött zárójelben a kódot végezheti.

Azok az emberek, akik tanulmányozni kezdnek a programozást, gyakran hibáznak, a megadott változó értékét egy jel "\u003d" segítségével. Az ilyen bejegyzés egyértelműen jelzi a változó értékének hozzárendelését, és ezért az állapot mindig "igaz", azaz fut. Ellenőrizze, hogy a változó egyenlő egy adott értékkel, mindig a kettős jelet jelölje meg (\u003d\u003d).

Feltételként használhatja a funkció funkcióját, például:

Ha (init ()) (serial.print ("OK");)

A fenti példát az alábbiak szerint hajtjuk végre: Az első lépésben az init () funkciót hívják. Ez a szolgáltatás olyan értéket ad vissza, amelyet "igaz" vagy "FALSE" -ként értelmeznek. Az összehasonlítás eredményétől függően az "OK" szöveg kerül elküldésre, vagy semmi sem kerül elküldésre.

Ha ... más operátor

Meghosszabbított, ha az üzemeltető olyan, ha ... más operátor. Biztosítja az egy kódfragmens végrehajtását, ha az állapotot elvégzik (igaz), és végrehajtja a második kódfragmenst, ha az állapot nem történik (hamis). Szintaxis operátor Ha .... más úgy néz ki, mint ez:

Ha (állapot) (// Team a) más (// B csapat)

Az "A" parancsok csak akkor kerülnek végrehajtásra, ha az állapot végrehajtásra kerül, a "B" parancs végrehajtásra kerül, ha az állapot nincs végrehajtva. Az "A" és a "B" parancs egyidejű végrehajtása lehetetlen. A következő példa megmutatja, hogyan kell használni a szintaxist, ha ... más:

Ha (init ()) (serial.print ("ok");) más (serial.print ("hiba");)

Hasonlóképpen ellenőrizheti a funkció helyességét, és tájékoztathatja a felhasználót.

A szokásos gyakorlat a feltételek megtagadása. Ez annak köszönhető, hogy a végrehajtott funkció helyesen visszaadja a 0 értéket, és a funkció, amely valamilyen oknál fogva helytelenül dolgozott, nem nulla értéket ad vissza.

Egyszerűen magyarázata az ilyen "életet az élet" egyszerű. Ha a funkció helyesen történik, akkor ez az egyetlen információ, amire szükségünk van. Hiba esetén néha szükséges megérteni, hogy mi történt rosszul, miért nem teljesül a funkció. És itt vannak, a számok eltérnek a nullától a mentésre, azaz digitális kódok használatával meghatározhatjuk a hiba típusát. Például az 1 probléma az érték olvasása, 2 - nincs hely a memóriában vagy a lemezen, stb.

Az utolsó módosított példában azt mutatjuk be, hogyan hívhat olyan funkciót, amely megfelelő végrehajtással visszatér:

Ha (! Init ()) (serial.print ("ok");) más (serial.print ("hiba");)

Operátorkapcsoló tok.

Az IF utasítás lehetővé teszi, hogy csak egy állapotot ellenőrizze. Néha szükség van az egyik művelet végrehajtására a visszaküldött vagy olvasási értéktől függően. Ehhez a többszörös kiválasztó operátor több kapcsoló. A Switch Command Syntax az alábbiakban látható:

Kapcsoló (var) (1. eset: 1: // Var \u003d 1 szünet utasítása; 2: // Var \u003d 2-es utasítás; alapértelmezett: // alapértelmezett utasítás (ha a var különbözik az 1. és 2. \\ t

A VAR változó értékétől függően az utasításokat bizonyos blokkokban végezzük. Az esettanulmány-címke a megadott érték blokkjának megkezdését jelenti. Például az 1. eset: azt jelenti, hogy ez a készülék az egyik változó VAR értékének értékére történik.

Minden blokkot a Break parancs segítségével kell kitölteni. Megszakítja a kapcsoló üzemeltető további végrehajtását. Ha a Break parancs hiányzik, akkor az utasításokat a későbbi blokkokban hajtják végre a Break parancsra. Az alapértelmezett címke nem kötelező, mint az IF parancsban. Az alapértelmezett blokkban található utasításokat csak akkor hajtják végre, ha a var variable változó értéke nem alkalmas bármilyen sablonra.

Gyakran előfordul, hogy ugyanazokat az utasításokat több értékre kell elvégezni. Ez az alábbiak szerint érhető el:

Kapcsoló (x) (x) (1: // x \u003d 1 szünet utasításai; 2. eset: 2. eset: 3. eset: 5: // x \u003d 2 vagy 3 vagy 4 szünet utasításai; 4: // x \u003d 4-es utasítás ; 6. eset: // utasítások x \u003d 6 szünet; Alapérték: // alapértelmezett utasításokat (ha x különbözik az 1,2,3,4,5,6))

Az x változó értékétől függően elvégezhető a megfelelő utasítások. REPETITION CASE 2: 3. eset: 5. eset: 5. eset: tájékoztatja a fordítót, hogy ha az X változó értéke 2 vagy 3 vagy 5, akkor ugyanazt a kódfragmenst végeznek.

Operátor

Az üzemeltetőt több azonos kódot használnak. Gyakran szükséges, hogy ugyanazokat az utasításokat csak bizonyos változó értékének megváltoztatásával kell elvégezni. Ehhez a ciklus tökéletes. A parancs szintaxisa a következő:

Int i; mert (i \u003d 0; i<10;i++) { // инструкции для выполнения в цикле }

Az első utasításban idézett első paraméter a változó kezdeti értéke. Egy másik elem az, hogy ellenőrizze a ciklus végrehajtásának folytatásának feltételeit. A ciklust az állapot elvégzéséig végezzük. Az utolsó elem a változó értékének változása. Leggyakrabban növeljük vagy csökkentjük értékét (ha szükséges). Ebben a példában a ciklusban található utasításokat i \u003d 0 ... 9-en végezzük.

Gyakran a ciklusban használt változó az ibid.

Mert (int i \u003d 0; i<10;i++) { // инструкции для выполнения в цикле }

A későbbi ciklus lépések kiszámításához használt változó lehet használni, hogy a megfelelő paraméterekkel ellátott funkciót hívjon.

Mert (int i \u003d 10, i\u003e 0; i-) (serial.print (i); // számok 11,9,8,6,5,5,4,3,2,1 fognak jönni)

Keréküzemeltető

A ciklus ideális, ahol kiszámítani szeretnénk. Olyan helyzetben, ahol bizonyos műveleteket kell végrehajtania egyetlen esemény eredményeként, amely nem feltétlenül kiszámítható (például arra várjuk, hogy a gomb megnyomja a gombot), akkor használhatjuk az utasításokat, amelyek végrehajtják a kezelőblokkot amíg az állapot elvégzése. Az egész operátor szintaxis így néz ki:

Míg (állapot) (// végrehajtási utasítások blokkja)

Fontos, hogy az állam érvényesítése a ciklus elején történjen. Megtörténhet, hogy az utasítások belülről kerékciklus Soha ne hajtsa végre. Ezenkívül végtelen ciklust hozhat létre. Lássunk két példát:

Int x \u003d 2; Míg (x\u003e 5) (serial.print (x);) -------------- int y \u003d 5; Míg (y\u003e 0) (serial.print (y);)

Az első olyan operátorok blokkja, amely a míg a benne található, soha nem lesz befejezve. Az X változó kettővel számít, és nem lesz több 5. A második példában végtelen ciklussal foglalkozunk. Az "Y" változó időtartama 5, azaz nulla. A cikluson belül nincs változás az "Y" változóban, így a ciklus soha nem lesz befejezve.

Ez egy gyakori hiba, amikor elfelejtjük a ciklus befejezését okozó paraméter megváltoztatását. Az alábbiakban két helyes példa van a míg ciklus alkalmazására:

Int x \u003d 0; Míg (X.<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

Az első példában gondoskodtunk az állapotban ellenőrzött változó értékének megváltoztatásáról. Ennek eredményeként a ciklus valaha is befejeződik. A második példában egy végtelen ciklust szándékosan létrehoztak. Ez a ciklus megegyezik az Arduino IDE hurok () függvényével. Ezenkívül a ciklus belsejében egy tesztet írtak be, miután végrehajtották a ciklust a Break parancs elvégzésével.

Az üzemeltető ... miközben

Akár a ciklus is ... a ciklus közben. A szintaxis mellett az állapot ellenőrzési helye jellemzi. Abban az esetben, ha a feltételek végrehajtása az utasításblokk végrehajtása után történik. Ez azt jelenti, hogy a ciklusú testület utasításainak blokkját legalább egyszer hajtják végre. Az alábbiakban az alábbi szintaxis a ... míg a parancs:

Do (// utasítás blokk), míg (állapot)

Minden, ami az üzemeltető, az üzemeltető is érvényes ... míg. Az alábbiakban egy példa a ciklus használatára ... Míg:

Int x \u003d 10; do (// utasítások blokkja x-;), míg (x\u003e 0); -------------- Do (// Ha utasításblokk (állapot) szünet;) míg (igaz);

Operátorszünet

A szünet kezelő lehetővé teszi, hogy kilép a ciklus (do ... while, for, while), és kilép a Switch opciót. A következő példában fontolja meg a törési parancs végrehajtását:

Mert (i \u003d 0; i<10;i++) { if(i==5) break; Serial.print(i); }

A ciklust 0 és 9 közötti számok esetén kell végrehajtani, hanem az 5-ös számok esetén egy állapot fut, amely futtatja a szünetelállítót. Ez a ciklus kimenetéhez vezet. Ennek eredményeképpen csak 0,1,2,3,4 számokat küldünk a soros portra (serial.print).

Folytassa az üzemeltetőt

A folytonos üzemeltető a ciklus utasításainak végrehajtásának megszüntetését okozza (Do ... míg, míg, míg) az aktuális értékre és a következő ciklus lépésre történő átmenetre. A következő példa megmutatja, hogyan működik a folytatás:

Mert (i \u003d 0; i<10;i++) { if(i==5) continue; Serial.print(i); }

Nem nehéz észrevenni, a ciklus 0-ról 9-re lesz kitöltve az 5-ös értékre, a Folyamatban a Continue parancs végrehajtásra kerül, amelynek eredményeképpen a parancs teljesülése után befejező utasítások teljesülnek. Ennek eredményeként a 0,1,2,3,4,6,7,8,9 számot a soros porthoz (serial.print) küldjük.

Üzemeltető visszatér

A visszatérési utasítás befejezi az úgynevezett funkció végrehajtását, és visszaadja az adott típus értékét. Paraméterként megadhat egy bizonyos típusú számot, karaktert vagy változóat. Fontos, hogy a visszatérési érték megfelel-e a megadott funkció típusának. A következő példa bemutatja a visszatérési nyilatkozat használatát:

INT Checksensor () (ha (analogread (0)\u003e 400) (// analóg bemeneti visszaadása 1; // az értékeknél több mint 400 értéket ad vissza 1 más (0, // mások visszatérése 0))

Amint láthatja, egy funkcióban több visszatérő operátort használhat, de csak egyikük mindig működik. Megengedhető, hogy a visszatérő operátor paraméter nélkül használható. Ez lehetővé teszi a funkció korai megszüntetését, amely nem ad vissza semmilyen értéket.

Void_name_name () (utasítás1, ha (x \u003d\u003d 0) visszatér; utasítás2; utasítás3;)

A fenti példában az utasítás1 mindig elvégez, ha a funkciót hívják. Az utasítás végrehajtása és az utasítások3 az IF parancs eredményétől függ. Ha az állapot végrehajtása (TRUE), akkor a visszatérési parancs végrehajtásra kerül, és a funkció befejezi a munkát.

Abban az esetben, ha a feltétel nem teljesül, a RETURN parancs szintén nem hajtották végre, hanem utasítások végrehajtásra kerülnek. Instructions2 és instruction3, majd a függvény befejezi a működését.

Goto operátor

Az ideológiai megfontolásokból ki kell hagynia ezt a leírást ... A GOTO operátor olyan parancs, amelyet nem szabad használni a hagyományos programozásban. Ez a komplikáció kódot emeli, és rossz szokás a programozásban. Javasoljuk, hogy ne használja ezt a parancsot a programjaiban. Ennek köszönhetően, hogy a Goto az Arduino.cc webhelyén található hivatalos dokumentációban rövid leírást adunk. Goto parancs szintaxis:

.... Goto metka; // Menj a karakterláncra a "Metka" felirat ... ... .... .... Metka: // címke, amellyel a program továbbra is működik ...

A parancs lehetővé teszi a jelzett címkére való átmenetet, azaz a program helyére.

Ez a lecke minimális ismereteket ad az ARDUINO SYSTEMS programozásához a C-ben. Csak megtekintheti és további referenciainformációkat használhat. Azok, akik a C más rendszerekben programoztak, kihagyhatja a cikket.

Ismétlem, hogy ez a minimális információ. Mutatók, osztályok, stringváltozók stb. a későbbi leckékben adják meg. Ha valami érthetetlen, ne aggódjon. További leckékben sok példa és magyarázat lesz.

Az Arduino program szerkezete.

Az Arduino program szerkezete meglehetősen egyszerű, és a minimális kiviteli alak a telepítő () és a hurok () két részéből áll.

void Setup () () () () (

void hurok () () () (

A Beállítás () függvény egyszer történik, amikor bekapcsolja a vezérlő áramát vagy kisülését. Általában a változók kezdeti beállításaiban fordul elő. A funkciónak jelen kell lennie a programban, még akkor is, ha nincs semmi.

A beállítás () befejezése után a vezérlés a hurok () függvénybe kerül. Végtelen ciklusban (a göndör zárójelben) rögzíti a testében rögzített parancsokat. Valójában ezek a csapatok és a vezérlő összes algoritmikus cselekedeteit.

Kezdeti szintaxisszabályok C.

; pontosvessző A kifejezések tartalmazhatnak sok szóközt, string portokat. A kifejezés befejezése jele a "pont egy vesszővel" szimbólummal.

z \u003d x + y;
z \u003d X.
+ Y;

() Ábra zárójelek Határozza meg a funkciót vagy a kifejezéseket. Például a Setup () és a hurok () függvényekben.

/ * ... * / Comment BlockGyőződjön meg róla, hogy bezárja.

/ * Ez egy megjegyzés blokk * /

// egysoros megjegyzés, nem szükséges bezárni, érvényes a vonal végéig.

// ez egy sor megjegyzés

Változók és adattípusok.

Változó egy cella véletlen hozzáférési memóriamilyen információkat tárolnak. A program változókat használ a közbenső számítási adatok tárolására. Számításokhoz, különböző formátumokból származó adatok, különböző bit, így a nyelvű változók a következő típusok vannak.

Adattípus	Bit	Számválaszték
boolean.	8	igaz hamis
char.	8	-128 … 127
aláíratlan char.	8	0 … 255
byte	8	0 … 255
int.	16	-32768 … 32767
aláíratlan int.	16	0 … 65535
szó.	16	0 … 65535
hosszú.	32	-2147483648 … 2147483647
aláíratlan hosszú.	32	0 … 4294967295
rövid	16	-32768 … 32767
úszó.	32	-3.4028235+38 … 3.4028235+38
kettős.	32	-3.4028235+38 … 3.4028235+38

Az adattípusok a számítások, az adatformátumok stb. Kívánt pontossága alapján vannak kiválasztva Nem például egy 100-ig tartó számláló esetében válassza a Típus hosszú lehetőséget. Ez fog működni, de a művelet több adatmemóriát és programot vállal, több időt igényel.

A változók bejelentése.

Az adattípust jelzi, majd a változó nevét.

int x; // Az X típusú változó bejelentése
Úszó szélesség; // A változó nevű, WIDTHBOX típusú lebegő bejelentése

Minden változót fel kell tüntetni, mielőtt azokat használják.

A változó a program bármely részében bejelenthető, de attól függ, hogy melyik szoftverblokkok használhatók. Azok. A változóknak hatókörei vannak.

• A program elején bejelentett változók A Void Setup () funkciót a globális és bárhol elérhetővé válik a programban.
• A helyi változókat a funkciókban vagy blokkokban, például a ciklusban, és csak a bejelentett blokkokban lehet használni. Számos változó van egy névvel, de a láthatóság különböző területei.

int mód; // változó elérhető minden funkció számára

void Setup () () () () (
// üres blokk, a kezdeti telepítések nem szükségesek
}

void hurok () () () (

hosszú szám; // számváltozó csak hurok () funkciókban érhető el.

mert (int i \u003d 0; i< 10;) // переменная i доступна только внутри цикла
{
I ++;
}
}

A változó kijelentésekor meg lehet adni kezdeti értékét (inicializálja).

int x \u003d 0; // Az x változót 0 kezdeti értékkel kell bejelenteni
char d \u003d 'a'; // A D változó az "A" szimbólumkóddal egyenlő kezdeti értékkel van megadva

A különböző típusú adatokkal rendelkező aritmetikai műveletekben az adattípusok automatikusan átalakulnak. De jobb, ha mindig egy explicit transzformációt használ.

int x; // Int változó.
char y; // változó karakter.
int z; // Int változó.

z \u003d x + (int) y; Az Y változó egyértelműen az int int

Aritmetikai műveletek.

Kapcsolati műveletek.

Logikai műveletek.

Műveletek a mutatókon.

Bit műveletek.

&	ÉS
|	VAGY
^	Kizárva vagy
~	Inverzió
<<	Eltolódás balra
>>	Jobbra vált

Vegyes hozzárendelési műveletek.

Válasszuk az Opciók, Programmenedzsment lehetőséget.

Ha az üzemeltető Ellenőrzi a zárójelben lévő állapotot, és végrehajt egy későbbi expressziót vagy blokkot göndör zárójelben, ha az állapot igaz.

ha (x \u003d\u003d 5) // ha x \u003d 5, akkor z \u003d 0
z \u003d 0;

ha (x\u003e 5) // Ha x\u003e
(z \u003d 0; y \u003d 8;)

Ha más Lehetővé teszi, hogy két lehetőség közül választhat.

ha (x\u003e 5) // Ha x\u003e 5, akkor a z \u003d 0, y \u003d 8 blokk;
{
z \u003d 0;
y \u003d 8;
}

{
z \u003d 0;
y \u003d 0;
}

Más, ha. - Lehetővé teszi a többszörös választás készítését

ha (x\u003e 5) // Ha x\u003e 5, akkor a z \u003d 0, y \u003d 8 blokk;
{
z \u003d 0;
y \u003d 8;
}

más, ha (x\u003e 20) // Ha x\u003e 20, akkor ez a készülék végrehajtásra kerül
{
}

egyébként // egyébként ez a készülék végrehajtása.
{
z \u003d 0;
y \u003d 0;
}

Kapcsolószekrény. - Több választási lehetőség. Lehetővé teszi, hogy összehasonlítsa a változót (az X. példában) több konstansokkal (az 5. és 10. példában), és végezzen olyan blokkot, amelyben a változó megegyezik az állandóval.

kapcsoló (x) (

5. eset:
// kódot hajt végre, ha x \u003d 5
Szünet;

10. eset:
// kódot hajt végre, ha x \u003d 10
Szünet;

alapértelmezett:
// kódot, ha nincs korábbi érték egybeesik
Szünet;
}

Ciklus. A tervezés lehetővé teszi a ciklusok megszervezését egy adott számú iterációval. A szintaxis így néz ki:

(a ciklus indítása előtti intézkedés;
a ciklus feltételének folytatása;
Akció az egyes iteráció végén) (

// kódkód ciklus

Példa egy 100 iteráció ciklusára.

mert (i \u003d 0; i< 100; i++) // начальное значение 0, конечное 99, шаг 1

{
SUM \u003d SUM + I;
}

Ciklus közben. Az üzemeltető lehetővé teszi a ciklusok megszervezését a tervezéssel:

míg (kifejezés)
{
// kódkód ciklus
}

A ciklust mindaddig elvégzik, amíg a zárójelben lévő kifejezés igaz. Példa egy ciklusra 10 iterációra.

x \u003d 0;
míg (X.< 10)
{
// kódkód ciklus
X ++;
}

Csinálni, miközben - ciklus a kimenet állapotával.

tegye.
{
// kódkód ciklus
) Míg (kifejezés);

A ciklust addig végzik, amíg a kifejezés igaz.
Szünet - Kimeneti üzemeltető a ciklusból. A forgások végrehajtásának megszakítására használják, miközben ciklusokat végeznek.

x \u003d 0;
míg (X.< 10)
{
ha (z\u003e 20) szünet; // ha z\u003e 20, akkor menjen ki a ciklusból
// kódkód ciklus
X ++;
}

Menj. - feltétel nélküli átmeneti üzemeltető.

goto metka1; // átmenet metka1
………………
metka1:

Folytatni. - Ugrás az üzemeltetők a ciklus testének végéig.

x \u003d 0;
Míg (X.< 10)
{
// kódkód ciklus
Ha (z\u003e 20) folytatódik; // ha z\u003e 20, akkor térjen vissza a ciklus testének kezdetére
// kódkód ciklus
X ++;
}

Tömbök.

A tömb olyan memóriaterület, ahol több változót egymás után tárolunk.

A tömböt bejelentették.

int; // 10 változó tömbje

Úszási súly; // 100 változó tömbje lebeg

A tömbök bejelentése során inicializálható:

iNT AGES \u003d (23, 54, 34, 24, 45, 56, 23, 23, 27, 28);

Alkalmazzon olyan karok változóit:

x \u003d korosztály; // x értéke 5 tömbelem értéke.
AGES \u003d 32; // 9 A tömbelem 32-re van állítva

A tömbelemek számozása mindig a semmiből származik.

Funkciók.

A funkciók lehetővé teszik, hogy ugyanazokat a műveleteket végezzen különböző adatokkal. A funkció:

• az általa okozott név;
• argumentumok - Adatok, amelyeket a funkció kiszámításához használ;
• adat típus, amelyet a funkció.

A felhasználói funkciót a beállítás () és a hurok () függvényeken kívül írják le.

void Setup () () () () (
// A program elindításakor végrehajtott kód
}

void hurok () () () (
// fő kód, a ciklusban
}

// A Funkcióname nevű felhasználói funkció bejelentése
Írja be az egyik funkciót (írja be az argumentum1, írja be az argumentumot1, ..., típusú argumentum)
{
// Body funkció
Visszatérés ();
}

Egy példa a két argumentum négyzeteinek összegének kiszámítására.

int sumqwadr (int x, int y)
{
Visszatérés (x * x + y * y);
}

A funkcióhívás történik:

d \u003d 2; b \u003d 3;
z \u003d sumqwadr (D, B); // Z-ben a d és b változók négyzeteinek összege lesz

A funkciók beépítettek, egyedi, csatlakoztatva vannak.

Nagyon rövid, de ez az adat kell ahhoz, hogy írásban programok C Arduino rendszerek.

Az utolsó dolog, amit meg akarok mondani ebben a leckében, amint a szokásos programok végrehajtásához a C.-en keresztül. Azt hiszem, ha először olvassa el ezt a leckét, érdemes kihagyni ezt a részt, és később visszatér, amikor lehetővé teszi.

A külső programtervezés fő célja a programok olvashatóságának javítása, csökkenti a hivatalos hibák számát. Ezért e cél elérése érdekében biztonságosan megsértheti az összes ajánlást.

Nevek C.

Az adattípusokat ábrázoló neveket vegyes nyilvántartásba kell írni. A név első betűje a cím (felső regiszter).

Jel, timeCount

A változóit a vegyes regiszterben neveket kell rögzíteni, a vonal első betűje (kisbetűk).

Rovatcím :. Hozzáadhatja a könyvjelzőket.

Az Arduino fő elemeinek megismerése után, valamint a "Hello World" program írása után. Itt az ideje a programozási nyelv megismerésére.

A nyelv szerkezete elsősorban a C / C ++ alapú, így azok, akik korábban programoztak ebben a nyelven, nem lesz nehéz az Arduino programozás elhagyása. A többinek meg kell tanulnia az alapvető információkat a menedzsment parancsokról, az adattípusokról és a funkciókról.

A legtöbb itt szereplő információk kompatibilis lesz minden C / C ++ természetesen figyelembe véve a különbségeket adattípusok, valamint számos konkrét utasításokat programozás I / O portok.

Az alapok alapjai

Számos formális dolog, azaz, hogy mindenki tudja, de néha elfelejti ...

Az Arduino IDE-ben, mint a C / C ++ -nél, meg kell emlékezni a karakterek nyilvántartásaira. Kulcsszavak, például ha, mert mindig a kisbetűsek. Minden utasítás véget ér ";". A pontosvessző egy fordítót jelent, amely az utasításként értelmezhető.

A konzolok (.. ..) szoftverblokkok kijelölésére használják. Használjuk őket, hogy korlátozzuk a test funkciót (lásd alább), ciklusokat és feltételes operátorokat.

A bevált gyakorlat az, hogy megjegyzéseket adjon a program tartalmához, segít könnyen megérteni a kódot. Egysoros megjegyzések kezdődnek // (Dupla süllyedő vonal). Többsoros megjegyzések kezdődnek /* és vége */

Ha bármilyen könyvtárat szeretne csatlakoztatni a programunkba, használjuk az Include parancsot. Íme példák a könyvtárak összekapcsolására:

#Inlude. // standard könyvtár #include "svoya_biblioteka.h" // könyvtár a projektkatalógusban

Az Arduino funkciói.

A funkció (szubrutin) a program különálló része, amely bizonyos műveleteket végez. A funkciókat a fő program egyszerűsítésére és a kód olvashatóságának javítására használják. Hasznos a funkciók használatához, mivel sok projektünkben könnyen használhatjuk őket.

A Standard programozási tanfolyam tartalmaz információkat a következő cikkekről. Arduino esetében a funkciókat az elején tárgyaljuk, mert még a legegyszerűbb programnak két speciális funkcióval kell rendelkeznie. Már megemlítették a korábbi cikkekben, de itt rendszerezünk ezeket az információkat.

Védelmi hirdetés

A nyilatkozat-rendszer jellemzői a következők:

Function_name típus (paraméter) (// végrehajtási utasítások (testfunkció) Visszatérés (/ * Visszatérési érték * /);)

egy típus - Ez a rendelkezésre álló adattípus neve ez a nyelv Programozás. Az Arduino programozás során elérhető típusok listája Lássuk egy külön cikkben.

Végrehajtás után a funkció visszaadja a bejelentett típus értékét. Abban az esetben, ha a funkció nem fogad el semmilyen visszatérési értéket, az adattípus "érvénytelen" lesz.

funkció neve Lehetővé teszi, hogy egyértelműen azonosítsa. Ahhoz, hogy hívja (futtassa) funkciót, adunk neki nevét.

paraméter - Funkcióhívás paraméter. A paraméterek nem szükségesek, de gyakran hasznosak. Ha olyan funkciót írunk, amelynek nincs argumentuma, üresen hagyjuk a kerek zárójeleket.

A konzolokon belül "(...)" tartalmazza a funkció tényleges testét vagy az általunk kívánt utasításokat. Az egyedi utasítások leírása külön cikkben jelezhető.

Minden olyan funkció, amely az értékre visszatér, a visszatérő operátor befejeződik, majd a visszatérési értéket. Csak a nulla mutatóval ("Void") által bejelentett funkciók nem tartalmazzák a visszatérő szolgáltatót. Meg kell tudni, hogy a visszatérési utasítás befejezi a funkció teljesítményét a helyszíntől függetlenül.

Az alábbiakban néhány példa a funkciók nyilatkozataira.

Void F1 () (// Body funkció) -------------- int mínusz () (// Body Function Return (0);) ----------- --- int plusz (int A, int B) (visszatérés (A + B);)

Amint a példákon látható, a funkciók nyilatkozata az Ön igényeitől függően különböző formákat ölthet.

Javasoljuk, hogy a saját programok írásakor feltárja és alkalmazza a funkciókat. Idővel minden programozó saját funkciók könyvtárát nyeri meg "minden alkalomra", ami megkönnyíti és felgyorsítja az új programok írásának folyamatát.

Most, hogy tudjuk, hogyan írhatod meg saját funkcióját, meg kell tanulnod használni.

Hívás funkció

Minden funkció, amelyet egy fájlban / programban rögzítünk. Természetesen elegánsabb megoldás, de megpróbáljuk leírni legközelebb.

A funkció bejelenti, más funkciókban használhatjuk a megfelelő nevet és a szükséges paramétert. Az alábbiakban példák arra, hogy felhívja a fenti funkciókat:

F1 (); Plusz (2.2); y \u003d plusz (1.5);

Amint a példákban látható, a funkcióhívást a nevének és a szükséges paraméterek számának megadásával végzik. Fontos, hogy a bejelentéssel összhangban mindig hívjon funkciót.

Ha az F1 () függvény paraméterek nélkül kerül kimutatásra, akkor nem adható meg paraméterek, ha úgynevezett, azaz. Az F1 (0) funkció hívása helytelen lesz.

A plusz funkció (INT A, INT B) pontosan két paramétert igényel, így a hívás egy vagy három paraméterrel lehetetlen.

A Hívás Y \u003d Plus (1.5) végrehajtásra kerül a "Plus" funkcióval az "1" és "5" paraméterekkel, és mentheti a visszatérési értéket az "Y" változóhoz.

Beállítás () és hurok () funkciók.

A funkciók bejelentésének és hívásának ismerete, az Arduino rendszer funkcióihoz mehetünk: beállít () és hurok (). Arduino IDE B. kötelező Ez a két funkció ki kell mondania.

a beállítás () egy olyan funkció, amelyet automatikusan hívnak, ha a készülék be van kapcsolva, vagy a RESET gomb megnyomásával.

A nevének megfelelően a változók kezdeti értékeinek beállítása, a bemenetek és a rendszerkimenetek, amelyek általában a kezdeti paraméterekben vannak beállítva. A sajátosságának köszönhetően ez a funkció nem tér vissza az értékeket, és nem hívják paraméterekkel. A megfelelő beállítási () funkciónyilatkozatot az alábbiakban mutatjuk be:

Void Setup () (// Body Function - System inicializálás)

a hurok () olyan függvény, amelyet végtelen ciklusban hívnak. Ez a funkció nem tér vissza, és nem hívják paraméterekkel. A hurok () függvény helyes nyilatkozata az alábbiakban látható.

Void hurok () (// Body Function - Program kód)

Amint láthatja, a hurok () funkció megjegyzése megegyezik a Beállítás () függvény nyilatkozatával. A különbség az, hogy ezeket a funkciókat mikrokontrollerrel végezzük.

Most elemezzük a következő pszeudokódot:

Void Setup () (ON_LED1 (); // Kapcsolja be a LED1-et OFF_LED1 () LED-t; // Kapcsolja ki a LED1 LED1-et1) Void Loop () (ON_LED2 (); // Kapcsolja be a LED2-et Kapcsolja ki a LED2 LED-et)

A Beállítás () funkcióban két utasítás van: az első bekapcsolás a LED1 LED-ről, amely a fedélzethez csatlakozik (például érintkező 13), és a második bekapcsolja a LED1 LED-et.

A hurok () függvény azonos utasításokkal rendelkezik a fedélzethez csatlakoztatott LED2 LED bekapcsolásához és kikapcsolásához (például a 12. érintkezővel).

A LED1 LED program elindítása eredményeként a LED egyszer villog, míg a LED2 világít, és kialszik, amíg az Arduino be van kapcsolva.

A RESET gomb megnyomása arra a tényre vezet, hogy a LED1 egyszer villog, és a LED2 ismét villogni kezd.

Összesít:

• A beállítás () és a hurok () függvények olyan rendszerfunkciók, amelyeket minden egyes projektben meg kell határozni. Még olyan helyzetben is, ahol az egyikben nem írunk semmilyen kódot, még mindig meg kell adnunk ezt a két funkciót;
• A Setup () funkció egyszer történik, a hurok () folyamatosan történik;
• Létrehozunk saját funkciók egy fájlban;
• Mindkét beállítás () és hurok () és más funkciókból származó funkciókat hívhatjuk;
• Saját funkciókat hívhatunk paraméterekkel és visszatérési értékkel;
• A funkcióhívást a nyilatkozatnak megfelelően kell elvégezni.

Az Arduino modul programozási nyelv alapja az SI nyelv (meglehetősen s ++). Pontosabban, ezt a nyelvi dialektust feldolgozásnak / vezetéknek nevezik. Jó nyelvi áttekintés, amelyet az alkalmazásban talál. És többet akarok mondani, nem a nyelvről, hanem a programozásról.

A program egyfajta parancs, amelyet a processzor megérti a számítógép feldolgozóját, vagy az Arduino modul mikrokontroller processzor nem fontos. A processzor elolvassa a parancsokat, és elvégzi őket. Bármely csapat, amelyet a processzor megérti, bináris számok. Ezek csak bináris számok és semmi más. Az aritmetikai műveletek végrehajtásával, amelyekre a processzor egyszer és szándékozik, a processzor számokkal működik. Bináris számok. És kiderül, hogy mind a csapatok, mind pedig a bináris számokhoz tartoznak. Mint ez. De hogyan tudja a processzor ezt a "halom" bináris számok?

Először is, ezek a bináris számokat írt soros memória sejtek, amelyek a címeket. Amikor letölti a programot, és elkezd dolgozni, a processzor megkapja a program első címét, ahol a parancsot rögzíteni kell. Azok a parancsok, amelyek a számokkal rendelkező processzor műveleteket igényelnek "jelzések azonosítása", például a következő két memóriacellákban két számot kell hajtani. És a számláló, amely felhívja a parancsokat, ahol a következő parancs címét rögzíti, ebben az esetben növeli a címet úgy, hogy a program a következő parancs legyen ebben a címben. Ha a program vagy kudarc a program vagy kudarcok, a processzor lehet összetéveszteni, majd, miután elolvasta a szám helyett a csapat, a processzor nem tenni valamit, hogy meg kell csinálni, és a program „lefagy”.

Így bármely program a bináris számok sorozata. És a programozás képes helyesen rögzíteni a bináris számok helyes szekvenciáit. Hosszú ideig olyan speciális eszközöket kezdett használni, amelyeket programozási nyelveknek neveznek.

Mindazonáltal minden program először egyértelműen meg kell értenie, hogy mit kell tennie a programnak, és hogy mire van szükség. A tisztább, amit értesz, annál könnyebb egy program létrehozása. Kis programok, bár nehéz megmondani, hogy mely programok kicsiek, és amelyek nem, teljes mértékben tekinthetők. A bonyolultabb programok jobban osztódnak olyan részekre, amelyek független programként tekinthetők meg. Tehát jobb létrehozni, könnyebb hibakeresés és ellenőrzés.

Nem vagyok hajlandó vitatkozni, de úgy gondolom, hogy a program kényelmesebb a szokásos nyelv leírása. És ebben az értelemben azt hiszem, hogy a programozást nem szabad összetéveszteni a programkód írásával. Ha a programot hagyományos szavak írják le, akkor könnyebb meghatározni, hogy milyen programozási nyelvet választhat a programkód létrehozásához.

A program a bináris számok, az összeszerelő nyelv használatához legközelebb van. A nyelvi parancsok bináris csapatoknak való megfelelését, az érthető processzort jellemzik. De az összeállítási programok kódolása nagy erőfeszítést igényel és közelebb van a művészethez, mint a formális műveletekhez. Sokoldalúbb és könnyebben alkalmazható magas szintű nyelvek, mint Baisik vagy C. És sokáig egy grafikus nyelvet használnak a programok általában, és a közelmúltban "fordítók" megjelentek ebből a nyelvből a processzor nyelvre.

A nyelvi programozási nyelvek mellett mindig léteztek a programozási nyelvek specializációjára, és léteztek szakosodott nyelvekről. Az utolsó az Arduino modul programozási nyelvet is elvégezném.

Mindössze annyit kell mondanod, hogy a modult úgy kell mondania, hogy valami szükséges hozzánk, szervezzen egy kényelmes parancsot. De először arról, hogy mire van szükségünk Arduino?

A modul különböző tulajdonságokban használható - ez a robot szíve (vagy feje), ez az eszköz alapja, ez egy kényelmes tervező a mikrokontrollerekkel való munkavégzéshez stb.

A fentiekben már használtuk az egyszerű programokat, hogy ellenőrizzék a modul csatlakozását a számítógéphez. Valaki túl egyszerűnek tűnhet, ezért nem érdekes, de bármilyen összetett program olyan egyszerűbb töredékekből áll, amelyekhez hasonlóan vannak, akikkel már megismerkedtünk.

Lássuk, mit tudunk mondani a legjobban egyszerű program "Teljes LED".

int ledpin \u003d 13;

pinmode (Ledpin, kimenet);

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

Először is, emlékezzünk arra, hogy mi a LED. Lényegében ez egy hétköznapi dióda, amely a tervezés miatt, amikor a jelenlegi áramlási irányba áramlik, az átmenet megkezdődik. Vagyis, hogy a LED világít, át kell áramolnia rajta, és ez azt jelenti, hogy a LED-t a LED-re kell alkalmazni. És így, hogy a jelenlegi nem haladja meg a megengedett értéket, a sorozat a LED egy ellenállást kell venni, amely az úgynevezett áramkorlátozó (lásd függelék, digitális kimenet). A LED feszültsége egy mikrokontrollerre vonatkozik, amely az ARDUINO modul alapja. A mikrokontroller, kivéve a processzort, amely végrehajtja a parancsokat, van egy vagy több I / O port. Figyelembe véve specifikus eszköz Port, mondjuk - ha a port kimenet működik a kimeneten, akkor két állapotú digitális chip kimenetként jeleníthető meg, be- és kikapcsolható (a kimeneten van feszültség, nincs feszültség a kimeneten).

De ugyanaz a portkimenet is bejáratként működhet. Ebben az esetben azt lehet beadni, például, például egy digitális chip bemenet - logikai szint, magas vagy alacsony (lásd az A. függelék, digitális bemenet).

Ahogy villogunk a LED-en:

Engedélyezze a port kimenetét. Kapcsolja ki a port kimenetét.

De a processzor nagyon gyorsan működik. Nem lesz időnk látni villogni. Ha ezt a villogást szeretnénk látni, meg kell adnunk szünetet. Azaz:

Engedélyezze a port kimenetét. Pause 1 másodperc.

Kapcsolja ki a port kimenetét.

Pause 1 másodperc.

Ez a programunk. A processzor elolvassa az első parancsot, és bekapcsolja a kimenetet, a LED világít. A processzor akkor szünetelteti a működést, és kikapcsolja a kimenetet, a LED kimegy. De csak egyszer villogott.

A folyamat vagy a beállított parancsok ismétlését ciklus programozásnak nevezik. Különböző típusú ciklusokat használtak. Van egy ciklus, amelyet elvégeznek Állítsa be a számot idő. Ez egy ciklus. Vannak olyan ciklusok, amelyek végrehajtásra kerülnek, amíg a feltétel részét képezi a ciklus nyelvi tervezésének. És ha a feltétel soha nem fejeződött be, akkor a ciklus végtelen számú alkalommal történik. Ez végtelen ciklus.

Nem hiszem, hogy a mikrokontrollereket a fenti típusú programokkal használják. Ez az, hogy több parancsot hajtanak végre egyszer, és a vezérlő nem működik. Szabályként folyamatosan működik, amint a tápfeszültséget szállítják. És ez azt jelenti, hogy a mikrokontrollernek végtelen ciklusban kell működnie.

Ez az, amit a függvény hurok (), hurok egy hurok, zárt ciklus. A ciklus megszüntetésének feltételei nem, és ezért nincs feltétel a befejezéshez.

Ezenkívül be kell jelenteni az Arduino modulot, amely a port kimenetét és a használatát szeretnénk használni, kilépni (kimenet) vagy bemenet (bemenet). Ez a cél a Void Setup () funkció, amely kötelező az Arduino nyelvre, még akkor is, ha nem használják, és a PINMODE () parancs () parancsot a kimeneti mód megadásához.

pinmode (Ledpin, kimenet);

És mégis, a nyelvi tervezés változókat használ a kimeneti szám meghatározásához:

int ledpin \u003d 13;

A változók használata kényelmes. Úgy dönt, hogy a 13. és 12 kimenetet nem fogja használni, csak egy sorban változtatni fog. Különösen erősen befolyásolja a nagy programokat. A változó nevét saját belátása szerint választhatjuk meg, de szabályként csak szimbólum, és gyakran a karakterek száma korlátozott. Ha félreértelmezed a változó nevét, azt hiszem, a fordító kijavítja Önt.

A Digitalwrite funkció (Ledpin, High) meghatározza a megadott kimenetet magas szintű állapotba, vagyis a kimenetre fordul.

És késleltetés (1000), ahogy már értette, azt jelenti, hogy szünetet tartanak 1000 milliszekundumban vagy 1 másodperc alatt.

Továbbra is megérteni, hogy a konzolok, mint például az INT, érvénytelen. Bármely érték, bármely változó a memóriába kerül, mint a programparancsok. A memóriakejtekben a számokat gyakran 8 bitből írják ki. Ez a bájt. De a bájt számok 0-tól 255-ig. Nagy számok írása két bájtra van szüksége, vagy több, azaz két vagy több memóriacellát. Annak érdekében, hogy a processzor világos legyen, hogyan lehet megtalálni a számot, különböző típusok A számok különböző nevekkel rendelkeznek. Tehát a BYTE által megnevezett szám, egy cellát, int (egész szám, egész szám) többet vesz. Ezenkívül a programozási nyelvekben használt funkciókat a számok is visszaadják. Annak meghatározásához, hogy melyik típusú számot kell adnia egy funkciónak, az ilyen típusú visszaküldött számot a funkció előtt rögzítik. De bizonyos funkciók nem térhet vissza a számok, mint a funkciók előzi meg a Void bejegyzést (lásd függelék, változók).

Ez az, hogy mennyire megmondhatja az érdekes program.

Mindez reméli, hogy elolvassa az alkalmazást. És most egyszerű kísérleteket fogunk csinálni, csak azt, amit már tudunk a nyelv képességétől. Először cserélje ki változó típus Int, amely sok helyet foglal el a memóriában, a bájton - egy helyen, egy memóriacellával. Lássuk, mit sikerülünk.

byte Ledpin \u003d 13;

pinmode (Ledpin, kimenet);

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

A program összeállítása és letöltése után a modulra nem fogjuk megjegyezni a program változásait. Oké. Ezután megváltoztatom a programot, hogy észrevegyem a munkájában bekövetkezett változásokat.

Ehhez a számot a késleltetés (1000) változó függvényében helyettesítjük, hívják a my_del-t. Ez a változónak egész számnak kell lennie, azaz int.

int my_del \u003d 5000;

Ne felejtsd el befejezni az egyes csapatot vesszővel. Végezze el a program módosítását, fordítsa össze, és indítsa el a modulba. Ezután változtassa meg a változót, és ismételje meg az összeállítást és a betöltést:

byte my_del \u003d 5000;

A különbség, biztos vagyok benne, hogy kézzelfogható lesz.

Egy másik kísérletet fogunk végezni a szünet időtartamának megváltoztatásával. A szünetek időtartamának csökkentése, mondjuk, ötször. 2 másodpercig szünetelünk, majd ötször is növeljük. És ismét 2 másodpercig szünetelünk. A ciklus végrehajtott meghatározott számú alkalommal hívják ciklus És így van:

mert (int i \u003d 0; i<5; i++)

valami, amit a ciklusban végzik

A ciklus végrehajtásához változónak szüksége van rá, van ez az én, a változó, amelyre be kell állítania az általunk jóváhagyott kezdeti értéket. Ezután követi a ciklus befejezésének feltételét, kevesebb, mint 5. és I ++ felvétel jellemző a C rekord a változó egységenkénti egységenként. Ábra zárójelek Korlátozza a végrehajtandó parancsok készletét a ciklusban. Más programozási nyelveken lehetnek más korlátozók, amelyek kiemelik a funkciókód blokkját.

A cikluson belül ugyanúgy végezünk, mint korábban, kisebb változásokkal:

mert (int i \u003d 0; i<5; i++)

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

my_del \u003d my_del - 100;

Beszéltünk a szünet felvételének megváltoztatásáról, és a szünet megváltozása a változó 100-as csökkenésével érhető el.

A második ciklusban ugyanazt a kód blokkot írjuk, de a szünet időtartamának változása 100-ra nő.

mert (int i \u003d 0; i<5; i++)

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

Észrevette, hogy a szünet csökkenésének és növekedésének felvétele másképp néz ki. Ez az SI nyelv egyik jellemzője is. Bár az egyértelműség érdekében meg kellett ismételni ezt a bejegyzést csak a mínusz jelzés megváltoztatásával. Tehát egy ilyen programot kapunk:

int ledpin \u003d 13;

int my_del \u003d 1000;

pinmode (Ledpin, kimenet);

mert (int i \u003d 0; i<5; i++)

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

mert (int i \u003d 0; i<5; i++)

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

Másolja át programunk kódját az Arduin programban, fordítsa el, és vezesse be a modulba. A szünet időtartamának megváltoztatása észrevehető. És még észrevehetőbb lesz, próbálja meg, ha befejezi a ciklust, mondjuk, csak 8.

Amit most tettünk most, és professzionális programozók - késztermékkel rendelkező programozókkal, könnyen módosíthatók az Ön igényei vagy vágyai alatt. Ezért tárolják az összes programot. Mit tanácsolok neked és te.

Mi hiányzott a kísérletedben? Nem tettük meg a munkánkat. Megjegyzés hozzáadása, vagy kettős "egyenes" ferde vonal, vagy egyetlen, de csillagok (lásd az A. függelék). Azt tanácsolom, hogy tegye meg magad, mert egy pillanatra visszatér a programba, hogy könnyebben kitaláljuk, ha elmagyarázza, hogy a program egy adott helyén dolgozik. És azt is javaslom egy mappában minden egyes programot, hogy tárolja leírását a szokásos nyelven, bármely szövegszerkesztőben készült.

A legegyszerűbb program "befagyasztja a LED" még egy tucat kísérlet (még egy LED) is szolgálhat. Úgy tűnik számomra a munka ezen része, feltalálja, hogy még mindig érdekes, legérdekesebb. Ha hivatkozik az alkalmazásra, ahol a programozási nyelvet leírja, a "Program menedzsment" szakaszban a ciklus más típusú ciklusra cserélheti. És próbálja meg más típusú ciklusokat.

Bár a mikrokontroller processzor, mint bármely más, számításokat eredményezhet (ehhez és feltalálta), és ezt alkalmazzák, például az eszközökben, mégis a mikrokontroller leginkább jellemző működése a kikötő kimenete magas vagy alacsony Állam, azaz "LED", mint a külső eseményekre való reakció.

A külső eseményekről A mikrokontroller elsősorban a bejáratok állapotában fog tudni. A portok következtetéseinek konfigurálása a digitális bemenetre követhetjük. Ha a kezdeti bemeneti állapot magas szintű, és az esemény a bejelentkezés alacsony állapotba kerül, akkor tehetünk valamit, válaszolunk erre az eseményre.

A legegyszerűbb példa a gomb bemenete. Ha a gombot nem nyomja meg, akkor a magas állapotban van. Ha megnyomja a gombot, a bemenet alacsony állapotba kerül, és "gyújtani" a kimeneti LED-et. A következő alkalommal, amikor megnyomja a LED gombot, kifizetheti.

Ez egy egyszerű példa egy egyszerű programra. Még a kezdők is, úgy tűnik, érdektelen. Ez az egyszerű program azonban nagyon hasznos felhasználást eredményezhet. Csak egy példát adok: Nem fogjuk megvilágítani a LED-et a gombra kattintva, de az egyesítés (bizonyos módon). És a LED infravörös sugárzással lesz. Ennek eredményeként megkapjuk a központot. Itt van egy ilyen egyszerű program.

A program különböző verzióiban különbségek vannak a példák listáján. De a nyelvi kézikönyvben hivatkozhat az alkalmazásban, ahol a program példája és rendszere van (a "Függelék" című példákban) a bevezetéssel való együttműködéshez. Másolom a programot:

int ledpin \u003d 13;

pinmode (Ledpin, kimenet);

pinmode (inpin, bemenet);

ha (digitalread (inpin) \u003d\u003d magas)

digitalwrite (Ledpin, magas);

digitalwrite (Ledpin, alacsony);

És ahogy látod, teljesen új programot kapunk, módosítva a régiet. Most a LED csak akkor villog, ha a nyomógombot megnyomja, amely a 2. kimenethez van csatlakoztatva. A gomb az egyik vége a tápfeszültséghez + 5V, és a másik vége a 2. kimenethez.

A programban találkozunk egy új nyelvi struktúrával, ha a programkezelő részből áll. Ez így olvasható: ha egy feltétel teljesül (zárójelben van csatolva), akkor a program a göndör zárójelben kerül végrehajtásra. Kérjük, vegye figyelembe, hogy az állapotban (digitalread (inpin) \u003d\u003d magas) A bemenet egyenlősége nagymértékben végrehajtott két egyenlőségi jelzéssel! Nagyon gyakran sietve, hogy elfelejtették, és a feltétel helytelen.

A program átmásolható és letölthető az Arduino modulra. A program működésének ellenőrzéséhez azonban módosítania kell a modul kialakítását. Azonban a modul változatosságától függ. Az eredeti modul rendelkezik egy aljzattal a hosszabbító táblákhoz való csatlakozáshoz. Ebben az esetben megfelelő egymagos vezetékeket illeszthet a kívánt csatlakozókhoz. A modulom kés kapcsolatokat tartalmaz a hosszabbító táblák csatlakoztatásához. Vagy kereshetek egy megfelelő csatlakozót, vagy amely olcsóbb, használja a megfelelő mikrokriffit panel a DIP tokban.

A második kérdés - hogyan lehet megtalálni a következtetéseket a programban használt modulból?

Ezzel a kérdésben segíteni fogja a webhelyről vett képet: http://roobocraft.ru/.

Ábra. 4.1. A vezérlő és az Arduino modul következtetéseinek helye és célja

A kézműves modulom minden következtetése megjelölve van, így a megfelelő következtetés megtalálása nem lesz nehéz. Csatlakoztathatja a gombot és ellenállást, és ellenőrizheti a program működését. By the way, a fent említett helyszíni robokraft, a teljes folyamat megjelenik a képeken (de a program nem nagyon ilyen következtetéseket használ!). Azt tanácsolom, hogy nézzen.

A kompozícióban számos mikrokontroller további hardvereszközökkel rendelkezik. Tehát az ATMEGA168, amely alapján az Arduino modul összeszerelte egy UART, egy beépített blokkot a más eszközökkel való kommunikációhoz egy következetes adatcserével. Például egy számítógéppel a COM porton keresztül. Vagy egy másik mikrokontrollerrel beépített UART egység segítségével. Van egy analóg-digitális átalakító is. És latitudinális modulációs képző.

A használata az utóbbi szemlélteti a program, hogy én is másolja a Robocraft oldalon. De a program az alkalmazásból származhat. És talán az Arduino program példái.

// a barnagan által vezetett fading

iNT érték \u003d 0; // változó a kívánt érték tárolásához

int ledpin \u003d 9; // LED a digitális PIN-hez csatlakoztatva 9

// nincs szükség a PINMODE funkcióra

mert (érték \u003d 0; érték<= 255; value+=5) // постепенно зажигаем светодиод

analogwrite (Ledpin, érték); // kimeneti érték (0 és 255 között)

késedelem (30); // keres 🙂

mert (érték \u003d 255, érték\u003e \u003d 0, érték- \u003d 5) // fokozatosan Gassim LED

analogwrite (Ledpin, érték);

Ha az előző új programot nekünk volt egy DigitalDalread (INPIN) függvény, olvasás digitális bemenettel, akkor ez a program egy új funkció AnalogWrite (LEDPIN, érték) függvény, de a paraméterei ezt a funkciót már ismerős számunkra változókat. Az analóg bemenet használatával az ADC (analóg-to digitális átalakító) segítségével később beszélünk. És most visszatérünk a programozás általános kérdéseihez.

A programozás mindenki számára elérhető, de az idő kell elsajátítani és programozni, és bármilyen programozási nyelvet. Ma számos olyan program van, amelyek segítenek megtudni a programozásban. És egyikük közvetlenül kapcsolódik az Arduino modulhoz. Ezt nevezik karcolás az Arduino vagy a Rebreviated S4a számára. Ezt a programot megtalálhatja és letöltheti: http://seaside.citilab.eu/scratch/arduino. Nem tudom, hogy a program neve pontosan lefordul, de a "Scratchindítás kezdete" lefordítva "STARTS A SCRATCH" -ként "le van fordítva.

Az S4A projekt oldalán található verziók Windows és Linux, de a legújabb operációs rendszer készen áll a program telepítésére a Debian elosztási verzióban. Nem akarom azt mondani, hogy nem használható más Linux disztribúciókkal, de először meglátjuk, hogyan kell működni a programban az ARDUINO modul ablakban.

A program telepítése után az orosz interfész szokásos módon konfigurálható a nyelvi kapcsolóval.

Ábra. 4.2. Program interfész nyelvkapcsoló

Az első eszköztár ikon, ha rákattint, megjeleníti az összes lehetséges programinterfész nyelvet. Az orosz nyelv megtalálható a szakaszban ...

Ábra. 4.3. A nyelvek listája a programfelületen

... "Tovább ...".

Ha semmit nem tesz, akkor a "Keresési tábla" felirat megmarad, de a modul nem található. Az ARDUINO modul S4A-hoz való csatlakoztatásához töltsön le valamit a projekt oldaláról.

Ábra. 4.4. Fájl letöltése az S4A Arduino modulhoz

Ez a fájl nem más, mint egy program az Arduino (vázlat) számára. Azaz, egy szöveges fájl, amely lehet másolni az Arduino szerkesztő, fordítási és feltölteni a modult. Az Arduino program elhagyása után futtathatja az S4A programot, és most a modul található.

Ábra. 4.5. Modul csatlakoztatása a programhoz

A modul analóg bemenetei nincsenek csatlakoztatva, valamint a digitális, ezért a modulra megjelenő értékek folyamatosan változóak véletlenszerűen.