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. 11 perc
Lapozás: OK   8 / 8

A Stellaris Launchpad kártya  bemutatása

A Texas Instruments  EK-LM4F120XL típusjelű Stellaris LM4F120 LaunchPad kártyája egy kicsit kilóg a sorból, mivel nem MSP430 hanem egy nagyteljesítményű 32 bites ARM Cortex-M4F magú LM4F120H5QR mikrovezérlő ketyeg benne, ami teljesítményben és bonyolultságban már meghaladja azt a szintet, amit kezdőnek szívesen ajánlana az ember. A teljesség kedvéért azonban erről a kártyáról is szólnunk kell, hiszen az Energia ezt a kártyát is támogatja.

Szólnunk kell azonban arról is, hogy a 2012. őszén megjelent Stellaris LM4F120 LaunchPad kártyát a gyártó már átdolgozta, s egy még nagyobb teljesítményű és USB OTG képességű TM4C123GH6PM mikrovezérlővel szerelve fogja árulni (e sorok írásának idején még csak előrendeléseket fogadnak), s előbb-utóbb azt is támogatni fogja az Energia. Mi azonban egyelőre az eredeti EK-LM4F120XL kártyánál maradunk, azt ismertetjük röviden.

A kártya felépítése az alábbi ábrán látható. A kártya felső részén a programozó és hibavadász áramkör található, amely egy USB mikro-B kábelen keresztül csatlakoztatható a számítógéphez. A kártya középső és alsó részén a kísérleti áramkör (vagy "cél áramkör") helyezkedik el.

 stellarpad_550.png

 8_1. ábra: Az LM120 Stellaris Launchpad kártya

A céláramkörhöz RESET gomb, két felhasználói nyomógomb és egy RGB LED is csatlakozik. A kivezetések úgy vannak kialakítva, hogy a két szélső csatlakozósor (a képen J1 és J2) geometriailag és elektromosan is kompatibil az MSP430 Launchpad kártyával. Ez lehetővé teszi, hogy az MSP430 Launchpad kártyához készült bővítőkártyákat (shield) a Stellaris Launchpad kártyához is használhassuk. A kártya túloldalán a kivezetések 20 pólusú csatlakozóhüvelyekben végződnek. Ezek segítségével a Stellaris Launchpad kártya akár egy anyalapra (motherboard) is ráültethető.

A Stellaris LaunchPad kártya (nemhivatalos nevén "Stellarpad") egy 80 MHz-es LM4F120H5QR mikrovezérlőt tartalmaz (pontosabban kettőt, mert a kártyára épített programozó és hibavadász áramkör is egy másik ugyanilyen mikrovezérlőt tartalmaz).  Az LM4F120H5QR mikrovezérlő 256 KB flash programtároló memóriát, 32 KB RAM-ot és 2 KB EEPROM-ot tartalmaz. Van benne két 12-bites analóg-digitális átalakító, egy USB 2.0 port, hibernációs modul, és sokféle soros kommunikációs lehetőséggel rendelkezik (pl. UART, CAN, SPI, I2C).

Az Energia szoftverkönyvtáraiban a lábak szerepét az alábbi diagram segítségével mutatjuk be, melyet a https://github.com/energia/Energia/wiki/Hardware címről vettünk át (az ábrát Rei Vilo készítette). 

stellar_pinmap_small.jpg

8_2 ábra: A Stellaris LM4F120 LaunchPad kártya lábkiosztása
(kattintson az ábrára a nagyításhoz!)

Amint a fenti ábra is mutatja, összesen 35 általános célú ki/bemenet áll rendelkezésre, melyek közül 12 db lehet analóg bemenet. Az általános célú I/O kivezetések szokásos elnevezése mellett a RED_LED, BLUE_LED, GREEN_LED (az RGB LED-et vezérlő PF_1, PF_2, PF_3 kivezetések  alternatív elnevezései), valamint a PUSH1, PUSH2 (felhasználói nyomógombok) neveket is használhatjuk.

Mintapélda: Az RGB LED villogtatása

Az alábbi programban egyenként felkapcsoljuk a kártyán található RGB LED piros, zöld és kék alapszínét, ebben a sorrendben.  Mindegyik szín egy-egy másodpercig világít, utána lekapcsoljuk.  Végül egy másodpercre kikapcsolva hagyjuk az összes alapszínt.

Hardver követelmények: Stellaris Launchpad kártya.

A program listája az alábbi ábrán látható.

 rgb_ledblink.png

8_3. ábra: Az RGB_ledblink program listája

 

 Mintapélda: RGB LED vezérlése folyamatos színátmenettel

Az alábbi program az "Arduino Forum"-ról letölthető Code for RGB LED példaprogram némileg átdolgozott változata. A program véletlen számokat generál az RGB színkomponenesek előállítására, s az előző színből az új színbe való átmenet fokozatosan, 255 lépésben történik. Az  előállított RGB színkomponenseket a kártyán elhelyezett RGB LED vezérlésére használjuk fel, a digitalWrite() függvény segítségével  (lásd a PWM vezérlésnél, a 4. oldalon).

Hardver követelmények: Stellaris Launchpad kártya.

  1. /*
  2.  * RGB LED
  3.  * Fokozatos átmenet egyik véletlen színből a másikba
  4.  * Forrás: http://arduino.cc/forum/index.php/topic,11293.0.html
  5.  * Hardver követelmények: Stellaris Launcpad kártya
  6.  */
  7.  
  8. float RGB1[3];
  9. float RGB2[3];
  10. float INC[3];
  11. float SUM;
  12. int red, green, blue;
  13.  
  14. void setup() {
  15. //--- Kiindulási színek generálása, véletlenszerűen
  16.   randomSeed(analogRead(0));
  17.   for (int x=0; x < 3; x++) {
  18.     RGB1[x] = random(256);
  19.     RGB2[x] = random(256);
  20.   }
  21. }
  22.  
  23. void loop() {
  24. //--- Az 1. színből a 2. színbe történő átmenet lépéseinek meghatározása
  25.   for (int x=0; x < 3; x++) {
  26.     INC[x] = (RGB1[x] - RGB2[x]) / 256;
  27.   }
  28.  
  29.   for (int s=0; s < 256; s++) {
  30.     red = int(RGB1[0]);
  31.     green = int(RGB1[1]);
  32.     blue = int(RGB1[2]);
  33. //--- A közelítő szín kijelzése
  34.     analogWrite (RED_LED, red);
  35.     analogWrite (GREEN_LED, green);  
  36.     analogWrite (BLUE_LED, blue);    
  37.     delay(20);  
  38.  
  39.     for (int x=0; x < 3; x++) {
  40.       RGB1[x] -= INC[x];   //Közelítünk a másik színhez  
  41.     }
  42.  
  43.   }
  44. //--- Új színt konstruálunk, véletlen számok generálásával
  45.   do {
  46.     SUM = 0;
  47.     for (int x=0; x < 3; x++) {
  48.       RGB2[x] = random(956)-700;
  49.       RGB2[x] = constrain(RGB2[x], 0, 255);
  50.       SUM += RGB2[x];
  51.     }
  52.   }
  53.   while(SUM < 300);        //Nem engedjük túlságosan elsötétedni
  54. }

Az eredeti programhoz képest lecsökkentettük, illetve kivettük a késleltetéseket, s azzal, hogy nem fogadunk el olyan színkombinációt, ahol az R+B+G összege nem éri el a 300-at, megakadályozzuk, hogy az RGB LED túlságosan elsötétedjen. 

 

Nokia 5110 grafikus kijelző vezérlése

A 6. oldalon bemutatott, Nokia 5110 grafikus kijelzőt működtető programot a Stellaris Launchpad kártyán is futtathatjuk, hiszen Rei Vilo LCD_5110_SPI példaprogramja úgy van megírva, hogy az MSP430 Launchpad kártyán kívül a Stellaris Launchpad kártyával is működjön. A program ezért meg van tűzdelve feltételes fordítási direktívákkal. Most csak azok a programsorok fordulnak be a programunkba, amelyek vagy nincsenek feltételhez kötve, vagy pedig az __LM4F120H5QR__ szimbólum definiáltságához vannak kötve.

A bekötés megegyezik a 6_6. ábrán bemutatottal. Az alábbi táblázatban a Sparkfun által forgalmazott kijelző modul lábkiosztását követtük, amelyen a lábak sorrendje balról jobbra így néz ki:

Sorsz.   Név  
Szín Leírás Stellaris
Launchpad
1. VCC narancs   Tápfeszültség VCC
2. GND fekete Közös pont (föld) GND
3. SCE szürke Kiválasztás (chip )         PA_7
4. RST türkiz Reset PB_5
5. D/C lila Adat/parancs választójel      PA_2
6. DIN kék SPI adatküldés (MOSI) PB_7
7. SCLK sárga SPI órajel (CLK) PB_4
8. LED barna Háttárvilágítás PA_6

Figyeljünk a bekötésre, mert más gyártók más bekötési sorrendet alakítanak ki (az alábbi fényképen is más a lábak sorrendje és emiatt a vezetékek színe)! Eltérés lehet abban is, hogy a háttérvilágítás bekapcsolása VCC vagy GND szintű jellel történik.

A program működéséhez be kell csatolnunk az SPI.h és az LCD_5110_SPI.h fejléc állományokat. Előbbi a "gyári" könyvtárak között található, utóbbit nekünk kell a felhasználói könyvtárunkban az Energia/libraries könyvtárban elhelyezni. Ha az MSP430 Launchpad kártyán már futtattuk ezt a programot, akkor az LCD_5110_SPI könyvtár már a "helyén van", nem kell foglalkoznunk vele...

A setup() függvényben előbb az SPI soros kommunikációs egységet kell beállítani, ezt követően pedig az LCD modult inicializáljuk. Az SPI modul órajelének sebességét úgy kell beállítani, hogy az 5 MHz-et ne haladja meg, mert ennyit bír a Nokia 5110 modul PCD8544 típusú vezérlője.

A Stellaris Launchpad kártya esetében az SPI modul inicializálásánál meg kell mondanunk, hogy melyik SPI egységet használjuk, mert több is van belőle. Mi a 2. sorszámú modult használjuk, s  ezt az SPI.setModule(2) függvényhívással mondhatjuk meg. Ez egyúttal meghívja az SPI.begin() metódust is, tehát azt nem kell külön kiadnunk. Ezt a részt Rei Vilo eredeti programján módosítanunk kellett, mert az abban szereplő SPI inicializálás nem volt kompatibilis az Energia "gyári" SPI könyvtárával.

A háttérvilágítást kezdetben bekapcsoljuk, a futás során pedig a Launchpad kártya felhasználói nyomógombjával ki-be kapcsolgathatjuk. Ha valaki hozzám hasonlóan olyan 5110 modult szerez be, amelyiken a háttérvilágítás alacsony jelszinttel történik (a LED-ek katódja van kivezetve), akkor ne lepődjön meg, ha a program fordítva működik: a háttérvilágítás kezdetben ki lesz kapcsolva. 

A képernyő bal felső sarkában kiírjuk a "Hello!" üzenetet. Egy másodperc elteltével töröljük a képernyőt, majd a bal alső sarokba kiírjuk a "Light off" üzenetet. (A mobiltelefonokhoz hasonlóan mindig a gombbal indítható műveletet írjuk ki, azaz a következő gombnyomás lekapcsolja a háttérvilágítást.)

A végtelen ciklusban figyeljük a nyomógombot (lenyomás esetén átváltjuk a háttérvilágítás állapotát), majd nagyobb méretű betűkel felváltva az MSP430, illetve az LM4F feliratokat írjuk ki.

Ezt követően kisebb karaktermérettel egy csillagot (vagy szorzásjelet) szánkáztatunk a képernyőn balról jobbra (az animáció miatt a mozgó csillag a pillanatfelvételen többnyire kettőnek látszik...).

lcd_5110_lm4f120.jpg

8_4. ábra: Az LCD_5110_SPI program futtatása Stellaris Launchpad kártyán

 

Színes TFT kijelző vezérlése

Számos helyen beszerezhető olyan színes LCD modul, amelyben a JD-T1800 kijelzőt használják, amely szinkron soros (SPI) módon kommunikál (többnyire a népszerű Arduino platformhoz ajánlják). A kijelző modul hátuljára többnyire egy SD kártya foglalatot is felszerelnek (az SD kártya szintén az SPI buszra csatlakozik, de külön kiválasztó vonal tartozik hozzá). Az E-bay kínálatában található olyan kivitel (lásd az alábbi képen!), amelyen az illesztő minden vonalán egy-egy szintillesztő tranzisztor is helyet kapott, így 5 V-os és 3,3 V-os áramkörökhöz egyaránt csatlakoztatható. Ha a későbbiekben 5 V-os rendszerekben is használni szeretnénk, ennek beszerzését javasoljuk.

1_8_tft.jpg

8_5. ábra: Soros vezérlésű, 1.8" TFT színes kijelző modul

A kijelző vezérlője egy ST7735 chip, adatlapja innen letölthető. A kijelző felbontása 128x160 képpont, a színmélység elvileg 18 bites, mi ebből csak 16 bitet használunk majd (RGB 5/6/5). Az Adafruit honlapján is árulnak a fentihez többé-kevésbé hasonló, és vele teljesen kompatibilis kijelző mudulokat, amelyekhez részletes termékleírás és tutorial is található, ezért ezekre a részletekre itt nem térünk ki. Az Adafruit honlapjáról elérhető programkönyvtárak és demóprogramok az Arduino kártyához készültek, amelyeket közvetlenül nem tudunk felhasználni. A kijelzőt kezelő Adafruit_ST7735 és a grafikus eljárásokat tartalmazó Adafruit_GFX könyvtárakat azonban Stephen Crane már adaptálta a Stellaris Launchpad kártyához.

A kijelző modult az alábbi táblázat szerint kössük össze a Stellaris Launchpad kártyával. A fehér vezetéket (SD_CS kiválasztójel) nem kell bekötni, mivel ebben a példában az SD kártyát nem használjuk.

Sorsz.   Név  
Szín Leírás Stellaris
Launchpad
1. GND fekete  Közös pont (föld) GND
2. SD_CS fehér SD kártya kiválasztás (chip ) nem használt
3. LCD_CS szürke LCD kiválasztás (chip )         PA_7
4. SCLK lila SPI órajel (CLK) PB_4
5. MOSI kék SPI adatküldés (MOSI) PB_7
6. MISO zöld SPI adatfogadás (MISO) PB_6
7. RS sárga Adat/parancs választójel PA_6
8. RESET narancs Reset RST
9. BL piros Háttárvilágítás (lehúzásra világít) GND
10. VCC barna Tápfeszültség VBUS

A jelszinttől függetlenül a kijelző VCC lábára +5 V-ot kell adni (saját feszültség-stabilizátorral állítja elő a 3,3 V-ot). A Stellaris Launchpad kártyán a +5 V-ot a +VBUS feliratú lábak valamelyikéről vehetjük le.

Mintaprogram: graphicstest_highspeed

Az Adafruit_ST7735 programkönyvtár mintapéldái közül egyelőre csak a graphicstest_highspeed demóprogram használható a Stellaris Launchpad kártyán. Ez a program a színes kijelző és az Adafruit_GFX könyvtár lehetőségeit mutatja be. A "highspeed" elnevezés itt arra utal, hogy az SPI kommunikációt hardveres támogatással végezzük (alternatív lehetőség a szoftveres SPI kezelés, amely flexibilisebb lábkiosztást engedélyez, de lassabb és CPU időigényesebb a kezelés).

A program elején felhívják arra is a figyelmet, hogy a JD-T1800 (vagy vele kompatibilis) kijelzőkből több változat is piacra került, amelyek vezérlésben apróbb különbségek vannak. Ezek a változatok a védőfólia fülének színe alapján is azonosíthatók, vagy próbálgatásos alapon kell megtalálni a megfelelő beállítást. Ha nem jók a kijelzett színek (piros - kék színcsere tapasztalható), vagy a kép szélén zavaró képpontok látszanak, akkor az INITR_BLACKTAB helyett az  INITR_REDTAB, vagy az INITR_GREENTAB paramétert kell választani. A 8.5 ábrán látható kijelzőnél például a védőfólia füle zöld színű, ennél a gyártmánysorozatnál a INITR_GREENTAB paramétert kell megadni az inicializáló metódusnak. Nekem egy fekete címkéset sikerült kifogni, ehhez az INITR_BLACKTAB-ot kellet választani, különben a képernyőn piros helyett kék, kék helyett piros látszott.  

Hardver követelmények:

  • Stellaris Launchpad kártya
  • 1.8" TFT színes kijelző ST7735 vezérlővel, a fenti táblázat szerinti bekötéssel

A graphicstest_highspeed program listája:

(forrás: Adafruit_ST7735 on GitHUB)

  1. /***************************************************
  2.   This is an example sketch for the Adafruit 1.8" SPI display.
  3.   This library works with the Adafruit 1.8" TFT Breakout w/SD card
  4.   ----> http://www.adafruit.com/products/358
  5.   as well as Adafruit raw 1.8" TFT display
  6.   ----> http://www.adafruit.com/products/618
  7.  
  8.   Check out the links above for our tutorials and wiring diagrams
  9.   These displays use SPI to communicate, 4 or 5 pins are required to
  10.   interface (RST is optional)
  11.   Adafruit invests time and resources providing this open source code,
  12.   please support Adafruit and open-source hardware by purchasing
  13.   products Adafruit!
  14.  
  15.   Written by Limor Fried/Ladyada for Adafruit Industries.
  16.   MIT license, all text above must be included in any redistribution
  17.  ****************************************************/
  18.  
  19. //#define sclk 13
  20. //#define mosi 11
  21. #define cs   10
  22. #define dc   9
  23. #define rst  8  // you can also connect this to the Arduino reset
  24.  
  25. #include    // Core graphics library
  26. #include// Hardware-specific library
  27. #include
  28.  
  29. // Option 1: use any pins but a little slower
  30. //Adafruit_ST7735 tft = Adafruit_ST7735(cs, dc, mosi, sclk, rst);
  31.  
  32. // Option 2: must use the hardware SPI pins
  33. // (for UNO thats sclk = 13 and sid = 11) and pin 10 must be
  34. // an output. This is much faster - also required if you want
  35. // to use the microSD card (see the image drawing example)
  36. Adafruit_ST7735 tft = Adafruit_ST7735(cs, dc, rst);
  37. float p = 3.1415926;
  38.  
  39. void setup(void) {
  40.   Serial.begin(9600);
  41.   Serial.print("hello!");
  42.  
  43.   // Our supplier changed the 1.8" display slightly after Jan 10, 2012
  44.   // so that the alignment of the TFT had to be shifted by a few pixels
  45.   // this just means the init code is slightly different. Check the
  46.   // color of the tab to see which init code to try. If the display is
  47.   // cut off or has extra 'random' pixels on the top & left, try the
  48.   // other option!
  49.   // If you are seeing red and green color inversion, use Black Tab
  50.  
  51.   // If your TFT's plastic wrap has a Black Tab, use the following:
  52.   tft.initR(INITR_BLACKTAB);   // initialize a ST7735S chip, black tab
  53.   // If your TFT's plastic wrap has a Red Tab, use the following:
  54.   //tft.initR(INITR_REDTAB);   // initialize a ST7735R chip, red tab
  55.   // If your TFT's plastic wrap has a Green Tab, use the following:
  56.   //tft.initR(INITR_GREENTAB); // initialize a ST7735R chip, green tab
  57.  
  58.   Serial.println("init");
  59.  
  60.   uint16_t time = millis();
  61.   tft.fillScreen(ST7735_BLACK);
  62.   time = millis() - time;
  63.  
  64.   Serial.println(time, DEC);
  65.   delay(500);
  66.  
  67.   // large block of text
  68.   tft.fillScreen(ST7735_BLACK);
  69.   testdrawtext("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur adipiscing ante sed nibh tincidunt feugiat. Maecenas enim massa, fringilla sed malesuada et, malesuada sit amet turpis. Sed porttitor neque ut ante pretium vitae malesuada nunc bibendum. Nullam aliquet ultrices massa eu hendrerit. Ut sed nisi lorem. In vestibulum purus a tortor imperdiet posuere. ", ST7735_WHITE);
  70.   delay(1000);
  71.  
  72.   // tft print function!
  73.   tftPrintTest();
  74.   delay(4000);
  75.  
  76.   // a single pixel
  77.   tft.drawPixel(tft.width()/2, tft.height()/2, ST7735_GREEN);
  78.   delay(500);
  79.  
  80.   // line draw test
  81.   testlines(ST7735_YELLOW);
  82.   delay(500);
  83.  
  84.   // optimized lines
  85.   testfastlines(ST7735_RED, ST7735_BLUE);
  86.   delay(500);
  87.  
  88.   testdrawrects(ST7735_GREEN);
  89.   delay(500);
  90.  
  91.   testfillrects(ST7735_YELLOW, ST7735_MAGENTA);
  92.   delay(500);
  93.  
  94.   tft.fillScreen(ST7735_BLACK);
  95.   testfillcircles(10, ST7735_BLUE);
  96.   testdrawcircles(10, ST7735_WHITE);
  97.   delay(500);
  98.  
  99.   testroundrects();
  100.   delay(500);
  101.  
  102.   testtriangles();
  103.   delay(500);
  104.  
  105.   mediabuttons();
  106.   delay(500);
  107.  
  108.   Serial.println("done");
  109.   delay(1000);
  110. }
  111.  
  112. void loop() {
  113.   tft.invertDisplay(true);
  114.   delay(500);
  115.   tft.invertDisplay(false);
  116.   delay(500);
  117. }
  118.  
  119. void testlines(uint16_t color) {
  120.   tft.fillScreen(ST7735_BLACK);
  121.   for (int16_t x=0; x < tft.width(); x+=6) {
  122.     tft.drawLine(0, 0, x, tft.height()-1, color);
  123.   }
  124.   for (int16_t y=0; y < tft.height(); y+=6) {
  125.     tft.drawLine(0, 0, tft.width()-1, y, color);
  126.   }
  127.  
  128.   tft.fillScreen(ST7735_BLACK);
  129.   for (int16_t x=0; x < tft.width(); x+=6) {
  130.     tft.drawLine(tft.width()-1, 0, x, tft.height()-1, color);
  131.   }
  132.   for (int16_t y=0; y < tft.height(); y+=6) {
  133.     tft.drawLine(tft.width()-1, 0, 0, y, color);
  134.   }
  135.  
  136.   tft.fillScreen(ST7735_BLACK);
  137.   for (int16_t x=0; x < tft.width(); x+=6) {
  138.     tft.drawLine(0, tft.height()-1, x, 0, color);
  139.   }
  140.   for (int16_t y=0; y < tft.height(); y+=6) {
  141.     tft.drawLine(0, tft.height()-1, tft.width()-1, y, color);
  142.   }
  143.  
  144.   tft.fillScreen(ST7735_BLACK);
  145.   for (int16_t x=0; x < tft.width(); x+=6) {
  146.     tft.drawLine(tft.width()-1, tft.height()-1, x, 0, color);
  147.   }
  148.   for (int16_t y=0; y < tft.height(); y+=6) {
  149.     tft.drawLine(tft.width()-1, tft.height()-1, 0, y, color);
  150.   }
  151. }
  152.  
  153. void testdrawtext(char *text, uint16_t color) {
  154.   tft.setCursor(0, 0);
  155.   tft.setTextColor(color);
  156.   tft.setTextWrap(true);
  157.   tft.print(text);
  158. }
  159.  
  160. void testfastlines(uint16_t color1, uint16_t color2) {
  161.   tft.fillScreen(ST7735_BLACK);
  162.   for (int16_t y=0; y < tft.height(); y+=5) {
  163.     tft.drawFastHLine(0, y, tft.width(), color1);
  164.   }
  165.   for (int16_t x=0; x < tft.width(); x+=5) {
  166.     tft.drawFastVLine(x, 0, tft.height(), color2);
  167.   }
  168. }
  169.  
  170. void testdrawrects(uint16_t color) {
  171.   tft.fillScreen(ST7735_BLACK);
  172.   for (int16_t x=0; x < tft.width(); x+=6) {
  173.     tft.drawRect(tft.width()/2 -x/2, tft.height()/2 -x/2 , x, x, color);
  174.   }
  175. }
  176.  
  177. void testfillrects(uint16_t color1, uint16_t color2) {
  178.   tft.fillScreen(ST7735_BLACK);
  179.   for (int16_t x=tft.width()-1; x > 6; x-=6) {
  180.     tft.fillRect(tft.width()/2 -x/2, tft.height()/2 -x/2 , x, x, color1);
  181.     tft.drawRect(tft.width()/2 -x/2, tft.height()/2 -x/2 , x, x, color2);
  182.   }
  183. }
  184.  
  185. void testfillcircles(uint8_t radius, uint16_t color) {
  186.   for (int16_t x=radius; x < tft.width(); x+=radius*2) {
  187.     for (int16_t y=radius; y < tft.height(); y+=radius*2) {
  188.       tft.fillCircle(x, y, radius, color);
  189.     }
  190.   }
  191. }
  192.  
  193. void testdrawcircles(uint8_t radius, uint16_t color) {
  194.   for (int16_t x=0; x < tft.width()+radius; x+=radius*2) {
  195.     for (int16_t y=0; y < tft.height()+radius; y+=radius*2) {
  196.       tft.drawCircle(x, y, radius, color);
  197.     }
  198.   }
  199. }
  200.  
  201. void testtriangles() {
  202.   tft.fillScreen(ST7735_BLACK);
  203.   int color = 0xF800;
  204.   int t;
  205.   int w = 63;
  206.   int x = 159;
  207.   int y = 0;
  208.   int z = 127;
  209.   for(t = 0 ; t
  210.     tft.drawTriangle(w, y, y, x, z, x, color);
  211.     x-=4;
  212.     y+=4;
  213.     z-=4;
  214.     color+=100;
  215.   }
  216. }
  217.  
  218. void testroundrects() {
  219.   tft.fillScreen(ST7735_BLACK);
  220.   int color = 100;
  221.   int i;
  222.   int t;
  223.   for(t = 0 ; t
  224.     int x = 0;
  225.     int y = 0;
  226.     int w = 127;
  227.     int h = 159;
  228.     for(i = 0 ; i
  229.       tft.drawRoundRect(x, y, w, h, 5, color);
  230.       x+=2;
  231.       y+=3;
  232.       w-=4;
  233.       h-=6;
  234.       color+=1100;
  235.     }
  236.     color+=100;
  237.   }
  238. }
  239.  
  240. void tftPrintTest() {
  241.   tft.setTextWrap(false);
  242.   tft.fillScreen(ST7735_BLACK);
  243.   tft.setCursor(0, 30);
  244.   tft.setTextColor(ST7735_RED);
  245.   tft.setTextSize(1);
  246.   tft.println("Hello World!");
  247.   tft.setTextColor(ST7735_YELLOW);
  248.   tft.setTextSize(2);
  249.   tft.println("Hello World!");
  250.   tft.setTextColor(ST7735_GREEN);
  251.   tft.setTextSize(3);
  252.   tft.println("Hello World!");
  253.   tft.setTextColor(ST7735_BLUE);
  254.   tft.setTextSize(4);
  255.   tft.print(1234.567);
  256.   delay(1500);
  257.   tft.setCursor(0, 0);
  258.   tft.fillScreen(ST7735_BLACK);
  259.   tft.setTextColor(ST7735_WHITE);
  260.   tft.setTextSize(0);
  261.   tft.println("Hello World!");
  262.   tft.setTextSize(1);
  263.   tft.setTextColor(ST7735_GREEN);
  264.   tft.print(p, 6);
  265.   tft.println(" Want pi?");
  266.   tft.println(" ");
  267.   tft.print(8675309, HEX); // print 8,675,309 out in HEX!
  268.   tft.println(" Print HEX!");
  269.   tft.println(" ");
  270.   tft.setTextColor(ST7735_WHITE);
  271.   tft.println("Sketch has been");
  272.   tft.println("running for: ");
  273.   tft.setTextColor(ST7735_MAGENTA);
  274.   tft.print(millis() / 1000);
  275.   tft.setTextColor(ST7735_WHITE);
  276.   tft.print(" seconds.");
  277. }
  278.  
  279. void mediabuttons() {
  280.   // play
  281.   tft.fillScreen(ST7735_BLACK);
  282.   tft.fillRoundRect(25, 10, 78, 60, 8, ST7735_WHITE);
  283.   tft.fillTriangle(42, 20, 42, 60, 90, 40, ST7735_RED);
  284.   delay(500);
  285.   // pause
  286.   tft.fillRoundRect(25, 90, 78, 60, 8, ST7735_WHITE);
  287.   tft.fillRoundRect(39, 98, 20, 45, 5, ST7735_GREEN);
  288.   tft.fillRoundRect(69, 98, 20, 45, 5, ST7735_GREEN);
  289.   delay(500);
  290.   // play color
  291.   tft.fillTriangle(42, 20, 42, 60, 90, 40, ST7735_BLUE);
  292.   delay(50);
  293.   // pause color
  294.   tft.fillRoundRect(39, 98, 20, 45, 5, ST7735_RED);
  295.   tft.fillRoundRect(69, 98, 20, 45, 5, ST7735_RED);
  296.   // play color
  297.   tft.fillTriangle(42, 20, 42, 60, 90, 40, ST7735_GREEN);
  298. }

A program inicializálás után a szövegkiírási lehetőségeket mutatja be. Mivel az Adafruit_ST7735 és az Adafruit_GFX objektumosztályok a Print osztály leszármazottjai, így a képernyő inicializálása és a tintaszín megadása után a print metódussal írathatunk ki szöveget, számokat, lebegőpontos számot és hexadecimális számot.

Nagyított karakterek kiírására is van lehetőség, de vegyük figyelembe, hogy a szöveg nagyítása csak a pixelek felnagyításával történik, ami durva karakterképet eredményez. 

A program ízelítőt ad a vonalak, síkidomok, kitöltött és kitöltetlen alakzatok rajzolásából is. Végül egy lejátszó és leállító gomb rajzolata jeleni meg, majd a program végtelen ciklusban invertálja a színeket.

A futás végeredménye az alábbi képen látható.

graphicstest_highspeed.jpg

8_6. ábra: A graphicstest_highspeed program futásának eredménye

Következő: »»   8 / 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