├── CACHE.HTM
├── LCD.cpp
├── LCD.h
├── LCDfont.h
├── PIP_07.ino
├── README.md
└── tags.h


/CACHE.HTM:
--------------------------------------------------------------------------------
1 |      ____    __  ____
2 |     / __ \  / / / __ \
3 |    / /_/ / / / / /_/ /
4 |   / ____/ / / / ____/
5 |  / /     / / / /
6 | /_/     /_/ /_/
7 | 
8 | PIP Micro Web Browser v0.7 (c) Chris Anderson 2014
9 | 


--------------------------------------------------------------------------------
/LCD.cpp:
--------------------------------------------------------------------------------
  1 | #include "LCD.h"
  2 | #include "LCDfont.c"
  3 | #include <limits.h>
  4 | #include "pins_arduino.h"
  5 | #include "wiring_private.h"
  6 | //#include <avr/pgmspace.h>
  7 | #include <SPI.h>
  8 | 
  9 | #define SCLK 13  // Don't change
 10 | #define MOSI 11  // Don't change
 11 | #define CS   9
 12 | #define DC   8
 13 | #define RST  7  // you can also connect this to the Arduino reset
 14 | 
 15 | #define DELAY 0x80
 16 | 
 17 | #define TFT_CASET   0x2A
 18 | #define TFT_RASET   0x2B
 19 | #define TFT_RAMWR   0x2C
 20 | 
 21 | // SPI/TFT setup
 22 | volatile uint8_t *csport, *rsport;
 23 | uint8_t  datapinmask, clkpinmask, cspinmask, rspinmask;
 24 | 
 25 | 
 26 | //================================================
 27 | // LCD object init
 28 | //================================================
 29 | LCD::LCD (int16_t w, int16_t h): 
 30 | WIDTH(w), HEIGHT(h), CURSOR_WIDTH(w / TEXTWIDTH), CURSOR_HEIGHT (h / TEXTHEIGHT) {
 31 |   cursorX =  0;
 32 |   cursorY = 0;
 33 |   textColour = 0xFFFF;
 34 |   bgColour = 0x0000;
 35 |   wrap = true;
 36 | }
 37 | 
 38 | //================================================
 39 | // SPI write commands
 40 | //================================================
 41 | void spiwrite (uint8_t c) {
 42 |   SPDR = c;
 43 |   while (!(SPSR & _BV(SPIF)));
 44 | }
 45 | 
 46 | void writecommand (uint8_t c) {
 47 |   *rsport &= ~rspinmask;
 48 |   *csport &= ~cspinmask;
 49 |   spiwrite (c);
 50 |   *csport |= cspinmask;
 51 | }
 52 | 
 53 | void writedata (uint8_t c) {
 54 |   *rsport |= rspinmask;
 55 |   *csport &= ~cspinmask;
 56 |   spiwrite (c);
 57 |   *csport |= cspinmask;
 58 | }
 59 | 
 60 | void setAddrWindow (uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
 61 |   writecommand (TFT_CASET); // Column addr set
 62 |   writedata (y0 >> 8);
 63 |   writedata (y0 & 0xff);     // YSTART
 64 |   writedata (y1 >> 8);
 65 |   writedata (y1 & 0xff);     // YEND  
 66 |   writecommand (TFT_RASET); // Row addr set
 67 |   writedata (x0 >> 8);
 68 |   writedata (x0 & 0xff);     // XSTART 
 69 |   writedata (x1 >> 8);
 70 |   writedata (x1 & 0xff);     // XEND
 71 |   writecommand (TFT_RAMWR); // write to RAM
 72 | }
 73 | 
 74 | 
 75 | //================================================
 76 | // LCD init code store
 77 | //================================================
 78 | static const uint8_t PROGMEM LCDinit[] = {
 79 |   21,
 80 |   0xcb,	5,  0x39, 0x2c, 0x00, 0x34, 0x02,
 81 |   0xcf,	3,  0x00, 0xc1, 0x30,
 82 |   0xe8,	3,  0x85, 0x00, 0x78,
 83 |   0xea,	2,  0x00, 0x00,
 84 |   0xed,	4,  0x64, 0x03,	0x12, 0x81,
 85 |   0xf7,	1,  0x20,
 86 |   0xc0,	1,  0x23,
 87 |   0xc1,	1,  0x10,
 88 |   0xc5,	2,  0x3e, 0x28,
 89 |   0xc7,	1,  0x86,
 90 |   0x36,	1,  0x08,
 91 |   0x3a,	1,  0x55,
 92 |   0xb1,	2,  0x00, 0x18,
 93 |   0xb6,	3,  0x08, 0x82, 0x27,
 94 |   0xf2,	1,  0x00,
 95 |   0x26,	1,  0x01,
 96 |   0xe0,	15, 0x0f, 0x31, 0x2b, 0x0c, 0x0e, 0x08, 0x4e, 0xf1, 0x37, 0x07, 0x10, 0x03, 0x0e, 0x09, 0x00,
 97 |   0xe1, 15, 0x00, 0x0e, 0x14, 0x03, 0x11, 0x07, 0x031, 0xc1, 0x48, 0x08, 0x0f, 0x0c, 0x31, 0x36, 0x0f,
 98 |   0x11, 0+DELAY, 120,
 99 |   0x29, 0,
100 |   0x2c, 0 
101 | };
102 | //0x08,
103 | 
104 | //================================================
105 | // LCD init code handler
106 | //================================================
107 | void commandList (const uint8_t *addr) {
108 |   uint8_t numCommands, numArgs;
109 |   uint16_t ms;
110 | 
111 |   numCommands = pgm_read_byte (addr++);   // Number of commands to follow
112 | 
113 |   while (numCommands--) {                 // For each command...
114 |     writecommand (pgm_read_byte (addr++)); //   Read, issue command
115 |     numArgs = pgm_read_byte (addr++);    //   Number of args to follow
116 |     ms = numArgs & DELAY;          //   If hibit set, delay follows args
117 |     numArgs &= ~DELAY;                   //   Mask out delay bit
118 |     while (numArgs--) {                   //   For each argument...
119 |       writedata (pgm_read_byte (addr++));  //     Read, issue argument
120 |     }
121 |     if (ms) {
122 |       ms = pgm_read_byte (addr++); // Read post-command delay time (ms)
123 |       if (ms == 255) ms = 500;     // If 255, delay for 500 ms
124 |       delay (ms);
125 |     }
126 |   }
127 | }
128 | 
129 | 
130 | //================================================
131 | // Init LCD object and LCD panel
132 | //================================================
133 | void LCD::init() {
134 |   pinMode (DC, OUTPUT);
135 |   pinMode (CS, OUTPUT);
136 |   pinMode (RST, OUTPUT);
137 |   csport    = portOutputRegister(digitalPinToPort(CS));
138 |   rsport    = portOutputRegister(digitalPinToPort(DC));
139 |   cspinmask = digitalPinToBitMask(CS);
140 |   rspinmask = digitalPinToBitMask(DC);
141 | 
142 |   SPI.begin();
143 |   //SPI.setClockDivider (SPI_CLOCK_DIV4); // 4 MHz (half speed)
144 |   //Due defaults to 4mHz (clock divider setting of 21)
145 |   SPI.setBitOrder (MSBFIRST);
146 |   SPI.setDataMode (SPI_MODE0);
147 | 
148 |   // toggle RST low to reset; CS low so it'll listen to us
149 |   *csport &= ~cspinmask;
150 |   digitalWrite (RST, HIGH);
151 |   delay (10);
152 |   digitalWrite (RST, LOW);
153 |   delay (10);
154 |   digitalWrite (RST, HIGH);
155 |   delay (10);
156 | 
157 |   commandList (LCDinit);
158 |   digitalWrite (CS, HIGH);
159 | 
160 |   fillRect (0 ,0, WIDTH, HEIGHT, BLACK);
161 | }
162 | 
163 | 
164 | //================================================
165 | // LCD write
166 | //================================================
167 | size_t LCD::write (uint8_t c) {
168 |   if (c == '\n') {
169 | //    fillRect (cursorX, cursorY, WIDTH - cursorX, TEXTHEIGHT, bgColour);  // Blank rest of line
170 |     cursorX  = 0;
171 |     cursorY += TEXTHEIGHT;
172 |     if (cursorY == CURSOR_HEIGHT) return 1;
173 |   } 
174 |   else if (c != '\r') { // Skip '\r'
175 |     drawChar(cursorX, cursorY, c, textColour, bgColour);
176 |     cursorX += TEXTWIDTH;
177 |     if (wrap && (cursorX > (WIDTH - TEXTWIDTH))) {
178 |       cursorX = 0;
179 |       cursorY += TEXTHEIGHT;
180 |       if (cursorY > HEIGHT) cursorY = 1;
181 |     }
182 |   }
183 |   return 1;
184 | }
185 | 
186 | //================================================
187 | // LCD draw character
188 | //================================================
189 | void LCD::drawChar (int16_t x, int16_t y, unsigned char c, uint16_t colour, uint16_t bg) {
190 |   unsigned char charData;
191 | 
192 |   if((x >= WIDTH) || (y >= HEIGHT) || ((x + TEXTWIDTH - 1) < 0) || ((y + TEXTHEIGHT - 1) < 0))
193 |     return;
194 | 
195 |   c -= 32; // Shift ASCII to font array values
196 |   if ((c < 0) || (c > 97)) c = 97;
197 | 
198 |   uint8_t fhi = colour >> 8, flo = colour & 0xff;
199 |   uint8_t bhi = bg >> 8, blo = bg & 0xff;
200 | 
201 |   setAddrWindow (x, y, x + TEXTWIDTH - 1, y + TEXTHEIGHT - 1);
202 | 
203 |   *rsport |= rspinmask;
204 |   *csport &= ~cspinmask;
205 | 
206 |   for (int8_t i = 0; i < TEXTWIDTH; i++ ) {
207 |     charData = pgm_read_byte (font + (c * (TEXTWIDTH - 1)) + i);
208 | 
209 |     for (int8_t j = 0; j < TEXTHEIGHT; j++) {
210 | 
211 |       if ((i < (TEXTWIDTH -1)) && ((charData >> j) & 0x01)) {
212 |         spiwrite (fhi);
213 |         spiwrite (flo);
214 |       } 
215 |       else {         
216 |         spiwrite (bhi);
217 |         spiwrite (blo);
218 |       } 
219 | 
220 |     }
221 |   }
222 | 
223 |   *csport |= cspinmask;
224 | 
225 | }
226 | 
227 | 
228 | //================================================
229 | // Filled rectangle
230 | //================================================
231 | void LCD::fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t colour) {
232 | 
233 |   if ((x >= WIDTH) || (y >= HEIGHT)) return;
234 |   if ((x + --w) >= WIDTH) w = WIDTH  - x - 1;
235 |   if ((y + --h) >= WIDTH) h = WIDTH - y - 1;
236 | 
237 |   setAddrWindow (x, y, x + w, y + h);
238 | 
239 |   uint8_t hi = colour >> 8;
240 |   uint8_t lo = colour & 0xff;
241 |   *rsport |=  rspinmask;
242 |   *csport &= ~cspinmask;
243 | 
244 |   for (y = h; y >= 0; y--) {
245 |     for (x = w; x >= 0; x--) {
246 |       spiwrite (hi);
247 |       spiwrite (lo);
248 |     }
249 |   }
250 |   *csport |= cspinmask;
251 | }
252 | 
253 | 
254 | //================================================
255 | // Utility functions
256 | //================================================
257 | void LCD::setCursor (int16_t x, int16_t y) {
258 |   cursorX = x * TEXTWIDTH;
259 |   cursorY = y * TEXTHEIGHT;
260 | }
261 | 
262 | void LCD::setTextColour (uint16_t c) {
263 |   textColour = c;
264 | }
265 | 
266 | void LCD::setBGColour (uint16_t b) {
267 |   bgColour = b;
268 | }
269 | 
270 | int16_t LCD::getTextColour () {
271 |   return textColour;
272 | }
273 | 
274 | int16_t LCD::getBGColour () {
275 |   return bgColour;
276 | }
277 | 
278 | void LCD::setTextWrap (boolean w) {
279 |   wrap = w;
280 | }
281 | 
282 | int16_t LCD::getCursorX() {
283 |   return cursorX;
284 | }
285 | 
286 | int16_t LCD::getCursorY() {
287 |   return cursorY;
288 | }
289 | 


--------------------------------------------------------------------------------
/LCD.h:
--------------------------------------------------------------------------------
 1 | #ifndef _LCD_H
 2 | #define _LCD_H
 3 | 
 4 | #include "Arduino.h"
 5 | #include "Print.h"
 6 | 
 7 | #define	BLACK   0x0000
 8 | #define	RED     0xF800
 9 | #define	GREEN   0x07E0
10 | #define	BLUE    0x001F
11 | #define YELLOW  0xFFE0
12 | #define MAGENTA 0xF81F
13 | #define CYAN    0x07FF  
14 | #define WHITE   0xFFFF
15 | #define GREY    0x632C
16 | 
17 | #define TEXTWIDTH   6
18 | #define TEXTHEIGHT  8
19 | 
20 | class LCD : 
21 | public Print {
22 | 
23 | public:
24 |   LCD(int16_t w, int16_t h);
25 | 
26 |   void init();
27 | 
28 |   void fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t colour);
29 |   void drawChar (int16_t x, int16_t y, unsigned char c, uint16_t colour, uint16_t bg);
30 | 
31 |   virtual size_t write (uint8_t);
32 | 
33 |   void setCursor (int16_t x, int16_t y);
34 |   void setTextColour (uint16_t c);
35 |   void setBGColour (uint16_t bg);
36 |   int16_t getTextColour ();
37 |   int16_t getBGColour ();
38 |   void setTextWrap (boolean w);
39 |   int16_t getCursorX();
40 |   int16_t getCursorY();
41 | 
42 |   const int16_t WIDTH, HEIGHT;
43 |   const int16_t CURSOR_WIDTH, CURSOR_HEIGHT;
44 | 
45 | protected:
46 |   int16_t cursorX, cursorY;
47 |   uint16_t textColour, bgColour;
48 |   boolean wrap; // If set, 'wrap' text at right edge of display
49 | };
50 | 
51 | #endif // _LCD_H
52 | 


--------------------------------------------------------------------------------
/LCDfont.h:
--------------------------------------------------------------------------------
  1 | #ifndef _FONT_C
  2 | #define _FONT_C
  3 | 
  4 | // #include <avr/io.h>
  5 |  #include <avr/pgmspace.h>
  6 | 
  7 | // Standard ASCII 5x7 font for chars 32+
  8 | static const char font[] PROGMEM = {
  9 | 	0x00, 0x00, 0x00, 0x00, 0x00,   // Space
 10 | 	0x00, 0x00, 0x5F, 0x00, 0x00,   // !
 11 | 	0x00, 0x07, 0x00, 0x07, 0x00,   // "
 12 | 	0x14, 0x7F, 0x14, 0x7F, 0x14,
 13 | 	0x24, 0x2A, 0x7F, 0x2A, 0x12,
 14 | 	0x23, 0x13, 0x08, 0x64, 0x62,
 15 | 	0x36, 0x49, 0x56, 0x20, 0x50,
 16 | 	0x00, 0x08, 0x07, 0x03, 0x00,
 17 | 	0x00, 0x1C, 0x22, 0x41, 0x00,
 18 | 	0x00, 0x41, 0x22, 0x1C, 0x00,
 19 | 	0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
 20 | 	0x08, 0x08, 0x3E, 0x08, 0x08,
 21 | 	0x00, 0x80, 0x70, 0x30, 0x00,
 22 | 	0x08, 0x08, 0x08, 0x08, 0x08,
 23 | 	0x00, 0x00, 0x60, 0x60, 0x00,
 24 | 	0x20, 0x10, 0x08, 0x04, 0x02,
 25 | 	0x3E, 0x51, 0x49, 0x45, 0x3E,  // 0
 26 | 	0x00, 0x42, 0x7F, 0x40, 0x00,
 27 | 	0x72, 0x49, 0x49, 0x49, 0x46,
 28 | 	0x21, 0x41, 0x49, 0x4D, 0x33,
 29 | 	0x18, 0x14, 0x12, 0x7F, 0x10,
 30 | 	0x27, 0x45, 0x45, 0x45, 0x39,
 31 | 	0x3C, 0x4A, 0x49, 0x49, 0x31,
 32 | 	0x41, 0x21, 0x11, 0x09, 0x07,
 33 | 	0x36, 0x49, 0x49, 0x49, 0x36,
 34 | 	0x46, 0x49, 0x49, 0x29, 0x1E,  // 9
 35 | 	0x00, 0x00, 0x14, 0x00, 0x00,
 36 | 	0x00, 0x40, 0x34, 0x00, 0x00,
 37 | 	0x00, 0x08, 0x14, 0x22, 0x41,
 38 | 	0x14, 0x14, 0x14, 0x14, 0x14,
 39 | 	0x00, 0x41, 0x22, 0x14, 0x08,
 40 | 	0x02, 0x01, 0x59, 0x09, 0x06,
 41 | 	0x3E, 0x41, 0x5D, 0x59, 0x4E,
 42 | 	0x7C, 0x12, 0x11, 0x12, 0x7C,  // A
 43 | 	0x7F, 0x49, 0x49, 0x49, 0x36,
 44 | 	0x3E, 0x41, 0x41, 0x41, 0x22,
 45 | 	0x7F, 0x41, 0x41, 0x41, 0x3E,
 46 | 	0x7F, 0x49, 0x49, 0x49, 0x41,
 47 | 	0x7F, 0x09, 0x09, 0x09, 0x01,
 48 | 	0x3E, 0x41, 0x41, 0x51, 0x73,
 49 | 	0x7F, 0x08, 0x08, 0x08, 0x7F,
 50 | 	0x00, 0x41, 0x7F, 0x41, 0x00,
 51 | 	0x20, 0x40, 0x41, 0x3F, 0x01,
 52 | 	0x7F, 0x08, 0x14, 0x22, 0x41,
 53 | 	0x7F, 0x40, 0x40, 0x40, 0x40,
 54 | 	0x7F, 0x02, 0x1C, 0x02, 0x7F,
 55 | 	0x7F, 0x04, 0x08, 0x10, 0x7F,
 56 | 	0x3E, 0x41, 0x41, 0x41, 0x3E,
 57 | 	0x7F, 0x09, 0x09, 0x09, 0x06,
 58 | 	0x3E, 0x41, 0x51, 0x21, 0x5E,
 59 | 	0x7F, 0x09, 0x19, 0x29, 0x46,
 60 | 	0x26, 0x49, 0x49, 0x49, 0x32,
 61 | 	0x03, 0x01, 0x7F, 0x01, 0x03,
 62 | 	0x3F, 0x40, 0x40, 0x40, 0x3F,
 63 | 	0x1F, 0x20, 0x40, 0x20, 0x1F,
 64 | 	0x3F, 0x40, 0x38, 0x40, 0x3F,
 65 | 	0x63, 0x14, 0x08, 0x14, 0x63,
 66 | 	0x03, 0x04, 0x78, 0x04, 0x03,
 67 | 	0x61, 0x59, 0x49, 0x4D, 0x43,  // Z
 68 | 	0x00, 0x7F, 0x41, 0x41, 0x41,
 69 | 	0x02, 0x04, 0x08, 0x10, 0x20,
 70 | 	0x00, 0x41, 0x41, 0x41, 0x7F,
 71 | 	0x04, 0x02, 0x01, 0x02, 0x04,
 72 | 	0x40, 0x40, 0x40, 0x40, 0x40,
 73 | 	0x00, 0x03, 0x07, 0x08, 0x00,
 74 | 	0x20, 0x54, 0x54, 0x78, 0x40,  // a
 75 | 	0x7F, 0x28, 0x44, 0x44, 0x38,
 76 | 	0x38, 0x44, 0x44, 0x44, 0x28,
 77 | 	0x38, 0x44, 0x44, 0x28, 0x7F,
 78 | 	0x38, 0x54, 0x54, 0x54, 0x18,
 79 | 	0x00, 0x08, 0x7E, 0x09, 0x02,
 80 | 	0x18, 0xA4, 0xA4, 0x9C, 0x78,
 81 | 	0x7F, 0x08, 0x04, 0x04, 0x78,
 82 | 	0x00, 0x44, 0x7D, 0x40, 0x00,
 83 | 	0x20, 0x40, 0x40, 0x3D, 0x00,
 84 | 	0x7F, 0x10, 0x28, 0x44, 0x00,
 85 | 	0x00, 0x41, 0x7F, 0x40, 0x00,
 86 | 	0x7C, 0x04, 0x78, 0x04, 0x78,
 87 | 	0x7C, 0x08, 0x04, 0x04, 0x78,
 88 | 	0x38, 0x44, 0x44, 0x44, 0x38,
 89 | 	0xFC, 0x18, 0x24, 0x24, 0x18,
 90 | 	0x18, 0x24, 0x24, 0x18, 0xFC,
 91 | 	0x7C, 0x08, 0x04, 0x04, 0x08,
 92 | 	0x48, 0x54, 0x54, 0x54, 0x24,
 93 | 	0x04, 0x04, 0x3F, 0x44, 0x24,
 94 | 	0x3C, 0x40, 0x40, 0x20, 0x7C,
 95 | 	0x1C, 0x20, 0x40, 0x20, 0x1C,
 96 | 	0x3C, 0x40, 0x30, 0x40, 0x3C,
 97 | 	0x44, 0x28, 0x10, 0x28, 0x44,
 98 | 	0x4C, 0x90, 0x90, 0x90, 0x7C,  // y
 99 | 	0x44, 0x64, 0x54, 0x4C, 0x44,  // z
100 | 	0x00, 0x08, 0x36, 0x41, 0x00,  // {
101 | 	0x00, 0x00, 0x7f, 0x00, 0x00,  // |
102 | 	0x00, 0x41, 0x36, 0x08, 0x00,  //  }
103 |   0x02, 0x01, 0x02, 0x04, 0x02,  // ~ 126
104 |   0x18, 0x3c ,0x18, 0x00, 0x00,  // Bullet point (not ASCII) 127
105 |   0x00, 0x00 ,0x00, 0x00, 0x00,  // &nbsp; 128
106 |   0x00, 0x7F, 0x41, 0x41, 0x7F   // Unprintable characters 129
107 | };
108 | #endif // _FONT_C
109 | 


--------------------------------------------------------------------------------
/PIP_07.ino:
--------------------------------------------------------------------------------
   1 | /*================================================
   2 |  ================================================= 
   3 |  ####  ###  ####
   4 |  #  #   #   #  #
   5 |  #  #   #   #  #
   6 |  ####   #   ####
   7 |  #      #   #
   8 |  #      #   #
   9 |  #     ###  #
  10 |  
  11 |  PIP Micro Web Browser v0.7
  12 |  Suitable for 32KB Arduino/ATmega use.
  13 |  
  14 |  (c) Chris Anderson 2014.
  15 |  
  16 |  Creative Commons license:
  17 |  Creative Commons Attribution 4.0 International License
  18 |  http://creativecommons.org/licenses/by/4.0/
  19 |  
  20 |  PIP is a functional but incomplete web browser for Arduino and runs 
  21 |  well on an Uno. It can  download and render plain HTML (no images, CSS 
  22 |  or Javascript) and follow  embedded links. It's joystick controlled 
  23 |  and uses a 320x240 LCD screen  for output. 
  24 |  
  25 |  The Ethernet and SD card libraries use about 20KB of code, so the LCD 
  26 |  driver, HTML parser and renderer squeeze in under 12KB. 
  27 |  
  28 |  Requires:
  29 |  
  30 |  * Arduino Uno or similiar ATmega 328 powered board
  31 |  * Wiz5100 powered Ethernet board with SD card slot (SPI CS = 10 & 4)
  32 |  * 320x240 TFT LCD screen (SPI CS = 9)  Found here: http://tinyurl.com/tftlcd
  33 |  * Analogue joystick with button (PS2 style)
  34 |  
  35 |  Installation:
  36 | 
  37 |  * Plug an SD card (MAXIMUM 2GB) into your computer and copy the file 
  38 |   "CACHE.HTM" from this enclosing folder into the root level of the card.
  39 |  * Download the file "HOME.HTM" from the URL below and put it in the enclosing
  40 |    folder. Then copy the file to the root level of the SD card.
  41 |    https://www.dropbox.com/s/v8h2d94uxxcw1oj/HOME.HTM?dl=0
  42 |  * Put the SD card into your Ethernet shield and upload PIP to your Arduino.
  43 |  * Rename the enclosing folder of this file to "PIP_07.ino". 
  44 |  * Copy the enclosing folder into you local Arduino sketch folder, as per 
  45 |    usual for new programs.
  46 |  
  47 |  Wiring for LCD:
  48 |  Name  Pin
  49 |  SCLK  13  Clock
  50 |  MOSI  11  Master Out - Don't change or you loose hardware assisted speed
  51 |  CS    9   Chip Select
  52 |  DC    8   Data/Comand
  53 |  RST   7   Reset
  54 |  LED   Arduino 3.3v
  55 |  VCC   Arduino 5v
  56 |  GND   Ground
  57 | 
  58 |  Wiring for joystick:
  59 |  VRx   A0 - Analogue input 0
  60 |  VRy   A1
  61 |  SW    A2
  62 |  VCC   Arduino 5v
  63 |  GND   Ground
  64 |  
  65 |  Notes:
  66 |  
  67 |  Handles a sub-set of HTML tags. See tags.h file for list.
  68 |  
  69 |  HTML pages over 20KB or so can stall and fail somewhat randomly. The Wiz5100 
  70 |  just doesn't seem to like dripping data to an Arduino much. Over 1KB/sec 
  71 |  download speed can be cosidered 'good'.
  72 |  
  73 |  Occationally when the browser crashes during a render, the HOME.HTM can get 
  74 |  corrupted. Just copy the file in the enclosing folder back onto the SD card.
  75 |  
  76 |  Due to poor Ethernet and SD card interaction on the SPI bus, the cace file
  77 |  on the SD card is held open as long as possible and only closed and re-opened
  78 |  during HTML download and parsing. That seems to make things ore reliable.
  79 |  
  80 |  HTML files are parsed and made partially binary before being stored on the CD card.
  81 |  File are generally around 50% smaller when unused junk is removed. The stored 
  82 |  file will be truncated to 64KB as 16 bit pointers are being used for page and 
  83 |  URL indexing.
  84 |  May fix this by going to relative pointers.
  85 |  
  86 |  Currently, URLs over 90 characters in size are truncated. This will undoubtably
  87 |  break them, or results in 404 errors. Which aren't handled well yet.
  88 |  
  89 |  The LCD screen is used via a custom library (very similar to the Adafruit GFX 
  90 |  library) which only implements rectangle and character drawing to save space.
  91 |  As only rectangle drawing and the print command are used, it should be easy to 
  92 |  adapt PIP to use a different LCD. 
  93 |  
  94 |  Doesn't do images. Come on, there's only 2KB of memory and a tiny screen 
  95 |  to play with! JPEG parsing might be problematic as there's only 2KB of 
  96 |  program space free.
  97 |  
  98 |  Forms are not even attempted. There's no keyboard, so good luck with that.
  99 |  
 100 |  To do:
 101 |  Handle state case when a page break the middle of a tag.
 102 |  
 103 |  v0.7 14/10/2014
 104 |  Fixed exception for <script> and <style> tags. Improved resiliance
 105 |  to buffer under-runs with slow ethernet connections.
 106 |  
 107 |  v0.6 1/10/2014
 108 |  Indexes in-HTML links, shows current link, steps through links
 109 |  activates links and handles ethernet buffer under-runs
 110 |  
 111 |  v0.5 17/9/2014
 112 |  Parser re-written as purely state-based, fixed SD card/Ethernet 
 113 |  conflicts - somwhat
 114 |  
 115 |  v0.4 3/9/2014
 116 |  Rebuilt and renamed browser as PIP, indexes pages, custom LCD
 117 |  libray re-written, optimise parser
 118 |  
 119 |  v0.3 18/4/1014
 120 |  Custom LCD driver library added, buggy
 121 |  
 122 |  v0.2 27/3/2014
 123 |  Downloads and parses basic HTML pages
 124 |  
 125 |  v0.1 13/3/2014
 126 |  Download and display concept, Muzayik
 127 |  
 128 |  ================================================ 
 129 |  ================================================*/
 130 | 
 131 | #define DEBUG0  false   // Main loop / Setup - Turns of a world of serial output - 
 132 | #define DEBUG1  true   // URLloading - You really don't want to turn these on 
 133 | #define DEBUG2  false   // Page display - Really. Just don't 
 134 | 
 135 | #include <Fat16.h>
 136 | #include <Ethernet.h>
 137 | #include <SPI.h>
 138 | #include "LCD.h"                                 // Custom LCD driver
 139 | #include "tags.h"                               // Support HTML tag transcodes
 140 | 
 141 | #define CACHEFILE      "CACHE.HTM"              // Cached HTML filename
 142 | #define HOMEPAGE       "HOME.HTM"               // First load homepage name
 143 | #define PAGEINDEXSIZE  10                       // Must small - each page uses 3 bytes
 144 | #define LINKINDEXSIZE  20                       // Must small - each link uses 2 bytes 
 145 | #define TIMEOUT        5000                     // Timeout on ethernet reads
 146 | 
 147 | //================================================
 148 | // Global variables - gotta love 'em
 149 | //================================================
 150 | byte mac[] = { 
 151 |   0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };          // Random MAC address - may need to be more random
 152 | IPAddress ip(172,20,30,225);                     // Fallback IP address if DNS doesn't work
 153 | EthernetClient client;
 154 | 
 155 | char server[30] = "*";                         // THERE HAS TO BE A BETTER WAY OF SPLITTING A URL
 156 | char path[60] = "";                            // INTO PARTS USING VARIABLES - JUST TO PASS THE HTTP REQUEST
 157 | char url[90] = "";                           // What IS a reasonable maximum URL length?
 158 | 
 159 | SdCard card;
 160 | Fat16 file;
 161 | struct cacheStruct {
 162 |   uint8_t    pagePtr, lastPage;                 // Pointers to current and last page indexed
 163 |   uint16_t  index[PAGEINDEXSIZE];               // File page index pointers
 164 |   uint8_t   pageState[PAGEINDEXSIZE];           // Initial tag state for page e.g. in a <strong>
 165 | };
 166 | cacheStruct textContent = { 
 167 |   0, 0, false };
 168 | 
 169 | struct linkStruct {
 170 |   uint8_t    linkPtr, lastLink;                  // Pointers to current and last link indexed
 171 |   uint16_t   index[LINKINDEXSIZE];               // Link 
 172 | };
 173 | linkStruct pageLinks = {
 174 |   0, 0 };
 175 | 
 176 | LCD tftLCD = LCD (320, 240);                      // LCD object instance
 177 | 
 178 | uint16_t lowestRAM = 2000;                        // Keeps tabs for low memoery alerts
 179 | 
 180 | uint8_t command = 6;                              // Initial browser command to display the homepage
 181 | uint16_t jX = 0, jY = 0;                          // Input joystick positions
 182 | uint8_t generalBuffer[55];
 183 | 
 184 | //================================================
 185 | // CPU hard reset
 186 | //================================================
 187 | void (* resetFunc) (void) = 0;                    //declare reset function at address 0
 188 | 
 189 | 
 190 | //================================================
 191 | // Setup
 192 | //================================================
 193 | void setup () {
 194 |   pinMode (10, OUTPUT);                           // Force Ethernet pin as output
 195 |   pinMode (A2, INPUT_PULLUP);                     // Ground activated switch
 196 | 
 197 |   Serial.begin (115200);
 198 |   Serial.println (F("Starting..."));
 199 |   delay (1000);
 200 | 
 201 |   //================================================
 202 |   // LCD initialisation stuff
 203 |   //================================================
 204 |   tftLCD.init();
 205 |   tftLCD.setTextColour (GREEN);
 206 |   tftLCD.fillRect (0, 0, tftLCD.WIDTH, 8, GREY);
 207 |   tftLCD.setCursor (0, 1);
 208 |   tftLCD.println (F("PIP Web Browser, v0.7, (c) Chris Anderson 2014"));
 209 | 
 210 |   freeRam();
 211 | 
 212 |   delay(100);
 213 | 
 214 |   //================================================
 215 |   // SD card initialisation stuff
 216 |   //================================================
 217 |   tftLCD.print (F("\nSD card init... "));
 218 |   digitalWrite (10, HIGH);                        // Force Ethernet off the SPI bus
 219 |   if (!card.init()) {
 220 |     tftLCD.println (F("failed, card.init"));
 221 |     command = 11;
 222 |     return;
 223 |   }
 224 |   if (!Fat16::init(&card)) {
 225 |     tftLCD.println (F("failed, Fat16::init\nResetting"));
 226 |     command = 11;
 227 |     return;
 228 |   }
 229 |   tftLCD.println();
 230 |   if (!openCacheFile(true)) {
 231 |     command = 11;
 232 |     return;
 233 |   }
 234 | 
 235 |   //================================================
 236 |   // Get IP address
 237 |   //================================================
 238 |   tftLCD.print (F("\n\nGetting IP address... "));
 239 |   if (Ethernet.begin(mac) == 0) {
 240 |     tftLCD.print (F("\nTrying fixed IP"));
 241 | #if (DEBUG0)
 242 |     Serial.println (F("\nTrying fixed IP"));
 243 | #endif
 244 |     Ethernet.begin(mac, ip);
 245 |   }
 246 |   tftLCD.println (Ethernet.localIP());
 247 | 
 248 |   delay (1000);
 249 | }
 250 | 
 251 | 
 252 | //================================================
 253 | // Main Loop - Reads joystick and passes on commands
 254 | //================================================
 255 | void loop () {
 256 |   jX = analogRead(A0);                           // Joystick X coord on analogue pin A0
 257 |   jY = analogRead(A1);                           // Joystick Y coord on analogue pin A1
 258 | 
 259 |     switch (command) {
 260 |     //================================================
 261 |     // Null command - check the joystick for new commands
 262 |     //================================================
 263 |   case 0:
 264 |     if (digitalRead (A2) == 0) {  // Joystick button on pin A2
 265 | #if (DEBUG0)
 266 |       Serial.print (F("\n>> Button Clicked: "));
 267 | #endif
 268 |       buildURL (pageLinks.index[pageLinks.linkPtr]);  // Get URL from page index
 269 | #if (DEBUG0)
 270 |       Serial.print (F("Built url: "));
 271 |       Serial.println (url);
 272 |       splitURL (url);
 273 |       Serial.print (F("Split url: "));
 274 |       Serial.print (server);
 275 |       Serial.print (F(" + "));
 276 |       Serial.println (path);
 277 | #endif
 278 | 
 279 |       if (url[0] != '*') {                        // Load default home page
 280 |         pageLinks.linkPtr = 0;
 281 |         pageLinks.lastLink = 0;
 282 |         textContent.pagePtr = 0;
 283 |         textContent.lastPage = 0;
 284 |         command = 5;
 285 | #if (DEBUG0)
 286 |         Serial.print (F("Loading URL: "));
 287 |         Serial.print (server);
 288 |         Serial.println (path);
 289 | #endif
 290 |       } 
 291 |       else {                                      // Something stuffed up
 292 |         command = 10; //      command = 5;
 293 |         file.sync();
 294 | #if (DEBUG0)
 295 |         Serial.println ("No URL");
 296 | #endif
 297 |       }
 298 |     }
 299 |     else if (jY < 20) command = 1;   // up
 300 |     else if (jX > 1000) command = 3; // right
 301 |     else if (jY > 1000) command = 2; // down
 302 |     else if (jX < 20) command = 4;   // left
 303 |     break;
 304 | 
 305 |     //================================================
 306 |     // Page up - then re-display
 307 |     //================================================
 308 |   case 1:
 309 | #if (DEBUG0)
 310 |     Serial.print (F("\n>> Command 1: "));
 311 | #endif
 312 |     if (textContent.pagePtr > 0) {
 313 |       textContent.pagePtr--;
 314 |       command = 6;
 315 |       pageLinks.lastLink = 0;
 316 | #if (DEBUG0)
 317 |       Serial.print (F("Page up to page "));
 318 |       Serial.println (textContent.pagePtr);
 319 | #endif      pageLinks.linkPtr = 0;
 320 |     } 
 321 |     else { // Can't got up any further
 322 |       command = 10;
 323 | #if (DEBUG0)
 324 |       Serial.println(F("Cancelled"));
 325 | #endif
 326 |     } 
 327 |     break;
 328 | 
 329 |     //================================================
 330 |     // Page down - then re-display
 331 |     //================================================
 332 |   case 2:
 333 | #if (DEBUG0)
 334 |     Serial.print (F("\n>> Command 2: "));
 335 | #endif
 336 |     if (textContent.pagePtr < textContent.lastPage) 
 337 |       textContent.pagePtr++;
 338 |     else
 339 |       textContent.pagePtr = 0;  // Reset to top
 340 | 
 341 |     command = 6;
 342 |     pageLinks.linkPtr = 0;
 343 |     pageLinks.lastLink = 0;
 344 | #if (DEBUG0)
 345 |     Serial.print (F("Page down to page "));
 346 |     Serial.println (textContent.pagePtr);
 347 | #endif
 348 |     break;
 349 | 
 350 |     //================================================
 351 |     // Next link - then re-display to update link highlight
 352 |     //================================================
 353 |   case 3:
 354 | #if (DEBUG0)
 355 |     Serial.print (F("\n>> Command 3: Next link: "));
 356 | #endif
 357 |     if (pageLinks.linkPtr < pageLinks.lastLink) {
 358 |       pageLinks.linkPtr++;
 359 |       command = 6;
 360 | #if (DEBUG0)
 361 |       Serial.print (F("Increased link to "));
 362 |       Serial.println (pageLinks.linkPtr);
 363 | #endif
 364 |     } 
 365 |     else 
 366 |     {
 367 |       pageLinks.linkPtr = 0;
 368 |       command = 6;
 369 | #if (DEBUG0)
 370 |       Serial.print (F("Reset link to "));
 371 |       Serial.println (pageLinks.linkPtr);
 372 | #endif
 373 |     }
 374 |     break;
 375 | 
 376 |     //================================================
 377 |     // Prev link - then re-display to update link highlight
 378 |     //================================================
 379 |   case 4:
 380 | #if (DEBUG0)
 381 |     Serial.print (F("\n>> Command 4: Previous link: "));
 382 | #endif
 383 |     if (pageLinks.linkPtr > 0) {
 384 |       pageLinks.linkPtr--;
 385 |       command = 6;
 386 | #if (DEBUG0)
 387 |       Serial.print (F("Decreased link to "));
 388 |       Serial.println (pageLinks.linkPtr);
 389 | #endif
 390 |     } 
 391 |     else  {
 392 |       pageLinks.linkPtr = pageLinks.lastLink;
 393 |       command = 6;
 394 | #if (DEBUG0)
 395 |       Serial.print (F("Reset link to "));
 396 |       Serial.println (pageLinks.linkPtr);
 397 | #endif
 398 |     }
 399 |     break;
 400 | 
 401 |     //================================================
 402 |     // Download, parse and cache url
 403 |     //================================================
 404 |   case 5:
 405 | #if (DEBUG0)
 406 |     Serial.println (F("\n>> Command 5: Load & cache URL"));
 407 | #endif
 408 |     file.sync();
 409 |     file.close ();                  // Close read only cache file
 410 |     splitURL (url);
 411 |     if (cacheURL (server, path)) {  // Download and cache URL
 412 |       pageLinks.lastLink = 0;
 413 |       pageLinks.linkPtr = 0;
 414 |       command = 6;
 415 |       //      printCache();
 416 |     } 
 417 |     else {
 418 |       file.close ();
 419 |       client.stop();
 420 |       tftLCD.println(F("\nDownload & caching failed"));
 421 |       memcpy (server, "*\0", 2);
 422 |       memcpy (path, '\0', 1);
 423 |       memcpy (url, '\0', 1);
 424 |       pageLinks.lastLink = 0;
 425 |       openCacheFile (true);
 426 |       command = 6;
 427 | #if (DEBUG0)
 428 |       Serial.println("Download & caching failed");
 429 | #endif
 430 |       //      tftLCD.println (F("Press button to continue"));
 431 |       //     while (digitalRead (A2) != 0) ;
 432 |       //     command = 11;
 433 |       break;
 434 |     }
 435 |     if (!openCacheFile(true)) {             // Re-open read only cache file
 436 |       tftLCD.println (F("Cache open failed"));
 437 |       memcpy (server, "*\0", 2);
 438 |     } 
 439 |     else {
 440 |       pageLinks.lastLink = 0;
 441 |       command = 6;
 442 |     }
 443 |     break;
 444 | 
 445 |     //================================================
 446 |     // Display current page from cached file
 447 |     //================================================
 448 |   case 6:
 449 | #if (DEBUG0)
 450 |     Serial.print (F("\n>> Command 6: Display cached page: "));
 451 |     Serial.println (textContent.pagePtr);
 452 | #endif
 453 |     if (!displayPage()) {
 454 |       tftLCD.println(F("\nDisplay cache failed"));
 455 | #if (DEBUG0)
 456 |       Serial.println(F("\nDisplay cache failed"));
 457 | 
 458 | #endif
 459 |     }
 460 |     //    printCache();
 461 |     command = 10;
 462 |     file.sync();
 463 |     break;
 464 | 
 465 | #if (DEBUG0)
 466 |     //================================================
 467 |     // Print cache file to serial - debug only
 468 |     //================================================
 469 |   case 7:
 470 |     Serial.print (F("\n>> Command 7: Print raw cached page: "));
 471 |     //    printCache();
 472 |     command = 10;
 473 |     break;
 474 | #endif
 475 | 
 476 |     //================================================
 477 |     // After work state - joystick awaits reset state
 478 |     //================================================
 479 |   case 10:
 480 |     if ((jX > 400) && (jX < 600) && (jY > 400) && (jY < 600) && digitalRead (A2) != 0)
 481 |       command = 0;
 482 |     break;
 483 | 
 484 |     //================================================
 485 |     // Reset Arduino on failure 
 486 |     //================================================
 487 |   case 11:
 488 |     tftLCD.println (F("Press button to reset"));
 489 |     while (digitalRead (A2) != 0) ;
 490 |     resetFunc();
 491 | 
 492 |   default:
 493 |     ;
 494 |   } 
 495 | }
 496 | 
 497 | 
 498 | //================================================
 499 | //================================================
 500 | // Cache URL to SD card file - long routine
 501 | //================================================
 502 | // Connects to the remote server and downloads the
 503 | // data, parses the HTML before storing to the 
 504 | // cache file on the SD card
 505 | //================================================
 506 | byte cacheURL (char *URLserver, char *URLpath) {
 507 |   // HTML parser states
 508 | #define sLEADIN 0
 509 | #define sHEADER 1
 510 | #define sTEXT	2
 511 | #define sPRE	3
 512 | #define sTAG	4
 513 | #define sAMP	5
 514 | #define sANCHOR 6
 515 | #define sSTUFF	7
 516 | #define sHREF   8
 517 | #define sURL	9
 518 | #define sENDTAG 10
 519 | #define sQUIET  11
 520 | #define sSCRIPT 12
 521 | #define sFOOTER 99
 522 | 
 523 | #define URL_SIZE = 130
 524 | 
 525 |   uint16_t  count = 0;                // Output char count
 526 |   uint32_t  downloadCount = 0;        // Download char count
 527 |   uint8_t   localState = sTEXT;       // HTML stream state
 528 |   uint8_t   metaState = sTEXT;        // HTML output state
 529 |   uint8_t   nextState = sTEXT;
 530 |   uint16_t  tagHash = 0;              // Hash for tag name
 531 |   uint16_t  ampHash = 0;              // Hash for escape characters
 532 |   char      url[130];                 // Buffer for building parsed URLs
 533 |   uint8_t   i = 0;
 534 |   uint8_t   c = 0;                    // Input char
 535 |   uint8_t   lastChar = TAG_CR;        // Set to supress leading junk
 536 |   uint16_t  outputChar = 0;           // Char to build output
 537 |   uint32_t  fileLength = 0;
 538 |   uint8_t   cleanChar = 0;
 539 |   uint32_t  startTime = 0;
 540 | 
 541 |   //================================================
 542 |   // Open URL
 543 |   //================================================
 544 |   tftLCD.setTextColour (GREEN);
 545 |   tftLCD.setBGColour (BLACK);
 546 |   tftLCD.fillRect (0, 8, tftLCD.WIDTH, 88, BLACK);
 547 |   tftLCD.fillRect (0, 96, tftLCD.WIDTH, 1, GREEN);
 548 |   tftLCD.fillRect (0, 0, tftLCD.WIDTH, 8, GREY);
 549 |   tftLCD.setCursor (0, 1);
 550 | 
 551 |   // tftLCD.print (F("\nOpening cache... "));
 552 |   //  tftLCD.print (CACHEFILE);
 553 | #if (DEBUG1)
 554 |   Serial.print (F("\nOpening cache... "));
 555 |   Serial.print (CACHEFILE);
 556 | #endif
 557 |   if (!openCacheFile(false)) {                   // Re-open read only cache file
 558 |     tftLCD.println (F("Cache open failed"));
 559 |     return 0;
 560 |   }
 561 |   delay (100);
 562 | 
 563 |   tftLCD.println (F("\nConnecting..."));
 564 |   tftLCD.print (URLserver);
 565 |   tftLCD.println (URLpath);
 566 |   if (URLserver[0] == '*') {                      // Should never get an * here
 567 |     tftLCD.println (F("Invalid URL"));
 568 |     return 0;
 569 |   } 
 570 |   else {
 571 | #if (DEBUG1)
 572 |     freeRam();
 573 |     Serial.print ("URL: ");
 574 |     Serial.print (URLserver);
 575 |     Serial.print (F(" + "));
 576 |     Serial.println (URLpath);
 577 | #endif
 578 |   }
 579 | 
 580 |   if (client.connect(URLserver, 80)) {            // Connect to server and request HTML
 581 |     client.print (F("GET "));
 582 |     client.print (URLpath);
 583 |     client.print (F(" HTTP/1.1\nHost: "));
 584 |     client.println (URLserver);
 585 |     client.println (F("User-Agent: Mozilla/4.0 (Mobile; PIP/7.0) PIP/7.0\nConnection: close\n\n"));
 586 |   } 
 587 |   else {
 588 |     tftLCD.println(F(" failed"));
 589 | #if (DEBUG1)
 590 |     Serial.println (F("BOOM!\nConnect failed"));
 591 | #endif
 592 |     command = 11;
 593 |     return 0;
 594 |   }
 595 | 
 596 |   delay(500);                                    // Give the Ethernet shield a mo to get going
 597 |   if (!inputWait()) {
 598 |     Serial.println (F("\nEthernet timeout"));
 599 |     return 0;
 600 |   }
 601 |   tftLCD.print (F("\n\nParsing..."));
 602 | #if (DEBUG1)
 603 |   Serial.println (F("\nParsing..."));
 604 | #endif
 605 |   startTime = millis();
 606 | 
 607 |   {
 608 |     memcpy (generalBuffer, "HTTP/1.1 \0", 10);
 609 |     outputChar = findUntil (generalBuffer, true);
 610 |     if (outputChar == 2) {
 611 |       fileLength = client.parseInt();
 612 | #if (DEBUG1)
 613 |       Serial.print (F("Result: ")); 
 614 |       Serial.println (fileLength);
 615 | #endif
 616 |       if (fileLength >= 300) {
 617 |         command = 6;
 618 |         return 0;
 619 |       }
 620 |     }
 621 |     memcpy (generalBuffer, "-Length: \0", 10);
 622 |     outputChar = findUntil (generalBuffer, true);
 623 | #if (DEBUG1)
 624 |     Serial.print ("\n");
 625 |     Serial.println (outputChar);
 626 | #endif
 627 | 
 628 |     if (outputChar == 2) {
 629 |       fileLength = client.parseInt();
 630 |       if (fileLength < 10) fileLength = 0;
 631 | #if (DEBUG1)
 632 |       if (fileLength > 0) {
 633 |         Serial.print (F("File length: "));
 634 |         Serial.println (fileLength);
 635 |       }
 636 | #endif
 637 |     } 
 638 |     else if (outputChar == 1) {
 639 | #if (DEBUG1)
 640 |       Serial.println (F("\nStopped by <, no file length found"));
 641 | #endif
 642 |       fileLength = 0;
 643 |     } 
 644 |     else {    
 645 | #if (DEBUG1)
 646 |       Serial.println (F("\nTimeout finding file length"));
 647 | #endif
 648 |       fileLength = 0;
 649 |     }
 650 | 
 651 |     memcpy (generalBuffer, "<body\0", 7); 
 652 |     outputChar = findUntil (generalBuffer, false);
 653 |     if (outputChar = 0) {
 654 |       Serial.println (F("\nTimeout finding <body>\nShould probably stop now")); 
 655 |     } 
 656 |     else localState = sENDTAG;
 657 |   }
 658 |   c = client.read();
 659 | 
 660 |   //================================================
 661 |   // Loading loop
 662 |   //================================================
 663 |   while (metaState < sFOOTER) {
 664 |     c = 0;
 665 | 
 666 |     if (client.available()) {
 667 |       //      freeRam();
 668 |       c = client.read();
 669 |       downloadCount++;
 670 |     } 
 671 |     else if (!inputWait()) {
 672 |       client.stop();
 673 |       Serial.println(F(" DONE"));
 674 |       file.sync();
 675 |       return 0;
 676 |     }
 677 | 
 678 |     nextState = localState;
 679 |     outputChar = c;
 680 | 
 681 | #if (DEBUG1)
 682 |     if (metaState > sLEADIN) {
 683 |       Serial.print (F("|\n"));
 684 |       Serial.print (client.available());
 685 |       Serial.print (F("\t"));
 686 |       Serial.print (count);
 687 |       Serial.print (F("\tmS "));
 688 |       Serial.print (metaState);
 689 |       Serial.print (F("\tlS "));
 690 |       Serial.print (localState);
 691 |       Serial.print (F("\t"));
 692 |       if (lastChar > 31) Serial.write (lastChar);
 693 |       else Serial.print (lastChar, DEC);
 694 |       Serial.print (F("\t"));
 695 |       if (c > 31) Serial.write (c);
 696 |       else Serial.print (c, DEC);
 697 |       Serial.print (F("\t|"));
 698 |     }
 699 | #endif
 700 | 
 701 | 
 702 |     //================================================
 703 |     // State is sAMP &amp;                           4
 704 |     //================================================
 705 |     if ((c == '&') && ((localState == sTEXT) || (localState == sURL))) {  // Enter state condition
 706 |       if (metaState == sANCHOR) url[i++] = c;
 707 |       localState = sAMP;
 708 |       ampHash = 0;
 709 |       continue; 
 710 |     }
 711 |     if (localState == sAMP) {
 712 |       if (c == ';') {                                 // End condition
 713 | #if (DEBUG2)
 714 |         Serial.print (" OutputChar = ");
 715 |         Serial.println (hashOut (ampHash), DEC);
 716 | #endif
 717 | 
 718 |         if (metaState != sANCHOR) {
 719 |           outputChar = hashOut (ampHash);
 720 | 
 721 |           if (outputChar == 0) {
 722 |             outputChar = 129;  // Unkown character
 723 |             nextState = sTEXT;
 724 |           }
 725 |           else nextState = sTEXT;
 726 |         }         
 727 |         else outputChar = 0;
 728 |         if (metaState == sANCHOR) nextState = sURL;
 729 |       } 
 730 |       else { 
 731 |         ampHash = (ampHash << 2) + ((int) c) - 32;
 732 |         outputChar = 0;
 733 |         continue; 
 734 |       }
 735 |     }
 736 | 
 737 | 
 738 |     //================================================
 739 |     // State is sTAG                                 3
 740 |     //================================================
 741 |     if (c == '<') {                                    // Enter state condition
 742 |       localState = sTAG;
 743 |       nextState = sTAG;
 744 |       if (metaState != sQUIET) metaState = sTEXT;
 745 |       tagHash = 0;
 746 |       continue; 
 747 |     }
 748 | 
 749 |     if (localState == sTAG) {
 750 |       nextState = sTAG;
 751 |       if ((c == '>') || (c == ' ') || (c == '\t')) {    // End condition
 752 | #if (DEBUG1)
 753 |         Serial.print (" end tag ");
 754 |         Serial.print (tagHash);
 755 | #endif
 756 |         nextState = sTEXT;
 757 | 
 758 |         if (tagHash == BODYTAGEND) {
 759 |           metaState = sFOOTER;
 760 |           continue; 
 761 |         }
 762 | 
 763 |         if ((tagHash == SCRIPTTAGEND) || (tagHash == STYLETAGEND)) {
 764 | #if (DEBUG1)
 765 |           Serial.print (F(" SCRIPT/STYLE TAG end"));
 766 | #endif
 767 |           nextState = sTEXT;
 768 |           localState = sTEXT; 
 769 |           metaState = sTEXT; 
 770 |           continue;
 771 |         }
 772 |         if ((tagHash == SCRIPTTAG) || (tagHash == STYLETAG)) {
 773 | #if (DEBUG1)
 774 |           Serial.print (F(" SCRIPT/STYLE TAG start "));
 775 | #endif
 776 |           if (c == '>') localState = sTEXT;
 777 |           else localState = sENDTAG;
 778 |           metaState = sQUIET;
 779 |           tagHash = 0;
 780 |           continue;
 781 |         }
 782 | 
 783 |         if (tagHash == PRETAG) { 
 784 |           nextState = sTEXT;
 785 |           metaState = sPRE;
 786 |         }
 787 |         if (tagHash == PRETAGEND) {
 788 |           nextState = sTEXT; 
 789 |           metaState = sTEXT;
 790 |         }
 791 |         outputChar = hashOut (tagHash);
 792 |         if (c != '>') 
 793 |           if (tagHash == 65) nextState = sSTUFF;         // Is actually an <a tag
 794 |           else nextState = sENDTAG;                      // Tag not supported
 795 |         tagHash = 0;
 796 | 
 797 | #if (DEBUG1)
 798 |         Serial.print (" Next state: ");
 799 |         Serial.print (nextState);
 800 | #endif
 801 |       }
 802 |       else {
 803 |         tagHash = (tagHash << 1) + ((int) lowerCase (c)) - 32;
 804 |         outputChar = 0;
 805 |       }
 806 |     }
 807 | 
 808 |     //================================================
 809 |     // State is sSTUFF in an <a  tag before href="   7
 810 |     //================================================
 811 |     if (localState == sSTUFF) {
 812 |       if ((c != ' ') && (c != '\t')) {                // End condition
 813 |         tagHash = lowerCase (c) - 32;
 814 |         nextState = sHREF;
 815 |       }
 816 |       else if (c == '>') {                            // Error in tag termination, wasn't an anchor
 817 |         nextState = sTEXT;
 818 |         tagHash = 0;
 819 |       }
 820 |       outputChar = 0;
 821 |     }
 822 | 
 823 |     //================================================
 824 |     // State is sHREF href="                         8
 825 |     //================================================
 826 |     if (localState == sHREF) {
 827 |       if (tagHash == HREFTAG) {                        // End condition
 828 |         nextState = sURL;
 829 |         metaState = sANCHOR;
 830 |         i = 0;
 831 |       } 
 832 |       else if ((c == '"') || (c == '\'') || (c == '>')) {  // No href match
 833 |         nextState = sSTUFF;
 834 |         tagHash = 0;
 835 |       }
 836 |       else
 837 |         tagHash = (tagHash << 1) + ((int) toLowerCase (c)) - 32;
 838 |       outputChar = 0;
 839 |     }
 840 | 
 841 |     //================================================
 842 |     // State is sURL in href="url"                   9
 843 |     //================================================
 844 |     if (localState == sURL) {
 845 |       if ((c == '"') || (c == '\'')) {                 // End condition
 846 |         url[i++] = 0;
 847 |         nextState = sENDTAG;
 848 |         storeURL(url);
 849 |         file.write (TAG_LINK2);
 850 | #if (DEBUG1)
 851 |         Serial.print (TAG_LINK2);
 852 | #endif
 853 |       }
 854 |       else {
 855 |         url[i++] = c;
 856 |         url[i] = 0;
 857 |         if (i > 130) {
 858 |           nextState = sENDTAG;
 859 |           file.write (TAG_LINK2);
 860 | #if (DEBUG1)
 861 |           Serial.print (TAG_LINK2);
 862 | #endif
 863 |         }
 864 |       }
 865 |       outputChar = 0;
 866 |     }
 867 | 
 868 | 
 869 |     //================================================
 870 |     // State is sENDTAG after href="url"             10
 871 |     //================================================
 872 |     if (localState == sENDTAG) {
 873 |       if ((c == '>') && (metaState != sQUIET)) {      // End condition
 874 |         metaState = sTEXT;
 875 |         nextState = sTEXT; 
 876 |       } 
 877 |       else
 878 |         continue;
 879 |       outputChar = 0;
 880 |     }
 881 | 
 882 |     //================================================
 883 |     // State is sTEXT - Output stage                10
 884 |     //================================================
 885 |     cleanChar = outputChar & ATTR_MASK;
 886 | 
 887 |     if ((cleanChar == 10) || (cleanChar == '\t')) {
 888 |       uint32_t speed = 0;
 889 | 
 890 |       tftLCD.setCursor (0, 7);
 891 |       tftLCD.print (downloadCount);
 892 |       tftLCD.print (F(" bytes downloaded @ "));
 893 |       speed = downloadCount / ((millis() - startTime) / 1000);
 894 |       tftLCD.print (speed);
 895 |       tftLCD.println (F(" bytes/sec       "));
 896 | 
 897 |       if (fileLength > 0) {
 898 |         uint32_t percent = 0;
 899 |         tftLCD.print (fileLength);
 900 |         tftLCD.println (F(" bytes file size   "));
 901 |         percent = downloadCount * 100 / fileLength;
 902 |         //        tftLCD.print (percent);
 903 |         //         tftLCD.println (F("% downloaded"));
 904 |         tftLCD.fillRect (0, 0, percent * tftLCD.WIDTH / 100, 8, GREEN);
 905 |       }    
 906 | 
 907 |       tftLCD.print (count);
 908 |       tftLCD.println (F(" bytes stored   "));
 909 |     }
 910 | 
 911 |     // Handle tags with pre breaks
 912 |     if ((outputChar & PRE_BREAK)) {
 913 |       file.write (10);
 914 |       count++;
 915 | #if (DEBUG1)
 916 |       Serial.write ('%');
 917 | #endif
 918 |     }
 919 | 
 920 |     // Write \n and \r verbatim inside PRE tag
 921 |     if (metaState == sPRE) {
 922 |       if (cleanChar == 13) cleanChar = 0;
 923 |       if (cleanChar == 10) cleanChar = TAG_CR;
 924 |     }
 925 | 
 926 |     // Convert any \n \r \t to spaces for possible supression
 927 |     else {
 928 |       if ((cleanChar == 10) || (cleanChar == 13) || (cleanChar == '\t')) {
 929 |         if (lastChar != TAG_CR) {
 930 |           cleanChar = ' ';
 931 | #if (DEBUG1)
 932 |           Serial.print (cleanChar);
 933 |           Serial.print (F(" Set ' '"));
 934 | #endif
 935 |         } 
 936 |         else {
 937 |           cleanChar = 0;
 938 |         }
 939 |       }
 940 |       if ((cleanChar == ' ') || (cleanChar == TAG_CR))
 941 |         if ((lastChar == ' ') || (lastChar == '>') || (lastChar == TAG_CR) || (cleanChar < 32)) {
 942 |           cleanChar = 0;
 943 |           /*#if (DEBUG1)
 944 |            Serial.print (F(" set 0\t"));
 945 |            Serial.print (lastChar);
 946 |            Serial.print (F("\t"));
 947 |            Serial.print (outputChar, DEC);
 948 |            #endif*/
 949 |         }
 950 |     }
 951 | 
 952 |     // Write out the charater
 953 |     if (cleanChar > 0) {
 954 |       count++;
 955 | 
 956 |       if (cleanChar > 129) cleanChar = 129;
 957 | 
 958 |       if ((cleanChar == TAG_CR) && !(outputChar & PRE_BREAK)) {
 959 | #if (DEBUG1)
 960 |         Serial.print ('@');
 961 | #endif
 962 |         file.write (10);
 963 |       }
 964 |       else if (cleanChar > 31) {
 965 |         if (metaState != sQUIET) {
 966 |           file.write (cleanChar);
 967 | #if (DEBUG1)
 968 |           Serial.write (cleanChar);
 969 | #endif
 970 |         }
 971 |       } 
 972 |       else {
 973 |         file.write (cleanChar);
 974 |         count++;
 975 | #if (DEBUG1)
 976 |         Serial.print (cleanChar, DEC);
 977 | #endif
 978 |       }
 979 |       lastChar = cleanChar;
 980 |     } 
 981 |     else if (outputChar & PRE_BREAK) lastChar = TAG_CR;
 982 | 
 983 |     // Handle tags with pre breaks
 984 |     if ((outputChar & POST_BREAK) && (lastChar != TAG_CR)) {
 985 |       file.write (10);
 986 |       count++;
 987 | #if (DEBUG1)
 988 |       Serial.print ('#');
 989 | #endif
 990 |       lastChar = TAG_CR;
 991 |     }
 992 | 
 993 |     localState = nextState;
 994 |   } // Loading loop
 995 | 
 996 |   file.print ('\0');
 997 |   client.flush();
 998 |   client.stop();
 999 | 
1000 |   tftLCD.println ();
1001 |   tftLCD.print (count);
1002 |   tftLCD.print (F(" bytes"));
1003 | 
1004 |   file.close ();
1005 | #if (DEBUG1)
1006 |   Serial.print (F("\nCount: "));
1007 |   Serial.println (count, DEC);
1008 |   freeRam();
1009 | #endif
1010 |   return count;
1011 | }
1012 | 
1013 | 
1014 | //================================================
1015 | //================================================
1016 | // Display page - long routine
1017 | //================================================
1018 | //================================================
1019 | byte displayPage () {
1020 |   uint16_t filePtr = textContent.index[textContent.pagePtr];  // Pointer into cached file
1021 |   uint8_t c = 1;                                      // Input character
1022 |   uint16_t count = 0;                                 // Character count for page index building
1023 |   uint16_t colourStack = WHITE;                       // One level stack to remember colour state
1024 |   boolean invisiblePrint = false;                     // Turn off output (for URLs, etc)
1025 |   uint8_t currentLink = 0;                            // Curretly highlightd link of the page
1026 |   boolean buildingIndex = (pageLinks.lastLink == 0);  // True if this page's URL haven't been index yet
1027 | 
1028 |   // Draw header
1029 |   tftLCD.fillRect (0, 0, tftLCD.WIDTH, 8, GREY);
1030 |   tftLCD.setCursor (0, 0);
1031 |   tftLCD.setBGColour(GREY);
1032 |   tftLCD.setTextColour(BLACK);
1033 |   if (server[0] == '*') tftLCD.println (F("Home page"));
1034 |   else tftLCD.println (url);
1035 | 
1036 |   if (!file.seekSet (filePtr)) {
1037 |     tftLCD.println (F("Seek failture"));
1038 |     return 0;
1039 |   }
1040 | 
1041 | #if (DEBUG2)
1042 |   freeRam();
1043 |   Serial.print (F("SD File position is: "));
1044 |   Serial.println (file.curPosition());
1045 |   if (buildingIndex) Serial.println (F("Building link index"));
1046 | #endif
1047 | 
1048 |   tftLCD.setCursor (0, 1);
1049 |   tftLCD.setBGColour(BLACK);
1050 |   tftLCD.setTextColour(WHITE);
1051 | 
1052 |   // Loop through cache file
1053 |   while ((filePtr <= file.fileSize()) && (tftLCD.getCursorY() < tftLCD.HEIGHT - 1) && (c != 0)) {
1054 |     c = file.read();
1055 |     filePtr++;
1056 |     count++;
1057 | 
1058 |     // Print only visible ASCII characters
1059 |     if (c > 31) {
1060 |       if (!invisiblePrint) {  // Print only if in visible mode (supresses URLs)
1061 |         tftLCD.write (c);
1062 | #if (DEBUG2)
1063 |         Serial.write(c);
1064 | #endif
1065 |       } 
1066 |       else {
1067 | #if (DEBUG2)
1068 |         //  Serial.print (F("_"));
1069 | #endif
1070 |         ;
1071 |       }
1072 |     }
1073 | 
1074 |     // Handle display codes
1075 |     else {
1076 |       switch (c) {
1077 |       case TAG_CR:
1078 |       case 10:
1079 |         // Fill the rest of the current line with black to erase the previous contents
1080 |         tftLCD.fillRect (tftLCD.getCursorX(), tftLCD.getCursorY(), tftLCD.WIDTH - tftLCD.getCursorX(), 8, BLACK);
1081 |         tftLCD.write(10);
1082 | #if (DEBUG2)
1083 |         Serial.println();
1084 | #endif
1085 |         invisiblePrint = false;
1086 |         break;
1087 |       case 13:
1088 |         // Only doing a CR/LF on ASCII 10
1089 |         break;
1090 | 
1091 |         // Start of a header tag
1092 |       case TAG_HEADING1:
1093 |         colourStack = tftLCD.getTextColour();      // Store the colour state
1094 |         tftLCD.setTextColour (COL_HEADING);
1095 |         break;
1096 | 
1097 |         // Start of a bold tag
1098 |       case TAG_BOLD1:
1099 |         colourStack = tftLCD.getTextColour();
1100 |         tftLCD.setTextColour (COL_BOLD);
1101 |         break;
1102 | 
1103 |         // Start of an anchor tag. The actual URL follows
1104 |       case TAG_LINK1:
1105 |         invisiblePrint = true;                      // Turn off printing while the URL is loading
1106 |         if ((buildingIndex) && (currentLink < LINKINDEXSIZE)) {
1107 |           pageLinks.index[currentLink] = filePtr;
1108 |           pageLinks.lastLink++;
1109 |         }
1110 |         break;
1111 | 
1112 |         // End of the URL part. Start of the anchor texyt
1113 |       case TAG_LINK2:
1114 |         colourStack = tftLCD.getTextColour();
1115 |         if (currentLink == pageLinks.linkPtr) {  // Print inverse colours for the active link
1116 |           tftLCD.setTextColour (BLACK);
1117 |           tftLCD.setBGColour (COL_LINK);
1118 |         } 
1119 |         else 
1120 |           tftLCD.setTextColour (COL_LINK);
1121 |         invisiblePrint = false;                  // Turn on printing again
1122 |         break;
1123 | 
1124 |         // End of the anchor tag
1125 |       case TAG_LINK3:
1126 |         if (currentLink < LINKINDEXSIZE) currentLink++; // Removed && buildingLink
1127 |         tftLCD.setTextColour (colourStack);
1128 |         tftLCD.setBGColour (BLACK);
1129 |         colourStack = WHITE;
1130 |         break;
1131 | 
1132 |         // End of header or bold tags
1133 |       case TAG_HEADING2:
1134 |       case TAG_BOLD2:
1135 |         tftLCD.setTextColour (colourStack);
1136 |         break;
1137 | 
1138 |         // List entry tag
1139 |       case TAG_LIST:
1140 |         tftLCD.write (127);
1141 |         break;
1142 | 
1143 |         // Horizontal rule tag
1144 |       case TAG_HR:
1145 |         tftLCD.fillRect (8, tftLCD.getCursorY(), tftLCD.WIDTH - 16, 1, GREY);
1146 | #if (DEBUG2)
1147 |         Serial.println (F("------"));
1148 |         Serial.println (tftLCD.getCursorX());
1149 |         Serial.println (tftLCD.getCursorY());
1150 | #endif
1151 |       default:
1152 |         ;
1153 |       }
1154 |     }
1155 |   }
1156 |   tftLCD.println();
1157 | 
1158 |   // Fill the rest of the screen under the last line with black
1159 |   tftLCD.fillRect (0, tftLCD.getCursorY(), tftLCD.WIDTH, tftLCD.HEIGHT  - tftLCD.getCursorY() - 8, BLACK);
1160 | 
1161 | #if (DEBUG2)
1162 |   Serial.print (F("\nCurrent page: "));
1163 |   Serial.println (textContent.pagePtr);
1164 | 
1165 |   Serial.print (F("Character count: "));
1166 |   Serial.print (count);
1167 | 
1168 | 
1169 |   if (textContent.pagePtr == textContent.lastPage)
1170 |     Serial.println (F("pagePtr == lastPage")); 
1171 |   else 
1172 |     Serial.println (F("pagePtr < lastPage")); 
1173 |   if (textContent.pagePtr < PAGEINDEXSIZE)
1174 |     Serial.println (F("pagePtr < PAGEINDEXSIZE"));
1175 |   if (filePtr++ < file.fileSize())
1176 |     Serial.println (F("filePtr++ < SDFile.size"));
1177 | #endif
1178 | 
1179 |   // Update page index
1180 |   if ((textContent.pagePtr == textContent.lastPage) && (textContent.pagePtr < PAGEINDEXSIZE) && (filePtr++ < file.fileSize())) {
1181 |     textContent.lastPage++;
1182 |     textContent.index[textContent.lastPage] = filePtr - 2; //textContent.index[textContent.lastPage] + count;
1183 |   }
1184 | 
1185 |   // Update last link pointer
1186 |   if ((buildingIndex) && (pageLinks.lastLink > 0)) pageLinks.lastLink--;
1187 | 
1188 | #if (DEBUG2)
1189 |   displayPageIndex();
1190 |   displayLinkIndex ();
1191 | 
1192 |   Serial.print (F("Char count:\t"));
1193 |   Serial.println (count);
1194 |   Serial.print (F("filePtr:\t"));
1195 |   Serial.println (filePtr);
1196 |   Serial.print (F("SD size:\t"));
1197 |   Serial.println (file.fileSize());
1198 |   Serial.print (F("======"));
1199 | #endif
1200 | 
1201 |   // Draw RAM use and page position in header
1202 |   tftLCD.setCursor (43, 0);
1203 |   tftLCD.setBGColour(GREY);
1204 |   tftLCD.setTextColour(BLACK);
1205 |   tftLCD.print (lowestRAM);
1206 |   tftLCD.setCursor (46, 0);
1207 |   tftLCD.print (F(" p"));
1208 |   tftLCD.print (textContent.pagePtr + 1);
1209 |   tftLCD.print (F("/"));
1210 |   tftLCD.println (textContent.lastPage + 1);
1211 |   return 1;
1212 | }
1213 | 
1214 | 
1215 | //================================================
1216 | // Convert ASCII upper to lower case for a-z
1217 | //================================================
1218 | char lowerCase (char c) {
1219 |   if ((c > 64) && (c < 91)) return c += 32;
1220 |   else return c;
1221 | }
1222 | 
1223 | 
1224 | //================================================
1225 | // Convert hash number to tags & flags
1226 | //================================================
1227 | uint16_t hashOut (uint16_t hash) {
1228 |   uint16_t output = 0;
1229 | 
1230 |   for (byte i = 0; i < NUMTAGS; i++) {
1231 |     if (hash == pgm_read_word (&tag_codes[i++])) {
1232 |       output = pgm_read_word (&tag_codes[i]);              
1233 |       i = NUMTAGS;
1234 |     }
1235 |   }
1236 |   return output;
1237 | }
1238 | 
1239 | //================================================
1240 | // Store an extracted URL
1241 | //================================================
1242 | void storeURL (char *local_url) {
1243 |   byte i = 0;
1244 |   byte j = 0;
1245 | 
1246 |   if ((local_url[5] == '/') && (local_url[6] == '/')) {
1247 |     j = 6;     // Strip leading http://
1248 |     local_url[i++] = TAG_HTTP;
1249 |   }
1250 |   else if ((local_url[6] == '/') && (local_url[7] == '/')) {
1251 |     j = 7;  // Strip leading https://
1252 |     local_url[i++] = TAG_HTTP;
1253 |   }
1254 | 
1255 |   while (local_url[i] > 0)
1256 |     local_url [i++] = local_url [i + j];
1257 | 
1258 | #if (DEBUG1)
1259 |   Serial.print (local_url);
1260 |   Serial.print (F("|"));
1261 | #endif
1262 | 
1263 |   file.print (local_url);
1264 |   freeRam();
1265 | }
1266 | 
1267 | 
1268 | //================================================
1269 | // Split a URL into server / path
1270 | //================================================
1271 | // This routine should be simpler but there are a
1272 | // surprising number of different URL formatting
1273 | // cases that need to be handled.
1274 | //================================================
1275 | void splitURL (char *localURL) {
1276 |   byte i = 0;
1277 |   byte urlIndex = 0;
1278 |   byte hasDot = 0;
1279 |   byte hasSlash = 0;
1280 | 
1281 | #if (DEBUG2)
1282 |   Serial.print (F("\nURL to Split: "));
1283 |   Serial.println (localURL);
1284 | #endif
1285 | 
1286 |   if (localURL[urlIndex] == TAG_HTTP) {
1287 |     urlIndex++;
1288 |     while ((localURL[urlIndex] > 0) && (localURL[urlIndex] != '/'))
1289 |       server[i++] = localURL[urlIndex++];
1290 |     server[urlIndex] = 0;
1291 |     server[i] = 0;
1292 |     if (localURL[urlIndex] > 0) {
1293 |       i = 0;
1294 |       while ((localURL[urlIndex] > 0) && (i < 60))
1295 |         path[i++] = localURL[urlIndex++];
1296 |       path[i] = 0;
1297 |     } 
1298 |     else {
1299 |       memcpy(path, "/\0", 2);
1300 |     }
1301 |   }
1302 |   else if (localURL[urlIndex] == '/') {  // URL starts with a slash
1303 |     while (localURL[urlIndex] > 0)
1304 |       path[i++] = localURL[urlIndex++];
1305 |     localURL[urlIndex] = 0;
1306 |   } 
1307 |   else {  // URL is plain
1308 |     while (localURL[urlIndex] > 0) {
1309 |       if (localURL[urlIndex] == '.') hasDot++;
1310 |       if (localURL[urlIndex++] == '/') hasSlash++;
1311 |     }
1312 | #if (DEBUG2)
1313 |     Serial.print ("Dots:");
1314 |     Serial.println (hasDot);
1315 |     Serial.print ("Slashes:");
1316 |     Serial.println(hasSlash);
1317 | #endif
1318 | 
1319 |     if (hasDot == 1) {
1320 |       path[0] = '/';
1321 |       urlIndex = 0;
1322 |       i = 1;
1323 |       do {
1324 |         path[i++] = localURL[urlIndex];
1325 |       } 
1326 |       while (localURL[urlIndex++] > 0);
1327 | 
1328 |     } 
1329 |     else if ((hasSlash > 0) && (hasDot > 1)) {
1330 |       urlIndex = 0;
1331 |       i = 0;
1332 |       while ((localURL[urlIndex] > 0) && (localURL[urlIndex] != '/'))
1333 |         server[i++] = localURL[urlIndex++];
1334 |       server[urlIndex] = 0;
1335 |       i = 0;
1336 |       while (localURL[urlIndex] > 0)
1337 |         path[i++] = localURL[urlIndex++];
1338 |       path[i] = 0;
1339 |     } 
1340 |     else {
1341 |       urlIndex = 0;
1342 |       i = 0;
1343 |       while (localURL[urlIndex] > 0)
1344 |         server[i++] = localURL[urlIndex++];
1345 |       server[urlIndex] = 0;
1346 |       memcpy (path, "/\0", 2);
1347 |     }
1348 |   }
1349 | #if (DEBUG2)
1350 |   Serial.print (F("URL: "));
1351 |   Serial.println (server);
1352 |   Serial.println (path);
1353 | #endif
1354 |   freeRam();
1355 | }
1356 | 
1357 | 
1358 | //================================================
1359 | // Builds a URL from data in the cache
1360 | //================================================
1361 | void buildURL (uint16_t pointer) {
1362 |   byte i = 0;
1363 |   char c = 0;
1364 |   uint16_t oldPos = file.curPosition();
1365 | 
1366 |   if (!file.seekSet (pointer)) {
1367 |     tftLCD.println (F("Seek failure"));
1368 | #if (DEBUG1)
1369 |     Serial.println (F("Seek failure"));
1370 | #endif
1371 |     return;
1372 |   }
1373 | 
1374 |   c = file.read();
1375 |   while (c != TAG_LINK2) {
1376 |     url [i++] = c;
1377 |     c = file.read();
1378 |   }
1379 | 
1380 |   url[i] = 0;
1381 |   file.seekSet (oldPos);
1382 |   freeRam();
1383 | }
1384 | 
1385 | #if (DEBUG2)
1386 | //================================================
1387 | // Display pageindex
1388 | //================================================
1389 | void displayPageIndex () {
1390 |   Serial.print (F("\nPage index:"));
1391 |   Serial.print (F("\npagePtr:\t"));
1392 |   Serial.println (textContent.pagePtr);
1393 |   Serial.print (F("lastPage:\t"));
1394 |   Serial.println (textContent.lastPage);
1395 |   Serial.println(F("Page Index"));
1396 | 
1397 |   for (byte i = 0; i <= textContent.lastPage; i++) {
1398 |     Serial.print (i);
1399 |     Serial.print (F("\t"));
1400 |     Serial.println (textContent.index[i]);
1401 |   }
1402 |   Serial.println();
1403 |   freeRam();
1404 | }
1405 | 
1406 | 
1407 | //================================================
1408 | // Display linkindex
1409 | //================================================
1410 | void displayLinkIndex () {
1411 |   Serial.print (F("\nLink index:"));
1412 |   Serial.print (F("\nlinkPtr:\t"));
1413 |   Serial.println (pageLinks.linkPtr);
1414 |   Serial.print (F("lastLink:\t"));
1415 |   Serial.println (pageLinks.lastLink);
1416 | 
1417 |   if (pageLinks.lastLink == 0) return;
1418 | 
1419 |   Serial.println(F("Link Index"));
1420 |   for (byte i = 0; i <= pageLinks.lastLink; i++) {
1421 |     Serial.print (i);
1422 |     Serial.print (F("\t"));
1423 |     Serial.print (pageLinks.index[i]);
1424 |     Serial.print (F("\t"));
1425 |     file.seekSet (pageLinks.index[i]);
1426 |     byte c = 0, j = 0;
1427 |     c = file.read();
1428 |     while ((c != TAG_LINK2) && (j++ < 100)) {
1429 |       Serial.write (c);
1430 |       c = file.read();
1431 |     }
1432 |     Serial.println();
1433 |   }
1434 |   Serial.println();
1435 |   freeRam();
1436 | }
1437 | #endif
1438 | 
1439 | 
1440 | #if (DEBUG0)
1441 | //================================================
1442 | // Print cache to serial - debug only
1443 | //================================================
1444 | uint8_t printCache () {
1445 |   int16_t c;
1446 |   uint16_t count = 0;
1447 | 
1448 |   if (!file.isOpen()) {
1449 |     Serial.println (F(" failed, not open"));
1450 |     return 0;
1451 |   }
1452 |   file.seekSet (0);
1453 | 
1454 |   Serial.print (F("\nFile size: "));
1455 |   Serial.println (file.fileSize());
1456 | 
1457 |   while ((c = file.read()) > 0) {
1458 |     Serial.print (count++);
1459 |     Serial.print (F("\t"));
1460 |     if (c > 31) {
1461 |       Serial.write((char)c);
1462 |       Serial.println();
1463 |     }
1464 |     else {
1465 |       Serial.print ("*");
1466 |       Serial.println (c);
1467 |     }
1468 |   }
1469 | 
1470 |   Serial.println (F("\nDone"));
1471 |   freeRam();
1472 | }
1473 | #endif
1474 | 
1475 | 
1476 | //================================================
1477 | // Open cache file with read or write option
1478 | //================================================
1479 | uint8_t openCacheFile (boolean readOnly) {
1480 |   char cacheFile[10];
1481 |   uint8_t openMask = O_RDWR | O_TRUNC | O_CREAT;
1482 | 
1483 |   if (readOnly) openMask = O_READ;
1484 | 
1485 |   if (server[0] == '*') memcpy (cacheFile, HOMEPAGE, sizeof(HOMEPAGE));
1486 |   else memcpy (cacheFile, CACHEFILE, sizeof(CACHEFILE));
1487 | 
1488 |   //  tftLCD.setCursor (0, 1);
1489 |   tftLCD.print (F("\nOpening cache... "));
1490 |   tftLCD.print (cacheFile);
1491 | 
1492 | #if (DEBUG2)
1493 |   Serial.print (F("Opening cache... "));
1494 |   Serial.println (cacheFile);
1495 | #endif
1496 | 
1497 |   digitalWrite (10, HIGH);
1498 | 
1499 |   if (!file.open (cacheFile, openMask)) {
1500 |     tftLCD.println (F(" Failed on open"));
1501 |     return 0;
1502 |   }
1503 |   if (!file.isOpen()) {
1504 |     tftLCD.println (F(" Failed, not open"));
1505 |     return 0;
1506 |   }
1507 | #if (DEBUG2)
1508 |   Serial.println();
1509 | #endif
1510 |   return 1;
1511 | }
1512 | 
1513 | 
1514 | //================================================
1515 | // Memory free tool
1516 | //================================================
1517 | void freeRam () {
1518 |   extern int __heap_start, *__brkval; 
1519 |   uint16_t v; 
1520 |   v = (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
1521 | #if (DEBUG1)
1522 |   Serial.print (F("Free RAM: "));
1523 |   Serial.print (v);
1524 | #endif
1525 |   if (v < lowestRAM) {
1526 |     lowestRAM = v;
1527 | #if (DEBUG1)
1528 |     Serial.print (F(" KB (Lowest: "));
1529 |     Serial.print (lowestRAM);
1530 |     Serial.println (F(")"));
1531 | #endif
1532 |   } 
1533 | #if (DEBUG1)
1534 |   else Serial.println();
1535 | #endif
1536 | 
1537 | }
1538 | 
1539 | 
1540 | //================================================
1541 | // Consumes data from Ethernet until the given 
1542 | // string is found, or time runs out
1543 | //================================================
1544 | byte findUntil (uint8_t *string, boolean terminate) {
1545 |   char currentChar = 0;
1546 |   long timeOut = millis() + 5000;
1547 |   char c = 0;
1548 | 
1549 | #if (DEBUG1)
1550 |   Serial.print (F("\nLooking for: "));
1551 | 
1552 |   for (byte i = 0; string[i] != 0; i ++)
1553 |     Serial.write (string[i]);
1554 |   Serial.println('\n');
1555 | #endif
1556 | 
1557 |   while (millis() < timeOut) {
1558 |     if (client.available()) {
1559 |       timeOut = millis() + 5000;
1560 |       c = client.read();
1561 |       if (terminate && (c == '<')) return 1;  // Pre-empted match
1562 | #if (DEBUG1)
1563 |       Serial.write (c);
1564 | #endif
1565 |       if (c == string[currentChar]) {
1566 |         if (string[++currentChar] == 0) {
1567 | #if (DEBUG1)
1568 |           Serial.println(F("[FOUND]"));
1569 | #endif
1570 |           return 2;                          // Found
1571 |         }
1572 |       } 
1573 |       else currentChar = 0;
1574 |     } 
1575 |   }
1576 |   return 0;                                  // Timeout
1577 | }
1578 | 
1579 | 
1580 | //================================================
1581 | // Delays until Ethernet data is available
1582 | //================================================
1583 | boolean inputWait() {
1584 |   byte wait = 0;
1585 |   long timeOut = millis() + 9000;             // Allow 5 seconds of no data
1586 | #if (DEBUG1)
1587 |   Serial.println ();
1588 | #endif
1589 |   while ((millis() < timeOut) && (!client.available())) {
1590 | #if (DEBUG1)
1591 |     Serial.print (" ");
1592 |     Serial.print (wait * 100);
1593 | #endif
1594 |     delay(++wait * 100);
1595 |   }
1596 |   if ((!client.available()) && (!client.connected())) return 0;
1597 |   else return 1;
1598 | }
1599 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | PIP
  2 | ===
  3 |  PIP Micro Web Browser v0.7
  4 |  Suitable for 32KB Arduino/ATmega use.
  5 |  
  6 |  (c) Chris Anderson 2014.
  7 |  
  8 |  Creative Commons license:
  9 |  Creative Commons Attribution 4.0 International License
 10 |  http://creativecommons.org/licenses/by/4.0/
 11 | 
 12 |  PIP is a functional but incomplete web browser for Arduino and runs 
 13 |  well on an Uno. It can  download and render plain HTML (no images, CSS 
 14 |  or Javascript) and follow  embedded links. It's joystick controlled 
 15 |  and uses a 320x240 LCD screen  for output. 
 16 |  
 17 |  The Ethernet and SD card libraries use about 20KB of code, so the LCD 
 18 |  driver, HTML parser and renderer squeeze in under 12KB. 
 19 |  
 20 |  Requires:
 21 |  
 22 |  * Arduino Uno or similiar ATmega 328 powered board
 23 |  * Wiz5100 powered Ethernet board with SD card slot (SPI CS = 10 & 4)
 24 |  * 320x240 TFT LCD screen (SPI CS = 9)  Found here: http://tinyurl.com/tftlcd
 25 |  * Analogue joystick with button (PS2 style)
 26 |  
 27 |  Installation:
 28 | 
 29 |  * Plug an SD card (MAXIMUM 2GB) into your computer and copy the file 
 30 |   "CACHE.HTM" from this enclosing folder into the root level of the card.
 31 |  * Download the file "HOME.HTM" from the URL below and put it in the enclosing
 32 |    folder. Then copy the file to the root level of the SD card.
 33 |    https://www.dropbox.com/s/v8h2d94uxxcw1oj/HOME.HTM?dl=0
 34 |  * Put the SD card into your Ethernet shield and upload PIP to your Arduino.
 35 |  * Rename the enclosing folder of this file to "PIP_07.ino". 
 36 |  * Copy the enclosing folder into you local Arduino sketch folder, as per 
 37 |    usual for new programs.
 38 |  
 39 |  Wiring for LCD:
 40 |  Name  Pin
 41 |  * SCLK  13  Clock
 42 |  * MOSI  11  Master Out - Don't change or you loose hardware assisted speed
 43 |  * CS    9   Chip Select
 44 |  * DC    8   Data/Comand
 45 |  * RST   7   Reset
 46 |  * LED   Arduino 3.3v
 47 |  * VCC   Arduino 5v
 48 |  * GND   Ground
 49 | 
 50 |  Wiring for joystick:
 51 |  * VRx   A0 - Analogue input 0
 52 |  * VRy   A1
 53 |  * SW    A2
 54 |  * VCC   Arduino 5v
 55 |  * GND   Ground
 56 |  
 57 |  Notes:
 58 |  
 59 |  Handles a sub-set of HTML tags. See tags.h file for list.
 60 |  
 61 |  HTML pages over 20KB or so can stall and fail somewhat randomly. The Wiz5100 
 62 |  just doesn't seem to like dripping data to an Arduino much. Over 1KB/sec 
 63 |  download speed can be cosidered 'good'.
 64 |  
 65 |  Occationally when the browser crashes during a render, the HOME.HTM can get 
 66 |  corrupted. Just copy the file in the enclosing folder back onto the SD card.
 67 |  
 68 |  Due to poor Ethernet and SD card interaction on the SPI bus, the cace file
 69 |  on the SD card is held open as long as possible and only closed and re-opened
 70 |  during HTML download and parsing. That seems to make things ore reliable.
 71 |  
 72 |  HTML files are parsed and made partially binary before being stored on the CD card.
 73 |  File are generally around 50% smaller when unused junk is removed. The stored 
 74 |  file will be truncated to 64KB as 16 bit pointers are being used for page and 
 75 |  URL indexing.
 76 |  May fix this by going to relative pointers.
 77 |  
 78 |  Currently, URLs over 90 characters in size are truncated. This will undoubtably
 79 |  break them, or results in 404 errors. Which aren't handled well yet.
 80 |  
 81 |  The LCD screen is used via a custom library (very similar to the Adafruit GFX 
 82 |  library) which only implements rectangle and character drawing to save space.
 83 |  As only rectangle drawing and the print command are used, it should be easy to 
 84 |  adapt PIP to use a different LCD. 
 85 |  
 86 |  Doesn't do images. Come on, there's only 2KB of memory and a tiny screen 
 87 |  to play with! JPEG parsing might be problematic as there's only 2KB of 
 88 |  program space free.
 89 |  
 90 |  Forms are not even attempted. There's no keyboard, so good luck with that.
 91 |  
 92 |  To do:
 93 |  Handle state case when a page break the middle of a tag.
 94 |  
 95 |  v0.7 14/10/2014
 96 |  Fixed exception for &lt;script> and &lt;style> tags. Improved resiliance
 97 |  to buffer under-runs with slow ethernet connections.
 98 |  
 99 |  v0.6 1/10/2014
100 |  Indexes in-HTML links, shows current link, steps through links
101 |  activates links and handles ethernet buffer under-runs
102 |  
103 |  v0.5 17/9/2014
104 |  Parser re-written as purely state-based, fixed SD card/Ethernet 
105 |  conflicts - somwhat
106 |  
107 |  v0.4 3/9/2014
108 |  Rebuilt and renamed browser as PIP, indexes pages, custom LCD
109 |  libray re-written, optimise parser
110 |  
111 |  v0.3 18/4/1014
112 |  Custom LCD driver library added, buggy
113 |  
114 |  v0.2 27/3/2014
115 |  Downloads and parses basic HTML pages
116 |  
117 |  v0.1 13/3/2014
118 |  Download and display concept, Muzayik
119 | 


--------------------------------------------------------------------------------
/tags.h:
--------------------------------------------------------------------------------
  1 | // Render colour presets
  2 | #define COL_TEXT     0xFFFF  // White
  3 | #define COL_HEADING  0xFFE0  // Yellow
  4 | #define COL_BOLD     0x07E0  // Green  0xF800 //0xFC30  // Red-ish
  5 | #define COL_LINK     0x1B1F  // Blue-ish
  6 | 
  7 | // Specific hash -> tag mappings
  8 | #define BODYTAG       1069   // <body>
  9 | #define BODYTAGEND    1309   // </body>
 10 | #define PRETAG        553    // <pre>
 11 | #define PRETAGEND     673    // </pre>
 12 | #define HREFTAG       2253   // href=
 13 | #define STYLETAG      2577   // <style>
 14 | #define STYLETAGEND   3057   // </style>
 15 | #define SCRIPTTAG     4920   // <script>
 16 | #define SCRIPTTAGEND  5880   // </script>
 17 | #define PIP           546    // <pip> custom tag
 18 | 
 19 | // Use non-printable ASCII characters for tag codes
 20 | #define TAG_CR        14   // ~
 21 | #define TAG_HEADING1  15   // [
 22 | #define TAG_HEADING2  16   // ]
 23 | #define TAG_BOLD1     17   // (
 24 | #define TAG_BOLD2     18   // )
 25 | #define TAG_LINK1     19   // { <a
 26 | #define TAG_LINK2     20   // | URL
 27 | #define TAG_LINK3     21   // } </a>
 28 | #define TAG_HR        22   // %
 29 | #define TAG_LIST      23   // *
 30 | #define TAG_PRE       24   // `
 31 | #define TAG_PRE2      25   // '
 32 | #define TAG_HTTP      26   // http://
 33 | 
 34 | /*
 35 | #define TAG_CR        182  //¶  14   // ~
 36 | #define TAG_HEADING1  167  //§  15   // [
 37 | #define TAG_HEADING2  168  //¨  16   // ]
 38 | #define TAG_BOLD1     185  //¹  17   // (
 39 | #define TAG_BOLD2     186  //º  18   // )
 40 | #define TAG_LINK1     188  //¼  19   // { <a
 41 | #define TAG_LINK2     189  //½  20   // | URL
 42 | #define TAG_LINK3     190  //¾  21   // } </a>
 43 | #define TAG_HR        172  //¬  22   // %
 44 | #define TAG_LIST      164  //¤  23   // *
 45 | #define TAG_PRE       162  //¢  24   // `
 46 | #define TAG_PRE2      163  //£  25   // '
 47 | #define TAG_HTTP      187  //»  26   // http://
 48 | */
 49 | 
 50 | // Hash flags and masks
 51 | #define INLINE       0x8000             // High bit flag for tag allowing post spaces
 52 | #define PRE_BREAK    0x4000             // High bit flag for pre-tag render break
 53 | #define POST_BREAK   0x2000             // High bit flag for post tag break
 54 | #define ATTR_MASK    0x1fff             // Mask to remove high bit flags
 55 | 
 56 | // Hash -> tag & flag mappings
 57 | #define NUMTAGS 76
 58 | static const uint16_t tag_codes[] PROGMEM = {
 59 |   161,   TAG_HEADING1 | PRE_BREAK,           // <h1>
 60 |   162,   TAG_HEADING1 | PRE_BREAK,           // <h2>
 61 |   163,   TAG_HEADING1 | PRE_BREAK,           // <h3>
 62 |   164,   TAG_HEADING1 | PRE_BREAK,           // <h4>
 63 |   80,    TAG_CR | PRE_BREAK,                 // <p>
 64 |   226,   TAG_HR | PRE_BREAK | POST_BREAK,    // <hr>
 65 |   246,   TAG_CR | PRE_BREAK,                 // <ul>
 66 |   234,   TAG_CR | PRE_BREAK,                 // <ol>
 67 |   225,   TAG_LIST | PRE_BREAK,               // <li>
 68 |   PRETAG, TAG_PRE | PRE_BREAK,                // <pre>
 69 | 
 70 |   221,   TAG_HEADING2 | POST_BREAK,          // </h1>
 71 |   222,   TAG_HEADING2 | POST_BREAK,          // </h2>
 72 |   223,   TAG_HEADING2 | POST_BREAK,          // </h3>
 73 |   224,   TAG_HEADING2 | POST_BREAK,          // </h4>
 74 | 
 75 |   443,   TAG_CR | POST_BREAK,       // <br/>
 76 |   214,   TAG_CR | POST_BREAK,       // <br>
 77 |   110,   TAG_CR | POST_BREAK,       // </p>
 78 |   294,   TAG_CR | POST_BREAK,       // </ol>
 79 |   306,   TAG_CR | POST_BREAK,       // </ul>
 80 |   285,   TAG_CR | POST_BREAK,       // </li>
 81 |   PRETAGEND, TAG_PRE2 | POST_BREAK,     // </pre>
 82 | 
 83 |   66,     TAG_BOLD1 | INLINE,       // <b>
 84 |   96,     TAG_BOLD2 | INLINE,       // </b>
 85 |   5199,   TAG_BOLD1 | INLINE,       // <strong>
 86 |   6159,   TAG_BOLD2 | INLINE,       // </strong>
 87 |   65,     TAG_LINK1 | INLINE,       // <a>
 88 |   HREFTAG, TAG_LINK2 | INLINE,       // URL
 89 |   95,     TAG_LINK3 | INLINE,       // </a>
 90 | 
 91 |   1428, 38,  // Ampersand
 92 |   2682, 96,  // 8216; Curly single quote
 93 |   2683, 39,  // 8217; Curly single quote
 94 |   6460, 128,  // nbsp;
 95 |   2680, 34,  // 8220; Curly double quotes
 96 |   2681, 34,  // 8221; Curly double quotes
 97 |   2677, 45,  // 8211; Hyphens en
 98 |   2678, 45,  // 8212; Hyphens em
 99 |   368,  62, // Greater than
100 |   388,  60  // Less than
101 | };
102 | 


--------------------------------------------------------------------------------