powersave.c

Go to the documentation of this file.

#include "powersave.h"
#include "networkif.h"
#include "main-header.h"
#include "streams.h"
#include "powerup.h"
#include <platform-header.h>
#include "led.h"
 
// powersave variables for mainloop condition evaluation
#define SECS_AFTER_BOOT_BEFORE_POWERSAFE 120
#define SECS_AFTER_WAKE_BEFORE_POWERSAFE 10
 
// wait some time after the last command was sent or the last stream was closed before sleeping
#define SECS_AFTER_LASTCOM_BEFORE_POWERSAFE 3
 
// #define MAX_SECS_BEFORE_SCHEDULED_WAKEUP 300
static long throttle_after_fast = 0; // if something makes the cpu go fast, do not throttle immediately, wait a few secs
static long powersave_afterwake = 0;
static long powersave_aftercom = 0;
static byte powermode = 0;
static byte booted = 0;
//static int powermodectr = 15;// only go into powersave mode if this counter hits 0
static void power_mcusleep();
static void trigger_send_powering_down();
// store a previous power_state
typedef struct power_state {
  byte  wifi_on;
  byte  ti1101_on;
  byte  lora_on;
} _power_state;
 
struct power_state prev_state;
 
int power_set_connectivity(struct power_state *ps, int turnon) {
  if (turnon) {
    printf("[power] Turning connectivity on...\r\n");
    if (ps->wifi_on) {
      esp8266_enable();
    }
    // TODO - make this an interator
    if (ps->ti1101_on) {
      start_nic_by_type(SOURCE_RADIO);
    }
    if (ps->lora_on) {
      start_nic_by_type(SOURCE_LORA);
    }
    remove_stale_routes();
    send_routing_update_now();
  } else {
    trigger_send_powering_down();
    printf("[power] Turning connectivity off...\r\n");
    ps->wifi_on = esp8266_is_enabled();
    esp8266_disable();
    ps->ti1101_on = stop_nic_by_type(SOURCE_RADIO);
    ps->lora_on = stop_nic_by_type(SOURCE_LORA);
  }
  return 0;
}
/*
 * \brief set power level (state is a combination of flags of what ought to be enabled)
 * returns 0 if ok, otherwise error
 */
int set_mcu_power_mode(int state) {
  //  struct power_state *ps = &prev_state;
  struct cnw_config *cfg = config_get_ram_struct();
 
  //power_set_connectivity(ps, state & (1 << POWER_CONNECTIVITY));
  if (state == 0) {
    led_set_machine_managed();
    led_indicate(LED_POWERSAVE);
  } else {
    led_set_user_managed();
  }
  if (state == 0) {
    printf("[power] Going to low power mode for %i secs...\r\n\r\n", cfg->sleep_duration);      // extra CR because last byte might get eaten by sleep
    mculib_sleep(0, cfg->sleep_duration);                                                       //seconds to sleep, returns after this number of seconds
    state = 0xFF;                                                                               //wakeup
    // it does not print after startup oddly
    /*
     * int i;
     * for (i=0;i<100;i++) {
     * printf("[power] %i Woke up from low power mode...\r\n",i);
     * }
     */
    //power_set_connectivity(ps, state & (1 << POWER_CONNECTIVITY));
  }
  return 0;
}
 
/*
 * \brief set power level to the most appropriate
 */
void calc_power_mode() {
}
 
// called in main loop. might block for a long time (when it determines it is time to sleep)
void power_main_loop() {
  // if disabled, do not do anything
  if (!config_get_flag(CONFIG_FLAGS_POWER_SAVE)) {
    return;
  }
  // if powerup has not been delivered, do not do anything
  if (!powerup_delivered()) {
    return;
  }
 
  // on first boot, we wait with going to sleep
  if (!booted) {
    if (mculib_has_time_passed(SECS_AFTER_BOOT_BEFORE_POWERSAFE, &powersave_afterwake) == 0) {
      return;
    }
    booted = 1;
  }
  struct cnw_config *cfg = config_get_ram_struct();
 
  if (cfg == NULL) {
    // no config? do not powersave. this is highly odd
    return;
  }
  if (config_get_powermode_flag(CONFIG_POWERFLAG_THROTTLE)) {
    if (mculib_has_time_passed(10, &throttle_after_fast)) {
      power_set_speed(1);
    }
  }
  // deal with mcu sleep
  power_mcusleep();
  return;
}
// this might put the mcu to sleep, so it might not return until mcu wakes up some seconds later
void power_mcusleep() {
  struct cnw_config *cfg = config_get_ram_struct();
 
  if ((cfg->sleep_duration == 0) || (cfg->nonsleep_duration == 0)) {
    // if sleep/nonsleep is 0, do not sleep, that's a misconfiguration of sort
    return;
  }
 
  // powermode starts as '0'.
  // powermode == 1 means that the module is trying to get to sleep (e.g. after last com was sent)
  // powermode == 0 means that the module has just woken up and won't go to sleep for a certain duration
 
  if (powermode == 0) {
    if (mculib_has_time_passed(cfg->nonsleep_duration, &powersave_afterwake) == 0) {
      // still staying awake until time has passed.
      return;
    }
    mculib_has_time_passed(0, &powersave_aftercom); // reset timer
    // mark that it is time to go to sleep
    powermode = 1;
    return;
  }
 
 
  if (powermode == 1) {
    if ((get_outbound_command_count_important() != 0) || (count_open_streams() != 0)) {
      // don't go to sleep, we still got outbound commands or open streams
      mculib_has_time_passed(0, &powersave_aftercom); // reset timer
      return;
    }
    if (mculib_has_time_passed(SECS_AFTER_LASTCOM_BEFORE_POWERSAFE, &powersave_aftercom) == 0) {
      // too soon after command or openstream, don't sleep just yet
      return;
    }
  }
 
  //  printf("[power] Powerdue counter: %i, secs_since_boot: %i\r\n",(int)powersave_due,(int)mculib_get_seconds_since_boot());
  powermode = 0;
  set_mcu_power_mode(0); // got to sleep
  // we do this with the assumption that it will return true, because we slept for >1 second
  // the (important) side-effect is that it will set the powersave_due counter, so that
  // next time we check if we got to go to powersave mode we won't immediately activate it
  mculib_has_time_passed(0, &powersave_aftercom);       // reset timer
  mculib_has_time_passed(0, &powersave_afterwake);      // reset timer
  //printf("[power] Powerdue counter: %i, secs_since_boot: %i\r\n",(int)powersave_due,(int)mculib_get_seconds_since_boot());
}
 
static void trigger_send_powering_down() {
  int r = 0;
  int z;
  struct command *com;
 
  // send to server
  com = alloc_command();
  if (com != NULL) {
    com->com = 60; //powerinfo
    com->target = CLOUD_SERVER;
    command_add_arg(com, "powerstate=low");
    for (z = 0; z < 10; z++) {
      r = send_command(com);
      if (r == 0) {
        break;
      }
    }
    free_command(com);
  }
  printf("[power] Result of sending powerinfo to server: %i\r\n", r);
 
  // send to broadcast
  com = alloc_command();
  if (com != NULL) {
    com->com = 60; //powerinfo
    com->target = BROADCAST;
    command_add_arg(com, "powerstate=low");
    for (z = 0; z < 10; z++) {
      r = send_command(com);
      if (r == 0) {
        break;
      }
    }
    free_command(com);
  }
  printf("[power] Result of sending powerinfo broadcast: %i\r\n", r);
}
 
void power_set_speed(int speed) {
  if (speed != 1) {
    mculib_has_time_passed(0, &throttle_after_fast); // reset timer
  }
  /*
   * printf("[power] not changing speed, because usart dies if we do, and so does usb\r\n");
   * return;
   */
  if (!config_get_flag(CONFIG_FLAGS_POWER_SAVE)) {
    return;
  }
 
  if (mculib_get_speed() == speed) {
    return;
  }
  printf("[power] setting mculib speed to %i\r\n", speed);
  mculib_set_speed(speed);
  /*
   * mculib_serialport_enable(MAIN_MCULIBHANDLE, USART_CONSOLE, 115200);
   * mculib_serialport_enable(MAIN_MCULIBHANDLE, USART_ESP8266, esp8266_get_operational_baudrate());
   */
}
 
 
typedef struct powersavething {
} _powersavething;
 
void init_powersavething(struct powersavething *pst) {
}
 
// mark this thing as "in use" right now
void mark_last_in_use(struct powersavething *pst) {
}