command-handler.c

Go to the documentation of this file.

#include <main-header.h>
#include <loader-api.h>
#include <user_app_exe.h>
#include <constants.h>
#include <function-instr.h>
#include "sc_time.h"
#include <baseinfo.h>
#include <streams.h>
#include <flashapp.h>
#include <fets.h>
#include <led.h>
#include <sensors/sensor.h>
#include <sensors/sensor_command.h>
#include <routing.h>
#include <route_command.h>
#include <forwarding.h>
#include "ti1101.h"
#include "user_app_info.h"
#include "user_app_exe.h"
//#include <bare-metal.h>
 
static int dac_toggle_high = 0;
static int dac_toggle_low = 0;
static int dac_toggle_speed;
static int dac_toggle_cur;
static int dac_cur_value = 0;
static int dac_toggle_step = 0;
static byte dac_cur_dir = 0;
 
static int strobe_relay = 0;
static int strobe_cur = 0;
static int strobe_repeat = 0;
static int strobe_timeout_on = 0;
static int strobe_timeout_off = 0;
static int strobe_state = 0;
#define MAX_PIN_STATES 5
static uint16_t pinstates[MAX_PIN_STATES]; // max 5 pins may be
// the delivery queue
 
 
extern int ack_ctr;
 
static void restore_pin(int pin);
static void store_pin(int pin);
void list_modules(struct command *com);
void process_strobe_command(struct command *com);
void check_strobe();
void start_strobe(int relay, int ton, int toff, int repeat);
static void software_info(struct command *com);
static void installed_info(struct command *com);
static void button_pressed(struct command *com);
static void set_server_name(struct command *com);
static void set_sensor_server_name(struct command *com);
static void set_config(struct command *com);
void init_command_handler() {
  memset(&pinstates, 0, sizeof(pinstates));
}
void setpin(struct command *com) {
  int r;
  int pin = atoi(get_arg(com, 0));
  int state = atoi(get_arg(com, 1));
 
  if ((pin == 100) || (pin == 101)) {
    fets_set_com(com);
    return;
  }
  printf("setting pin %i to %i\r\n", pin, state);
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, pin, HAL_PIN_FASTEST))) {
    printf("set-pin: failed to set pin %i to out: %i\r\n", pin, r);
    return;
  }
  r = mculib_pin_set(MAIN_MCULIBHANDLE, pin, state);
  if (r != 0) {
    printf("set-pin: failed to set pin: %i\r\n", r);
  }
}
static void completion(struct command *com, int result) {
  if (result == 1) {
    send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
    return;
  } else if (result == 2) {
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
}
 
int is_packet_for_us(struct command *com) {
  char ownnode[10];
  char othernode[10];
 
  node_to_str(config_get_ram_struct()->nodeid, ownnode);
  if (!adr_isvalid(com->sender)) {
    node_to_str(com->sender, othernode);
    printf("Dropping packet: Invalid sender ID: %s\r\n", othernode);
    return 0;
  }
  if (!adr_isvalid(com->recipient)) {
    node_to_str(com->recipient, othernode);
    printf("Dropping packet: Invalid recipient ID: %s\r\n", othernode);
    return 0;
  }
  if (!adr_isvalid(com->target)) {
    node_to_str(com->target, othernode);
    printf("Dropping packet: Invalid target ID: %s\r\n", othernode);
    return 0;
  }
  // check if packet is for ourselves
  if (
    (com->recipient == 0xFFFFFFFF)
    || (com->target == 0xFFFFFFFF)
    || (com->recipient == get_my_node_id())
    ) {
    return 1;
  }
 
 
  // not for ourselves - but to forward
  node_to_str(com->recipient, othernode);
  printf("comhandler: Forwarding packet to %s...\r\n", othernode);
  int i = forward_packet(com);
 
  printf("forward result: %i\r\n", i);
  return 0;
}
 
void set_logging(struct command *com) {
  int enable;
  int newpos;
 
  enable = 0;
  if (com->argctr > 0) {
    enable = atoi(get_arg(com, 0));
  }
  if (com->argctr > 1) {
    long node = ascii_parse_hex((const byte *)get_arg(com, 1), 8, &newpos);
    logging_set_node(node);
    config_set_log_node(node);
    config_commit();
    IPLOG("logging enabled\r\n");
  }
  if (enable) {
    logging_on();
  } else {
    IPLOG("Disabling logging\r\n");
    logging_off();
    config_set_log_node(0);
    config_commit();
  }
}
void static inline xdelay_us(int us, int timeout) {
  int jc = 0;
  int x = us * timeout;
 
  while (jc < x) {
    jc++;
  }
}
 
 
void micro_strobe(struct command *com) {
  int pin = atoi(get_arg(com, 0));
  int timeout_on = atoi(get_arg(com, 1));
  int timeout_off = atoi(get_arg(com, 2));
  int repeat = atoi(get_arg(com, 3));
  int us = atoi(get_arg(com, 4));
  int i = 0;
 
  //long t = mculib_get_seconds_since_boot();
  for (i = 0; i < repeat; i++) {
    //    long x = mculib_get_seconds_since_boot();
    //if ( (x-t) > 10) {
    //  break;
    //}
    //avoid_watchdog();
    mculib_pin_set(MAIN_MCULIBHANDLE, pin, 1);
    xdelay_us(us, timeout_on);
    mculib_pin_set(MAIN_MCULIBHANDLE, pin, 0);
    xdelay_us(us, timeout_off);
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  printf("Did strobe timeout_on=%i,timeout_off=%i...\r\n", timeout_on, timeout_off);
}
void factory_default(struct command *com) {
  printf("Erasing config...\r\n");
  config_erase();
  loader_erase_config();
  printf("Rebooting...\r\n");
  reboot_fast();
}
 
 
 
long get_my_node_id() {
  long res = config_get_ram_struct()->nodeid;
 
  if (!adr_isvalid(res)) {
    return 0;
  }
  res = res & 0xFFFFFFFF; // ensure 32bit
  return res;
}
 
void setcloudtoken(struct command *com) {
  if (com->argctr != 1) {
    printf("Missing cloud token!\r\n");
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  const char *token = get_arg(com, 0);
 
  if (token == NULL) {
    printf("cloud token must not be NULL!\r\n");
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  printf("Setting a cloud token\r\n");
  config_set_cloud_token(token);
  config_commit();
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  //esp_cloudconnect("module-in.singingcat.net");
  esp8266_send_instructions();
}
void forward_radio(struct command *com) {
  int newpos;
  long node = ascii_parse_hex((const byte *)get_arg(com, 0), 8, &newpos);
 
  ti1101_forward_radio(node);
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
static void set_server_name(struct command *com) {
  config_set_cloud_server(get_arg(com, 0));
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  //send_command_reply(com, COMFLAGS_ACK);
  printf("Command-handler: set new cloud server to %s\r\n", get_arg(com, 0));
  esp_init();
}
static void set_sensor_server_name(struct command *com) {
  if (com->argctr != 2) {
    IPLOG("Error - need exactly 2 arguments to set_server_name, not %i\r\n", com->argctr);
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  const char *srv = get_arg(com, 0);
 
  printf("Setting sensor server to \"%s\"\r\n", srv);
  config_set_sensor_server(srv);
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  config_commit();
}
void set_config_flag(struct command *com) {
  if (com->argctr != 2) {
    IPLOG("Error - need exactly 2 arguments to set_config_flag, not %i\r\n", com->argctr);
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  int flag = atoi(get_arg(com, 0));
  int value = atoi(get_arg(com, 1));
 
  config_set_flag(flag, value);
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  config_commit();
}
void get_config_flags(struct command *com) {
  struct command *reply;
 
  reply = alloc_command();
  if (reply == NULL) {
    printf("cannot reply.\r\n");
    return;
  }
  command_add_arg(reply, "flags1=%i", config_get_ram_struct()->flags1);
  command_add_arg(reply, "flags2=%i", config_get_ram_struct()->flags2);
  command_add_arg(reply, "flags=%N", config_get_flags());
  reply->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  reply->index = com->index;
  reply->target = com->sender;
  reply->encoding = 'a';
  reply->connid = com->connid;
  reply->com = com->com;
 
  deliver_command(reply, NULL);
}
 
void wifi_info(struct command *com) {
  struct ipv4address *ip;
  struct command *reply;
 
  ip = esp8266_get_current_ip();
  reply = alloc_command();
  if (reply == NULL) {
    printf("cannot reply.\r\n");
    return;
  }
  command_add_arg(reply, "ws=%i", esp8266_get_firmware_version());
  if (ip != NULL) {
    command_add_arg(reply, "ip=%i.%i.%i.%i", ip->ip1, ip->ip2, ip->ip3, ip->ip4);
  }
  const char *ssid = esp_get_last_ssid();
 
  if (ssid != NULL) {
    command_add_arg(reply, "ssid=%s", ssid);
  }
  const char *pw = esp_get_last_pw();
 
  if (pw != NULL) {
    command_add_arg(reply, "pw=%s", pw);
  }
  command_add_arg(reply, "rsctr=%i", get_esp_reboot_ctr());
  reply->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  reply->index = com->index;
  reply->target = com->sender;
  reply->encoding = 'a';
  reply->connid = com->connid;
  reply->com = com->com;
 
  deliver_command(reply, NULL);
}
 
void getcloudtoken(struct command *com) {
  struct command *reply;
 
  reply = alloc_command();
  if (reply == NULL) {
    printf("cannot reply.\r\n");
    return;
  }
  const char *tok = config_get_cloud_token();
 
  if (tok != NULL) {
    command_add_arg(reply, "key=%s", tok);
    reply->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  } else {
    reply->flags = COMFLAGS_ACK;
  }
  reply->index = com->index;
  reply->target = com->sender;
  reply->encoding = 'a';
  reply->connid = com->connid;
  reply->com = com->com;
 
  deliver_command(reply, NULL);
}
 
void getpubkey(struct command *com) {
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
 
static void gpio_set_dac(int dac, int val) {
  printf("gpio_set_dac not implemented in command-handler.c\r\n");
}
 
void setdac(struct command *com) {
  if (com->argctr == 2) {
    int dac = atoi(get_arg(com, 0));
    int val = atoi(get_arg(com, 1));
    dac_toggle_step = 0;
    gpio_set_dac(dac, val);
  } else if (com->argctr == 5) {
    dac_toggle_high = atoi(get_arg(com, 1));
    dac_toggle_low = atoi(get_arg(com, 2));
    dac_toggle_step = atoi(get_arg(com, 3));
    dac_toggle_speed = atoi(get_arg(com, 4));
    if (dac_toggle_low > dac_toggle_high) {
      int x = dac_toggle_low;
      dac_toggle_low = dac_toggle_high;
      dac_toggle_high = x;
    }
    dac_cur_value = dac_toggle_low;
    dac_toggle_cur = 0;
    if (dac_toggle_step == 0) {
      gpio_set_dac(0, 0);
    }
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
void list_modules(struct command *com) {
  printf("Listing modules...\r\n");
  struct command *dcom;
  int nodes;
  struct hostroute *host;
  int i;
 
  dcom = alloc_command();
  if (dcom == NULL) {
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  nodes = routing_count_nodes();
  printf("Got %i nodes\r\n", nodes);
  for (i = 0; i < nodes; i++) {
    host = routing_get_node_by_index(i);
    if (host != NULL) {
      printf("%p\r\n", (void *)host->host);
      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, "%N", host->host);
      command_add_arg(dcom, "%i", host->hosttype);
      command_add_arg(dcom, "%i", host->device);
      send_command(dcom);
      free_command(dcom);
    }
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
 
static void button_pressed(struct command *com) {
  // do what here exactly?
}
static void installed_info(struct command *com) {
  char buf[100];
  int max = loader_get_app_base_address_count();
  int i;
 
  for (i = 0; i < max; i++) {
    struct app_header *app = loader_get_app_base_address(i);
    if (app == NULL) {
      continue;
    }
    struct meta_header *header = loader_get_app_meta_address(i);
    int seq = 0;
    if (header != NULL) {
      seq = header->meta_seq;
    }
    snprintf(buf, 99, "av=%i,ad=%p,ab=%p,repo=%i,seq=%i,idx=%i",
             app->version,
             app->buildtime,
             app,
             app->repoid,
             seq,
             i
             );
    printf("INSTALLED: %s\r\n", buf);
    if (send_data(com, "%s", buf) != 0) {
      goto fail;
    }
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  return;
fail:
  send_command_reply(com, COMFLAGS_ACK);
}
static void software_info(struct command *com) {
  struct command *dcom;
 
  dcom = get_data_reply(com);
  if (dcom == NULL) {
    goto fail;
  }
 
  command_add_arg(dcom, "av=%i", CNW_BUILD_VERSION);
  command_add_arg(dcom, "ad=%p", CNW_BUILD_TIMESTAMP);
  command_add_arg(dcom, "ab=%p", get_app_header());
  command_add_arg(dcom, "repo=%i", get_app_header()->repoid);
  command_add_arg(dcom, "ws=%i", esp8266_get_firmware_version());
  command_add_arg(dcom, "ua=%p", config_get_userapp());
  if (config_get_userapp() != 0) {
    struct userapp_info *ua = get_user_app();
    command_add_arg(dcom, "uv=%i", ua->version);
    command_add_arg(dcom, "ur=%i", ua->repoid);
  }
 
  send_command(dcom);
  free_command(dcom);
 
  dcom = get_data_reply(com);
  if (dcom == NULL) {
    goto fail;
  }
  command_add_arg(dcom, "lv=%i", loader_get_version());
  command_add_arg(dcom, "lpc=%p", constants()->last_return_address);
  command_add_arg(dcom, "fadr=%p", constants()->failing_address);
  command_add_arg(dcom, "cfsr=%p", constants()->CFSR);
  command_add_arg(dcom, "curts=%i", mculib_get_seconds_since_boot());
  command_add_arg(dcom, "rc=%p", loader_get_last_reset_cause());
  send_command(dcom);
  free_command(dcom);
 
 
  if (send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS)) {
    goto fail;
  }
  printf("sent data for software info\r\n");
  return;
fail:
  send_command_reply(com, COMFLAGS_ACK);
  printf("Failed to sent data for software info\r\n");
}
 
 
void dac_timer() {
  check_strobe();
  if (dac_toggle_step == 0) {
    return;
  }
  if (dac_toggle_cur < dac_toggle_speed) {
    dac_toggle_cur++;
    return;
  }
  dac_toggle_cur = 0;
  if (dac_cur_dir == 0) {
    dac_cur_value = dac_cur_value + dac_toggle_step;
    if (dac_cur_value >= dac_toggle_high) {
      dac_cur_dir = 1;
    }
  } else {
    dac_cur_value = dac_cur_value - dac_toggle_step;
    if (dac_cur_value <= dac_toggle_low) {
      dac_cur_dir = 0;
    }
  }
  gpio_set_dac(0, dac_cur_value);
}
 
 
void check_strobe() {
  if (strobe_timeout_on == 0) {
    return;
  }
  int max = 0;
 
  if (strobe_state == 1) {
    max = strobe_timeout_off;
  } else {
    max = strobe_timeout_on;
  }
  if (strobe_cur < max) {
    strobe_cur++;
    return;
  }
  strobe_cur = 1;
  if (strobe_state == 0) {
    mculib_pin_set(MAIN_MCULIBHANDLE, strobe_relay, 0);
    strobe_state = 1;
  } else {
    strobe_repeat--;
    mculib_pin_set(MAIN_MCULIBHANDLE, strobe_relay, 1);
    strobe_state = 0;
  }
  if (strobe_repeat <= 0) {
    strobe_timeout_on = 0;
    restore_pin(strobe_relay);
  }
}
 
void start_strobe(int relay, int ton, int toff, int repeat) {
  int r;
 
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, relay, HAL_PIN_FASTEST))) {
    printf("Strobe: failed to set pin %i to out: %i\r\n", relay, r);
    return;
  }
  store_pin(relay);
  strobe_state = 0;
  strobe_relay = relay;
  strobe_timeout_on = ton;
  strobe_timeout_off = toff;
  strobe_repeat = repeat;
  strobe_cur = 1;
  mculib_pin_set(MAIN_MCULIBHANDLE, strobe_relay, 1);
}
 
 
static void sensorrequest(struct command *com) {
  int x;
 
  if (com->argctr != 3) {
    printf("Need exactly 3 args for sensorrequest, not %i\r\n", com->argctr);
    // send fail?
    return;
  }
  const void *sensorname = get_arg(com, 0);
  long idx = ascii_parse_hex(sensorname, strlen(sensorname), NULL);
  const void *nodeid = get_arg(com, 1);
  long h = ascii_parse_hex(nodeid, strlen(nodeid), NULL);
 
  printf("nodeid: %s (%p)\r\n", nodeid, h);
  int paras[3];
 
  if ((x = get_arg_int_array(com, 2, (int *)paras, 3)) != 3) {
    printf("Too few arguments (need 3, got %i\r\n)", x);
    completion(com, 2);
    return;
  }
 
  completion(com, sensor_submit_request(h, (int)idx, paras[0], paras[1], paras[2]));
}
static void blinkled(struct command *com) {
  if (com->argctr < 3) {
    printf("Need at least 3 args for blinkled, not %i\r\n", com->argctr);
    // send fail?
    return;
  }
  led_set_user_managed();
  int col = atoi(get_arg(com, 0));
  int on = atoi(get_arg(com, 1));
  int off = atoi(get_arg(com, 2));
  int brightness = 256;
 
  if (com->argctr > 3) {
    brightness = atoi(get_arg(com, 3));
  }
  uint32_t flags = 0;
 
  if (com->argctr > 4) {
    flags = atoi(get_arg(com, 4));
  }
  printf("Led blink in colour %i, brightness=%i, on=%i, off=%i\r\n", col, brightness, on, off);
  if (col == 0) {
    led_off(LED_USER);
    led_set_machine_managed();
  } else {
    led_blink_flags(LED_USER, col, brightness, on, off, flags);
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  led_print_status();
}
void process_strobe_command(struct command *com) {
  if (com->argctr != 4) {
    return;
  }
 
  start_strobe(atoi(get_arg(com, 0)), atoi(get_arg(com, 1)), atoi(get_arg(com, 2)), atoi(get_arg(com, 3)));
}
 
 
 
void process_command(struct command *com) {
  int i;
 
  if (!is_packet_for_us(com)) {
    return;
  }
  if (com->flags & COMFLAGS_ACK) {
    // do not send this via log! - log will be ack'ed
    printf("ack received for %i (com=%i)\r\n", com->index, com->com);
    // packet is an ack
    i = process_queue_reply(com);
    if (i > 0) {
      IPLOG("ack processed for %i (com=%i)\r\n", com->index, com->com);
      return;
    }
    if (i == 0) {
      // we received a reply, but we (no longer) know which command triggered it!
      printf("ack received for %i (com=%i), but no trigger command found?\r\n", com->index, com->com);
      if (com->com == 12) {
        routing_request_reply(com); // update routing table
      }
    }
    if (i < 0) {
      printf("ack received for %i (com=%i), but failed to process it.\r\n", com->index, com->com);
    }
    return;
  }
  if (com->flags & COMFLAGS_DATA) {
    printf("data received for %i (com=%i)\r\n", com->index, com->com);
    // packet is data
    return;
  }
 
 
  if (com->com != 28) {
    // skip printing streamdata - too many!
    IPLOG("Processing incoming command.:\r\n");
    command_print(com);
  }
 
  /****************************************************
  * some commands will be executed prior to userhook
  * to ensure we can recover from broken userhooks
  ****************************************************/
 
  if (com->com == 6) {
    if (com->argctr == 0) {
      reboot_hard();
    } else {
      reboot(atoi(get_arg(com, 0)));
    }
  } else if (com->com == 23) {
    // routing update
    send_routing_update_now();
  } else if (com->com == 24) {
    // factory default
    factory_default(com);
  } else if (com->com == 25) {
    software_info(com);    // software info
  } else if (com->com == 26) {
    // button pressed
    button_pressed(com);
  } else if (com->com == 27) {
    streamsetup(com);
  } else if (com->com == 28) {
    streamdata(com);
  } else if (com->com == 19) {
    flashcom(com);
  } else if (com->com == 36) {
    installed_info(com);
  } else if (com->com == 35) {
    // start app is super important - perhaps we fuck up flashing?
    restart_app_idx(atoi(get_arg(com, 0)));
  }
 
 
  /****************************************************
  * now we call the userhook and may or may not
  * continue normal processing, depending on return value
  ****************************************************/
 
  // we call the userhook
  if (user_app_executable()) {
    completion(com, invoke_on_command_received(com));
  }
 
  /****************************************************
  * normal processing of commands
  * (unless command is superimportant - implement here)
  ****************************************************/
 
  if (com->com == 1) {
    send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  } else if (com->com == 4) { // set-wireless
    esp8266_add_ap(get_arg(com, 0), get_arg(com, 1));
  } else if (com->com == 5) {
    setpin(com);
  } else if (com->com == 7) {
    esp8266_reset();
  } else if (com->com == 8) {   // radio-ping
    //
  } else if (com->com == 9) {   // radiopingloop
    //
  } else if (com->com == 10) {
    printf("Freezing...\r\n");
    for (;;) {
      ; // I am frozen ;)
    }
  } else if (com->com == 11) {
    list_modules(com);
  } else if (com->com == 13) {
    process_strobe_command(com);
  } else if (com->com == 14) {
    getpubkey(com);
  } else if (com->com == 15) {
    setcloudtoken(com);
  } else if (com->com == 16) {
    set_logging(com);
    send_command_reply(com, COMFLAGS_ACK);
  } else if (com->com == 17) {
    setdac(com);
  } else if (com->com == 18) {
    printf("Set serial port not implemented\r\n");
  } else if (com->com == 20) {
    micro_strobe(com);
  } else if (com->com == 30) {
    blinkled(com);
  } else if (com->com == 31) {
    sensorrequest(com);
  } else if (com->com == 33) {
    completion(com, received_radio_get_config(com));
  } else if (com->com == 34) {
    completion(com, received_radio_set_config(com));
  } else if (com->com == 21) {
    set_server_name(com);
  } else if (com->com == 38) {
    getcloudtoken(com);
  } else if (com->com == 39) {
    forward_radio(com);
  } else if (com->com == 41) {
    set_config_flag(com);
  } else if (com->com == 43) {
    set_sensor_server_name(com);
  } else if (com->com == 44) {
    wifi_info(com);
  } else if (com->com == 45) {
    get_config_flags(com);
  } else if (com->com == 46) {
    esp8266_wifi_scan(com);
  } else if (com->com == 47) {
    route_command(com);
  } else if (com->com == 48) {
    sensor_com_list(com);
  } else if (com->com == 49) {
    sensor_com_config(com);
  } else if (com->com == 52) {
    set_config(com);
  } else if (com->com == 53) {
    user_app_info(com);
  } else if (com->com == 54) {
    user_app_control(com);
  } else if (com->com == 57) {
    completion(com, esp32_bt_trigger_read_characteristic_com(com));
  } else if (com->com == 55) {
    completion(com, esp32_bt_set_characteristic_com(com));
  } else if (com->com == 58) {
    completion(com, esp32_bt_peers(com));
  } else if (com->com == 59) {
    completion(com, time_command_received(com)); // clock-sync
  }
 
 
  if ((com->com == 3)
      || (com->com == 4)
      || (com->com == 8)
      || (com->com == 9)
      || (com->com == 10)
      || (com->com == 13)
      || (com->com == 5)) {
    send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  }
 
  free_command(com);
}
 
// command 52 "setconfig"
static void set_config(struct command *com) {
  const char *na = namedarg(com, "modid");
 
  if (na != NULL) {
    uint64_t modid = atoi(na);
    config_set_moduleid(modid);
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
 
/***************************** store/restore pin status *******************************/
// for after strobe..
static void store_pin(int pin) {
  int i = 0;
  int r;
  int t = 0;
 
  r = mculib_pin_get(MAIN_MCULIBHANDLE, pin);
  if (r == 0) {
    // noop
  } else if (r == 1) {
    t = (1 << 9);
  } else {
    printf("failed to get pin state: %i\r\n", r);
    return;
  }
  for (i = 0; i < MAX_PIN_STATES; i++) {
    if (((pinstates[i] & 0xFF) == pin) && (pinstates[i] & (1 << 8))) {
      // do not overwrite value
      return;
    }
    if ((pinstates[i] & (1 << 8)) && ((pinstates[i] & 0xFF) != pin)) {
      continue;
    }
    pinstates[i] = (uint16_t)(((uint8_t)pin) | (1 << 8)) | t;
    printf("Stored pin %i: %i\r\n", pin, (int)pinstates[i]);
    return;
  }
  printf("Unable to store pin %i: out of free slots\r\n", pin);
}
 
// runs in IRQ!
static void restore_pin(int pin) {
  int i = 0;
  int r;
  uint16_t p;
 
  for (i = 0; i < MAX_PIN_STATES; i++) {
    p = pinstates[i];
    if ((p & (1 << 8)) == 0) {
      continue;
    }
    if ((p & 0xFF) != pin) {
      continue;
    }
    r = 0;
    if (p & (1 << 9)) {
      r = 1;
    }
    mculib_pin_set(MAIN_MCULIBHANDLE, pin, r);
    pinstates[i] = 0;
    break;
  }
}