Added references to old Arduino TFT code and updated source code to new Adafruit API

Author: j54n1n

src/LcdScreen.cpp

@@ -29,22 +29,17 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include "TFT.h"
+#include "LcdScreen.h"
 
 #if ARDUINO_AVR_ESPLORA
-TFT EsploraTFT(7, 0, 1);
+LcdScreen EsploraTFT(7, 0, 1);
 #endif
 
-TFT::TFT(uint8_t CS, uint8_t RS, uint8_t RST) 
-  : Adafruit_ST7735(CS, RS, RST)
-{
-  // as we already know the orientation (landscape, therefore rotated),
-  // set default width and height without need to call begin() first.
-  _width = ST7735_TFTHEIGHT;
-  _height = ST7735_TFTWIDTH;
-}
+LcdScreen::LcdScreen(uint8_t CS, uint8_t RS, uint8_t RST)
+  : Arduino_ILI9163(CS, RS, RST)
+{ }
 
-void TFT::begin() {
+void LcdScreen::begin() {
 //initR(INITR_REDTAB);
   initG();
   setRotation(1);

src/LcdScreen.h

@@ -29,30 +29,215 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef _ARDUINO_TFT_H
-#define _ARDUINO_TFT_H
+#ifndef _ARDUINO_LCD_SCREEN_H
+#define _ARDUINO_LCD_SCREEN_H
 
-#include "Arduino.h"
-#include "utility/Adafruit_GFX.h"
-#include "utility/Adafruit_ST7735.h"
+#include <Arduino.h>
+#include <Adafruit_GFX.h>
+#include "utility/Arduino_ILI9163.h"
 
-/// The Arduino LCD is a ST7735-based device.
+/*
+ * This library can work with or without the presence of an SD
+ * reading library (to load images). At the moment, only the
+ * Arduino SD library is supported; it is included in
+ * standard Arduino libraries.
+ * 
+ * The presence of the SD library is detected by looking at the
+ * __SD_H__ preprocessor variable, defined into 
+ * Arduino SD library to avoid double inclusion. This means
+ * that in order to use the image-related API of Adafruit_GFX,
+ * SD.h *must* be included before Adafruit_GFX.
+ * 
+ * The bottom part of this include file contains the actual image
+ * loading code; if it was in a separate .cpp file, there were no
+ * way to check if the SD library was present or not.
+ * 
+ * A partial solution was to include SD.h anyway, see if that works
+ * (i.e. it is found in the include search path) and act accordingly.
+ * But this solution relied on the preprocessor to issue only a
+ * warning when an include file is not found. Avr-gcc, used for
+ * Arduino 8-bit MCUs, does that, but the standard gcc-4.4, used for
+ * Arduino Due, issues a fatal error and stops compilation.
+ * 
+ * The best solution so far is to put the code here. It works if this
+ * include is used only in one .cpp file in the build (this is the
+ * case of most Arduino sketches); if used in multiple .cpp files,
+ * the linker may complain about duplicate definitions.
+ * 
+ */
+
+#if defined(__SD_H__)  // Arduino SD library
+ #include "utility/PImage.h"
+#else
+ #warning "The SD library was not found. loadImage() and image() won't be supported."
+#endif
+
+/// The Arduino LCD is a ILI9163-based device.
 /// By default, it is mounted horizontally.
-/// TFT class follows the convention of other
+/// LcdScreen class follows the convention of other
 /// Arduino library classes by adding a begin() method
 /// to be called in the setup() routine.
 /// @author Enrico Gueli <[email protected]>
-class TFT : public Adafruit_ST7735 {
+class LcdScreen : public Arduino_ILI9163 {
 public:
-  TFT(uint8_t CS, uint8_t RS, uint8_t RST);
+  LcdScreen(uint8_t CS, uint8_t RS, uint8_t RST);
 
   void begin();  
+
+#if defined(__SD_H__)  // Arduino SD library
+  PImage loadImage(const char * fileName) { return PImage::loadImage(fileName); }
+
+  void image(PImage & img, uint16_t x, uint16_t y);
+#endif
 };
 
 /// Esplora boards have hard-wired connections with
 /// the Arduino LCD if mounted on the onboard connector.
 #if ARDUINO_AVR_ESPLORA // are we building for Esplora?
-extern TFT EsploraTFT;
+extern LcdScreen EsploraTFT;
 #endif
 
-#endif // _ARDUINO_TFT_H
+#if defined(__SD_H__)  // Arduino SD library
+
+#define BUFFPIXEL 20
+
+void LcdScreen::image(PImage & img, uint16_t x, uint16_t y) {
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0;
+  uint8_t  sdbuffer[3*BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+
+  // Crop area to be loaded
+  w = img._bmpWidth;
+  h = img._bmpHeight;
+  if((x+w-1) >= width())  w = width()  - x;
+  if((y+h-1) >= height()) h = height() - y;
+
+  //// Set TFT address window to clipped image bounds
+  //setAddrWindow(x, y, x+w-1, y+h-1);
+  
+  for (row=0; row<h; row++) { // For each scanline...
+    // Seek to start of scan line.  It might seem labor-
+    // intensive to be doing this on every line, but this
+    // method covers a lot of gritty details like cropping
+    // and scanline padding.  Also, the seek only takes
+    // place if the file position actually needs to change
+    // (avoids a lot of cluster math in SD library).
+    if(img._flip) // Bitmap is stored bottom-to-top order (normal BMP)
+      pos = img._bmpImageoffset + (img._bmpHeight - 1 - row) * img._rowSize;
+    else     // Bitmap is stored top-to-bottom
+      pos = img._bmpImageoffset + row * img._rowSize;
+    if(img._bmpFile.position() != pos) { // Need seek?
+      img._bmpFile.seek(pos);
+      buffidx = sizeof(sdbuffer); // Force buffer reload
+    }
+
+    for (col=0; col<w; col++) { // For each pixel...
+      // Time to read more pixel data?
+      if (buffidx >= sizeof(sdbuffer)) { // Indeed
+        img._bmpFile.read(sdbuffer, sizeof(sdbuffer));
+        buffidx = 0; // Set index to beginning
+      }
+
+      // Convert pixel from BMP to TFT format, push to display
+      b = sdbuffer[buffidx++];
+      g = sdbuffer[buffidx++];
+      r = sdbuffer[buffidx++];
+      //pushColor(tft.Color565(r,g,b));
+      drawPixel(x + col, y + row, Color565(r, g, b));
+      
+    } // end pixel
+  } // end scanline
+
+}
+
+
+
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+
+uint16_t PImage::read16(File f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t PImage::read32(File f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+
+PImage PImage::loadImage(const char * fileName) {
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  bool     flip    = true;        // BMP is stored bottom-to-top
+
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(fileName)) == NULL) {
+    Serial.print(F("loadImage: file not found: "));
+    Serial.println(fileName);
+    return PImage(); // load error
+  }
+  
+  
+  
+  // Parse BMP header
+  if(read16(bmpFile) != 0x4D42) { // BMP signature
+    Serial.println(F("loadImage: file doesn't look like a BMP"));
+    return PImage();
+  }
+  
+  Serial.print(F("File size: ")); Serial.println(read32(bmpFile));
+  (void)read32(bmpFile); // Read & ignore creator bytes
+  bmpImageoffset = read32(bmpFile); // Start of image data
+  Serial.print(F("Image Offset: ")); Serial.println(bmpImageoffset, DEC);
+  // Read DIB header
+  Serial.print(F("Header size: ")); Serial.println(read32(bmpFile));
+  bmpWidth  = read32(bmpFile);
+  bmpHeight = read32(bmpFile);
+  if(read16(bmpFile) != 1) { // # planes -- must be '1'
+    Serial.println(F("loadImage: invalid n. of planes"));
+    return PImage();
+  }
+  
+  bmpDepth = read16(bmpFile); // bits per pixel
+  Serial.print(F("Bit Depth: ")); Serial.println(bmpDepth);
+  if((bmpDepth != 24) || (read32(bmpFile) != 0)) { // 0 = uncompressed {
+    Serial.println(F("loadImage: invalid pixel format"));
+    return PImage();
+  }
+
+  Serial.print(F("Image size: "));
+  Serial.print(bmpWidth);
+  Serial.print('x');
+  Serial.println(bmpHeight);
+
+  // BMP rows are padded (if needed) to 4-byte boundary
+  rowSize = (bmpWidth * 3 + 3) & ~3;
+
+  // If bmpHeight is negative, image is in top-down order.
+  // This is not canon but has been observed in the wild.
+  if(bmpHeight < 0) {
+    bmpHeight = -bmpHeight;
+    flip      = false;
+  }
+  
+  return PImage(bmpFile, bmpWidth, bmpHeight, bmpDepth, bmpImageoffset, rowSize, flip);
+}
+
+#endif // __SD_H__
+
+#endif // _ARDUINO_LCD_SCREEN_H

src/utility/Arduino_ILI9163.cpp

@@ -278,7 +278,7 @@ void Arduino_ILI9163::commonInit(const uint8_t *cmdList) {
 
 
 // Initialization for ILI9163C screens
-void LcdScreen::initG(void) {
+void Arduino_ILI9163::initG(void) {
   commonInit(Gcmd);
 }
 

src/utility/PImage.h

@@ -4,6 +4,7 @@
 #define _PIMAGE_H
 
 class Adafruit_GFX;
+class LcdScreen;
 
 #if defined(__SD_H__)  // Arduino SD library
 
@@ -31,7 +32,7 @@ class PImage {
   int height() { return _bmpHeight; }
 
 private:
-  friend class Adafruit_GFX;
+  friend class LcdScreen;
 
   File _bmpFile;
   int  _bmpWidth, _bmpHeight;   // W+H in pixels