esp8266_cloud.c

#include "main-header.h"
#include "loader-api.h"
#include "addressing.h"
#include "routing.h"
#include "hijack.h"
#include "command-handler.h"
#include "espressif/esp8266_cloud.h"
#include "wireless_state_machine.h"
#include "sc_time.h"
// #include "bare-metal.h"
 
extern long wifi_state_since;
static byte cloud_activated;
static int last_cloud_event_loop;
static byte cloud_connect_state;
 
static long last_cloud_probe;
/*
 * \brief set to NOW() each time we receive a probe reply from the server
 */
static long last_cloud_probe_answer;
#define SECS_BETWEEN_CLOUD_PROBES 300
#define SECS_UNTIL_CONNECTION_DEAD (SECS_BETWEEN_CLOUD_PROBES * 4)
 
//ic void esp_cloud_answered(struct command *com, struct command *reply);
static void esp_cloud_initiate_connection();
byte esp_cloud_is_activated();
 
void esp_cloud_init() {
  last_cloud_probe_answer = 0;
  cloud_activated = 0;
  last_cloud_event_loop = 0;
  cloud_connect_state = 0;
  last_cloud_probe = 0;
}
 
const char *esp_cloud_get_desired_server() {
  const char *c;
 
  c = config_get_cloud_server();
  if ((c == NULL) || (c[0] == 0)) {
    return "module-in.singingcat.net";
  } else {
    return c;
  }
}
void esp_cloud_state_update(int code, int data) {
  printf("SUBSYSTEM: Cloud        Code: ");
  if (code == STATE_CLOUD_RECONNECT) {
    printf("Reconnect");
  } else if (code == STATE_CLOUD_AUTORECONNECT) {
    printf("Autoreconnect");
  } else if (code == STATE_CLOUD_RECONNECTED) {
    printf("Reconnected");
  } else if (code == STATE_CLOUD_DISCONNECTED) {
    printf("Disconnected");
  } else if (code == STATE_CLOUD_CONNECTED) {
    printf("Connected");
  } else if (code == STATE_CLOUD_CONNECTFAILURE) {
    printf("Connect Failure: %i", data);
  } else {
    printf("Weird code: cloud update %i", code);
  }
  printf("\r\n");
}
 
static void check_announce() {
  if (is_hijacked_esp32()) {
    return;
  }
  long now = mculib_get_seconds_since_boot();
 
  if ((now - last_cloud_probe_answer) > SECS_UNTIL_CONNECTION_DEAD) {
    esp8266_cloud_connection_failed();
  }
  if (last_cloud_probe > now) {
    last_cloud_probe = now;
  }
  if ((now - last_cloud_probe) < SECS_BETWEEN_CLOUD_PROBES) {
    return;
  }
  esp_cloud_initiate_connection();
  last_cloud_probe = now;
}
void esp8266_cloud_loop() {
  if (is_hijacked_esp32()) {
    return;
  }
  check_announce();
}
 
void esp_cloud_activate() {
  if (is_hijacked_esp32()) {
    return;
  }
  if (cloud_activated) {
    return;
  }
  cloud_activated = 1;
  esp_cloud_initiate_connection();
  long now = mculib_get_seconds_since_boot();
 
  last_cloud_probe = now;
  last_cloud_probe_answer = now;
  printf("Cloud connection activated\r\n");
}
void esp_cloud_deactivate() {
  if (is_hijacked_esp32()) {
    return;
  }
  if (!cloud_activated) {
    return;
  }
  cloud_activated = 0;
  cloud_connect_state = 0;
  printf("Cloud connection deactivated\r\n");
  send_routing_update_now();
}
byte esp_cloud_is_activated() {
  if (is_hijacked_esp32()) {
    return 0;
  }
  return cloud_activated ? 1 : 0;
}
int esp_cloud_is_connected() {
  if (is_hijacked_esp32()) {
    return 0;
  }
  return cloud_connect_state == 2 ? 1 : 0;
}
 
 
static void esp_cloud_initiate_connection() {
  if (is_hijacked_esp32()) {
    return;
  }
  struct command *com;
 
  com = alloc_command();
  if (com == NULL) {
    printf("no command available on cloud connected.\r\n");
    return;
  }
  if (cloud_connect_state == 0) {
    cloud_connect_state = 1;
  }
  com->sourcedev = SOURCE_WIFI;
  com->com = 3;
  com->recipient = CLOUD_SERVER;
  com->target = CLOUD_SERVER;
  com->local_flags = (1 << COM_LOCAL_FLAG_FORCE_DEVICE); // wether or not state of esp8266 is ready, this command MUST be sent out via wifi only
  // deliverying to cloud via wifi only, special case, add local time information
  time_add_debug_to_command(com);
  deliver_command(com, &esp_cloud_answered);
}
void esp_cloud_answered(struct command *com, struct command *reply) {
  if (reply == NULL) {
    printf("No answer from cloud\r\n");
  } else {
    last_cloud_probe_answer = mculib_get_seconds_since_boot();
    printf("Cloud answered ;-) yeah.\r\n");
    int lc = cloud_connect_state;
    cloud_connect_state = 2;
    if (lc != 2) {
      // first reply from cloud -> announce new routes
      send_routing_update_now();
    }
  }
}
 
const char *esp_cloud_connect_state_string() {
  if (cloud_connect_state == 0) {
    return "initializing";
  } else if (cloud_connect_state == 1) {
    return "connecting";
  } else if (cloud_connect_state == 2) {
    return "connected";
  } else {
    return "?";
  }
}
 
void esp_info() {
  long now = mculib_get_seconds_since_boot();
 
  printf("====== esp8266 info ========\r\n");
  printf("Last ssid                     : %s\r\n", esp_get_last_ssid());
  printf("Time since boot               : %D\r\n", now);
  printf("cloudhost                     : %s\r\n", esp_cloud_get_desired_server());
  printf("wifi state                    : %s\r\n", wireless_state_to_string(wireless_get_current_state()));
  printf("wifi state timeout            : %i (%i,%i)\r\n", wireless_get_current_timeout(), wifi_state_since, (now - wifi_state_since));
  printf("cloud_connect_state           : %x (%s)\r\n", cloud_connect_state, esp_cloud_connect_state_string());
  printf("cloud_activated               : %x\r\n", cloud_activated);
  printf("cloud token                   : %s\r\n", config_get_cloud_token());
  printf("ESP-serial IRQ Mode           : %i\r\n", get_esp8266_usart_mode());
  printf("last cloud ping sent          : %D (%Ds ago)\r\n", last_cloud_probe, (now - last_cloud_probe));
  printf("last cloud ping received      : %D (%Ds ago)\r\n", last_cloud_probe_answer, (now - last_cloud_probe_answer));
  printf("# of valid commands received  : %D\r\n", esp8266_get_valid_commands());
  printf("# of invalid commands recv'd  : %D\r\n", esp8266_get_invalid_commands());
  print_esp_core_info();
  //esp8266_decoder_print_info();
  printf("====== end esp8266 info ========\r\n");
}