NeoMatrix-Server-W5100.ino

#include <SPI.h>
#include <Ethernet.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>
#include <elapsedMillis.h>
#include <avr/wdt.h>

//#define DEBUG

#ifdef DEBUG
#define Debug(message) Serial.println(F(message))
#else
#define Debug(message)
#endif


#define NEOMATRIX_COLUMNS 31
#define NEOMATRIX_ROWS 8
#define NEOMATRIX_CONTROL_PIN 8
#define CHARACTER_WIDTH 6

/* *********************************
 * Functions and types declarations
 * *********************************/
typedef enum HTTPState
{
    HTTP_IDLE,            /* Waiting for request */
    HTTP_PARSED_HEADERS,  /* Headers parsed  */
    HTTP_PARSED_CONTENT,  /* Content parsed */
    HTTP_PARSED_REQUEST,  /* Request parsed */
    HTTP_ERROR            /* Error. Run away! */
};

void HTTP_parse_request(EthernetClient client);
void HTTP_parse_headers(EthernetClient client, int* content_length);
void HTTP_parse_content(EthernetClient client, int content_length);
void HTTP_send_204(EthernetClient client);
void HTTP_send_500(EthernetClient client);
void content_parser(char c, int position, int length);
void content_parser_init(void);

/* *****************
 * Global variables
 * *****************/

/* Settings for Ethernet */
byte mac[] = { 0x66, 0xff, 0xaa, 0xcc, 0x31, 0x32 };
IPAddress ip(192, 168, 1, 100);
EthernetServer server(80);
HTTPState server_state;

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(
    /* Columns:  */  NEOMATRIX_COLUMNS,
    /* Rows:     */  NEOMATRIX_ROWS,
    /* Data Pin: */  NEOMATRIX_CONTROL_PIN,
    NEO_MATRIX_TOP     + NEO_MATRIX_RIGHT +
    NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
    NEO_GRB            + NEO_KHZ800);

/* Message */
typedef struct display {
    uint16_t color;
    char text[32];
    uint8_t length;
    uint8_t speed;
    bool update;
} display_t;

display_t current_display;

int cursor_pos    = matrix.width();
elapsedMillis timeElapsed;
int interval = 0;

int msglen(int length) {
    if (length * CHARACTER_WIDTH < NEOMATRIX_COLUMNS)
        return NEOMATRIX_COLUMNS * 2;
    else
        return (NEOMATRIX_COLUMNS * 2) + ((length * CHARACTER_WIDTH) - NEOMATRIX_COLUMNS);
}


int freeRam () {
    extern int __heap_start, *__brkval;
    int v;
    return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

int ctoi(char c){
    if (c >= 48 && c <= 57)
        /* 48 - 57 : 0-9 */
        return c - 48;
    if (c >= 97 && c <= 102)
        /* 97 - 102 : a-f */
        return c - 97 + 10;
    if (c >= 65 && c <= 70)
        /* 65 -  70 : A-F */
        return c - 65 + 10;
    return -1;
}

int strhex(char *str) {
    int val, retval = 0;
    char *str_i;
    for (str_i = str; *str_i != '\0'; str_i++) {
        val = ctoi(*str_i);
        if (val>=0)
            retval = (retval * 16) + val;
    }
    return retval;
}

int strint(char *str) {
    int val, retval = 0;
    char *str_i;
    for (str_i = str; *str_i != '\0'; str_i++) {
        val = ctoi(*str_i);
        if (val>=0)
            retval = (retval * 10) + val;
    }
    return retval;
}

int strlength(char *str) {
    int retval=0;
    char *str_i;
    for(str_i = str; *str_i != '\0'; str_i++)
        retval++;
    return retval;
}

/* ************************
 * Arduino entry functions
 * ************************/
void setup()
{

#ifdef DEBUG
    Serial.begin(9600);
#endif

    /* Initialize the ethernet module*/
    Ethernet.begin(mac, ip);
    /* Start server */
    server.begin();

    Debug("Waiting for connections.");

    /* Initialize NeoMatrix */
    matrix.begin();
    matrix.setTextWrap(false);
    matrix.setBrightness(32);

    current_display.color = matrix.Color(0, 200, 0);
    strcpy(current_display.text, "Hello, world!");
    current_display.length = msglen(strlength(current_display.text));
    current_display.speed = 20;
    current_display.update = true;

    /* Enable watchdog */
    wdt_enable(WDTO_1S);
}

void loop()
{
    /* Listen for incoming connections */
    EthernetClient client = server.available();
    server_state = HTTP_IDLE;

    /* Feed watchdog */
    wdt_reset();
    
    /* Check RAM usage */
    if (freeRam() < 16) {
        Debug("RAM is almost full");
        /* HACK ALERT: Watchdog will get us outta here */
        while(1);
    }
    
    if (client)
        /* Client connected */
    {
        Debug("New connection.");

        /* Initialize content parser */
        content_parser_init();
        HTTP_parse_request(client);
        Debug("Request parsed.");
        switch (server_state)
        {
            /* If the request succeeded, send HTTP 204 */
            case HTTP_PARSED_REQUEST:
                Debug("Sending 204");
                HTTP_send_204(client);
                break;
            /* Otherwise, send HTTP 500 */
            case HTTP_ERROR:
            default:
                Debug("Sending 500");
                HTTP_send_500(client);
        }

        /* Close the connection */
        client.stop();
        Debug("Connection closed.");
    }

    if (timeElapsed > interval) {
        /* Text need update ? */
        if(current_display.update) {
            matrix.setTextColor(current_display.color);
            if (current_display.speed > 0) {
                cursor_pos = matrix.width();
                interval = 1000 / current_display.speed;
            }
            else {
                cursor_pos = 0;
                interval = 0;
            }
            current_display.update = false;
        }
        matrix.fillScreen(0);
        matrix.setCursor(cursor_pos, 0);
        matrix.print(current_display.text);
        if(interval > 0 && --cursor_pos < (NEOMATRIX_COLUMNS - current_display.length)) {
            cursor_pos = matrix.width();
        }
        matrix.show();
        timeElapsed = 0;
    }
}

/* ***********************
 * HTTP Handling Functions
 * ***********************/

/* Static keyword strings
 * XXX: These strings eat up the SRAM */
char HTTP_POST_METHOD_STR[]     = "POST";
char HTTP_CONTENT_LENGTH_STR[]  = "Content-Length";

void HTTP_parse_request(EthernetClient client)
{
    /* We should only reach here from the IDLE state */
    if (server_state != HTTP_IDLE)
    {
        /* Set ERROR status and return */
        Debug("Error: Invalid state.");
        server_state = HTTP_ERROR;
        return;
    }

    /* Since this is a new request we should parse
     * the HTTP headers.
     */
    int content_length = 0;
    HTTP_parse_headers(client, &content_length);
    Debug("Headers parsed.");

    /* We should now be in PARSED_HEADER state */
    if (server_state != HTTP_PARSED_HEADERS)
    {
        /* Set ERROR status and return */
        Debug("Error: Invalid state.");
        server_state = HTTP_ERROR;
        return;
    }

    /* If content-length is set non-zero we should now
     * parse the request content
     */
    if (content_length)
    {
        /* Parse the content! */
        HTTP_parse_content(client, content_length);
        Debug("Content parsed.");
        /* We should now be in PARSED_CONTENT state */
        if (server_state != HTTP_PARSED_CONTENT)
        {
            /* Set ERROR status and return */
            Debug("Error: Invalid state.");
            server_state = HTTP_ERROR;
            return;
        }
    }
    server_state = HTTP_PARSED_REQUEST;
    return;
}

void HTTP_parse_headers(EthernetClient client, int *content_length)
{
    /* Parse the HTTP request headers.
     * XXX: We only support POST method for now.
     */

    /* Strings and pointers and fun */

    char *method_ptr = &HTTP_POST_METHOD_STR[0];
    char *clen_ptr = &HTTP_CONTENT_LENGTH_STR[0];
    char clen_val[8] = "\0\0\0\0\0\0\0";
    char *clen_val_i = &clen_val[0];

    /* Parser state */
    enum HTTPHeaderState
    {
        HTTP_HEADER_METHOD = 0,
        HTTP_HEADER_CONTENT_LENGTH,
        HTTP_HEADER_COLON,
        HTTP_HEADER_CONTENT_LENGTH_VAL,
        HTTP_HEADER_PARSING_COMPLETE
    } header_state;

    boolean lineIsBlank = true;

    boolean found[2] = {false, false};

    /* First parse method */
    header_state = HTTP_HEADER_METHOD;

    while (client.connected())
    {
        if (client.available())
        {
            /* Read a character from client */
            char c = client.read();

            /* if we've reached the end of the line and the line is blank,
             * the http headers has ended.
             */
            if (c == '\n' && lineIsBlank)
            {
                if (found[HTTP_HEADER_METHOD]
                 && found[HTTP_HEADER_CONTENT_LENGTH])
                {
                    server_state = HTTP_PARSED_HEADERS;
                    *content_length = strint(clen_val);
                    return;
                }
                else
                {
                    Debug("Error: Header missing.");
                    server_state = HTTP_ERROR;
                    return;
                }
            }
            if (c == '\n')
            {
                /* A new line is starting */
                lineIsBlank = true;
            }
            else if (c != '\r')
            {
                /* There is a character in current line */
                lineIsBlank = false;
            }

            if (header_state == HTTP_HEADER_METHOD)
            {
                if (c == *method_ptr)
                    method_ptr++;
                else
                    method_ptr = &HTTP_POST_METHOD_STR[0];
                if (*method_ptr == '\0')
                {
                    header_state = HTTP_HEADER_CONTENT_LENGTH;
                    found[HTTP_HEADER_METHOD] = true;
                    continue;
                }
            }
            if (header_state == HTTP_HEADER_CONTENT_LENGTH)
            {
                if (c == *clen_ptr)
                    clen_ptr++;
                else
                    clen_ptr = &HTTP_CONTENT_LENGTH_STR[0];
                if(*clen_ptr == '\0')
                {
                    header_state = HTTP_HEADER_COLON;
                    found[HTTP_HEADER_CONTENT_LENGTH] = true;
                    continue;
                }
            }
            if (header_state == HTTP_HEADER_COLON)
            {
                if (c == ' ')
                    continue;
                if (c == ':')
                {
                    header_state = HTTP_HEADER_CONTENT_LENGTH_VAL;
                    continue;
                }
                else
                {
                    server_state = HTTP_ERROR;
                    Debug("Error: Malformed header: Colon.");

                    return;
                }
            }
            if (header_state == HTTP_HEADER_CONTENT_LENGTH_VAL)
            {
                if (c == ' ')
                    continue;
                if ( c == '\r' || c == '\n')
                {
                    header_state = HTTP_HEADER_PARSING_COMPLETE;
                    continue;
                }
                if ( c > 47 && c < 58)
                {
                    *clen_val_i = c;
                    clen_val_i++;
                }
                else
                {
                    server_state = HTTP_ERROR;
                    Debug("Error: Malformed header: Value.");
                    return;
                }
            }
        }
    }
}

void HTTP_parse_content(EthernetClient client, int content_length)
{
    int i, timeout;
    for(i = 0; i < content_length; i++)
    {
        if (!client.connected())
        {
            Debug("Error: Connection dropped.");
            server_state = HTTP_ERROR;
            return;
        }
        /* 1000 ms should be enough for everyone */
        timeout = 1000;
        while(!client.available())
        {
            delay(1);
            if(timeout-- == 0)
            {
                Debug("Error: Connection timeout.");
                server_state = HTTP_ERROR;
                return;
            }
        }
        /* Read a character from client */
        char c = client.read();

        content_parser(c);
    }

    server_state = HTTP_PARSED_CONTENT;
}

void HTTP_send_204(EthernetClient client)
{
    /* Send HTTP OK Status to client without content.
     */
    client.println(F("HTTP/1.1 204 No Content\nServer: Arduino NeoMatrix/0.1\nCache-Control: no-cache\nConnection: close\n\n"));
}

void HTTP_send_500(EthernetClient client)
{
    /* Send HTTP Error Status to client without content.
     */
    client.println(F("HTTP/1.1 500 Internal Server Error\nServer: Arduino NeoMatrix/0.1\nConnection: close\n\n"));
}


/*************************
 * JSON Handling functions
 *************************/

/* Static strings
 * XXX: These strings eat up the SRAM */
char CONTENT_JSON_FIELD_COLOR[] = "color";
char CONTENT_JSON_FIELD_MSG[]   = "text";
char CONTENT_JSON_FIELD_SPEED[] = "speed";

typedef enum ParserState
{
    PARSING_IDLE,        /* Consuming text */
    PARSING_COLOR_KEY,   /* Parsing color field  */
    PARSING_COLOR_VALUE,
    PARSING_TEXT_KEY,    /* Parsing message field */
    PARSING_TEXT_VALUE,
    PARSING_SPEED_KEY,   /* Parsing speed field */
    PARSING_SPEED_VALUE
};

typedef enum ParserExpect
{
    COLON,
    QUOTE,
    STRING
};

/* Use static pointers as iterators */
char *json_color;
char *json_text;
char *json_speed;

ParserState  json_parser_state;
ParserExpect json_parser_expect;

char json_color_field[7];
char json_text_field[33];
char json_speed_field[4];
char buffer[3] = "\0\0";
int characters_rd = 0;
int red;
int green;
int blue;

void content_parser_init(void) {
    Debug("Content parser init");
    /* Set state to idle */
    json_parser_state = PARSING_IDLE;
    /* Reset iterators */
    json_color = &CONTENT_JSON_FIELD_COLOR[0];
    json_text = &CONTENT_JSON_FIELD_MSG[0];
    json_speed = &CONTENT_JSON_FIELD_SPEED[0];
}

void content_parser(char c){
  Debug("Content parser");
  switch(json_parser_state) {
    /*
     * Parser waiting for key. (Idle state)
     */
    case PARSING_IDLE:
    Debug("Parsing idle");
    if(c == *json_text) {
        json_text++;
        json_parser_state = PARSING_TEXT_KEY;
    }    
    else if(c == *json_color) {
        json_color++;
        json_parser_state = PARSING_COLOR_KEY;
    }
    else if(c == *json_speed) {
        json_speed++;
        json_parser_state = PARSING_SPEED_KEY;
    }
    break;

    /*
     * This looks like text field key.
     */
    case PARSING_TEXT_KEY:
    Debug("Parsing text key");
    if(c == *json_text) {
        json_text++;
    }
    else {
        Debug("Else text.");
        json_text = &CONTENT_JSON_FIELD_MSG[0];
        json_parser_state = PARSING_IDLE;
    }
    if (*json_text == '\0') {
        /* Now parsing message */
        Debug("Text field found.");
        json_parser_state = PARSING_TEXT_VALUE;
        json_parser_expect = COLON;
    }
    break;
    case PARSING_COLOR_KEY:
    if(c == *json_color) {
        json_color++;
    }
    else {
        json_color = &CONTENT_JSON_FIELD_COLOR[0];
        json_parser_state = PARSING_IDLE;
    }
    if (*json_color == '\0') {
        /* Now parsing color */
        Debug("Color field found.");
        json_parser_state = PARSING_COLOR_VALUE;
        json_parser_expect = COLON;
    }
    break;
    case PARSING_SPEED_KEY:
    if(c == *json_speed) {
        json_speed++;
    }
    else {
        json_speed = &CONTENT_JSON_FIELD_SPEED[0];
        json_parser_state = PARSING_IDLE;
    }
    if (*json_speed == '\0') {
        /* Now parsing speed */
        Debug("Speed field found.");
        json_parser_state = PARSING_SPEED_VALUE;
        json_parser_expect = COLON;
    }
    break;

    case PARSING_COLOR_VALUE:
        switch (json_parser_expect) {
        case COLON:
            if ( c == ':' )
                json_parser_expect = QUOTE;
           break;
        case QUOTE:
            if ( c == '\"')
                json_parser_expect = STRING;
                characters_rd = 0;
            break;
          case STRING:
            if (++characters_rd > 6) {
                /* Oops. String too long */
                json_parser_state = PARSING_IDLE;
                json_color = &CONTENT_JSON_FIELD_COLOR[0];
            }
            json_color_field[characters_rd - 1] = c;
            if ( c == '\"') {
                /* String read success*/
                json_color_field[characters_rd - 1] = '\0';
                /* Parse red */
                buffer[0] = json_color_field[0];
                buffer[1] = json_color_field[1];
                red = strhex(buffer);
                /* Parse green */
                buffer[0] = json_color_field[2];
                buffer[1] = json_color_field[3];
                green = strhex(buffer);
                /* Parse blue */
                buffer[0] = json_color_field[4];
                buffer[1] = json_color_field[5];
                blue = strhex(buffer);
                current_display.color = matrix.Color(red, green, blue);
                current_display.update = true;
                json_parser_state = PARSING_IDLE;
                json_color = &CONTENT_JSON_FIELD_COLOR[0];
            }
            break;
      }
      break;
    case PARSING_TEXT_VALUE:
      switch (json_parser_expect) {
        case COLON:
              if ( c == ':' )
                  json_parser_expect = QUOTE;
              break;
          case QUOTE:
              if ( c == '\"')
                  json_parser_expect = STRING;
                  characters_rd = 0;
              break;
          case STRING:
              if (++characters_rd > 32) {
                  /* Oops. String too long */
                  json_parser_state = PARSING_IDLE;
                  json_text = &CONTENT_JSON_FIELD_MSG[0];
              }
              json_text_field[characters_rd - 1] = c;
              if ( c == '\"') {
                  /* String read success*/
                  json_text_field[characters_rd - 1] = '\0';
                  strcpy(current_display.text, json_text_field);
                  current_display.length = msglen(strlength(current_display.text));
                  current_display.update = true;
                  json_parser_state = PARSING_IDLE;
                  json_text = &CONTENT_JSON_FIELD_MSG[0];
              }
              break;
      }
      break;

    case PARSING_SPEED_VALUE:
      switch (json_parser_expect) {
          case COLON:
              if ( c == ':' )
                  json_parser_expect = QUOTE;
              break;
          case QUOTE:
              if ( c == '\"')
                  json_parser_expect = STRING;
                  characters_rd = 0;
              break;
          case STRING:
              if (++characters_rd > 3) {
                  /* Oops. String too long */
                  json_parser_state = PARSING_IDLE;
                  json_speed = &CONTENT_JSON_FIELD_SPEED[0];
              }
              json_speed_field[characters_rd - 1] = c;
              if ( c == '\"') {
                  /* String read success*/
                  json_speed_field[characters_rd - 1] = '\0';
                  current_display.speed = strint(json_speed_field);
                  current_display.update = true;
                  json_parser_state = PARSING_IDLE;
                  json_speed = &CONTENT_JSON_FIELD_SPEED[0];
              }
              break;
      }
      break;
    }
}