config.c

#include "main-header.h"
// #include "bare-metal.h"
 
// this is my in-ram copy
struct cnw_config config;
static byte valid;
static byte *destadr = 0;
int config_is_ram_valid();
//extern void *app_flash_adr; // its the ADRESS of the label !!
 
static int flash_read(void *buf, const int size) {
  byte *ram = buf;
 
  printf("[config] Config at %p\r\n", destadr);
  int i;
 
  for (i = 0; i < size; i++) {
    ram[i] = destadr[i];
  }
  return 1;
}
int flash_config_init() {
  struct cnw_config *cfg;
 
  destadr = get_flash_config_addr();
 
  valid = 0;
  printf("[config] Reading config from flash\r\n");
  flash_read(config_get_ram_struct(), sizeof(_cnw_config));
 
  if (config_is_ram_valid()) {
    printf("[config] Config in FLASH is valid\r\n");
  } else {
    printf("[config] Config in FLASH is not valid!\r\n");
    cfg = config_get_ram_struct();
    memset(cfg, 0, sizeof(_cnw_config));
    cfg->size = sizeof(_cnw_config);
    memset(&cfg->apcredentials, 0, ESP_AP_NAME_SIZE);
    cfg->wifidetected = 0;
    cfg->flags1 = 0;
    cfg->flags2 = 0;
    cfg->nodeid = 0;
    config_commit();
    return 1;
  }
  printf("[config] Done\r\n");
  return 0;
}
 
struct cnw_config *config_get_ram_struct() {
  return &config;
}
 
static int toflash() {
  int size = sizeof(_cnw_config);
  int res;
 
  if ((res = mculib_flash_unlock(MAIN_MCULIBHANDLE))) {
    printf("[config] Unlock flash failed: %i\r\n", res);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return res;
  }
  if ((res = mculib_flash_erase(MAIN_MCULIBHANDLE, destadr, size))) {
    printf("[config] Save config failed: %i\r\n", res);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return res;
  }
  int fw = mculib_flash_write(MAIN_MCULIBHANDLE, config_get_ram_struct(), destadr, size);
 
  mculib_flash_lock(MAIN_MCULIBHANDLE);
  printf("[config] Saved %i bytes to flash. Flash result: %i\r\n", size, fw);
  if (!config_check_crc((struct cnw_config *)destadr)) {
    printf("[configConfig in flash is STILL not valid!\r\n");
  }
  return 0;
}
int config_commit() {
  valid = 0;
  config_get_ram_struct()->crc = config_calc_crc(config_get_ram_struct());
  config_get_ram_struct()->size = sizeof(_cnw_config);
 
  // check if in_ram is identical to in_flash, if so, we do not need to write
  uint8_t *a;
  uint8_t *b;
 
  a = (uint8_t *)config_get_ram_struct();
  b = (uint8_t *)destadr;
  int i;
  uint8_t mustwrite = 0;
 
  for (i = 0; i < config_get_ram_struct()->size; i++) {
    if (a[i] != b[i]) {
      mustwrite = 1;
      break;
    }
  }
  if (mustwrite == 0) {
    printf("[config] no need to write\r\n");
    return 0;
  }
  printf("[config] Saving config to flash\r\n");
  return toflash();
}
 
// return >0 if ok
int config_is_ram_valid() {
  if (valid == 1) {
    return 1;
  } else if (valid == 2) {
    return 0;
  }
  if (config_check_crc(&config)) {
    //printf("[configConfig in ram is valid!\r\n");
    valid = 1;
    return 1;
  }
  //printf("[configConfig in ram is NOT valid!\r\n");
  valid = 2;
  return 0;
}
 
uint32_t config_calc_crc(struct cnw_config *cfg) {
  int crcsize = sizeof(config) - (((void *)&config.crc_start) - ((void *)&config));
  uint8_t *buf = (void *)&cfg->crc_start;
 
  //printf("crc size: %i\r\n", crcsize);
  int i;
  uint32_t crc = 0;
 
  for (i = 0; i < crcsize; i++) {
    crc = crc + buf[i];
  }
  crc = 0xFFFFFFFF - crc;
  return crc;
}
int config_check_crc(struct cnw_config *cfg) {
  uint32_t i = config_calc_crc(cfg);
 
  //printf("Config: crc value: %i, calculated: %i\r\n",cfg->crc,i);
  if ((cfg->crc & 0xFFFFFFFF) == i) {
    return 1;
  }
 
  return 0;
}
 
void config_set_wifidetected(int b) {
  valid = 0;
  if (b) {
    config.wifidetected &= ~2;
  } else {
    config.wifidetected |= 2;
  }
}
 
void config_set_wifidisable(int b) {
  valid = 0;
  if (b) {
    config_set_flag(CONFIG_FLAGS_WIFI_DISABLE, 1);
  } else {
    config_set_flag(CONFIG_FLAGS_WIFI_DISABLE, 0);
  }
}
int config_get_wifidisable() {
  return config_get_flag(CONFIG_FLAGS_WIFI_DISABLE);
}
 
void config_set_flashmode(byte b) {
  valid = 0;
  config.flashmode = b;
}
 
void config_set_ti1101disable(int b) {
  config_set_flag(CONFIG_FLAGS_RADIODISABLE, b ? 1 : 0);
}
int config_get_ti1101disable() {
  return config_get_flag(CONFIG_FLAGS_RADIODISABLE);
}
 
void config_erase() {
  valid = 0;
  if (config_is_ram_valid()) {
    config_get_ram_struct()->crc++; // force invalidate
  }
  int r = toflash();
 
  if (r != 0) {
    printf("[config] Config erase from flash failed (%i)!\r\n", r);
  }
}
 
int config_get_sensors_enabled() {
  return (config_get_flag(CONFIG_FLAGS_SENSORS_DISABLED) == 0) ? 1 : 0;
}
void config_set_sensors_enabled(int b) {
  config_set_flag(CONFIG_FLAGS_SENSORS_DISABLED, (b == 0) ? 1 : 0);
}
 
const char *config_get_cloud_token() {
  if (!config_is_ram_valid()) {
    return "";
  }
  return config.cloudtoken;
}
void config_set_cloud_token(const char *token) {
  valid = 0;
  int i;
 
  for (i = 0; i < strlen(token); i++) {
    config.cloudtoken[i] = token[i];
    if (i >= (sizeof(config.cloudtoken) - 1)) {
      config.cloudtoken[i] = 0;
      printf("[config] CLOUDTOKEN TOO LARGE!\r\n");
      return;
    }
  }
  config.cloudtoken[i] = 0;
}
 
const char *config_get_sensor_server() {
  if (!config_is_ram_valid()) {
    return "";
  }
  return config.sensorserver;
}
void config_set_sensor_server(const char *name) {
  valid = 0;
  int i;
 
  for (i = 0; i < strlen(name); i++) {
    config.sensorserver[i] = name[i];
    config.sensorserver[i + 1] = 0;
    if (i >= (sizeof(config.sensorserver) - 1)) {
      config.sensorserver[i] = 0;
      printf("[config] SENSORSERVERNAME TOO LARGE!\r\n");
      return;
    }
  }
}
const char *config_get_cloud_server() {
  if (!config_is_ram_valid()) {
    return NULL;
  }
  return config.cloudserver;
}
void config_set_cloud_server(const char *name) {
  valid = 0;
  int i;
 
  for (i = 0; i < strlen(name); i++) {
    config.cloudserver[i] = name[i];
    config.cloudserver[i + 1] = 0;
    if (i >= (sizeof(config.cloudserver) - 1)) {
      config.cloudserver[i] = 0;
      printf("[config] CLOUDSERVERNAME TOO LARGE!\r\n");
      return;
    }
  }
  config_commit();
}
 
long config_get_log_node() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.lognode;
}
void config_set_log_node(long nodeid) {
  valid = 0;
  config.lognode = nodeid;
}
byte config_get_flag(int flag) {
  if (!config_is_ram_valid()) {
    return 0;
  }
  int r = 0;
 
  if (flag > 7) {
    r = config.flags2 & (1 << (flag - 8));
  } else {
    r = config.flags1 & (1 << flag);
  }
  return r ? 1 : 0;
}
 
void config_set_flag(int flag, byte value) {
  int r;
 
  byte *f = &config.flags1;
  char const *s = "flags1";
 
  if (flag > 7) {
    s = "flags2";
    f = &config.flags2;
    flag = flag - 8;
  }
  byte z = *f;
 
  IPLOG("[config] Setting flag %i in %s to %i\r\n", flag, s, value);
  if (value == 0) {
    r = 0xFF & ~(1 << flag);
    *f = *f & r;
  } else {
    *f = *f | (1 << flag);
  }
  IPLOG("[config] New config flag: %x\r\n", *f);
  if (z != *f) {
    valid = 0;
  }
}
 
uint32_t config_get_flags() {
  uint32_t res = config.flags1;
 
  res = res | (((uint32_t)config.flags2) << 8);
  return res;
}
 
void config_flag_line(const char *line) {
  printf("[config] got flag line: %s\r\n", line);
  int i;
  int a = atoi(line);
  int b = 0;
 
  for (i = 0; i < strlen(line); i++) {
    if (line[i] == ' ') {
      b = atoi(&line[i + 1]);
    }
  }
  config_set_flag(a, b);
  config_commit();
}
void config_set_moduleid(uint64_t modid) {
  if (config.moduleid == modid) {
    return;
  }
  config.moduleid = modid;
  config_commit();
}
uint64_t config_get_moduleid() {
  if (!config_is_ram_valid()) {
    return 0;
  }
 
  return config.moduleid;
}
void config_set_userapp(uint32_t userapp_base) {
  if (config.userapp == userapp_base) {
    return;
  }
  config.userapp = userapp_base;
  config_commit();
}
struct userapp_info *config_get_userapp() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return (void *)config.userapp;
}
uint32_t get_user_config_flags() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.userflags;
}
int get_user_config_flag(int flag) {
  if ((flag < 0) || (flag > 31)) {
    return 0;
  }
  if (!config_is_ram_valid()) {
    return 0;
  }
  if (config.userflags & (1 << flag)) {
    return 1;
  }
  return 0;
}
void set_user_config_flag(int flag, int value) {
  if ((flag < 0) || (flag > 31)) {
    return;
  }
  if (value) {
    config.userflags |= (1 << flag);
  } else {
    config.userflags &= ~(1 << flag);
  }
  config_commit();
}
void set_user_config_flags(uint32_t flags) {
  config.userflags = flags;
  config_commit();
}
 
uint32_t config_get_clock_mul() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.clock_mul;
}
uint32_t config_get_clock_div() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.clock_div;
}
void config_set_clock_mul(uint32_t mul) {
  config.clock_mul = mul;
  config_commit();
}
void config_set_clock_div(uint32_t div) {
  config.clock_div = div;
  config_commit();
}
void config_set_timezone(uint32_t tz) {
  config.tz = tz;
  config_commit();
}
uint32_t config_get_timezone() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.tz;
}
void config_set_powermode_flags(uint32_t new_flags) {
  config.powermodeflags = new_flags;
  config_commit();
}
uint32_t config_get_powermode_flags() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.powermodeflags;
}
int config_get_powermode_flag(int b) {
  if (!config_is_ram_valid()) {
    return 0;
  }
  if (config.powermodeflags & (1 << b)) {
    return 1;
  }
  return 0;
}
uint16_t config_get_radiooff_duration() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.radiooff_duration;
}
void config_set_radiooff_duration(uint16_t dur) {
  config.radiooff_duration = dur;
}
uint16_t config_get_wifioff_duration() {
  if (!config_is_ram_valid()) {
    return 0;
  }
  return config.wifioff_duration;
}
void config_set_wifioff_duration(uint16_t wifioff) {
  config.wifioff_duration = wifioff;
}