esp8266.c

#include "main-header.h"
#include "loader-api.h"
#include "addressing.h"
#include "espressif/esp8266_flash.h"
#include "coms/coms.h"
#include "espressif/esp32_bluetooth.h"
#include "proto-esp-usart.h"
#include "platform-header.h"
#include "wireless_state_machine.h"
//#include "bare-metal.h"
#include "led.h"
#include "metrics/metrics.h"
#include "ringbuffer.h"
#include "hijack.h"
 
static byte isupdating = 0;
static uint32_t sc_boot_version = 0;
//static long total_update_bytes=0;
static long valid_commands = 0;
static long invalid_commands = 0;
long wifi_state_since = 0;
static long timedout_state = 0;
static byte contbridge = 0;
static byte comctr = 0;
static long comctrts = 0;
static byte esp8266_usart_mode = 0;
static byte esp8266_debug = 0;
static byte esp8266_mode;
static byte gpio4_prev_state = 0;
static int default_baudrate = 115200;
static int esp8266_reboots = 0;
static long last_request_for_core = 0;
static long core_info_age = 0;
 
static uint32_t core_version = 0;
static uint32_t core_base;
static uint8_t core_chip;
static uint32_t core_repo;
 
static byte core_after_reset = 0; // esp8266_on sets it to '0'. upon receipt will be reset to '1';
static const char *lastssid;
static byte esp_reset_detect = 0;
// command to which wifi scan results will be replied...
static struct command *scan_com;
static uint8_t com_state = 0;
struct ringbuffer esp_ringbuffer;
 
// #define DEBUG_SYNC_PIN 110
 
#define ESPMODE_ISAP 1
 
#define ESP8266_AFTER_BOOT_DEFAULT_BAUDRATE 9600
 
#define AT_COMMAND_OK 2
#define AT_COMMAND_TIMEOUT 7
#define MAX_SECS_BETWEEN_WIFI_DETECT 600
 
#define SECONDS_BEFORE_ESP_FAIL 30
#define SECONDS_BEFORE_ESP_RESET_FAIL 30
#define SECONDS_BEFORE_ATTEMPTING_TO_RECONNECT 600
 
 
static byte next_reset_ap = 0;  // if 1, after next reset will go into AP instead of Statio node
static byte esplogin = 0;       //0=no need, 1=attempting, 2=failed, 3=ok
static void request_core_info();
void print_pkt_state_update(int subsystem, int code, uint8_t d1, uint8_t d2);
static void wireless_queue_event(int event);
void enter_esp_passthrough_mode();
void esp_empty_ringbuffer();
static char esplinebuf[80];
static char espline_received[190];
static int espline_received_valid;
struct ipv4address lastip;
static long ip_age = 0;
 
static byte gotmac = 0;
static long mac0;
static long mac1;
 
 
static void check_espusart_and_send_to_terminal();
static int esp8266_ison();
static void esp8266_off();
static void esp8266_on();
static const char *translate_baudrate(int baudrate);
static void scanComplete();
static void scanUpdate(const uint8_t *buf);
 
char esptmpbuf[128];
static byte baud_verify = 0;
const char *BAUD_CHANGE_INDICATOR = "NEW BAUDRATE: [";
static long new_baud = 0;
 
/********************************************************************
* Boot sequence:
* esp8266_reset:
* pin CHPD: low
* decode_esp_packet_init()
* queue_event(wireless_event_onreset) (-> state "IDLE")
*
* event_loop()  (called by main each iteration, ~20k per second)
* [LOOP] if STATE=="IDLE" -> send event "WIFIENABLED" => state "ROMCHECK"
* [LOOP] if STATE=="ROMCHECK" -> send event "ONROMCHECKED" => state "INIT"
* [LOOP] state INIT timesout after 1 second and becomes "RESETTING"
* [CALLBACK "RESETTING"]: esp8266_trigger_reset_normal(); (toggle CHPD and set baud 74800)
* [LOOP] if STATE=="RESETTING" -> if "[BOOTDONE]"&GPIO4=1 -> send event "RESETSUCCEEDED" => state READY
* [CALLBACK "READY"]: send event "GOTAP" => state CONNECTINGAP
* [CALLBACK "CONNECTINGAP"]: set_station_mode (send config, change baudrate to configured)
*
* at any time: if GPIO4 toggles from low->high: send event "ONRESET(DETECTED)"
********************************************************************/
 
/*
 * static void set_wifi_led(int colour) {
 * printf("*** WIFILED: %i *** \r\n", colour);
 * led_blink(LED_WIFI, colour, 255, 20, 100);
 * }
 * static void led_connected() {
 * set_wifi_led(0x00FF00);
 * Delay(100);
 * led_set_machine_managed();
 * }
 */
 
//static long wifidetect = 0;
static int is_ready_for_commands() {
  if (is_hijacked_esp32()) {
    return 0;
  }
 
  if (
    (wireless_get_current_state() == WIRELESS_STATE_DEFAULTSOFTAP)
    || (wireless_get_current_state() == WIRELESS_STATE_CONNECTED)
    || (wireless_get_current_state() == WIRELESS_STATE_CONNECTINGCLOUD)
    ) {
    return 1;
  }
  return 0;
}
 
static int pin_set(int pin, int onoff) {
  int r = mculib_pin_set(ESP8266_MCULIBHANDLE, pin, onoff);
 
#ifdef DEBUG_SYNC_PIN
  if (pin == PIN_ESP8266_GPIO0) {
    mculib_pin_set(ESP8266_MCULIBHANDLE, DEBUG_SYNC_PIN, onoff);
  }
#endif
 
  if (r) {
    printf("esp8266: Failed to set pin %i to %i: %i\r\n", pin, onoff, r);
  }
  return r;
}
int is_last_ip_valid() {
  return lastip.ip1 | lastip.ip2 | lastip.ip3 | lastip.ip4;
}
int get_esp_reboot_ctr() {
  return esp8266_reboots;
}
 
long esp8266_get_valid_commands() {
  return valid_commands;
}
long esp8266_get_invalid_commands() {
  return invalid_commands;
}
void esp8266_reset_command_validity_ctrs() {
  invalid_commands = 0;
  valid_commands = 0;
}
void esp8266_set_operational_baudrate(int baudrate) {
  if (default_baudrate == baudrate) {
    return;
  }
  if (translate_baudrate(baudrate) == NULL) {
    printf("esp8266: Cannot set baudrate %i\r\n", baudrate);
    return;
  }
  default_baudrate = baudrate;
  esp8266_reset();
}
int esp8266_get_operational_baudrate() {
  return default_baudrate;
}
 
// indicate to esp32 wether or not we are ready to receive. 1==ready,0==not ready
static void esp_indicate_terminal_ready(int ready) {
  if (config_get_flag(CONFIG_FLAGS_ESP_COMSYNC) == 0) {
    return;
  }
  /*
   * int ec = get_esp8266_usart_mode();
   * if ( (ec != ESP8266_USART_PACKET_ONLY) && ( ec !=  ESP8266_USART_SMART ) ) {
   * return;
   * }
   * int state = wireless_get_current_state();
   * if (state == WIRELESS_STATE_RESETTING) {
   * return;
   * }
   */
  pin_set(PIN_ESP8266_GPIO0, ready?1:0);
}
 
static void esp8266_set_baudrate(int baudrate) {
  int res;
 
  //write_serial_string(USART_ESP8266, "\r"); // ensure all transmits are done
  res = mculib_serialport_enable(ESP8266_MCULIBHANDLE, USART_ESP8266, baudrate);
  if (res) {
    printf("esp8266: Failed to set esp8266 usart to %i baud: %i\r\n", baudrate, res);
  } else {
    printf("esp8266: Set esp8266 usart to %i baud\r\n", baudrate);
  }
  write_serial_string(USART_ESP8266, "AT\r"); // ensure all transmits are done
}
 
void esp8266_test() {
  esp8266_set_baudrate(esp8266_get_operational_baudrate());
  printf("esp8266: Switching esp8266 off and on in write-to-flash mode...\r\n");
  pin_set(PIN_ESP8266_GPIO0, 0);
  Delay(50);
  esp8266_off();
  Delay(100);
  esp8266_on();
  long started = mculib_get_seconds_since_boot();
 
  while ((mculib_get_seconds_since_boot() - started) < 2) {
    check_espusart_and_send_to_terminal();
  }
  printf("esp8266: Attempting sync to flash protocol...\r\n");
  int res = espflash_sync();
 
  if (res != 0) {
    printf("esp8266: Sync failed (%i)\r\n", res);
    goto failure;
  }
  printf("esp8266: Sync ok\r\n");
  goto skipflashtest;
  res = espflash_prepare((void *)0x40000, 152648);
  if (res != 0) {
    printf("esp8266: Prepare failed (%i)\r\n", res);
    goto failure;
  }
  printf("esp8266: Prepare ok\r\n");
  res = espflash_write_block(0, 0);
  if (res != 0) {
    printf("Write failed (%i)\r\n", res);
    goto failure;
  }
  printf("esp8266: Write ok\r\n");
skipflashtest:
  res = espflash_finish();
  if (res != 0) {
    printf("esp8266: Finish failed (%i)\r\n", res);
  } else {
    printf("esp8266: Finish ok\r\n");
  }
  pin_set(PIN_ESP8266_GPIO0, 1);
  Delay(50);
  printf("esp8266: Switching esp8266 off and on in boot-from-flash mode...\r\n");
  esp8266_off();
  Delay(100);
  esp8266_on();
  started = mculib_get_seconds_since_boot();
  while ((mculib_get_seconds_since_boot() - started) < 2) {
    check_espusart_and_send_to_terminal();
  }
failure:
  printf("esp8266: Done.\r\n");
}
 
void set_esp8266_debug(byte b) {
  printf("esp8266: Set esp8266 debug to %i\r\n", (int)b);
  esp8266_debug = b;
}
 
static int esp8266_ison() {
  return mculib_pin_get(ESP8266_MCULIBHANDLE, PIN_ESP8266_CHPD);
}
static void esp8266_off() {
  printf("esp8266: esp8266 off\r\n");
  esp_cloud_deactivate();
  pin_set(PIN_ESP8266_CHPD, 0);
  Delay(50);
  decode_esp_packet_init();
  esp_reset_detect = 0;
}
static void esp8266_on() {
  sc_boot_version = 0;  // detect at boot. 0 == not found
  esp_reset_detect = 0;
  core_after_reset = 0; // it's a reset, we got to ask for firmware version again
  printf("esp8266: esp8266 on\r\n");
  decode_esp_packet_init();
  esp8266_set_baudrate(ESP8266_AFTER_BOOT_DEFAULT_BAUDRATE);
  pin_set(PIN_ESP8266_CHPD, 1);
  Delay(50);
  esp8266_reboots++;
}
static void esp8266_trigger_reset_normal() {
  esp_indicate_terminal_ready(1);
  set_esp8266_usart_mode(ESP8266_USART_PASSTHROUGH);
  printf("esp8266: Resetting esp8266 to normal mode\r\n");
  if (esp8266_ison()) {
    printf("esp8266: ESP8266 is already enabled!\r\n");
    esp8266_off();
    Delay(10);
  }
  pin_set(PIN_ESP8266_GPIO0, 1);
  Delay(50);
  //esp8266_set_baudrate( 74800);
  esp8266_set_baudrate(ESP8266_AFTER_BOOT_DEFAULT_BAUDRATE);
  esp8266_on();
}
 
// on "wifidebug"
void esp8266_dodebug(const char *paras) {
  pin_set(PIN_ESP8266_GPIO0, 1);
  Delay(50);
  esp8266_set_baudrate(ESP8266_AFTER_BOOT_DEFAULT_BAUDRATE);
  if (strlen(paras) > 0) {
    if (paras[0] == 'c') {
      contbridge = 1;
      esp8266_set_baudrate(74800);
    }
    if (strlen(paras) > 2) {
      const char *bs = &paras[0];
      int br = atoi(bs);
      if (br == 0) {
        printf("esp8266: wifidebug: Invalid baudrate: %i (%s)\r\n", br, bs);
        return;
      }
      printf("esp8266: Wifidebug, requested baudrate %i...\r\n", br);
      esp8266_set_baudrate(br);
      contbridge = 1;
    }
  }
  esp8266_reset();
  esp8266_on();
  esp8266_bridge();
  contbridge = 0;
}
void esp8266_reset() {
  esp8266_off();
  wireless_queue_event(WIRELESS_EVENT_ONRESET);
}
 
static char *get_ap_credentials() {
  return config_get_ram_struct()->apcredentials;
}
static int get_ap_count() {
  if (get_ap_credentials()[0] == 0) {
    return 0;
  }
  return 1;
}
static const char *get_ssid(int num) {
  return (const char *)get_ap_credentials();
}
static const char *get_ssid_pw(int num) {
  const char *p = get_ssid(num);
 
  while (*p++ != 0) {
  }
  //p++;
  return p;
}
void esp8266_add_ap(const char *ssid, const char *pw) {
  int i;
  int t;
  byte *p = (byte *)get_ap_credentials();
 
  t = 0;
  for (i = 0; i < strlen(ssid); i++) {
    p[t++] = ssid[i];
    p[t] = 0;
  }
  p[t++] = 0;
  for (i = 0; i < strlen(pw); i++) {
    p[t++] = pw[i];
    p[t] = 0;
  }
  config_commit();
  wireless_queue_event(WIRELESS_EVENT_GOTNEWAP);
}
 
 
static void check_espusart_and_send_to_terminal() {
  int esp;
 
  while ((esp = ringbuffer_get_byte(&esp_ringbuffer)) >= 256) {
    if ((esp == 0x12) || (esp < 9) || (esp > 127)) {
      esp = ' ';
    }
    write_serial_char(USART_CONSOLE, esp);
  }
}
 
static void esp8266_cfg_entry(char type, const char *txt) {
  if (esp8266_debug) {
    printf("esp8266: Sent Config: %c == \"%s\"\r\n", type, txt);
  }
  write_serial_char(USART_ESP8266, type);
  write_serial_string(USART_ESP8266, txt);
  write_serial_char(USART_ESP8266, 1);
}
static const char *translate_baudrate(int baudrate) {
  const char *c = NULL;
 
  if (baudrate == 9600) {
    c = "0";
  } else if (baudrate == 19200) {
    c = "1";
  } else if (baudrate == 38400) {
    c = "2";
  } else if (baudrate == 57600) {
    c = "3";
  } else if (baudrate == 115200) {
    c = "4";
  } else if (baudrate == 230400) {
    c = "5";
  } else if (baudrate == 460800) {
    c = "6";
  } else if (baudrate == 921600) {
    c = "7";
  } else if (baudrate == 74880) {
    c = "8";
  }
  return c;
}
static void set_common_parameters() {
  esp_indicate_terminal_ready(0);
  com_state = 0;
  esp8266_cfg_entry('d', (esp8266_debug & 0x02) ? "1" : "0");
  if (config_get_flag(CONFIG_FLAGS_UDP_ENABLED)) {
    esp8266_cfg_entry('L', "7234");
  } else {
    esp8266_cfg_entry('L', "0");
  }
  if (config_get_flag(CONFIG_FLAGS_ESP_COMSYNC)) {
    esp8266_cfg_entry('s', "1");
  }
 
  const char *tok = config_get_cloud_token();
 
  if ((tok != NULL) && (strlen(tok) > 0)) {
    esp8266_cfg_entry('T', tok);
  }
  char buf[16];
 
  node_to_str(config_get_ram_struct()->nodeid, buf);
  esp8266_cfg_entry('N', buf);
  esp8266_cfg_entry('I', "5");
  //  esp8266_cfg_entry('E', "0"); // obsolete
  const char *sn = config_get_sensor_server();
 
  if (strlen(sn) > 0) {
    esp8266_cfg_entry('D', sn);
  }
  char *c = (char *)translate_baudrate(esp8266_get_operational_baudrate());
 
  esp8266_cfg_entry('B', c);
}
 
static void set_station_mode(int num) {
  const char *ssid = get_ssid(num);
 
  lastssid = ssid;
  led_indicate(LED_WIFI_STATION);
  write_serial_string(USART_ESP8266, "\rAT+CFG=");
  esp8266_cfg_entry('M', "1");
  esp8266_cfg_entry('S', ssid);
  esp8266_cfg_entry('P', get_ssid_pw(num));
  esp8266_cfg_entry('C', esp_cloud_get_desired_server());
  set_common_parameters();
  write_serial_string(USART_ESP8266, "\r\r\r");
  esp8266_set_baudrate(esp8266_get_operational_baudrate());
 
  esp8266_mode = esp8266_mode & ~ESPMODE_ISAP;
  Delay(10);
  // send_nodeid();
  printf("esp8266: Esp8266 connecting to %s with pw %s\r\n", ssid, get_ssid_pw(num));
  set_esp8266_usart_mode(ESP8266_USART_PACKET_ONLY);
  //request_core_info();
  //printf("Enabling esp8266 DMA\r\n");
  //mculib_serialport_enable_dma(USART_ESP8266,serialbuf,sizeof(serialbuf));
}
void esp8266_send_config() {
  set_station_mode(0);
}
 
static byte got_ap_pw() {
  const char *c = config_get_cloud_token();
 
  if ((c == NULL) || (strlen(c) < 1)) {
    return 0;
  }
  return 1;
}
 
static void set_ap_mode() {
  lastssid = NULL;
  led_indicate(LED_WIFI_APMODE);
  write_serial_string(USART_ESP8266, "\rAT+CFG=");
  esp8266_cfg_entry('M', "2");
  set_common_parameters();
  char buf[63];
 
  snprintf(buf, 63, "singingcat_%N", config_get_ram_struct()->nodeid);
  esp8266_cfg_entry('S', buf);
  if (got_ap_pw()) {
    strncpy(buf, config_get_cloud_token(), 11);
    esp8266_cfg_entry('P', buf);
  } else {
    esp8266_cfg_entry('P', "singingcat");
  }
  write_serial_string(USART_ESP8266, "\r\r\r");
  esp8266_set_baudrate(esp8266_get_operational_baudrate());
  Delay(10);
  esp8266_send_instructions();
  printf("esp8266: Esp8266 set to accesspoint\r\n");
  set_esp8266_usart_mode(ESP8266_USART_PACKET_ONLY);
}
int esp8266_is_accespoint() {
  return (esp8266_mode & ESPMODE_ISAP) ? 1 : 0;
}
 
void esp_empty_ringbuffer() {
  ringbuffer_init(&esp_ringbuffer);
}
 
static int cat_is_control_byte(uint8_t b) {
  return (b == PKT_START_BYTE)
         || (b == PKT_END_BYTE)
         || (b == PKT_ESC_BYTE)
  ;
}
 
static void transmit_to_esp(const byte *buf, int len) {
  if (is_hijacked_esp32()) {
    return;
  }
  int i;
 
  for (i = 0; i < len; i++) {
    write_serial_char(USART_ESP8266, buf[i]);
  }
}
void wifi_send_data(const PACKET_TYPE type, const byte *buf, const int len) {
  int tl;
  int startpos;
  byte b[3];
 
  if (!is_ready_for_commands()) { // includes check for hijack
    if (esp8266_debug) {
      printf("esp8266: Not sending to esp - not ready yet\r\n");
    }
    return;
  }
 
  if (cat_is_control_byte(type)) {
    // big error!
    printf("esp8266: invalid packet type\r\n");
    return;
  }
  b[0] = PKT_START_BYTE;
  b[1] = type;
  transmit_to_esp((const byte *)&b, 2);
  startpos = 0;
  b[0] = PKT_ESC_BYTE;
  for (tl = 0; tl < len; tl++) {
    if (cat_is_control_byte(buf[tl])) {
      transmit_to_esp((const byte *)&buf[startpos], tl - startpos);
      transmit_to_esp((const byte *)&b, 1);
      startpos = tl;
    }
  }
  if (startpos < tl) {
    transmit_to_esp((const byte *)&buf[startpos], tl - startpos);
  }
  b[0] = PKT_END_BYTE;
  b[1] = '\n';
  transmit_to_esp((const byte *)&b, 1);
  IncMetric_PKTS_WIFI_CTR_OUT;
}
 
static void do_gpio4() {
  int b = mculib_pin_get(ESP8266_MCULIBHANDLE, PIN_ESP8266_GPIO4);
 
  if (b == gpio4_prev_state) {
    return;
  }
  gpio4_prev_state = b;
  if (b) {
    // wireless_queue_event(WIRELESS_EVENT_ONRESETDETECTED);
    printf("esp8266: ESP8266 gpio4: high\r\n");
    printf("esp8266: ESP8266 reset detected\r\n");
    wireless_queue_event(WIRELESS_EVENT_ONRESET);
    IncMetric_WIFI_RESTARTS;
  } else {
    printf("esp8266: ESP8266 gpio4: low\r\n");
  }
}
void esp8266_wififlash_bridge(void) {
  int res = espflash_sync();
 
  if (res) {
    printf("esp8266: FAIL: failed to sync to esp8266. Is it connected and powered up?\r\n");
    return;
  }
  esp8266_bridge();
  wireless_queue_event(WIRELESS_EVENT_ONRESETDETECTED);
}
static void do_com_while_bridged(const char c) {
  if (c == '+') {
    led_blink(LED_WIFI_BRIDGE, 0xFF0000, 255, 10, 1);
    comctr++;
    comctrts = mculib_get_seconds_since_boot();
    //printf("+ received (%i)\r\n",comctr);
  } else {
    //printf("non-+ received (%i)\r\n",c);
    if ((c != '\r') && (c != '\n')) {
      led_blink(LED_WIFI_BRIDGE, 0x0000FF, 255, 10, 1);
      comctr = 0;
    }
  }
}
static void scan_esp_output_while_bridged(const char c) {
  if (BAUD_CHANGE_INDICATOR[baud_verify] == 0) {
    // found baud rate indicator
    if ((c >= '0') && (c <= '9')) {
      new_baud = new_baud * 10 + (c - '0');
    } else {
      printf("esp8266:  *** SingingCat firmware detected baudrate change: %i (%c)\r\n", (int)new_baud, c);
      esp8266_set_baudrate(new_baud);
      baud_verify = 0;
    }
  } else {
    if (c == BAUD_CHANGE_INDICATOR[baud_verify]) {
      baud_verify++;
      new_baud = 0;
    } else {
      baud_verify = 0;
    }
  }
}
 
static int com_mode_bridged() {
  //return/quit/config/ap/reset/scan
  printf("\r\n(ato|atq|atc|atC|atp|atr|atscan)\r\nOK\r\n");
  comctrts = 0;
  comctr = 0;
  esptmpbuf[0] = 0;
  for (;;) {
    avoid_watchdog();
    int x = console_get_line((char *)&esptmpbuf, 50);
    if (x <= 0) {
      continue;
    }
    console_reset();
    if (strcmp(esptmpbuf, "ato") == 0) {
      printf("esp8266: reconnecting...\r\n");
      break;
    }
    if (strcmp(esptmpbuf, "atscan") == 0) {
      printf("esp8266: starting scan...\r\n");
      start_wifi_scan();
      break;
    }
    if (strcmp(esptmpbuf, "atq") == 0) {
      printf("esp8266: quitting\r\n");
      return 1;
    }
    if (strcmp(esptmpbuf, "atp") == 0) {
      set_ap_mode();
      set_esp8266_usart_mode(ESP8266_USART_PASSTHROUGH);
      break;
    }
    if (strcmp(esptmpbuf, "atC") == 0) {
      printf("esp8266: sending quick update config...\r\n");
      write_serial_string(USART_ESP8266, "\rAT+CFG=");
      esp8266_cfg_entry('M', "1");
      esp8266_cfg_entry('u', "1"); // if debug, update immediately
      esp8266_cfg_entry('S', get_ssid(0));
      esp8266_cfg_entry('P', get_ssid_pw(0));
      esp8266_cfg_entry('C', esp_cloud_get_desired_server());
      set_common_parameters();
      write_serial_string(USART_ESP8266, "\r\r\r");
      esp8266_set_baudrate(esp8266_get_operational_baudrate());
      break;
    }
    if (strcmp(esptmpbuf, "atc") == 0) {
      printf("esp8266: sending config...\r\n");
      write_serial_string(USART_ESP8266, "\rAT+CFG=");
      esp8266_cfg_entry('M', "1");
      esp8266_cfg_entry('S', get_ssid(0));
      esp8266_cfg_entry('P', get_ssid_pw(0));
      esp8266_cfg_entry('C', esp_cloud_get_desired_server());
      set_common_parameters();
      write_serial_string(USART_ESP8266, "\r\r\r");
      esp8266_set_baudrate(esp8266_get_operational_baudrate());
      break;
    }
    if (strcmp(esptmpbuf, "atr") == 0) {
      esp8266_off();
      Delay(2);
      printf("esp8266: ESP8266 on & return\r\n");
      //      reset_ringbuffer(USART_CONSOLE);
      esp8266_on();
      return 0;
    }
  }
  //  reset_ringbuffer(USART_CONSOLE);
  return 0;
}
 
void esp8266_bridge() {
  printf("esp8266: Bridging esp2866 & debug console...\r\n");
  comctr = 0;
  comctrts = 0;
  console_reset();
  led_indicate(LED_WIFI_BRIDGE);
  baud_verify = 0;
  printf("esp8266: contbridge==%i\r\n", contbridge);
  printf("esp8266: Entering passthrough mode\r\n");
  printf("[BRIDGE ACTIVE]\r\n"); // easy parse ;)
  esp8266_usart_mode = ESP8266_USART_PASSTHROUGH;
  reset_delay_counter(DELAY_ESP2SERIAL);
  reset_delay_counter(DELAY_DEFAULT);
  avoid_watchdog();
  int to = 20000;
 
  for (;;) {
    avoid_watchdog();
    do_gpio4();
    if (get_delay_counter(DELAY_DEFAULT) > 20) {
      reset_delay_counter(DELAY_DEFAULT);
    } else if (get_delay_counter(DELAY_DEFAULT) > 10) {
    }
    // check for +++ and some time passed thereafter
    if ((comctr >= 3) && (mculib_get_seconds_since_boot() - comctrts) >= 2) {
      // check for commands (after +++)
      if (com_mode_bridged()) {
        break;
      }
    }
    // deal with chars from console while bridged
    uint16_t x;
    if ((x = console_get_byte()) < 256) {
      to = 500;
      avoid_watchdog();
      write_serial_char(USART_ESP8266, x);
      reset_delay_counter(DELAY_ESP2SERIAL);
      if (contbridge) {
        // count '+' (increases variable comctr, each time one is received)
        do_com_while_bridged(x);
      } else {
        led_blink(LED_WIFI_BRIDGE, 0xFFFFFF, 255, 10, 1);
      }
    } else {
      led_blink(LED_WIFI_BRIDGE, 0, 0, 0, 0);
    }
    // deal with chars from esp8266 while bridged
    if ((x = ringbuffer_get_byte(&esp_ringbuffer)) < 256) {
      write_char_to_console(x);
      if (contbridge) {
        scan_esp_output_while_bridged(x);
      }
    }
 
    // if no traffic for some time, leave debug mode
    if ((contbridge == 0) && (get_delay_counter(DELAY_ESP2SERIAL) > to)) {
      printf("esp8266: Leaving passthrough mode.\r\n");
      esp8266_usart_mode = ESP8266_USART_PACKET_ONLY;
      printf("[BRIDGE MODE FINISHED]\r\n"); // easy parse ;)
      break;
    }
  }
  led_indicate(LED_WIFI_BRIDGE2);
}
char *esp8266_status_string() {
  if (is_hijacked_esp32()) {
    return "userapp_control";
  }
 
  if (isupdating) {
    return "Updating Firmware";
  }
  if (config_get_wifidisable()) {
    return "Disabled";
  }
  if (esp8266_is_accespoint()) {
    return "Accesspoint";
  }
  if (!is_last_ip_valid()) {
    return "Client (No IP)";
  }
  return "Connected to AP (Got IP)";
}
 
void esp_init() {
  int r;
 
  ringbuffer_init(&esp_ringbuffer);
  espline_received[0] = 0;
  espline_received_valid = 0;
  if (config_get_wifidisable()) {
    // even if wifi is disabled, enable pin for output, so we can turn wifi off
    if ((r = mculib_pin_out(ESP8266_MCULIBHANDLE, PIN_ESP8266_CHPD, HAL_PIN_FASTEST))) {
      printf("esp8266: Failed to set pin: %i\r\n", r);
    }
    esp8266_off();
    return;
  }
  lastssid = NULL;
  core_version = 0;
  core_chip = 0;
  core_base = 0;
  core_repo = 0;
  esp8266_usart_mode = ESP8266_USART_PACKET_ONLY;
 
#ifdef DEBUG_SYNC_PIN
  if ((r = mculib_pin_out(ESP8266_MCULIBHANDLE, DEBUG_SYNC_PIN, HAL_PIN_FASTEST))) {
    printf("esp8266: Failed to set pin: %i\r\n", r);
  }
#endif
  if ((r = mculib_pin_out(ESP8266_MCULIBHANDLE, PIN_ESP8266_CHPD, HAL_PIN_FASTEST))) {
    printf("esp8266: Failed to set pin: %i\r\n", r);
  }
  if ((r = mculib_pin_out(ESP8266_MCULIBHANDLE, PIN_ESP8266_GPIO0, HAL_PIN_FASTEST))) {
    printf("esp8266: Failed to set pin: %i\r\n", r);
  }
  if ((r = mculib_pin_in(ESP8266_MCULIBHANDLE, PIN_ESP8266_GPIO4, HAL_PIN_SLOWEST, HAL_PUSHPULL_DOWN))) {
    printf("esp8266: Failed to set pin: %i\r\n", r);
  }
  esp8266_off();
  wireless_init();
  if (!config_get_wifidisable()) {
    esp8266_enable();
  }
  CNWDEBUG("esp_init() complete\n");
}
 
int esp_get_mac(char *buf, int bufsize) {
  if ((bufsize == 0) || (buf == NULL)) {
    return 2;
  }
  buf[0] = 0;
  if (!gotmac) {
    return 1;
  }
  snprintf(buf, bufsize, "18:FE:34:%x:%x:%x",
           (int)((mac1 >> 8) & 0xff),
           (int)((mac1) & 0xff),
           (int)((mac0 >> 24) & 0xff));
  return 0;
}
int esp_read_mac() {
  avoid_watchdog();
  int res;
 
  res = 0;
  printf("esp8266: Syncing to esp8266...\r\n");
  if ((res = espflash_sync()) != 0) {
    res = 1;
    goto failure;
  }
  espflash_read_register(0x3ff00050, &mac0);
  espflash_read_register(0x3ff00054, &mac1);
  gotmac = 1;
failure:
  avoid_watchdog();
  esp8266_off();
  return res;
}
 
void set_esp8266_usart_mode(int i) {
  esp8266_usart_mode = i;
}
int get_esp8266_usart_mode() {
  return esp8266_usart_mode;
}
 
void print_esp_core_info() {
  long now = mculib_get_seconds_since_boot();
  long ago = now - core_info_age;
 
  printf("esp8266 firmware chip         : %i\r\n", (int)core_chip);
  printf("esp8266 firmware version      : %i (from %is ago)\r\n", (int)core_version, ago);
  printf("esp8266 firmware repository   : %i\r\n", (int)core_repo);
  printf("esp8266 firmware base         : %p\r\n", (int)core_base);
}
static void esp_core_update(int code, byte *buf, int size) {
  printf("esp firmware version update received (%i bytes)\r\n", size);
  printf("esp-fw-buf: ");
  printHex("esp-fw-buf: ", buf, size);
  int pos = 0;
 
  if ((size < 8) || (buf[0] != 0)) {
    printf("esp firmware - Old style\r\n");
    uint16_t v = (((uint16_t)buf[0]) << 8) | (((uint16_t)buf[1]) << 0);
    core_version = (uint32_t)v;
    core_chip = 1;      // we don't know any better. but it's old, so probably an esp8266
    core_repo = 0;      // we just don't know ;(
    core_base = 0;      // we just don't know ;(
    core_info_age = mculib_get_seconds_since_boot();
    core_after_reset = 1;
    return;
  }
  // new style:
  printf("esp firmware - New style\r\n");
  //uint8_t version, uint8_t chip, uint32_t version, uint32_t repo, uint32_t baseadr
  if (buf[1] != 1) {
    printf("esp firmware - unknown structure %i\r\n", buf[0]);
    return;
  }
  pos = 2;
  get_uint8(buf, size, &pos, &core_chip);
  get_uint32(buf, size, &pos, &core_version);
  get_uint32(buf, size, &pos, &core_repo);
  get_uint32(buf, size, &pos, &core_base);
  core_info_age = mculib_get_seconds_since_boot();
  core_after_reset = 1;
}
 
void wifi_new_creds(char *buf) {
  int i;
  const char *pw = NULL;
  const char *ssid = NULL;
 
  for (i = 0; i < strlen(buf); i++) {
    if ((ssid == NULL) && ((buf[i] == 13) || (buf[i] == 10))) {
      continue;
    }
    if (ssid == NULL) {
      ssid = &buf[i];
    }
    if (buf[i] == 1) {
      buf[i] = 0;
      pw = (const char *)(buf + i + 1);
      break;
    }
  }
  if (pw == NULL) {
    printf("esp8266 - got new wifi SSID (%s), but no password\r\n", ssid);
    return;
  }
  printf("esp8266 - got new wifi credentials: %s %s\r\n", ssid, pw);
  esp8266_add_ap(ssid, pw);
  esp8266_reset();
}
 
static void request_core_info() {
  cat_send_local_instruction(INSTRUCTION_GET_CORE_INFO, (const uint8_t *)esplinebuf, 0);
}
/************************ wifi update handler ***************************/
void wifi_update_started() {
  printf("esp8266: wifi_update started\r\n");
  isupdating = 1;
}
void wifi_update_completed() {
  isupdating = 0;
  printf("esp8266: wifi_update completed\r\n");
}
void wifi_update_progress(const uint8_t *buf) {
  printf("esp8266: wifi_update: %s\r\n", buf);
}
 
void esp8266_got_packet(const byte *buf, int size) {
  // tell esp that we received the packet.
  com_state = 2;
  esp_indicate_terminal_ready(1);
  if (size == 0) {
    esp8266_reset_buf();
    com_state = 0;
    return; // empty packet? ;)
  }
  if (buf[0] == PKT_COMMAND) {
    struct command *com;
    com = command_parse(buf + 1, size - 1);
    if (com == NULL) {
      invalid_commands++;
      printf("esp8266: Invalid command from espserialport (%i): \r\n    \"%s\"\r\n", buf[0], buf + 1);
      printHex("", buf + 1, size - 1);
      IncMetric_PKTS_WIFI_INVALID;
    } else {
      valid_commands++;
      com->sourcedev = SOURCE_WIFI;
      got_new_packet(com, 255);
      IncMetric_PKTS_WIFI_CTR_IN;
    }
  } else if (buf[0] == PKT_IP_UPDATE) {
    lastip.ip1 = buf[1];
    lastip.ip2 = buf[2];
    lastip.ip3 = buf[3];
    lastip.ip4 = buf[4];
    ip_age = mculib_get_seconds_since_boot();
    const char *statestr;
    if (esp_cloud_is_connected()) {
      statestr = "CONNECTED";
    } else {
      statestr = "NOT CONNECTED";
    }
    if (is_last_ip_valid()) {
      wireless_queue_event(WIRELESS_EVENT_IPASSIGNED);
    }
    printf("esp8266: WIFI IP: %i.%i.%i.%i (%s)\r\n", lastip.ip1, lastip.ip2, lastip.ip3, lastip.ip4, statestr);
    if ((esplogin == 1) || (esplogin == 2)) {
      esplogin = 3;
    }
  } else if (buf[0] == PKT_LOG) {
    printf("esp8266: WIFI LOG: %s\r\n", buf + 1);
  } else if (buf[0] == PKT_STATE_UPDATE) {
    int subsystem = buf[1];
    int code = buf[2];
    printf("esp8266: ESP state update: subsystem=%i, code=%i\r\n", subsystem, code);
    if ((subsystem == SUBSYS_AP) && (code == STATE_AP_CONNECTED)) {
      wireless_queue_event(WIRELESS_EVENT_APCONNECTED);
    }
    if ((subsystem == SUBSYS_AP) && (code == STATE_AP_FAILED)) {
      wireless_queue_event(WIRELESS_EVENT_APFAILURE);
    }
    if ((subsystem == SUBSYS_CLOUD) && (code == STATE_CLOUD_CONNECTED)) {
      wireless_queue_event(WIRELESS_EVENT_CLOUDISOK);
    }
    if ((subsystem == SUBSYS_CLOUD) && (
          (code == STATE_CLOUD_DISCONNECTED)
          || (code == STATE_CLOUD_CONNECTFAILURE)
          || (code == STATE_CLOUD_AUTORECONNECT)
          )) {
      wireless_queue_event(WIRELESS_EVENT_CLOUDDISCONNECTED);
    }
    if ((subsystem == PKT_IP_UPDATE) && (code == STATE_AP_CONNECTED)) {
      wireless_queue_event(WIRELESS_EVENT_APCONNECTED);
    }
    if (subsystem == SUBSYS_CORE) {
      esp_core_update(code, (byte *)(buf + 3), size - 3);
    }
    if (size > 4) {
      print_pkt_state_update(subsystem, code, buf[3], buf[4]);
    } else if (size > 3) {
      print_pkt_state_update(subsystem, code, buf[3], 0);
    } else if (size > 2) {
      print_pkt_state_update(subsystem, code, 0, 0);
    } else {
      printf("esp8266: WIFI state update: no subsystem\r\n");
    }
  } else if (buf[0] == PKT_LOCAL_INSTRUCTION) {
    printf("esp8266: Local instruction received: ");
    int i;
    for (i = 0; i < size; i++) {
      printf(" %i", buf[i]);
    }
    printf("\r\n");
  } else if (buf[0] == PKT_WIFI_SCAN_UPDATE) {
    scanUpdate(buf + 1);
  } else if (buf[0] == PKT_WIFI_SCAN_COMPLETE) {
    scanComplete();
  } else if (buf[0] == PKT_WIFI_UPDATE_STARTED) {
    wifi_update_started();
  } else if (buf[0] == PKT_WIFI_UPDATE_COMPLETED) {
    wifi_update_completed();
  } else if (buf[0] == PKT_WIFI_UPDATE_PROGRESS) {
    wifi_update_progress(buf + 1);
  } else if (buf[0] == PKT_BT_PEER_UPDATE) {
    bt_peer_update(buf + 1, size - 1);
  } else if (buf[0] == PKT_WIFI_NEW_CREDS) {
    wifi_new_creds((char *)buf + 1);
  } else {
    printf("invalid esp8266 packet type (%i: \"%s\")!\r\n", buf[0], buf);
    printHex("packet: ", buf, size);
  }
  esp8266_reset_buf();
  com_state = 0; // allow esp to send next packet
}
 
// 1==esp8266, 2=esp32
int esp8266_get_chip() {
  return core_chip;
}
int esp8266_get_firmware_version() {
  return core_version;
}
int esp8266_get_firmware_repo() {
  return core_repo;;
}
uint64_t esp8266_get_firmware_base() {
  return core_base;
}
void print_pkt_state_update(int subsystem, int code, uint8_t d1, uint8_t d2) {
  int data = (((int)d1) << 8) | ((int)d2);
 
  if (subsystem == SUBSYS_AP) {
    printf("SUBSYSTEM: Accesspoint  Code: ");
    if (code == STATE_AP_IDLE) {
      printf("Idle\r\n");
    } else if (code == STATE_AP_CONNECTING) {
      printf("Connecting\r\n");
    } else if (code == STATE_AP_CONNECTED) {
      printf("Connected\r\n");
    } else if (code == STATE_AP_FAILED) {
      printf("Logon to accesspoint failed\r\n");
    } else if (code == PKT_WIFI_AP_NOT_FOUND) {
      printf("SSID not found\r\n");
    } else if (code == PKT_WIFI_AP_REJECTED) {
      printf("accesspoint rejected auth\r\n");
    } else if (code == PKT_WIFI_AP_DISCONNECT_UNKNOWN_REASON) {
      printf("disconnected from accesspoint, reason unspecified\r\n");
    } else {
      printf("%i\r\n", code);
    }
  } else if (subsystem == SUBSYS_CLOUD) {
    esp_cloud_state_update(code, data);
  } else if (subsystem == SUBSYS_CORE) {
    printf("esp core update\n");
  } else {
    printf("SUBSYSTEM: %i           Code: %i\r\n", subsystem, code);
  }
}
 
 
struct ipv4address *esp8266_get_current_ip() {
  if ((lastip.ip1 | lastip.ip2 | lastip.ip3 | lastip.ip4) == 0) {
    return NULL;
  }
  return &lastip;
}
long esp8266_get_time_of_last_ip() {
  return ip_age;
}
 
static const char *eob = "csum";
static int det = 0;
// obsolete...
static void esp8266_afterreset(byte read) {
  ringbuffer_add_byte(&esp_ringbuffer, read);
  if (read == eob[det]) {
    det++;
  } else {
    det = 0;
    if (read == eob[det]) {
      det++;
    }
  }
  if (det == 4) {
    esp8266_set_baudrate(ESP8266_AFTER_BOOT_DEFAULT_BAUDRATE);
    set_esp8266_usart_mode(ESP8266_USART_PASSTHROUGH);
  }
}
 
void esp8266_read_byte_from_serialport(int val) {
  if (get_esp8266_usart_mode() == ESP8266_USART_IGNORE) {
    return;
  }
  byte read = 0xFF & val;
 
  int state = wireless_get_current_state();
 
  if ((com_state == 0) && (val == '{')) {
    com_state = 1;
    esp_indicate_terminal_ready(0);
  }
  if (state == WIRELESS_STATE_RESETTING) {
    ringbuffer_add_byte(&esp_ringbuffer, read);
    return;
  }
  if (get_esp8266_usart_mode() == ESP8266_USART_PACKET_ONLY) {
    esp8266_add_byte(read);
    if (esp8266_debug) {
      //      if (!esp8266_is_in_packet()) {
      ringbuffer_add_byte(&esp_ringbuffer, read);
      //}
    }
    return;
  } else if (get_esp8266_usart_mode() == ESP8266_USART_SMART) {
    esp8266_add_byte(read);
    if (!esp8266_is_in_packet()) {
      ringbuffer_add_byte(&esp_ringbuffer, read);
    }
    return;
  } else if (get_esp8266_usart_mode() == ESP8266_USART_PASSTHROUGH) {
    ringbuffer_add_byte(&esp_ringbuffer, read);
    return;
  } else if (get_esp8266_usart_mode() == ESP8266_USART_AFTERRESET) {
    esp8266_afterreset(read);
    return;
  }
}
 
static void write_serial_buffer(int USART, const uint8_t *buf, int length) {
  int i;
 
  for (i = 0; i < length; i++) {
    write_serial_char(USART, buf[i]);
  }
}
void esp8266_send_instructions() {
  char buf[16];
 
  if (esp8266_debug) {
    printf("esp8266 - sending extra instructions\r\n");
  }
  node_to_str(config_get_ram_struct()->nodeid, buf);
  cat_send_local_instruction(INSTRUCTION_SET_LOCAL_NODEID, (const uint8_t *)buf, strlen(buf));
  const char *tok = config_get_cloud_token();
 
  if ((tok != NULL) && (strlen(tok) > 0)) {
    cat_send_local_instruction(INSTRUCTION_SET_CLOUDTOKEN, (const uint8_t *)tok, strlen(tok));
  }
}
void esp8266_ota() {
  char buf[16];
 
  buf[0] = 0;
  if (esp8266_debug) {
    printf("esp8266 - asking for ota\r\n");
  }
  cat_send_local_instruction(INSTRUCTION_DOWNLOAD_UPDATE, (const uint8_t *)buf, 0);
}
 
void cat_send_local_instruction(const PACKET_TYPE type, const uint8_t *buf, const int len) {
  int tl;
  int startpos;
  uint8_t b[2];
 
  if (cat_is_control_byte(type)) {
    // big error!
    printf("invalid packet type\r\n");
    return;
  }
  write_serial_char(USART_ESP8266, PKT_START_BYTE);
  write_serial_char(USART_ESP8266, PKT_LOCAL_INSTRUCTION);
  write_serial_char(USART_ESP8266, type);
 
  startpos = 0;
  for (tl = 0; tl < len; tl++) {
    if (cat_is_control_byte(buf[tl])) {
      write_serial_buffer(USART_ESP8266, &buf[startpos], tl - startpos);
      write_serial_char(USART_ESP8266, PKT_ESC_BYTE);
      startpos = tl;
    }
  }
  if (startpos < tl) {
    write_serial_buffer(USART_ESP8266, &buf[startpos], tl - startpos);
  }
  b[0] = PKT_END_BYTE;
  b[1] = '\n';
  write_serial_buffer(USART_ESP8266, (const uint8_t *)&b, 2);
}
 
// start a wifi scan, drop results
void start_wifi_scan() {
  char buf[16];
 
  buf[0] = 0;
  cat_send_local_instruction(INSTRUCTION_START_SCAN, (const uint8_t *)buf, 0);
}
static void scanComplete() {
  send_command_reply(scan_com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  scan_com = NULL;
  printf("Wifi scan finished\r\n");
}
static void scanUpdate(const uint8_t *buf) {
  struct command *com = scan_com;
 
  if (com == NULL) {
    return;
  }
 
 
  struct command *dcom = alloc_command();
 
  if (dcom == NULL) {
    printf("Cannot send wifi update - no free command\r\n");
    return;
  }
  command_init(dcom);
  //dcom->recipient = com->sender; // WRONG!! next hop!
  dcom->target = com->sender;
  dcom->encoding = 'a';
  dcom->index = com->index;
  dcom->sourcedev = com->sourcedev;
  dcom->connid = com->connid;
  dcom->com = com->com;
  dcom->flags = COMFLAGS_DATA | COMFLAGS_SUCCESS;
  command_add_arg(dcom, "chan=%i", buf[0]);
  command_add_arg(dcom, "rssi=%i", buf[1]);
  command_add_arg(dcom, "ssid=%s", &buf[8]);
  send_command(dcom);
  free_command(dcom);
  printf("Channel=%i, rssi=%i, SSID: %s\r\n", buf[0], buf[1], &buf[8]);
}
 
// start a wifi scan, return results to command as replies
void esp8266_wifi_scan(struct command *com) {
  char buf[16];
 
  buf[0] = 0;
  scan_com = com;
  cat_send_local_instruction(INSTRUCTION_START_SCAN, (const uint8_t *)buf, 0);
}
 
 
const char *esp_get_last_pw() {
  return get_ssid_pw(0);
}
const char *esp_get_last_ssid() {
  return lastssid;
}
 
// tell us if esp8266 is currently enabled.
int esp8266_is_enabled() {
  if (config_get_wifidisable()) {
    return 0;
  }
  // maybe consider soft-enable (e.g. calling enable/disable w/o config flag?)
  return 1;
}
 
void esp8266_enable() {
  printf("esp8266 enable\r\n");
  wireless_queue_event(WIRELESS_EVENT_WIFIENABLED);
}
void esp8266_disable() {
  printf("esp8266 disable\r\n");
  wireless_queue_event(WIRELESS_EVENT_ONWIFIDISABLE);
  esp8266_off();
  esp8266_event_loop(); // kick through the loop once at least.
}
 
/*******************************************************************
 * called from mainloop, asks the esp8266 for information about
 * itself
 */
static void check_esp_core() {
  int state = wireless_get_current_state();
 
  // we allow for "not ready" states, because if we fail to connect
  // we still want to report the version (possibly through the 868Mhz to the cloud)
  if ((state != WIRELESS_STATE_CONNECTED)
      && (state != WIRELESS_STATE_CONNECTINGAP)
      && (state != WIRELESS_STATE_CONNECTINGIP)
      && (state != WIRELESS_STATE_CONNECTINGCLOUD)
      ) {
    return;
  }
  long now = mculib_get_seconds_since_boot();
 
  // if it's fresh enough, do nothing
  if (core_info_age > now) {
    core_info_age = now;
  }
  // if the information we have is no older than this,
  // don't do stuff (esp_reset, does reset the counter!)
  if (core_after_reset && ((now - core_info_age) < 600)) {
    return;
  }
 
  if (last_request_for_core > now) {
    last_request_for_core = now;
  }
  // ask no more frequently than every 2 seconds
  if ((now - last_request_for_core) < 2) {
    return;
  }
  last_request_for_core = now;
 
  printf("esp8266: Requesting core info...\r\n");
  request_core_info();
}
 
static void check_boot_firmware() {
  if (!espline_received_valid) {
    return;
  }
  const char *x = "Singingcat Firmware Version: ";
 
  if (strlen(x) > strlen(espline_received)) {
    return;
  }
  int i;
 
  for (i = 0; i < strlen(x); i++) {
    if (espline_received[i] != x[i]) {
      return;
    }
  }
  sc_boot_version = atoi(&espline_received[strlen(x)]);
  printf("esp8226: singingcat firmware version: \"%s\" (%i)\r\n", &espline_received[strlen(x)], sc_boot_version);
}
 
static void read_esp_serial_line() {
  if (espline_received_valid) {
    espline_received_valid = 0;
    espline_received[0] = 0;
  }
  //  return;
  //  if (ringbuffer_find_string(USART_ESP8266, "Singingcat Firmware Version:")) {
  for (;;) {
    int nb = ringbuffer_get_byte(&esp_ringbuffer);
    if (nb >= 256) {
      break;
    }
    int l = strlen(espline_received);
    if (l > sizeof(espline_received) - 5) {
      l = 0;
    }
    if ((nb == '\r') || (nb == '\n')) {
      if (l > 0) {
        espline_received_valid = 1;
        break;
      }
    } else {
      espline_received[l++] = (byte)nb;
      espline_received[l] = 0;
    }
  }
}
 
/*******************************************************************
* Main loop (called ~20k per second)
*******************************************************************/
static void wireless_process_event_queue();
static long lastloop = 0;
static int laststate = 0;
// this is called ~5k per second from mainloop
void esp8266_event_loop() {
  if (config_get_wifidisable()) {
    return;
  }
 
  read_esp_serial_line();// this sets espline_received
 
  if (espline_received_valid) {
    if (esp8266_debug) {
      printf("esp8266: buf: \"%s\"\r\n", &espline_received);
    }
  }
  mculib_serialport_transferbuffer(USART_ESP8266);
  /*
   * if (esp8266_debug & 0x4) {
   * check_espusart_and_send_to_terminal();
   * }
   */
  int state = wireless_get_current_state();
 
  // in some cases we have to force next state if we're debugging
#ifdef DEBUG_ON_LINUX
  if (state == WIRELESS_STATE_RESETTING) {
    wireless_queue_event(WIRELESS_EVENT_RESETSUCCEEDED);
  }
#endif
 
  if (state != WIRELESS_STATE_RESETTING) {
    do_gpio4();
  }
  //check_espusart_and_send_to_terminal();
 
  long now = mculib_get_seconds_since_boot();
 
  check_esp_core();
  // if state changed, print new state
  if (state != laststate) {
    printf("esp8266: State: %s\r\n", wireless_state_to_string(state));
    laststate = state;
  }
  lastloop = now;
 
 
  if (state == WIRELESS_STATE_IDLE) {
    wireless_queue_event(WIRELESS_EVENT_WIFIENABLED);
  }
 
  if (state == WIRELESS_STATE_ROMCHECK) {
#ifdef DEBUG_ON_LINUX
    wireless_queue_event(WIRELESS_EVENT_ONROMCHECKED);
#else
    if (esp_read_mac()) {
      wireless_queue_event(WIRELESS_EVENT_ONROMFAILED);
    } else {
      wireless_queue_event(WIRELESS_EVENT_ONROMCHECKED);
    }
#endif
  }
 
  if (state == WIRELESS_STATE_RESETTING) {
    check_boot_firmware();      // parse for singingcat version
    isupdating = 0;             // after reset we are never "updating a firmware"
    if (esp_reset_detect == 0) {
      if ((espline_received_valid) && (strcmp(espline_received, "[BOOTDONE]") == 0)) {
        printf("esp8266: detected [BOOTDONE] message\r\n");
        esp_reset_detect = 1;
      }
      /*
       * if (ringbuffer_find_string(USART_ESP8266, "[BOOTDONE]")) {
       * printf("esp8266: detected [BOOTDONE] message\r\n");
       * esp_reset_detect = 1;
       * }
       */
    } else if (esp_reset_detect == 1) {
      isupdating = 0; // after reset we are never "updating a firmware"
      gpio4_prev_state = mculib_pin_get(ESP8266_MCULIBHANDLE, PIN_ESP8266_GPIO4);
      if (gpio4_prev_state == 1) {
        // we're resetting, we know, do not trigger again
        printf("esp8266: gpio high detected\r\n");
        wireless_queue_event(WIRELESS_EVENT_RESETSUCCEEDED);
        esp_reset_detect = 0;
      }
    }
  }
 
  // connected to the cloud -> periodically call the cloud handler
  if (state == WIRELESS_STATE_CONNECTED) {
    esp8266_cloud_loop();
  }
  wireless_process_event_queue();
 
  if (wifi_state_since > now) {
    wifi_state_since = now; // our clock goes backwards???
  }
  int to = wireless_get_current_timeout();
  if ((to != 0) && ((now - wifi_state_since) >= to) && (state != timedout_state)) {
    timedout_state = state;
    if (state != WIRELESS_STATE_CONNECTED) {
      printf("esp8266: Wireless state: %s timed out (%i secs, max=%i secs)\r\n",
             wireless_state_to_string(state),
             (int)(now - wifi_state_since),
             to
             );
      wireless_timeout();
    }
  }
 
  return;
}
void esp8266_cloud_connection_failed() {
  wireless_queue_event(WIRELESS_EVENT_CLOUDDISCONNECTED);
}
 
/*******************************************************************
* wireless state machine stuff
*******************************************************************/
static int wireless_queue[10];
static void wireless_queue_event(int event) {
  int i;
  int max = 0;
 
  if ((!esp8266_is_enabled()) && (event != WIRELESS_EVENT_WIFIENABLED)) {
    // if disabled, then only event allowed is to enable it
    return;
  }
  if (esp8266_debug) {
    printf("esp8266: [wireless-statemachine] Queued wireless event: %s\r\n", wireless_event_to_string(event));
  }
  for (i = 0; i < (sizeof(wireless_queue) / sizeof(wireless_queue[0])); i++) {
    if (wireless_queue[i] != 0) {
      max = i;
    }
  }
  if ((max + 1) >= sizeof(wireless_queue) / sizeof(wireless_queue[0])) {
    printf("esp8266: [wireless-statemachine] ERROR -> Out of event buffers!!\r\n");
    return;
  }
  wireless_queue[max + 1] = event;
}
 
static void wireless_process_event_queue() {
  int i;
 
  for (i = 0; i < (sizeof(wireless_queue) / sizeof(wireless_queue[0])); i++) {
    if (wireless_queue[i] != 0) {
      wireless_new_event(wireless_queue[i]);
      wireless_queue[i] = 0;
    }
  }
}
 
// the state machine is already in new state!
void wireless_callback_state_change(int newstate, int oldstate) {
  printf("esp8266: [wireless-statemachine] State change: %s(%i) to %s(%i)\r\n",
         wireless_state_to_string(oldstate), oldstate,
         wireless_state_to_string(newstate), newstate);
  wifi_state_since = mculib_get_seconds_since_boot();
  timedout_state = -1;
 
  if (newstate == WIRELESS_STATE_RESETTING) {
    esp8266_trigger_reset_normal();
  }
  if (newstate == WIRELESS_STATE_READY) {
    if ((get_ap_count() == 0) || (next_reset_ap)) {
      next_reset_ap = 0;
      wireless_queue_event(WIRELESS_EVENT_GOTNOAP);
    } else {
      wireless_queue_event(WIRELESS_EVENT_GOTAP);
    }
  }
  if (newstate == WIRELESS_STATE_DEFAULTSOFTAP) {
    led_set_wifi_managed();
    set_ap_mode();
  }
  if (newstate == WIRELESS_STATE_TRIGGERDEFAULTSOFTAP) {
    led_set_wifi_managed();
    esp8266_reset();
    next_reset_ap = 1;
  }
  if (newstate == WIRELESS_STATE_CONNECTINGAP) {
    set_station_mode(0);
  }
  if (newstate == WIRELESS_STATE_CONNECTED) {
    led_indicate(LED_WIFI_CONNECTED);
    esp_cloud_init();
    esp_cloud_activate();
    esp8266_send_instructions();
  }
  if (oldstate == WIRELESS_STATE_CONNECTED) {
    // we left the connected stuff
    esp_cloud_deactivate();
    esp8266_send_instructions();
  }
 
  if (newstate == WIRELESS_STATE_NEXTAP) {
    // we should count up here and only go into softap
    // once we tried all known SSIDS
    // (but atm we only know one, so...)
    if (got_ap_pw()) {
      wireless_queue_event(WIRELESS_EVENT_ONNOMOREAPS);
    }
  }
}
 
 
/*******************************************************************
* end wireless state machine stuff
*******************************************************************/
/* write to serial port and USB */
int write_char_to_console(char b) {
  int i;
 
  i = write_serial_char(USART_CONSOLE, b);
  mculib_usb_send(ESP8266_MCULIBHANDLE, 1, (uint8_t *)&b);
  return i;
}