st7735: Added text feature and documentation with license

Signed-off-by: Kiveisha Yevgeniy <yevgeniy.kiveisha@intel.com>

examples/st7735.cxx

@@ -35,27 +35,42 @@ main(int argc, char **argv)
     upm::ST7735 * lcd = new upm::ST7735(7, 4, 9, 8);
     lcd->fillScreen (ST7735_RED);
     lcd->refresh ();
-    
+
     lcd->fillScreen (ST7735_CYAN);
     lcd->refresh ();
-    
+
     lcd->fillScreen (ST7735_BLACK);
     lcd->refresh ();
-    
+
     lcd->drawLine(10, 10, 10, 100, ST7735_MAGENTA);
     lcd->drawLine(20, 20, 10, 100, ST7735_YELLOW);
     lcd->drawLine(30, 30, 50, 100, ST7735_WHITE);
     lcd->refresh ();
-    
+
     lcd->drawPixel (20, 20, ST7735_GREEN);
     lcd->refresh ();
-    
+
     lcd->drawTriangle (50, 50, 80, 80, 60, 90, ST7735_GREEN);
     lcd->refresh ();
-    
+
     lcd->drawCircle (100, 110, 10, ST7735_BLUE);
     lcd->refresh ();
-    
+
+
+    lcd->setTextWrap(0x0);
+
+    lcd->setCursor(0, 30);
+    lcd->setTextColor(ST7735_RED, ST7735_RED);
+    lcd->setTextSize(1);
+    lcd->print("Hello World!");
+
+    lcd->setCursor(10, 50);
+    lcd->setTextColor(ST7735_RED, ST7735_YELLOW);
+    lcd->setTextSize(2);
+    lcd->print("BIG");
+
+    lcd->refresh ();
+
     std::cout << "exiting application" << std::endl;
 
     delete lcd;

src/st7735/gfx.cxx

@@ -30,48 +30,50 @@
 
 using namespace upm;
 
-GFX::GFX (int width, int height) {
+GFX::GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font) : WIDTH(width), HEIGHT(height) {
     m_height = height;
     m_width  = width;
+    m_font   = font;
+    m_map    = screenBuffer;
 }
 
 GFX::~GFX () {
 }
 
-maa_result_t 
+maa_result_t
 GFX::setPixel (int x, int y, uint16_t color) {
     if((x < 0) ||(x >= m_width) || (y < 0) || (y >= m_height)) {
         return MAA_ERROR_UNSPECIFIED;
     }
-    
+
     int index = ((y * m_width) + x) * sizeof(uint16_t);
     m_map[index] = (uint8_t) (color >> 8);
     m_map[++index] = (uint8_t)(color);
-    
+
     return MAA_SUCCESS;
 }
 
-void 
+void
 GFX::fillScreen (uint16_t color) {
     fillRect(0, 0, m_width, m_height, color);
 }
 
-void 
+void
 GFX::fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
     for (int16_t i=x; i<x+w; i++) {
         drawFastVLine(i, y, h, color);
     }
 }
 
-void 
+void
 GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
     drawLine(x, y, x, y+h-1, color);
 }
 
-void 
+void
 GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
     int16_t steep = abs(y1 - y0) > abs(x1 - x0);
-    
+
     if (steep) {
         swap(x0, y0);
         swap(x1, y1);
@@ -109,14 +111,14 @@ GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
     }
 }
 
-void 
+void
 GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
     drawLine(x0, y0, x1, y1, color);
     drawLine(x1, y1, x2, y2, color);
     drawLine(x2, y2, x0, y0, color);
 }
 
-void 
+void
 GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
     int16_t f = 1 - r;
     int16_t ddF_x = 1;
@@ -136,7 +138,7 @@ GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
             f += ddF_y;
         }
         x++;
-        
+
         ddF_x += 2;
         f += ddF_x;
 
@@ -150,3 +152,80 @@ GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
         setPixel(x0 - y, y0 - x, color);
     }
 }
+
+void
+GFX::setCursor (int16_t x, int16_t y) {
+    m_cursorX = x;
+    m_cursorY = y;
+}
+
+void
+GFX::setTextColor (uint16_t textColor, uint16_t textBGColor) {
+    m_textColor   = textColor;
+    m_textBGColor = textBGColor;
+}
+
+void
+GFX::setTextSize (uint8_t size) {
+    m_textSize = (size > 0) ? size : 1;
+}
+
+void
+GFX::setTextWrap (uint8_t wrap) {
+    m_wrap = wrap;
+}
+
+void
+GFX::drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size) {
+    if( (x >= m_width)            || // Clip right
+        (y >= m_height)           || // Clip bottom
+        ((x + 6 * size - 1) < 0)  || // Clip left
+        ((y + 8 * size - 1) < 0))    // Clip top
+    return;
+
+    for (int8_t i=0; i<6; i++ ) {
+        uint8_t line;
+        if (i == 5) {
+            line = 0x0;
+        } else {
+            line = *(m_font+(data * 5)+i);
+            for (int8_t j = 0; j<8; j++) {
+                if (line & 0x1) {
+                    if (size == 1) // default size
+                        setPixel (x+i, y+j, color);
+                    else {  // big size
+                        fillRect (x+(i*size), y+(j*size), size, size, color);
+                    }
+                } else if (bg != color) {
+                    if (size == 1) // default size
+                        setPixel (x+i, y+j, bg);
+                    else {  // big size
+                        fillRect (x+i*size, y+j*size, size, size, bg);
+                    }
+                }
+                line >>= 1;
+            }
+        }
+    }
+}
+
+void
+GFX::print (std::string msg) {
+    int len = msg.length();
+
+    for (int idx = 0; idx < len; idx++) {
+        if (msg[idx] == '\n') {
+            m_cursorY += m_textSize * 8;
+            m_cursorX  = 0;
+        } else if (msg[idx] == '\r') {
+            // skip em
+        } else {
+            drawChar(m_cursorX, m_cursorY, msg[idx], m_textColor, m_textBGColor, m_textSize);
+            m_cursorX += m_textSize * 6;
+            if (m_wrap && (m_textColor > (m_width - m_textSize * 6))) {
+                m_cursorY += m_textSize * 8;
+                m_cursorX = 0;
+            }
+        }
+    }
+}

src/st7735/gfx.h

@@ -32,7 +32,7 @@
 #define swap(a, b) { int16_t t = a; a = b; b = t; }
 
 namespace upm {
-    
+
 /**
  * @brief GFX helper class
  *
@@ -43,10 +43,12 @@ class GFX {
         /**
          * Instanciates a GFX object
          *
-         * @param width 
-         * @param height
+         * @param width screen width
+         * @param height screen height
+         * @param screenBuffer pointer to screen buffer
+         * @param font pointer to font map
          */
-        GFX (int width, int height);
+        GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font);
 
         /**
          * GFX object destructor
@@ -62,55 +64,153 @@ class GFX {
          * @param y1 second coordinate
          */
         virtual void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) = 0;
-        
+
         /**
-         * 
+         * Send pixel collor (RGB) to the chip. Must be implemented by
+         * inherited class.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color rgb value
          */
         virtual void drawPixel (int16_t x, int16_t y, uint16_t color) = 0;
-        
+
         /**
-         * 
+         * Copy the buffer to the chip via SPI interface.
          */
         virtual void refresh () = 0;
-        
+
+        /**
+         *
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param data character to write
+         * @param color character's color
+         * @param bg character's background color
+         * @param size size of the font
+         */
+        void drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size);
+
         /**
-         * 
+         * Print the message to the screen
+         *
+         * @param msg message which will be printed
+         */
+        void print (std::string msg);
+
+        /**
+         * Print the message to the screen
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color pixel's color
          */
         maa_result_t setPixel (int x, int y, uint16_t color);
-        
+
         /**
-         * 
+         * Fill screen with selected color
+         *
+         * @param color selected's color
          */
         void fillScreen (uint16_t color);
-        
+
         /**
-         * 
+         * Fill rectangle with selected color
+         *
+         * @param x axis on horizontal scale (top left corner)
+         * @param y axis on vertical scale (top left corner)
+         * @param w distanse from x
+         * @param h distanse from y
+         * @param color selected color
          */
         void fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
-        
+
         /**
-         * 
+         * Draw line in vertical scale.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param h distanse from y
+         * @param color selected color
          */
         void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
-        
+
         /**
-         * 
+         * Draw line from coordinate C0 to coordinate C1
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         * @param color selected color
          */
         void drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
-        
+
         /**
-         * 
+         * Draw a triangle
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         * @param x2 third coordinate
+         * @param y2 third coordinate
+         * @param color selected color
          */
         void drawTriangle (int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
-        
+
         /**
-         * 
+         * Draw a circle
+         *
+         * @param x center of circule on X scale
+         * @param y center of circule on Y scale
          */
-        void drawCircle (int16_t x0, int16_t y0, int16_t r, uint16_t color);
-        
-        int m_height;
-        int m_width;
-        
-        uint8_t m_map[160 * 128 * 2];
+        void drawCircle (int16_t x, int16_t y, int16_t r, uint16_t color);
+
+        /**
+         * Set cursor for text message
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         */
+        void setCursor (int16_t x, int16_t y);
+
+        /**
+         * Set text color for the message
+         *
+         * @param textColor font color
+         * @param textBGColor background color
+         */
+        void setTextColor (uint16_t textColor, uint16_t textBGColor);
+
+        /**
+         * Set the size of the font
+         *
+         * @param size font size
+         */
+        void setTextSize (uint8_t size);
+
+        /**
+         * Wrap printed message.
+         *
+         * @param wrap true (0x1) or false (0x0)
+         */
+        void setTextWrap (uint8_t wrap);
+
+        int m_height; /**< Screen height */
+        int m_width; /**< Screen width */
+        int m_textSize; /**< Printed text size */
+        int m_textColor; /**< Printed text color */
+        int m_textBGColor; /**< Printed text background color */
+        int m_cursorX; /**< Cursor X coordinate */
+        int m_cursorY; /**< Cursor Y coordinate */
+        int m_wrap; /**< Wrapper flag (true or false) */
+
+        uint8_t * m_map; /**< Screens buffer */
+
+    protected:
+        const int16_t   WIDTH, HEIGHT;
+        const unsigned char * m_font;
     };
 }

src/st7735/license.txt

@@ -0,0 +1,24 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2012 Adafruit Industries.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

src/st7735/st7735.cxx

@@ -32,14 +32,14 @@
 
 using namespace upm;
 
-ST7735::ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst) : GFX (160, 128) {
+ST7735::ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst) : GFX (160, 128, m_map, font) {
     maa_init();
-    
+
     m_csLCD = csLCD;
     m_cSD   = cSD;
     m_rST   = rst;
     m_rS    = rs;
-    
+
     initModule ();
     configModule ();
 }
@@ -71,7 +71,7 @@ ST7735::~ST7735 () {
 void
 ST7735::initModule () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     m_height = 160;
     m_width  = 128;
 
@@ -86,13 +86,13 @@ ST7735::initModule () {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_cSD);
         exit (1);
     }
-    
+
     m_rSTPinCtx = maa_gpio_init (m_rST);
     if (m_rSTPinCtx == NULL) {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rST);
         exit (1);
     }
-    
+
     m_rSPinCtx = maa_gpio_init (m_rS);
     if (m_rSPinCtx == NULL) {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rS);
@@ -108,12 +108,12 @@ ST7735::initModule () {
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
     }
-    
+
     error = maa_gpio_dir (m_rSTPinCtx, MAA_GPIO_OUT);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
     }
-    
+
     error = maa_gpio_dir (m_rSPinCtx, MAA_GPIO_OUT);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -124,7 +124,7 @@ ST7735::initModule () {
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
     }
-    
+
     lcdCSOn ();
 }
 
@@ -140,7 +140,7 @@ ST7735::data (uint8_t value) {
     maa_spi_write (m_spi, value);
 }
 
-void 
+void
 ST7735::executeCMDList(const uint8_t *addr) {
     uint8_t  numCommands, numArgs;
     uint16_t ms;
@@ -165,45 +165,45 @@ ST7735::executeCMDList(const uint8_t *addr) {
     }
 }
 
-void 
+void
 ST7735::setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) {
     uint8_t colstart, rowstart;
     colstart  = rowstart = 0;
 
     write (ST7735_CASET);                       // Column addr set
-    
+
     rsHIGH ();
-    m_spiBuffer[0] = 0x00;              
+    m_spiBuffer[0] = 0x00;
     m_spiBuffer[1] = x0 + colstart;             // XSTART
     m_spiBuffer[2] = 0x00;
     m_spiBuffer[3] = x1 + colstart;             // XEND
     maa_spi_write_buf(m_spi, m_spiBuffer, 4);
-    
+
     write (ST7735_RASET);                       // Row addr set
-    
+
     rsHIGH ();
-    m_spiBuffer[0] = 0x00;              
+    m_spiBuffer[0] = 0x00;
     m_spiBuffer[1] = y0 + rowstart;             // YSTART
     m_spiBuffer[2] = 0x00;
     m_spiBuffer[3] = y1 + rowstart;             // YEND
     maa_spi_write_buf(m_spi, m_spiBuffer, 4);
-    
+
     write (ST7735_RAMWR);                       // write to RAM
 }
 
-void 
+void
 ST7735::drawPixel(int16_t x, int16_t y, uint16_t color) {
     if (MAA_SUCCESS != setPixel (x, y, color)) {
         return;
     }
-    
+
     refresh ();
 }
 
-void 
+void
 ST7735::refresh () {
     rsHIGH ();
-    
+
     int fragmentSize = m_height * m_width * 2 / 20;
     for (int fragment = 0; fragment < 20; fragment++) {
         maa_spi_write_buf(m_spi, &m_map[fragment * fragmentSize], fragmentSize);
@@ -215,72 +215,36 @@ ST7735::configModule() {
     rsHIGH ();
     lcdCSOff ();
     lcdCSOn ();
-    
+
     maa_gpio_write (m_rSTPinCtx, HIGH);
     usleep (500000);
     maa_gpio_write (m_rSTPinCtx, LOW);
     usleep (500000);
     maa_gpio_write (m_rSTPinCtx, HIGH);
     usleep (500000);
-    
+
     executeCMDList (Rcmd1);
     executeCMDList (Rcmd2red);
     executeCMDList (Rcmd3);
-    
+
     write (ST7735_MADCTL);
     data (0xC0);
-        
+
     setAddrWindow (0, 0, m_width - 1, m_height - 1);
-    
+
     fillScreen (ST7735_BLACK);
     refresh ();
 }
 
-void 
-ST7735::fill (int col, uint16_t* buff, int len) {
-    uint8_t colstart, rowstart;
-    uint8_t buf[len * 2];
-    
-    colstart = 0;
-
-    write (ST7735_CASET);                       // Column addr set
-    
-    rsHIGH ();
-    m_spiBuffer[0] = 0x00;              
-    m_spiBuffer[1] = col + 1;             // XSTART
-    m_spiBuffer[2] = 0x00;
-    m_spiBuffer[3] = col + 1;             // XEND
-    maa_spi_write_buf(m_spi, m_spiBuffer, 4);
-    
-    write (ST7735_RASET);                       // Row addr set
-    
-    rsHIGH ();
-    m_spiBuffer[0] = 0x00;              
-    m_spiBuffer[1] = 0x01;             // YSTART
-    m_spiBuffer[2] = 0x00;
-    m_spiBuffer[3] = 0x9F;             // YEND
-    maa_spi_write_buf(m_spi, m_spiBuffer, 4);
-    
-    write (ST7735_RAMWR);                       // write to RAM
-    
-    /*for (int idx = 0; idx < len; idx++) {
-        buf[idx*2] = buff[idx] >> 8;
-        buf[(idx*2)+1] = buff[idx];
-    }*/
-    
-    rsHIGH ();
-    maa_spi_write_buf(m_spi, (uint8_t *)buff, len * 2);
-}
-
 maa_result_t
 ST7735::lcdCSOn () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_csLCDPinCtx, LOW);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
     }
-    
+
     error = maa_gpio_write (m_cSDPinCtx, HIGH);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -292,7 +256,7 @@ ST7735::lcdCSOn () {
 maa_result_t
 ST7735::lcdCSOff () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_csLCDPinCtx, HIGH);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -304,12 +268,12 @@ ST7735::lcdCSOff () {
 maa_result_t
 ST7735::sdCSOn () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_cSDPinCtx, LOW);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
     }
-    
+
     error = maa_gpio_write (m_csLCDPinCtx, HIGH);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -321,7 +285,7 @@ ST7735::sdCSOn () {
 maa_result_t
 ST7735::sdCSOff () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_cSDPinCtx, HIGH);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -333,7 +297,7 @@ ST7735::sdCSOff () {
 maa_result_t
 ST7735::rsHIGH () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_rSPinCtx, HIGH);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);
@@ -345,7 +309,7 @@ ST7735::rsHIGH () {
 maa_result_t
 ST7735::rsLOW () {
     maa_result_t error = MAA_SUCCESS;
-    
+
     error = maa_gpio_write (m_rSPinCtx, LOW);
     if (error != MAA_SUCCESS) {
         maa_result_print (error);

src/st7735/st7735.h

@@ -2,10 +2,9 @@
  * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
  * Copyright (c) 2014 Intel Corporation.
  *
- * Credits to Adafrut.com
- * {Based on,Inspired from} original <libname> from <author>. See original license in <filepath>.
-
- * 
+ * Credits to Adafruit.
+ * Based on Adafruit ST7735 library, see original license in license.txt file.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -87,13 +86,13 @@
 #define ST7735_GMCTRN1      0xE1
 
 // Color definitions
-#define	ST7735_BLACK        0x0000
-#define	ST7735_BLUE         0x001F
-#define	ST7735_RED          0xF800
-#define	ST7735_GREEN        0x07E0
+#define ST7735_BLACK        0x0000
+#define ST7735_BLUE         0x001F
+#define ST7735_RED          0xF800
+#define ST7735_GREEN        0x07E0
 #define ST7735_CYAN         0x07FF
 #define ST7735_MAGENTA      0xF81F
-#define ST7735_YELLOW       0xFFE0  
+#define ST7735_YELLOW       0xFFE0
 #define ST7735_WHITE        0xFFFF
 
 #define HIGH                1
@@ -103,7 +102,7 @@
 
 namespace upm {
 
-static const uint8_t Bcmd[] = {                  
+static const uint8_t Bcmd[] = {
     // Initialization commands for 7735B screens
       18,                     // 18 commands in list:
     ST7735_SWRESET,   DELAY,  //  1: Software reset, no args, w/delay
@@ -189,7 +188,7 @@ static const uint8_t Bcmd[] = {
       0x00,                   //     Boost frequency
     ST7735_PWCTR4 , 2      ,  // 10: Power control, 2 args, no delay:
       0x8A,                   //     BCLK/2, Opamp current small & Medium low
-      0x2A,  
+      0x2A,
     ST7735_PWCTR5 , 2      ,  // 11: Power control, 2 args, no delay:
       0x8A, 0xEE,
     ST7735_VMCTR1 , 1      ,  // 12: Power control, 1 arg, no delay:
@@ -236,27 +235,285 @@ static const uint8_t Bcmd[] = {
 
 #define swap(a, b) { int16_t t = a; a = b; b = t; }
 
-
+const unsigned char font[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
+    0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
+    0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
+    0x18, 0x3C, 0x7E, 0x3C, 0x18,
+    0x1C, 0x57, 0x7D, 0x57, 0x1C,
+    0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
+    0x00, 0x18, 0x3C, 0x18, 0x00,
+    0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
+    0x00, 0x18, 0x24, 0x18, 0x00,
+    0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
+    0x30, 0x48, 0x3A, 0x06, 0x0E,
+    0x26, 0x29, 0x79, 0x29, 0x26,
+    0x40, 0x7F, 0x05, 0x05, 0x07,
+    0x40, 0x7F, 0x05, 0x25, 0x3F,
+    0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
+    0x7F, 0x3E, 0x1C, 0x1C, 0x08,
+    0x08, 0x1C, 0x1C, 0x3E, 0x7F,
+    0x14, 0x22, 0x7F, 0x22, 0x14,
+    0x5F, 0x5F, 0x00, 0x5F, 0x5F,
+    0x06, 0x09, 0x7F, 0x01, 0x7F,
+    0x00, 0x66, 0x89, 0x95, 0x6A,
+    0x60, 0x60, 0x60, 0x60, 0x60,
+    0x94, 0xA2, 0xFF, 0xA2, 0x94,
+    0x08, 0x04, 0x7E, 0x04, 0x08,
+    0x10, 0x20, 0x7E, 0x20, 0x10,
+    0x08, 0x08, 0x2A, 0x1C, 0x08,
+    0x08, 0x1C, 0x2A, 0x08, 0x08,
+    0x1E, 0x10, 0x10, 0x10, 0x10,
+    0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
+    0x30, 0x38, 0x3E, 0x38, 0x30,
+    0x06, 0x0E, 0x3E, 0x0E, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x5F, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x07, 0x00,
+    0x14, 0x7F, 0x14, 0x7F, 0x14,
+    0x24, 0x2A, 0x7F, 0x2A, 0x12,
+    0x23, 0x13, 0x08, 0x64, 0x62,
+    0x36, 0x49, 0x56, 0x20, 0x50,
+    0x00, 0x08, 0x07, 0x03, 0x00,
+    0x00, 0x1C, 0x22, 0x41, 0x00,
+    0x00, 0x41, 0x22, 0x1C, 0x00,
+    0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
+    0x08, 0x08, 0x3E, 0x08, 0x08,
+    0x00, 0x80, 0x70, 0x30, 0x00,
+    0x08, 0x08, 0x08, 0x08, 0x08,
+    0x00, 0x00, 0x60, 0x60, 0x00,
+    0x20, 0x10, 0x08, 0x04, 0x02,
+    0x3E, 0x51, 0x49, 0x45, 0x3E,
+    0x00, 0x42, 0x7F, 0x40, 0x00,
+    0x72, 0x49, 0x49, 0x49, 0x46,
+    0x21, 0x41, 0x49, 0x4D, 0x33,
+    0x18, 0x14, 0x12, 0x7F, 0x10,
+    0x27, 0x45, 0x45, 0x45, 0x39,
+    0x3C, 0x4A, 0x49, 0x49, 0x31,
+    0x41, 0x21, 0x11, 0x09, 0x07,
+    0x36, 0x49, 0x49, 0x49, 0x36,
+    0x46, 0x49, 0x49, 0x29, 0x1E,
+    0x00, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x40, 0x34, 0x00, 0x00,
+    0x00, 0x08, 0x14, 0x22, 0x41,
+    0x14, 0x14, 0x14, 0x14, 0x14,
+    0x00, 0x41, 0x22, 0x14, 0x08,
+    0x02, 0x01, 0x59, 0x09, 0x06,
+    0x3E, 0x41, 0x5D, 0x59, 0x4E,
+    0x7C, 0x12, 0x11, 0x12, 0x7C,
+    0x7F, 0x49, 0x49, 0x49, 0x36,
+    0x3E, 0x41, 0x41, 0x41, 0x22,
+    0x7F, 0x41, 0x41, 0x41, 0x3E,
+    0x7F, 0x49, 0x49, 0x49, 0x41,
+    0x7F, 0x09, 0x09, 0x09, 0x01,
+    0x3E, 0x41, 0x41, 0x51, 0x73,
+    0x7F, 0x08, 0x08, 0x08, 0x7F,
+    0x00, 0x41, 0x7F, 0x41, 0x00,
+    0x20, 0x40, 0x41, 0x3F, 0x01,
+    0x7F, 0x08, 0x14, 0x22, 0x41,
+    0x7F, 0x40, 0x40, 0x40, 0x40,
+    0x7F, 0x02, 0x1C, 0x02, 0x7F,
+    0x7F, 0x04, 0x08, 0x10, 0x7F,
+    0x3E, 0x41, 0x41, 0x41, 0x3E,
+    0x7F, 0x09, 0x09, 0x09, 0x06,
+    0x3E, 0x41, 0x51, 0x21, 0x5E,
+    0x7F, 0x09, 0x19, 0x29, 0x46,
+    0x26, 0x49, 0x49, 0x49, 0x32,
+    0x03, 0x01, 0x7F, 0x01, 0x03,
+    0x3F, 0x40, 0x40, 0x40, 0x3F,
+    0x1F, 0x20, 0x40, 0x20, 0x1F,
+    0x3F, 0x40, 0x38, 0x40, 0x3F,
+    0x63, 0x14, 0x08, 0x14, 0x63,
+    0x03, 0x04, 0x78, 0x04, 0x03,
+    0x61, 0x59, 0x49, 0x4D, 0x43,
+    0x00, 0x7F, 0x41, 0x41, 0x41,
+    0x02, 0x04, 0x08, 0x10, 0x20,
+    0x00, 0x41, 0x41, 0x41, 0x7F,
+    0x04, 0x02, 0x01, 0x02, 0x04,
+    0x40, 0x40, 0x40, 0x40, 0x40,
+    0x00, 0x03, 0x07, 0x08, 0x00,
+    0x20, 0x54, 0x54, 0x78, 0x40,
+    0x7F, 0x28, 0x44, 0x44, 0x38,
+    0x38, 0x44, 0x44, 0x44, 0x28,
+    0x38, 0x44, 0x44, 0x28, 0x7F,
+    0x38, 0x54, 0x54, 0x54, 0x18,
+    0x00, 0x08, 0x7E, 0x09, 0x02,
+    0x18, 0xA4, 0xA4, 0x9C, 0x78,
+    0x7F, 0x08, 0x04, 0x04, 0x78,
+    0x00, 0x44, 0x7D, 0x40, 0x00,
+    0x20, 0x40, 0x40, 0x3D, 0x00,
+    0x7F, 0x10, 0x28, 0x44, 0x00,
+    0x00, 0x41, 0x7F, 0x40, 0x00,
+    0x7C, 0x04, 0x78, 0x04, 0x78,
+    0x7C, 0x08, 0x04, 0x04, 0x78,
+    0x38, 0x44, 0x44, 0x44, 0x38,
+    0xFC, 0x18, 0x24, 0x24, 0x18,
+    0x18, 0x24, 0x24, 0x18, 0xFC,
+    0x7C, 0x08, 0x04, 0x04, 0x08,
+    0x48, 0x54, 0x54, 0x54, 0x24,
+    0x04, 0x04, 0x3F, 0x44, 0x24,
+    0x3C, 0x40, 0x40, 0x20, 0x7C,
+    0x1C, 0x20, 0x40, 0x20, 0x1C,
+    0x3C, 0x40, 0x30, 0x40, 0x3C,
+    0x44, 0x28, 0x10, 0x28, 0x44,
+    0x4C, 0x90, 0x90, 0x90, 0x7C,
+    0x44, 0x64, 0x54, 0x4C, 0x44,
+    0x00, 0x08, 0x36, 0x41, 0x00,
+    0x00, 0x00, 0x77, 0x00, 0x00,
+    0x00, 0x41, 0x36, 0x08, 0x00,
+    0x02, 0x01, 0x02, 0x04, 0x02,
+    0x3C, 0x26, 0x23, 0x26, 0x3C,
+    0x1E, 0xA1, 0xA1, 0x61, 0x12,
+    0x3A, 0x40, 0x40, 0x20, 0x7A,
+    0x38, 0x54, 0x54, 0x55, 0x59,
+    0x21, 0x55, 0x55, 0x79, 0x41,
+    0x21, 0x54, 0x54, 0x78, 0x41,
+    0x21, 0x55, 0x54, 0x78, 0x40,
+    0x20, 0x54, 0x55, 0x79, 0x40,
+    0x0C, 0x1E, 0x52, 0x72, 0x12,
+    0x39, 0x55, 0x55, 0x55, 0x59,
+    0x39, 0x54, 0x54, 0x54, 0x59,
+    0x39, 0x55, 0x54, 0x54, 0x58,
+    0x00, 0x00, 0x45, 0x7C, 0x41,
+    0x00, 0x02, 0x45, 0x7D, 0x42,
+    0x00, 0x01, 0x45, 0x7C, 0x40,
+    0xF0, 0x29, 0x24, 0x29, 0xF0,
+    0xF0, 0x28, 0x25, 0x28, 0xF0,
+    0x7C, 0x54, 0x55, 0x45, 0x00,
+    0x20, 0x54, 0x54, 0x7C, 0x54,
+    0x7C, 0x0A, 0x09, 0x7F, 0x49,
+    0x32, 0x49, 0x49, 0x49, 0x32,
+    0x32, 0x48, 0x48, 0x48, 0x32,
+    0x32, 0x4A, 0x48, 0x48, 0x30,
+    0x3A, 0x41, 0x41, 0x21, 0x7A,
+    0x3A, 0x42, 0x40, 0x20, 0x78,
+    0x00, 0x9D, 0xA0, 0xA0, 0x7D,
+    0x39, 0x44, 0x44, 0x44, 0x39,
+    0x3D, 0x40, 0x40, 0x40, 0x3D,
+    0x3C, 0x24, 0xFF, 0x24, 0x24,
+    0x48, 0x7E, 0x49, 0x43, 0x66,
+    0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
+    0xFF, 0x09, 0x29, 0xF6, 0x20,
+    0xC0, 0x88, 0x7E, 0x09, 0x03,
+    0x20, 0x54, 0x54, 0x79, 0x41,
+    0x00, 0x00, 0x44, 0x7D, 0x41,
+    0x30, 0x48, 0x48, 0x4A, 0x32,
+    0x38, 0x40, 0x40, 0x22, 0x7A,
+    0x00, 0x7A, 0x0A, 0x0A, 0x72,
+    0x7D, 0x0D, 0x19, 0x31, 0x7D,
+    0x26, 0x29, 0x29, 0x2F, 0x28,
+    0x26, 0x29, 0x29, 0x29, 0x26,
+    0x30, 0x48, 0x4D, 0x40, 0x20,
+    0x38, 0x08, 0x08, 0x08, 0x08,
+    0x08, 0x08, 0x08, 0x08, 0x38,
+    0x2F, 0x10, 0xC8, 0xAC, 0xBA,
+    0x2F, 0x10, 0x28, 0x34, 0xFA,
+    0x00, 0x00, 0x7B, 0x00, 0x00,
+    0x08, 0x14, 0x2A, 0x14, 0x22,
+    0x22, 0x14, 0x2A, 0x14, 0x08,
+    0xAA, 0x00, 0x55, 0x00, 0xAA,
+    0xAA, 0x55, 0xAA, 0x55, 0xAA,
+    0x00, 0x00, 0x00, 0xFF, 0x00,
+    0x10, 0x10, 0x10, 0xFF, 0x00,
+    0x14, 0x14, 0x14, 0xFF, 0x00,
+    0x10, 0x10, 0xFF, 0x00, 0xFF,
+    0x10, 0x10, 0xF0, 0x10, 0xF0,
+    0x14, 0x14, 0x14, 0xFC, 0x00,
+    0x14, 0x14, 0xF7, 0x00, 0xFF,
+    0x00, 0x00, 0xFF, 0x00, 0xFF,
+    0x14, 0x14, 0xF4, 0x04, 0xFC,
+    0x14, 0x14, 0x17, 0x10, 0x1F,
+    0x10, 0x10, 0x1F, 0x10, 0x1F,
+    0x14, 0x14, 0x14, 0x1F, 0x00,
+    0x10, 0x10, 0x10, 0xF0, 0x00,
+    0x00, 0x00, 0x00, 0x1F, 0x10,
+    0x10, 0x10, 0x10, 0x1F, 0x10,
+    0x10, 0x10, 0x10, 0xF0, 0x10,
+    0x00, 0x00, 0x00, 0xFF, 0x10,
+    0x10, 0x10, 0x10, 0x10, 0x10,
+    0x10, 0x10, 0x10, 0xFF, 0x10,
+    0x00, 0x00, 0x00, 0xFF, 0x14,
+    0x00, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x1F, 0x10, 0x17,
+    0x00, 0x00, 0xFC, 0x04, 0xF4,
+    0x14, 0x14, 0x17, 0x10, 0x17,
+    0x14, 0x14, 0xF4, 0x04, 0xF4,
+    0x00, 0x00, 0xFF, 0x00, 0xF7,
+    0x14, 0x14, 0x14, 0x14, 0x14,
+    0x14, 0x14, 0xF7, 0x00, 0xF7,
+    0x14, 0x14, 0x14, 0x17, 0x14,
+    0x10, 0x10, 0x1F, 0x10, 0x1F,
+    0x14, 0x14, 0x14, 0xF4, 0x14,
+    0x10, 0x10, 0xF0, 0x10, 0xF0,
+    0x00, 0x00, 0x1F, 0x10, 0x1F,
+    0x00, 0x00, 0x00, 0x1F, 0x14,
+    0x00, 0x00, 0x00, 0xFC, 0x14,
+    0x00, 0x00, 0xF0, 0x10, 0xF0,
+    0x10, 0x10, 0xFF, 0x10, 0xFF,
+    0x14, 0x14, 0x14, 0xFF, 0x14,
+    0x10, 0x10, 0x10, 0x1F, 0x00,
+    0x00, 0x00, 0x00, 0xF0, 0x10,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
+    0xFF, 0xFF, 0xFF, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xFF, 0xFF,
+    0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
+    0x38, 0x44, 0x44, 0x38, 0x44,
+    0x7C, 0x2A, 0x2A, 0x3E, 0x14,
+    0x7E, 0x02, 0x02, 0x06, 0x06,
+    0x02, 0x7E, 0x02, 0x7E, 0x02,
+    0x63, 0x55, 0x49, 0x41, 0x63,
+    0x38, 0x44, 0x44, 0x3C, 0x04,
+    0x40, 0x7E, 0x20, 0x1E, 0x20,
+    0x06, 0x02, 0x7E, 0x02, 0x02,
+    0x99, 0xA5, 0xE7, 0xA5, 0x99,
+    0x1C, 0x2A, 0x49, 0x2A, 0x1C,
+    0x4C, 0x72, 0x01, 0x72, 0x4C,
+    0x30, 0x4A, 0x4D, 0x4D, 0x30,
+    0x30, 0x48, 0x78, 0x48, 0x30,
+    0xBC, 0x62, 0x5A, 0x46, 0x3D,
+    0x3E, 0x49, 0x49, 0x49, 0x00,
+    0x7E, 0x01, 0x01, 0x01, 0x7E,
+    0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
+    0x44, 0x44, 0x5F, 0x44, 0x44,
+    0x40, 0x51, 0x4A, 0x44, 0x40,
+    0x40, 0x44, 0x4A, 0x51, 0x40,
+    0x00, 0x00, 0xFF, 0x01, 0x03,
+    0xE0, 0x80, 0xFF, 0x00, 0x00,
+    0x08, 0x08, 0x6B, 0x6B, 0x08,
+    0x36, 0x12, 0x36, 0x24, 0x36,
+    0x06, 0x0F, 0x09, 0x0F, 0x06,
+    0x00, 0x00, 0x18, 0x18, 0x00,
+    0x00, 0x00, 0x10, 0x10, 0x00,
+    0x30, 0x40, 0xFF, 0x01, 0x01,
+    0x00, 0x1F, 0x01, 0x01, 0x1E,
+    0x00, 0x19, 0x1D, 0x17, 0x12,
+    0x00, 0x3C, 0x3C, 0x3C, 0x3C,
+    0x00, 0x00, 0x00, 0x00, 0x00
+};
 
 /**
- * @brief C++ API for NRF24l01 transceiver module
+ * @brief C++ API for ST7735 SPI LCD module
  *
- * This file defines the NRF24l01 C++ interface for libnrf24l01
+ * This file defines the ST7735 C++ interface for libst7735
  *
- * @snippet nrf_receiver.cxx Interesting
- * @snippet nrf_transmitter.cxx Interesting
+ * @snippet st7735.cxx Interesting
  */
 class ST7735 : public GFX {
     public:
         /**
-         * Instanciates a NRF24l01 object
+         * Instanciates a ST7735 object
          *
-         * @param cs chip select pin
+         * @param csLCD LCD chip select pin
+         * @param cSD SD card chip select pin
+         * @param rs data/command pin
+         * @param rst reset pin
          */
         ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst);
 
         /**
-         * NRF24l01 object destructor
+         * ST7735 object destructor
          */
         ~ST7735 ();
 
@@ -269,76 +526,92 @@ class ST7735 : public GFX {
         }
 
         /**
-         * 
+         * Initialize the modules GPIOs
          */
         void initModule ();
 
         /**
-         * 
+         * Configure the chip via SPI interface
          */
         void configModule ();
-        
+
         /**
-         * 
+         * Send command to SPI bus (rs must be LOW)
+         *
+         * @param value command number
          */
         void write (uint8_t value);
-        
+
         /**
-         * 
+         * Send data to SPI bus (rs must be HIGH)
+         *
+         * @param value command number
          */
         void data (uint8_t value);
-        
+
         /**
-         * 
+         * Execute set of commands and data
+         *
+         * @param *addr pointer to start of the commands/data section
          */
         void executeCMDList (const uint8_t *addr);
-        
+
         /**
-         * 
+         * Set the window size inside the screen where the pixels data
+         * will be written.
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
          */
         void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1);
-        
+
         /**
-         * 
+         * Send pixel collor (RGB) to the chip.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color rgb (16bit) color (R[0-4], G[5-10], B[11-15])
          */
         void drawPixel (int16_t x, int16_t y, uint16_t color);
-        
+
         /**
-         * 
+         * Copy the buffer to the chip via SPI interface.
          */
         void refresh ();
-        
+
         /**
-         * 
+         * LCD chip select LOW.
          */
         maa_result_t lcdCSOn ();
 
         /**
-         * 
+         * LCD chip select HIGH.
          */
         maa_result_t lcdCSOff ();
 
         /**
-         * 
+         * CD card chip select LOW.
          */
         maa_result_t sdCSOn ();
 
         /**
-         * 
+         * CD card select HIGH.
          */
         maa_result_t sdCSOff ();
-        
+
         /**
-         * 
+         * Data select HIGH.
          */
         maa_result_t rsHIGH ();
 
         /**
-         * 
+         * Data select LOW.
          */
         maa_result_t rsLOW ();
-        
-        void fill (int col, uint16_t* buff, int len);
+
+        uint8_t m_map[160 * 128 * 2]; /**< Screens buffer */
     private:
         maa_spi_context      m_spi;
         uint8_t              m_csLCD;
@@ -350,8 +623,8 @@ class ST7735 : public GFX {
         maa_gpio_context     m_cSDPinCtx;
         maa_gpio_context     m_rSTPinCtx;
         maa_gpio_context     m_rSPinCtx;
-                
-        uint8_t              m_spiBuffer[128];
+
+        uint8_t              m_spiBuffer[32];
 
         std::string          m_name;
 };