#include <EtherCard.h>
#include <TinyXML.h>
#include <Adafruit_GFX.
h>
#include <Adafruit_ST7735.
h>
1 #include <SPI.h>
#include <MemoryFree.h>
#include <stdlib.h>
#include <string.h>
#include <avr/pgmspace.
h>
#define TFT_RST -1
#define TFT_RS 5
#define TFT_LED 6
#define TFT_CS 7
#define SD_CS 8
#define ETHER_CS 10
byte Ethernet::buffer[567]; // 567 is minimum buffer size to avoid losing data
uint32_t last_fetch, bright_on;
char website[] PROGMEM = "weather.yahooapis.com";
Adafruit_ST7735 tft(TFT_CS, TFT_RS, TFT_RST);
//#define DEBUG
#ifdef DEBUG
Print &out = Serial;
#else
Print &out = tft;
#endif
#define IN_LOCATION 1
#define IN_UNITS 2
#define IN_ATMOS 4
#define IN_FORECAST 8
#define IN_WIND 16
#define IN_CONDITION 32
#define DISPLAY_UPDATE 64
#define READING_RESPONSE 128
byte status;
char temp_unit, pres_unit[3], speed_unit[5], condition_code[3], condition_text[32], city[16];
byte wind_speed, atmos_humidity;
int8_t atmos_rising, condition_temp, wind_chill;
uint16_t wind_direction, atmos_pressure;
#define FORECASTS 5
struct forecast {
int8_t low, high;
char code[3], day[4], text[24], date[7];
} forecasts[FORECASTS];
byte fcast;
byte xmlbuf[90];
TinyXML xml;
static int centre_text(const char *s, int x, int size)
{
return x - (strlen(s)*size*6) / 2;
}
static int right(int n, int x, int size)
{
return x - n*size*6;
}
static int val_len(int b)
{
if (b >= 1000) return 4;
if (b >= 100) return 3;
if (b >= 10) return 2;
if (b >= 0) return 1;
if (b > -10) return 2;
return 3;
}
// from Adafruit's spitftbitmap ST7735 example
int bmp_draw(byte *buf, int bufsiz, char *filename, uint8_t x, uint8_t y) {
int bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t buffidx = bufsiz; // Current position in buffer
boolean flip = true; // BMP is stored bottom-to-top
int w, h, row, col;
uint8_t r, g, b;
uint32_t pos = 0;
if((x >= tft.width()) || (y >= tft.height())) return -1;
#ifdef DEBUG
uint32_t startTime = millis();
#endif
int res = PFFS.open_file(filename);
if (res != FR_OK) {
out.print(F("file.open!"));
out.print(' ');
out.print(filename);
out.print(' ');
out.println(res);
return res;
}
// Parse BMP header
uint32_t currPos = 0;
if (read16(currPos) != 0x4D42) {
out.println(F("Unknown BMP signature"));
return -1;
}
#ifdef DEBUG
out.print(F("File size: "));
out.println(read32(currPos));
#else
(void)read32(currPos);
#endif
(void)read32(currPos); // Read & ignore creator bytes
bmpImageoffset = read32(currPos); // Start of image data
#ifdef DEBUG
out.print(F("Image Offset: "));
out.println(bmpImageoffset, DEC);
#endif
// Read DIB header
#ifdef DEBUG
uint32_t header_size = read32(currPos);
out.print(F("Header size: "));
out.println(header_size);
#else
(void)read32(currPos);
#endif
bmpWidth = read32(currPos);
bmpHeight = read32(currPos);
if (read16(currPos) != 1) {
out.println(F("# planes -- must be '1'"));
return -1;
}
bmpDepth = read16(currPos); // bits per pixel
#ifdef DEBUG
out.print(F("Bit Depth: "));
out.println(bmpDepth);
#endif
if((bmpDepth != 24) || (read32(currPos) != 0)) {
// 0 = uncompressed
out.println(F("BMP format not recognized."));
return -1;
}
#ifdef DEBUG
out.print(F("Image size: "));
out.print(bmpWidth);
out.print('x');
out.println(bmpHeight);
#endif
// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * 3 + 3) & ~3;
// If bmpHeight is negative, image is in top-down order.
// This is not canon but has been observed in the wild.
if (bmpHeight < 0) {
bmpHeight = -bmpHeight;
flip = false;
}
// Crop area to be loaded
w = bmpWidth;
h = bmpHeight;
if ((x+w-1) >= tft.width()) w = tft.width() - x;
if ((y+h-1) >= tft.height()) h = tft.height() - y;
// Set TFT address window to clipped image bounds
tft.setAddrWindow(x, y, x+w-1, y+h-1);
for (row=0; row<h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
if (flip) // Bitmap is stored bottom-to-top order (normal BMP)
pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
else // Bitmap is stored top-to-bottom
pos = bmpImageoffset + row * rowSize;
if (currPos != pos) { // Need seek?
PFFS.lseek_file(pos);
currPos = pos;
buffidx = bufsiz; // Force buffer reload
}
for (col=0; col<w; col++) { // For each pixel...
// Time to read more pixel data?
if (buffidx >= bufsiz) { // Indeed
int nread;
PFFS.read_file((char *)buf, bufsiz, &nread);
currPos += nread;
buffidx = 0; // Set index to beginning
}
// Convert pixel from BMP to TFT format, push to display
b = buf[buffidx++];
g = buf[buffidx++];
r = buf[buffidx++];
tft.pushColor(tft.Color565(r,g,b));
} // end pixel
}
#ifdef DEBUG
out.print(F("Loaded in "));
out.print(millis() - startTime);
out.println(F(" ms"));
#endif
return FR_OK;
}
// These read 16- and 32-bit types from the SD card file.
// BMP data is stored little-endian, Arduino is little-endian too.
// May need to reverse subscript order if porting elsewhere.
static uint16_t read16(uint32_t &p) {
uint16_t result;
int n;
PFFS.read_file((char *)&result, sizeof(result), &n);
p += n;
return result;
}
static uint32_t read32(uint32_t &p) {
uint32_t result;
int n;
PFFS.read_file((char *)&result, sizeof(result), &n);
p += n;
return result;
}
static const __FlashStringHelper *cardinal_direction(short deg)
{
if (deg < 12 || deg >= 349)
return F("N");
if (deg >= 12 && deg < 34)
return F("NNE");
if (deg >= 34 && deg < 57)
return F("NE");
if (deg >= 57 && deg < 79)
return F("ENE");
if (deg >= 79 && deg < 102)
return F("E");
if (deg >= 102 && deg < 124)
return F("ESE");
if (deg >= 124 && deg < 147)
return F("SE");
if (deg >= 147 && deg < 169)
return F("SSE");
if (deg >= 169 && deg < 192)
return F("S");
if (deg >= 192 && deg < 214)
return F("SSW");
if (deg >= 214 && deg < 237)
return F("SW");
if (deg >= 237 && deg < 259)
return F("WSW");
if (deg >= 259 && deg < 282)
return F("W");
if (deg >= 282 && deg < 304)
return F("WNW");
if (deg >= 304 && deg < 327)
return F("NW");
// if (deg >= 327 && deg < 349)
return F("NNW");
}
static void display_unit(const char *unit) {
tft.setTextSize(1);
tft.print(unit);
}
static void display_unit(char unit) {
tft.setTextSize(1);
tft.print(unit);
}
static void display_current() {
tft.fillScreen(ST7735_WHITE);
tft.setTextColor(ST7735_BLACK);
tft.setTextSize(2);
tft.setCursor(1, 1);
tft.print(wind_speed);
display_unit(speed_unit);
tft.setCursor(1, 17);
tft.print(cardinal_direction(wind_direction));
tft.setTextSize(2);
tft.setCursor(1, tft.height()-16);
tft.print(condition_temp);
display_unit(temp_unit);
if (condition_temp != wind_chill) {
tft.setCursor(1, tft.height()-24);
tft.print(wind_chill);
}
tft.setTextSize(2);
tft.setCursor(right(val_len(atmos_humidity), tft.width(), 2)-6, tft.height()-16);
tft.print(atmos_humidity);
tft.setCursor(tft.width()-6, tft.height()-16); // ???
display_unit('%');
tft.setTextSize(2);
tft.setCursor(right(val_len(atmos_pressure), tft.width(), 2)-6*strlen(pres_unit), 1);
tft.print(atmos_pressure);
display_unit(pres_unit);
if (atmos_rising == 1) {
tft.setCursor(right(6, tft.width(), 1), 17);
tft.print(F("rising"));
} else if (atmos_rising == -1) {
tft.setCursor(right(7, tft.width(), 1), 17);
tft.print(F("falling"));
}
tft.setCursor(centre_text(city, 80, 1), 30);
tft.println(city);
bmp_draw(xmlbuf, sizeof(xmlbuf), condition_code, 54, 38);
tft.setCursor(centre_text(condition_text, 80, 1), 90);
tft.print(condition_text);
int rad = 60, cx = 80, cy = 64;
const float a = 0.999847695, b = 0.017452406;
// wind dir is azimuthal angle with N at 0
float s = 1.0, c = 0.0;
for (uint16_t i = 0; i < wind_direction; i++) {
const float ns = a*s + b*c;
const float nc = a*c - b*s;
c = nc;
s = ns;
}
// wind dir rotates clockwise so compensate
int ex = cx-rad*c, ey = cy-rad*s;
tft.fillCircle(ex, ey, 3, ST7735_BLACK);
tft.drawLine(ex, ey, ex + wind_speed*(cx - ex)/50, ey+wind_speed*(cy-ey)/50, ST7735_BLACK);
}
static void display_forecast(struct forecast *f)
{
tft.fillScreen(ST7735_WHITE);
tft.setTextSize(2);
tft.setCursor(1, tft.height()-16);
tft.print(f->low);
tft.setTextSize(1);
tft.print(temp_unit);
tft.setCursor(1, tft.height()-24);
tft.print(F("low"));
tft.setTextSize(2);
tft.setCursor(right(val_len(f->high), tft.width(), 2)-6, tft.height()-16);
tft.print(f->high);
tft.setTextSize(1);
tft.setCursor(tft.width()-6, tft.height()-16); // ???
tft.print(temp_unit);
tft.setCursor(right(4, tft.width(), 1), tft.height()-24);
tft.print(F("high"));
tft.setTextSize(2);
tft.setCursor(centre_text(f->day, 80, 2), 14);
tft.print(f->day);
tft.setTextSize(1);
tft.setCursor(centre_text(f->date, 80, 1), 30);
tft.println(f->date);
bmp_draw(xmlbuf, sizeof(xmlbuf), f->code, 54, 38);
tft.setCursor(centre_text(f->text, 80, 1), 90);
tft.print(f->text);
}
static void set_status(int bit, boolean cond)
{
if (cond)
status |= bit;
else
status &= ~bit;
}
static void read_str(const char *from, uint16_t fromlen, char *to, uint16_t tolen, bool update = true)
{
uint16_t len = tolen < fromlen? tolen: fromlen;
if (strncmp(to, from, len) != 0) {
strncpy(to, from, len);
if (len == tolen)
to[len-1] = '\0';
else
to[len] = '\0';
if (update)
set_status(DISPLAY_UPDATE, true);
}
}
static int read_int(const char *from, int curr, bool update = true)
{
int val = atoi(from);
int n = val_len(val);
// bodge for round-up (saves atof)
if (from[n] == '.') {
int r = from[n+1] - '0';
if (r > 4) {
if (val >= 0)
val++;
else
val--;
}
}
if (val != curr && update)
set_status(DISPLAY_UPDATE, true);
return val;
}
static boolean strequals(const char *first, PGM_P second)
{
return strcmp_P(first, second) == 0;
}
static boolean strcontains(const char *first, PGM_P second)
{
return strstr_P(first, second) != 0;
}
void xml_callback(uint8_t statusflags, char *tagName, uint16_t tagNameLen, char *data, uint16_t dlen) {
if (statusflags & STATUS_START_TAG) {
if (tagNameLen) {
set_status(IN_LOCATION, strcontains(tagName, PSTR(":location")));
set_status(IN_UNITS, strcontains(tagName, PSTR(":units")));
set_status(IN_ATMOS, strcontains(tagName, PSTR(":atmos")));
set_status(IN_WIND, strcontains(tagName, PSTR(":wind")));
set_status(IN_CONDITION, strcontains(tagName, PSTR(":condition")));
set_status(IN_FORECAST, strcontains(tagName, PSTR(":forecast")));
}
} else if (statusflags & STATUS_END_TAG) {
if (strequals(tagName, PSTR("/rss")))
fcast = 0;
else if (status & IN_FORECAST) {
fcast++;
if (fcast == FORECASTS)
fcast = 0;
}
} else if (statusflags & STATUS_ATTR_TEXT) {
if (status & IN_LOCATION) {
if (strequals(tagName, PSTR("city")))
read_str(data, dlen, city, sizeof(city));
} else if (status & IN_UNITS) {
if (strequals(tagName, PSTR("temperature")))
temp_unit = *data;
else if (strequals(tagName, PSTR("pressure")))
read_str(data, dlen, pres_unit, sizeof(pres_unit));
else if (strequals(tagName, PSTR("speed")))
read_str(data, dlen, speed_unit, sizeof(speed_unit));
} else if (status & IN_WIND) {
if (strequals(tagName, PSTR("chill")))
wind_chill = read_int(data, wind_chill);
else if (strequals(tagName, PSTR("direction")))
wind_direction = read_int(data, wind_direction);
else if (strequals(tagName, PSTR("speed")))
wind_speed = read_int(data, wind_speed);
} else if (status & IN_ATMOS) {
if (strequals(tagName, PSTR("humidity")))
atmos_humidity = read_int(data, atmos_humidity);
else if (strequals(tagName, PSTR("pressure")))
atmos_pressure = read_int(data, atmos_pressure);
else if (strequals(tagName, PSTR("rising")))
atmos_rising = read_int(data, atmos_rising);
} else if (status & IN_CONDITION) {
if (strequals(tagName, PSTR("code")))
read_str(data, dlen, condition_code, sizeof(condition_code));
if (strequals(tagName, PSTR("text")))
read_str(data, dlen, condition_text, sizeof(condition_text));
else if (strequals(tagName, PSTR("temp")))
condition_temp = read_int(data, condition_temp);
} else if (status & IN_FORECAST) {
if (strequals(tagName, PSTR("day")))
read_str(data, dlen, forecasts[fcast].day, sizeof(forecasts[fcast].day), false);
else if (strequals(tagName, PSTR("low")))
forecasts[fcast].low = read_int(data, forecasts[fcast].low, false);
else if (strequals(tagName, PSTR("high")))
forecasts[fcast].high = read_int(data, forecasts[fcast].high, false);
else if (strequals(tagName, PSTR("code")))
read_str(data, dlen, forecasts[fcast].code, sizeof(forecasts[fcast].code), false);
else if (strequals(tagName, PSTR("text")))
read_str(data, dlen, forecasts[fcast].text, sizeof(forecasts[fcast].text), false);
else if (strequals(tagName, PSTR("date")))
read_str(data, dlen, forecasts[fcast].date, sizeof(forecasts[fcast].date), false);
}
} else if (statusflags & STATUS_ERROR) {
#ifdef DEBUG
out.print(F("\nTAG:"));
out.print(tagName);
out.print(F(" :"));
out.println(data);
#endif
bool rsp = (status & READING_RESPONSE);
status = 0;
set_status(DISPLAY_UPDATE, true);
set_status(READING_RESPONSE, rsp);
}
}
static byte rx()
{
SPDR = 0xFF;
loop_until_bit_is_set(SPSR, SPIF);
return SPDR;
}
static void tx(byte d)
{
SPDR = d;
loop_until_bit_is_set(SPSR, SPIF);
}
uint16_t update_interval = 20*60;
char city_code[7];
char units[2];
byte bright, dim, fade;
static void halt() {
out.println(F("halt"));
for (;;);
}
void setup () {
#ifdef DEBUG
Serial.begin(57600);
#endif
tft.initR(INITR_REDTAB);
tft.setRotation(1);
tft.fillScreen(ST7735_BLACK);
tft.setTextColor(ST7735_WHITE);
tft.setCursor(0,0);
analogWrite(TFT_LED, 0);
out.println(F("Weather Guy (c)2013 Steve"));
out.println(freeMemory());
// initialise the SD card and read the config file
out.print(F("PFFS"));
int res = PFFS.begin(SD_CS, rx, tx);
if (res != FR_OK) {
out.print('!');
out.println(res);
halt();
}
out.println();
out.print(F("Config"));
strcpy_P((char *)xmlbuf, PSTR("config"));
res = PFFS.open_file((char *)xmlbuf);
if (res != FR_OK) {
out.print('!');
out.println(res);
halt();
}
out.println();
int nread;
res = PFFS.read_file((char *)xmlbuf, sizeof(xmlbuf), &nread);
if (res != FR_OK) {
out.print(F("read!"));
out.println(res);
halt();
}
const char *delim = " \n";
char *p = strtok((char *)xmlbuf, delim);
update_interval = atoi(p);
p = strtok(0, delim);
bright = atoi(p);
p = strtok(0, delim);
dim = atoi(p);
p = strtok(0, delim);
strcpy(city_code, p);
p = strtok(0, delim);
strcpy(units, p);
// ethernet interface mac address, must be unique on the LAN
out.print(F("Ethernet"));
byte mac[] = { 0x74, 0x69, 0x69, 0x2d, 0x30, 0x31 };
if (ether.begin(sizeof Ethernet::buffer, mac, ETHER_CS) == 0) {
out.println('!');
halt();
}
out.println();
out.print(F("DHCP"));
if (!ether.dhcpSetup()) {
out.println('!');
halt();
}
out.println();
out.print(F("DNS"));
if (!ether.dnsLookup(website)) {
out.println('!');
halt();
}
ether.persistTcpConnection(true);
xml.init(xmlbuf, sizeof(xmlbuf), xml_callback);
analogWrite(TFT_LED, dim);
fade = dim;
// force first update
last_fetch = -update_interval;
wdt_enable(WDTO_8S);
}
static void net_callback(byte status, word off, word len) {
#ifdef DEBUG
out.println(off);
out.println(len);
#endif
if (status == 1) {
set_status(READING_RESPONSE, len == 512);
char *rs = (char *)Ethernet::buffer+off;
while (len-- > 0) {
#ifdef DEBUG
out.print(*rs);
#endif
xml.processChar(*rs++);
}
}
}
void loop() {
uint32_t now = millis();
ether.packetLoop(ether.packetReceive());
if (fade == dim) {
if (analogRead(A5) == 1023) {
bright_on = now;
fade = bright;
analogWrite(TFT_LED, fade);
}
} else if (now - bright_on > FORECASTS*10000L) {
analogWrite(TFT_LED, fade++);
if (fade == dim)
set_status(DISPLAY_UPDATE, true);
else
delay(25);
}
if (now - last_fetch > update_interval*1000L) {
last_fetch = now;
strcpy_P((char *)xmlbuf, PSTR("?w="));
strcat((char *)xmlbuf, city_code);
strcat_P((char *)xmlbuf, PSTR("&u="));
strcat((char *)xmlbuf, units);
ether.browseUrl(PSTR("/forecastrss"), (char *)xmlbuf, website, PSTR("Accept: text/xml\r\n"), net_callback);
set_status(READING_RESPONSE, true);
} else if (!(status & READING_RESPONSE)) {
wdt_reset();
if (status & DISPLAY_UPDATE) {
display_current();
set_status(DISPLAY_UPDATE, false);
} else if (fade != dim && ((now - bright_on) % 10000) == 0) {
uint32_t t = ((now - bright_on) / 10000) % FORECASTS;
display_forecast(forecasts+t);
}
}
}
