wtorek, 24 października 2017

[35] Arduino - Wyświetlacz TFT

Ten post chciałbym poświęcić na opisanie sposobu sterowania wyświetlaczem TFT 1.8 cala za pomocą interfejsu SPI. 

[Źródło: https://nettigo.pl/products/wyswietlacz-lcd-tft-1-8-spi-ili9163]

Podłączenie:


Poniżej przedstawię w jaki sposób podłączyć układ do płytki Arduino:

  • LED - 3.3V
  • SCK - Arduino pin 13
  • SDA - Arduino pin 11
  • A0 - definiowany w programie
  • RESET - definiowany w programie
  • CS - definiowany w programie
  • GND - GND
  • VCC - 5V


Biblioteki:


W projekcie będą wykorzystywane dwie wbudowane biblioteki. Jedna z nich SPI.h odpowiada za komunikację z wyświetlaczem poprzez interfejs SPI. Druga czyli TFT.h jest odpowiedzialna za rysowanie oraz wypisywanie tekstu na ekranie.

Biblioteka dla wyświetlacza korzysta z plików przygotowanych przez Adafruit, które zawierają funkcje graficzne takie jak rysowanie bitmap, figur geometrycznych czy obsługi tekstu. 

Sam plik TFT zawiera inicjalizację obiektu który przekazuje wielkość wyświetlacza oraz piny sterujące dla biblioteki z Adafruit.

Jedyna funkcja jaka znajduje się w pliku TFT odpowiada za uruchomienie sterownika wyświetlacza (ILI9163C) oraz ustawienia orientacji ekranu:

  1. void TFT::begin() {
  2.   initG();
  3.   setRotation(1);
  4. }

Funkcja uruchamiająca sterownik wyświetlacza oraz ustawiająca SPI:

  1. // Initialization for ST7735B screens
  2. void Adafruit_ST7735::initG(void) {
  3.   commonInit(Gcmd);
  4. }
  5. // Initialization code common to both 'B' and 'R' type displays
  6. void Adafruit_ST7735::commonInit(const uint8_t *cmdList)
  7. {
  8.   colstart  = rowstart = 0; // May be overridden in init func
  10.   pinMode(_rs, OUTPUT);
  11.   pinMode(_cs, OUTPUT);
  12.   csport    = portOutputRegister(digitalPinToPort(_cs));
  13.   cspinmask = digitalPinToBitMask(_cs);
  14.   rsport    = portOutputRegister(digitalPinToPort(_rs));
  15.   rspinmask = digitalPinToBitMask(_rs);
  17.   if(hwSPI) { // Using hardware SPI
  18.     SPI.begin();
  19. #ifdef SPI_HAS_TRANSACTION
  20.     spisettings = SPISettings(4000000L, MSBFIRST, SPI_MODE0);
  21. #else
  22. #if defined(ARDUINO_ARCH_SAM)
  23.     SPI.setClockDivider(24); // 4 MHz (half speed)
  24. #else
  25.     SPI.setClockDivider(SPI_CLOCK_DIV4); // 4 MHz (half speed)
  26. #endif
  27.     SPI.setBitOrder(MSBFIRST);
  28.     SPI.setDataMode(SPI_MODE0);
  29. #endif // SPI_HAS_TRANSACTION
  30.   } else {
  31.     pinMode(_sclk, OUTPUT);
  32.     pinMode(_sid , OUTPUT);
  33.     clkport     = portOutputRegister(digitalPinToPort(_sclk));
  34.     clkpinmask  = digitalPinToBitMask(_sclk);
  35.     dataport    = portOutputRegister(digitalPinToPort(_sid));
  36.     datapinmask = digitalPinToBitMask(_sid);
  37.     *clkport   &= ~clkpinmask;
  38.     *dataport  &= ~datapinmask;
  39.   }
  41.   // toggle RST low to reset; CS low so it'll listen to us
  42.   *csport &= ~cspinmask;
  43.   if (_rst) {
  44.     pinMode(_rst, OUTPUT);
  45.     digitalWrite(_rst, HIGH);
  46.     delay(500);
  47.     digitalWrite(_rst, LOW);
  48.     delay(500);
  49.     digitalWrite(_rst, HIGH);
  50.     delay(500);
  51.   }
  53.   if(cmdList) commandList(cmdList);
  54. }

Z funkcji korzysta się poprzez wywołanie zdefiniowanego typu z biblioteki TFT i podanie funkcji z jakiej chce się dla wyświetlacza korzystać. Lista dostępnych publicznych funkcji wygląda następująco:

  1.   Adafruit_ST7735(uint8_t CS, uint8_t RS, uint8_t SID, uint8_t SCLK,
  2.     uint8_t RST);
  3.   Adafruit_ST7735(uint8_t CS, uint8_t RS, uint8_t RST);
  5.   void     initB(void),                             // for ST7735B displays
  6.            initG(void),                             // for ILI9163C displays
  7.            initR(uint8_t options = INITR_GREENTAB), // for ST7735R
  8.            setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1),
  9.            pushColor(uint16_t color),
  10.            fillScreen(uint16_t color),
  11.            drawPixel(int16_t x, int16_t y, uint16_t color),
  12.            drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
  13.            drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
  14.            fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
  15.              uint16_t color),
  16.            setRotation(uint8_t r),
  17.            invertDisplay(boolean i);
  18.   uint16_t Color565(uint8_t r, uint8_t g, uint8_t b) { return newColor(r, g, b);}

Dodatkowo dostępne są funkcje:

  1. public:
  3.   Adafruit_GFX(int16_t w, int16_t h); // Constructor
  5.   // This MUST be defined by the subclass
  6.   virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
  8.   // These MAY be overridden by the subclass to provide device-specific
  9.   // optimized code.  Otherwise 'generic' versions are used.
  10.   virtual void
  11.     drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
  12.         uint16_t color),
  13.     drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
  14.     drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
  15.     drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
  16.         uint16_t color),
  17.     fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
  18.         uint16_t color),
  19.     fillScreen(uint16_t color),
  20.     invertDisplay(boolean i);
  22. // These exist only with Adafruit_GFX (no subclass overrides)
  23.   void
  24.     drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
  25.     drawCircleHelper(int16_t x0, int16_t y0,
  26.             int16_t r, uint8_t cornername, uint16_t color),
  27.     fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
  28.     fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
  29.               uint8_t cornername, int16_t delta, uint16_t color),
  31.     drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
  32.             int16_t x2, int16_t y2, uint16_t color),
  33.     fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
  34.             int16_t x2, int16_t y2, uint16_t color),
  35.     drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
  36.              int16_t radius, uint16_t color),
  37.     fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
  38.              int16_t radius, uint16_t color),
  40.     drawBitmap(int16_t x, int16_t y,
  41.           const uint8_t *bitmap, int16_t w, int16_t h,
  42.           uint16_t color),
  43.     drawChar(int16_t x, int16_t y, unsigned char c,
  44.         uint16_t color, uint16_t bg, uint8_t size),
  45.     setCursor(int16_t x, int16_t y),
  46.     setTextColor(uint16_t c),
  47.     setTextColor(uint16_t c, uint16_t bg),
  48.     setTextSize(uint8_t s),
  49.     setTextWrap(boolean w),
  50.     setRotation(uint8_t r);
  52. #if ARDUINO >= 100
  53.   virtual size_t write(uint8_t);
  54. #else
  55.   virtual void   write(uint8_t);
  56. #endif
  58.   int16_t
  59.     height(void),
  60.     width(void);
  63.   uint8_t getRotation(void);
  66.   /*
  67.    * Processing-like graphics primitives
  68.    */
  70.   /// transforms a color in 16-bit form given the RGB components.
  71.   /// The default implementation makes a 5-bit red, a 6-bit
  72.   /// green and a 5-bit blue (MSB to LSB). Devices that use
  73.   /// different scheme should override this.
  74.   virtual uint16_t newColor(uint8_t red, uint8_t green, uint8_t blue);
  77.   void
  78.     // http://processing.org/reference/background_.html
  79.     background(uint8_t red, uint8_t green, uint8_t blue),
  80.     background(color c),
  82.     // http://processing.org/reference/fill_.html
  83.     fill(uint8_t red, uint8_t green, uint8_t blue),
  84.     fill(color c),
  86.     // http://processing.org/reference/noFill_.html
  87.     noFill(),
  89.     // http://processing.org/reference/stroke_.html
  90.     stroke(uint8_t red, uint8_t green, uint8_t blue),
  91.     stroke(color c),
  93.     // http://processing.org/reference/noStroke_.html
  94.     noStroke(),
  96.     text(const char * text, int16_t x, int16_t y),
  97.     textWrap(const char * text, int16_t x, int16_t y),
  99.     textSize(uint8_t size),
  101.     // similar to ellipse() in Processing, but with
  102.     // a single radius.
  103.     // http://processing.org/reference/ellipse_.html
  104.     circle(int16_t x, int16_t y, int16_t r),
  105.     point(int16_t x, int16_t y),
  106.     line(int16_t x1, int16_t y1, int16_t x2, int16_t y2),
  107.     quad(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, int16_t x4, int16_t y4),
  108. rect(int16_t x, int16_t y, int16_t width, int16_t height),
  109.     rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius),
  110.     triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3);

Programowanie:


Poniżej przedstawię prostą aplikacje wypisującą tekst na ekranie oraz zmieniającą jego kolor:

  1. #include <TFT.h>  
  2. #include <SPI.h>
  4. /* Pin definitions*/
  5. #define CS_Pin   10
  6. #define A0_Pin   9
  7. #define RST_Pin  8
  9. /* Create library instance, pass pin numbers */
  10. TFT TFTDisplay = TFT(CS_Pin, A0_Pin, RST_Pin);
  12. void setup() {
  13.   /* Initialize library */
  14.   TFTDisplay.begin();
  16.   /* Clear screen, set background color */
  17.   TFTDisplay.background(0, 0, 0);
  19.   /* set the font color to white */
  20.   TFTDisplay.stroke(255, 255, 255);
  22.   /* Set text size */
  23.   TFTDisplay.setTextSize(4);
  25.   TFTDisplay.text("Napis :\n ", 0, 0);
  27.   /* Select font color */
  28.   TFTDisplay.stroke(50, 100, 100);
  29. }
  31. void loop()
  32. {
  33.   int redColor = 0;
  34.   int greenColor = 0;
  35.   int blueColor = 0;
  37.   TFTDisplay.stroke(redColor, greenColor, blueColor);
  38.   /* Print text */
  39.   TFTDisplay.text("Hello, World!", 20, 24);
  41.   if(redColor == 255)
  42.   {
  43.     redColor=0;
  44.     greenColor=0;
  45.     blueColor=0;
  46.   }
  48.   redColor++;
  49.   greenColor++;
  50.   blueColor++;
  52.   /* Small delay */
  53.   delay(100);
  54. }

Autor: o
Etykiety: ,