decode_esp_packet.c

Go to the documentation of this file.

#include "decode_esp_packet.h"
 
typedef struct espbuf {
  int   order;  /* >1: is ready for consumption */
  int   size;   /* size of packet (if valid packet in buf)  */
  byte  buf[260];
} _espbuf;
struct espbuf bufs[7];
static byte escaped = 0;
static int curorder;
static struct espbuf *cur_out_buf;      // buffer to be consumed...
static struct espbuf *cur_in_buf;       // buffer bytes from IRQ for main app
static byte decoder_state = 0;
static byte dodgy_packet_counter = 0;
static byte debug = 0;
void decode_esp_packet_init() {
  cur_in_buf = &bufs[0];
  cur_out_buf = NULL;
  memset(&bufs, 0, sizeof(bufs));
  escaped = 0;
  decoder_state = 0;
  curorder = 1;
}
 
 
// use an empty buf or the oldest one
static void find_best_buf() {
  int i;
  int ob = -1;
  int oo = 0;
 
  for (i = 0; i < (sizeof(bufs) / sizeof(bufs[0])); i++) {
    if ((ob == -1) || ((bufs[i].order < oo))) {
      ob = i;
      oo = bufs[i].order;
    }
    if (bufs[i].order == 0) {
      cur_in_buf = &bufs[i];
      return;
    }
  }
  if (ob != -1) {
    cur_in_buf = &bufs[ob];
  }
}
static void find_empty_buf() {
  int i;
 
  for (i = 0; i < (sizeof(bufs) / sizeof(bufs[0])); i++) {
    if (bufs[i].order == 0) {
      cur_in_buf = &bufs[i];
      return;
    }
  }
}
 
int esp8266_add_byte(byte b) {
  if (cur_in_buf == NULL) {
    find_best_buf();
  }
  if (cur_in_buf == NULL) {
    printf("No esp packet buf (all bufs in use)\r\n");
    decode_esp_packet_init();
    return 0;
  }
  // if no bytes in buf yet, we only accept PKT_START_BYTE
  if (decoder_state == 0) {
    if (b == PKT_START_BYTE) {
      decoder_state = 1;
      return 0;
    }
    return 0;
  }
 
  // got complete packet in buf. we return this until resetbuf() is called
  if (decoder_state == 5) { // never called afaict
    if ((!escaped) && (b == PKT_START_BYTE)) {
      printf("Warning - PKT_START_BYTE received while buf contains a packet!\r\n");
      printf("buf [bytesinbuf=%i]: \"%s\"\r\n", cur_in_buf->size, &cur_in_buf->buf);
      cur_in_buf->size = 0;
    }
    return cur_in_buf->size;
  }
 
  // check if our buf overflows - if so reset all bufs
  if (cur_in_buf->size >= sizeof(cur_in_buf->buf)) {
    dodgy_packet_counter++;
    if (debug) {
      // bad: printf from IRQ. eeks.
      printf("Warning - esp8266 buf overflow (%i,%i)\r\n", cur_in_buf->size, dodgy_packet_counter);
      int i;
      for (i = 0; i < cur_in_buf->size; i++) {
        write_serial_char(USART_CONSOLE, cur_in_buf->buf[i]);
      }
      cur_in_buf->size = 0;
    }
    decode_esp_packet_init();
    return 0;
  }
 
 
  if (escaped) {
    cur_in_buf->buf[cur_in_buf->size++] = b;
    escaped = 0;
    return 0;
  }
  escaped = (b == PKT_ESC_BYTE);
 
  // packets never end with PKT_ESC
  if (escaped) {
    decoder_state = 2;
    return 0;
  }
 
  // not escaped.
  if (b == PKT_END_BYTE) {
    cur_in_buf->order = curorder++;
    if (cur_out_buf == NULL) {
      esp8266_reset_buf();
    }
    cur_in_buf = NULL;
    find_empty_buf();
    decoder_state = 0;
    return cur_out_buf->size;
  } else {
    if (b == '{') {
      // if we receive a '{' (which is not escaped), then it _MUST_ be start of a packet, so reset buf
      cur_in_buf->size = 0;
      return 0;
    }
    decoder_state = 2;
    cur_in_buf->buf[cur_in_buf->size++] = b;
  }
  return 0;
}
 
void esp8266_reset_buf() {
  CNWDEBUG("Resetting buf\r\n");
  if (cur_out_buf != NULL) {
    cur_out_buf->size = 0;
    cur_out_buf->order = 0;
  }
  // any other bufs ready for consumption?
  int i;
  struct espbuf *res = NULL;
 
  for (i = 0; i < (sizeof(bufs) / sizeof(bufs[0])); i++) {
    if (bufs[i].order != 0) {
      if ((res == NULL) || (res->order > bufs[i].order)) {
        res = &bufs[i];
      }
    }
  }
  cur_out_buf = res;
}
 
byte *esp8266_get_buf() {
  if (cur_out_buf == NULL) {
    return NULL;
  }
  return (byte *)&cur_out_buf->buf;
}
 
byte esp8266_is_in_packet() {
  return decoder_state > 0;
}
int esp8266_packet_size() {
  if (cur_out_buf == NULL) {
    return 0;
  }
  if (cur_out_buf->order == 0) {
    return 0;
  }
  return cur_out_buf->size;
}
void esp8266_decoder_print_info() {
  int i;
 
  printf("  decoder.escaped      : %i\r\n", escaped);
  printf("  decoder.curorder     : %i\r\n", curorder);
  printf("  decoder.decoder_state: %i\r\n", decoder_state);
  for (i = 0; i < (sizeof(bufs) / sizeof(bufs[0])); i++) {
    printf("   #%i order=%i, size=%i\r\n", i, bufs[i].order, bufs[i].size);
  }
}