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

» Több friss téma
Cikkek » Launchpad: ismerkedés az MSP430 mikrovezérlőkkel IV.
Launchpad: ismerkedés az MSP430 mikrovezérlőkkel IV.
Szerző: icserny, idő: Jan 14, 2013, Olvasva: 16043, Oldal olvasási idő: kb. 5 perc
Lapozás: OK   1 / 8
Ebben a részben a Launchpad kártyát megtanítjuk kommunikálni a számítógéppel (most az egyszerűség kedvéért csak az adatküldést fogjuk használni). Eztán az MSP430 mikrovezérlők analóg digitális átalakítjának használatával ismerkedünk meg, s ennek során intenzíven használjuk az adatküldés funkciót is, az eredmények kiíratására.

Kommunikáljunk a számítógéppel!

Mielőtt folytatnánk az ismerkedést az MSP430 mikrovezérlőkkel, készítünk egy egyszerű szoftveres segédeszközt, hogy kommunikálni tudjunk a számítógéppel! Az MSP430  Launchpad kártya emulátora (FET) kétirányú univerzális aszinkron soros adatküldés és fogadás kapcsolatot  (Universal Asynchronous Receiver/Transmitter, UART) biztosít a kommunikációhoz, amiből most az egyszerűség kedvéért csak az adatküldés lehetősőget fogjuk használni. Mivel az UART kommunikációt a Launchpad kártyához kapott mikrovezérlők közül csak az MSP430G2553 támogatja hardveresen, ezért az univerzális alkalmazhatóság érdekében szoftveresen kezelt UART adatküldést valósítunk meg.

A szoftveresen megvalósított UART adatküldés úgy történik, hogy fogjuk az adatbájtot és azt bitenként, sorban kiküldjük egy adatvonalon, esetünkben történetesen a P1.1 portlábon. Ne törődjünk most azzal, hogy a Launchpad kártyán egy USB-UART protokol konverter USB üzenetcsomagok formájában küldi át a karaktereket a számítógépnek, s azzal sem foglalkozunk, hogy a számítógép operációs rendszere hogyan alakítja ezeket vissza, s mutatja az alkalmazásoknak egy virtuális soros portra érkező karakterekként. A mi dolgunk csak annyi, hogy a számítógépre kiküldendő karaktereket a keretező jelekkel együtt megfelelő ütemben kiléptessük a P1.1 kimeneten.

Karakter keretezés

Az UART kommunikáció során az adatbájtok (vagy karakterek) keretbe foglalva kerülnek kiküldésre. Erre egyrészt azért van szükség, hogy a végtelen bitfolyamban meg lehessen találni az egyes adategységeket, másrészt minden újabb adatbájt kezdete lehetőséget ad az újraszinkronizálásra.     

A keretezés azt jelenti, hogy minden adatbájt előtt van egy start bit, az adatbájt után pedig egy (vagy két) stop bit. A start és stop bit között adatküldési formátumtól függően lehet 5, 7, 8 vagy 9 adatbit és opcionálisan egy paritásbit. Mi a legelterjedtebb 8, N, 1 formátumot fogjuk használni, azaz 8 adatbitet küldünk, nem használunk paritásbitet, s a stop bitek száma 1 lesz. Egy tipikus jelalak (a TXD kimenet jelszintjének időbeli lefutása) az alábbi ábrán látható. Az ábrán látható jelsorozat a bináris 0b01001101 adatbájt (ne feledjük: visszafelé kell olvasni!), ami a hexadecimális 0x4D-nek, vagy a decimális 77-nek felel meg, s az ASCII kódtábla szerint az „M” karakter kódját jelenti.

uart_jelalak.png 

1_1. ábra: Egy tipikus UART jelalak

Tétlen állapotban, amikor nincs adatküldés, az adás vonalat (TXD) magas szinten kell tartani. Minden elküldött karakter egy start jellel kezdődik, azaz a TXD vonal egy bitidő tartamára alacsony szintre vált. Ezt követően kerülnek kiküldésre egymás után az adatbitek, a legkisebb helyiértékű bittel kezdve. A legmagasabb helyiértékű bit után egy stop bit következik, amikor egy bitidő tartamára a kimenet magas szintre vált.

Ha a vevő azt tapasztalja, hogy a stop bit helyén (ami esetünkben a 10 bitet jelenti, ami a start bit lefutó élét 9 bitidőnyi késéssel követi) alacsony szintet észlel, akkor „keretezési hibát” jelez és eldobja a feltehetően hibásan vett adatot.

Adatsebesség, bitidő

Egy bit időtartama az adatküldés sebességétől függ. A szabványos adatsebességek (300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200 bit/s) közül mi a 9600 bit/s-ot használjuk, a Launchpad kártya USB-UART protokol konvertere ugyanis ezt a sebességet támogatja. A 9600 bit/s azt jelenti, hogy egy bitre 1 s/9600  = 0,00010416667 s, azaz 104,1667 µs idő jut.

Az alábbi példaprogramban teljes mértékben szoftveresen valósítjuk meg az UART adatküldést (bit banging), az időzítéseket is szoftveres késleltetésekkel oldjuk meg. A késleltetés idejét úgy kell megválasztani, hogy a soron következő bit kiforgatásához és valamelyik általános célú I/O lábra történő kiadásához szükséges utasítások idejét is figyelembe vegyük. A gyárilag kalibrált 1 MHz-es DCO órajelet használjuk, így egy utasításciklus 1 µs lesz.  Az alábbi programban az IAR Embedded Workbench szimulátorában futtattam a programot, s a szimuláció során a regiszterek ablakát megnyitva ellenőrizni tudtam, hogy ha 89 utasításciklusnyi késleltetést használok, akkor két bit kiküldése között közelítőleg 104 µs idő telik el. Abszolút pontosságot nem lehet elérni, mert a bit értékétől függően az if... else ... utasítás más-más ágon fut.

Hardver követelmények:

  • Launchpad kártya (az új típusú kártyánál ügyeljünk rá, hogy a TXD/RXD átkötéseket SW állásba kell helyezni!)
  • A mintaprojekt MSP430G2231 mikrovezérlőhöz van beállítva, de a mikrovezérlő típusa tetszés szerint átállítható a projekt opcióknál

 

1_1. lista: A 4_uart_soft program listája

  1. #include "io430.h"
  2. #include "stdint.h"
  3.  
  4. #define TXD       BIT1            // TXD a P1.1 lábon
  5.  
  6.  
  7. /**----------------------------------------------
  8.  *   Késleltető eljárás (1 - 65535 ms)
  9.  *-----------------------------------------------
  10.  * delay - a késleltetés ms egységben megadva
  11.  */
  12. void delay_ms(uint16_t delay) {
  13.   uint16_t i;
  14.   for(i=0; i < delay; i++) {
  15.     __delay_cycles(1000);         //1 ms késleltetés
  16.   }
  17. }
  18.  
  19. /**----------------------------------------------
  20.  *   Egy karakter kiküldése a soros portra
  21.  *   SW_UART: 9600 bit/s, 8, N, 1 formátum
  22.  *   DCO = 1 MHz (Bitidő = 104,17 usec)
  23.  *-----------------------------------------------
  24.  * c - a kiküldeni kívánt karakter kódja
  25.  */
  26. void sw_uart_putc(char c) {
  27.   uint8_t i;
  28.   uint16_t TXData;
  29.   TXData = (uint16_t)c | 0x100;   //Stop bit (mark)
  30.   TXData = TXData << 1;           //Start bit (space)
  31.   for(i=0; i < 10; i++) {
  32.     if(TXData & 0x0001) {         //Soron következő bit vizsgálata
  33.       P1OUT |= TXD;               //Ha '1'
  34.     } else {
  35.       P1OUT &= ~TXD;              //Ha '0'
  36.     }
  37.     TXData = TXData >> 1;         //Adatregiszter léptetés jobbra
  38.     __delay_cycles(89);           //Itt kell hangolni!
  39.   }
  40.   P1OUT |= TXD;                   //Az alaphelyzet: mark
  41. }
  42.  
  43. /**----------------------------------------------
  44.  *  Karakterfüzér kiírása a soros portra
  45.  *-----------------------------------------------
  46.  * p_str - karakterfüzér mutató (nullával lezárt stringre mutat)
  47.  */
  48. void sw_uart_puts(char* p_str) {
  49.   char c;
  50.   while ((c=*p_str)) {            //Amíg a lezáró nullát el nem érjük
  51.       sw_uart_putc(c);            //egy karakter kiírás
  52.       p_str++;                    //mutató léptetése
  53.   }
  54. }
  55.  
  56. void main(void) {
  57.   WDTCTL = WDTPW + WDTHOLD;       //Letiltjuk a watchdog időzítőt
  58.   DCOCTL = CALDCO_1MHZ;           // DCO beállítása a gyárilag kalibrált
  59.   BCSCTL1 = CALBC1_1MHZ;          // 1 MHz-es frekvenciára
  60. //--- A TXD kimenet beállítása ----------------------------------
  61.   P1DIR |= TXD;                   //TXD legyen digitális kimenet
  62.   P1OUT |= TXD;                   //TXD alaphelyzete: mark
  63. //---  P1.3 bemenet legyen, belső felhúzását engedélyezzük ------
  64.   P1DIR &= ~BIT3;                 //P1.3 legyen digitális bemenet
  65.   P1OUT |= BIT3;                  //Felfelé húzzuk, nem lefelé
  66.   P1REN |= BIT3;                  //Belső felhúzás engedélyezése  
  67.   while(1) {
  68.     delay_ms(1000);               //1 másodperc várakozás
  69.     sw_uart_puts("Hello world!\r\n");  //Egy sor kiírása
  70.   }
  71. }

A delay_ms() eljárást csak a főprogramban használjuk, az UART kommunikációhoz nem kell.

Az  sw_uart_putc() eljárás végzi egy karakter kiküldését a program elején definiált portlábon (a Launchpad kártyánál szoftveres UART módban P1.1 a TXD láb). A küldés megkezdése előtt a kiküldendő 8 adatbitet „keretezzük”. Kiegészítjük egy stop és egy start bittel. Így összesen 10 kiküldendő bit lesz, a for ciklus ezért megy 10-ig. Kiküldéskor megnézzük a soron következő bit értékét, s ennek megfelelően a TXD kimenentet alacsony vagy magas szintre állítjuk. Arra ügyeljünk, hogy P1OUT aktualizálásánál kizárólag csak a TXD kimenethez tartozó bitet módosítsuk, nehogy mellékhatásként valamit ki- vagy bekapcsoljunk! A mintapéldában pl. beállítjuk a belső felhúzást az S2 nyomógombhoz tartozó P1.3 bemeneten. Ha véletlenül töröljük P1OUT 3. bitjét, akkor ez a felhúzás lehúzásba vált!

Az sw_uart_puts() eljárás egy nullával lezárt karakterfüzért (stringet) írat ki úgy, hogy karakterenként meghívja az Az  sw_uart_putc() eljárást. Ugyanilyen eljárást használtunk már az LCD alfanumerikus modulok kezelésénél.

A főprogramban letiltjuk az őrkutyát, beállítjuk a gyárilag kalibrált 1 MHz-es órajelet, konfiguráljuk a TXD kimenetet, s bekapcsoljuk az S2 nyomógomhoz tartozó P1.3 bemeneten a belső felhúzást. A program így mind a régi, mind az újabb Launchpad kártyával kompatibilis lesz (nem lebeg a P1.3 bemenet).

A program futtatása

A program használatához szükség lesz valamilyen terminál emulációs szoftverre. Windows XP alatt a Hyperterminál, Windows 7 alatt a szabadon letölthető PutTTY.exe, vagy hasonló program használható.

A PC oldalon a Launchpad kártyához tartozó virtuális soros portot (hogy melyik az, azt az Eszközkezelőben nézhetjük meg a COM és LPT Portok között) az alábbi paraméterekkel nyissuk meg: 9600 bit/s, 8 adatbit, nincs paritás, 1 stop bit. (PC oldalon 1 stop bitet állítsunk majd be a későbbi mintaprogramoknál is, ahol két stop bitet küldünk!).

Először mindig a Launchpad kártyát csatlakoztassuk, s csak utána nyissuk meg a virtuális soros portot az alkalmazásból! Leálláskor fordított sorrenben kell eljárni: először az alkalmazásban zárjuk le a kapcsolatot, csak utána húzzuk ki a Launchpad kártyát a gépből! Így is előfordulhat, különösen Windows 7 esetén, hogy csak sokszori csatlakoztatás és kapcsolatbontás után sikerül működésbe hozni a soros kommunikációt. 

A program futtatásának eredménye az alábbi ábrán látható.

4_uart_soft.png 

1_2. ábra: A 4_uart_soft program futási eredménye


A cikk még nem ért véget, lapozz!
Következő: »»   1 / 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