Arduino uno r3 projektek kezdőknek. Arduino: mit lehet vele kezdeni. Projektek a jövőre nézve

Ez a szimulátor a Chrome böngészőben működik a legjobban
Nézzük meg közelebbről az Arduinót.

Az Arduino nem egy nagy számítógép, amelyhez külső áramkörök csatlakoztathatók. Az Arduino Uno Atmega 328P-t használ
Ez a legnagyobb chip a táblán. Ez a chip végrehajtja a memóriájában tárolt programokat. A programot USB-n keresztül töltheti le az Arduino IDE segítségével. Az USB port az arduino tápellátását is biztosítja.

Van egy külön konnektor. Az alaplapon két kimenet található, 5V és 3,3V jelöléssel, amelyekre különféle eszközök táplálásához van szükség. GND feliratú érintkezőket is találsz, ezek földelt tűk (a föld 0V). Az Arduino platform 14 digitális tűvel (csapokkal) is rendelkezik, amelyek 0 és 13 közötti számokkal vannak ellátva, amelyek külső csomópontokhoz csatlakoznak, és két állapotuk van, magas vagy alacsony (be vagy kikapcsolva). Ezek az érintkezők működhetnek kimenetként vagy bemenetként, pl. vagy képesek bizonyos adatokat továbbítani és külső eszközöket vezérelni, vagy adatokat fogadni eszközökről. A táblán a következő tűk A0-A5 jelzéssel vannak ellátva. Ezek olyan analóg bemenetek, amelyek különböző érzékelőktől származó adatokat tudnak fogadni. Ez különösen akkor hasznos, ha egy bizonyos tartományt, például hőmérsékletet kell mérnie. Az analóg bemenetek további funkciókkal rendelkeznek, amelyek külön aktiválhatók.

Hogyan kell használni a kenyérsütőt.

A kenyérpirító arra szolgál, hogy ideiglenesen összekapcsolja az alkatrészeket, és tesztelje az eszköz működését, mielőtt mindent összeforraszt.
A következő példák mindegyike kenyérsütőtáblára van szerelve, így gyorsan módosíthatja az áramkört, és újra felhasználhatja az alkatrészeket a forrasztással járó gond nélkül.

A kenyérsütőlapon lyuksorok találhatók, amelyekbe alkatrészeket és vezetékeket helyezhet be. Néhány ilyen lyuk elektromosan össze van kötve egymással.

A két felső és alsó sor sorba van kötve a teljes tábla mentén. Ezek a sorok az áramkör tápellátására szolgálnak. Lehet 5 V vagy 3,3 V, de mindkét esetben először csatlakoztassa az 5 V-ot és a GND-t a kenyérsütőtáblához, ahogy az ábra mutatja. Néha ezek a sorkapcsolatok megszakíthatók a tábla közepén, majd ha kell, az ábrán látható módon össze is köthetjük őket.

A tábla közepén található többi lyuk öt lyukkal van csoportosítva. Az áramköri részek összekapcsolására szolgálnak.

Az első dolog, amit a mikrokontrollerünkhöz csatlakoztatunk, egy LED. A kapcsolási rajz a képen látható.

Mi a célja az ellenállásnak az áramkörben? Ebben az esetben korlátozza a LED-en áthaladó áramot. Minden LED egy bizonyos áramerősségre van tervezve, és ha ez az áram nagyobb, akkor a LED meghibásodik. Az ohm törvény segítségével megtudhatja, hogy mekkora értékűnek kell lennie az ellenállásnak. Azok számára, akik nem ismerik vagy elfelejtették, Ohm törvénye szerint lineáris kapcsolat van az áram és a feszültség között. Azaz minél nagyobb feszültséget adunk az ellenállásra, annál több áram fog átfolyni rajta.
V=I*R
Ahol V- feszültség az ellenálláson
én- áram az ellenálláson keresztül
R a keresendő ellenállás.
Először is meg kell találnunk az ellenálláson lévő feszültséget. Az Ön által használt 3 mm-es vagy 5 mm-es LED-ek többsége 3 V-os üzemi feszültséggel rendelkezik. Tehát az ellenálláson 5-3 \u003d 2v-ot kell fizetnünk.

Ezután kiszámítjuk az ellenálláson áthaladó áramot.
A legtöbb 3 és 5 mm-es LED teljes fényerővel, 20 mA-en világít. Az ennél nagyobb áram tönkreteheti őket, a kisebb áram pedig csökkenti a fényerejüket anélkül, hogy kárt okozna.

Tehát egy 5V-os áramkörben szeretnénk bekapcsolni a LED-et úgy, hogy az áramerőssége 20 mA legyen. Mivel minden alkatrész egy áramkörben található, az ellenállásnak is 20 mA árama lesz.
Kapunk
2V=20mA*R
2V=0,02A*R
R = 100 ohm
100 ohm a minimális ellenállás, jobb, ha egy kicsit többet használunk, mert a LED-ek jellemzői eltérnek egymástól.
Ebben a példában 220 ohmos ellenállást használunk. Csak mert a szerzőnek sok van belőlük :wink: .

Helyezze be a LED-et a kártya közepén lévő lyukakba úgy, hogy a hosszú vezetéke csatlakozzon az ellenállás egyik vezetékéhez. Csatlakoztassa az ellenállás másik végét az 5V-hoz, a LED másik végét pedig a GND-hez. A LED-nek világítania kell.

Kérjük, vegye figyelembe, hogy különbség van a LED csatlakoztatásában. Az áram a hosszabb vezetéktől a rövidebb vezeték felé halad. A diagramon elképzelhető, hogy az áram abban az irányban folyik, amerre a háromszög irányul. Próbálja meg fordítani a LED-et, és látni fogja, hogy nem fog világítani.

De az ellenállást hogyan fogja csatlakoztatni, nincs különbség. Megfordíthatja, vagy megpróbálhatja a LED másik kimenetére csatlakoztatni, ez nem befolyásolja az áramkör működését. Továbbra is korlátozza az áramot a LED-en keresztül.

Egy Arduino vázlat anatómiája.

Az Arduino programokat vázlatnak nevezik. Két fő funkciójuk van. Funkció beállítés funkciója hurok
ezen a funkción belül beállíthatja az összes alapvető beállítást. Mely kimenetek működnek bemenetként vagy kimenetként, mely könyvtárakat kell csatlakoztatni, inicializálni a változókat. Funkció Beállít() csak egyszer fut le a vázlat alatt, amikor a program végrehajtása elindul.
ez a fő funkció, amely ezután kerül végrehajtásra beállít(). Valójában ez maga a program. Ez a funkció korlátlan ideig működik, amíg ki nem kapcsolja az áramellátást.

Arduino villogó LED

Ebben a példában egy LED áramkört csatlakoztatunk az Arduino egyik digitális érintkezőjéhez, és a programmal be- és kikapcsoljuk, valamint megtanulunk néhány hasznos funkciót.

Ezt a funkciót használják beállít() része a programnak, és a bemenetként használt tűk inicializálására szolgál (BEMENET) vagy kilép (KIMENET). Addig nem tud adatokat olvasni vagy írni a pinről, amíg megfelelően be nem állítja pinMode. Ennek a függvénynek két argumentuma van: pinkód a PIN-kód, amelyet használni fog.

mód-beállítja a tű működését. A bejáratnál (BEMENET) vagy kilép (KIMENET). A LED világításához jelet kell adnunk TÓL TŐL 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 van (általában 3 van), az egyik az MAGAS, a tűn 5v lesz, a másik meg alacsonyés a tű 0v lesz. Tehát a LED világításához magas szintet kell állítanunk a LED-hez csatlakoztatott tűn MAGAS.

Késleltetés. A program késleltetésére szolgál egy ms-ban megadott időtartamra.
Az alábbiakban látható a kód, amely miatt a LED villogni kezd.
//LED Blink int ledPin = 7;//Arduino tű, amelyhez a LED csatlakozik void setup() ( pinMode(ledPin, OUTPUT);// pin beállítása OUTPUT-ként ) void loop() ( digitalWrite(ledPin, HIGH);/ / kapcsolja be a LED késleltetést(1000);// késleltetés 1000 ms (1 mp) digitalWrite(ledPin, LOW);// Kapcsolja ki a LED késleltetést (1000);// várjon 1 másodpercet )

Kis magyarázatok a kódhoz.
A „//” karakterrel kezdődő sorok olyan megjegyzések, amelyeket az Arduino figyelmen kívül hagy.
Minden parancs pontosvesszővel végződik, ha elfelejti, hibaüzenetet kap.

ledPin egy változó. A változókat a programok az értékek tárolására használják. Ebben a példában a változó ledPin a 7-es érték van hozzárendelve, ez az Arduino PIN-kódja. Amikor az Arduino a programban találkozik egy változóval rendelkező sorral ledPin, a korábban megadott értéket fogja használni.
Szóval rekord pinMode(ledPin, OUTPUT) bejegyzéshez hasonló pinMode(7, OUTPUT).
De az első esetben csak meg kell változtatnia a változót, és minden sorában megváltozik, ahol használják, a második esetben pedig a változó megváltoztatásához minden parancsban módosítania kell a fogantyúkkal.

Az első sor a változó típusát jelzi. Az Arduino programozásakor fontos, hogy mindig deklaráljuk a változók típusát. Amíg ezt tudod INT negatív és pozitív számokat deklarál.
Az alábbiakban egy vázlatszimuláció látható. Nyomja meg a Start gombot, hogy lássa, hogyan működik az áramkör.

Ahogy az várható volt, a LED egy másodperc múlva ki- és bekapcsol. Próbálja meg módosítani a késleltetést, hogy megtudja, hogyan működik.

Több LED vezérlése.

Ebben a példában megtudhatja, hogyan vezérelhet több LED-et. Ehhez telepítsen további 3 LED-et az alaplapra, és csatlakoztassa őket az Arduino ellenállásokhoz és érintkezőkhöz az alábbiak szerint.

A LED-ek egymás utáni be- és kikapcsolásához egy ehhez hasonló programot kell írni:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; intled3Pin = 6; int led4Pin = 7; void setup() ( //tűk beállítása OUTPUT-ként pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH) );//világító LED késleltetés (1000);//késleltetés 1 mp digitalWrite(led1Pin, LOW);//kikapcs. led2Pin , HIGH); // bekapcsolja a LED késleltetést (1000);// késleltetés 1 mp digitalWrite(led2Pin, LOW);// kikapcsolja a LED késleltetést (1000);// késleltetés 1 másodperc digitalWrite(led3Pin, HIGH) ;// a LED késleltetés bekapcsolása (1000);// késleltetés 1 mp digitalWrite(led3Pin, LOW);// LED késleltetés kikapcsolása (1000);// késleltetés 1 mp digitalWrite(led4Pin, HIGH);// bekapcsolás LED késleltetés (1000);// késleltetés 1 mp digitalWrite (led4Pin, LOW);// LED késleltetés kikapcsolása (1000);//késleltetés 1 mp )

Ez a program jól fog működni, de nem a legokosabb megoldás. A kódot módosítani kell. Annak érdekében, hogy a program újra és újra működjön, egy konstrukciót alkalmazunk.
A hurkok akkor hasznosak, ha ugyanazt a műveletet többször meg kell ismételni. A fenti kódban megismételjük a sorokat

DigitalWrite(led4Pin, HIGH); késleltetés(1000); digitalWrite(led4Pin, LOW); késleltetés(1000);
teljes vázlatkód a mellékletben (letöltések száma: 1260)

LED fényerő állítás

Néha módosítania kell a programban lévő LED-ek fényerejét. Ezt a paranccsal lehet megtenni analogWrite() . Ez a parancs olyan gyorsan kapcsolja be és ki a LED-et, hogy a szem nem látja ezt a villogást. Ha a LED fele ideig világít, fele pedig kikapcsolt, akkor vizuálisan úgy tűnik, hogy fényerejének felével világít. Ezt hívják impulzusszélesség-modulációnak (angolul PWM vagy PWM). A PWM-et elég gyakran használják, mivel digitális kód segítségével egy "analóg" komponens vezérlésére használható. Nem minden Arduino tű alkalmas erre a célra. Csak azok a következtetések, amelyek közelében ilyen megjelölés található" ~ ". A 3, 5, 6, 9, 10, 11 tűk mellett látni fogja.
Csatlakoztassa az egyik LED-jét az egyik PWM érintkezőhöz (a szerző érintkezője 9). Most futtassa a LED villogó vázlatot, de először módosítsa a parancsot digitalWrite() tovább analogWrite(). analogWrite() két argumentuma van: az első a pin szám, a második a PWM érték (0-255), a LED-ek esetében ez lesz a fényerőjük, az elektromos motoroknál pedig a forgási sebesség. Az alábbiakban egy példakód látható a különböző LED-fényerősségekhez.
//A LED fényerejének módosítása int ledPin = 9;//Ebhez a lábhoz egy LED csatlakozik void setup() ( pinMode(ledPin, OUTPUT);// a kimeneti érintkező inicializálása ) void loop() ( analogWrite (ledPin, 255);// teljes fényerő (255/255 = 1) késleltetés (1000);// szünet 1 másodpercig digitalWrite(ledPin, LOW);// kikapcsolja a LED késleltetést (1000);// szünet 1 másodperc analóg írás (ledPin, 191);// fényerő 3/4 (191/255 ~= 0,75) késleltetés (1000);//szünet 1 mp digitalWrite(ledPin, LOW);//LED késleltetés kikapcsolása (1000);// szünet 1 mp analógWrite(ledPin, 127); //fél fényerő (127/255 ~= 0,5) késleltetés (1000);//szünet 1 mp digitalWrite(ledPin, LOW);//LED késleltetés kikapcsolása(1000);// szünet 1 mp analógWrite(ledPin, 63); // negyed fényerő (63/255 ~= 0,25) késleltetés (1000);// szünet 1 másodperc digitalWrite(ledPin, LOW);// LED késleltetés kikapcsolása(1000);// szünet 1 másodperc)

Próbálja megváltoztatni a PWM értéket a parancsban analogWrite() hogy ez hogyan befolyásolja a fényerőt.
Ezután megtanulhatja, hogyan állíthatja be a fényerőt zökkenőmentesen teljesről nullára. Természetesen egy kódrészletet 255-ször másolhat
analogWrite(ledPin, fényerő); delay(5);//rövid késleltetés világosság = fényerő + 1;
De érti - ez nem lesz praktikus. Ennek legjobb módja a korábban használt FOR ciklus használata.
A következő példa két hurkot használ, az egyikkel a fényerőt 255-ről 0-ra csökkenti
for (int brightness=0;rightness=0;rightness--)( analogWrite(ledPin,lightness); delay(5); )
késés [5] a be- és kiúszási sebesség lelassítására szolgál 5*256=1280ms=1,28sec.)
Az első sor a " Fényerősség-", hogy a fényerő értéket 1-gyel csökkentse minden alkalommal, amikor a ciklus ismétlődik. Vegye figyelembe, hogy a ciklus addig fut, amíg fényerő >=0.A tábla cseréje > a táblán >= 0-t vettünk a fényerő tartományba. Ezt a vázlatot az alábbiakban modellezzük. //simán változtassa a fényerőt int ledPin = 9;//egy LED csatlakozik ehhez a tűhöz void setup() ( pinMode(ledPin, OUTPUT);// a kimeneti láb inicializálása ) void loop() ( //simán növelje a fényerő (0-tól 255-ig) ehhez: (int brightness=0;brightness=0;brightness--)( analogWrite(ledPin,brightness); delay(5); ) delay(1000);//várjon 1 másodpercet //lassan csökkentse a fényerőt (255-től 0-ig) for (int brightness=255;rightness>=0;rightness--)( analogWrite(ledPin,lightness); delay(5); ) delay(1000);//várjon 1 mp-et ) )
Nem néz ki túl jól, de az ötlet világos.

RGB LED és Arduino

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

A különböző fényerejű LED-ek bekapcsolásával különböző színeket kombinálhat és kaphat. Egy 256 színátmenettel rendelkező Arduino esetén 256^3=16581375 lehetséges szín érhető el. A valóságban persze kevesebb lesz belőlük.
A LED, amelyet közös katódként fogunk használni. Azok. mindhárom LED szerkezetileg katódokkal van összekötve egy kimenettel. Ezt a tűt csatlakoztatjuk a GND érintkezőhöz. A többi kimenetet korlátozó ellenállásokon keresztül a PWM kimenetekhez kell csatlakoztatni. A szerző a 9-11 érintkezőket használta, így az egyes LED-eket külön-külön lehet vezérelni. Az első vázlat bemutatja, hogyan kell az egyes LED-eket külön-külön bekapcsolni.

//RGB LED - teszt //tűs csatlakozások int red = 9; int zöld = 10; int kék = 11; void setup()( pinMode(piros, OUTPUT); pinMode(kék, OUTPUT); pinMode(zöld, OUTPUT); ) void loop()( //a piros LED be-/kikapcsolása digitalWrite(piros, HIGH); késleltetés( 500) ; digitalWrite(piros, LOW); késleltetés(500); //a zöld LED be-/kikapcsolása digitalWrite(zöld, HIGH); késleltetés(500); digitalWrite(zöld, LOW); késleltetés(500); // kapcsolja be/ki a kék LED-et digitalWrite (kék, HIGH); késleltetés (500); digitalWrite (kék, LOW); késleltetés (500); )

A következő példa a parancsokat használja analogWrite()és különböző véletlenszerű fényerő értékeket kapni a LED-ekhez. Látni fogja, hogy a különböző színek véletlenszerűen változnak.
//RGB LED - véletlenszerű színek //tűs csatlakozások int red = 9; int zöld = 10; int kék = 11; void setup()( pinMode(piros, OUTPUT); pinMode(kék, OUTPUT); pinMode(zöld, OUTPUT); ) void loop()( //válasszon egy véletlenszerű színt analógWrite(piros, véletlenszerű(256)); analógWrite( kék, véletlenszerű (256)); analógWrite (zöld, véletlenszerű (256)); késleltetés (1000);//várjon egy másodpercet )

Véletlen (256)- 0 és 255 közötti véletlen számot ad vissza.
A csatolt fájlban egy vázlat, amely bemutatja a színek zökkenőmentes átmenetét a pirosról a zöldre, majd a kékre, pirosra, zöldre stb. (letöltések száma: 348)
A vázlatos példa működik, de sok az ismétlődő kód. Egyszerűsítheti a kódot, ha megírja saját segédfunkcióját, amely simán vált egyik színről a másikra.
Így fog kinézni: (letöltések száma: 385)
Nézzük darabonként a függvénydefiníciót. A függvényt hívják faderés két érve van. Minden argumentum vesszővel van elválasztva, és a függvénydefiníció első sorában deklarált típusuk van: void fader (belső szín1, belső szín2). Látható, hogy mindkét argumentum a következőként van deklarálva int, és el vannak nevezve szín1És szín2 mint feltételváltozók a függvény meghatározásához. Üres azt jelenti, hogy a függvény nem ad vissza semmilyen értéket, csak parancsokat hajt végre. Ha olyan függvényt kell írnia, amely a szorzás eredményét adja vissza, az így nézne ki:
int szorzó(int szám1, int szám2)( int termék = szám1*szám2; visszatérő termék; )
Figyeld meg, hogyan deklaráltuk a típust int helyett visszatérési típusként
üres.
A függvényen belül olyan parancsok találhatók, amelyeket az előző vázlatban már használt, csak a PIN-kódok lettek helyettesítve szín1És szín2. A függvényt hívják fader, argumentumait a következőképpen számítjuk ki szín1=pirosÉs szín2 = zöld. Az archívum egy teljes vázlatot tartalmaz függvények használatával (letöltések száma: 288)

Gomb

A következő vázlat normál nyitott érintkezőkkel rendelkező gombot használ, reteszelés nélkül.

Ez azt jelenti, hogy amíg a gombot nem nyomják meg, nem folyik rajta áram, elengedés után a gomb visszaáll eredeti helyzetébe.
Az áramkörben a gombon kívül ellenállást is használnak. Ilyenkor nem korlátozza az áramerősséget, hanem "felhúzza" a gombot 0v-ra (GND). Azok. amíg a gombot meg nem nyomják, az Arduino tűje, amelyhez csatlakoztatva van, alacsony lesz. A 10 kΩ-os áramkörben használt ellenállás.

//a gombnyomás meghatározása int buttonPin = 7; void setup()( pinMode(buttonPin, INPUT);//pin inicializálása a bemenethez Serial.begin(9600);//soros port inicializálása ) void loop()( if (digitalRead(buttonPin)==HIGH)(//if a gombot megnyomják Serial.println("pressed"); // "nyomva" nyomtatás
Ebben a vázlatban több új parancs is található.
-Ez a parancs elfogadja az általunk ellenőrzött kimenet High (magas szint) és alacsony (alacsony) értékét. Korábban a setup()-ban ezt a kimenetet bemenetként kellett konfigurálni.
; //ahol a gombPin az a PIN-kód, amelyhez a gomb csatlakoztatva van.
A soros port lehetővé teszi, hogy az Arduino üzeneteket küldjön a számítógépnek, miközben a vezérlő maga hajtja végre a programot. Ez hasznos egy program hibakereséséhez, üzenetek küldéséhez más eszközöknek vagy alkalmazásoknak. A soros porton keresztüli adatátvitel engedélyezéséhez (az UART vagy USART másik neve), inicializálnia kell azt a beállításban ()

Serial.begin() egyetlen érve van - ez az Arduino és a számítógép közötti adatátviteli sebesség.
A vázlat egy parancs segítségével üzenetet jelenít meg a képernyőn az Arduino IDE-ben (Eszközök >> Soros monitor).
- a kialakítás lehetővé teszi a program előrehaladásának ellenőrzését több ellenőrzés egy helyen történő kombinálásával.
Ha(ha) a digitalRead HIGH értéket ad vissza, akkor a "megnyomva" szó jelenik meg a monitoron. Egyébként (egyébként) a "megnyomva" szó jelenik meg a monitoron. Most megpróbálhatja egy gombnyomással be- és kikapcsolni a LED-et.
//gombnyomás érzékelés LED kimenettel int buttonPin = 7; int ledPin = 8; void setup()( pinMode(buttonPin, INPUT);//ez alkalommal a gombtűt INPUT-ként állítjuk be pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop()( if (digitalRead(buttonPin)= =MAGAS)( digitalWrite(ledPin,HIGH); Serial.println("lenyomva"); ) else ( digitalWrite(ledPin,LOW); Serial.println("nem nyomott"); ) )

Analóg bemenet.

analogRead lehetővé teszi az adatok olvasását az egyik Arduino analóg érintkezőről, és 0 (0V) és 1023 (5V) közötti tartományban ad ki értéket. Ha az analóg bemenet feszültsége 2,5 V, akkor 2,5 / 5 * 1023 = 512 kerül kinyomtatásra
analogRead csak egy argumentuma van - Ez az analóg bemenet száma (A0-A5). A következő vázlat a feszültség potenciométerről történő leolvasásának kódját mutatja. Ehhez csatlakoztasson egy változtatható ellenállást, a szélső kivezetésekkel az 5V-os és a GND érintkezőkkel, a középső kivezetéssel az A0 bemenettel.

Futtassa a következő kódot, és nézze meg a soros monitoron, hogyan változnak az értékek az ellenállás gombjának elfordulásától függően.
//analóg bemenet int potPin = A0;//a potenciométer középső tűje ehhez a lábhoz csatlakozik void setup()( //az analóg pin alapértelmezés szerint engedélyezve van bemenetként, így nincs szükség inicializálásra Serial.begin(9600); ) void loop()( int potVal = analogRead(potPin);//potVal egy szám 0 és 1023 között Serial.println(potVal); )
A következő vázlat a gombnyomás vázlatát és a LED fényerőszabályzó vázlatát egyesíti. A LED kigyullad a gombról, és a potenciométer szabályozza az izzás fényerejét.
//gombnyomás-érzékelés LED-kimenettel és változó intenzitású int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup()( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop()( if (digitalRead(buttonPin)==HIGH)(//ha gomb megnyomva int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal); // LED bekapcsolása pot által beállított intenzitással Serial. println("pressed"); ) else ( digitalWrite(ledPin, LOW);//kikapcsolás, ha nincs megnyomva a gomb Serial.println("lenyomva"); ) )

Új házi készítésű termékek kiszállítása a postára

Válogatott új házi készítésű termékeket kaphat postai úton. Nincs spam, csak hasznos ötletek!

Ebben a cikkben úgy döntöttem, hogy összeállítok egy teljes, lépésről lépésre szóló útmutatót kezdő Arduino számára. Elemezzük, mi az arduino, mi kell a tanulás megkezdéséhez, hol tölthető le és hogyan telepíthető és konfigurálható a programozási környezet, hogyan működik és hogyan kell használni a programozási nyelvet, és még sok mást, ami a teljes értékű létrehozásához szükséges ezeknek a mikrokontrollereknek a családján alapuló összetett eszközök.

Itt megpróbálok tömör minimumot adni, hogy megértse az Arduino-val való munka alapelveit. A programozható mikrokontrollerek világában való teljesebb elmerüléshez figyeljen az oldal más szakaszaira és cikkeire. Néhány szempont részletesebb tanulmányozása érdekében hivatkozásokat hagyok ezen az oldalon más anyagokra.

Mi az az Arduino és mire való?

Az Arduino egy elektronikus készlet, amely lehetővé teszi bárki számára, hogy különféle elektromechanikus eszközöket hozzon létre. Az Arduino szoftverből és hardverből áll. A szoftver rész tartalmaz egy fejlesztőkörnyezetet (firmware írási és hibakereső program), sok kész és kényelmes könyvtárat, valamint egy egyszerűsített programozási nyelvet. A hardveres rész mikrokontrollerek nagy sorát és a hozzájuk való kész modulokat tartalmazza. Ennek köszönhetően az Arduino-val nagyon egyszerű dolgozni!

Az arduino segítségével programozást, elektrotechnikát és mechanikát tanulhatsz. De ez nem csak egy képzési konstruktőr. Ez alapján igazán hasznos eszközöket lehet készíteni.
Kezdve az egyszerű villogó lámpákkal, időjárás-állomásokkal, automatizálási rendszerekkel és az okosotthon-rendszerekkel, CNC-gépekkel és pilóta nélküli légi járművekkel. A lehetőségeknek még a fantáziád sem szab határt, mert rengeteg instrukció és ötlet létezik a megvalósításhoz.

Arduino Starter Kit

Az Arduino tanulásának megkezdéséhez magának a mikrovezérlő kártyának és további részleteknek kell lennie. A legjobb, ha egy Arduino kezdőkészletet vásárol, de mindent, amire szüksége van, saját maga is felveheti. Azt tanácsolom, hogy válasszon készletet, mert egyszerűbb és gyakran olcsóbb is. Íme linkek a legjobb készletekhez és egyes alkatrészekhez, amelyek biztosan hasznosak lesznek a tanulmányozáshoz:

Alap arduino készlet kezdőknek:	megvesz
Nagy készlet képzésekhez és első projektekhez:	megvesz
További érzékelők és modulok készlete:	megvesz
Az Arduino Uno a legalapvetőbb és legkényelmesebb modell a sorozatból:	megvesz
Forrasztás nélküli kenyértábla az egyszerű tanuláshoz és prototípuskészítéshez:	megvesz
Vezetékkészlet kényelmes csatlakozókkal:	megvesz
LED készlet:	megvesz
Ellenállás készlet:	megvesz
Gombok:	megvesz
Potenciométerek:	megvesz

Arduino IDE fejlesztői környezet

A firmware írásához, hibakereséséhez és feltöltéséhez le kell töltenie és telepítenie kell az Arduino IDE-t. Ez egy nagyon egyszerű és kényelmes program. Az oldalamon már leírtam a fejlesztői környezet letöltésének, telepítésének és konfigurálásának folyamatát. Ezért itt egyszerűen hivatkozásokat fogok hagyni a program legújabb verziójára és a

Változat	ablakok	Mac OS X	Linux
1.8.2

Arduino programozási nyelv

Ha kéznél van egy mikrokontroller kártya, és telepítve van egy fejlesztői környezet a számítógépére, elkezdheti írni az első vázlatokat (firmware). Ehhez meg kell ismerkednie a programozási nyelvvel.

Az Arduino programozás a C++ nyelv egyszerűsített változatát használja előre meghatározott funkciókkal. A többi C-szerű programozási nyelvhez hasonlóan a kódírásnak számos szabálya van. Íme a legalapvetőbbek:

Minden állítást pontosvesszőnek (;) kell követnie
A függvény deklarálása előtt meg kell adni a függvény által visszaadott adattípust, vagy érvénytelen, ha a függvény nem ad vissza értéket.
A változó deklarálása előtt meg kell adni az adattípust is.
A megjegyzéseket a következő jelzi: // Inline és /* blokk */

Az oldalon többet megtudhat az adattípusokról, függvényekről, változókról, operátorokról és nyelvi konstrukciókról, ezeket az információkat nem kell megjegyeznie és memorizálnia. Mindig a hivatkozásra léphet, és megtekintheti egy adott függvény szintaxisát.

Az összes Arduino firmware-nek legalább 2 funkciót kell tartalmaznia. Ezek a setup() és a loop().

beállítási funkció

Ahhoz, hogy minden működjön, vázlatot kell írnunk. Tegyük úgy, hogy a LED a gomb megnyomása után világít, a következő megnyomás után pedig kialszik. Íme az első vázlatunk:

// változók a csatlakoztatott eszközök lábaival int switchPin = 8; int ledPin = 11; // változók a gomb állapotának és a LED logikai értékének tárolására lastButton = LOW; logikai aktuális gomb = LOW; logikai ledOn = hamis; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // debounce függvény boolean debounse(boolean last) ( logikai aktuális = digitalRead(switchPin); if(last != current) ( késleltetés (5) ); current = digitalRead(switchPin); ) return current; ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ;digitalWrite (ledPin, ledOn); )

// változók a csatlakoztatott eszközök lábaival

int switchPin = 8 ;

int ledPin = 11 ;

// változók a gomb és a LED állapotának tárolására

logikai lastButton = LOW ;

logikai currentButton = LOW ;

logikai ledOn = false ;

void setup()(

pinMode (switchPin , INPUT ) ;

pinMode (ledPin , OUTPUT ) ;

// debounce függvény

logikai visszapattanás (boolean last ) (

logikai áram = digitalRead(switchPin) ;

if (utolsó != aktuális ) (

késleltetés(5) ;

áram = digitalRead(kapcsolóPin) ;

visszatérő áram ;

void loop()(

currentButton = debounce(lastButton) ;

if (lastButton == LOW && currentButton == HIGH ) (

ledOn = ! ledOn ;

lastButton = currentButton ;

digitalWrite(ledPin , ledOn ) ;

Ebben a vázlatban létrehoztam egy további visszapattanási funkciót az érintkezés visszapattanásának elnyomására. A kapcsolatok visszapattanásáról a honlapomon található. Feltétlenül nézze meg ezt az anyagot.

PWM Arduino

Az impulzusszélesség-moduláció (PWM) a feszültség szabályozásának folyamata egy jel munkaciklusának felvételével. Vagyis a PWM segítségével simán tudjuk szabályozni a terhelést. Például egy LED fényerejét simán lehet változtatni, de ezt a fényerő-változást nem a feszültség csökkentésével, hanem az alacsony jelintervallumok növelésével érjük el. A PWM működési elve az alábbi ábrán látható:

Amikor PWM-et alkalmazunk egy LED-re, az gyorsan be- és kikapcsolni kezd. Az emberi szem nem látja ezt, mert a frekvencia túl magas. De videózáskor valószínűleg olyan pillanatokat fog látni, amikor a LED kialszik. Ez akkor történik meg, ha a kamera képfrekvenciája nem többszöröse a PWM frekvenciának.

Az Arduino beépített impulzusszélesség-modulátorral rendelkezik. A PWM-et csak azokon a lábakon használhatja, amelyeket a mikrokontroller támogat. Például az Arduino Uno és a Nano 6 PWM kimenettel rendelkezik: ezek a D3, D5, D6, D9, D10 és D11 érintkezők. A csapok más táblákon eltérőek lehetnek. Megtalálhatja az Önt érdeklő tábla leírását

A PWM használatához az Arduino rendelkezik egy funkcióval, amely argumentumként a pin számot és a PWM értéket veszi fel 0 és 255 között. Példaként írjunk egy egyszerű vázlatot. Tegyük meg, hogy a LED zökkenőmentesen világítson, várjunk egy másodpercet, és ugyanolyan simán elhalványuljon, és így tovább a végtelenségig. Íme egy példa a függvény használatára:

// LED a 11-es lábhoz csatlakoztatva int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analógWrite(ledPin, i); késleltetés(5); ) )

// LED a 11-es érintkezőhöz csatlakozik

int ledPin = 11 ;

void setup()(

pinMode (ledPin , OUTPUT ) ;

void loop()(

for (int i = 0 ; i< 255 ; i ++ ) {

analogWrite (ledPin , i );

késleltetés(5) ;

késleltetés(1000) ;

for (int i = 255 ; i > 0 ; i -- ) (

Az Arduino nagyon népszerű a barkácsolók körében. Be kell mutatni nekik és azoknak, akik még soha nem hallottak róla.

Mi az az Arduino?

Hogyan jellemezné röviden az Arduino-t? A legjobb szavak a következők lennének: Az Arduino egy olyan eszköz, amellyel különféle elektronikus eszközöket hozhat létre. Valójában ez egy igazi hardveres számítási platform univerzális használatra. Mind egyszerű áramkörök építésére, mind meglehetősen összetett projektek megvalósítására használható.

A konstruktor a hardverén alapul, ami egy I/O kártya. A tábla C/C++ alapú nyelvekkel van programozva. Ezeket rendre Processing/Wiring néven kapták. A C csoportból a rendkívüli egyszerűséget örökölték, aminek köszönhetően bárki nagyon gyorsan elsajátítja őket, és a tudás gyakorlati alkalmazása sem jelent jelentős problémát. Hogy képet adjunk arról, milyen könnyű dolgozni, gyakran mondják, hogy az Arduino kezdő varázslóknak való. Még a gyerekek is tudnak bánni az Arduino táblákkal.

Mit lehet gyűjteni rajta?

Az Arduino felhasználása meglehetősen sokrétű, használható mind a cikk végén ajánlott legegyszerűbb példákra, mind pedig meglehetősen összetett mechanizmusokra, beleértve a manipulátorokat, robotokat vagy gyártógépeket. Egyes kézműveseknek sikerül tableteket, telefonokat, otthoni felügyeleti és biztonsági rendszereket, intelligens otthoni rendszereket vagy éppen számítógépeket készíteni ilyen rendszerek alapján. A cikk végén találhatók a kezdőknek szánt Arduino projektek, amelyeket még tapasztalatlanok is elkezdhetnek. Még primitív virtuális valóság-rendszerek létrehozására is használhatók. Mindez a meglehetősen sokoldalú hardvernek és az Arduino programozás nyújtotta lehetőségeknek köszönhető.

Hol lehet alkatrészeket vásárolni?

Az Olaszországban gyártott alkatrészek eredetinek számítanak. De az ilyen készletek ára nem alacsony. Ezért számos cég vagy akár magánszemély készít kézműves Arduino-kompatibilis eszközöket és alkatrészeket, amelyeket viccből termelési klónoknak neveznek. Az ilyen klónok vásárlásakor lehetetlen biztosan megmondani, hogy működni fognak, de a pénzmegtakarítási vágy megbosszulja magát.

Az alkatrészek készlet részeként vagy külön-külön is megvásárolhatók. Vannak még előre elkészített készletek autók, helikopterek különböző típusú kezelőszervekkel vagy hajók összeszereléséhez. A fenti képhez hasonló, Kínában készült készlet 49 dollárba kerül.

Bővebben a hardverről

Az Arduino kártya egy egyszerű AVR mikrokontroller, amelyet bootloaderrel villantottak fel, és rendelkezik a minimálisan szükséges USB-UART porttal. Még mindig vannak fontos összetevők, de a cikk határain belül jobb lesz csak ennél a két összetevőnél megállni.

Először is a mikrokontrollerről, egy egyetlen áramkörre épített mechanizmusról, amelyben a kifejlesztett program található. A program befolyásolható gombnyomással, jelek fogadásával az alkotás összetevőitől (ellenállások, tranzisztorok, érzékelők stb.) stb. Sőt, az érzékelők rendeltetésükben nagyon eltérőek lehetnek: világítás, gyorsulás, hőmérséklet, távolság, nyomás, stb. akadályok stb. Kijelzőként egyszerű alkatrészek használhatók, a LED-ektől és magassugárzóktól az összetett eszközökig, például grafikus kijelzőkig. Motoroknak, szelepeknek, reléknek, szervóknak, elektromágneseknek és sok másnak számítanak, amelyek nagyon-nagyon hosszú ideig szerepelnek. Valamivel ezekből a listákból az MK közvetlenül működik, összekötő vezetékek segítségével. Egyes mechanizmusokhoz adapterekre van szükség. De ha elkezdesz tervezni, nehéz lesz elszakadnod. Most beszéljünk az Arduino programozásról.

Tudjon meg többet a tábla programozási folyamatáról

Az olyan programot, amely már készen áll a mikrokontrolleren való munkára, firmware-nek nevezzük. Egy projekt és Arduino projekt is lehet, ezért kívánatos lenne minden firmware-t külön mappában tárolni a megfelelő fájlok megtalálásának felgyorsítása érdekében. Speciális eszközökkel: programozókkal van felvarrva az MK kristályra. És itt az "Arduino"-nak van egy előnye - nincs szüksége programozóra. Mindent úgy csinálnak, hogy az Arduino programozása kezdőknek ne legyen nehéz. Az írott kód USB kábelen keresztül letölthető az MK-ra. Ezt az előnyt nem néhány előre megépített programozó éri el, hanem egy speciális firmware - egy rendszerbetöltő. A bootloader egy speciális program, amely a csatlakozás után azonnal lefut, és figyeli, hogy vannak-e parancsok, kell-e flashelni a chipet, vannak-e Arduino projektek vagy sem. A rendszerbetöltő használatának számos nagyon vonzó előnye van:

Csak egy kommunikációs csatorna használata, amely nem igényel további időköltséget. Tehát az Arduino projektekhez nem szükséges sok különböző vezeték csatlakoztatása, és használatuk során zavart okozott. Egy USB kábel elegendő a sikeres működéshez.
Védelem a görbe kezek ellen. A mikrokontroller tégla állapotba hozása direkt firmware segítségével meglehetősen egyszerű, nem kell sokat erőlködni. Amikor bootloaderrel dolgozunk, nem juthatunk el a potenciálisan veszélyes beállításokhoz (természetesen fejlesztői program segítségével, különben mindent összetörhetünk). Ezért az Arduino kezdőknek nem csak abból a szempontból készült, hogy érthető és kényelmes, hanem lehetővé teszi a nemkívánatos pénzügyi kiadások elkerülését is, amelyek a velük dolgozó személy tapasztalatlanságával járnak.

Indítandó projektek

A készlet, a forrasztópáka, a gyanta és a forrasztószer beszerzése után nem szabad azonnal nagyon bonyolult szerkezeteket faragni. Természetesen elvakíthatja őket, de az Arduino sikerének esélye a kezdőknek meglehetősen alacsony összetett projektek esetén. Az edzéshez és a kezek "töméséhez" megpróbálhatsz néhány egyszerűbb ötletet megvalósítani, amelyek segítenek megbirkózni az Arduino interakciójával és működésével. A kezdőknek szánt Arduino használatának első lépéseiként azt tanácsolhatjuk, hogy fontolja meg:

Hozzon létre egyet, amely működni fog az "Arduino"-nak köszönhetően.
Külön gomb csatlakoztatása az Arduino-hoz. Ebben az esetben lehetőség van arra, hogy a gomb az 1. ponttól kezdve képes legyen a LED világításának vezérlésére.
Potenciométer csatlakozás.
Szervo vezérlés.
Csatlakoztatás és működés háromszínű LED-del.
A piezoelektromos elem csatlakoztatása.
Fotoellenállás csatlakozás.
Mozgásérzékelő csatlakoztatása és a működésére vonatkozó jelzések.
Páratartalom vagy hőmérséklet érzékelő csatlakoztatása.

Projektek a jövőre nézve

Nem valószínű, hogy érdekli az "Arduino" az egyes LED-ek csatlakoztatása érdekében. Valószínűleg vonzza a lehetőség, hogy saját autót vagy repülő lemezjátszót készítsen. Az ilyen projekteket nehéz megvalósítani, sok időt és kitartást igényelnek, de teljesítve azt kapod, amit akartál: értékes Arduino tervezési tapasztalatot kezdőknek.

Cikkek és oktatóanyagok sorozata kezdőknek, Arduino rádióamatőr kísérletekkel. Ez egy olyan amatőr rádiós játéktervező, amelyből forrasztópáka, nyomtatott áramköri lapok maratása és hasonlók nélkül bármilyen elektronikai vízforraló össze tud állítani egy teljes értékű működő eszközt, amely alkalmas professzionális prototípuskészítésre és amatőr kísérletekre is. elektronikát tanul.

Az Arduino tábla elsősorban arra szolgál, hogy kezdő rádióamatőröket tanítson a mikrokontrollerek programozásának alapjaira és saját kezűleg készítsen mikrokontroller eszközöket komolyabb elméleti képzés nélkül. Az Arduino fejlesztői környezet lehetővé teszi, hogy kész programkódot fordítsunk le és töltsünk be az alaplap memóriájába. Ráadásul a kód letöltése rendkívül egyszerű.

Arduino hol kezdje a kezdőt

Először is, az Arduino táblával való munkához egy kezdő elektronikai mérnöknek le kell töltenie az Arduino fejlesztőprogramot, ez egy beépített szövegszerkesztőből áll, amelyben programkóddal dolgozunk, egy üzenetterületről, egy szöveges kimeneti ablakból (konzol ), egy eszköztár a gyakran használt parancsokhoz gombokkal és több menüvel. A program letöltéséhez és a kommunikációhoz ez a program szabványos USB-kábellel csatlakozik az Arduino kártyához.

Az Arduino környezetben írt kódot hívják vázlat. Szövegszerkesztőben írják, amely speciális eszközökkel rendelkezik a szöveg beszúrásához / kivágásához, cseréjéhez / kereséséhez. Mentés és exportálás közben az üzenetterületen (lásd az ábrát az első kezdőknek szóló oktatóanyagban, közvetlenül lent) magyarázatok jelennek meg, és hibák is megjelenhetnek. A konzol Arduino üzeneteket jelenít meg, beleértve a teljes hibajelentéseket és egyéb hasznos információkat. Az eszköztár gombjai lehetővé teszik a vázlatok ellenőrzését és rögzítését, megnyitását, létrehozását és mentését, soros busz figyelésének megnyitását és még sok mást.

Tehát folytassuk az első Arduino áramköri leckét kezdő elektronikai mérnököknek.

A kezdők kényelmét szolgálja, hogy az Arduino UNO vezérlő már rendelkezik ellenállással és a csatlakozó 13-as érintkezőjére csatlakoztatott LED-del, így az első kísérletben nincs szükségünk külső rádióelemekre.

A kód betöltésével az Arduino lehetővé teszi, hogy programunk részt vegyen a rendszer inicializálásában. Ehhez jelezzük a mikrokontrollernek azokat a parancsokat, amelyeket az első rendszerindításkor végrehajt, majd teljesen elfelejtjük őket (azaz ezeket a parancsokat az Arduino csak egyszer hajtja végre indításkor). És erre a célra a kódunkban lefoglalunk egy blokkot, amelyben ezek a parancsok vannak tárolva. void setup(), vagy inkább a funkció göndör kapcsos zárójeleinek belsejében, lásd a programozási vázlatot.

Ne felejtsd el a göndör fogszabályzót! Ha bármelyiket is elveszíti, az egész vázlat teljesen működésképtelenné válik. De ne tegyen extra zárójeleket, mert hiba is előfordul.

Kód letöltése:

Vázlat megjegyzésekkel és magyarázatokkal a 001-1_mig-led.ino fájlban

Funkció void loop() ide helyezzük azokat a parancsokat, amelyek addig futnak, amíg az Arduino be van kapcsolva. A végrehajtást az első parancstól kezdve az Arduino a végére ér, és azonnal az elejére ugrik, hogy megismételje ugyanazt a sorozatot. És így végtelen számú alkalommal, amíg a tábla kap áramot. Lényegében az üres hurok a fő funkció, az Arduino belépési pontja.

Funkció késleltetés(1000) 1000 ezredmásodperccel késlelteti a program feldolgozását. Mindez örök körforgásban megy végbe hurok().

A fő következtetés az első Arduino programunk észlelése után: A void loop és void setup funkciók segítségével adjuk át utasításainkat a mikrokontrollernek. A beállítási blokkon belül minden csak egyszer kerül végrehajtásra. A ciklusmodul tartalma egy ciklusban ismétlődik, amíg az Arduino bekapcsolva marad.

Az előző programban egy másodperces késleltetés volt a LED be- és kikapcsolása között. Egy nagy mínusz volt a fent használt kezdő arduinist legegyszerűbb kódjában. A LED be- és kikapcsolása közötti szünet egy másodpercben tartásához alkalmaztuk a funkciót késleltetés()és ezért abban a pillanatban a vezérlő nem képes más parancsok végrehajtására a fő funkcióban hurok(). A kód javítása a függvényben hurok( Az alábbiakban bemutatott ) megoldja ezt a problémát.

Ahelyett, hogy az értéket HIGH-ra, majd LOW-ra állítanánk, megkapjuk a ledPin értékét, és megfordítjuk. Tegyük fel, ha MAGAS volt, akkor LOW lesz, stb.

Második arduino kódváltozat a led vezérléséhez Itt:

Ezután lecserélheti a funkciót késleltetés(). Ehelyett jobb a funkciót használni millis(). A program indítása óta eltelt ezredmásodpercek számát adja vissza. Körülbelül 50 nappal a kód futtatása után a funkció túlcsordul.

Hasonló funkció az micros(), amely a kód futtatása óta eltelt mikromásodpercek számát adja vissza. A funkció 70 perccel a program futtatása után nullára áll vissza.

Természetesen ez néhány sor kóddal bővíti a vázlatunkat, de határozottan tapasztaltabb programozóvá tesz, és növeli Arduino potenciálját. Ehhez csak meg kell tanulnia a millis függvény használatát.

Világosan meg kell érteni, hogy a legegyszerűbb késleltetési funkció felfüggeszti a teljes Arduino program végrehajtását, így ez alatt az idő alatt nem tud semmilyen feladatot végrehajtani. A teljes programunk szüneteltetése helyett megszámolhatjuk, hogy mennyi idő telt el az akció befejezése előtt. Ezt szépen a millis() függvény segítségével valósítjuk meg. Annak érdekében, hogy minden könnyen érthető legyen, figyelembe vesszük a következő lehetőséget a LED késleltetés nélküli villogására.

Ennek a programnak az eleje megegyezik bármely más szabványos Arduino vázlattal.

Ez a példa két Arduino digitális I/O-t használ. A LED a 8-as érintkezőhöz csatlakozik, amely OUTPUT-ként van konfigurálva. Egy gomb csatlakozik a 9 átmenethez, amely BEMENET-ként van konfigurálva. Amikor megnyomjuk a gombot, a 9-es láb HIGH-ra áll, a 8-ast pedig HIGH-ra kapcsolja a program, ezzel bekapcsolva a LED-et. A gomb elengedése visszaállítja a kilencedik kimenetet LOW állapotba. A kód ezután a 8-as érintkezőt LOW állásba kapcsolja, és kikapcsolja a jelzőfényt.

Az öt LED vezérléséhez különféle manipulációkat fogunk alkalmazni az Arduino portokkal. Ehhez közvetlenül az Arduino portokra írunk adatokat, ez lehetővé teszi, hogy egyetlen funkcióval beállítsa a LED-ek értékeit.

Az Arduino UNO három porttal rendelkezik: B(digitális bemenetek/kimenetek 8-tól 13-ig); C(analóg bemenetek); D(Digitális I/Ok 0-7)

Minden port három regisztert vezérel. Az első DDR határozza meg, hogy a láb bemenet vagy kimenet lesz-e. A második PORT regiszter segítségével a pint HIGH vagy LOW állapotba állíthatjuk. A harmadik segítségével információkat olvashatunk az Arduino lábak állapotáról, ha bemenetként működnek.

Az áramkör működéséhez a B portot használjuk. Ehhez állítsa be a port összes lábát digitális kimenetként. A B portnak összesen 6 érintkezője van. A DDRB regiszter bitjeit be kell állítani "1" ha a tűt OUTPUT-ként fogják használni, és be "0" ha a tűt bemenetként tervezzük használni (INPUT). A portbitek 0-tól 7-ig vannak számozva, de nem mindig rendelkeznek mind a 8 érintkezővel

Mondjuk: DDRB = B00111110;// a B port 1-től 5-ig tartó lábait állítsa be kimenetként és 0-t bemenetként.

Futólámpáink áramkörében öt kimenetet használunk: DDRB = B00011111; // a B port 0-tól 4-ig tartó lábait állítsa be kimenetként.

Adatok B portra írásához a PORTB regisztert kell használni. Az első LED-et a vezérlőparanccsal világíthatja meg: PORTB=B00000001;, első és negyedik LED: PORTB=B00001001 stb

Két bináris eltolási operátor létezik: balra és jobbra. A bal oldali eltolás operátor az összes adatbitet balra, a jobbra váltó operátor jobbra mozgatja.

Példa:

varA = 1; // 00000001
varA = 1 varA = 1 varA = 1

Most térjünk vissza programunk forráskódjához. Két változót kell bevezetnünk: fel le tartalmazni fogja azokat az értékeket, ahol mozoghat - felfelé vagy lefelé, és a második cylon jelzi, melyik led világít.

Szerkezetileg egy ilyen LED-nek minden színhez egy közös kimenete és három kimenete van. Az alábbiakban egy RGB LED-nek egy közös katóddal ellátott Arduino kártyához való csatlakoztatásának diagramja látható. A csatlakozó áramkörben használt összes ellenállásnak azonos értékűnek kell lennie 220-270 ohm között.

A közös katóddal való csatlakoztatáshoz a háromszínű led bekötési sémája majdnem ugyanaz lesz, kivéve, hogy a közös érintkezőt nem a földre kell kötni (gnd a készüléken), hanem a +5 voltos kivezetéshez. A piros, zöld és kék kimenetek mindkét esetben a 9, 10 és 11 vezérlő digitális kimeneteire csatlakoznak.

Csatlakoztasson egy külső LED-et az Arduino UNO kilencedik érintkezőjéhez 220 ohmos ellenálláson keresztül. Utóbbi fényerejének zökkenőmentes szabályozására a funkciót használjuk analogWrite(). PWM jelkimenetet biztosít a vezérlő lábához. És a csapat pinMode() telefonálás nem kötelező. Mert analógWrite(pin,érték) két paramétert tartalmaz: pin - pin száma a kimenethez, érték - érték 0 és 255 között.

Kód:
/*
Egy képzési példa egy kezdő arduino számára, feltárja az analogWrite () parancs lehetőségeit a LED Fade hatásának megvalósítására
*/
int fényerő = 0; // LED fényerő
int fadeAmount = 5; // fényerő lépés
unsigned long currentTime;
unsigned long loopTime;

Érvénytelen beállítás() (
pinMode(9, OUTPUT); // a 9-es láb beállítása kimenetként
currentTime = millis();
loopTime = currentTime;
}

void loop() (
currentTime = millis();
if(currentTime >= (loopTime + 20))(
analógWrite(9, fényerő); // érték beállítása a 9-es lábon

Fényerő = fényerő + fadeAmount; // adjunk hozzá egy lépést a fényerő módosításához, amelyet a következő ciklusban állítunk be

// ha min. vagy max. értékeket, akkor az ellenkező irányba megyünk (vissza):
if (fényerő == 0 || fényerő == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = currentTime;
}
}

Működő Arduino kódolóval

A kódolót úgy tervezték, hogy a forgásszöget elektromos jellé alakítsa át. Ebből két jelet (A és B) kapunk, amelyek fázisban ellentétesek. Ebben az oktatóanyagban a SparkFun COM-09117 kódolót fogjuk használni, amelynek fordulatonként tizenkét pozíciója van (mindegyik pozíció pontosan 30°). Az alábbi ábra jól mutatja, hogy az A és B kimenet hogyan függ egymástól, amikor a jeladó az óramutató járásával megegyező vagy ellentétes irányban mozog.

Ha az A jel pozitívról nullára megy, akkor a B kimenet értékét olvassuk le. Ha a B kimenet ekkor pozitív állapotban van, akkor a kódoló az óramutató járásával megegyező irányba mozog, ha B nulla szintet ad ki, akkor a kódoló bemozdul. ellenkező irányba. Mindkét kimenet leolvasásával mikrokontroller segítségével tudjuk kiszámítani a forgásirányt, az enkóder A kimenetéből érkező impulzusok számlálásával pedig a forgásszöget.

Ha szükséges, a frekvenciaszámítással meghatározhatja, milyen gyorsan forog a kódoló.

Az oktatóanyagunkban található kódoló segítségével a PWM kimenet segítségével szabályozzuk a LED fényerejét. A kódolóból származó adatok olvasásához szoftveres időzítőkön alapuló módszert használunk, amelyet már tárgyaltunk.

Tekintettel arra, hogy a leggyorsabb esetben 1/10 másodperc alatt tudjuk 180°-kal elfordítani a kódológombot, ez 1/10 másodperc alatt 6, egy másodperc alatt 60 impulzus lesz.

A valóságban nem lehet gyorsabban forogni. Mivel minden félciklust nyomon kell követnünk, a frekvenciának 120 Hertz körül kell lennie. A teljes biztonság kedvéért vegyünk 200 Hz-et.

Mivel ebben az esetben mechanikus kódolót használunk, lehetséges a kontaktus visszapattanása, és az alacsony frekvencia tökéletesen kiszűri az ilyen visszapattanásokat.

A szoftveres időzítő jelei szerint folyamatosan össze kell hasonlítani a kódoló A kimenetének aktuális értékét az előző értékkel. Ha az állapot pozitívról nullára változik, akkor lekérdezzük a B kimenet állapotát. Az állapotlekérdezés eredményétől függően növeljük vagy csökkentjük a LED fényerejének számlálóját. Az alábbiakban látható a kb. 5 ms (200 Hz) időintervallumú programkód:

Arduino kezdő kód:
/*
** Kódoló
** A Sparkfun kódolója a LED fényerejének szabályozására szolgál
*/

int fényerő = 120; // LED fényereje, felétől kezdve
int fadeAmount = 10; // fényerő lépés
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 12; // 12. tű
const int pin_B = 11; // 11. tű
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_A_prev=0;
void setup()(
// deklarálja a 9-es érintkezőt kimenetnek:
pinMode(9, OUTPUT); // a 9-es láb beállítása kimenetként
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
currentTime = millis();
loopTime = currentTime;
}
void loop() (
currentTime = millis();
if(currentTime >= (loopTime + 5))( // állapotok ellenőrzése 5 ms-ként (200 Hz-es frekvencia)
kódoló_A = digitalRead(pin_A); // kódoló kimenetének olvasása A állapot
kódoló_B = digitalRead(pin_B); // B kódoló kimenet
if((!encoder_A) && (encoder_A_prev))( // ha az állapot pozitívról nullára változik
if(kódoló_B) (
// A B kimenet pozitív, tehát az óramutató járásával megegyező irányban forog
// növelje a ragyogás fényerejét, legfeljebb 255
if(fényerő + fadeAmount )
más(
// a B kimenet nulla állapotban van, tehát a forgatás az óramutató járásával ellentétes
// csökkenti a fényerőt, de nulla alá nem
if(fényerő - fadeAmount >= 0) brightness -= fadeAmount;
}

}
kódoló_A_előző = kódoló_A; // mentse el az A értékét a következő ciklushoz

analógWrite(9, fényerő); // állítsa a fényerőt a kilencedik tűre

LoopTime = currentTime;
}
}

Ebben a kezdő példában megvizsgáljuk a piezo berregővel való munkát a hangok generálására. Ehhez vegyen egy piezoelektromos átalakítót, amely lehetővé teszi hanghullámok generálását a 20 Hz - 20 kHz frekvenciatartományban.

Ez egy olyan amatőr rádiókialakítás, ahol a LED-ek az egész hangerőben találhatók. Ezzel a sémával különféle világítási és animációs effektusokat hozhat létre. Az összetett sémák akár különféle háromdimenziós szavakat is megjeleníthetnek. Más szóval, ez egy elemi térhatású monitor

A szervó a fő eleme a különféle rádióvezérlésű modellek felépítésének, vezérlése a vezérlővel egyszerű és kényelmes.

A vezérlőprogram egyszerű és intuitív. A szervo vezérléséhez szükséges összes parancsot tartalmazó fájl csatlakoztatásával kezdődik. Ezután létrehozunk egy szervo objektumot, például a servoMain-t. A következő setup() függvény, amelyben megadjuk, hogy a szervo a vezérlő kilencedik kimenetére csatlakozzon.

Kód:
/*
Arduino szervo
*/
#beleértve
Szervo fő; // Szervo objektum

Érvénytelen beállítás()
{
szervoMain.attach(9); // Szervo csatlakoztatva a 9-es érintkezőhöz
}

Void loop()
{
szervoMain.write(45); // Forgassa el a szervót 45°-kal balra
késleltetés (2000); // Várjon 2000 milliszekundumot (2 másodperc)
szervoMain.write(0); // A szervó elforgatása 0°-kal balra
késleltetés(1000); // 1-es szünet.

késleltetés(1500); // Várjon 1,5 másodpercet.
szervoMain.write(135); // Forgassa el a szervót 135°-kal jobbra
késleltetés(3000); // 3 másodperc szünet.
szervoMain.write(180); // Forgassa el a szervót 180°-kal jobbra
késleltetés(1000); // Várj 1 másodpercet.
szervoMain.write(90); // Forgassa el a szervót 90°-kal. középső helyzet
késleltetés (5000); // 5 másodperc szünet.
}

A fő funkcióban hurok(), parancsokat adunk a szervomotornak, köztük szünetekkel.

Arduino számláló áramkör egy 7 szegmenses kijelzőn

Ez az egyszerű Arduino projekt kezdőknek egy számláló áramkör létrehozása egy közös katódos 7 szegmenses kijelzőn. Az alábbi kód lehetővé teszi, hogy a gomb megnyomásakor 0-tól 9-ig számoljon.

Hétszegmenses jelző - 8 LED kombinációja (az utolsó a pontért felelős) közös katóddal, amely a kívánt sorrendben bekapcsolható, hogy számokat hozzon létre. Meg kell jegyezni, hogy ebben az áramkörben, lásd az alábbi ábrát, a 3. és 8. érintkező a katód számára van fenntartva.

A jobb oldalon egy táblázat látható, amely az Arduino tűi és a LED-jelző érintkezők közötti leképezést mutatja.

A projekt kódja:

bájtszámok = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
void setup()(
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
int számláló = 0;
bool go_by_switch = igaz;
int utolsó_bemeneti_érték = ALACSONY;
void loop() (
if(go_by_switch) (
int switch_bemeneti_érték = digitalRead(9);
if(utolsó_bemeneti_érték == LOW && switch_input_value == MAGAS) (

}
utolsó_bemeneti_érték = switch_input_value;
) más (
késleltetés(500);
számláló = (számláló + 1) % 10;
}
writeNumber(számláló);
}

Érvénytelen writeNumber(int number) (
if(9) (
Visszatérés;
}
bytemask = számok;
byte currentPinMask = B10000000;
for(int i = 2; i if(maszk & currentPinMask) digitalWrite(i,HIGH);
else digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}

Az Arduino lapokban rejlő lehetőségeket jelentősen bővítheted a szinte bármilyen eszköz PIN-kimenetére csatlakoztatható kiegészítő modulok segítségével. Tekintsük a legnépszerűbb és legérdekesebb bővítőmodulokat vagy, ahogyan más néven, pajzsokat.

Az Arduino késleltetése nagyon fontos szerepet játszik. Nélkülük a Blink legegyszerűbb példája sem működik, amely meghatározott idő elteltével villog egy LED-et. De a legtöbb kezdő programozó keveset tud az időkésleltetésről, és csak az Arduino késleltetést használja anélkül, hogy ismerné ennek a parancsnak a mellékhatásait. Ebben a cikkben részletesen beszélek az ideiglenes funkciókról és azok használatának jellemzőiről az Arduino IDE fejlesztői környezetben.

Az Arduino számos különböző parancsot tartalmaz, amelyek felelősek az idővel és a szünetekkel való munkavégzésért:

késleltetés()
késleltetésMikroszekundum()
millis()
micros()

Pontosságban különböznek, és megvannak a saját jellemzőik, amelyeket figyelembe kell venni a kód írásakor.

Az arduino késleltetési funkció használata

Szintaxis

Az Arduino késleltetés a legegyszerűbb parancs, és a kezdők leggyakrabban használják. Valójában ez egy késleltetés, amely szünetelteti a programot a zárójelben megadott számú ezredmásodpercig. (Egy másodpercben 1000 ezredmásodperc van.) A maximális érték 4294967295 ms lehet, ami megközelítőleg 50 napnak felel meg. Nézzünk egy egyszerű példát, amely bemutatja ennek a parancsnak a működését.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // jel 13 láb nagy késleltetés (10000); // szünet 10000 ms vagy 10 másodperc digitalWrite13, LOW); // alacsony jel küldése a 13-as lábnak delay(10000); // szünet 10000 ms vagy 10 másodperc)

A módszerben beállít előírjuk, hogy a 13-as érintkezőt használjuk kimenetként. A program fő részében először egy magas jelet adunk a pinre, majd 10 másodperces késleltetést teszünk. Jelenleg a program felfüggesztettnek tűnik. Ezután egy alacsony jelet adnak, majd ismét egy késleltetést, és minden kezdődik elölről. Ennek eredményeként azt kapjuk, hogy a tű felváltva van táplálva, majd 5 V, majd 0.

Világosan meg kell értenie, hogy a késleltetést használó szünet alatt a program felfüggesztésre kerül, az alkalmazás nem kap adatokat az érzékelőktől. Ez az Arduino késleltetési funkció használatának legnagyobb hátránya. Ezt a korlátozást megkerülheti megszakításokkal, de erről egy külön cikkben fogunk beszélni.

Késleltetési példa villogó LED-del

Egy példadiagram a késleltetési függvény működésének szemléltetésére.
LED-del és ellenállással áramkört építhet. Ezután kapunk egy szabványos példát - villog egy LED. Ehhez a csatlakozón, amelyet kimenetként jelöltünk meg, a LED-et pozitív érintkezővel kell csatlakoztatni. A LED szabad lábát körülbelül 220 ohmos ellenálláson keresztül (kicsit több is lehet) csatlakoztatjuk a földhöz. A polaritást meghatározhatja, ha megnézi a belsejét. A benne lévő nagy csésze a mínuszhoz, a kis láb a pluszhoz csatlakozik. Ha új a LED-je, akkor a vezetékek hosszával meghatározhatja a polaritást: a hosszú láb plusz, a rövid láb mínusz.

delayMicroseconds funkció

Ez a funkció a késleltetés teljes analógja, azzal a különbséggel, hogy mértékegysége nem ezredmásodperc, hanem mikroszekundum (1000000 mikroszekundum 1 másodpercben). A maximális érték 16383 lesz, ami 16 ezredmásodpercnek felel meg. A felbontás 4, vagyis a szám mindig négy többszöröse lesz. Egy példarészlet így nézne ki:

DigitalWrite(2, HIGH); // 2. láb nagy késleltetés küldéseMicroseconds(16383); // szünet 16383µs digitalWrite(2, LOW); // alacsony jelet küld a 2. lábnak delayMicroseconds(16383); // szünet 16383 µs

A delayMicroseconds probléma pontosan ugyanaz, mint a késleltetéssel - ezek a funkciók teljesen "lefagynak" a programban, és szó szerint lefagy egy időre. Jelenleg nem lehet portokkal dolgozni, érzékelőkből származó információkat olvasni és matematikai műveleteket végrehajtani. A villogók esetében ez az opció rendben van, de a tapasztalt felhasználók nem használják nagy projektekhez, mivel ott nincs szükség ilyen hibákra. Ezért sokkal jobb az alább leírt funkciók használata.

késleltetés helyett millis függvény

A millis() függvény lehetővé teszi, hogy késleltetés nélkül hajtsa végre az arduinót, ezzel megkerülve az előző módszerek hiányosságait. A millis paraméter maximális értéke megegyezik a késleltetési funkcióéval (4294967295 ms vagy 50 nap).

A millis használatával nem állítjuk le a teljes vázlat végrehajtását, hanem egyszerűen jelezzük, hogy az arduinónak mennyi ideig kell egyszerűen „megkerülnie” pontosan azt a kódblokkot, amelyet szüneteltetni szeretnénk. A késleltetéssel ellentétben a millis önmagában nem állít le semmit. Ez a parancs egyszerűen visszaadja nekünk a mikrokontroller beépített időzítőjéből az indítás óta eltelt ezredmásodpercek számát. Minden hurokhívásnál Mi magunk mérjük a kódunk utolsó hívása óta eltelt időt, és ha az időeltolódás kisebb, mint a kívánt szünet, akkor figyelmen kívül hagyjuk a kódot. Amint a különbség meghaladja a kívánt szünetet, lefuttatjuk a kódot, lekérjük az aktuális időt ugyanazzal a milliméterrel, és megjegyezzük – ez lesz az új referenciapont. A következő ciklusban a visszaszámlálás már az új ponttól fog történni, és ismét figyelmen kívül hagyjuk a kódot, amíg a millis és az előzőleg tárolt értékünk közötti új különbség ismét el nem éri a kívánt szünetet.

A késleltetés nélküli késleltetés millisekkel több kódot igényel, de villoghat a LED és szüneteltetheti a vázlatot a rendszer leállítása nélkül.

Íme egy példa, amely egyértelműen illusztrálja a parancs működését:

aláíratlan hosszú időzítés; // Változó a referenciapont tárolására void setup() ( Serial.begin(9600); ) void loop() ( /* Itt kezdődik a delay() analóg végrehajtása. Számítsa ki a különbséget az aktuális és az előző pillanat között mentett referenciapont. Ha a különbség nagyobb, mint Ha nem, ne csináljon semmit */ if (millis() - időzítés > 10000)( // 10000 helyett cserélje ki a szükséges szünetértéket timing = millis(); Serial. println ( "10 másodperc") ;)))

Először is bevezetünk egy időzítési változót, amely az ezredmásodpercek számát tárolja. Alapértelmezésben a változó értéke 0. A program fő részében ellenőrizzük a feltételt: ha a mikrokontroller indítása óta eltelt ezredmásodpercek száma mínusz az időzítési változóba írt szám nagyobb mint 10000, akkor egy A művelet végrehajtása során üzenetet küld a portfigyelőnek, és az aktuális időértéket a változóba írja. A program működése következtében 10 másodpercenként megjelenik a 10 másodperc üzenet a port monitoron. Ez a módszer lehetővé teszi a LED késleltetés nélküli villogását.

micros funkció késleltetés helyett

Ez a funkció a késleltetési parancs használata nélkül is késleltetheti. Pontosan ugyanúgy működik, mint a milliszekundum, de nem ezredmásodperceket, hanem mikroszekundumokat számol 4 µs-os felbontással. Maximális értéke 4294967295 mikroszekundum vagy 70 perc. Túlcsorduláskor az érték egyszerűen visszaáll 0-ra, ezt ne felejtsd el.

Összegzés

Az Arduino platform számos módot biztosít számunkra a késleltetés megvalósítására projektünkben. Késleltetéssel gyorsan szüneteltetheti a vázlat végrehajtását, ugyanakkor blokkolhatja a mikrokontroller működését. A millis parancs használatával megszabadulhat az Arduino késleltetésétől, de ez egy kicsit több programozást igényel. Válassza ki a legjobb módszert a projekt összetettségétől függően. Az egyszerű vázlatoknál és 10 másodpercnél rövidebb késleltetésnél általában a késleltetést használják. Ha bonyolultabb a működési logika és nagy késleltetésre van szükség, akkor a késleltetés helyett jobb a millis használata.