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: 26644, Oldal olvasási idő: kb. 5 perc
Lapozás: OK   7 / 8

Az MSP430FR5937 (Fraunchpad) kártya bemutatása

A Texas Instruments MSP-EXP430FR5739 ("Fraunchpad") fejlesztői kártyája 2011 nyarán debütált, de méltatlanul háttérbe szorult, pedig egyes vonatkozásokban kiemelkedő tulajdonságokkal rendelkezik. A kártya az MSP430FR5739 mikrovezérlőre épül, amely FRAM (ferroelektromos RAM) programtároló memóriával rendelkezik, amely kis fogyasztású, gyors működésű, nem felejtő memória. A flash memóriához képest kis fogyasztás, gyors írás és rendkívül magas (1013-szoros) újraírhatósági szám jellemzi.

Az alábbi ábrán bejelöltem a kártya főbb részegységeit.

board_hu500.jpg

7_1. ábra: A Texas Instruments MSP-EXP430FR5739 fejlesztői kártyája

Az MSP-EXP430FR5739 fejlesztői kártya főbb jellemzői:

  • MSP430FR5739 16-bites mikrovezérlő, 16 kB FRAM és 1 kB RAM memóriával, max. 24 MHz CPU frekvencia, 2x Timer_A blokk, 3x Timer_B blokk, 1x USCI (UART/SPI/IrDA/I2C ) blokk, 16 csatornás 10 bites ADC, 16 csatornás analóg komparátor, 32 I/O.
  • Programozó és hibavadász áramkör (ugyanz, mint a Launchpad kártyánál)
  • 8 db LED
  • 3 db nyomógomb (RESET és 2x felhasználói nyomógomb)
  • ADXL335B háromtengelyű gyorsulásmérő
  • NTC ellenállás (hőmérő)
  •  Csatlakozás CCxxxx RF kártyához, EXP-MSP430F5438 kártyához

 Az egyes portkivezetések foglaltságát és elérhetőségét (hol van kivezetve) az alábbi táblázatban foglaltam össze:

port_usage.png

7_2. ábra: Az MSP430FR5739 mikrovezérlő portlábainak foglaltsága és elérhetősége a  Fraunchpad kártyán

Amint látjuk, a nagyszámú I/O kivezetéseknek köszönhetően egyes portlábak csak a TPnn tesztpontokon, vagy az RF3 csatlakozón érhatők el, mert nem fértek el a 2x12 pólusú tüskesoron. It jegyezzük meg, hogy a kártya két oldalán elhelyezkedő kivezetések nemcsak a pólusszámban térnek el a Launchpad kártyától, hanem a két tüskesor távolsága és a portlábak kivezetési sorrendje is más. Ezért a Launchpad kártyához fejlesztett feltét (shield) kártyák nem kompatibilisek a Fraunchpad kártyával.

Az Energia szoftverkönyvtáraiban a lábak szerepét a szokásos diagram segítségével mutatjuk be, melyet a https://github.com/energia/Energia/wiki/Hardware címről vettünk át (Rei Vilo alkotása).

fp-pinout_small.png

7_3. ábra: Az MSP-EXP430FR5739 ("Fraunchpad") kártya lábkiosztása
(kattintson az ábrára a nagyításhoz!)

 Ezen a kártyán 8 db kék színű felhasználói LED áll rendelkezésre, ezek azonban két portra (Port 3 és Port J) vannak szétosztva. A RED_LED és a GREEN_LED elnevezéseknek ugyan itt nincs semmi értelme, de a programok kompatibilitásának megőrzése végett ezek az elnevezések is hozzá vannak rendelve egy-egy LED-hez: LED1-hez van rendelve a RED_LED és LED4-hez a GREEN_LED név.  

A két felhasználói nyomógombra PUSH1 és PUSH2 néven hivatkozhatunk (emellett természetesen a 23. és 29. lábszámmal, valamint P4_0 és P4_1 névvel is hivatkozhatunk rájuk).

A gyorsulásmérő X, Y és Z kimeneteire ACC_X, ACC_Y és ACC_Z néven hivatkozhatunk, ezek egyébként rendre az A6, A5 és A4 analóg bemenetekre vannak kötve. A gyorsulásmérő azonban csak akkor kap tápfeszültséget, ha az ACC_ENABLE (P2_7) digitális kimenetet magas szintre állítjuk:

  1. digitalWrite(ACC_ENABLE, HIGH);

Ugyanez a kimenet ad tápfeszültséget az NTC (negatív hőfoktényezőjű) ellenállás osztójának, és a gyárilag nem beépített LDR (fényre érzékeny) ellenállás osztójának is. Emiatt a fenti P2_7 kivezetésre NTC_ENABLE néven is hivatkozhatunk. Az NTC ellenállás osztójának feszültségét a 21. kivezetésen (amelyre P1_4, A1, vagy NTC néven is hivatkozhatunk) mérhetjük meg az ADC segítségével.

A hardver további részleteit az MSP-EXP430FR5739 Experimenter Board User's Guide dokumentumból, illetve az Energia telepítési könyvtárának hardware\msp430\variants\fraunchpad\ almappájában található pins_energia.h fejléc állományból olvashatjuk ki.

LED fényeffektus

Az előző oldalakon leírtak alapján a mintapéldák között található egyszerű LED villogtató program már aligha okoz gondot a kedves olvasónak, ezért mindjárt egy bonyolultabb esettel kezdünk: készítsünk fényeffektust, kihasználva, hogy ilyen sok LED van a kártyán!

Villogtassuk a LED-eket úgy, hogy először a két szélső LED-et villanjuk fel, majd a mellettük levőt, s így haladunk befelé 4 lépsben. Utána középről kifelé haladva villantjuk fel sorban a LED-eket, majd ha kiértünk a szélére, kezdjük előlről. A program ötlete, valamint az alábbi program StartUpSequence() függvényének kódja az MSP-EXP430FR5739 kártya gyári demójából való. 

Hardver követelmények:

  • MSP-EXP430FR5739 ("Fraunchpad") kártya 

A program kódja az alábbi listán látható. Kényelmi okokból itt nem az Arduino mintájú digitalWrite() függvényeket használjuk a LED-ek kezelésre, hanem közvetlenül a port regisztereket írjuk, C utasításokkal. 

7_1. lista: A LED_effect program listája

  1. /*
  2.  * LED_effect
  3.  * Fényeffektus a Fraunchpad kártya gyári demójából átvéve,
  4.  * melyben a P3 és PJ portokon található 4-4 LED-et villogtatjuk.
  5.  */
  6.  
  7. #include "Energia.h"
  8.  
  9. void StartUpSequence(void)
  10. {
  11.   unsigned char flag=4,up=1,counter = 0;
  12.   unsigned char LED_ArrayPJ[] = { 0x01,0x02,0x04,0x08 };
  13.   unsigned char LED_ArrayP3[] = { 0x80,0x40,0x20,0x10 };
  14.   while (counter <10)
  15.   {  
  16.     counter++;
  17.     PJOUT &= ~(BIT0 +BIT1+BIT2+BIT3);
  18.     P3OUT &= ~(BIT4 +BIT5+BIT6+BIT7);  
  19.     if(up)               // from the outside - in
  20.     {
  21.       while(flag)
  22.       {
  23.         P3OUT = LED_ArrayP3[flag-1];
  24.         PJOUT = LED_ArrayPJ[flag-1];
  25.         delay(31);              
  26.         flag--;
  27.       }
  28.       up=0;
  29.     }
  30.     else
  31.     {      // from the inside - out
  32.       while(flag<4)
  33.       {
  34.         P3OUT = LED_ArrayP3[flag];
  35.         PJOUT = LED_ArrayPJ[flag];
  36.         delay(31);      
  37.         flag++;
  38.       }
  39.       up = 1;
  40.     }
  41.   }
  42.   // Exit Loop, Clear LEDs
  43.   PJOUT &= ~(BIT0 +BIT1+BIT2+BIT3);
  44.   P3OUT &= ~(BIT4 +BIT5+BIT6+BIT7);  
  45. }
  46.  
  47. void  setup() {
  48.   PJDIR |= 0x0F;      // PJ alsó félbájt kimenet legyen
  49.   P3DIR |= 0xF0;      // P3 felső félbájt kimenet legyen  
  50. }
  51.  
  52. void loop() {
  53.   StartUpSequence();  // Fényefekktus meghívása
  54.   delay(1000);        // Egymásodperces szünet
  55. }

 

Hőmérséklet mérése az NTC ellenállás segítségével

A kártyán található negatív hőfoktényezőjű ellenállás segítségével hőmérsékletet tudunk mérni. A mérés elve az, hogy a P2_7 láb magas szintre állításával rákapcsoljuk a tápfeszültséget az R35 sorszámú 470 kΩ-os ellenállásból és a 25 °C-on 100 kΩ-os NTC ellenállásból álló osztóra, s megmérjük a leosztott feszültséget, ami a P1_4 (más néven: A1, vagy NTC) bementre van kötve.  Az NTC ellenállás értéke szobahőmérséklet körül fokonként kb. 4,5 %-kal változik meg. A változás pontos értékei a B57560G1104 adatlap táblázatából olvashatók ki (a -25 - +75 °C közötti tartományra vonatkozó értékeket a program is táblázatos formában tárolja, 105-tel felszorozva. 

Az NTC ellenállással történő hőmérséklet méréshez Rei Vilo mintaprogramját használjuk fel, amely a Fraunchpad_NTC könyvtári modulból és az NTC_thermometer.ino főprogramból áll. A könyvtári modulhoz tartozó állományokat szokás szerint a felhasználói könyvtárunkban, az  Energia/libraries/Fraunchpad_NTC mappában kell elhelyezni.

7_2. lista: Az NTC_thermometer program listája

  1. /*
  2.  * FraunchPad NTC hőmérő
  3.  * Egyszerű mintaprogram a beépített NTC hőmérő használatához
  4.  * szerző: Rei Vilo, embedxcode.weebly.com
  5.  */
  6. #include "Energia.h"
  7. #include "FraunchPad_NTC.h" // Az NTC könyvtár becsatolása
  8.  
  9. int32_t temperature;
  10. NTC_FR myNTC;
  11.  
  12. //Decimális kiíratás egy tizedesre
  13. void printX10(int32_t i) {
  14.   if (i
  15.     Serial.print("-");
  16.     i = -i;
  17.   }
  18.   Serial.print(i/10, DEC);
  19.   Serial.print(".");
  20.   Serial.print(i%10, DEC);
  21. }
  22.  
  23.  
  24. void setup() {
  25.   pinMode(PUSH1, INPUT_PULLUP);  // Nyomógomb bemenet felhúzása
  26.   pinMode(PUSH2, INPUT_PULLUP);  // Nyomógomb bemenet felhúzása
  27.   myNTC.begin();                 // Az NTC osztójának bekapcsolása
  28.   Serial.begin(9600);
  29.   Serial.println(myNTC.WhoAmI());
  30.   Serial.println("press PUSH2 to exit serial");
  31.   delay(500);
  32. }
  33.  
  34. void loop() {
  35.   myNTC.get();
  36.   Serial.print("Temperature = ");
  37.   myNTC.celsiusX10(temperature);
  38.   printX10(temperature);
  39.   Serial.print(" oC\t");
  40.  
  41.   myNTC.fahrenheitX10(temperature);
  42.   printX10(temperature);
  43.   Serial.println(" oF");
  44.   delay(1000);
  45.  
  46.   if (digitalRead(PUSH2)==LOW) {
  47.     Serial.print("exit... ");
  48.     Serial.end();
  49.     Serial.println("end");
  50.     while(true); // endless loop
  51.   }
  52. }

 

A gyorsulásmérő kiolvasása

A következő példában (AccelReadSerial.ino) az ADXL335B háromtengelyű gyorsulásmérő egyszerű használatát mutatjuk be: kiolvassuk a nehézségi gyorsulás három komponensét (ax, ay, az). Ha a kártya nyugalomban van, akkor ez a helyi nehézségi gyorsulásnak felel meg, de ha rángatjuk, rázzuk, vagy dobáljuk a kártyát, akkor végeredményben a kártyára ható erők által keltett gyorsulások eredőjét mérjük.

A gyorsulásmérő használatához az ACC_ENABLE (P2_7) kimenetet magas szintre kell húzni. A gyorsulásmérő analóg kimenetei rendre az ACC_x, ACC_Y, ACC_Z névvel választhatók ki (ezek egyébként az A6, A5, A4 analóg bemeneteket jelentik).

Hardver követelmények:

  • MSP-EXP430FR5739 ("Fraunchpad") kártya 

7_3. lista: Az AccelReadSerial program listája

  1. int x,y,z;
  2.  
  3. void setup() {
  4.   pinMode(PUSH1, INPUT_PULLUP);  // Nyomógomb bemenet felhúzása
  5.   pinMode(PUSH2, INPUT_PULLUP);  // Nyomógomb bemenet felhúzása
  6.   pinMode(ACC_ENABLE, OUTPUT);   // Gyorsulásmérő engedélyező láb
  7.   digitalWrite(ACC_ENABLE,HIGH); // Gyorsulásmérő engedélyezés
  8.   Serial.begin(9600);
  9.   Serial.println(" X    Y    Z");
  10.   Serial.println("------------");
  11. }
  12.  
  13. void loop() {
  14.   x = analogRead(ACC_X);
  15.   y = analogRead(ACC_Y);
  16.   z = analogRead(ACC_Z);
  17.   Serial.print(x);
  18.   Serial.write(' ');
  19.   Serial.print(y);
  20.   Serial.write(' ');
  21.   Serial.println(z);
  22.   delay(500);
  23. }

A program felépítés rendkívül egyszerű, gyakorlatilag az Energia mintapéldái között található AnalogReadSerial programot alakítottuk át a gyorsulásmérőhöz.

accelreadserial.png

7_5. ábra: Az AccelReadSerial program futtatási eredménye (programfutás közben a kártyát több irányba forgattam)


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