Arduino – Ki és Bemenetek

Az Arduino kártyák lábai digitális vagy analog be- vagy kimenetként konfigurálhatók, Illetve vannak különböző komunikációs portok is. Az Arduino analóg pinek használhatóak, mint a digitális csapok.

pinMode () függvény

A pinMode () függvény segítségével konfigurálható egy adott pin, hogy bemenetként vagy kimenetként viselkedjen. A pinMode () függvény szintaxisa:

pinMode(pin, mode)

pin – annak a csapnak a száma, amelynek módját be kívánja állítani. Az adattípus minden esetben int.
mode – ez lehet INPUT, OUTPUT vagy INPUT_PULLUP.

Az Arduino csapok alapértelmezés szerint bemenetek., ezért nem feltétlenül szükséges bemenetként deklarálni, azonban jobb, ha megtesszük a pinMode() függvény segítségével.

pinMode (pin, INPUT);

Az INPUT konfigurációjú csapokra, amelyekhez nincs csatlakoztatva semmi, hatással lehetnek a környezetből felvett elektromos zajok amelyek nem várt változásokat generálhatnak a pin állapotában . A stabilitás miatt felhúzó ellenállást (Pull Up) kell elhelyezni. A felhúzó ellenállások használatával a bemenet alaphelyzetben magas (HIGH) állapotba kerül. Ezt úgy tehetjük meg, hogy a bemenet és az 5V közé egy 10K ellenállást kapcsolunk. Az INPUT mód letiltja a belső felhúzó ellenálás használatát.

Az INPUT módban alkalmazhatunk lehúzó ellenállást is, ez értelemszerűen a földre(GND) kapcsolt 10K-s ellenállással tehetjük meg, ekkor a bemenetünk alapértelmezésben alacsony(LOW) lesz.

Használhatjuk a belső felhúzó ellenállást, ( INPUT_PULLUP ) is, ebben az esetben a bemenet alapértelmezésben magas lesz.

pinMode(pin, INPUT_PULLUP);

A pinMode () segítségével kimenetként (OUTPUT) konfigurálhatjuk a csapokat. Az Atmega csapok akár 40 mA (milliamper) áramot is képes biztosítani. Ez elegendő áram ahhoz, hogy világítson egy LED vagy működjön egy tranzisztor, de kevés a relék vagy motorok működtetéséhez. Ha nagyáramú eszközöket kapcsolunk a kimeneti csapokra, tönkreteheti a pin kimeneti tranzisztorait, vagy károsíthatja a teljes Atmega chipet. Segíthet a pinek védelmében, ha az OUTPUT csapokat 470Ω – 1k ellenálláson keresztül kapcsoljuk más eszközökhöz.

digitalWrite () függvény

Ha a csapot OUTPUT-ként konfiguráltuk , a digitalWrite() függvény segítségével HIGH vagy LOW értéket írhatunk rá. Ilyenkor a pin feszültsége, ha a HIGH paramétert adunk meg, a tábla működési feszültségére lesz beállítva (5 V vagy 3,3 V). Ha a LOW értéket használjuk, a pin feszültsége 0V lesz.

Ha a pin INPUT-ként van konfigurálva, a digitalWrite () engedélyezi (HIGH) vagy letiltja (LOW) a bemeneti pin belső felhúzó ellenállását. A belső felhúzó ellenállás engedélyezéséhez használjuk inkább a pinMode(pin, INPUT_PULLUP) függvényt. A digitalWrite () függvény szintaxisa:

digitalWrite(pin, VALUE);

pin – annak a csapnak a száma, amelynek módját be kívánjuk állítani
VALUE – HIGH, vagy LOW.

Lássunk egy példát. (A 13.pin a fedélzeti led.)

int Led = 13;

void setup()
{
  pinMode(Led, OUTPUT);
}
void loop()
{
  digitalWrite(Led, HIGH);
  delay(1000);
  digitalWrite(Led, LOW);
  delay(1000);
}

digitalRead () függvény

Az Arduino képes érzékelni, hogy van-e feszültség az egyik érintkezõjén, ezt a digitalRead() függvény segítségével tudjuk olvasni . 

Ha a csapot INPUT vagy INPUT_PULLUP-ként konfiguráltuk , a digitalRead() függvény segítségével beolvashatjuk a csap állapotát. Ez lehet HIGH vagy LOW érték.

Az 5V-os táblák esetében a 3,0 V-nál nagyobb feszültség magas logikai értéket, az 1,5 V-nál kisebb feszültség alacsony logikai értéket ad vissza.

A 3,3 V-os tábláknál 2,0 V-nál nagyobb feszültség magas, míg a 1,0 V-nál kisebb feszültség alacsony logikai érték lesz. A digitalRead() függvény szintaxisa:

digitalRead(pin);

pin – A csapnak a száma, amelyikről olvasni akarunk.

Egy példa. Ha megnyomjuk a gombot, akkor világít a led:

int Led = 13;
int Button = 2;

void setup()
{
  pinMode(Led, OUTPUT);
  pinMode(Button, INPUT_PULLUP);
}
void loop()
{
  bool ButtonValue = digitalRead(Button);
  
  if(ButtonValue == true)
  {
    digitalWrite(Led, HIGH);
  }
  else
  {
    digitalWrite(Led, LOW);
  }
}

analogRead () függvény

Egy analóg érzékelő értéke folyamatosan változik. Az ilyen típusú érzékelők leolvasásához olyan bemenetre van szükségünk, ami ezt kezelni tudja.

Az Arduino táblán találunk „Analog In” felirattal ellátott bemeneteket. Ezek a speciális csapok nemcsak azt mondják meg, hogy van-e rajtuk feszültség, hanem annak értékét is. Az analogRead () függvény segítségével leolvashatjuk a csap feszültséget.

Ez a függvény 0 és 1023 közötti számot ad vissza, amely 0 és 5 volt közötti feszültséget jelent. Például, ha a A0-as pinről 2,5 V feszültséget olvasunk, az analogRead (A0) értéke 512. Az analogRead () függvény szintaxisa:

analogRead(pin);

pin – az analóg csap száma, amelyikről olvasni szeretnénk. (Ez a legtöbb táblán, pl UNO: A0 – A5, a Mini és a Nano esetén A0 – A7, ha a választott kártya a Mega akkor A0 – A 15 közötti pinek.)

Az alábbi példában egy potméter értékét olvassuk be és küldjük el a soros porton.

int potmeterPin = A0;
int potmeterValue = 0;

void setup()
{
  Serial.begin(9600);
} 

void loop()
{
  potmeterValue = analogRead(potmeterPin);
  Serial.println(potmeterValue);
  delay(100);
}

analogReference () függvény

Beállítja az analóg bemenethez használt referenciafeszültséget. Ez a bemeneti tartomány felső értéke. Az analogReference függvény 0 és 1023 közötti számot ad vissza. Az analogReference() függvény szintaxisa:

analogReference(type);

type – az alábbiak közül bármelyik típust használhatja:

DEFAULT – Az alapértelmezett analóg referencia. Az Arduino táblák üzemi feszültsége(5V vagy 3,3V).

INTERNAL – Beépített referencia, 1,1 volt az ATmega168 vagy ATmega328-on és 2,56 volt az ATmega8-on (az Arduino Mega nem érhető el)

INTERNAL1V1 – Beépített 1.1 V referencia (csak Mega)

INTERNAL2V56 – Beépített 2,56 V referencia (csak Mega)

EXTERNAL – Az AREF pinre kapcsolt feszültséget (csak 0–5 V) használják referenciaként.

Az AREF-pin külső referenciafeszültségéhez csak 0V és 5V közötti értéket használhatunk. Ha külső referenciát használunk az AREF csapon, akkor az analóg hivatkozást EXTERNAL-ra kell állítania az analogReference() függvény segítségével a setup() szakaszban, mielőtt meghívná az analogRead() függvényt. Ha nem így teszünk összeköthetjük az aktív belső referenciafeszültséget és az AREF lábat, és ez károsíthatja a mikrokontrollert. 

A fenti ábrán látható kapcsoláson, beállítjuk az AREF feszültségét 3,3V- ra egy feszültségosztó segítségével. Ez lesz a mérhető érték felső határa. A potmétert középső kivezetését csatlakoztassuk az A0 pinhez, a jobb a GND-re, a bal oldalon lévőt pedig a 3,3V-ra. És egy példakód:

int potmeterPin = A0;
int potmeterValue = 0;

void setup()
{
   Serial.begin(9600);
   analogReference(EXTERNAL);
}

void loop()
{
   potmeterValue = analogRead(potmeterPin);
   Serial.println(potmeterValue);
}

A soros konzolon láthatjuk a potméter által beállított értéket.

analogWrite () függvény

Az analogWrite() függvény analóg értéket, ír az erre alkalmas pinekre. Ez egy állandó négyszög jel, a paraméterben megadott érték szerinti kitöltési tényezővel.

Az analogWrite() függvény használható például led-ek fényerejének változtatására, motorok fordulatszámszabályozására, stb. 

TÁBLA	PWM CSAPOK	PWM FREKVENCIA
Uno, Nano, Mini	3, 5, 6, 9, 10, 11	490 Hz (5. és 6. pin: 980 Hz)
Mega	2 – 13, 44 – 46	490 Hz (4. és 13. pin: 980 Hz)

Az analogWrite() függvény szintaxisa:

analogWrite(pin, VALUE);

pin – A csapnak a száma, amelyikre írni akarunk. (lásd a fenti táblázatban az alkalmas pineket)
VALUE – az üzemi ciklus (kitöltési tényező): 0 -255 között.

Lássunk erre is egy példát:

int ledPin = 9;
int potmeterPin = A0;
int potmeterValue = 0;

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

void loop()
{
  potmeterValue = analogRead(potmeterPin);
  analogWrite(ledPin, potmeterValue / 4);
}

Beolvassuk a potméter értékét az analogRead () függvénnyel, majd a kapott értéket elossztjuk néggyel és kiírjuk a ledPinre az analogWrite függvény segítségével.

Azert kell elosztani a bejövő értéket néggyel, mert az analogRead függvény által visszaadott érték 0 és 1023 között lehet. Az analogWrite függvénynek viszont csak 0 és 255 közti értéket adhatunk meg.

---

Az arduino táblákkal való komunikáció talán legfontosabb eszköze a soros port. Lássuk hogyan működik.

Serial.begin ()

Mielött használni szeretnénk az arduino táblánkon a soros komunikációt, inicializálni kell a soros portot. A Serial.Begin() az adatsebességet bit / másodpercben (baud) állítja be a soros adatátvitelhez. Ezt a void setup() szakaszban kell megtenni.

// Serial.Begin(baud);

void setup()
{
  Serial.Begin(9600);
}

Serial.print ()

Az adatokat ember által olvasható formában, ASCII szövegként nyomtatja ki a soros portra. A számokat minden számjegyhez ASCII karakterrel nyomtatják. Az float típusok hasonlóan vannak nyomtatva, mint az ASCII számjegyek, alapértelmezés szerint két tizedesjegyig. A bájtokat egyetlen karakterként küldjük el. A karaktereket és a karakterláncokat úgy küldjük, ahogy vannak.

void setup()
{
  Serial.Begin(9600);

  Serial.print(40);              // kiírja a 40-et
  Serial.print(29.2236);         // ez csak 29.22 ír ki, két tizedesig
  Serial.print('H');             // a H karakter
  Serial.print("Hello World");   // és egy karakterlánc: Hello World
}
void loop()
{

}

Opcionálisan megadhatunk egy második paramétert is, ezzel formázhatjuk a kimenetet.

void setup()
{
  Serial.Begin(9600);
  
  Serial.print(100, 0);   // ASCII Tábla szerint kiírja: 40
  Serial.print(40, BIN);  // ASCII Tábla szerint kiírja: 0110 0100 
  Serial.print(40, OCT);  // ASCII Tábla szerint kiírja: 144
  Serial.print(40, HEX);  // ASCII Tábla szerint kiírja: 64
}
void loop()
{

}

Ezt a paramétert használhatjük lebegőpontos számok esetén is, (float, double) ez határozza meg a tizedesjegyek számát.

void setup()
{
  Serial.Begin(9600);
  
  Serial.print(29.2236, 0);  // kiírja: 29
  Serial.print(29.2236, 1);  // kiírja: 29.2
  Serial.print(29.2236, 4);  // kiírja: 29.2236
}
void loop()
{

}

Serial.println ()

Hasonlóan működik. mint a Serial.print (), különbség a kinyomtatott sor végére a kocsi vissza karaktert ‘\r’ és az új sor karaktert ‘\n’ illeszti. Tehát a következő nyomtatási sor új sorban kezdődik. minden egyéb paramétere megegyezik a Serial.print () függvénnyel.

void setup()
{
  Serial.Begin(9600);
  
  Serial.println("Hello World");
}
void loop()
{

}

A következő táblázatban láthatjuk, az Arduino táblákon használható soros port(ok) pinjeit.

TÁBLA	RX csapok	TX csapok
Uno, Nano, Mini	0	1
Mega	0, 15, 17, 19	1, 14, 16, 18

Ajánlom a gyakorláshoz:

---

A következő részben megnézzük a változókat és adattípusokat.

---

---