PWM kimenet példaprogram

Ez a példaprogram semmi értelmeset nem csinál. Csupán azt demonstrálja, hogy hat különböző kivezetésen hogyan lehet különböző kitöltési tényezőt (LED esetén fényerőt) beállítani. Az is látható, hogy mennyivel egyszerűbb az Arduino C program. A BASCOM-ban ismerni kell a PWM használatához a beépített időzítő áramkörök működését, míg az Arduino C-ben ezekről nem is kell tudni, hogy vannak.

Az áramkört nem rajzoltam meg, mert még mindig nem tanultam meg egyetlen áramkör rajzoló program használatát sem. Bocs! Azonban a digitális ki és bemenet példaprogramjában található kapcsolási rajznak és instrukcióknak elegendőnek kell lenni, hogy magadtól is megcsináld. Kell 6 db led, 6 db ellenállás és vezetékek. Akár használhatod az ott található kapcsolást is, csak a programot kell átalakítani, és egyetlen kivezetésen állítgatni a fényerőt.

Arduino C pédaprogram:

byte f=0;  		//dekleráltunk egy F nevű változót (fényerő „F”el)
byte l=0; 		//deklaráltunk egy L nevű változót (fényerő „L”e)

void setup() 
{
  pinMode(6,OUTPUT);	//Arduino Uno R3 6-os kivezetés kimenet
  pinMode(5,OUTPUT); 	//Arduino Uno R3 5-os kivezetés kimenet
  pinMode(9,OUTPUT); 	//Arduino Uno R3 9-os kivezetés kimenet
  pinMode(10,OUTPUT); 	//Arduino Uno R3 10-os kivezetés kimenet
  pinMode(11,OUTPUT); 	//Arduino Uno R3 11-os kivezetés kimenet
  pinMode(3,OUTPUT); 	//Arduino Uno R3 3-os kivezetés kimenet
}

void loop() 
{
  analogWrite(6,255);	//max fényerő
  analogWrite(5,255);  	//max fényerő
  analogWrite(9,0);  	//0 fényerő
  analogWrite(10,0);  	//0 fényerő
  analogWrite(11,f);  	//folyamatosan nő a fémyerő
  analogWrite(3,l);  	//folyamatosan csökken a fényerő
  f=f+8;			//’F értékét növeljük 5-el. Mivel byte típusú ciklikusan
//növekszik és nulláról újraindul
  l=l-8;			//’L értékét csökkentjük 5-el. Mivel byte típusú folyamatosan
//csökken, és átfordul
  delay(100);		//100msec-et várakozunk	
  analogWrite(6,128);	//fél fényerő
  analogWrite(5,55);  	//55/256 fényerővel világít
  analogWrite(9,5);  	// nagyon halványan világít
  analogWrite(10,255);	// teljes fényerővel világít
  delay(100);  	   	//100msec-et várakozunk
}

BASCOM példaprogram:

$regfile = "m328pdef.dat"
$crystal = 16000000
Dim F As Byte		’dekleráltunk egy F nevű változót (fényerő „F”el)
Dim L As Byte		’deklaráltunk egy L nevű változót (fényerő „L”e)
F = 0				’kezdőérték beállítás
L = 0				’kezdőérték beállítás
Config Portd.6 = Output         	'timer0 a comparátorhoz tartozó kimenet 
’(Arduino Uno R3 6-os kivezetés)
Config Portd.5 = Output         	'timer0 b comparátorhoz tartozó kimenet 
’(Arduino Uno R3 5-ös kivezetés)
Config Portb.1 = Output         	'timer1 a comparátorhoz tartozó kimenet 
’(Arduino Uno R3 9-es kivezetés)
Config Portb.2 = Output         	'timer1 b comparátorhoz tartozó kimenet 
’(Arduino Uno R3 10-es kivezetés)
Config Portb.3 = Output         	'timer2 a comparátorhoz tartozó kimenet 
’(Arduino Uno R3 11-es kivezetés)
Config Portd.3 = Output         	'timer2 b comparátorhoz tartozó kimenet 
’(Arduino Uno R3 3-as kivezetés)
  Config Timer0=Pwm , Compare_a_pwm=Clear_down , Compare_b_pwm=Clear_down , Prescale=64
  Config Timer1=Pwm , Compare_a_pwm=Clear_up , Compare_b_pwm=Clear_up , Prescale=64
  Config Timer2=Pwm , Compare_a_pwm=Clear_up , Compare_b_pwm=Clear_up , Prescale=64
  Reset Portb.4
  Do
     Pwm0a = 0                           	'mivel clear_down, teljes fényerővel világit
     Pwm0b = 0                           	'mivel clear_down, teljes fényerővel világit
     Pwm1a = 0                           	'mivel clear_up, nulla fényerővel világit
     Pwm1b = 0                           	'mivel clear_up, nulla fényerővel világit
     Pwm2a = F                           	'mivel clear_up, folyamatosan nő a fényerő
     Pwm2b = L                           	'mivel clear_up, folyamatosan csökken a fényerő
     F = F + 8		    	’F értékét növeljük 5-el. Mivel byte típusú 
’ciklikusan növekszik és nulláról újraindul
     L = L – 8		    	’L értékét csökkentjük 5-el. Mivel byte típusú
’folyamatosan csökken, és átfordul
     Waitms 100		   	’100msec-et várakozunk
     Pwm0a = 128                        	'mivel clear down,fél fényerővel világít
     Pwm0b = 200                        	'mivel clear down,(255-200)/255 fényerővel világít
     Pwm1a = 5                           	'mivel clear_up, nagyon halványan világít
     Pwm1b = 255                        	'mivel clear_up, teljes fényerővel világít
     Waitms 100                          	'100msec-et várakozunk
  Loop
  End

Ha sorban haladsz a tudnivalókkal, akkor most az analóg bemenet használata következik!

Digitális ki és bemenet használata

Ez a kis programocska beállítja az Arduino Uno R3 4-es kivezetését (chip 6-os kivezetése, d port 4. bitje) bemenetnek, valamint az Arduino Uno R3 13-as kivezetését (chip 19-es láb, b port 5. bitje) kimenetnek. H a bemeneten magas szintet talál, akkor a kimenetet is magas szintre állítja be, ha a bemenet alacsony szintet talál, akkor a kimenetet is alacsony szintre állítja.

Természetesen a program kipróbálásához ki kell alakítanunk a hardver környezetet, vagyis rá kell kötnünk egy nyomógombot a bemenetre, és egy ledet a kimenetre. Praktikusan úgy szokták a nyomógombot bekötni, hogy lenyomásakor a bemenetet a földre húzza le, ha nincs benyomva, akkor pedig a chip-be beépített felhúzó ellenállás a bemenetet felhúzza +5V-ra (magas szintre). A kimenetre egy soros kb. 200ohm ellenállással közvetlenül ráköthetjük a led-et. Az alábbi ábrát a Tavir 60 napos tanfolyamából vettem kölcsön. Ezen külső felhúzó ellenállás is szerepel, ami nem kell, ha bekapcsoljuk a chip-be épített felhúzó ellenállást.

Természetesen ilyen bekötéssel a kapcsolás pont fordítva működik, a led folyamatosan világít és a nyomógomb lenyomásakor elalszik!

A példa programban az egyes sorokat kommentekkel láttam el. Remélem ez elegendő a működés megértéséhez.

Arduino C példaprogram:

void setup() 
{
  pinMode(7, OUTPUT);       	//7-es kivezetés kimenet
  pinMode(6, INPUT);        	//6-os kivezetés bemenet
  digitalWrite(6,HIGH);     	//belső felhúzó ellenállás bekapcsol
  digitalWrite(7,LOW);      	//7-es kivezetés alacsony szint (led nem világít)
}

void loop() 
{
  if (digitalRead(6)==HIGH) 	//ha a bemenet 1
    {digitalWrite(7,HIGH);} 	//akkor led világít 
  else                     		//egyébként (bemenet 0)
    {digitalWrite(7,LOW);}  	//led nem világít
}

BASCOM példaprogram:

  $regfile = "m328pdef.dat"
  $crystal = 16000000
  Config Portd.7 = Output         'portb.7 kimenet
  Config Portd.6 = Input          'portd.6 bemenet
  Portd.6 = 1                     'felhúzó ellenállás bekapcsolva a portd.7 kimeneten
  Portd.7 = 0                     'portb.7 kikapcsolva (led nem világít)
  Do
   If Pind.6 = 1 Then             'ha a bemenet 1, akkor
      Portd.7 = 1                 'kimenet is 1
   Else                           'egyébként (bemenet 0)
      Portd.7 = 0                 'kimenet is 0
   End If
  Loop
  End

A BASCOM programhoz még annyi magyarázatot fűznék hozzá, hogy az első két sor el is hagyható, ha fejlesztő környezetben beállítjuk a chip típusát és a kristályfrekvenciát (lásd az első LED villogtató program leírását). Viszont ezeket a paramétereket a programba is beleírhatjuk, így a fordító innen is tudhatja, hogy milyen chip-et fogunk használni. Így a program is hordozhatóvá válik, nem kell egy másik gépen mindent  újra beállítani, ezért érdemes ezt megtenni.

Ha nem untad meg, akkor kattints ide, hogy a megtudhasd, hogyan kell a PWM kimeneteket használni!

Néhány Arduino modul

2×16 karekteres LCD kijelző szöveges infó megjelenítésére. Részletes leírása itt!

Led matrix kijelző, amivel nagyméretű feliratokat lehet megjeleníteni. Részletes leírása itt!

SD kártya modul, aminek a segítségével adatokat tárolhatsz. Részletes leírása itt!

Kikapcsoláskor elemről tovább működő óra, ami szolgáltatja a pontos időt és dátumot. Részletes leírása itt!

DHT11 illetve DHT22 hőmérséklet és páratartalommérő. Részletes leírása itt!

BMP180 légnyomás mérő. Részletes leírása itt!:

GY302 fényérzékelő modul. Részletes leírása itt! :

Ha már láttad az Arduino alaplapokat, a hozzá kapcsolható modulok egy részét, akár meg is tehetnéd az első lépéseket ahhoz, hogy saját kütyüket építs magad és családtagjaid, barátaid örömére. Kattints ide, és kezdheted is!

Néhány Arduino alaplap

Arduino UNO R3
Chip:ATmega328P
Órajel:16Mhz
Üzemi fesz:5V
Digitális lábak:14db (6db PWM)
Analóg bemenetek: 6db
Flash memória: 32Kbyte
SRAM: 2Kbyte
EEPROM:1Kbyte

Arduino Nano
Chip:ATmega328P
Órajel:16Mhz
Üzemi fesz:5V
Digitális lábak:14db (8db PWM)
Analóg bemenetek: 8db
Flash memória: 32Kbyte
SRAM: 2Kbyte
EEPROM:1Kbyte

Arduino Mini
Chip:ATmega328P
Órajel:16Mhz
Üzemi fesz:5V (3,3V)
Digitális lábak:14db (6db PWM)
Analóg bemenetek: 6db
Flash memória: 32Kbyte
SRAM: 2Kbyte
EEPROM:1Kbyte
nincs USB portja

Arduino Mega
Chip:ATmega2650
Órajel:16Mhz
Üzemi fesz:5V
Digitális lábak:54db (15db PWM)
Analóg bemenetek: 16db
Flash memória: 256Kbyte
SRAM: 8Kbyte
EEPROM:4Kbyte

Technikai adatok magyarázata:

Chip: az Arduino alaplapokban az ATMEL által gyártott mikrovezérlőket építik be. Ezek a mikrovezérlők jellemzően a kivezetések számában, a belső memóriában, és órajelben különböznek. Vannak természetesen más különbségek is. A fenti alaplapok az ATmega328 és az ATmega2650 vezérlőkkel készülnek. Érdemes lehet még megismerni az ATmega8 vezérlőt is, ha valahol nagyon kicsi programot kell futtatnunk. Minimális méretben (és kivezetés számban) az ATtiny85 típus lehet a nyerő, létezik is ezzel a chip-el szerel kicsi méretű USB-be dugható bélyeg nagyságú alaplap is.

Órajel: Az alaplapokra épített kontrollerek órajel ferekvenciája meghatározza a program végrehajtási sebességet. Azonban a nagy órajel frekvencia nagyobb fogysztást is jelent. Jellemzően 16Mhz szokott lenni, így ebben nincs választásunk.

Üzemi feszültség: Az alaplapokra építenek egy stabilizált tápegységet, ami 5-12V feszültséget 5V-ra csökkenti. Valójában a vezérlő 5V feszültségről üzemel. A vezérlő kimenetein is 5V körüli feszültség jelenik meg. Ez fontos lehet, mert egyes modulok 3,3V feszültségről működnek, és ekkor nem lehet közvetlenül összevezetékezni az alaplapot és az említett alkatrészeket.

Digitális lábak: azok a ki és bemenetnek konfigurálható vezérlő chip kivezetések, melyek közvetlenül felhasználhatók. A bemenetek 0V (LOW) és 5V (HIGH) feszültségek fogadására lettek tervezve. A valóságban a LOW kicsit több mint 0V, a HIGH pedig kevesebb mint 5V lehet ahhoz, hogy a bemenet helyesen érzékelje a LOW/HIGH szinteket. Bemenetek esetén bekapcsolható egy úgynevezett belső felhúzó ellenállás. Ez akkor segít, ha a bemenetre nem kapcsolunk semmit, így ebben az esetben a vezérlő HIGH állapotot olvas be. A kimenetek feszültsége szintén 0V és 5V között váltakozhat. Egyes kimenetek úgynevezett PWM képességekkel rendelkeznek, vagyis a kimeneten lévő négyszögjel kitöltési tényezőjét a vezérlő képes változtatni. Ezekkel lehet pl. fényerőt szabályozni.

Analóg bemenetek: Ezeket a bemeneteket feszültség mérésre lehet felhasználni. Több is található, de a feszültség digitális számmá alakítására szolgáló ADC-ből csak egy található a chiben. A vezérlő egyszerre mindég csak egy bemenet feszültségét méri meg. Az analóg bemenetek digitális ki és bemeneteknek is programozhatók, ha szükségünk van még több digitáis lábra.

Flashmemória számít az Arduino-k “fő” memóriájának, ez tárolja a letöltött programot, és kikapcsolás után is megőrzi a tartalmát, azaz a programot elegendő csak egyszer letölteni ide. Ezen kívül érdemes tudni, hogy kb 100.000-szer lehet új programot betölteni.

Az SRAM (static random-access memory; statikus tetszőleges hozzáférésű memória) tárolja a programban használt változókat. Az SRAM kikapcsoláskor elveszíti tartalmát.

Az EEPROM (Electrically Erasable Programmable Read-Only Memory, programozható, törölhető, csak olvasható memória). Ez kikapcsolás során is megőrzi a tartalmát, de szintén csak kb 100.000 újraírást bír ki. Praktikusan a következőkre használható:
– futás közben kiszámított fontos változók (paraméterek) tárolása, melyeket csak ritkán kell frissíteni.
– indulási alapbeállítások mentése
-…és bármi más, ami nem igényel a kütyü teljes élettartama alatt 100.000-nél több tárolási műveletet

Önmagában az Arduino nem sok mindenre jó. Ahhoz, hogy hasznos dolgot csináljon, modulokat kell hozzákapcsolni. Itt megismerhetsz néhányat ezek közül!

Mi az Arduino?

Írd be a Google keresőbe, és ömlik az információ. Túl sok, nem is igazán lehet elsőre kihámozni a lényeget. A legfontosabb tulajdonsága az Arduino névvel illetett eszközöknek, hogy otthoni barkács körülmények között is lehet nagy tudású kütyüket készíteni. Egyszerű eszközökkel, nagyon kevés induló tudás birtokában is összeállíthatsz elektronikus kapcsolásokat, amik a működtető programoktól kelnek életre. Ugyanazt az eszközt attól függően, hogy milyen programot töltöttél rá, igen sokféle feladatra használhatod fel. Tehát meg kell tanulni programozni! Nehéz szakma, de már nagyon kicsi kezdő tudással is sikerélményt szerezhetsz magadnak.

Önkényesen két csoportba soroltam az Arduino eszközöket:

Alaplapok: olyan gyárilag előre megszerelt elektronikus áramkörök, melyekre legalább egy mikrovezérlőt és kiegészítőket szereltek. Van benne tápegység, kivezetések, csatlakozók. Általában 5-12V feszültséget kell kötni rájuk szabványos csatlakozókon keresztül. A legtöbb alaplapot egy számítógépre tudod csatlakoztatni USB kábellel, de telefontöltőt is használhatsz. Az alaplapokra szerelt ATmega kontrollerek klasszikus mikrovezérlők. Rendelkeznek programmemóriával (flash), írható/olvasható memóriával a változó adatok tárolására, és nemfelejtő memóriával (eeprom), ami akkor is megőrzi az adatokat, ha kikapcsolod. Itt megtudhatsz néhány adatot azokról az alaplapokról, amiket én használtam már.

Kiegészítő modulok: Az alaplap önmagában semmire nem jó. Fut rajta egy program, ami adatokat kezel.
Első lépés, hogy érzékeljük a körülöttünk zajló eseményeket. Pl. mérjük a hőmérsékletet. Az érzékelt adatokat be kell juttatnunk a mikrovezérlőbe, és a rajta futó program feldolgozza azokat. A program pedig ezek alapján jelezni fog számunkra valamit, vagy elindít egy folyamatot pl. bekapcsolja a kazánt, ha hideg van.
A bemenő adatok előállításában, és a kimenő adatok felhasználásában segítenek nekünk a modulok. Vannak olyanok, melyek különféle fizikai jellemzőket alakítanak digitális adatokká (hőmérő, páratartalommérő, gyorsulásmérő, fénymérő stb.) és vannak modulok, melyek a mikrovezérlő adatait valamilyen módon felhasználják, és átalakítják. A legegyszerűbb modul, egy LED világító dióda, ami világit, ha mikrovezérlő feszültséget kapcsol rá. Beszerezhetünk magunknak reléket, amikkel villanymotorokat indíthatunk el, kijelzőket, melyek számunkra olvasható információkat jelenítenek meg. Ezek a modulok általában nem kifejezetten csak Arduino alaplapokhoz készülnek, általánosan felhasználhatók. Itt olvashatsz egy összefoglalót azokról a modulokról, amikkel már találkoztam.

Mire jó az Arduino?

Nehéz meghatározni, hogy mire is jó az Arduino? Talán leginkább szórakozás. Azonban nagyon hasznos eszközöket lehet készíteni. Csinálhatsz magadnak:

  • Riasztót a lakásodhoz
  • Világítás vezérlést, fényezőszabályzót
  • Kerti automata locsolót
  • Saját igényeidnek megfelelő ébresztőórát
  • Hőmérőt a lakásba
  • Játékokat a gyereknek
  • … és bármit, amit csak akarsz!

Mindezt otthon, barkács eszközökkel és fillérekért.

Azonban tudnod kell, hogy az általad készített eszközök, annyira lesznek megbízhatóak, amennyire megbízhatóra készíted. Ha nem töltesz elég időt a tervezéssel, a programok elkészítésével és a teszteléssel, lehetséges, hogy több bosszúságot fognak okozni kreálmányaid, mint örömöt. Viszont az is nagyszerű érzés, ha egy-egy bosszantó hiba okát megtalálod és kijavítod.

A boltban kapható Arduino modulok, amikből építkezhetsz, nem ipari kivitelezésűek. Néha ráakadsz majd selejtes darabokra. Ne vegye el a kedved, fillérekből megvehetsz egy újat és továbbléphetsz.

Az általam írt programokban szinte mindig maradnak hibák. A világítás vezérlésem 5 év alatt néhány alkalommal lefagyott. Ki kellett kapcsolni és újra vissza. Az időjárás állomásom összetett és bonyolult szerkezet lett, 4-5 hetente leáll, máig keresem a hiba okát. A szennyvíz átemelő szivattyú felügyeletét ellátó kis áramkörrel évek óta semmi baj nincs, működik. Mindezeket amatőr körülmények között, amatőr eszközökkel építettem. Szerintem erre számíthatsz Te is. Vágj bele, menni fog, és hasznos dolgokat hozhatsz létre!

Ha Te is úgy gondolod, akkor kezdhetjük a legelején! Kattints ide, ha készen állsz!

Analóg bemenet használata

Analóg bemenetre akkor lehet szükségünk, ha valamilyen eszköz vagy alkatrész kivezetésein szeretnénk megmérni a feszültséget. Az Arduino Uno-ban található analóg bemeneteknek eléggé korlátozottak a képességei. A teljes feszültség mérési tartományt 1024 részre tudja felbontani (10 bit). Azért ez elég sok esetben bőven elég. Sőt, időnként még sok is, így konfigurálható 256 feszültségszintre (8 bit), ami gyorsabb mérést tesz lehetővé. A chip-ben egy analóg-digital konverter (ADC) található, de elé építettek egy olyan kapcsolást, ami egyszerre csak egy bemenet köt az ADC-re. Ez a multiplexer! Ebből következik, hogy ha 6 jelet akarsz egyszerre mérni, azt csak egyenként sorban egymás után tudod megtenni. Egy mérés nem tart sokáig. Azt olvastam valahol, hogy egy csatornán másodpercenként több mint 10.000 mérést tudsz csinálni. Ennyi adat feldolgozásához már komoly memória és számítási teljesítmény kell. Mivel hang és videó képfeldolgozás egyenlőre nem célom, így ezzel a kérdéskörrel nem is foglalkoznék tovább.

Ahhoz, hogy az analóg bemenetek használatát megtanulhassuk, újra hardvert kell építeni. Be kell szerezni egy potenciométert. Természetesen az elektronikai boltokban ez is fillérekért kapható. Pl. egy 10kohm körüli darab pont megteszi. Nem feltétlenül kell tengellyel ellátott komolyabb darab. Én egy áramkörbe forraszthatót vettem, ennek ára 100Ft alatt van. Igaz, így csavarhúzóval kellett tekergetni, de a jelen feladatra éppen megfelelt így is.

Így néz ki a kapcsolás:

Ha mindez készen van, lehet megírni a programot. Annyit érdemes még tudni, hogy az Arduino Uno alaplapon az analóg bemeneteket A0..A5 jelöléssel látták el. Ezek a bemenetek is használhatók természetesen digitális ki és bemenetnek, ha éppen analóg mérésre nincs szükséged.

Az analóg feszültség értéket a chip egy 0..1023 közötti számként adja vissza. Értelem szerűen a 0 jelenti a 0V bemenő feszültséget. Az 1023-at akkor kapunk eredményül, ha a bemenő feszültségünk pontosan megegyezik egy referencia feszültséggel. Ennek értéke alapértelmezetten 5V (a tápfeszültség). A referencia feszültség lehet a 1,1V is az ATmega328P chip esetén, amit egy belső referencia tápegység szolgáltat. Ekkor Arduino Uno esetén 0..1,1V tartományban tudunk mérni. Ha pontosabb mérésre van szükség, akkor azonban külső referencia feszültséget kell kapcsolnunk a chip 21-es kivezetésére. Nagyon pontos mérések esetén az analóg konverternek külön tápfeszt is kell adni a chip 20-as kivezetésén, de ezzel kezdőként nem érdemes foglalkoznunk. Arra is vigyázzunk, hogy az analóg bemenetre semmiképpen nem kerülhet nagyobb feszültség, mint a chip tápfeszültsége (5V), mert tönkremegy az áramkör. Természetesen a földhöz képest negatív feszültséget is kerülni kell.

Mielőtt az analóg bemeneteket megismernénk érdemes egy kis kitérőt tennünk az Arduino Uno és a PC közötti sorosporti kommunikáció irányába. Erre azért lesz szükségünk, mert az analóg jelszintek mérésekor keletkező számadatokat nagyon nehezen tudnánk a kivezetéseken LED-ek vezérlésével láthatóvá tenni. Sokkal egyszerűbbnek tűnik beolvasni a PC-be és megnézni a képernyőn. Ha a mikrovezérlővel analóg jelet mérünk és nem akarjuk PC-n megjeleníteni a mért értéket, akkor könnyedén kiírhatjuk egy LCD kijelzőre, de most még nem akartam bonyolítani a programot az LCD kijelző programozásával. A soros kommunikáció beállítása és használta nagyon egyszerű, a kommentezett programsorok teljesen elegendőek a működés megértéséhez. A soros adatátviteli protokollokról itt olvashatunk részletesebben, de most még nyugodtan kihagyhatod, a következőkhöz nincs rá szükség.

És most végre jöhetnek a programkódok. Soros kommunikációt használtam arra, hogy megjelenjen a soros monitoron (illetve BASCOM-ban a terminál emulátorban) a mért értékek. Mérés közben természetesen tekergettem a potenciométert és az értékek szépen változtak. Érdemes kipróbálni, hogy mi történik, ha átállítjuk a referencia feszültséget, ezért benne is hagytam a forrás programokban kommentezve a másik lehetséges belső referencia értéket. Remélem a programsorokhoz írt kommentek itt is eléggé beszédesek. C-ben a programban kommenteket a “//” dupla dőlt zárújel után írhatunk. Ezt a fordító program nem veszi figyelembe, csak magunknak jegyzetelgethetünk.

Arduino C

Az itt megjelenő programrészlet már egy önmagában működőképes, futtatható program. Van “setup” és “loop” része, amiről már esett szó. A setup csak egyszer fut le, és a loop az ami ciklikusan ismétlődik. A “{” és a “}” zárójelek jelzik a setup illetve loop elejét és végét. Ez igaz minden függvény felépítésére, amiket a jövőben használni fogunk.

void setup() {
  Serial.begin(9600);                          //Soros port inicializálás
  Serial.println("Indul...");                //kiírjuk a soros portra, hogy indul a mérés
  analogReference(DEFAULT);       //A tápfeszt veszi referenciának (5V)
 //analogReference(INTERNAL);  //Atmega168 és ATmega328 esetén a belső referencia 1,1V, most nem ezt használjuk                                          
}
void loop() {
  Serial.println(analogRead(A0));      //az A0 bemeneten végzünk egy mérést és rögtön kiküldjük az eredményt a soros portra                                                                 
  delay(1000);                            //várakozunk 1 másodpercet a következő mérésig
}


Default referencia feszültség esetén a potenciométert teljesen végállásba kell tekerni ahhoz, hogy 1023-at lássunk mért értékként, míg ’INTERNAL” esetén már a potenciométer kis eltekerésével elérjük ugyanezt az adatot, hiszen a belső referencia 1,1V, és ehhez kb. 20%-ot kell forgatnunk csak.

Következzen egy kis gyakorlatias átalakítás! Gyakran arra használom az analóg bemenetet, hogy fejlesztés során mért értékeket szimuláljak a programban, és kipróbáljam a működést tág értékhatárok között. Pl. gyakran mérek hőmérsékletet, de valós hőmérő esetén nem szeretném megvárni a telet a negatív értékek kipróbáláshoz. Íme egy példa, amiben a mért értéket kb. -50 és +50 fok közötti értékre alakítja a program egy tizedes jegy felbontással:

float homerseklet;             //a homerseklet valtozó float típusú, ami negatív is lehet
void setup() {
  Serial.begin(9600);          //Soros port inicializálás
  Serial.println("Indul...");  //kiírjuk, hogy indula mérés 
  Reference(DEFAULT);          //A tápfeszt veszi referenciának (5V)
  //analogReference(INTERNAL); //Atmega168 és ATmega328 esetén a belső referencia 1,1V
}

void loop() {
  homerseklet=((float)analogRead(A0)/10)-50;  //(float) konvertálja az egész számot lebegőpontos számmá, jelen esetben a mért egész értéket. Ez után már lehet osztani 10-el, hogy legyen tizedes értékünk is!
  Serial.println(homerseklet);   //az A0 bemeneten végzünk egy mérést és rögtön kiküldjük az eredményt a soros portra                                                   
  delay(1000);                              //várakozunk 1 másodpercet a következő mérésig
}


Az analóg bemenet programozható digitális ki és bemenetnek is. Ekkor egyszerűen csak a setup részben a következőt kell megadni:
            pinmode(A0,INPUT);     //analog bemenet digitális bemenetre konfigurálása
            digitalread(A0); //olvasás a bemenetről

BASCOM

BASCOM-ban a program kommenteket egy ‘ szimpa idézőjel mögé írhatjuk! A kommenteket dőlt betűvel is megjelöltem, hogy jobban elkülönüljenek a program utasításoktól.

BASCOM-ban először az analóg konvertert be kell állítani

Config Adc=Single, Prescaler=Auto  Reference=INTERNAL ‘beállítjuk az analóg konvertert

Itt is sok minden magyarázatra szorul. A konverter beállítható úgy, hogy csak egy mérést végezzen (Adc=single), és úgy is, hogy folyamatosan mérjen (Adc=free). Folyamatos mérés beállítása esetén így néz ki egy mérés.

Start Adc                 ‘elindítjuk az analóg konverter részegységet
w=Getadc(0)          ‘mérünk egyet a 0 csatornán
Stop Adc                  ‘leállítjuk az analóg konvertert

A program tehát így néz ki:

$regfile = "m328pdef.dat"    'ATmega3218P chipet használunk
$crystal = 16000000             'órajel 16Mhz
$baud = 9600                          'sorosport sebességet ’9600boud-ra állítjuk
'Config Adc = Single , Prescaler = Auto , Reference = Avcc    
          'ADC konfigurálás, single mód,
           'referencia a tápfesz (5V), ez most
           'komment, mert nem 
           'így használom
Config Adc = Single , Prescaler = Auto , Reference = Internal   
           'ADC konfigurálás, single 
           'mód, referencia a tápfesz (1,1V)
Start Adc                            'ADC elindítása
Do
  Print Getadc(0)        'mérünk egyet és rögtön kiírjuk a soros portra
  Waitms 1000            'várakozunk 1 másodpercet a következő mérés előtt
Loop
End


Az Arduino ki és bemenetek konfigurálásával sokféle eszközt kezelhetünk. Világíthatnak LED-ek, meghúzhatunk egy relét, ami elindítja a szivattyút, beolvashatjuk egy potméter állását, megmérhetjük egy fényellenálláson eső feszültséget, ami sötétedéskor bekapcsolja a világítást stb. Ezek az egyszerű kiegészítők.

Ha valamilyen bonyolultabb kütyüt szeretnénk készíteni, akkor az eddig megismert ki és bemenetek kevésnek fognak bizonyulni. Sokkal nagyobb tudású eszközöket is használnunk kell, melyek már kommunikálni akarnak egymással. Érdemes összefoglalóan megismerni a kommunikációs lehetőségeket, amiket az Arduino biztosít számunkra. Kattints ide, ha még ez is érdekel!

PWM képes kimenet használata

A PWM kimenetet azért találták ki, hogy ne csak kétféle állapotot (feszültséget) lehessen beállítani egy kimeneten.
Ha csak digitális kimenetünk van, akkor a világítást bekapcsolhatjuk vagy kikapcsolhatjuk, de pl. nem tudunk félhomályt beállítani a szobában, pedig ez is nagyon kellene romantikus pillanatokban! Szerencsére van “digitális” megoldás a problémára. Ha gyorsan ki és bekapcsolgatjuk a világításunkat, akkor a szemünk kb. 50-100Hz felett már nem képes követni az eseményeket, folyamatos de halványabb fénynek érzékeli a villogást. Egy villanymotor pl. úgy reagál ha kapcsolgatják a működtető feszültségét, hogy kissebb fordulatszámmal forog. Persze a világítás vagy a motor kapcsolgatásához nem használhatunk relét, hiszen az nem tud ilyen gyorsan működni. Valamilyen elektronikus teljesítmény kapcsolóra lesz szükségünk, pl. vehetünk a boltban MOSFET tranzisztor, ami erre a célra tökéletes.
Tehát a PWM jó lesz nekünk. Nem kell mást tenni a kimenettel, mint a ki és bekapcsolások idejének arányát változtatni. Az Arduino ezt 256 fokozatban tudja megtenni. A ki és bekapcsolgatások frekvenciája is állítható, alap helyzetben úgy emlékszem 400Hz, de ehhez még soha nem kellett hozzányúlnom.

Lássunk végre a egy programkódot:

Arduino C

analogWrite(x,15);       //az x kivezetés PWM képes és 15-re állítottuk
                                       //x-et 0-255 intervallumban adhatjuk meg

A PWM képes kimenetre közvetlenül írhatsz a digitalWrite() utasítással is. Pl:

digitalWrite(5,High)    //ennek az utasításnak az eredménye
                                      //azonos az analogWrite(255,5) utasítással


BASCOM

Ez itt kicsit bonyolultabb mint C-ben. Elsőként azt kell tudnunk, hogy a hardveresen megvalósított pwm kimenetet a chip-be beépített timerek vezérlik, ezért elsőkét a timereket kell beállítani. Minden timerhez tartozik két kimenet, amit vezérelni tud. A chip kivezetés listájából derül ki, hogy melyik kimenetért melyik timer a felelős. Példaként az ATmega328 kivezetéseinek jelölését nézzük:

TIMER0:
OC0A (PD6) chip 12-es láb Arduino-n digital pin 6
OC0B (PD5) chip 11-es láb Arduino-n digital pin 5
TIMER1:
OC1A (PB1) chip 15-es láb Arduino-n digital pin 9
OC1B (PB2) chip 16-es láb Arduino-n digital pin 10
TIMER2:
OC2A (PB3) chip 17-es láb Arduino-n digital pin 11
OC2B (PD3) chip 5-es láb Arduino-n digital pin 3

Ha ezen kimenetek valamelyikét PWM módban akarod használni, akkor a megfelelő TIMER-t kel beállítani. Ehhez a következő sort kell beilleszteni a programba:

Cinfig Timer1 = PWM, Compare A PWM = Clear Down,
Compare B PWM Clear Down, Prescal = 64

Ebben a parancsban több dolog is magyarázatra szorul. A Config Timer1=PWM rész a megfelelő timer pwm felhasználását jelenti. Ekkor a timer már másra nem használható. A Compare A PWM részben a timerhez tartozó „A” komparátort állítjuk be úgy, hogy amikor a timer elért egy bizonyos értéket, akkor a kimenet jelét 1-ről 0-ra ejti. Nyilván azt a bizonyos elért értéket kell majd a programban beállítanunk. Lehet azt is, hogy a megadott értéknél kerüljön a kimenet 1-be, akkor azt kell írnunk, hogy Compare A PWM Clear Up. A másik kimenethez a másik, B jelű komparátor tartozik. Ha csak egyik vagy másik kimenetet akarjuk használni, akkor a kimenethez tartozó részt egyszerűen kihagyjuk. Pl. ha csak a B kimenet fog kelleni:

Cinfig Timer1 = PWM, Compare B PWM Clear Down, Prescal = 64

A Prescale=64 a timer bemeneti előosztóját állítja be. Gyakorlatilag ezzel a PWM jel frekvenciáját állíthatjuk be. A PWM jel frekvenciája így számítható ki: fpwm=fclk / (N*256), ahol fpwm a pwm frekvencia, fclk a chip frekvenciája, N pedig a PRESCALE rész mögé írt érték. Utóbbi lehet: 1,8,64,256,1024. Ha Prescale=1-et írunk, akkor a lehető legnagyobb a frekvencia. Ha jól sejtem ennek a beállításnak az értékei akár chip függők is lehetnek, ezért itt kelleni fog az adatlap. ATmega328 esetén a maximális érték 1024. Ha pl. a chip-re egy 16Mhz-s kvarc kristályt teszünk, akkor a frekvenciája fclk=16Mhz, és fpwm-re 61,02315Hz adódik. A Prescal=64 éerékre 976,56 Hz vagyis kb. 1Khz a PWM frekvencia! Megmértem frekvencia mérővel a kimenet PWM frekvenciáját és a következő értékeket kaptam:

Prescale (N)frekvencia
131,37 Khz
83,921 Khz
64490,2 Hz
256122,5 Hz
102430,63 Hz

És most lássuk, hogyan állítjuk be a chip kiválasztott kimenetén a PWM értékét. Egyszerűen csak ennyit kell írnunk Pl.:
Pwm1a=128      ’ekkor az OC1A kimenetet (chip 15-ös láb, Arduino-n digital pin 9)
                            ’kitöltési tényezőjét állítjuk 128/256.
Pwm2b=10        ’ekkor az OC2B kimenetet (chip 5-es láb Arduino-n digital pin 3)
                            ’kitöltési tényezőjét állítjuk 10/256-ra.

Ha működés közben szeretnél látni egy teljes példa programot ami a PWM kimeneteket vezérli, akkor kattints ide!


A kimenetet így nem analóg módon tudjuk szabályozni, csak ki be kapcsolatuk. Ha ténylegesen analóg feszültség értéket szeretnénk látni a kimeneten, akkor kössünk rá egy kondenzátort és ellenállást párhuzamosan. A kondenzátor a kimenet 1 értékénél feltöltődik, amit az ellenállás azonnal meríteni kezd. A kapacitás és ellenállás értékek megfelelő értékének kiválasztásával feszültség szintet fogunk kapni, de ez kicsit “fűrészfogas” lesz. Nekem ilyesmi még soha nem kellett, így nincs tapasztalatom. Létezik olyan kész áramkör modul is, ami konkrét feszültséget állít elő, de ez már más elven fog működni. Ilyen például az MCP4725 modul, ami I2C buszon kommunikál az Arduino-val és 12 bites felbontással (4096 lépésben) képes analóg feszültséget varázsolni a kimenetére. Ha ez a modul érdekel, akkor kattints ide!

Készítettem egy olyan demo programot, amit esetleg mások is sikerrel felhasználhatnak. Ez a program egy függvény, ami megadható bemenetet figyel, és az egyik kiválasztott pwm képes kimenetet vezérli. A bemenetre kötött nyomógombbal lehet a világítást fel-le kapcsolni, fényerőt szabályozni. Ha lekapcsolod a világítást, akkor fokozatosan csökkenti a fényerőt, és tartja egy darabig minimumon stb. A forráskódok menüpont alatt más hasonló hasznos programocskákat is elhelyeztem.

Készítettem egy lakás világítás vezérlő programot, ami PWM kimeneteket használ a fényerő beállításra. Igen bonyolult és áttekinthetetlen program lett, mert egyetlen Arduino (illetve ATmega328 chip-el) több szoba világítását is vezérlem, és ezeknek egy időben kell működniük, amit nehezen tudtam megoldani. Azonban érdemes lehet később visszatérni erre a programra. Csak nyomógombok és led-ek vannak benne.

Bár tökéletesen működő valódi analóg kimenetünk nincs, de analóg bemenet van. Meg akarod ismerni a működését? Kattints ide!

Arduino kivezetések konfigurálása és használata

Ebben a fejezetben azokat a nyelvi elemeket tekintjük át, melyekkel a mikrovezérlő egyes kivezetéseit lehet működésre bírni.

Én az Arduino  C és BASCOM (basic) fejlesztő környezetben ismerkedtem a programozással, ezért ebben a kettőben tudom megmutatni hogyan kell beállítani az egyes kivezetéseket a különböző funkciókra pl. bemenet, kimenet, PWM kimenet stb. és hogyan kell a programokban hivatkozni ez egyes kivezetésekre, csatlakozási pontokra. Találsz program példákat C-ben és BASCOM-ban is. Mivel végül a C mellett döntöttem, csak néhány oldalon találsz BASCOM leírásokat. Kezdetnek talán ennyi elég a választáshoz.

A kivezetések jelentős része a programban konfigurálható ki és bemenetnek, és különböző gyárilag beépített funkciókat láthatnak el. Arra már láttunk példát, hogy lehet egy kivezetésre LED-et kapcsolni és láttunk egy példa programot, ami villogtatta a LED-et. A LED attól villogott, hogy a program arra utasította a mikrovezérlőt, hogy a kivezetésére váltakozva hol 0, hol 5V feszültséget kapcsoljon. Amikor a kivezetésre 5V került, a LED világított! …és ki akarta, hogy 5V legyen a kimeneten? Hát persze hogy TE! Ennyire egyszerű!
Egyes kimeneteket be lehet állítani PWM kimenetnek. Ez a PWM kimenet képes arra, hogy a LED fényerejét vagy villanymotor fordulatszámát szabályozza,
Természetesen akár ugyanaz a kivezetés lehet bemenet is, és a rá kapcsolt magas (kb. 5V) vagy alacsony (kb. 0V) jelszinteket a programból tudjuk figyelni. Találunk analóg bemenetek is az Arduino alaplapokon. Ezekkel analóg feszültség szinteket lehet mérni, és számmá alakítani 0..1023 számtartományban. Pl. megmérheted egy 1,5V-os ceruza elem feszültségét. A kapott szám kb. 300-320 lesz, ha az elem nincs lemerülve, és 5V referencia feszültséget állítottál be az analóg konverternek (erről még később lesz szó). A leírt paraméterek mikrovezérlőnként változhatnak.
Az ATmega328P típusra gondolok, ha valamilyen adatot leírok. Ez a típus eléggé olcsó ugyanakkor „nagy tudású” ahhoz, hogy egy kezdőnek ideális legyen. Összesen 6 analóg bemenete és 14 digitális ki vagy bemenete van. Ha több kivezetés kell a feladat megvalósításához, vagy nagyobb program memóriára van szükség, akkor más típust kell választani. A program azonban nagyjából maradhat ugyanaz! Lássuk most sorban az egyes kivezetések beállítását és használatát Arduino C és BASCOM programnyelven is.

A következő eseteket fogjuk áttekinteni (kattints arra, ami érdekel, a bemenetet javaslom elsőnek):

Példa programokat is találni fogsz (oda is vezetlek ezekhez a megfelelő pontokon a későbbiekben):

Adott láb kimenetre állítása és használata

Amikor egy chip áramot kap a kivezetések bemenetként viselkednek. A betöltött program elindul, és tetszőleges pillanatban, akár egy programon belül többször is, átállíthatjuk kimenetnek, vagy vissza bemenetnek. Ha kimenetnek állítod, akkor tudnod kell, hogy kétféle állapotba kerülhet:
LOW állapot, ekkor közel 0V feszültség jelenik meg rajta.
HIGH állapot, ekkor közel 5V feszültség jelenik meg rajta.
Figyelni kell arra, hogy egy kimenetnek állított kivezetésre mit kötöttél rá. Ha pl. egy vezetékdarabbal a GND (föld) kivezetéshez kötötted, az nem szerencsés. Ha pl. LOW állapotban van, az még nem nagy probléma, de amint HIGH állapotba kapcsolod az 5V feszültség hatására egyre nagyobb áram kezd folyni a kimeneten. Ez az áram olyan nagy is lehetne, hogy tönkreteszi a chip-et. Szerencsére az áram nagyságát kb 40mA-ben korlátozták, így nem fog tönkre menni. De ez azt is jelenti, hogy teljesítmény LED-et nem érdemes idekötni. Azonban pl. egy jelzésre használható LED dióda egy soros áramkorlátozó ellenállással (pl. 220 ohm) simán ráköthető, és HIGH értéknél ragyogni fog. Lássuk végre a programozási lehetőségeket:

Arduino C

pinMode(x,OUTPUT);      //az x kivezetés kimenet
digitalWrite(x,HIGH);      //az x kivezetés kb 5V-ra kapcsol
digitalWrite(x,LOW);       //az x kivezetés kb. 0V-ra kapcsol

Pl.:

pinMode(13,OUTPUT);     //Arduino 13-as kivezetés kimenet (a chip 19-es láb)
digitalWrite(13,HIGH);     //Az Arduino 13-as kivezetésen 5V kimeneti szintet állítunk be
digitalWrite(13,LOW);      //Az Arduino 13-as kivezetésen 0V kimeneti szintet állítunk be


BASCOM

Config Portx.y=Output    ’x port y kivezetése kimenet lesz (x általában B,C,D port lehet)
portx.y=1                           ’x port y kivezetése kb 5V-ra kapcsol
portx.y=0                           ’x port y kivezetése kb 0V-ra kapcsol
Pl.:

Config portB.5=Output ’Arduino 13-as kivezetés (chip 19-es láb) kimenet
portB.5=1                        ’Arduino 13-as kivezetés (chip 19-es láb) kb. 5V jelenik meg
portB.5=0                        ’Arduino 13-as kivezetés (chip 19-es láb) kb. 0V jelenik meg

utóbbi utasítás helyett használhatjuk a következőt is:

Set portB.5 ’Arduino 13-as kivezetésen (chip 19-es láb) kb. 5V jelenik meg
Reset portB.5 ’Arduino 13-as kivezetésen (chip 19-es láb) kb. 0V jelenik meg

Ezen a ponton érdemes megtekintened egy működő példaprogramot a ki és bemenetek használatára.

Ha nem untad meg, akkor kattints ide, hogy a megtudhasd, milyen más működésű kimeneteket tudsz még használni!

Adott láb bemenetre állítása és állapotának kiolvasása a programból

A bemenet arra alkalmas, hogy HIGH (kb. 5V) és LOW (kb. 0V)feszültségszinteket különböztessen meg az Arduino. Ha egy bemenetet a GND (föld) kivezetéshez kapcsolsz egy vezetékkel, és beolvasod a bemenet állapotát, akkor LOW (bináris számként kifejezve 0, vagy logikai értékkel kifejezve false azaz hamis) értéket fog beolvasni a chip. Ha a vezeték darabot az 5V-os tápfeszültségre kötöd, akkor a bemenet állapota HIGH (bináris 1, vagy logikai true azaz igaz) lesz. Ne zavarjon, hogy HIGH, 1, 5V, true, igaz jelzőket használok. Mind ugyanazt jelenti: a bemeneten közel tápfeszültség van. Ez a magas (HIGH) feszültség állapot, amit a digitális értékek között az “1” képvisel, ligikai áramkörökben pedig azt mondjuk rá true. Ne hagyd magad megzavarni, csak azért írok mindig mást, mert ettől úgy tűnik mintha értenék hozzá!

Mi van akkor, ha nem kötöd sehová a bemenetet, csak lóg a levegőben. Ekkor bizonytalan lesz a bemenet állapota. Lehetséges, hogy az egyik beolvasás HIGH, míg a másik LOW értéket fog visszaadni. Ezért sok esetben a bemenetre egy úgynevezett felhúzó ellenállást kötnek. A felhúzó ellenállás értéke lehet kb. 10 Kohm, míg egyik vége a bemenethez, másik végét az 5V kivezetésre kötik. Ha pl. egy kapcsoló állapotát kell lekérdezni a bemeneten, akkor a kapcsoló egyik kivezetése a bemenet, másik a GND.

Az ábra innen származik: https://www.instructables.com/id/Understanding-the-Pull-up-Resistor-With-Arduino/) Itt a felhúzó ellenállás 4.7Kohm, ez is jó. Ha a kapcsoló nincs bekapcsolva (jobb oldali ábra), akkor a bemeneten HIGH szintet olvasunk be, hiszen a felhúzó ellenállás 5V-al köti össze. Ha megnyomjuk a nyomógombot (bal oldali ábra), akkor LOW szintet kapunk, hiszen a kapcsoló egy rövidzár a GND felé, és ilyenkor ez az erősebb. A felhúzó ellenálláson 5V/4,7Kohm=~1mA áram folyik amíg nyomod a gombot, de ez senki nem zavar, kicsit nagyobb az áramkör fogyasztása.
Viszont van egy jó hírem, a felhúzó ellenállást eleve beleépítették az ATmega328 chip-be. Mivel nincs rá mindig szükség, ki és bekapcsolhatóvá tették. Tehát ha egy bemenetre nyomógombot akarsz tenni, akkor állítsd a kivezetést bemenetre, és kapcsold be a felhúzó ellenállást. A belső felhúzó ellenállás magyarázó ábrája a tavir.hu weboldalról származik:

Fontos megfigyelni, hogy a kapcsoló bekapcsolt állapota esetén a bemeneten LOW szint van. Tehát a bemeneti 0V (LOW) szint az aktív, ez jelzi az eseményt. Ez nem baj, csak általában pont fordítva szoktak jelezni az érzékelők. Pl. egy mozgásérzékelő akkor ad HIGH szintet, ha mozgást érzékel. Semmi gond, csak tudjunk róla. Egyébként elvileg lehetne fordítva is, miszerint a föld felé teszünk “lehúzó” ellenállást, és a kapcsoló a 3V-ra húzza fel a bemenetet. Ekkor a nyomógomb megnyomásának eseményét a HIGH szint jelezné a bemeneten. Nem miért, de nem így szokták!

Lássuk végre, hogyan is kell bemenetet csinálni és lekérdezni azt! Még annyit érdemes tudni, hogy az Arduino IDE C programját két fő részre osztották. Van egy “SETUP” rész, ami csak egyszer fut le, és van egy “LOOP” rész, ami viszont ciklikusan, végtelen ideig újraindul az első utasítástól kezdve, ha befejeződött az utolsó utasítás végrehajtása. A kivezetések működésének definiálását a setup-ban szokták megcsinálni, de nem kötelező ott, a loop-ban is lehet. Sőt, akár működés közben is átállíthatod a kimenetet bemenetre, vagy vissza, de ezzel óvatosan kell bánni, és nehezen találok rá okot, hogy miért is kellene ilyet tenni.

Arduino C-ben a bemenetek beállítása és lekérdezése:

(C-ben a “//” két perjel mögötti szöveg a megjegyzés, amit magadnak irogatsz, nem a program része)

pinMode(x,INPUT);            //az x kivezetés bemenet
digitalWrite(x,HIGH)          //az x kivezetés belső felhúzó
                                             //ellenállásának bekapcsolása
digitalWrite(x,LOW)          //az x kivezetés belső felhúzó
                                            //ellenállásának kikapcsolása
digitalRead(x)                    //az x kivezetés aktuális értékének beolvasása

Ez itt alább már egy működőképes programrészlet (Ha bemásolod az Arduino IDE felületére, akkor ez egy lefordítható és Arduino-ba tölthető kód. Ez most még nem egy teljes program, hiányoznak fontos részek):

pinMode(13,INPUT);         //a chip 19-es láb (PB5, Ardunio-n
                                            //digital pin 13) bemenet
digitalWrite(13,HIGH);     //a 19-es lábon a belső felhúzó
                                            //ellenállás bekapcsolva
ertek=digitalRead(13);     //az ertek nevű változóba beolvassuk
                                            //a bemenet állapotát


BASCOM-ban a bemenetek beállítása és lekérdezése:

(BASCOM-ban a megjegyzéseket, kommenteket a ‘ jel után írhatod)

Config pinx=Input              ’az x port minden kivezetését
                                              ‘bemenetnek állítjuk
Config Pinx.y=Input           ’x port y kivezetése bemenet lesz

Felhúzó ellenállás bekapcsolása:
Portx.y=1                              ’x port y kivezetésén a felhúzó
                                               ‘ellenállás bekapcsolása
portx.y=0                              ’x port y kivezetésén a felhúzó
                                               ‘ellenállás kikapcsolása

Egy működőképes példaprogram részlet:

portb=&B00000010 ‘a második bitre 1-et írunk ezzel bekapcsoljuk
                                     ‘a belső felhúzó ellenállást. feltételeztem, hogy
                                     ‘csak a második kivezetés bemenet, a többi kimenet

vagy:

portb.2=1

Az alábbi példaprogram ugyanazt csinálja mint a fenti C példaprogram:

config PortB.5 INPUT    ’a chip 19-es láb (PB5, Ardunio-n
                                        ‘digital pin 13) legyen bemenet
portB.5=1                       ’a 19-es lábon a belső felhúzó ellenállás bekapcsolva
A=pinb.5                        ’A változóba beolvassa a bemenet állapotát


Van még néhány fontos tudnivaló:

  • Az átlagos nyomógombok nem adnak határozott jelet. Amikor megnyomod a nyomógombot, két fémdarab ér egymáshoz, és kapcsoláskor kicsit pattognak egymáson. Vagyis a kapcsoló egy darabig hol kapcsol, hol meg nem. Ezt a jelenséget “prell”-nek hívják. Az otthoni villanykapcsolón nem veszed észre, mert a jelenség néhány századmásodpercen belül lezajlik. A vezérlő viszont olyan gyors, hogy ezeket a bizonytalan hol be, hol ki állapotokat észreveszi. Ha pl. a gombnyomások számát akarod megszámolni, akkor egy gombnyomásra 4-5-öt is számolni fog a program. A prell szoftveresen megszüntethető. Egyszerű a dolog, hiszen az első kontaktusnál már tudjuk, hogy megnyomtuk a gombot, és egy ideig nem szabad figyelembe venni, hogy mi történik. Gyakorlatban ez a várakozási idő kb. 50msec. A prellmentesítéssel elég sokat foglalkoztam, mert folyton nehézségeket okoz. A forráskódok menüben találsz egy külön oldalt amiben összefoglaltam tapasztalataimat és készítettem a lehetséges megoldásokra mintapéldákat.
    A nyomógombokat sokféle módon lehet használni. Készítettem egy mintapéldát, segéd programot, ami nem csak prellmentesít, hanem különféle nyomógomb üzemmódokat valósít meg. Pl. egy megnyomás bekapcsol egy kimenetet, egy másik meg lekapcsolja. Vagy a nyomva tartás idejére bekapcsolva tartja a kimenetet, de időzíteni is lehet, ha elengedted a nyomógombot, akkor egy ideig még bekapcsolva marad a kimenete stb. Remélem másnak is hasznos.
  • A nyomógomb és az Arduino kivezetés közötti vezetékdarab hossza nem elhanyagolható. Próbapanelen 10-20 cm távolságnál még semmi baj nincs. Azonban pl. egy lakás méretében gondolkodva már komoly gondok lehetnek. Egy 10-20 méteres vezeték zajokat és zavarokat szed össze. Pl. beindul a hűtőgép, és a vezetékben akár 5-10V feszültség impulzus szalad át, mert a vezetékek egy szakaszon egymás mellett futnak a falban. Ez akár tönkre is teheti az Arduino-t, így ez ellen védekezni kell. Egyik lehetséges megoldás az optikai leválasztás. Ekkor a kapcsoló és az Arduino közé beteszünk egy led és fototranzisztorból épített leválasztó modult. A kapcsoló feszültséget ad a led-nek, az világítani kezd, mire a fototranzisztor a megvilágítás hatására lehúzza az áramkör kimenetét a 0V-ra (földre). Én egyszerűbb megoldást választottam a lakásunkban. Beforrasztottam a kapcsoló kontaktusai közé egy 10 mikroF kondenzátort. Ez a kondenzátor zavarszőrű hatást fejt ki. Folyamatosan 5V értékre töltődik a felhúzó ellenálláson keresztül, és a vezetékben keletkező zavarjelek energiája nem olyan nagy, hogy lényegi változás történjen a feszültségén. A nyomógomb rövidre zárja a kondenzátort, és a feszültség 0V-ra csökken. A kondenzátorban tárolt energia a kapcsolón keresztül távozik, így a kapcsolóban rövid ideig jelentős áram folyik. A falra szerelt 5-10A áramra tervezett fali kapcsolónak ez azonban meg sem kottyan. Ha kikapcsoljuk a kapcsolót, akkor a kondi a felhúzó ellenálláson keresztül újra feltöltődik az 5V feszültségre. Ezt én nem bíztam az ATmega328-ba beépített felhúzó ellenállásra, külső 1 Kohm felhúzó ellenállást alkalmaztam. A bemeneteket zener diódával is lehet védeni, erről most többet nem mesélnék, mert megy az idő!
  • A bemenetek HIGH illetve LOW érzékelése bemeneti feszültség függő. Ahhoz, hogy LOW értéket érzékeljen a mikrovezérlő, nem kell pontosan 0V-ot kapcsolni. Kb 0V és 0,5V között LOW szintet fog érzékelni, míg kb 2,5V felett HIGH értéket. Elvileg a chip adatlapjában 4,5V-tól garantálják a HIGH érzékelést, de a gyakorlatban ez már sokkal kisebb feszültségnél bekövetkezik. Pl. több érzékelőnek a kimenete 3,3V kimenő feszültséget állít elő. Ez közvetlenül rá lehet kötni egy bemenetre, és jól fog működni. A megadott feszültségszintek 5V tápfeszültség esetén értendők. Az ATmega328 chip működik 2,7V és 5V közötti bármilyen tápfeszültséggel. Pl. ha 3,3 V-ról működteted, akkor a kimenet LOW szintje 0V a HIGH viszont 3,3V. Ez ugyebár teljesen egyértelmű. A bemenet esetében már kevésbe egyértelmű a dolog. A LOW szint továbbra is 0 közeli érték a HIGH szint viszont maximum 3,3V vagy egy kicsit kisebb. Hogy pontosan mennyi, az minden bizonnyal kiderül az adatlapból, de nem voltam rá kíváncsi, mert az Arduino 5V-ról működik.
  • Mint az előbb említettem, az ATmega328 chip 2,7V és 5,5V tápfeszültség esetén működik. A kereskedelemben kapható kiegészítő modulok jelentős része mindössze 3,3V feszültséggel működtethető. Figyelni kell a különböző tápfeszültséggel működtetett eszközök összekapcsolásakor, mert ez problémát okozhat. Főleg az okoz gondot, ha egy eszköz bemenetére nagyobb feszültséget kapcsolunk, mint a tápfeszültsége. általában 0,5V-nál nagyobb túlfeszültség tönkreteszi az eszköz adott bemenetét!

Ha már le tudjuk kérdezni, hogy HIGH vagy LOW jelet kapcsoltunk egy kivezetésre, nézzük meg, hogyan csinálhatunk akár ugyanebből a kivezetésből kimenetet, ahol viszont az Arduino fogja megmondani, hogy milyen feszültség legyen. Kattints ide, ha ez is érdekel!

Amint elolvastad a kimenet beállításának tudnivalóit, érdemes lesz megtekintened egy működő példaprogramot a ki és bemenetek használatára.