user_app_exe.c

Go to the documentation of this file.

#include "user_app_exe.h"
#include "main-header.h"
#include "sys/types.h"
#include "user_app_info.h"
#include "powersave.h"
#include "constants.h"
#include "config.h"
#include "command-parser.h"
#include "sensors/sensor.h"
#include "ascii_parser.h"
#include "led.h"
#include "userconfig.h"
#include "protobuf.h"
#include "fets.h"
#include "sc_time.h"
#include "softirq.h"
#include "api_version.h"
#include "hijack.h"
#include "reboot.h"
static uint32_t repoid;         // most recently started repoid (e.g. for printf)
static uint32_t version;        // most recently started version (e.g. for printf)
static struct command *alloc_command_user();
static int user_serialport_callback(int mculibhandle, int portnum, serial_recv_callback cb);
static int mcu_set_speed(int mculibhandle, int speed);
static void reset_userapp();
static void led_app_blink(int colour, int brightness, int on, int off);
static int register_user_sensor(struct sensordev *sensor);
static void free_user_sensors();
static struct sensordev *sensordevptr[20];
static int unhandled_call();
static void user_printf(const char *format, ...);
static void user_debugf(const char *format, ...);
static serial_recv_callback serial_recv_callback_usart3;
static char userappbuf[500]; // max 512 lines long please
static char *PREFIX = "userapp";
static struct sc_firmware_api user_callback_api = {
  .printf                               = &user_printf,
  .debugf                               = &user_debugf,
  .mculib_serialport_enable             = &mculib_serialport_enable,
  .mculib_serialport_disable            = &mculib_serialport_disable,
  .user_serialport_callback             = &user_serialport_callback,
  .mculib_serialport_write_char         = &mculib_serialport_write_char,
  .mculib_pin_out                       = &mculib_pin_out,
  .mculib_pin_out_opendrain             = &mculib_pin_out_opendrain,
  .mculib_pin_in                        = &mculib_pin_in,
  .mculib_pin_in_callback               = &mculib_pin_in_callback,
  .mculib_pin_set                       = &mculib_pin_set,
  .mculib_pin_release                   = &mculib_pin_release,
  .mculib_pin_get                       = &mculib_pin_get,
  .mculib_serialport_write_string       = &mculib_serialport_write_string,
  .mculib_has_time_passed               = &mculib_has_time_passed,
  .mculib_get_seconds_since_boot        = &mculib_get_seconds_since_boot,
  .mculib_spi_disable                   = &mculib_spi_disable,
  .mculib_spi_send_dma                  = &mculib_spi_send_dma,
  .mculib_spi_speed                     = &mculib_spi_speed,
  .mculib_spi_master_enable3            = &mculib_spi_master_enable3,
  .mculib_spi_write_and_read            = &mculib_spi_write_and_read,
  .mculib_spi_write_only                = &mculib_spi_write_only,
  .mculib_spi_read16_only               = &mculib_spi_read16_only,
  .mculib_timer_enable_simple           = &mculib_timer_enable_simple,
  .mculib_timer_disable                 = &mculib_timer_disable,
  .mculib_timer_attach_pin_pwm          = &mculib_timer_attach_pin_pwm,
  .mculib_timer_set_pwm                 = &mculib_timer_set_pwm,
  .mculib_adc_read_once                 = &mculib_adc_read_once,
  .mculib_adc_get_resolution            = &mculib_adc_get_resolution,
  .mculib_adc_enable                    = &mculib_adc_enable,
  .mculib_adc_read                      = &mculib_adc_read,
  .com_get_named_arg                    = &namedarg,
  .com_get_named_arg_uint16             = &namedarg_uint16,
  .com_get_named_arg_uint32             = &namedarg_uint32,
  .com_get_arg                          = &get_arg,
  .com_get_arg_size                     = &get_arg_size,
  .com_add_arg                          = &command_add_arg,
  .com_add_binary_arg                   = &command_add_binary_arg,
  .com_add_varg                         = &command_add_varg,
  .com_alloc                            = &alloc_command_user,
  .com_free                             = &free_command,
  .com_get_data_reply                   = &get_data_reply,
  .com_send_reply_with_args             = &send_command_reply_with_args,
  .com_deliver_command                  = &deliver_command,
  .sensor_register                      = &register_user_sensor,
  .strcmp                               = &strcmp,
  .memset                               = &memset,
  .strlen                               = &strlen,
  .strncpy                              = &strncpy,
  .vsnprintf                            = &vsnprintf,
  .snprintf                             = &snprintf,
  .atoi                                 = &atoi,
  .led_blink                            = &led_app_blink,
  .get_config_flag                      = &get_user_config_flag,
  .com_send_command                     = &send_command,
  .userconfig_size                      = &userconfig_size,
  .userconfig_version                   = &userconfig_version,
  .userconfig_copy                      = &userconfig_copy,
  .userconfig_write                     = &userconfig_write,
  .sensor_get_runtime_by_index          = &get_runtime,
  .proto_buf_to_struct                  = &buf_to_struct,
  .proto_struct_to_buf                  = &struct_to_buf,
  .proto_release                        = &proto_release,
  .pin_pwm                              = &pin_pwm,
  .time_get_localtime_as_struct         = &get_localtime_as_struct,
  .timer_softirq                        = &softirq_timer,
  .time_get_diff                        = &diff_time,
  .time_bcd_to_timestruct               = &convert_timestamps_to_time,
  .mcu_set_speed                        = &mcu_set_speed,
  .hijack_usb_acm                       = &hijack_usb_acm,
  .send_via_usb_acm                     = &send_via_usb_acm,
  .hijack_esp32_usart                   = &hijack_esp32_usart,
  .hijack_esp32_usart_stop              = &unhijack_esp32,
  .reset_module                         = &reboot_hard,
  .reset_userapp                        = &reset_userapp,
  .unhandled_call1                      = &unhandled_call,
  .unhandled_call2                      = &unhandled_call,
  .unhandled_call3                      = &unhandled_call,
  .unhandled_call4                      = &unhandled_call,
  .unhandled_call5                      = &unhandled_call,
  .unhandled_call6                      = &unhandled_call,
  .unhandled_call7                      = &unhandled_call,
  .unhandled_call8                      = &unhandled_call,
};
 
 
/**************************** code to interact with usercode ************/
 
static uint8_t crc_ok = 0; // 0: not checked, 1:ok, 2:false
static uint8_t do_exe_user_app = 0;
static uint8_t has_failed = 0;
static uint8_t start_stop_status = 0; //most recent: 0->neither, 1->started, 2->stopped
static uint32_t myversion = 0;
static struct userapp_info *myapp;
 
#define MCULIB_USERAPP_HANDLE 7
 
// called by irq handlers and loop entry/exit
void set_in_app(uint8_t a) {
  constants()->in_user_app = a;
}
 
/* \brief called by main.c at startup, exactly once */
void user_app_exe_init() {
  memset(&sensordevptr, 0, sizeof(sensordevptr));
  start_stop_status = 0;
  myapp = (struct userapp_info *)config_get_userapp();
  if (myapp != NULL) {
    // store for later, so we can detect in-place upgrades
    myversion = myapp->version;
  }
  crc_ok = 0;
  /*
   * was there a reset whilst userapp was executed?
   */
  if ((constants()->in_user_app) && (mculib_get_reset_source() != HAL_RESET_POWER)) {
    has_failed = 1;
    printf("Userapp disabled (fail-safe)\r\n");
  } else {
    has_failed = 0;
  }
}
 
/*
 * \brief return >0 if app has changed since we last called init()
 */
static int has_changed() {
  struct userapp_info *newapp = (struct userapp_info *)config_get_userapp();
 
  if (newapp != myapp) {
    return 1;
  }
  if (newapp == NULL) {
    return 0;
  }
  // current app and myapp are same and not NULL
  if (newapp->version != myversion) {
    return 1;
  }
  // add checksum/other tests here...
  return 0;
}
 
static void reset_userapp() {
  user_app_disable();
  user_app_enable();
}
struct userapp_info *get_user_app() {
  return myapp;
}
// return 1 if it is enabled
int user_app_is_enabled() {
  return do_exe_user_app;
}
/*
 * \brief (re-)enable usercode. this is a bit more complex, because
 * a) we must avoid calling start() twice and b) the userapp might have
 * been upgraded since calling start().
 * the userapp might been upgraded in-place or at another memory location.
 * we detect in-place upgrade by comparing the version number
 */
void user_app_enable() {
  do_exe_user_app = 1;
  if (!user_app_executable()) {
    return;
  }
  if ((has_changed()) && (start_stop_status == 1)) {
    // stop old one
    invoke_stop();
    user_app_exe_init(); // re-init
  }
  if (start_stop_status != 1) {
    invoke_start(MCULIB_USERAPP_HANDLE);        // call the user startup hook (last thing to do)
    mculib_print_mappings(&printf);
  }
}
// TODO: clean up mculib
void user_app_disable() {
  if (!user_app_executable()) {
    set_in_app(0);
    do_exe_user_app = 0;
    return;
  }
  do_exe_user_app = 0;
  if (start_stop_status == 1) {
    invoke_stop();
  }
  set_in_app(0);
}
// return != 0 if checksum is valid
int user_app_checksum_valid() {
  struct userapp_info *uai = get_user_app();
 
  if (uai == NULL) {
    return 0;
  }
 
  if (!has_changed()) {
    if (crc_ok == 1) {
      return 1;
    } else if (crc_ok == 2) {
      return 0;
    }
  }
  if (!user_app_is_valid()) {
    return 0;
  }
  uint32_t checksum = calc_crc32((void *)uai, uai->length, 8);
 
  if (checksum == uai->checksum) {
    crc_ok = 1;
    return 1;
  }
  crc_ok = 2;
  printf("Userapp checksum calculated: %p, reported: %p\r\n", checksum, uai->checksum);
  return 0;
}
/* \brief returns !=0 if userapp is valid */
int user_app_is_valid() {
#ifdef __unix__
  return 0;
#endif
 
  struct userapp_info *uai = get_user_app();
  if (uai == NULL) {
    return 0;
  }
  if (uai->magic != 0x53435541) {
    return 0;
  }
 
  return 1;
}
 
/* \brief return !=0 if userapp should and can be executed */
int user_app_executable() {
#ifdef __unix__
  return 0;
#endif
  if (has_failed) {
    return 0;
  }
  if (!do_exe_user_app) {
    return 0;
  }
  if (!user_app_is_valid()) {
    return 0;
  }
  if (!user_app_checksum_valid()) {
    return 0;
  }
 
  return 1;
}
 
void invoke_start(int MCULIBHANDLE) {
  free_user_sensors();
  set_in_app(1);
  struct userapp_info *ua = get_user_app();
 
  repoid = ua->repoid;
  version = ua->version;
  ua->start(MCULIBHANDLE, &user_callback_api);
  set_in_app(0);
  start_stop_status = 1;
}
void invoke_stop() {
  serial_recv_callback_usart3 = NULL;
  free_user_sensors();
  softirqs_removeall();
  set_in_app(1);
  get_user_app()->stop();
  unhijack_all();
  set_in_app(0);
  start_stop_status = 2;
  led_off(LED_USER); // only turns it off if currently managed by user
  mculib_release_by_handle(MCULIB_USERAPP_HANDLE);
}
int invoke_on_command_received(struct command *com) {
  set_in_app(1);
  int r = get_user_app()->on_command_received(com);
 
  set_in_app(0);
  return r;
}
void invoke_on_new_node(struct hostroute *host) {
  set_in_app(1);
  get_user_app()->on_new_node(host);
  set_in_app(0);
}
 
void invoke_user_loop() {
  set_in_app(1);
  get_user_app()->user_loop();
  set_in_app(0);
}
 
void user_app_reset_state() {
  crc_ok = 0;
  do_exe_user_app = 0;
  myversion = 0;
  set_in_app(0);
  has_failed = 0;
  unhijack_all();
  printf("User app state reset\r\n");
}
 
// 0 if ok
int send_user_app_status() {
  return user_app_info(NULL);
}
static uint32_t user_app_git_repo() {
  struct userapp_info *uac = get_user_app();
 
  if (uac == NULL) {
    return 0;
  }
  return uac->repoid;
}
static uint32_t user_app_timestamp() {
  struct userapp_info *uac = get_user_app();
 
  if (uac == NULL) {
    return 0;
  }
  return uac->build_timestamp;
}
static uint32_t user_app_apiversion() {
  struct userapp_info *uac = get_user_app();
 
  if (uac == NULL) {
    return 0;
  }
  return uac->api_version;
}
int user_app_info(struct command *com) {
  struct command *reply = alloc_command();
 
  if (reply == NULL) {
    return 1;
  }
  printf("Delivering user_app_status\r\n");
  reply->target = CLOUD_SERVER;
  reply->com = 53; //userapp_info
  command_add_arg(reply, "adr=%p", myapp);
  command_add_arg(reply, "v=%p", myversion);
  command_add_arg(reply, "f=%i", (int)has_failed);
  command_add_arg(reply, "e=%i", user_app_executable());
  command_add_arg(reply, "vl=%i", user_app_checksum_valid());
  command_add_arg(reply, "en=%i", user_app_is_enabled());
  command_add_arg(reply, "flags=%i", (uint32_t)get_user_config_flags());
  command_add_arg(reply, "r=%i", user_app_git_repo());
  command_add_arg(reply, "ts=%i", user_app_timestamp());
  command_add_arg(reply, "av=%i/%i", user_app_apiversion(), CNW_API_VERSION);
  reply->flags = COMFLAGS_SUCCESS;
  reply->encoding = 'a';
  if (com != NULL) {
    reply->index = com->index;
    reply->target = com->sender;
    reply->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  }
  int i = deliver_command(reply, NULL);
 
  if (i != 0) {
    printf("Failed to deliver userapp_status command: %i\r\n", i);
  }
  return 0;
}
 
//userapp control command called
void user_app_control(struct command *com) {
  if (namedarg(com, "ucr") != NULL) {
    int i = userconfig_receive(com);
    if (i == 1) {
      send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
    } else if (i == 2) {
      send_command_reply(com, COMFLAGS_ACK);
    }
    return;
  }
  const char *x = get_arg(com, 0);
 
  if (x == NULL) {
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  int l = atoi(x);
 
  if (l == 1) {
    has_failed = 0;
    user_app_enable();
  } else if (l == 2) {
    user_app_disable();
  } else if (l == 3) {
    // process flags and stuff later
  } else {
    printf("invalid userapp control: %i\r\n", l);
    send_command_reply(com, COMFLAGS_ACK);
    return;
  }
  x = namedarg(com, "flags");
  if (x != NULL) {
    uint32_t fl = atoi(x);
    set_user_config_flags(fl);
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
 
/* led helper */
static void led_app_blink(int colour, int brightness, int on, int off) {
  led_set_user_managed();
  led_blink(LED_USER, colour, brightness, on, off);
}
 
static void free_user_sensors() {
  int max = sizeof(sensordevptr) / sizeof(struct sensordev *);
  int i;
 
  for (i = 0; i < max; i++) {
    struct sensordev *entry = sensordevptr[i];
    if (entry == NULL) {
      continue;
    }
    sensor_deregister(entry);
    sensordevptr[i] = NULL;
  }
}
 
static int register_user_sensor(struct sensordev *sensor) {
  struct sensordev *sd = sensor_register(sensor);
 
  if (sd == 0) {
    return 1;
  }
  int max = sizeof(sensordevptr) / sizeof(struct sensordev *);
  int i;
 
  for (i = 0; i < max; i++) {
    struct sensordev *entry = sensordevptr[i];
    if (entry == NULL) {
      sensordevptr[i] = sd;
      return 0;
    }
  }
  return 2;
}
 
int userapp_checksum_valid(void *baseadr) {
  struct userapp_info *uai = baseadr;
 
  if (uai == NULL) {
    return 0;
  }
  if (uai->magic != 0x53435541) {
    return 0;
  }
 
  uint32_t checksum = calc_crc32((void *)uai, uai->length, 8);
 
  if (checksum != uai->checksum) {
    return 0;
  }
  return 1;
}
 
static void user_printf(const char *format, ...) {
  va_list args;
  int max_size = sizeof(userappbuf) - 1;
 
  snprintf((char *)&userappbuf, max_size, "[%s info  #%i/%i] ", PREFIX, repoid, version);
 
  int l = strlen(userappbuf);
 
  va_start(args, format);
  vsnprintf((char *)&userappbuf + l, max_size - l, format, args);
  va_end(args);
  print((const char *)&userappbuf);
}
static void user_debugf(const char *format, ...) {
  va_list args;
  int max_size = 511;
 
  snprintf((char *)&userappbuf, max_size, "[%s debug #%i/%i] ", PREFIX, repoid, version);
 
  int l = strlen(userappbuf);
 
  va_start(args, format);
  vsnprintf((char *)&userappbuf + l, max_size - l, format, args);
  va_end(args);
  print((const char *)&userappbuf);
}
 
struct command *alloc_command_user() {
  struct command *com = alloc_command_with_minfree(10);
 
  return com;
}
 
static int unhandled_call() {
  printf("Userapp called a function which is not implemented\r\n");
  has_failed = 1;
  user_app_disable();
  return 0;
}
int user_serial_callback(int portnum, int byte) {
  if (portnum != 3) {
    return 0;
  }
  if (serial_recv_callback_usart3 == NULL) {
    return 0;
  }
  serial_recv_callback_usart3(portnum, byte);
  return 1;
}
static int user_serialport_callback(int mculibhandle, int portnum, serial_recv_callback cb) {
  if (portnum != 3) {
    return 5;
  }
  serial_recv_callback_usart3 = cb;
  return 0;
}
static int mcu_set_speed(int mculibhandle, int speed) {
  if (speed > 10) {
    return 1;
  }
  if (speed < 0) {
    return 2;
  }
  set_mcu_power_mode(speed);
  return 0;
}