main.c

#include "main-header.h"
#include "loader-api.h"
#include "sx1262/sx1262.h"
#include "irq_router.h"
#include "ti1101.h"
#include "softirq.h"
#include "constants.h"
#include "user_app_exe.h"
#include "uECC.h"
#include "flashapp.h"
#include "function-instr.h"
#include "wireless_state_machine.h"
#include "powersave.h"
#include "baseinfo.h"
#include "ti1101-pinconfig.h"
#include "metrics/metrics.h"
#include "streams.h"
#include "led.h"
#include "sensors/sensor.h"
#include "espressif/esp8266.h"
#include "espressif/esp8266_flash.h"
#include "espressif/esp8266_flash_from_serialport.h"
#include "boot_info.h"
#include "fets.h"
#include "powerup.h"
#include "ascii_parser.h"
#include "usb.h"
#include "route_command.h"
#include "forwarding.h"
#include "networkif.h"
#include "route_command.h"
#include "partitions.h"
#include "sc_time.h"
#include "hijack.h"
// #include "bare-metal.h"
 
extern byte overflow_check_active;
 
static void start_delayed();
 
struct hal_workspace hal;
extern uint32_t acm_byte_received;
static char minibuf[265];
static byte ping_loop;
static byte wifi_fail_ctr;
static byte stopped = 0;
static volatile int ping_ctr;
static volatile int ack_ctr;
static volatile long last_ping_received;
#define MAX_SECS_BEFORE_DELAYED_START 10
#define MAX_SECS_BETWEEN_STOP_WARNING 10
#define MAX_SECS_BETWEEN_RADIO_BROADCASTS 300
#define MAX_SECS_BETWEEN_LOOP_SAMPLES 5
struct ringbuffer console_ringbuffer;
 
// TODO: make this static (non-static because of troubleshooting 26/3/22)
void  irq_metric_counter(int pin) {
  metric_inc_by_number(IRQ_COUNTER);
}
static void  init_irq_metric_counter() {
  // BREAKS irq stuff!!! (e.g. radio inbound packets)
  //hal.pin_irq_callback = &irq_metric_counter;
}
 
void set_new_node_id(char *nodetxt) {
  long nodeid = ascii_parse_hex((const byte *)nodetxt, strlen(nodetxt), NULL);
 
  config_get_ram_struct()->nodeid = nodeid;
  config_commit();
  IPLOG("Committed new nodeid %N\r\n", config_get_ram_struct()->nodeid);
}
void create_new_node_id() {
  config_get_ram_struct()->nodeid = adr_create_new_node_id();
  config_commit();
  IPLOG("Committed new nodeid %N\r\n", config_get_ram_struct()->nodeid);
}
void print_program_status() {
  IPLOG("************* Application Info ************\r\n");
  IPLOG("Build #             %i\r\n", CNW_BUILD_VERSION);
  IPLOG("Build Info:         %s\r\n", get_cnw_build_info());
  IPLOG("ModuleID:           %i\r\n", (int)config_get_moduleid());
  IPLOG("Application base:   %p\r\n", get_app_header());
  IPLOG("Loader API:         %s\r\n", loader_has_api() ? "Yes" : "No");
  IPLOG("Loader Version:     %i\r\n", loader_get_version());
  IPLOG("Last PC:            %p\r\n", get_reboot_info()->function);
  IPLOG("Secs since boot:    %D\r\n", mculib_get_seconds_since_boot());
  IPLOG("Secs since start:   %D\r\n", get_seconds_since_start());
  IPLOG("PowerUP MSG/cause : %i/%i\r\n", powerup_status(), mculib_get_reset_source());
  IPLOG("Powermode flags:    %p\r\n", config_get_powermode_flags());
  IPLOG("Wifi Status:        %s\r\n", esp8266_status_string());
  IPLOG("Wifi State Machine: %s\r\n", wireless_state_to_string(wireless_get_current_state()));
  IPLOG("Cloud Connection:   %s\r\n", esp_cloud_is_connected() ? "Yes" : "No");
  char buf[50];
  struct ipv4address *adr = esp8266_get_current_ip();
 
  if (adr == NULL) {
    snprintf(buf, 40, "N/A");
  } else {
    snprintf(buf, 40, "%i.%i.%i.%i", adr->ip1, adr->ip2, adr->ip3, adr->ip4);
  }
  IPLOG("Wifi IP Address:    %s\r\n", buf);
  IPLOG("Userapp address:    %p (linked for %p)\r\n", get_user_app(), (user_app_is_valid() ? get_user_app()->base:0));
  IPLOG("Userapp version:    %i\r\n", user_app_is_valid() ? get_user_app()->version : 0);
  IPLOG("Userapp Repo:       %i\r\n", user_app_is_valid() ? get_user_app()->repoid : 0);
  IPLOG("Userapp enabled:    %s\r\n", user_app_is_enabled() ? "Yes" : "No");
  IPLOG("Userapp detected:   %s\r\n", user_app_is_valid() ? "Yes" : "No");
  IPLOG("Userapp executable: %s\r\n", user_app_executable() ? "Yes" : "No");
  IPLOG("Userapp crc ok:     %s\r\n", user_app_checksum_valid() ? "Yes" : "No");
}
 
static void failAt(uint32_t *x) {
  printf("Failing at %p\r\n", x);
  printf("Failing at %p\r\n", *x);
  printf("Failing at %p\r\n", x);
  *x = 1;
}
static void wifi_set_ap(char *line) {
  int i;
 
  for (i = 0; i < strlen(line); i++) {
    if (line[i] == ' ') {
      line[i] = 0;
      esp8266_add_ap(line, line + i + 1);
    }
  }
  esp8266_reset();
}
 
void printHelp() {
  print_program_status();
  print_node_id(config_get_ram_struct()->nodeid);
  printf("******* console help *****\r\n");
  printf("newnodeid:     create a new nodeid (careful), optional specifiy new id\r\n");
  printf("verbose|quiet: set output to console on or off\r\n");
  printf("constants:     display constants in ram area\r\n");
  printf("ping:          ping once via radio\r\n");
  printf("radiooff:      disable cc1101\r\n");
  printf("radioon:       enable cc1101\r\n");
  printf("wifioff:       disable esp8266\r\n");
  printf("wifion:        enable esp8266\r\n");
  printf("startflash:    set esp8266 into flash mode via serial (for esptool)\r\n");
  printf("startusbflash: set esp8266 into flash mode via usb (for esptool)\r\n");
  printf("wififlash:     same as startflash plus reset when done\r\n");
  printf("wifidebug:     reset esp8266 and bridge serialports\r\n");
  printf("wifiscan:      scan and list wifi accesspoints\r\n");
  printf("sensorserver:  set the dns-name of the server to send sensordata to\r\n");
  printf("server:        set the dns-name of the server to connect to\r\n");
  printf("restart:       restart app\r\n");
  printf("startapp [adr]:start app at address adr\r\n");
  printf("reset [num]:   reset mcu (type=num,default=0)\r\n");
  printf("pins:          show current pint mappings\r\n");
  printf("wifi2serial:   bridge esp8266 serial to console\r\n");
  printf("wifibaud [num]:set baudrate of esp8266 usart\r\n");
  printf("wififlsp [num]:set baudrate of esp8266 usart during flash\r\n");
  printf("ssid ssid pw:  set new accesspoint credentials, e.g. \"ssid foo bar\"\r\n");
  printf("esp_reset:     reset esp8266\r\n");
  printf("esp_init:      setup esp8266\r\n");
  printf("esp_debug:     enable debug mode of esp8266 (also esp_debug [int])\r\n");
  printf("esp_nodebug:   disable debug mode of esp8266\r\n");
  printf("esp_info:      show state of esp8266 controller\r\n");
  printf("esptest:       low-level tests of esp8266\r\n");
  printf("espmac:        reads the mac address of esp8266 using rom bootloader\r\n");
  printf("config_erase:  erase config from flash\r\n");
  printf("announce:      broadcast routing updates\r\n");
  printf("pingserver:    send ping to server\r\n");
  printf("network:       print network information\r\n");
  printf("nicprobe:      reprobe network adapters\r\n");
  printf("routes:        print routing table\r\n");
  printf("route_debug:   enable/disable debug of routing code \r\n");
  printf("forward_debug: enable/disable debug of forwarding code\r\n");
  printf("forward_table: view forwarding tables\r\n");
  printf("outqueue:      print outbound command queue\r\n");
  printf("clrqueue:      clear outbound command queue\r\n");
  printf("freecom:       free all commands\r\n");
  printf("fail:          cause a hardfault\r\n");
  printf("stop:          stop processing everything but console\r\n");
  printf("cont:          continue processing stuff\r\n");
  printf("loaderreset:   erase loader config\r\n");
  printf("loaderseq:     set this app to latest loader sequence\r\n");
  printf("log [string]:  log something\r\n");
  printf("memtest:       check memory\r\n");
  printf("stream_init:   close all current streams\r\n");
  printf("stream_info:   print info of all current streams\r\n");
  printf("stream_enable: start processing all streams\r\n");
  printf("stream_disable:stop processing all streams\r\n");
  printf("sensors:       print sensor status\r\n");
  printf("sensors_off:   disable sensors\r\n");
  printf("sensors_on:    enable sensors\r\n");
  printf("sensors_run:   run sensors [name of sensor] (e.g. \"sensors_run 0 3\" (read sensor 0)\r\n");
  printf("set_flag a b:  set config flag a to b\r\n");
  printf("show_flags:    show current flags\r\n");
  printf("pm_disable:    disable power save modes\r\n");
  printf("pm_wake:       wake from power save mode\r\n");
  printf("user_enable:   enable userapp\r\n");
  printf("user_disable:  disable userapp\r\n");
  printf("metric_send:   send metrics to server \r\n");
  printf("pwm_status:    print status of current pwm\r\n");
  printf("clock_sync:    request clock synchronisation from server\r\n");
  printf("softirq:       print softirq status\r\n");
  printf("clocksync [n]  clock info OR enable(n=1))/disable(n=0) clocksync \r\n");
  printf("********** end console help ******\r\n");
}
 
static uint32_t getmaxmem() {
  uint32_t *start = (uint32_t *)0x20000000 + 2048;
  //uint32_t *end =  (uint32_t *)0x2000BFFF;
 
  uint32_t *foo = start + 1024;
  uint32_t *lc = start + 1048;
 
  if (*foo == 0xAF34B012) {
    return *lc;
  }
  *foo = 0xAF34B012;
  uint32_t *adr = start;
 
  for (;;) {
    printf("poking memory at: %p\r\n", adr);
    *lc = (uint32_t)adr;
    adr = adr + 1024;
    *adr = (uint32_t)adr;
    if (*adr != (uint32_t)adr) {
      break;
    }
  }
  return *lc;
}
static void memcheck() {
  uint32_t foo[] = { 0x20001FFF, 0x2000BFFF, 0x20001000, 0x20013f00, 0x20010000, 0 };
  int i = 0;
 
  for (;;) {
    uint32_t f = foo[i];
    if (f == 0) {
      break;
    }
    printf("Memory at %p is stack: %i?\r\n", (void *)f, is_stack((void *)f));
    i++;
  }
  printf("Max memory: %p\r\n", getmaxmem());
}
 
/*
 * here input from the debug tty is processed.
 * it checks for known strings (see readme)
 * everything else it attempts to parse as a command
 */
void process_terminal_input() {
  int linelen;
  struct command *com;
  char *terminal_line;
 
  terminal_line = (char *)&minibuf;
  linelen = console_get_line(terminal_line, 255);
  if (linelen <= 0) {
    if (linelen == -1) {
      ringbuffer_init(&console_ringbuffer); // exceptionally long line - remove
    }
    return;
  }
  IPLOG("tty rx (%i): \"%s\"\r\n", linelen, terminal_line);
  if ((strcmp(terminal_line, "help") == 0) || (strcmp(terminal_line, "?") == 0)) {
    setquietflag(0); // someone typed help -> stop "quiet" mode
    printHelp();
  } else if (strcmp(terminal_line, "verbose") == 0) {
    setquietflag(0);
  } else if (strcmp(terminal_line, "user_disable") == 0) {
    user_app_disable();
  } else if (strcmp(terminal_line, "user_enable") == 0) {
    user_app_reset_state();
    user_app_exe_init();
    user_app_enable();
  } else if (strcmp(terminal_line, "quiet") == 0) {
    setquietflag(1);
  } else if ((strcmp(terminal_line, "status") == 0) || (strcmp(terminal_line, "\t") == 0)) {
    print_program_status();
    esp_info();
  } else if (strcmp(terminal_line, "newnodeid") == 0) {
    create_new_node_id();
  } else if (startsWith(terminal_line, "newnodeid ")) {
    set_new_node_id(terminal_line + 10);
  } else if (strcmp(terminal_line, "ping") == 0) {
    ping_loop = 0;
    //    doping();
  } else if (strcmp(terminal_line, "network") == 0) {
    print_all_nics();
  } else if (strcmp(terminal_line, "nicprobe") == 0) {
    init_all_nics();
  } else if (strcmp(terminal_line, "radiooff") == 0) {
    config_set_ti1101disable(1);
    config_commit();
    stop_nic_by_type(SOURCE_RADIO);
  } else if (strcmp(terminal_line, "radioon") == 0) {
    config_set_ti1101disable(0);
    config_commit();
    start_nic_by_type(SOURCE_RADIO);
  } else if (strcmp(terminal_line, "wifioff") == 0) {
    config_set_wifidisable(1);
    config_commit();
    esp8266_disable();
  } else if (strcmp(terminal_line, "wifion") == 0) {
    config_set_wifidisable(0);
    config_set_wifidetected(1);
    config_commit();
    esp8266_enable();
  } else if (strcmp(terminal_line, "usbappupdate") == 0) {
    usb_appupdate();
  } else if (strcmp(terminal_line, "startflash") == 0) {
    esp8266_wififlash_bridge();
  } else if (strcmp(terminal_line, "startusbflash") == 0) {
    esp8266_wififlash_usb_bridge();
  } else if (strcmp(terminal_line, "wififlash") == 0) {
    esp8266_flash_from_serialport();
    printf("Wififlash done\r\n");
  } else if (strcmp(terminal_line, "restart") == 0) {
    restart_app();
  } else if (startsWith(terminal_line, "startapp ")) {
    restart_app_adr(atoi(terminal_line + 9));
  } else if (startsWith(terminal_line, "reset")) {
    printf("Resetting...\r\n");
    reboot_fast();
  } else if (startsWith(terminal_line, "wifibaud ")) {
    int b = atoi(terminal_line + 9);
    esp8266_set_operational_baudrate(b);
    printf("Set ESP8266 Baudrate to %i\r\n", b);
  } else if (startsWith(terminal_line, "wififlsp ")) {
    int b = atoi(terminal_line + 9);
    espflash_set_baud(b);
  } else if (strcmp(terminal_line, "wifidebug") == 0) {
    esp8266_dodebug("c");
  } else if (strcmp(terminal_line, "wifiscan") == 0) {
    start_wifi_scan();
  } else if (startsWith(terminal_line, "wifidebug ")) {
    esp8266_dodebug(terminal_line + 10);
  } else if (strcmp(terminal_line, "pins") == 0) {
    mculib_print_mappings(&printf);
  } else if (strcmp(terminal_line, "wifi2serial") == 0) {
    mculib_serialport_enable(MAIN_MCULIBHANDLE, USART_ESP8266, esp8266_get_operational_baudrate());
    esp8266_bridge();
  } else if (strcmp(terminal_line, "announce") == 0) {
    send_routing_update_now();
  } else if (strcmp(terminal_line, "routes") == 0) {
    routing_print_table();
  } else if (strcmp(terminal_line, "powerup") == 0) {
    send_power_up_now(POWERUP_CLI);
  } else if (strcmp(terminal_line, "esp_ota") == 0) {
    esp8266_ota();
  } else if (strcmp(terminal_line, "esp_reset") == 0) {
    unhijack_esp32();
    esp8266_reset();
  } else if (strcmp(terminal_line, "esp_init") == 0) {
    esp_init();
  } else if (strcmp(terminal_line, "esp_debug") == 0) {
    set_esp8266_debug(3);
  } else if (startsWith(terminal_line, "esp_debug ")) {
    set_esp8266_debug(atoi(terminal_line + 10));
  } else if (strcmp(terminal_line, "esptest") == 0) {
    esp8266_test();
  } else if (strcmp(terminal_line, "espmac") == 0) {
    char buf[34];
    esp_read_mac();
    esp_get_mac(buf, sizeof(buf));
    printf("Mac read: \"%s\"\r\n", buf);
  } else if (strcmp(terminal_line, "esp_info") == 0) {
    esp_info();
  } else if (strcmp(terminal_line, "esp_nodebug") == 0) {
    set_esp8266_debug(0);
  } else if (startsWith(terminal_line, "server ")) {
    const char *sn = terminal_line + 7;
    config_set_cloud_server(sn);
    config_commit();
    esp8266_reset();
  } else if (startsWith(terminal_line, "sensorserver ")) {
    const char *sn = terminal_line + 13;
    config_set_sensor_server(sn);
    printf("Set sensor server to \"%s\"\r\n", sn);
    config_commit();
  } else if (strcmp(terminal_line, "config_erase") == 0) {
    config_erase();
  } else if (strcmp(terminal_line, "sensors") == 0) {
    sensor_info();
  } else if (startsWith(terminal_line, "sensors_run ")) {
    sensor_run_str(terminal_line + 12);
  } else if (strcmp(terminal_line, "sensors_off") == 0) {
    sensors_off();
    config_set_sensors_enabled(0);
    config_commit();
  } else if (strcmp(terminal_line, "sensors_on") == 0) {
    sensors_init();
    config_set_sensors_enabled(1);
    config_commit();
  } else if (strcmp(terminal_line, "fail") == 0) {
    failAt((void *)0x1fff000);
    failAt((void *)&hal - (1024 * 32));
  } else if (strcmp(terminal_line, "stop") == 0) {
    stopped = 1;
  } else if (strcmp(terminal_line, "outqueue") == 0) {
    print_outbound_queue();
  } else if (strcmp(terminal_line, "freecom") == 0) {
    free_commands(-1);
  } else if (strcmp(terminal_line, "clrqueue") == 0) {
    clear_outbound_queue();
  } else if (strcmp(terminal_line, "pingserver") == 0) {
    //pingserver();
  } else if (strcmp(terminal_line, "loaderseq") == 0) {
    int x = loader_set_latest_app(get_app_header());
    printf("Loader sequence number increased. result: %i\r\n", x);
  } else if (strcmp(terminal_line, "loaderreset") == 0) {
    loader_erase_config();
    printf("Config erased.\r\n");
  } else if (strcmp(terminal_line, "constants") == 0) {
    constants_print();
  } else if (strcmp(terminal_line, "memtest") == 0) {
    memcheck();
  } else if (strcmp(terminal_line, "stream_enable") == 0) {
    stream_enable();
  } else if (strcmp(terminal_line, "stream_disable") == 0) {
    stream_disable();
  } else if (strcmp(terminal_line, "stream_info") == 0) {
    print_stream_info();
  } else if (strcmp(terminal_line, "stream_init") == 0) {
    stream_init();
    printf("Streams reinitialized\r\n");
  } else if (strcmp(terminal_line, "show_flags") == 0) {
    printf("Flags    : %p\r\n", config_get_flags());
    printf("UserFlags: %p\r\n", (uint32_t)get_user_config_flags());
  } else if (startsWith(terminal_line, "set_flag ")) {
    config_flag_line(terminal_line + 9);
  } else if (startsWith(terminal_line, "log ")) {
    iplog("%s", terminal_line + 4);
    printf("Logged \"%s\"\r\n", terminal_line + 4);
  } else if (strcmp(terminal_line, "forward_table") == 0) {
    print_forwarding_table();
  } else if (strcmp(terminal_line, "softirq") == 0) {
    print_softirqs();
  } else if (strcmp(terminal_line, "clocksync") == 0) {
    clocksync_help();
  } else if (startsWith(terminal_line, "clocksync ")) {
    clocksync_enable((uint8_t)((terminal_line[10]) - '0'));
  } else if (strcmp(terminal_line, "forward_debug") == 0) {
    set_forward_debug(1);
    routing_command_debug(1);
  } else if (strcmp(terminal_line, "route_debug") == 0) {
    if (get_routing_debug()) {
      set_routing_debug(0);
    } else {
      set_routing_debug(1);
    }
  } else if (strcmp(terminal_line, "cont") == 0) {
    stopped = 0;
  } else if (strcmp(terminal_line, "pm_disable") == 0) {
    config_set_flag(CONFIG_FLAGS_POWER_SAVE, 0);
  } else if (strcmp(terminal_line, "pm_wake") == 0) {
    set_mcu_power_mode(0xFF);
  } else if (startsWith(terminal_line, "ssid ")) {
    wifi_set_ap(terminal_line + 5);
  } else if (strcmp(terminal_line, "flashdebug") == 0) {
    flash_debug();
  } else if (strcmp(terminal_line, "clock_sync") == 0) {
    send_clock_sync_request();
  } else if (strcmp(terminal_line, "pwm_status") == 0) {
    print_pwm_state();
  } else if (strcmp(terminal_line, "metric_send") == 0) {
    metric_send();
  } else {
    // it is not a known string, so parse as command
    com = command_parse((const byte *)terminal_line, linelen);
    if (com == NULL) {
      IPLOG("Invalid command from tty: \"%s\"\r\n", terminal_line);
      printHex("TTY: ", (const uint8_t *)terminal_line, linelen);
    } else {
      com->sourcedev = 3;
      command_print(com);
      got_new_packet(com, 255);
    }
  }
}
 
int console_get_line(char *outbuf, int outbufsize) {
  return ringbuffer_get_to_delimiter(&console_ringbuffer, '\r', outbuf, outbufsize);
}
void console_add_byte(uint8_t b) {
  ringbuffer_add_byte(&console_ringbuffer, b);
}
uint16_t console_get_byte() {
  return ringbuffer_get_byte(&console_ringbuffer);
}
void console_reset() {
  ringbuffer_init(&console_ringbuffer);
}
 
void app_main_no_return() __attribute__ ((noreturn));
void serialirq(int port, byte b)  __attribute__((no_instrument_function));
 
// called by mculib whenever we get a new byte
void serialirq(int port, byte b) {
  IncMetric_METRIC_IRQ_SERIAL;
  if (user_serial_callback(port, b)) {
    return;
  }
  if (port == USART_ESP8266) {
    if (hijack_receive_esp32(b) == 0) {
      esp8266_read_byte_from_serialport(b);
    }
    return;
  } else if (port == USART_CONSOLE) {
    if (acm_byte_received == 0) { // only accept if we don't get data from acm
      ringbuffer_add_byte(&console_ringbuffer, b);
    }
  } else if (port == 3) {
    //userheader
  } else {
    printf("Dodgy port IRQ: %i\r\n", port);
  }
}
void app_main_no_return() {
  int ci = constants_init();
 
  hijack_init();
  powerup_init();
  mculib_init(&hal);
  mculib_reset_source_clear();
  stream_init();
  ringbuffer_init(&console_ringbuffer);
  packet_init();
  multi_mem_init();
  softirq_init();
  logging_init();
  routing_init();
  init_command_handler();
  decode_esp_packet_init();
  mculib_enable_irq(MAIN_MCULIBHANDLE);
  mculib_serialport_enable(MAIN_MCULIBHANDLE, USART_CONSOLE, 115200);
  sctime_init();
  int i;
 
  for (i = 0; i < 3; i++) {
    printf("\r\n");
  }
  constants()->reset_counter++;
  constants_validate();
  if (ci) {
    printf("Constant ram area re-initialised.\r\n\r\n");
  } else {
    printf("Constant ram area reusable (Reset #%i).\r\n\r\n", constants()->reset_counter);
    constants_print();
  }
  printf("SingingCat Application #%i\r\n", CNW_BUILD_VERSION);
  printf("Initializing systicks...\r\n");
  mculib_systick(10, &UserSysTick_Handler);
  printf("Hal->systick load       : %D\r\n", mculib_workspace_get()->systick_load);
  printf("Hal->systick calibration: %D\r\n", mculib_workspace_get()->systick_calibration);
  printf("Getting time...\r\n");
 
  printf("Time is: %i\r\n", get_seconds_since_start());
  stopped = 0;
  overflow_check_active = 1;
 
  wifi_fail_ctr = 0;
  ping_loop = 0;
  ping_ctr = 0;
  ack_ctr = 0;
  irq_router_init();
  if (flash_config_init()) {
    IPLOG("Config:            Created\r\n");
    // created config
    long l = loader_get_user_long();
    //printf("Loadertable: %p\r\n", get_loader_table());
    printf("User long: %p\r\n", (void *)l);
  } else {
    IPLOG("Config:            Valid\r\n");
  }
  fets_init();
 
  metric_init();
 
  mculib_watchdog_avoid();
  long n = config_get_log_node();
 
  if (n != 0) {
    logging_set_node(n);
    logging_on();
  }
 
  // start usb
  usb_start();
  print_to_usb(1);
  routing_command_init();
 
  // indicate we got power and are running
  led_init();
  if (mculib_get_reset_source() == HAL_RESET_POWER) {
    led_indicate(LED_POWERUP);
  } else {
    led_indicate(LED_RESET);
  }
 
  mculib_serialport_callback(MAIN_MCULIBHANDLE, &serialirq);
 
  init_nic_registry();
  IPLOG("************* App started ************\r\n");
 
  partition_init();
 
  printf("Init userapp..\r\n");
  user_app_exe_init();  // init userapp stuff
 
  IPLOG("********* Init Network ***********\r\n");
  // we try the new 'netdev' api:
  register_nic(ti1101_get_netdev(), SOURCE_RADIO);
  register_nic(sx1262_get_netdev(), SOURCE_LORA);
 
  // ******************* init all nics
  init_all_nics();
  // ******************* init serialport etc..
 
 
  print_boot_info();
  printf("********** MAIN ***********\r\n");
  logging_event_loop(); // flush out the logging (small buffers, do this often)
 
  avoid_watchdog();
 
  printf("Initializing wifi...\r\n");
  esp_init();
  logging_event_loop(); // flush out the logging (small buffers, do this often)
  printf("wifi initialized...\r\n");
 
 
  if (!adr_isvalid(config_get_ram_struct()->nodeid)) {
    create_new_node_id();
  }
  logging_event_loop(); // flush out the logging (small buffers, do this often)
  print_node_id(config_get_ram_struct()->nodeid);
 
  logging_event_loop(); // flush out the logging (small buffers, do this often)
  print_program_status();
  logging_event_loop(); // flush out the logging (small buffers, do this often)
  IPLOG("User long:         %p\r\n", (void *)loader_get_user_long());
 
  logging_event_loop(); // flush out the logging (small buffers, do this often)
 
  long lastradioping = 0;
 
  logging_event_loop(); // flush out the logging (small buffers, do this often)
 
  static uint8_t delayed_started = 0;
 
  if (mculib_usb_host_connected(MAIN_MCULIBHANDLE) == 0) {
    printf("No usb host, starting immediately...\r\n");
    // if no usb host is connected, start immediately
    start_delayed();
    delayed_started = 1;
  }
 
  init_irq_metric_counter();
 
  uint32_t loopctr1 = 0;
  long loopctrsec = 0;
 
  long delayedctr = 0;
 
  /********************************************************
   ***** MAIN LOOP ********
   *******************************************************/
  IPLOG("mainloop!\r\n");
  logging_event_loop(); // flush out the logging (small buffers, do this often)
 
 
  while (1) {
    metric_inc_by_number(LOOP_COUNTER);
    // we start some stuff "delayed" (if and only if a usb host is connected)
    // this makes it easier to recover from borken userapps
    if (!delayed_started) {
      if (mculib_has_time_passed(MAX_SECS_BEFORE_DELAYED_START, &delayedctr)) {
        printf("usb host, completing late initialization...\r\n");
        start_delayed();
        delayed_started = 1;
      }
    }
    /************************ powersave handling ****************/
 
    // shall we go into powersave mode?
    power_main_loop(); // this function may not return for upto 5 minutes
 
    /************************ full-feature, no powersave mode: ****************/
    process_irqs(); // process all the softirqs now
 
    loopctr1++;
 
    if (mculib_has_time_passed(MAX_SECS_BETWEEN_LOOP_SAMPLES, &loopctrsec)) {
      if (loopctr1 < 500) {
        // if too slow, increase speed!
        power_set_speed(10);
      }
      printf("Loopctrs: %i @ speed %i\r\n", loopctr1, mculib_get_speed());
      loopctr1 = 0;
    }
    avoid_watchdog();
    /* check for commands on the terminal */
    process_terminal_input();
 
    if (stopped) {
      if (mculib_has_time_passed(MAX_SECS_BETWEEN_STOP_WARNING, &lastradioping)) {
        printf("Stopped (\"cont\" to continue.)\r\n");
      }
      continue;
    }
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
 
    /* process incoming esp8266 packets */
    if ((!config_get_wifidisable()) && (!is_hijacked_esp32())) {
      int bs;
      int r = 0;
      while ((bs = esp8266_packet_size()) > 0) {
        r++;
        if (r > 5) { // process at most 5 packets in one loop
          break;
        }
        esp8266_get_buf()[bs] = 0;
        esp8266_got_packet(esp8266_get_buf(), bs);
      }
    }
 
    //Delay(1); // in main: only loop in .001s intervals
 
    // TODO: each eventqueue should report wether or not it requires another
    // call. if we knew that here, we could safely go to sleep at some point
 
    // check the event queues. (reset watchdog before entering a queue)
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
 
    process_nic_event_loop();
    avoid_watchdog();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
 
    avoid_watchdog();           // we are progressing, so go away watchdog
    if (is_hijacked_esp32()) {
      //this takes current bytes in dma buffer and feeds them to the one-byte soft-IRQ
      mculib_serialport_transferbuffer(USART_ESP8266);
    } else {
      esp8266_event_loop();
    }
 
    avoid_watchdog();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
 
    avoid_watchdog();           // we are progressing, so go away watchdog
    process_command_queue();
 
    avoid_watchdog();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
 
    avoid_watchdog();           // we are progressing, so go away watchdog
    routing_event_loop();
 
    avoid_watchdog();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
 
    avoid_watchdog();           // we are progressing, so go away watchdog
    process_command_queue();    // do this at the end to so to quickly get rid of queued packets
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
 
    avoid_watchdog();
    stream_loop();
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
 
    led_loop();
 
    /* this needs an oscilloscope to properly be debugged */
    /*
     * int nspeed = 10;
     * uint32_t speed_lock = mculib_raise_speed(nspeed);
     * printf("New MCU Speed: %i\r\n",nspeed);
     * mculib_serialport_enable(USART_CONSOLE, 115200);
     */
    avoid_watchdog();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
 
    sensor_loop();
    logging_event_loop();       // flush out the logging (small buffers, do this often)
    /*
     * nspeed = mculib_lower_speed(speed_lock);
     * printf("New MCU Speed: %i\r\n",nspeed);
     * mculib_serialport_enable(USART_CONSOLE, 115200);
     */
    if (user_app_executable()) {
      avoid_watchdog();
      logging_event_loop(); // flush out the logging (small buffers, do this often)
      invoke_user_loop();
    }
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
    fets_loop();
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
    metric_loop();
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging (small buffers, do this often)
    check_power_on_loop();
 
    avoid_watchdog();
    logging_event_loop(); // flush out the logging
    check_time_on_loop();
  }
}
 
 
static void start_delayed() {
  if (config_get_flag(CONFIG_FLAGS_START_USERAPP_ON_BOOT)) {
    printf("Enable userapp..\r\n");
    user_app_enable(); // do this before sensors are enabled, so we pick up any sensors that are registered from user
  }
  if (config_get_sensors_enabled()) {
    sensors_init();
  } else {
    printf("sensors disabled in config.\r\n");
  }
}
 
int app_main(void) {
  app_main_no_return();
  return 0;
}