root/trunk/goodrobot/robot/plugins/arduino_ethernet/arduino_ethernet.pde

/*
  GoodRobot Arduino Ethernet connectivity

  This sketch provides a standard get/set functionality via 
  GoodRobot server. You can (via the server) set any pin to
  some value or get any value of a pin. Supported pins:

  digitalInp0 to digitalInp19 (analog pins 0 to 5 are mapped
                               to 14 to 19, if so desired)
  digitalOut0 to digitalOut13
  pwm0 to pwm13 (you should make sure that hardware supports
                 those pins)
  analogInp0 to  analogInp5 (for all boards)
  analogInp0 to  analogInp7 (for mini and nano)
  servo0 to servo13 (pwm pins 9 and 10 won't work)

  For your custom setup, You need to modify the following:

  Note: All changes to be made, as documented below are moved
  to config_params.h. In general you may not need to edit THIS
  file, but only config_params.h

  1. Your IP (ip[]), Gateway (gateway[]) and if you need the mac[]
  2. The putString[] needs to reflect the "robot" name in the 
     GoodRobot server. 
  3. The secret_key as well
  4. The server IP (server[]) - You may not need to modify this.

  Optionally, you need
  5. You can configure only some pins, so that, those pins data will
  be periodically posted to the server. If you don't, all pins will be 
  available for set/get -- but will only send the data, when requested.
  That may add some latency, which may be undesirable.

  To pre-configure pins, that will periodically send the values to the
  server, put in code similar to this, in config() function:
  (NOTE: All digital pins are to use cfg_pins[], including PWM
  All analog pins are to use cfg_apins[])

  cfg_pins[3] = 'p';  // Pin 3 is set for PWM mode
  cfg_pins[4] = 'i';  // Pin 4 is set for digital Input mode
  cfg_pins[5] = 'o';  // Pin 5 is set for digital Output mode
  cfg_apins[2] = 'a';  // Pin 2 analog mode
  cfg_pins[9] = 's';  // Pin 9 is set for Servo mode

  6. Enable ResetonTimeout Feature: If there is no real data from the 
  server for timeout time period, you may want to reset the pins to 
  LOW (digitalOut) or 0 (pwm). To configure this feature,
  put in code similar to this in config() function: 

  reset_pins[3] = 'p' // Pin 3, PWM mode, should be reset to 0
  reset_pins[4] = 'o' // Pin 4, digitalOut mode, should be reset to LOW
  reset_pins[5] = 't' // Pin 5, PWM mode/Tank drive, should be reset to 127
  reset_pins[6] = 's' // Pin 6, Servo mode, should be reset to 0

  Also modify, SERVER_TIMEOUT define to suit your needs.

  7. You can also modify SEND_FREQ define to specify how frequently you
  should send data to the server, when the incoming data is active. Use
  SEND_IDLE_FREQ to specify the frequency during Idle time.

  8. Arduino provides a way to turn on the PullupResistors, by setting
  pinmode to INPUT and then doing digitalWrite with HIGH. See
  http://arduino.cc/en/Tutorial/DigitalPins for details.
  If you want to do any such thing, you can do that in the config() 
  function, and always use that pin as digitalInp.
 
  9. Now, Arduino can act as multiple components. ie. when it sends data, it
  can identify itself as one of many component names. However, emulating more
  than two components can hit performance at high speeds, it is limited to
  two components. To send data as two components, do the following:
    a) Set max_loops variable to 2. If you leave it as 1, it will continue
    its current behavior of sending all data as one component.
    b) Set your first component name (as usual) in putString[] and secret_key[]
    c) Set your second component name in putString2[] and secret_key2[]. Even
       if you don't use it, you need to define it though!
    d) In the config() function, set those pins that need to be sent as first 
       component as cfg_pins[] for digital and cfg_apins[] for analog -- as you
       would do normally.
    e) For the second component, set those pins as cfg2_pins[] for digital/pwm 
       and cfg2_apins[]

  10. Arduino has very limited RAM, and thus was causing severe problems, when
  you exceed that. The worst problem is that we don't know, that we are overwriting
  heap and stack. So read these URLs:
     http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1213583720/all
     http://www.arduino.cc/playground/Code/AvailableMemory
     http://www.arduino.cc/en/Reference/PROGMEM
  The last url allows us to place some text strings (that won't change) in Flash 
  memory (rather than in SRAM). Because of that some strings are defined differently
  to place them in Flash mem. Make sure you don't remove those "PROGMEM" definitions.
  
  11. Now the sketch supports Servo motor support. You need to do the following to
  setup Servo motor.
    a) In config() function, cfg_pins[pin] to 's'. Also if you wish that the software
    do resetOnTimeout feature, specify reset_pins[pin] to 's'
    b) Tag names used to send data is "servoX" where X is the pin number.
  As per Arduino site, pins 9 and 10 are not available for PWM functions, if Servo
  support is comiled in. Excerpts:
  As of Arduino 0017, the Servo library supports up to 12 motors on most Arduino boards and 
  48 on the Arduino Mega. On boards other than the Mega, use of the library disables 
  analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on those pins. 
  On the Mega, up to 12 servos can be used without interfering with PWM functionality; 
  use of 12 to 23 motors will disable PWM on pins 11 and 12.

*/
#include <avr/pgmspace.h>
#include <string.h>
#include <Ethernet.h>
#include <Servo.h>


/* Max tags that we will process */
#define MAX_TAGS   20
/* Max size for each tag and value*/
#define MAX_TAG_SIZE   20
#define MAX_VAL_SIZE   20

#define MAX_PINS 20
#define MAX_APINS 6   /* Max Analog Pins */

/* All analog pins from 0 to 5/7 are mapped to 14 to 19/21 
   INTERNALLY, for easier management. Externally this is not
   exposed
*/
#define ANALOG_MAP_BASE  14  
#define SEND_BUF_LEN   200
char sendbuf[SEND_BUF_LEN];

char crlf[] = "\r\n\r\n";
char lf[] = "\n";
char lflf[] = "\n\n";
char id_[] = "id=";
char comma[] = ",";

char cstr_cl[] PROGMEM = "Content-Length: ";
char cstr_tag[] PROGMEM = "tag="; 
char cstr_value[] PROGMEM = "value=";
char cstr_digout[] PROGMEM = "digitalOut";
char cstr_diginp[] PROGMEM = "digitalInp";
char cstr_anainp[] PROGMEM = "analogInp";
char cstr_pwm[] PROGMEM = "pwm";
char cstr_none[] PROGMEM = "id=0,tag=none,value=none\n";
char cstr_noctrl[] PROGMEM = "No control data";
char cstr_connfailed[] PROGMEM = "Connection failed";
char cstr_dataend[] PROGMEM = "Data end";
char cstr_timeout[] PROGMEM = "timeout break";
char cstr_servo[] PROGMEM = "servo";

char cfg_pins[MAX_PINS];
char cfg_apins[MAX_APINS];
char cfg2_pins[MAX_PINS];
char cfg2_apins[MAX_APINS];
char reset_pins[MAX_PINS];

int pins[MAX_PINS];
int got_pins[MAX_PINS];



/* Storage details of received tags */
char tags[MAX_TAGS][MAX_TAG_SIZE];
char vals[MAX_TAGS][MAX_VAL_SIZE];
int tag_cnt, tag_mode, tag_spos, tag_dpos, tag_epos;
int val_cnt, val_mode, val_spos, val_dpos, val_epos;
int wait_mode, wait_spos, data_start, data_end;
int cur_loop = 0;
int max_loops = 1;

unsigned long control_lastseen = 0;
unsigned long last_sent_time = 0;
int control_ready = 0;
Servo myservo[14];

#include "config_params.h"

PROGMEM const char *string_table[] = {
  putString,                  // 0
  hostString,                 // 1
  secret_key,                 // 2
  putString2,                 // 3
  secret_key2,                // 4
  cstr_cl,                    // 5
  cstr_tag,                   // 6
  cstr_value,                 // 7
  cstr_digout,                // 8
  cstr_diginp,                // 9
  cstr_anainp,                // 10
  cstr_pwm,                   // 11
  cstr_none,                  // 12
  cstr_noctrl,                // 13
  cstr_connfailed,            // 14
  cstr_dataend,               // 15
  cstr_timeout,               // 16
  cstr_servo                  // 17
};

// Temp buffer
char tbuf[50];

Client client(server, 80);

/* Equiv of strcat */
void catstr(char *buf, char src[])
{
  int buf_idx, src_idx, i, j;

  buf_idx = strlen(buf);
  src_idx = strlen(src);
  for(i=0; i < src_idx; i++)
    buf[buf_idx+i] = src[i];
  buf[buf_idx+src_idx] = 0;
}

/* Like strcat, but the input is a integer
   which is concat as Decimal to the string */
void icatstr(char *buf, int num)
{
  int i, idx;

  idx = strlen(buf);
  if(num < 0) {
    buf[idx++] = '-';
    num = 0 - num;
  }
  for(i=10000; i > 0; i = i / 10)
    if(num >= i)
      break;

  if(i==0)
    buf[idx++] = 0x30;

  for(; i > 0; i = i / 10) {
    buf[idx++] = 0x30 + (num/i);
    num = num % i;
  }
  buf[idx] = 0;
}

void setup()
{
  Ethernet.begin(mac, ip, gateway);
  Serial.begin(9600);
  for(int i=0; i < MAX_PINS; i++) {
    pins[i] = 0;
    got_pins[i] = 0;
    reset_pins[i] = 0;
    cfg_pins[i] = 0;
    if(i < MAX_APINS)
      cfg_apins[i] = 0;
  }
  config();
  initPins();

  delay(2000);
}


int getValLength(unsigned int x)
{
  if(x < 10)
    return 1;
  if(x < 100)
    return 2;
  if(x < 1000)
    return 3;
  return 4;
}

void resetPins()
{
  // Reset only 
  if(!control_ready)
    return;
  if(millis() - control_lastseen < SERVER_TIMEOUT)
    return;
  for(int i=0; i < MAX_PINS; i++) {
    if(reset_pins[i] == 'p' || reset_pins[i] == 'o') {
      digitalWrite(i, LOW); // Both for digitalOut and PWM
      pins[i] = 0;
    }
    if(reset_pins[i] == 't') {
      analogWrite(i, 127);
      pins[i] = 127;
    }
    if(i < 14 && reset_pins[i] == 's') { // Servo motor
      myservo[i].write(0);
      pins[i] = 0;
    }
  }
  control_ready = 0;
  Serial.println("Resetting pins");
} 

void initPins()
{
  for(int i=0; i < MAX_PINS; i++) {
    if(reset_pins[i] == 'p' || reset_pins[i] == 'o')
      digitalWrite(i, LOW); // Both for digitalOut and PWM
    if(reset_pins[i] == 't')
      analogWrite(i, 127);
    if(i < 14 && cfg_pins[i] == 's') {
      myservo[i].attach(i);
      if(reset_pins[i] == 's') // Servo motor
        myservo[i].write(0);
    }
  }
}


int processData()
{
  int pin;
  char *p;

  for(int i=0; i < MAX_PINS; i++)
    got_pins[i] = 0;

  for(int cnt=0; cnt < tag_cnt; cnt++) {
    /* If tag is "none", we are done */
    if(strcmp(tags[cnt], "none") == 0) {
      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[13]))); // 13 - cstr_noctrl
      Serial.println(tbuf);
      return 0;
    }
    /* If tag is "error" */
    if(strcmp(tags[cnt], "error") == 0) {
      Serial.print("ERROR: ");
      Serial.println(vals[cnt]);
      return 0;
    }

    if(cnt > val_cnt)
      break;

    /* If tag is digitalOut */
    strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[8]))); // 8 - cstr_digout
    if(strncmp(tags[cnt], tbuf, 10) == 0) {
      pin = atoi(&(tags[cnt][10]));
      if(pin >= MAX_PINS || pin < 0)
        continue;

      control_lastseen = millis();
      control_ready = 1;
      /* Store the value */
      got_pins[pin] = 'o';
      pins[pin] = atoi(vals[cnt]);

      if(pins[pin] > 0)
        pins[pin] = 1;
      else
        pins[pin] = 0;

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[8]))); // 8 - cstr_digout
      Serial.print(tbuf);

      Serial.print(pin, DEC);

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
      Serial.print(tbuf);

      Serial.println(pins[pin], DEC);

      pinMode(pin, OUTPUT);
      if(pins[pin])
        digitalWrite(pin, HIGH);
      else
        digitalWrite(pin, LOW);
    }

    /* If tag is digitalInp */
    strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[9]))); // 9 - cstr_diginp
    if(strncmp(tags[cnt], tbuf, 10) == 0) {
      pin = atoi(&(tags[cnt][10]));
      if(pin >= MAX_PINS || pin < 0)
        continue;

      control_lastseen = millis();
      control_ready = 1;
      /* Store the value */
      got_pins[pin] = 'i';
      pinMode(pin, INPUT);
      pins[pin] = digitalRead(pin);

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[9]))); // 9 - cstr_diginp
      Serial.print(tbuf);

      Serial.print(pin, DEC);

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
      Serial.print(tbuf);

      Serial.println(pins[pin], DEC);
    }

    /* If tag is analogInp */
    strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[10]))); // 10 - cstr_anainp
    if(strncmp(tags[cnt], tbuf, 9) == 0) {
      pin = atoi(&(tags[cnt][9]));
      if(pin >= MAX_PINS || pin < 0)
        continue;

      control_lastseen = millis();
      control_ready = 1;
      /* Store the value */
      got_pins[pin+ANALOG_MAP_BASE] = 'a';
      pins[pin+ANALOG_MAP_BASE] = analogRead(pin);

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[10]))); // 10 - cstr_anainp
      Serial.print(tbuf);

      Serial.print(pin, DEC);
      Serial.print(' ', BYTE);

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
      Serial.print(tbuf);

      Serial.print(pins[pin+ANALOG_MAP_BASE], DEC);
      Serial.print(' ', BYTE);
      Serial.print('r', BYTE);
      Serial.print(' ', BYTE);
      Serial.println(atoi(vals[cnt]));
    }

    /* If tag is pwm */
    strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[11]))); // 11 - cstr_pwm
    if(strncmp(tags[cnt], tbuf, 3) == 0) {
      pin = atoi(&(tags[cnt][3]));
      if(pin >= MAX_PINS || pin < 0)
        continue;

      control_lastseen = millis();
      control_ready = 1;
      /* Store the value */
      got_pins[pin] = 'p';
      pins[pin] = atoi(vals[cnt]);

      if(pins[pin] < 0)
        pins[pin] = 0;
      if(pins[pin] > 255)
        pins[pin] = 255;

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[11]))); // 11 - cstr_pwm
      Serial.print(tbuf);

      Serial.print(&(tags[cnt][3]));

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
      Serial.print(tbuf);

      Serial.println(pins[pin], DEC);

      pinMode(pin, OUTPUT);
      analogWrite(pin, pins[pin]);

    }
    
    strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[17]))); // 17 - cstr_servo
    if(strncmp(tags[cnt], tbuf, 5) == 0) {
      pin = atoi(&(tags[cnt][5]));
      if(pin >= 14 || pin < 0)
        continue;

      control_lastseen = millis();
      control_ready = 1;
      /* Store the value */
      got_pins[pin] = 's';
      pins[pin] = atoi(vals[cnt]);

      if(pins[pin] < 0)
        pins[pin] = 0;
      if(pins[pin] > 180)
        pins[pin] = 180;

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[17]))); // 17 - cstr_servo
      Serial.print(tbuf);

      Serial.print(&(tags[cnt][5]));

      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
      Serial.print(tbuf);

      Serial.println(pins[pin], DEC);

      myservo[pin].write(pins[pin]);

    }
    
    delay(1);

  }
}

/*
Parses the input and looks for start and end pattern, and collects
the value in between. The parameters are:

  char inp     -- Input byte received now
  char start[] -- start pattern
  char end[]   -- end   pattern
  int maxlen   -- Max bytes to match
  int *mode    -- Is it matching now start(0)|data(1)|end(2)?

  char results[][] -- Store the results. Two dimensional array
  int  *rescnt     -- Which result is it being stored now?
  int  maxresults  -- How many results to store?

  int *spos    -- Variable initially initialized to 0, used
          internally to track the start pattern
  int *epos    -- Variable initially initialized to 0, used
          internally to track the end pattern
  int *dpos    -- Variable initially initialized to 0, used
          internally to track the data received
*/

int parseInput(char inp, char start[], char end[], int maxlen, int *mode,
         char results[][20], int *rescnt, int maxresults,
         int *spos, int *epos, int *dpos)
{
  if(0 == (unsigned long)spos || 0 == (unsigned long)mode)
    return 0;

  // Start pattern
  if(*mode == 0) {
    if(inp == start[*spos]) { /* Matched */
      if(((*spos)+1) == strlen(start)) { /* end of start */
        *spos = 0;
        *mode = 1;
      } else  {  /* Next start byte */
        (*spos)++;
      }
    }
    else { /* Not matched */
      *spos = 0;
    }
    /* Simple hack to make this function as waitInput().
    If end is not defined, then we consider *rescnt as ready and 
    end this function
    */
    if(end == NULL && *mode == 1) {
      *mode = 0;
      return 1;
    }
    return 0;
  }

  if(0 == (unsigned long)results || 0 == (unsigned long)rescnt)
    return 0;
  if(0 == (unsigned long)dpos || 0 == (unsigned long)epos)
    return 0;

  if(*rescnt > maxresults)
    return 0;

  // Data pattern (still store, even before end is matched)
  if(*mode == 1) {
    if(*dpos < maxlen) {
      /* We increment now, but after end pattern resolves,
         it is subtracted
       */
      results[*rescnt][*dpos] = inp;
      (*dpos)++;
      results[*rescnt][*dpos] = 0;
    }
    else {
      /* Has exceeded maxlen */
      results[*rescnt][*dpos] = 0;
    }
      
  }

  if(0 == (unsigned long)end)
    return 0;
  
  // end pattern (continue after storing data pattern)
  if(*mode > 0) {
    if(inp == end[*epos]) { /* Matched */
      if(((*epos)+1) == strlen(end)) { /* end of end */
        *spos = *epos = *mode = 0;
        *dpos = *dpos - strlen(end);
        results[*rescnt][*dpos] = 0;
        *dpos = 0;
        (*rescnt)++;
        return 1;
      }
      else { /* next end byte */
        (*epos)++;
      }
    }
    else { /* Not matched */
      *epos = 0;
    }
    return 0;
  }

  return 0;
}

int getContentLength()
{
  int len = 0;
  int pin, stdtxt;
  int cfg, cfga;

  /* Find content length */
  stdtxt = 17; // strlen("id=0,tag=,value=\n");
  for(pin=0; pin < MAX_PINS; pin++) {

    cfg = cfga = 0;
    if(cur_loop == 0)  {
      cfg = cfg_pins[pin];
      if(pin >= ANALOG_MAP_BASE)
        cfga = cfg_apins[pin];
    }
    if(cur_loop == 1) {
      cfg = cfg2_pins[pin];
      if(pin >= ANALOG_MAP_BASE)
        cfga = cfg2_apins[pin];
    }

    /* Set pre-configured pins here */
    if(!got_pins[pin]) {
      if(cfg) {
        got_pins[pin] = cfg;
        if(cfg == 'i')
          pins[pin] = digitalRead(pin);
      }
      if(pin >= ANALOG_MAP_BASE && cfga) {
        got_pins[pin] = 'a';
        pins[pin] = analogRead(pin-ANALOG_MAP_BASE);
      }
    }

    if(!got_pins[pin])
      continue;

    len += stdtxt + 1;  /* 1 is for pin number */
    /* If pin number is greater than 9 */
    if(pin > 9)
      len++;
    if(got_pins[pin] == 'o') /* digitalOut and value */
      len += 10 + 1;
    if(got_pins[pin] == 'i') /* digitalInp and value */
      len += 10 + 1;
    if(got_pins[pin] == 'a') /* analogInp */
      len += 9 + getValLength(pins[pin]) - 1; /* -1 for pin number mapping */
    if(got_pins[pin] == 'p') /* pwm */
      len += 3 + getValLength(pins[pin]);
    if(got_pins[pin] == 's') /* servo */
      len += 5 + getValLength(pins[pin]);
  }

  if(len==0) {
    len += stdtxt + 8; // 8 is none twice 
  }

  return len;
}


int sendData(int len)
{
  int pin = 0;
  int id = 0;

  client.connect();

  if(!client.connected()) {
    client.stop();
    if(!client.connect()) {
      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[14]))); // 14 - cstr_connfailed
      Serial.println(tbuf);
      return false;
    }
  }

  /* Send data */  
  // Serial.println("Connected!");
  sendbuf[0] = 0;
  if(cur_loop == 0)
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[0]))); // 0 - putString
  if(cur_loop == 1) 
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[3]))); // 3 - putString2

  strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[1]))); // 1 - hostString

  if(cur_loop == 0)
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[2]))); // 2 - secret_key
  if(cur_loop == 1)
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[4]))); // 4 - secret_key2

  strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[5]))); // 5 - cstr_cl
  icatstr(sendbuf, len);
  catstr(sendbuf, crlf);

  for(pin=id=0; pin < MAX_PINS; pin++) {
    if(!got_pins[pin])
      continue;

    catstr(sendbuf, id_);
    icatstr(sendbuf, id++);

    catstr(sendbuf, comma);
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[6]))); // 6 - cstr_tag

    if(got_pins[pin] == 'o') /* digitalOut and value */
      strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[8]))); // 8 - cstr_digout
    if(got_pins[pin] == 'i') /* digitalInp and value */
      strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[9]))); // 9 - cstr_diginp
    if(got_pins[pin] == 'a') /* analogInp */
      strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[10]))); // 10 - cstr_anainp
    if(got_pins[pin] == 'p') /* pwm */
      strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[11]))); // 11 - cstr_pwm
    if(got_pins[pin] == 's') /* servo */
      strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[17]))); // 17 - cstr_servo
      
    if(got_pins[pin] == 'a') 
      icatstr(sendbuf, pin-ANALOG_MAP_BASE);
    else
      icatstr(sendbuf, pin);

    catstr(sendbuf, comma);
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[7]))); // 7 - cstr_value
    icatstr(sendbuf, pins[pin]);
    catstr(sendbuf, lf);

    /* Make sure we don't exceed sendbuf */
    if(strlen(sendbuf) > SEND_BUF_LEN-50) {
      client.print(sendbuf);
      sendbuf[0] = 0;
    }
  }

  if(id == 0)
    strcat_P(sendbuf, (char*)pgm_read_word(&(string_table[12]))); // 12 - cstr_none

  catstr(sendbuf, crlf);
  client.print(sendbuf);
  last_sent_time = millis();
}

int getData()
{
  unsigned long loop_time = 0;

  data_start = data_end = 0;
  tag_cnt = tag_mode = tag_spos = tag_dpos = tag_epos = 0;
  val_cnt = val_mode = val_spos = val_dpos = val_epos = 0;
  wait_mode = wait_spos = 0;
  sendbuf[0] = 0;

  /* Wait in a small loop, until data arrives */
  loop_time = millis();
  while(1) {
    if(client.available()) {
      char inp = client.read();
      if(data_start == 0 && parseInput(inp, crlf, NULL, 0, &wait_mode,
                                       NULL, NULL, 0, &wait_spos, NULL, NULL)) {
        data_start = 1;
        wait_mode = wait_spos = 0;
      }
      if(data_start == 1) {
        parseInput(inp, ",tag=", ",", MAX_TAG_SIZE - 1, &tag_mode,
                   tags, &tag_cnt, MAX_TAGS, 
                   &tag_spos, &tag_epos, &tag_dpos);
        parseInput(inp, ",value=", "\n", MAX_VAL_SIZE - 1, &val_mode,
                   vals, &val_cnt, MAX_TAGS, 
                   &val_spos, &val_epos, &val_dpos);
        /* For data_end */
        data_end = parseInput(inp,lflf, NULL, 0, &wait_mode,
                   NULL, NULL, 0, &wait_spos, NULL, NULL);
        if(data_end) {
          // Serial.println(cstr_dataend);
          while(client.available()) { client.read(); }
          break;
        }
        continue;

      }
      continue;
    }
    
    if(millis() - loop_time > 10000) {
      strcpy_P(tbuf, (char*)pgm_read_word(&(string_table[16]))); // 16 - cstr_timeout
      Serial.println(tbuf);
      break;
    }
    
    resetPins();
    // delay(1);
  }
  
}


void loop()
{
  int len;
  unsigned long tm;

  tm = millis();
  if((control_ready && tm - last_sent_time > SEND_FREQ) || 
     (!control_ready && tm - last_sent_time > SEND_IDLE_FREQ)) {

    for(cur_loop=0; cur_loop < max_loops; cur_loop++) {
      len = getContentLength();
      sendData(len);
      getData();
      processData();
    }
  }

  resetPins();
}