Fórum témák

» Több friss téma
Cikkek » SRF-04 Ultrahangos távolságmérő szenzor használata Arduino-val és AVR-rel
SRF-04 Ultrahangos távolságmérő szenzor használata Arduino-val és AVR-rel
Szerző: Fizikus, idő: Dec 7, 2011, Olvasva: 27593, Oldal olvasási idő: kb. 4 perc
Lapozás: OK   3 / 7

Távolságmérés Arduino-val

Először nézzük a legegyszerűbb esetet, amikor az Arduino panelt használjuk. A fejlesztői környezet eltakarja előlünk a hardvert, ezért nem kell regiszter szinten ismerni az AVR mikrovezérlő és a beépített perifériák működését. Láthatjuk majd, hogy a távolságmérés és az adatok soros porton keresztül a PC-re történő küldése néhány utasítással megoldható.

Boarduino panel

A példában egy Arduino kompatibilis Boarduino panelt használtam, mivel a kapcsolásaim nagy részét dugdosós próbapanelon állítom össze. Ez a panel közvetlenül rádugható egy próbapanelra, nagymértékben meggyorsítva ezzel a fejlesztést.

Arduino fejlesztőkörnyezet

Az Arduino hardvert és fejlesztői környezetet nem ismertetem részletesen, mert a TavIR weboldalon egy nagyon jó összefoglaló található. (LINK)

Ha elindítjuk az Arduino fejlesztőkörnyezetet, az alábbi képernyő fogad:

Az eszközsorban az alábbi 7 gomb található:

Verify/Compile: mielőtt a programot az Arduino panelba töltenénk, le kell fordítanunk. Ezzel a gombbal fordítható és ellenőrizhető le, hogy a programunk hibamentes-e.

New: ezzel a gombbal egy új projektet hozhatunk létre

Open: ezzel a gombbal nyithatjuk meg a korábban létrehozott projekteket

Save: a jelenlegi projekt elmentése

Upload: a lefordított köd betöltése az Arduino panelba

Serial Monitor: az Arduino panel által küldött soros adatok megjelenítése egy terminálablakban

Az Arduino-val csak most ismerkedőknek egy kis segítség (az alábbi PDF dokumentumokban sok egyszerű, kezdőknek való példa található):

     

Távolságmérés Arduino-val

Arduino használata esetén elég egyszerű dolgunk van. A fejlesztői környezet eltakarja előlünk a hardvert, ezért nem kell részletesen ismerni a mikrovezérlő működését. Az AVR mikrovezérlő és a beépített perifériák használata legtöbbször néhány egyszerű paranccsal megoldható. Az ultrahangos szenzor használatához is csak azt kell tudnunk, hogy az I/O lábak állapotát hogyan tudjuk változtatni (a Trigger láb jelének a létrehozásához), és egy adott lábon lévő jel hosszát (láb állapotának időtartamát) hogyan tudjuk megmérni. Láthatjuk majd, hogy az Arduino esetén az egész példakód, a kommenteket leszámítva, a távolságméréssel és a soros kommunikációval együtt mindössze 18 sorból áll.

Arduino kód

  1. /*
  2. SFR04 Ultrahangos Szenzor Sketch
  3. Echo pin: PIN2-re kotve
  4. Trigger pin: PIN3-re kotve
  5. */
  6. #define EchoPin 2 // SRF04 Echo laba PIN2-re kotve
  7. #define TriggerPin 3 // SRF04 Trigger laba PIN3-ra kotve
  8. unsigned long EchoTime = 0; // az Echo labon megjeleno jel hosszat tartalmazo valtozo
  9. unsigned long Tavolsag = 0; // a mert tavolsagot tartalmazo valtozo
  10. void setup() {
  11.  pinMode(TriggerPin, OUTPUT); // Trigger lab kimenet
  12.  pinMode(EchoPin, INPUT); // Echo lab bemenet
  13.  Serial.begin(9600); // 9600 baud-sebessegu soros kommunikacios port beallitasa
  14. }
  15. void loop() {
  16.  digitalWrite(TriggerPin, HIGH); // a szenzornak 10 mikroszekundumos jel kuldese a Trigger labra
  17.  delayMicroseconds(10);
  18.  digitalWrite(TriggerPin, LOW);
  19.  EchoTime = pulseIn(EchoPin, HIGH); // az Echo labon a magas allapot idejenek merese
  20.  Tavolsag = 10*EchoTime/58; // a celtargy tavolsaganak kiszamitasa (mm-ben)
  21.  Serial.print(Tavolsag, DEC); // az eredmeny elkuldese a soros porton keresztul a PC-re
  22.  Serial.println(" mm"); // mm kiirasa az eredmeny utan
  23. }

A fenti kódot másoljuk be az Arduino programba, majd ellenőrzés és fordítás után töltsük le az Arduino panelba.

A sikeres programletöltés után, a Serial Monitort megnyitva, a megfelelő Com portot és 9600-as kommunikációs sebességet beállítva valami ilyesmit kell látnunk:

A kód legelején definiálom az EchoTime és Tavolsag változókat. A könnyebb használhatóság érdekében a 2-es és 3-as lábat elnevezem EchoPin-nek és TriggerPin-nek a #define paranccsal.


Az Arduino programnak tartalmaznia kell egy setup() és egy loop() függvényt, különben nem fog működni. A (void) arra utal, hogy a függvény nem ad vissza eredményül semmilyen adatot. Az üres zárójel pedig arra, hogy a függvény hívásakor mi sem adunk meg semmilyen adatot a függvénynek. A setup() függvény csak egyetlen egyszer fut le a program legelején mielőtt a programunk fő loop() ciklusa elindulna. Ezért a steup() részben adhatjuk meg a főbb beállításokat, általános utasításokat, eszköz inicializálásokat (pl. lábak adatirányának beállítása, soros kommunikáció sebességének beállítása stb…). A loop() függvény lényegében a fő program, ami folyamatosan fut és ismétlődik amíg az Arduino panel tápellátása be van kapcsolva.

A setup() részben a pinMode paranccsal a Trigger lábat kimenetnek, az Echo lábat pedig bemenetnek definiálom.

pinMode(láb, mód);   -  a lábak adatirányát állíthatjuk be ezzel az utasítással (INPUT: bemenet, OUTPUT: kimenet).

Ezután a Serial.begin(9600) utasítással egy 9600 baud-sebességű soros kommunikációs port-ot hozok létre.

A loop() részben a digitalWrite utasítással a Trigger lábat magas állapotra kapcsolom, majd 10 mikroszekundum után alacsonyra. Ezzel elő is állítottam a Trigger jelet.

digitalwrite(láb, érték);   -  ha egy lábat kimenetnek állítottunk be, akkor ezzel az utasítással az állapotát magasra (HIGH - +5V), vagy alacsonyra (LOW – 0V) állíthatjuk.

Az Echo lábon megjelenő visszhangimpulzus jel hossza a pulseIn() utasítással mérhető meg. Ez az utasítás egy I/O láb megadott állapotban (magas v. alacsony) eltöltött idejét méri meg mikroszekundumokban. A pulseIn() függvény teljesen lefoglalja a mikrovezérlőt, amíg a mérés be nem fejeződik, mert a mikrovezérlő folyamatosan figyeli (pollingolja) az Echo lábat és ezalatt más feladatot nem tud végezni.

A mért jelhossz értékből kiszámítom a céltárgy távolságát, majd a távolságértéket a Serial.print() utasítással a soros porton keresztül elküldöm a PC-nek.

A fenti megvalósítás elég egyszerű, a szenzor kipróbálására tökéletes, de mivel az USB kábel elég rövid, nem nagyon lehet vele az érzékelő méréstartományát tesztelni.

Azért hogy a kapcsolás mobil legyen, a kódot kicsit módosítva, a távolságértékeket a PC helyett a korábbi cikkemben már ismertetett soros LCD-re iratom ki (LINK).

  1. /*
  2. SFR04 Ultrahangos Szenzor Sketch
  3. Echo pin: PIN2-re kotve
  4. Trigger pin: PIN3-re kotve
  5. */
  6. #define EchoPin 2 // SRF04 Echo laba PIN2-re kotve
  7. #define TriggerPin 3 // SRF04 Trigger laba PIN3-ra kotve
  8. unsigned long EchoTime = 0; // az Echo labon megjeleno jel hosszat tartalmazo valtozo
  9. unsigned long Tavolsag = 0; // a mert tavolsagot tartalmazo valtozo
  10. void setup() {
  11.  pinMode(TriggerPin, OUTPUT); // Trigger lab kimenet
  12.  pinMode(EchoPin, INPUT); // Echo lab bemenet
  13.  Serial.begin(9600); // 9600 baud-sebessegu soros kommunikacios port beallitasa
  14. }
  15. void loop() {
  16.  digitalWrite(TriggerPin, HIGH); // a szenzornak 10 mikroszekundumos jel kuldese a Trigger labra
  17.  delayMicroseconds(10);
  18.  digitalWrite(TriggerPin, LOW);
  19.  EchoTime = pulseIn(EchoPin, HIGH); // az Echo labon a magas allapot idejenek merese
  20.  Tavolsag = 10*EchoTime/58; // a celtargy tavolsaganak kiszamitasa (mm-ben)
  21.  Serial.print("?f"); // ?f soros LCD parancs: LCD torlese
  22.  Serial.print(Tavolsag, DEC); // a celtargy tavolsaganak kiiratasa az LCD-re
  23.  Serial.print(" mm"); // mm kiirasa az eredmeny utan
  24.  Serial.print("?m"); // ?m soros LCD parancs: ugras a sor elejere
  25.  delay(20); // varakozas 20ms-ig
  26. }

Így már egy mérőszalag segítségével felvehető a szenzor impulzushossz - céltárgytávolság és mérttávolság - céltárgytávolság függvénye. A grafikonról látható, hogy a szenzor válasza eléggé lineáris, a hatótávolsága pedig kb. 4 méter.

Látható tehát hogy az Arduino-val egy mindössze 20-25 soros programmal már működésre bírható az SRF04-es érzékelő. De ennek az a hátránya, hogy a mérés időtartama alatt, a pollingolás miatt, a pulseIn() függvény teljesen lefoglalja a mikrovezérlőt, és az más feladatot nem tud végezni.

Most pedig nézzük meg hogy tudjuk ugyanezt a feladatot WinAVR-rel, AVR-GCC-ben megvalósítani! A következő két AVR-es példában az Echo lábon lévő jel hosszát kétféle módszerrel fogom megmérni. Először pollingolással a Timer1 Normál módjának használatával, másodszor pedig megszakításokkal az Input Capture mód használatával.
 


A cikk még nem ért véget, lapozz!
Következő: »»   3 / 7
Értékeléshez bejelentkezés szükséges!
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem