gistfile1.ino

#include <SPI.h>
#include <Ethernet.h>
#include <Flash.h>
#include <SD.h>
#include <TinyWebServer.h>
#include <IRremote.h>
#include <OneWire.h>

#define SONY 1
#define RC6 1
#define RAW 1

byte mac[] = { 0x90, 0xA2, 0xDA, 0x0C, 0x00, 0x0B };
IPAddress ip( 192,168,1,25 );
IPAddress gateway( 192,168,1,1 );
IPAddress subnet( 255,255,255,0 );
IPAddress dns( 192,168,1,1 );

char inbuffer[256]; //256 characters should be okay.
int index = 1;


const int SD_CS = 4;
const int ETHER_CS = 10;

OneWire ds(2);

boolean file_handler(TinyWebServer& web_server);
boolean index_handler(TinyWebServer& web_server);
boolean mobile_handler(TinyWebServer& web_server);
boolean temps_handler(TinyWebServer& web_server);
boolean post_handler(TinyWebServer& web_server);

TinyWebServer::PathHandler handlers[] = {
  {"/", TinyWebServer::GET, &index_handler },
  {"/mobile", TinyWebServer::GET, &mobile_handler },
  {"/temps.json", TinyWebServer::GET, &temps_handler },
  {"/ir", TinyWebServer::POST, &post_handler },
  {"/" "*", TinyWebServer::GET, &file_handler },
  {NULL},
};

const char* headers[] = {
  "Content-Length",
  NULL
};

TinyWebServer web = TinyWebServer(handlers, headers);

boolean has_filesystem = true;
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;

void send_file_name(TinyWebServer& web_server, const char* filename) {
  if (!filename) {
    web_server.send_error_code(404);
    web_server << F("Could not parse URL");
  } else {
    TinyWebServer::MimeType mime_type
      = TinyWebServer::get_mime_type_from_filename(filename);
    web_server.send_error_code(200);
    web_server.send_content_type(mime_type);
    web_server.end_headers();
    if (file.open(&root, filename, O_READ)) {
      web_server.send_file(file);
      file.close();
    } else {
      web_server << F("Could not find file: ") << filename << "\n";
    }
  }
}

boolean file_handler(TinyWebServer& web_server) {
  char* filename = TinyWebServer::get_file_from_path(web_server.get_path());
  char* foo = web_server.get_foo();
  char *str;
  
  // while ((str = strtok_r(foo, "/", &foo)) != NULL) {
  //    // Serial.println(str);
  //      Serial << F("Foo: ") << str << "\n";
  // }

  // Serial << F("Filename: ") << filename << "\n";
  // Serial << F("Path: ") << web_server.get_path() << "\n";  
  send_file_name(web_server, filename);
  free(filename);
  return true;
}

boolean mobile_handler(TinyWebServer& web_server) {
  send_file_name(web_server, "/mobile/index.htm");
  return true;
}

boolean index_handler(TinyWebServer& web_server) {
  send_file_name(web_server, "index.htm");
  Serial << F("Free RAM: ") << FreeRam() << "\n";
  return true;
}

boolean temps_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("application/json");
  web_server.end_headers();
  // web_server << getTemps();
  return true;
}

boolean post_handler(TinyWebServer& web_server) {
  Serial << F("Post Event") << "\n";
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  if(client) {
   while (client.connected() && client.available()) {
  	  char c = client.read();
  	  //inbuffer[0] = c; //the first character gets cut off in while loop. get it now.
      Serial.write(client.read());
      while(client.available()) {
        Serial.write(client.read());
       // if(index < 255) {
         // inbuffer[index] = c;
         // index++;
         // inbuffer[index] = '\0';
        //y}
      }
      Serial << "\n";
      // Serial << F("Read: ") << inbuffer << "\n";
   }
  }
  return true;
}


// char *getTemps(){
//   return true;
// }

void setup() {
  Serial.begin(115200);
  
  pinMode(SS_PIN, OUTPUT);
  digitalWrite(SS_PIN, HIGH);

  pinMode(ETHER_CS, OUTPUT);
  digitalWrite(ETHER_CS, HIGH);

  pinMode(SD_CS, OUTPUT);
  digitalWrite(SD_CS, HIGH);

  // initialize the SD card.
  if (!card.init(SPI_FULL_SPEED, SD_CS)) {
    has_filesystem = false;
  }
  // initialize a FAT volume.
  if (!volume.init(&card)) {
    has_filesystem = false;
  }
  if (!root.openRoot(&volume)) {
    has_filesystem = false;
  }

  Ethernet.begin(mac, ip, dns, gateway, subnet);
  web.begin();
}

void loop() {
  if (has_filesystem) {
    web.process();
  }
}