OK Mégsem
Fórum témák

» Több friss téma
Cikkek » Tényleg nincs királyi út? I. rész
Tényleg nincs királyi út? I. rész
Szerző: icserny, idő: Jún 22, 2013, Olvasva: 26939, Oldal olvasási idő: kb. 7 perc
Lapozás: OK   3 / 8

Az MSP430 Launchpad kártya sajátosságai

Az MSP-EX430G2 Launchpad kártya számunkra érdekes részének kapcsolási rajza az alábbi ábrán látható. Az ábrán már megjelöltük azokat az alkatrészeket, amelyek a Launchpad kártya újabb kiadásánál nincsenek gyárilag beépítve. Az UART átkötések HW és SW állásának szerepe pedig az, hogy az ábrán TxD és RxD felirattal jelölt lábak szerepét felcseréli.

launchpad_schematics_small.png

3_1. ábra: Az MSP430 Launcpad kártya kísérleti áramkörének kapcsolási rajza

(kattintson az ábrára a nagyításhoz!)

 Az Energia szoftverkönyvtáraiban a lábak szerepe a kártya IC foglalatába dugott mikrovezérlő típusától is függ. A támogatott típusok lábkiosztás diagramjai a https://github.com/energia/Energia/wiki/Hardware címen találhatók. Itt csak a legnépszerűbb típus, az MSP430G2553 lábkiosztását mutatjuk be.

launchpad_pin_diagram_small.jpg

3_2. ábra: Az MSP430G2553-mal szerelt Launchpad kártya lábkiosztása

(kattintson az ábrára a nagyításhoz!)

A digitális I/O funkciók (a digitalRead() és digitalWrite() függvények) a zöld és lila színnel jelölt lábak esetében használhatók. Ha az XIN/XOUT lábakra nincs beforrasztva kvarckristály, akkor a P1 és P2 portok minden bitje használható digitális I/O funkcióra. Az adatáramlás irányát és az üzemmódot a pinMode(pin,mode) függvényhívással állíthatjuk be. A lábat kijelölő pin paraméter többféleképpen is megadható. Hivatkozhatunk az IC láb sorszámára (fekete alapon írt sorszámok), használhatjuk a Px_y típusú jelölést (pl. P1_0), vagy az olyan absztrakt jelöléseket, mint RED_LED, PUSH2, stb.

Ha tehát a piros LED-et kimenetnek állítjuk és bekapcsolhatjuk, akkor írhatjuk így:

  1. pinMode(2, OUTPUT);
  2. digitalWrite(2,HIGH);

De annak sincs akadálya, hogy a szitanyomás feliratai szerint (P1.0) hivatkozzunk rá:

  1. pinMode(P1_0, OUTPUT);
  2. digitalWrite(P1_0,HIGH);

 A lábszámozást az Energia platform hardware/msp430/variants/launchpad/pins_energia.h fejléc állománya definiálja.

A fenti hivatkozások nagy hátránya a hardverfüggőség. Ha hordozható programot akarunk írni (például ugyanazt a LED villogtató programot a Stellaris Launchpad kártyán is futtatni szeretnénk, akkor célszerű további absztrakciót alkalmazni. A kártyán található piros és zöld LED-re, az S2 nyomógombra és a belső hőmérőre így hivatkozhatunk: RED_LED, GREEN_LED, PUSH2, TEMPSENSOR. Ezeket a szimbólumokat is a fenti állomány definiálja. Ha ezeket a jelöléseket használjuk, akkor nem kell izgatnunk magunkat azzal, hogy például a piros LED az MSP430 Launchpad kártya esetében a P1.0 kimenetre, a Stellaris Launchpad kártyán pedig az F.1 kimenetre van kötve.

Fentiek alapján tehát a piros LED-re így célszerű hivatkozni (ahogy az előző oldal végén ismertetett mintapéldában is használtuk):

  1. pinMode(RED_LED, OUTPUT);
  2. digitalWrite(RED_LED,HIGH);

Ha digitális bemenetről van szó, akkor a mode paraméter INPUT vagy INPUT_PULLUP lehet. Az új kiadású Launchpad kártya S2 nyomógombja esetében az utóbbit kell használni, ami egyúttal a belső felhúzást is bekapcsolja.

 

  1. pinMode(PUSH2, INPUT_PULLUP); // digitális bement beső felhúzással

 

Mintaprogram: DigitalReadSerial

Az Energia mintapéldáinak "1. Basics" csoportjában található a  DigitalReadSerial program is. Ez beolvassa az S2 nyomógomb állapotát (elengedett állapotban 1, lenyomott állapotban 0) és kiírja a soros kommunikációs vonalon keresztül. Az adatátviteli sebesség 9600 bit/s (kivéve az 1 MHz-en futó MSP430G2231-et, ahol 4800 bit/s adatsebességet kell beállítani).

Ne feledjük el, hogy az MSP430G2553 mikrovezérlő esetében a soros kommunikáció hardveres támogatással történik, tehát a TxD és RxD átkötéseket a rev 1.5 kiadású kártyán a 3_2. ábrán látható módon kell beállítani! Más kiadású kártya, illetve más mikrovezérlő típus esetén az átkötéseket  a https://github.com/energia/Energia/wiki/Hardware oldalon látható ábrák szerint kell beállítani.

3_1. lista: A DigitalReadSerial program listája

  1. void setup() {
  2.   Serial.begin(9600);                    // msp430g2231 esetén 4800 kell!
  3.   pinMode(PUSH2, INPUT_PULLUP);         // digitális bement belső felhúzással
  4. }
  5. void loop() {
  6.   int sensorValue = digitalRead(PUSH2); //Nyomógomb állapota
  7.   Serial.println(sensorValue);          //Kiírja a beolvasott értéket (1/0)
  8. }

A program elején a beállító részben (a setup() függvényben) először beállítjuk a soros kommunikáció sebességét 9600 b/s-ra, a felhasználói nyomógombhoz tartozó bemenetet pedig digitális bemenetként konfiguráljuk, belső felhúzással.

A végtelen ciklusban ismétlődő részben egy egész típusú változóba beolvassuk a nyomógomb állapotát (1, vagy 0 lehet), majd kiíratjuk a soros kommunikációs porton keresztül.

A program a Letöltés gombra kattintva lefordul, letöltődik és elindul. A PC oldalon egy soros porti kommunikációra alkalmas terminál emulációs programot kell beállítanunk. Legegyszerűbb ehhez az Energia IDE beépített Serial Monitor programját használni. Indítása előtt (ha korábban nem állítottuk volna még be) válasszuk ki a Launchpad kártyához tartozó virtuális soros portot az Energia Tools/Serial Port menüjében, az előző oldalon található útmutatás szerint! Ezután kattintsunk az Energia IDE ablakának jobb felső sarkában található gombra, indítsuk el vele a Serial Monitort!

start_serial_monitor.png

3_3. ábra: A Serial Monitor program indítása

A Serial Monitor első indításakor szükség lehet az adatsebesség beállítására. Ezt a Serial Monitor ablakának jobb alsó sarkában található legördülő listájában állíthatjuk be. Ha esetleg más programot akarunk használni a PC oldalon (Hyperterminal, PuTTY.exe, stb.), akkor 9600 b/s adatsebességet, és 8, N, 1 formátumot állítsunk be, s nincs sem hardveres, sem szoftveres adatfolyam-vezérlés.

digital_read_serial.png

3_4. ábra: A DigitalReadSerial program futtatása
(A nullákat csak a szemléletesség kedvéért utólag színeztük ki!)

 

Mintaprogram: AnalogReadSerial

Az Energia mintapéldáinak "1. Basics" csoportjában található az  AnalogReadSerial program is. Ennek segítségével a valamelyik analóg bemenetre kapcsolt jel (legegyszerűbben a tápfeszültségből egy 10 kΩ-os potméterrel leosztott jel)  nagyságát mérhetjük meg a beépített 10-bites felbontású analóg-digitális átalakító (ADC) segítségével. A konverzióból kapott nyers adatot (0-1023 közötti szám) kiíratjuk a PC képernyőjére. A soros port beállítása ugyanúgy történik, mint az előző példában.

Hardver követelmények

  • Launchpad kártya (MSP430G2553, MSP430G2452 vagy MSP430G2231 mikrovezérlővel)
  • egy 10 kΩ-os potenciométer

A kapcsolási rajz és a huzalozás vázlata az alábbi ábrákon látható. Az R1 potenciométer két vége a tápfeszültségre és a földre (a közös pontra) csatlakozik. Ha a potmétert tekergetjük, akkor a csúszka más-más feszültségosztási arányt állít be (a feszültségosztó alsó és  felső tagjának aránya változik, tehát az A4 analóg bemenetre vezetett  jel nagysága változtatható.

analogreadserial_schem.png

3_5. ábra: Az AnalogReadSerial programhoz használt kapcsolás vázlata

(az ábra a Fritzing programmal készült)


analogreadserial_circuit.png

3_6. ábra: Az AnalogReadSerial programhoz használt kapcsolás huzalozási rajza

(az ábra a Fritzing programmal készült)


A programot betöltés után (a File/Examples/1. Basics/AnalogReadSerial menüpontra kattintva tölthetjük be) célszerű módosítani, hogy ne az A0 analóg csatornát használjuk, mert az a láb foglalt, arra van kötve a piros LED! Az analogRead() függvény A0 paraméterét kell lecserélni, a fenti kapcsoláshoz A4-et kell írni helyette.

Megjegyzés: ha nincs kéznél potméter, akkor a beépített hőmérő jelét is megmérhetjük. Ehhez az analogRead() függvény A0 paraméterét TEMPSENSOR-ra kell lecserélni.

A program működése

Az alábbi programban az előkészítő részben (a setup() függvényben) csak a soros port adatsebességét kell beállítanunk:

  1. Serial.begin(9600);

A végtelen ciklusban (a loop() függvényben) deklarálnunk kell egy változót, amelybe az analogRead() függvényhívással kapott eredményt tárolhatjuk. Az MSP430G2xxx mikrovezérlők ADC-je 10 bites, tehát a konverzió eredménye 0 - 1023 közötti szám lehet. Az eredményt az alábbi paranccsal íratjuk ki:

  1. Serial.println(sensorValue, DEC);

A soros port println metódusának első paramétere a kiírandó érték, a második paraméter pedig a számábrázolás alapját adja meg (DEC - decimális, HEX -hexadecimális, BIN - bináris). A  println metódus a szám kiírása után egy sorvége jelet is küld (Windows esetében CR-LF). Jegyezzük meg, hogy ha helyette a print metódust használnánk, akkor egymás után írná a számokat, nem kezdene új sort!

3_2. lista: Az AnalogReadSerial program listája

  1. /*
  2.   AnalogReadSerial
  3.   Beolvas egy analóg jelet az A4 bemeneten és kiírja az eredményt
  4.   a soros porton keresztül
  5.   Ez a példaporgram szabadon felhasználható
  6.  */
  7. void setup() {
  8.   Serial.begin(9600); // msp430g2231 must use 4800
  9. }
  10. void loop() {
  11.   int sensorValue = analogRead(A4);
  12.   Serial.println(sensorValue);
  13. }

Ha letöltjük a programot és megnyitjuk  a Serial Monitor ablakot, akkor az alábbi ábrához hasonló listát kapunk. Ha most eltekerjük a potmétert (vagy a belső hőmérő választása esetén melegítjük a mikrovezérlőt) a számok azonnal megváltoznak. Természetesen ezek a számok közvetlen felhasználásra túl kényelmetlenek. Ha túl gyorsnak találjuk a kiíratások tempóját, akkor beiktathatunk egy késleltetést a loop() ciklusba. Például így:

  1. void loop() {
  2.   int sensorValue = analogRead(A4);
  3.   Serial.println(sensorValue);
  4.   delay(1000);
  5. }

 

A következő példában majd megmutatjuk, hogy hogyan lehet ezeket a számokat értelmes mennyiséggé alakítani.

 analogreadserial.png

 3_7. ábra: Az AnalogReadSerial program listája és futási eredménye

Mintaprogram: ReadAnalogVoltage

A ReadAnalogVoltage program nem található meg az Energia mintapéldái között, ezt az Arduino IDE mintapéldái közül vettük át. Ennek segítségével az A4 analóg bemenetre (P1_4 láb) kapcsolt jel nagyságát mérhetjük meg a beépített 10-bites felbontású analóg-digitális átalakító (ADC) segítségével. A konverzióból kapott nyers adatot voltokra átszámítva, 3 tizedesjegyre íratjuk ki a PC képernyőjére.

Hardver követelmények

  • Launchpad kártya (MSP430G2553, MSP430G2452 vagy MSP430G2231 mikrovezérlővel)
  • egy 10 kΩ-os potenciométer

A kapcsolási rajz és a huzalozás vázlata megegyezik az előző példánál bemutatottakkal (3_5. és 3_6. ábra).

Az alábbiakban röviden összefoglaljuk az analóg-digitális konverzió használatához szükséges képleteket, összefüggéseket. 

A konverzió digitális értéke (NADC):

  • Végkitérés: NADC= 1023, ha a bemenő jel ≥ VR+ -0.5*LSB
  • Nulla: NADC = 0000h, ha a bemenő jel ≤ VR- + 0.5 LSB
  • Közbeeső értékekre: NADC= 1023 * (VIN - VR-)/(VR+ - VR-)

Ahol:

NADC a konverzió eredménye (esetünkben 0 és 1023 közötti szám)

VR+ a pozitív referencia (esetünkben mot 3,5 V)

VR- a negatív referencia (esetünkben 0 V lesz)

VIN a bemenő feszültség, amit meg akarunk mérni

A mért feszültség meghatározása

Bennünket többnyire nem az érdekel hogy egy adott feszültség esetén milyen számot ad ki az ADC, hanem megfordítva: a konverzió NADC eredményéből a VIN bemenő feszültséget kell meghatározni volt, vagy millivolt egységekben. Az NADC= 1023 * (VIN - VR-)/(VR+ - VR-) képletből kifejezve, ezt kapjuk:

VIN = (VR+ - VR-) * NADC/1023 + VR-

 VR- = 0 V és VR+ = 3,5 V esetén a képlet erre egyszerűsödik:

VIN =  NADC * 3,50 V/1023

A ReadAnalogVoltage programban is ezt a képletet használjuk, néhány dologra azonban ügyelnünk kell:

  • A feszültség értéke és az osztás eredménye nem egész szám, tehát az eredményt float (lebegőpontos) típusú változóban kell tárolnunk.
  • A tizedesvessző helyett a programban tizedespontot kell használni.

3_3. lista: A ReadAnalogVoltage program listája

  1. void setup() {
  2.   Serial.begin(9600);               // msp430g2231 esetén 4800 kell!
  3. }
  4. void loop() {
  5.   int sensorValue = analogRead(A4); //Mérés az A4 bemeneten
  6.   float voltage = sensorValue * (3.5 / 1023.0);
  7.   Serial.print(voltage,3);          //Kiíratjuk az eredményt
  8.   Serial.println(" V");             //Kiíratjuk a mértékegységet is
  9.   delay(1000);
  10. }


Az alábbi ábrákon a programablak és a programfutás eredménye látható. A program futása közben a potmétert egyik szélső helyzetből lassan a másik végpontba tekertük.

readanalogvoltage_listing.png

3_8. ábra: A ReadAnalogVoltage program letöltése

readanalogvoltage.png

3_9. ábra: A ReadAnalogVoltage program futási eredménye

 


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

Belépés
Hirdetés
XDT.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