Arduino Tutoriál

Po nastavení vášho Arduino IDE je čas začať písať kód. Kódovanie pre platformu Arduino je jednoduché. Existuje množstvo knižníc na uľahčenie práce. Syntax je tiež pomerne jednoduchá. V tomto príspevku sa budeme venovať takmer všetkým základným jazykovým prvkom náčrtu (programu) Arduina. Potom by ste mali byť schopní čítať, písať a vykonávať akýkoľvek projekt kódovania Arduino.

Poznámka : Rôzne veci sú tu viac krát opakovane a vysvetľované z jednej aj z druhej strany, aby to čitateľ lepšie a dobre pochopil. 🙂

Ako a kde napísať Arduino program?

Program Arduino je zvyčajne napísaný v Arduino IDE. (IDE1 alebo IDE2). Program je súbor inštrukcií. Má niektoré špeciálne hlavičkové súbory ako súbory zip, ktoré sú dostupné online na poskytovanie špecializovaných funkcií. O tomto ale neskôr. Začneme zľahúčka. Program Arduino je známy ako skica.

Program je skica, skica je program

Ale najskôr si musíme nainštalovať do PC už spomínané IDE. Odporúčam nové IDE2.

Ak neviete ako tu je pomoc a popis a veľa o IDE-čku → ( Čo to vlastne to IDE je? )

Tak a teraz už viete, že dole na obrázku je spustený program, ktorí voláme Arduino IDE.

Ako to funguje ? :

Dôležité vedieť :

Kód Arduino by mal stále obsahovať dve funkcie a to :

• void setup() Táto funkcia sa vykoná iba raz, keď sa Arduino spúšťa. Bez ohľadu na to, či bol váš hardware (Arduino) práve zapnutý alebo resetovaný, ovládač Arduino začne okamžite vykonávať logiku vo vnútri tejto funkcie a potom sa presunie do funkcie loop(). Zvyčajne sa používa na inicializáciu knižníc alebo premenných, ktoré budete následne používať vo svojom kóde.
• void loop() Toto je základná logika vašej aplikácie, ktorá sa bude opakovane vykonávať navždy. Teda Arduino vám bude fungovať približne 100 rokov pokiaľ mu zabezpečíte zdroj napájania. Program sa tak bude opakovať stále v nekonečnej slučke. V každom programe Arduino musíte mať obe vyššie uvedené funkcie, aj keď budú len prázdne. Toto je minimálna požiadavka na program Arduino!

Každá funkcia je program platí to aj pre void setup(). Funkcie vedia všeličo a funkcia alebo program void setup() vie nastavovať. Táto funkcia vie zabezpečiť, aby sa v mikroprocesore zaplo práve to, čo potrebujete, napríklad aj preto je Arduino extrémne málo energetiky náročný hardware. To čo je vypnuté nepotrebuje energiu 🙂 A to čo budeme potrebovať funkcia void setup() vie pozapínať 🙂

Funkcia void setup() sa spustí len raz.

• keď zapnete Arduino alebo keď stlačíte tlačidlo RESET.

To znamená všetko čo napíšete do funkcie void setup() sa vykoná len raz.

Keď funkcia void setup() má všetko hotové okamžite začne pracovať funkcia void loop()

Funkcia void loop() je program, ktorý vie dobre opakovať opakuje všetko, čo do nej napíšete stále dookola a potom znova a znova stále vám váš program bude opakovať až donekonečna.

Tieto dva sú hlavnými prvkami akéhokoľvek kódu Arduino. Ako bolo povedané sú známe ako funkcie. Čoskoro sa na ne pozrieme bližšie. Všetky deklarácie sa robia vo void setup().

Poznámka: Ak budeme v našom programe potrebovať miesto v pamäti na uloženie nejakej hodnoty (napríklad nejaký senzor nám dáva nejaké údaje a tie potrebujeme uložiť) Arduino to musí vedieť, že také miesto potrebujeme ak to Arduinu nepovieme, že také miesto v pamäti potrebujeme tak nebudeme mať takéto miesto, kde sa dá niečo uložiť. A deklarácia je presne to povedať Arduinu čo všetko potrebujeme. Znamená urobíme požiadavku (deklarujeme) a funkcia void setup() ak je to možné tak nam to zabezpečí. Ako to urobí o to sa už starať nemusíme. 🙂

A presne na tento účel su funkcie uľahčuju nam programovanie, stači nam len vedieť ako ich použiť.

Tu nájdete viac info ako funguje funkcia : Používanie funkcií…

Názov void setup() obsahuje slovo „nastavenie“, ktoré by malo prezrádzať jeho účel.

setup → znamena nastavenie

Ale skutočné príkazy, ktoré sa majú vykonať, a výpočtový proces sú kódované vo funkcii void loop(). „Slučka“ znamená, že skica bude prebiehať donekonečna.

OK – takže už vieme že do editoru arduino musíme minimálne napísať toto :

Komentáre :

• // napíšte sem svoj kód, aby sa spustil raz:
•  // napíšte sem svoj kód, aby sa spustil opakovane:

Komentáre tam nemusíte písať. Komentáre len popisujú váš program (skicu).

Zátvorky :

• {
• }

Medzi tieto zátvorky píšeme kód. Zátvorky tam musíte písať. Tak Kompilátor dobre vie kde začína a končí funkcia void setup() a funkcia void loop().

Povinná štruktúra kódu je: void setup() a potom void loop(). Kompilátor to dobre vie a hľadá, kde sú tieto funkcie. Hľadá kde sa začínajú a tiež musí vedieť, kde končia. Zátvorkami kompilátoru jasne ukazujeme tieto miesta.

Kompilátor je prekladač, ktorý preloží váš program do rečí, ktorú pozná mikroprocesor.

Vyzerá to nejak takto : 01100001110101111110000101000000111010110101001010001

Takže kompilátor tak celý váš program v skratke prekladá na nuly a jedničky. Sekvencie núl a jedničiek niečo pre mikroprocesor znamenajú, a tak vie, čo a ako ma nastaviť alebo robiť.

Kompilátor samozrejme kontroluje štruktúru vášho kódu, a ak zistí niečo čomu nerozumie alebo by tomu mikroprocesor nerozumel tak vás na to upozorní.

Príklad: zabudol som napísať zátvorku a ukončiť funkciu void loop() :

Kompilátor (prekladač) to hneď zistil a samozrejme nevedel kde končí funkcia void loop().

Dole v kolónke Output (výstup) je správa o tom že toto vám kompilátor nepusti do Arduina a je potrebné to opraviť. Zle napísaný program ľahko môže poškodiť aj mikroprocesor.

Editor Arduino IDE vám ale nikdy nedovolí nahrať na hardware akéhokoľvek Arduina program v ktorom nájde chybu.

Chybu je potrebné nájsť a opraviť.

Syntax je prísne kontrolovaná!

Po oprave (dopísaní zátvorky }), na ktorú som zabudol je kompilátor kľudnejší a vypíše len údaje koľko bajtov program, teda skica použije pamäte a koľko je max. možné použiť.

Tento program je možné už nahrať do Arduina ( Ako nahrať program ? )

Program nebude nič robiť ale kompilátor to nerieši. Do Arduina môžete napísať aj program ktorý nič nerobí aj 10, 20 alebo aj 100 riadkov kódu ktorý nič nerobí.

Kompilátor sleduje len štruktúru (syntax) nie to čo váš program ma robiť alebo nemá robiť.

Pokiaľ bude syntax OK a pokiaľ veľkosť pamäte bude stačiť a váš program sa tam vojde potom akýkoľvek váš kód do Arduina bude možné nahrať.

Aký jazyk používame na písanie programu Arduino?

(Embedded C) sa používa na písanie programov pre Arduino. Používa sa pre aplikácie, ktoré sú veľmi blízko k hardvéru. Skoro priamo komunikuje s hardvérom. Je veľmi podobný C a C++. Má však niektoré vstavané funkcie iné ako bežné funkcie používané v bežnom C.

Teda málinko upravené C / C++ tak, aby ešte viac a bližšie malo k samotnému hardware.

Ak chcete programovať hardware aplikácie nič lepšie asi nenájdete.

Čo je skica?

Program napísaný pre Arduino sa nazýva skica. Obsahuje pokyny, ktoré má vykonať doska Arduino a ktoré sú napísané v jazyku Embedded C.

Program je skica, skica je program

Aké sú všeobecné prvky syntaxe v programovaní Arduino?

Všeobecná syntax pre písanie programu Arduino je takmer podobná syntaxi bežného C a C++. Tí, ktorí sú oboznámení so základnými jazykmi C a C++, to dokážu určite ľahko.

Zakladné prvky programovania :

Tak a teraz to začne 🙂

Pravdepodobne si všetko čo tu ďalej budete čítať hneď nezapamätate.

Treba si to čítať dookola tak ako to robí funkcia void loop() , toto sú základné vecičky ktoré budete potrebovať vedieť. Časom ale hlavne opakovaním vám nasledujúce slová začnú dávať zmysel.

Takže robte to ako funkcia void loop() 🙂

Tak začneme takto : Pokiaľ ste už videli nejaký program tak asi viete, že program celý program sú nejaké divné slovíčka, zátvorky, znamienka no a programátor nepotrebuje nič len vedieť, čo ktoré znamienko v programe robí, čo ktoré slovíčko je alebo znamená a pochopením kto, čo s kým a s čím je porozumenie programovacieho jazyka.

Divné slovíčka :

#define

Čo vám napadne, keď sa pokúsite myslieť nad účelom tohto príkazu?

Poznámka: Programovanie je skoro celé o anglickom jazyku zmierte sa s tým 🙂

Pravdepodobne to má niečo spoločné so zavedením prvku, však? to je pravda. #define sa používa na priradenie premennej ku konštante, ktorá sa má použiť v programe. Nepotrebuje žiadny pamäťový priestor.

Počas kompilácie môže kompilátor nahradiť premenné konštantou.

Premenná je miesto v pamäti viac tu : Používanie premenných

Vo všeobecnosti sú konštanty definované pomocou kľúčového slova „const“ namiesto #define. Nemali by ste používať bodkočiarku za #define alebo rovná sa znaku za #define; v opačnom prípade sa zobrazí chyba.

Syntax: #define premenná konštanta

Parametre:

• Premenná (je názov, ktorý musí byť priradený k hodnote.)
• Konštanta (je hodnota, ktorá sa používa v programe.)

Príklad :

príklad 1. #define a 3  //správne

príklad 2. #define a 3; //Chyba

príklad 3. #define a=3 //Chyba

V tomto príklade by mal kompilátor nahradiť premennú a číslom 3.

Tu vidíte ako to urobiť správne. #define a 3

#include<>

Je zrejmé, že to hovorí programu, aby niečo zahŕňal. Otázkou je, čo? Tento príkaz môžete použiť na zahrnutie ďalších súborov knižnice do skice na pridanie niektorých ďalších funkcií.

Je to jedna z najlepších funkcií Arduino IDE. Na internete je dostupných niekoľko knižníc. Sú špeciálne napísané pre účely Arduina. Každá knižnica vám poskytuje ďalší prístup k senzorom a modulom. Podobne ako pri príkaze #define nie je na konci príkazu #include potrebná bodkočiarka. V opačnom prípade sa zobrazí chyba.

Syntax: #include<library file>

Parametre:

• Súbor knižnice je ďalšou hlavičkou, ktorá sa má pridať.

Príklad :

Tento príklad obsahuje knižnicu SoftwareSerial, takže jej funkcie možno použiť na ovládanie GPS.

#include <SoftwareSerial.h> //súbor knižnice

static const int RX = 4, TX = 3;

static const uint32_t GPSBaud = 9600;

// Sériové pripojenie k zariadeniu GPS

SoftwareSerial ss(RX, TX);

void setup()

{

Serial.begin(115200);

ss.begin(GPSBaud);

}

void loop()

{

while (ss.available() > 0){

Serial.write(ss.read());

}

}

Všetky príkazy ako ss.read vo vyššie uvedenom náčrte pochádzajú zo súboru knižnice, ktorý sme zahrnuli na začiatku. Bez tohto súboru knižnice by bolo neuveriteľne ťažké implementovať funkciu GPS.

Blok pre komentáre /* */

Môžete ho použiť na písanie komentárov do náčrtu. Komentáre sú riadky, ktoré sa používajú na upovedomenie programátora o danom úryvku kódu. Neexportuje sa do procesora, takže nezaberá žiadne pamäťové miesto v pamäti mikrokontroléra. Slúži len na to, aby vám pomohol pochopiť kód. Písanie dobrých komentárov je kľúčovou súčasťou písania čistého a čitateľného kódu. Začiatok bloku komentárov je označený /* a koniec je označený znakom */.

Príklad :

/*Blikanie rozsvieti LED na sekundu,
potom na jednu sekundu vypne*/

Komentár //

Komentáre bloku môžu mať viacero riadkov. Ak chcete mať jednoriadkový komentár, môžete použiť // a potom napísať komentár. Podobne ako v prípade /**/ kompilátor ignoruje aj tieto riadky komentárov. Nezaberá žiadne miesto v pamäti mikrokontroléra.

Syntax: //

Príklad :

#define a=3

digitalWrite(a,1); //Zapnúť LED

zložené zátvorky {}

Zložené zátvorky alebo zátvorky sú dôležitou súčasťou programovacích jazykov C a C++. Po otvorenej zloženej zátvorke { musí nasledovať záverečná zložená zátvorka }. Vraj je to vyvážené. Kód v zložených zátvorkách sa považuje za blok, ktorý môže byť funkciou.

Príklad :

Void getdata(datatype argument){
                                      //Kód
}
Loops
while(condition){

                                     //Kód
}

Conditional statements
if(condition){

                                     //Kód
}

bodkočiarky ;

Používajú sa na konci vyhlásenia. Ak zabudnete vložiť bodkočiarku do akéhokoľvek iného príkazu ako #define a #include, budete určite upozornení chybou kompilátora.

Príklad :

int a=3;

Aká je všeobecná štruktúra skice?

Náčrt v Arduino IDE má dve hlavné časti vo svojej štruktúre: sú to

• setup()
• loop()

void setup()

Funkcia setup() by mala byť prvá, ktorá sa zavolá, keď sa skica začne spúšťať alebo kompilovať. Tento funkčný blok sa používa na inicializáciu pinových režimov, premenných a tiež prenosovej rýchlosti. Spustí sa iba raz, keď je Arduino napájané alebo má tendenciu sa resetovať.

Príklad :

#define a=3

/*Blikanie rozsvieti LED na jednu sekundu a potom na jednu sekundu zhasne*/

void setup()

{

pinMode(a,OUTPUT); //toto je príkaz, ktorý nastavuje povahu pinu Arduino ako výstupu. Pin sa bude takto dať použiť napríklad na blikanie LED-kou

}

void loop(){

//Kód

}

void loop()

Je to blok programu, ktorý obsahuje kód, ktorý má inštrukcie, ktoré musí mikrokontrolér vykonávať donekonečna od zapnutia dosky Arduino až po jej vypnutie.

Príklad :

#define a=3

/*Blikanie rozsvieti LED na jednu sekundu a potom na jednu sekundu zhasne*/

void setup()

{

pinMode(a,OUTPUT); //Deklarovanie pinmode

}

Void loop()

{

digitalWrite(a,0);// Vypnuť LED 

delay(1000);

digitalWrite(a,1); // Zapnúť LED 

delay(1000); //Oneskorenie 10 sekúnd

}

Typy premenných v programe Arduino?

V programovacom jazyku Arduino je asi 18 dátových typov. My si tu však predstavíme len tie najpoužívanejšie. Zvyšok bude predstavený vždy, keď to bude potrebné.

Čo je int?

Celé čísla sú dátový typ, ktorý môže ukladať čísla. V Arduino Uno môže int uložiť 16-bajtovú hodnotu, ktorá je 2-bajtová. Tu má int rozsah od -32 768 do 32 767. To je -2^15 až 2^15. Na niektorých doskách, ako je Arduino Due, môže int uložiť 32-bitovú hodnotu, ktorá má 4 bajty.

int môže tiež ukladať záporné čísla pomocou doplnkovej matematiky. Typ s názvom unsigned int môže ukladať iba kladné čísla.

Syntax: int variable = value;

Príklad :

int count=0; // inicializácia celého čísla s názvom „count“ a pridelenie hodnoty 0.

Void setup(){

Serial.begin(9600);

}

Void loop(){

Count++;

Serial.println(count);

Delay(1000)

}

Čo je char?

Pomáha nám uložiť znak. Typ údajov char má aspoň 8-bitovú veľkosť. Napr. „A“ Znaky sa ukladajú aj ako čísla. Tieto štandardné čísla, ktoré sú priradené všetkým znakom, sa nazývajú čísla ASCII. Napríklad hodnota ASCII „B“ je 66.

Syntax :

Char variable= character

Príklad :

char a = ‘A’;

char b=’;’;

Čo je float ?

Do float vieme ukladať desatinné čísla. Čísla s pohyblivou rádovou čiarkou sa používajú na aproximáciu analógových a spojitých hodnôt kvôli ich väčšiemu rozlíšeniu v porovnaní s celými číslami. Rozsah dátového typu float je od :

-3,4028235E+38 do 3,4028235E+38. (Má 32-bitové úložisko.)

Syntax

float variable=value;

Príklad :

float a, b=12.22;

int x=1, y;

y=x/2 //y má 0, pretože int nemôže ukladať zlomky a desatinné miesta

a=(float)x/2; //z má teraz 0,5

Čo je bool?

Môže uložiť iba dve hodnoty, true alebo false. Zaberá jeden bajt.

Syntax: bool a=true/false;

Príklad :

bool a=true;

while(a){

Serial.println(“áno”); //zobrazuje áno donekonečna

}

Čo je lokálna premenná?

Lokálne premenné sú premenné s lokálnym rozsahom. Môžeme ich použiť iba v rámci bloku kódu, kde ich deklarujeme.

Čo je globálna premenná?

Globálne premenné sú premenné s globálnym rozsahom. To znamená, že ich môžeme použiť kdekoľvek v náčrte.

Aké sú rôzne aritmetické funkcie, ktoré možno vykonávať v Arduine?

Všetky základné matematické operácie vieme vykonávať v programovacom jazyku Arduino.

Čo je operácia násobenia?

Operátor : *

Môže vynásobiť dve čísla.

Syntax: value1 *value2;

Príklad :

int a=5;

int b=5,c;

c= a*b; //c bude 25

Čo je operácia delenia ?

Operátor : %

Pomáha nám nájsť zvyšok, keď je jedno celé číslo delené druhým celým číslom. Funguje iba pre údajový typ int, nie pre údajový typ float

Syntax: remainder=dividend % divisor;

Príklad :

int a[10];

void setup(){

pinMode(0, INPUT);

}

void loop(){

a[i]=digitalRead(0);

i=(i+1)%10;

}

Čo je to operácia rozdelenie ?

Operátor : /

Môže rozdeliť dve čísla.

Syntax: quotient=divider/divisor;

Príklad :

int a=5;

int b=5,c;

c= a/b; // c bude 1

Čo je operácia sčítanie?

Operátor : +

Môže sčítať dve čísla s rovnakým typom údajov.

Syntax: value1 + value2;

Príklad :

int a=5;

int b=5,c;

c= a+b; // c bude 10

Čo je operácia odčítania?

Operátor : –

Môže odčítať dve čísla s rovnakým typom údajov.

Syntax: value1 – value2;

Príklad :

int a=5;

int b=5,c;

c= a - b; // c bude 0

Aká je operácia priradenia?

Operátor : =

Dokáže priradiť čísla na pravej strane k premennej na ľavej strane operátora.

Syntax: variable = value2;

Príklad :

int a=5;

int b=analogRead(3) //b má hodnotu snímača

Aké sú rôzne porovnávacie funkcie v programe Arduino?

Tieto funkcie pomáhajú porovnávať dve čísla v programe Arduino.

Čo porovnávacia operácia ?

Operátor : ==

Skontroluje, či sú dve čísla na ľavej a pravej strane rovnaké alebo nie, a vráti hodnotu „pravda“ alebo „nepravda“.

Syntax: value1 == value2;

Príklad :

int a=1;

int b=1,count=0;

if(a==b) //pravda

count++; //počet sa zvyšuje

Operácia čo sa nerovná ?

Operátor : !=

Kontroluje, či dve čísla na ľavej a pravej strane nie sú rovnaké alebo nie. A vráti true alebo false.

Syntax: value1 != value2;

Príklad :

int a=1;

int b=2,count=0;

if(a!=b) //pravda

count++; //počet sa zvyšuje

Čo je Operácia menej ?

Operátor : <

Skontroluje, či sú čísla na ľavej strane menšie ako čísla na pravej strane a vráti hodnotu true alebo false.

Syntax: value1 < value2;

Príklad :

int a=1;

int b=2,count=0;

if(a<b) //pravda

count++; //počet sa zvyšuje

Čo je operácia menšie alebo rovné ?

Operátor : <=

Skontroluje, či čísla na ľavej strane sú menšie alebo rovné číslam na pravej strane alebo nie, a vráti hodnotu true alebo false.

Syntax: value1 <= value2;

Príklad :

int a=1;

int b=2,count=0;

if(a<=b) //pravda

count++; //počet sa zvyšuje

int a=2;

int b=2,count=0;

if(a<=b) //pravda

count++; //počet sa zvyšuje

Väčšie operácia ?

Operátor :>

Skontroluje, či čísla na ľavej strane sú väčšie ako číslo na pravej strane a vráti hodnotu true alebo false.

Syntax: value1 > value2;

Príklad :

int a=2;

int b=1,count=0;

if(a>b) //pravda

count++; //počet sa zvyšuje

Čo je väčšie ako rovné?

Operátor : >=

Skontroluje, či sú čísla vľavo väčšie alebo rovné číslu na pravej strane a vráti hodnotu true alebo false.

Syntax: value1 >= value2;

Príklad :

int a=2;

int b=1,count=0;

if(a<=b) //pravda

count++; //počet sa zvyšuje

int a=2;

int b=2,count=0;

if(a==b) //pravda

count++; //počet sa zvyšuje

---

Čo je deklarácia režimu PIN?

Funkcia: režim pin (Pin, režim)

Na definovanie funkcie pinov na doske Arduino používame príkaz pinMode. Pomáha deklarovať PIN a režim, v ktorom sa PIN vykonáva. Inicializuje kolíky dosky Arduino, ktoré sa majú použiť ako vstupné alebo výstupné kolíky.

Argumenty:

• Pin – PIN môže byť digitálny alebo analógový pin dosky Arduino, kde je pripojený hardvér.
• Mode – Existujú dva režimy ako režim VSTUP a režim VÝSTUP. Vstupný režim vám pomôže získať údaje. Výstupný režim vám pomáha vykonávať nejakú funkciu činnosť na tomto kolíku. napíklad: blikanie LED

Zvyčajne používame túto funkciu v bloku void setup ().

Príklad :

void setup() {
pinMode(13, OUTPUT);
}

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}

Digitále. piny

Tieto digitálne I/O kolíky sa používajú na vykonávanie operácií v zmysle 0 a 1. Na doske Arduino Uno je prítomných 13 digitálnych I/O pinov. Na to aby sme ich vedeli použiť máme k dispozícii dve hlavné funkcie:

digitalRead(Pin)

Môžete ho použiť na získanie digitálneho vstupu zo zariadení, ako sú senzory a štíty Arduino, vo forme 0 a 1.

Argument:

Pin – Pin, ktorý sa spája so snímačom.

Vráti hodnotu : 0 alebo 1

Príklad :

int Pin = 8; //Inicializuje sa Arduino Pin
int Reading;

void setup() {
  pinMode(Pin, INPUT); //Deklarovanie Arduino Pin ako vstupu
}

void loop() {
  Reading = digitalRead(Pin); // Stav čítania digitálneho pinu Arduino
  
  if(Reading == HIGH)
  {
    Serial.println("HIGH");
  }

  if(Reading == LOW)
  {
    Serial.println("LOW");
  }
 
}

digitalWrite(Pin, Mode)

Je užitočný pri poskytovaní digitálneho výstupu zariadeniam, ako sú moduly, LED, motor a iné elektronické zariadenia.V tvare 0 a 1.Tento kolík môže poskytnúť až 3,3 V, keď je výstup 1.

Argument:

Pin – Pin, ktorý sa pripája k senzoru.

Mode – 0 alebo 1, čo znamená LOW / HIGH.

Príklad :

const int p = 2 ;
void setup()
{
pinMode(pwm,OUTPUT) ;
}
void loop()
{
digitalWrite(p,HIGH) ;//napíše stav HIGH na pripnutie p
delay(50) ;
digitalWrite(p,LOW) ;
delay(50) ;
digitalWrite(p,HIGH) ;
delay(50) ;
digitalWrite(p,LOW) ;
delay(50) ;
}

Analóg. piny

Na doske Arduino Uno je päť analógových I/O pinov. PIN Dokáže odosielať a prijímať analógové signály. Je to užitočné pri regulácii PWM a tiež napríklad pomáha získať presné hodnoty snímača.

Tu zistite viac o PWM : Pulzne šírková modulácia

AnlogRead(Pin)

Môžete ho použiť na získanie analógového vstupu zo zariadení, ako sú senzory a štíty, vo forme 0 a 1.

Argument:

Pin – Pin, ktorý sa spája so snímačom.

Príklad :

const int pwm = 2 ; 
const int adc = 0 ; 
void setup()
{
pinMode(pwm,OUTPUT) ; 
}
void loop()
{
int adc = analogRead(0) ;  //číta analógové dáta z ADC
adc = map(adc, 0, 1023, 0, 255); 
analogWrite(pwm,adc) ; 
}

AnalogWrite(Pin, Value)

Túto funkciu môžete použiť na poskytnutie analógového výstupu zariadeniam, ako sú moduly, štíty, LED, motor a iné elektronické zariadenia. Pomáha tiež pri regulácii PWM.

Argument:

Pin – Pin, ktorý sa spája so snímačom.

Value – Pracovný cyklus, ktorý sa pohybuje medzi 0 a 255.

Príklad :

const int pwm = 2 ; 
void setup()
{
pinMode(pwm,OUTPUT) ; 
}
void loop()
{
analogWrite(pwm,25) ; //zapíše výstup 25 na kolík 2
delay(50) ; 
analogWrite(pwm,50) ; 
delay(50) ; 
analogWrite(pwm,100) ; 
delay(50) ; 
analogWrite(pwm,225) ; 
delay(50) ; 
}

Čo sú to príkazy alebo presmerovania?

Čo je to prerušenie?

break

Syntax: break

Tento príkaz môžete použiť na prerušenie cyklu, keď je daná podmienka splnená. To znamená, že vychádza zo slučky.

Príklad :

int a;

while(True){

a=digitalRead(3); //a uloží digitálny vstup na kolík 3

if(a==1){ // skontrolujte, či je digitálny vstup 1

break; //preruší, keď je digitálny vstup 1.

}

}

Čo je return ?

Syntax: return hodnota

Vráti hodnotu do premennej. Funkcie zvyčajne používajú tento príkaz return. Hodnotou môže byť akýkoľvek typ údajov. Ale musí byť špecifikovaný v deklarácii funkcie.

Príklad :

int value(int a){

if(a>50){

return a-50;

}

else{

return a;

}

}

Void loop(){

int a;

a=value(analogRead(3)); //odovzdať analógový údaj na kolíku 3 funkcii.

Serial.println(a); /* zobraziť pôvodnú hodnotu-50, ak pôvodná hodnota presiahne 50, inak sa pôvodná hodnota nezmení*/

}

Čo je continue ?

Syntax:continue

Pri splnení danej podmienky preskočí nižšie uvedené príkazy.

Príklad :

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

if(i%2==0){ //kontroluje, či je párne alebo nie.

continue; //preskočte nižšie uvedené , ak i je párne číslo

}

analogWrite(3,i) //Ovláda PWM na kolíku 3 podľa i

delay(50);

}

Čo je goto ?

Syntax: goto

Prenesie ukazovateľ na označený bod.

Príklad :

int a;

While(1){

if(analogRead(3)>250){

goto action; /*odovzdať tok programu do akcie, keď je analógové čítanie väčšie ako 250*/

}

}

akcia:

digitalWrite(3,HIGH);

---

Pondmienky :

Čo je : for

Syntax: for(Počiatočná podmienka; podmienka zastavenia; podmienka pribúdania/znižovania){}

Argumenty: Vo vnútri príkazu for sú tri argumenty.

• 1.Najprv musíte inicializovať premennú. A tejto premennej môžete priradiť počiatočné číslo.
• 2.Druhým je stav zastavenia. Príkaz spúšťa kód, kým premenná nesplní túto podmienku.
• 3.Ďalšia, tretia je meniaca sa podmienka, ktorá uvádza, ako zvýšiť alebo znížiť premennú pre nadchádzajúce iterácie.

Príklad :

for(int i=0;i<100;i=i*i){ /* i je inicializované ako 0, zastaví sa, keď dosiahnem 100 a I sa zvýši o i*I
 */

digitalWrite(3,HIGH);

delay(100);

digitalWrite(3,LOW);

delay(100);

}

Čo je : while

Syntax: while(podmienka zastavenia){ inkrementačný/znižujúci príkaz}

Argumenty: Je to zastavovacia podmienka.

Blok while musí obsahovať príkaz na zvýšenie/zníženie. A tiež musíte inicializovať premennú pred volaním príkazu while.

Príklad :

int a=0

while(a<100){ // beží, kým a nedosiahne 100

digitalWrite(3,HIGH);

delay(100);

digitalWrite(3,LOW);

delay(100);

a=a+5; //a zvyšuje sa o 5

}

Čo je : do-while

Syntax:robiť{ }počas (podmienka zastavenia)

Argumenty: príkaz while obsahuje podmienku zastavenia.

Výhodou príkazu do-while je, že spustí kód aspoň raz, aj keď podmienka nie je splnená. Blok musí obsahovať príkaz na zvýšenie/zníženie. A tiež musíte inicializovať premennú pred volaním príkazu do-while.

Príklad :

int a;

do{

digitalWrite(3,HIGH);

delay(100);

digitalWrite(3,LOW);

delay(100);

}while(if(digitalRead(1))); // beží, kým pin D1 nedá vstup

Čo je Serial begin funkcia ?

Syntax: Serial.begin(hodnota)

Argument: hodnota – prenosová rýchlosť

Prenosová rýchlosť je rýchlosť prenosu dát. Keď komunikujeme so zariadením, musíme sa uistiť, že prenosová a prijímacia rýchlosť sú na oboch koncoch komunikácie rovnaké. Prenosová rýchlosť udáva rýchlosť prenosu dát. Invertujte to a získate počet bitov prenášaných za sekundu. Môžeme použiť rôzne prenosové rýchlosti, sú to 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 alebo 115200.

Príklad :

void setup(){

pinMode(1, INPUT);

Serial.begin(9600);

}

Čo je Serial print funkcia?

Údaje zobrazí ako ľudsky zrozumiteľný ASCII text.

Syntax:Serial.print(Údaje, Formát)
Argumenty:Údaje 
Formát- Nie je to potrebné, ale pomáha vám zobraziť údaje v špecifikovanom formáte, ako je binárny, osmičkový, desiatkový.

Príklad :

Serial.print(68) //zobraziť 68

Serial.print(1.5555) //zobraziť 1.55

Serial.print(“Ahoj Svet”) //zobraziť “Ahoj Svet”

Serial.print(78, OCT) /zobraziť “116”

Serial.print(“abc”) ;Serial.print(“def”); //zobraziť “abcdef”

Čo je Serial println funkcia ?

Údaje zobrazí ako ľudsky zrozumiteľný ASCII text. Vráti „\r“ a „\n“, aby sa ďalší príkaz vytlačil v novom riadku.

Syntax: Serial.println(Údaje, Formát)

Argumenty:Údaje

Formát- Nie je to potrebné, ale pomáha vám zobraziť údaje v špecifikovanom formáte, ako je binárny, osmičkový, desiatkový.

Serial.println(68) //zobraziť 68

Serial.println(1.5555) //zobraziť 1.55

Serial.println(“Ahoj”) //zobraziť “Ahoj”

Serial.println(78, OCT) //zobraziť “116”

Serial.print(“abc”) ;Serial.print(“def”);

/*zobraziť “abc”

         “def” */

Čo je Serial parseInt funkcia ?

Syntax:

• Serial.parseInt()
• Serial.parseInt(pozrieť sa dopredu)
• Serial.parseInt(pozerať dopredu, ignorovať)

Argumenty:

• Pozrite sa dopredu na celé číslo
• SKIP_ALL (predvolený): Ignoruje všetky znaky okrem číslic alebo znamienka mínus „-“.
• SKIP_NONE: Nič nepreskočí.
• SKIP_WHITESPACE: Preskakuje tabulátory, medzery.

Vráti:Vráti ďalšie platné celé číslo.

Príklad :

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
char valA;
int valB;

void setup()
{
Serial.begin(9600);
lcd.begin(16,2);
}

void loop()
{
  if (Serial.available()>0)
  {      
    valA=Serial.parseInt();
    lcd.write(valA);
    valB=Serial.read();
    lcd.write(valB);
  }
}

Čo je Serial parse Float funkcia?

Vráti prvé platné celé číslo zo sériovej vyrovnávacej pamäte.

Syntax:

• Serial.parseInt()
• Serial.parseInt(pozrieť sa dopredu)
• Serial.parseInt(pozerať dopredu, ignorovať)

Argumenty:

• Pozrite sa dopredu na celé číslo
• SKIP_ALL (predvolený): Ignoruje všetky znaky okrem číslic alebo znamienka mínus „-“.
• SKIP_NONE: Nič nepreskočí.
• SKIP_WHITESPACE: Preskakuje tabulátory, medzery.

Vráti:Vráti ďalší platný float(znak)

Príklad :

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < FILTERSAMPLES; i++) {
    filterSamples[i] = 0;
  }

  Serial.println("Odstráňte všetku váhu z váhy, potom zadajte ok a stlačte enter.");
  while (!Serial.find("ok"));
  zeroOffset = readADC(0); 
  Serial.println();
  Serial.println("Položte vajce na váhu a zadajte jeho hmotnosť v gramoch, potom stlačte enter.");
  grams = Serial.parseFloat();
  while (grams <= 0) {
    grams = Serial.parseFloat();
  }

Čo je String() ?

Vytvára triedu reťazcov. Teda postupnosť znakov. Existuje mnoho typov na vytváranie reťazcov z rôznych dátových typov, ktoré ich formátujú ako sekvenciu znakov. Vráti inštanciu triedy string

• V úvodzovkách: reťazec znakov (napr. „Ahoj“)
• V jednoduchých úvodzovkách: jeden znak (napr. „N“)
• Môže to byť ďalšia inštancia objektu String.
• Konvertuje na dlhé celé číslo so zadaným základom

Syntax:

• string(hodnotu)
• string (hodnotu, základ)
• string (hodnotu, desatinné miesta)

Príklad :

string a=string(13);

string a=string(13, HEX);

Dáva „D“, čo je hexadecimálna reprezentácia 13. Môžete tiež uprednostniť binárne nahradením HEX za BIN.

Čo je Array?

Pole je súbor homogénnych premenných. Sú prístupné pomocou indexového čísla ako a[0], a[1]. Polia majú nulový index. Prvý prvok poľa je vždy na indexe 0 a veľkosť poľa je celkové číslo -1.

Pomocou slučiek môžete manipulovať s poľami.

Syntax: Pole môžete vytvoriť nasledujúcimi metódami,

int a[6];

int a[]={1,2,3,4,5,6};

char a[8]= “Ahojsvet”;

Príklad :

int a[5]={0,1,2,3};

Má iba štyri prvky, ale veľkosť je päť, takže a[4] poskytuje neplatnú hodnotu A a[8] malo neplatnú adresu.

Indexu poľa môžete priradiť hodnotu takto :

a[0] = 1;

A tiež môžete získať hodnotu tým,

b=a[0];

Potom môžete tiež zobraziť a získať prístup k prvkom poľa pomocou slučky.

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

Serial.println(a[i]);

}

Čo je funkcia?

Okrem vstavaných funkcií môžete písať aj svoje funkcie. Pomocou toho môžeme rozdeliť veľký program na základné stavebné bloky.

Funkcia obsahuje sadu programovacích príkazov so zloženými zátvorkami ako {}. Poskytuje opätovnú použiteľnosť. Používateľom definované funkcie sú rozdelené do štyroch typov :

• Funkcia bez argumentov, ktorá nevracia žiadnu hodnotu.
• Potom funkcia bez argumentov, ktorá vráti hodnotu.
• Funkcia s argumentmi, ktorá nevracia žiadnu hodnotu.
• A funkcia s argumentmi, ktorá vracia hodnotu.

Výhody používania :

Používanie funkcií zabráni opakovanému prepisovaniu rovnakého kódu, Pomáha ľahko pochopiť kód.

Záver

S Arduinom môžete robiť oveľa oveľa viac. To, čo ste videli v tomto príspevku, by však malo byť viac než dostatočné na to, aby ste mohli začať s väčšinou projektov.

Viac:

• Arduino a Typy premenných

---

Tutoriály:

Tutoriály Arduino Uno

Tutoriály Arduino Nano

---

• Elektrotechnika
• Programovanie
• Tutoriály Nano
• Tutoriály Uno
• Uno články