Initial ESP8266 HW SPI implementation

ILI9341 lib as a client for SPI lib

libraries/TFT_Touch_Shield_V2/examples/drawCircle/drawCircle.ino

@@ -0,0 +1,32 @@
+/*  Demo of draw circle's APP
+    drawCircle(int poX, int poY, int r,INT16U color);
+    fillCircle(int poX, int poY, int r,INT16U color);
+*/
+
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+void setup()
+{
+    TFT_BL_ON;                                          //turn on the background light 
+    
+    Tft.TFTinit();                                      //init TFT library             
+
+    Tft.drawCircle(100, 100, 30,YELLOW);                //center: (100, 100), r = 30 ,color : YELLOW              
+    
+    Tft.drawCircle(100, 200, 40,CYAN);                  // center: (100, 200), r = 10 ,color : CYAN  
+    
+    Tft.fillCircle(200, 100, 30,RED);                   //center: (200, 100), r = 30 ,color : RED    
+    
+    Tft.fillCircle(200, 200, 30,BLUE);                  //center: (200, 200), r = 30 ,color : BLUE                 
+}
+
+void loop()
+{
+
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/drawLines/drawLines.ino

@@ -0,0 +1,31 @@
+/*  Demo of draw line's APP
+    drawLine(unsigned int x0,unsigned int y0,unsigned int x1,unsigned int y1,unsigned int color);
+    drawVerticalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color);
+    drawHorizontalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color);
+*/
+
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+void setup()
+{
+    TFT_BL_ON;                                  // turn on the background light
+    Tft.TFTinit();                              //init TFT library
+
+    Tft.drawLine(0,0,239,319,RED);              //start: (0, 0) end: (239, 319), color : RED
+   
+    Tft.drawVerticalLine(60,100,100,GREEN);     // Draw a vertical line
+                                                // start: (60, 100) length: 100 color: green
+                                            
+    Tft.drawHorizontalLine(30,60,150,BLUE);     //Draw a horizontal line
+                                                //start: (30, 60), high: 150, color: blue
+}
+
+void loop()
+{
+  
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/drawNumber/drawNumber.ino

@@ -0,0 +1,40 @@
+/*  draw number's APP
+    drawNumber(long long_num,INT16U poX, INT16U poY,INT16U size,INT16U fgcolor);
+    drawFloat(float floatNumber,INT8U decimal,INT16U poX, INT16U poY,INT16U size,INT16U fgcolor);
+    drawFloat(float floatNumber,INT16U poX, INT16U poY,INT16U size,INT16U fgcolor);
+*/
+
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+void setup()
+{
+    TFT_BL_ON;                                      // turn on the background light
+    
+    Tft.TFTinit();                                  // init TFT library
+    
+    Tft.drawNumber(1024, 0, 0, 1, RED);             // draw a integer: 1024, Location: (0, 0),  size: 1, color: RED
+    
+    Tft.drawNumber(1024, 0, 20, 2, BLUE);           // draw a integer: 1024, Location: (0, 20), size: 2, color: BLUE
+    
+    Tft.drawNumber(1024, 0, 50, 3, GREEN);          // draw a integer: 1024, Location: (0, 50), size: 3, color: GREEN
+    
+    Tft.drawNumber(1024, 0, 90, 4, BLUE);           // draw a integer: 1024, Location: (0, 90), size:4, color: BLUE
+    
+    Tft.drawFloat(1.2345, 0, 150, 4, YELLOW);       // draw a float number: 1.2345, Location: (0, 150), size: 4, color: YELLOW
+    
+    Tft.drawFloat(1.2345, 2, 0, 200, 4, BLUE);      // draw a float number: 1.2345: Location: (0, 200), size: 4, decimal: 2, color: BLUE
+    
+    Tft.drawFloat(1.2345, 4, 0, 250, 4, RED);       // draw a float number: 1.2345 Location: (0, 250), size: 4, decimal: 4, color: RED
+    
+}
+
+void loop()
+{
+  
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/drawRectangle/drawRectangle.ino

@@ -0,0 +1,26 @@
+/*  Draw Boxes - Demonstrate drawRectangle and fillRectangle
+    fillScreen(INT16U XL,INT16U XR,INT16U YU,INT16U YD,INT16U color);
+    fillRectangle(INT16U poX, INT16U poY, INT16U length, INT16U width, INT16U color);
+    drawRectangle(INT16U poX, INT16U poY, INT16U length,INT16U width,INT16U color);
+*/
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+void setup()
+{
+    TFT_BL_ON;      // turn on the background light
+    Tft.TFTinit();  // init TFT library
+
+    Tft.fillScreen(80, 160, 50, 150,RED);
+    Tft.fillRectangle(30, 120, 100,65,YELLOW);
+    Tft.drawRectangle(100, 170, 120,60,BLUE);
+}
+
+void loop()
+{
+  
+}
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/paint/paint.ino

@@ -0,0 +1,55 @@
+// Paint application - Demonstate both TFT and Touch Screen
+#include <stdint.h>
+#include <SeeedTouchScreen.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+int ColorPaletteHigh = 30;
+int color = WHITE;  //Paint brush color
+unsigned int colors[8] = {BLACK, RED, GREEN, BLUE, CYAN, YELLOW, WHITE, GRAY1};
+
+// For better pressure precision, we need to know the resistance
+// between X+ and X- Use any multimeter to read it
+// The 2.8" TFT Touch shield has 300 ohms across the X plate
+
+TouchScreen ts = TouchScreen(XP, YP, XM, YM); //init TouchScreen port pins
+
+void setup()
+{
+    Tft.TFTinit();  //init TFT library
+    Serial.begin(115200);
+    //Draw the pallet
+    for(int i = 0; i<8; i++)
+    {
+        Tft.fillRectangle(i*30, 0, 30, ColorPaletteHigh, colors[i]);
+    }
+}
+
+void loop()
+{
+    // a point object holds x y and z coordinates.
+    Point p = ts.getPoint();
+
+    //map the ADC value read to into pixel co-ordinates
+
+    p.x = map(p.x, TS_MINX, TS_MAXX, 0, 240);
+    p.y = map(p.y, TS_MINY, TS_MAXY, 0, 320);
+
+    // we have some minimum pressure we consider 'valid'
+    // pressure of 0 means no pressing!
+
+    if (p.z > __PRESURE) {
+        // Detect  paint brush color change
+        if(p.y < ColorPaletteHigh+2)
+        {
+            color = colors[p.x/30];
+        }
+        else
+        {
+            Tft.fillCircle(p.x,p.y,2,color);
+        }
+    }
+}
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/shapes/shapes.ino

@@ -0,0 +1,23 @@
+// Draw Boxes - Demonstrate drawRectangle and fillRectangle
+
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+void setup()
+{
+    TFT_BL_ON;                                          // turn on the background light
+    Tft.TFTinit();                                      // init TFT library
+}
+
+void loop()
+{
+    for(int r=0;r<115;r=r+2)                            //set r : 0--115
+    {
+        Tft.drawCircle(119,160,r,random(0xFFFF));       //draw circle, center:(119, 160), color: random
+    }
+    delay(10);
+}
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

libraries/TFT_Touch_Shield_V2/examples/text/text.ino

@@ -0,0 +1,35 @@
+/*  draw text's APP
+    drawChar(INT8U ascii,INT16U poX, INT16U poY,INT16U size, INT16U fgcolor);
+    drawString(char *string,INT16U poX, INT16U poY,INT16U size,INT16U fgcolor);
+*/
+
+#include <stdint.h>
+#include <TFTv2.h>
+#include <SPI.h>
+
+void setup()
+{
+    TFT_BL_ON;      // turn on the background light
+    Tft.TFTinit();  // init TFT library
+    
+    Tft.drawChar('S',0,0,1,RED);                // draw char: 'S', (0, 0), size: 1, color: RED
+    
+    Tft.drawChar('E',10,10,2,BLUE);             // draw char: 'E', (10, 10), size: 2, color: BLUE
+    
+    Tft.drawChar('E',20,40,3,GREEN);            // draw char: 'E', (20, 40), size: 3, color: GREEN
+    
+    Tft.drawChar('E',30,80,4,YELLOW);           // draw char: 'E', (30, 80), size: 4, color: YELLOW
+    
+    Tft.drawChar('D',40,120,4,YELLOW);          // draw char: 'D', (40, 120), size: 4, color: YELLOW
+    
+    Tft.drawString("Hello",0,180,3,CYAN);       // draw string: "hello", (0, 180), size: 3, color: CYAN
+    
+    Tft.drawString("World!!",60,220,4,WHITE);    // draw string: "world!!", (80, 230), size: 4, color: WHITE
+    
+
+}
+
+void loop()
+{
+  
+}

libraries/TFT_Touch_Shield_V2/examples/tftbmp/tftbmp.ino

@@ -0,0 +1,235 @@
+/*
+  TFT Touch Shield 2.0 examples - tftbmp
+  
+  loovee
+  2013-1-21
+  
+  this demo can show specified bmp file in root Directory of SD card
+  please ensure that your image file is 320x240 size. 
+
+  change __Gnfile_num and __Gsbmp_files to display your image
+*/
+
+#include <SD.h>
+#include <SPI.h>
+#include <Streaming.h>
+
+#include "TFTv2.h"
+
+#define MAX_BMP         10                      // bmp file num
+#define FILENAME_LEN    20                      // max file name length
+
+
+const int PIN_SD_CS = 4;                        // pin of sd card
+
+const int __Gnbmp_height = 320;                 // bmp hight
+const int __Gnbmp_width  = 240;                 // bmp width
+
+unsigned char __Gnbmp_image_offset  = 0;        // offset
+
+
+int __Gnfile_num = 3;                           // num of file
+
+char __Gsbmp_files[3][FILENAME_LEN] =           // add file name here
+{
+"flower.BMP",
+"hibiscus.bmp",
+"test.bmp",
+};
+
+
+File bmpFile;
+
+
+void setup()
+{
+
+    Serial.begin(9600);
+    
+    pinMode(PIN_SD_CS,OUTPUT);
+    digitalWrite(PIN_SD_CS,HIGH);
+
+    Tft.TFTinit();
+
+    Sd2Card card;
+    card.init(SPI_FULL_SPEED, PIN_SD_CS); 
+    
+    if(!SD.begin(PIN_SD_CS))              
+    { 
+        Serial.println("failed!");
+        while(1);                               // init fail, die here
+    }
+    
+    Serial.println("SD OK!");
+
+    TFT_BL_ON;
+}
+
+void loop()
+{
+    for(unsigned char i=0; i<__Gnfile_num; i++)
+    {
+        bmpFile = SD.open(__Gsbmp_files[i]);
+        if (! bmpFile)
+        {
+            Serial.println("didnt find image");
+            while (1);
+        }
+
+        if(! bmpReadHeader(bmpFile)) 
+        {
+            Serial.println("bad bmp");
+            return;
+        }
+
+        bmpdraw(bmpFile, 0, 0);
+        bmpFile.close();
+
+        delay(1000);
+    }
+
+}
+
+/*********************************************/
+// This procedure reads a bitmap and draws it to the screen
+// its sped up by reading many pixels worth of data at a time
+// instead of just one pixel at a time. increading the buffer takes
+// more RAM but makes the drawing a little faster. 20 pixels' worth
+// is probably a good place
+
+#define BUFFPIXEL       60                      // must be a divisor of 240 
+#define BUFFPIXEL_X3    180                     // BUFFPIXELx3
+
+void bmpdraw(File f, int x, int y)
+{
+    bmpFile.seek(__Gnbmp_image_offset);
+
+    uint32_t time = millis();
+
+    uint8_t sdbuffer[BUFFPIXEL_X3];                 // 3 * pixels to buffer
+
+    for (int i=0; i< __Gnbmp_height; i++)
+    {
+
+        for(int j=0; j<(240/BUFFPIXEL); j++)
+        {
+            bmpFile.read(sdbuffer, BUFFPIXEL_X3);
+            uint8_t buffidx = 0;
+            int offset_x = j*BUFFPIXEL;
+            
+            unsigned int __color[BUFFPIXEL];
+            
+            for(int k=0; k<BUFFPIXEL; k++)
+            {
+                __color[k] = sdbuffer[buffidx+2]>>3;                        // read
+                __color[k] = __color[k]<<6 | (sdbuffer[buffidx+1]>>2);      // green
+                __color[k] = __color[k]<<5 | (sdbuffer[buffidx+0]>>3);      // blue
+                
+                buffidx += 3;
+            }
+
+            Tft.setCol(offset_x, offset_x+BUFFPIXEL);
+            Tft.setPage(i, i);
+            Tft.sendCMD(0x2c);                                                  
+            
+            TFT_DC_HIGH;
+            TFT_CS_LOW;
+
+            for(int m=0; m < BUFFPIXEL; m++)
+            {
+                SPI.transfer(__color[m]>>8);
+                SPI.transfer(__color[m]);
+            }
+
+            TFT_CS_HIGH;
+        }
+        
+    }
+    
+    Serial.print(millis() - time, DEC);
+    Serial.println(" ms");
+}
+
+boolean bmpReadHeader(File f) 
+{
+    // read header
+    uint32_t tmp;
+    uint8_t bmpDepth;
+    
+    if (read16(f) != 0x4D42) {
+        // magic bytes missing
+        return false;
+    }
+
+    // read file size
+    tmp = read32(f);
+    Serial.print("size 0x");
+    Serial.println(tmp, HEX);
+
+    // read and ignore creator bytes
+    read32(f);
+
+    __Gnbmp_image_offset = read32(f);
+    Serial.print("offset ");
+    Serial.println(__Gnbmp_image_offset, DEC);
+
+    // read DIB header
+    tmp = read32(f);
+    Serial.print("header size ");
+    Serial.println(tmp, DEC);
+    
+    
+    int bmp_width = read32(f);
+    int bmp_height = read32(f);
+    
+    if(bmp_width != __Gnbmp_width || bmp_height != __Gnbmp_height)      // if image is not 320x240, return false
+    {
+        return false;
+    }
+
+    if (read16(f) != 1)
+    return false;
+
+    bmpDepth = read16(f);
+    Serial.print("bitdepth ");
+    Serial.println(bmpDepth, DEC);
+
+    if (read32(f) != 0) {
+        // compression not supported!
+        return false;
+    }
+
+    Serial.print("compression ");
+    Serial.println(tmp, DEC);
+
+    return true;
+}
+
+/*********************************************/
+// These read data from the SD card file and convert them to big endian
+// (the data is stored in little endian format!)
+
+// LITTLE ENDIAN!
+uint16_t read16(File f)
+{
+    uint16_t d;
+    uint8_t b;
+    b = f.read();
+    d = f.read();
+    d <<= 8;
+    d |= b;
+    return d;
+}
+
+// LITTLE ENDIAN!
+uint32_t read32(File f)
+{
+    uint32_t d;
+    uint16_t b;
+
+    b = read16(f);
+    d = read16(f);
+    d <<= 16;
+    d |= b;
+    return d;
+}

libraries/TFT_Touch_Shield_V2/examples/tftbmp2/tftbmp2.ino

@@ -0,0 +1,348 @@
+/*
+  TFT Touch Shield 2.0 examples - tftbmp2
+  
+  loovee
+  2013-1-21
+  
+  this demo can show all bmp file in root Directory of SD card
+  please ensure that your image file is 320x240 size. 
+
+  MAX_BMP can config the max file to display
+  FILENAME_LEN can config the max length of file name
+  
+*/
+
+#include <SD.h>
+#include <SPI.h>
+#include <Streaming.h>
+
+#include "TFTv2.h"
+
+#define MAX_BMP         10                      // bmp file num
+#define FILENAME_LEN    20                      // max file name length
+
+const int PIN_SD_CS = 4;                        // pin of sd card
+
+const long __Gnbmp_height = 320;                 // bmp hight
+const long __Gnbmp_width  = 240;                 // bmp width
+
+long __Gnbmp_image_offset  = 0;;
+
+int __Gnfile_num = 0;                           // num of file
+char __Gsbmp_files[MAX_BMP][FILENAME_LEN];      // file name
+
+File bmpFile;
+
+// if bmp file return 1, else return 0
+bool checkBMP(char *_name, char r_name[])
+{
+    int len = 0;
+
+    if(NULL == _name)return false;
+    
+    while(*_name)
+    {
+        r_name[len++] = *(_name++);
+        if(len>FILENAME_LEN)return false;
+    }
+
+    r_name[len] = '\0';
+
+    if(len < 5)return false;
+
+    // if xxx.bmp or xxx.BMP
+    if( r_name[len-4] == '.' \
+        && (r_name[len-3] == 'b' || (r_name[len-3] == 'B')) \
+        && (r_name[len-2] == 'm' || (r_name[len-2] == 'M')) \
+        && (r_name[len-1] == 'p' || (r_name[len-1] == 'P')) )
+    {
+        return true;
+    }
+
+    return false;
+
+}
+
+// search root to find bmp file
+void searchDirectory()
+{
+    File root = SD.open("/");                       // root
+    while(true) 
+    {
+        File entry =  root.openNextFile();
+        
+        if (! entry)
+        {
+            break;
+        }
+
+        if(!entry.isDirectory())
+        {
+            char *ptmp = entry.name();
+
+            char __Name[20];
+
+            if(checkBMP(ptmp, __Name))
+            {
+                Serial.println(__Name);
+
+                strcpy(__Gsbmp_files[__Gnfile_num++], __Name);
+            }
+        }
+        entry.close();
+    }
+    
+    Serial.print("get ");
+    Serial.print(__Gnfile_num);
+    Serial.println(" file: ");
+    
+    for(int i=0; i<__Gnfile_num; i++)
+    {
+        Serial.println(__Gsbmp_files[i]);
+    }
+}
+
+
+void setup()
+{
+
+    Serial.begin(115200);
+    
+    pinMode(PIN_SD_CS,OUTPUT);
+    digitalWrite(PIN_SD_CS,HIGH);
+
+    Tft.TFTinit();
+
+    Sd2Card card;
+    card.init(SPI_FULL_SPEED, PIN_SD_CS); 
+    
+    if(!SD.begin(PIN_SD_CS))              
+    { 
+        Serial.println("failed!");
+        while(1);                               // init fail, die here
+    }
+    
+    Serial.println("SD OK!");
+    
+    searchDirectory();
+
+    TFT_BL_ON;
+}
+
+void loop()
+{
+/*
+    static int dirCtrl = 0;
+    for(unsigned char i=0; i<__Gnfile_num; i++)
+    {
+        bmpFile = SD.open(__Gsbmp_files[i]);
+        if (! bmpFile)
+        {
+            Serial.println("didnt find image");
+            while (1);
+        }
+
+        if(! bmpReadHeader(bmpFile)) 
+        {
+            Serial.println("bad bmp");
+            return;
+        }
+
+        dirCtrl = 1-dirCtrl;
+        bmpdraw(bmpFile, 0, 0, dirCtrl);
+        bmpFile.close();
+
+        delay(1000);
+    }
+*/
+
+
+        bmpFile = SD.open("pfvm_1.bmp");
+        
+        if (! bmpFile)
+        {
+            Serial.println("didnt find image");
+            while (1);
+        }
+
+        if(! bmpReadHeader(bmpFile)) 
+        {
+            Serial.println("bad bmp");
+            return;
+        }
+
+        bmpdraw(bmpFile, 0, 0, 1);
+        bmpFile.close();
+
+        while(1);
+}
+
+/*********************************************/
+// This procedure reads a bitmap and draws it to the screen
+// its sped up by reading many pixels worth of data at a time
+// instead of just one pixel at a time. increading the buffer takes
+// more RAM but makes the drawing a little faster. 20 pixels' worth
+// is probably a good place
+
+#define BUFFPIXEL       60                          // must be a divisor of 240 
+#define BUFFPIXEL_X3    180                         // BUFFPIXELx3
+
+
+#define UP_DOWN     1
+#define DOWN_UP     0
+
+// dir - 1: up to down
+// dir - 2: down to up
+void bmpdraw(File f, int x, int y, int dir)
+{
+
+    if(bmpFile.seek(__Gnbmp_image_offset))
+    {
+        Serial.print("pos = ");
+        Serial.println(bmpFile.position());
+    }
+    
+    uint32_t time = millis();
+
+    uint8_t sdbuffer[BUFFPIXEL_X3];                                         // 3 * pixels to buffer
+
+    for (int i=0; i< __Gnbmp_height; i++)
+    {
+        if(dir)
+        {
+            bmpFile.seek(__Gnbmp_image_offset+(__Gnbmp_height-1-i)*240*3);
+        }
+
+        for(int j=0; j<(240/BUFFPIXEL); j++)
+        {
+        
+            bmpFile.read(sdbuffer, BUFFPIXEL_X3);
+            uint8_t buffidx = 0;
+            int offset_x = j*BUFFPIXEL;
+            
+            unsigned int __color[BUFFPIXEL];
+            
+            for(int k=0; k<BUFFPIXEL; k++)
+            {
+                __color[k] = sdbuffer[buffidx+2]>>3;                        // read
+                __color[k] = __color[k]<<6 | (sdbuffer[buffidx+1]>>2);      // green
+                __color[k] = __color[k]<<5 | (sdbuffer[buffidx+0]>>3);      // blue
+                
+                buffidx += 3;
+            }
+
+            Tft.setCol(offset_x, offset_x+BUFFPIXEL);
+
+            if(dir)
+            {
+                Tft.setPage(i, i);
+            }
+            else
+            {
+                Tft.setPage(__Gnbmp_height-i-1, __Gnbmp_height-i-1);
+            }
+
+            Tft.sendCMD(0x2c);                                                  
+            
+            TFT_DC_HIGH;
+            TFT_CS_LOW;
+
+            for(int m=0; m < BUFFPIXEL; m++)
+            {
+                SPI.transfer(__color[m]>>8);
+                SPI.transfer(__color[m]);
+                
+                delay(10);
+            }
+
+            TFT_CS_HIGH;
+        }
+        
+    }
+    
+    Serial.print(millis() - time, DEC);
+    Serial.println(" ms");
+}
+
+boolean bmpReadHeader(File f) 
+{
+    // read header
+    uint32_t tmp;
+    uint8_t bmpDepth;
+    
+    if (read16(f) != 0x4D42) {
+        // magic bytes missing
+        return false;
+    }
+
+    // read file size
+    tmp = read32(f);
+    Serial.print("size 0x");
+    Serial.println(tmp, HEX);
+
+    // read and ignore creator bytes
+    read32(f);
+
+    __Gnbmp_image_offset = read32(f);
+    Serial.print("offset ");
+    Serial.println(__Gnbmp_image_offset, DEC);
+
+    // read DIB header
+    tmp = read32(f);
+    Serial.print("header size ");
+    Serial.println(tmp, DEC);
+    
+    int bmp_width = read32(f);
+    int bmp_height = read32(f);
+    
+    if(bmp_width != __Gnbmp_width || bmp_height != __Gnbmp_height)      // if image is not 320x240, return false
+    {
+        return false;
+    }
+
+    if (read16(f) != 1)
+    return false;
+
+    bmpDepth = read16(f);
+    Serial.print("bitdepth ");
+    Serial.println(bmpDepth, DEC);
+
+    if (read32(f) != 0) {
+        // compression not supported!
+        return false;
+    }
+
+    Serial.print("compression ");
+    Serial.println(tmp, DEC);
+
+    return true;
+}
+
+/*********************************************/
+// These read data from the SD card file and convert them to big endian
+// (the data is stored in little endian format!)
+
+// LITTLE ENDIAN!
+uint16_t read16(File f)
+{
+    uint16_t d;
+    uint8_t b;
+    b = f.read();
+    d = f.read();
+    d <<= 8;
+    d |= b;
+    return d;
+}
+
+// LITTLE ENDIAN!
+uint32_t read32(File f)
+{
+    uint32_t d;
+    uint16_t b;
+
+    b = read16(f);
+    d = read16(f);
+    d <<= 16;
+    d |= b;
+    return d;
+}