static void
print_stuff() {
printf("tmr now = %ss\n", time_now_f());
printf("SDK version: %s\n", system_get_sdk_version());
printf("APP version: %s built: %s %s\n", BUILD_DATE, __DATE__, __TIME__);
printf("CPU freq was %d\n", system_get_cpu_freq());
printf("CPU freq = %d\n", set_cpu_freq(160));
printf("tmr now = %ss\n", time_now_f());
printf("tout = %sV\n", ffp(3, read_tout(0)*123/10));
printf("vdd = %sV\n", ffp(3, read_vdd()));
print_mac(STATION_IF);
print_mac(SOFTAP_IF);
print_ip_info(SOFTAP_IF);
print_ip_info(STATION_IF);
printf("tmr now = %ss\n", time_now_f());
printf("sleeping 2s\n");
system_deep_sleep(2*1000000);
vTaskDelete(NULL);
}
// Lua: dsleep( us, option )
static int node_deepsleep( lua_State* L )
{
s32 us, option;
//us = luaL_checkinteger( L, 1 );
// Set deleep option, skip if nil
if ( lua_isnumber(L, 2) )
{
option = lua_tointeger(L, 2);
if ( option < 0 || option > 4)
return luaL_error( L, "wrong arg range" );
else
deep_sleep_set_option( option );
}
// Set deleep time, skip if nil
if ( lua_isnumber(L, 1) )
{
us = lua_tointeger(L, 1);
// if ( us <= 0 )
if ( us < 0 )
return luaL_error( L, "wrong arg range" );
else
system_deep_sleep( us );
}
return 0;
}
static void
blink_led(void)
{
int i;
uint16 pins;
pin_config(12, GPIO_DIR_OUT);
pin_config(13, GPIO_DIR_OUT);
pin_config(15, GPIO_DIR_OUT);
pins = BIT12|BIT13|BIT15;
for (i = 1; i < 8; ++i) { // 7 colours
uint16 mask = ((i&4)<<(12-2)) | ((i&2)<<(13-1)) | ((i&1)<<(15-0));
printf(" %d", i);
gpio_output_set(mask, (~mask)&pins, 0, 0);
delay_us(250000);
gpio_output_set(0, mask, 0, 0); // all off
delay_us(250000);
}
printf("\n");
printf("tmr now = %ss\n", time_now_f());
printf("sleeping 2s\n");
system_deep_sleep(2*1000000);
vTaskDelete(NULL);
}
static int do_deepsleep(int argc, const char* argv[])
{
char *tmp = argv[1];
unsigned long n = skip_atoul(&tmp);
console_printf("Deep sleep mode for %ul microseconds\n", n);
system_deep_sleep(n);
}
static enum v7_err dsleep(struct v7 *v7, v7_val_t *res) {
enum v7_err rcode = V7_OK;
v7_val_t time_v = v7_arg(v7, 0);
double time = v7_to_number(time_v);
v7_val_t flags_v = v7_arg(v7, 1);
uint8 flags = v7_to_number(flags_v);
if (!v7_is_number(time_v) || time < 0) {
*res = v7_mk_boolean(false);
goto clean;
}
if (v7_is_number(flags_v)) {
if (!system_deep_sleep_set_option(flags)) {
*res = v7_mk_boolean(false);
goto clean;
}
}
system_deep_sleep((uint32_t) time);
*res = v7_mk_boolean(true);
goto clean;
clean:
return rcode;
}
STATIC mp_obj_t machine_deepsleep(void) {
// default to sleep forever
uint32_t sleep_us = 0;
// see if RTC.ALARM0 should wake the device
if (pyb_rtc_alarm0_wake & MACHINE_WAKE_DEEPSLEEP) {
uint64_t t = pyb_rtc_get_us_since_2000();
if (pyb_rtc_alarm0_expiry <= t) {
sleep_us = 1; // alarm already expired so wake immediately
} else {
uint64_t delta = pyb_rtc_alarm0_expiry - t;
if (delta <= 0xffffffff) {
// sleep for the desired time
sleep_us = delta;
} else {
// overflow, just set to maximum sleep time
sleep_us = 0xffffffff;
}
}
}
// prepare for RTC reset at wake up
rtc_prepare_deepsleep(sleep_us);
// put the device in a deep-sleep state
system_deep_sleep_set_option(0); // default power down mode; TODO check this
system_deep_sleep(sleep_us);
for (;;) {
// we must not return
ets_loop_iter();
}
return mp_const_none;
}
void ICACHE_FLASH_ATTR
user_sensor_deep_sleep_enter(void)
{
return;
system_deep_sleep(SENSOR_DEEP_SLEEP_TIME > link_start_time \
? SENSOR_DEEP_SLEEP_TIME - link_start_time : 30000000);
}
STATIC mp_obj_t esp_deepsleep(mp_uint_t n_args, const mp_obj_t *args) {
uint32_t sleep_us = n_args > 0 ? mp_obj_get_int(args[0]) : 0;
// prepare for RTC reset at wake up
rtc_prepare_deepsleep(sleep_us);
system_deep_sleep_set_option(n_args > 1 ? mp_obj_get_int(args[1]) : 0);
system_deep_sleep(sleep_us);
return mp_const_none;
}
void ICACHE_FLASH_ATTR data_func() {
// Read out the sensor data structure from RTC memory
system_rtc_mem_read( SENSOR_DATA_MEM_ADDR, &sensor_data, sizeof(SENSOR_DATA_RTC_MEM) );
// When the system powers on for the first time, the data in the rtc memory is random.
struct esp_platform_saved_param esp_param_t;
user_esp_platform_load_param(&esp_param_t); // Stored in flash
// Load user params to check if the device was successfully registered to the server
// If it wasn't, it usually returns 255 (from the flash.)
if(sensor_data.init_flg!=INIT_MAGIC || sensor_data.cnt>SENSOR_DATA_NUM ) {
// This case runs when we first power on or when it time to flush the RTC memory of old data.
if(esp_param_t.activeflag!=1) { // If registered & activated
user_esp_platform_init(); // Router is not configured. Setup softAP. Wait for config.
#ifdef SERVER_SSL_ENABLE
user_webserver_init(SERVER_SSL_PORT);
#else
user_webserver_init(SERVER_PORT);
#endif
} else { // was connected! So we set init magic to exit the setup loop
sensor_data.init_flg = INIT_MAGIC;
sensor_data.cnt = 0;
system_rtc_mem_write(SENSOR_DATA_MEM_ADDR, &sensor_data, sizeof(SENSOR_DATA_RTC_MEM));
__SET__DEEP_SLEEP__WAKEUP_NO_RF__;
system_deep_sleep(100000);
}
} else { // This is where the measurements are made
uint16 vdd_val = 0;
if(sensor_data.cnt<0 || sensor_data.cnt>=SENSOR_DATA_NUM)
sensor_data.cnt=0; // range check and resets counter if needed
/* Reads power supply voltage, byte 107 of init_data.bin should be set to 0xFF.
* Replace with your own code.*/
sensor_data.data[sensor_data.cnt++] = (uint16)(phy_get_vdd33());
system_rtc_mem_write( SENSOR_DATA_MEM_ADDR, &sensor_data, sizeof(SENSOR_DATA_RTC_MEM) );
// Setup next sleep cycle
if(sensor_data.cnt==SENSOR_DATA_NUM-1) { __SET__DEEP_SLEEP__WAKEUP_NORMAL__; }
else { __SET__DEEP_SLEEP__WAKEUP_NO_RF__; }
// Uploads or go to sleep
if(sensor_data.cnt == SENSOR_DATA_NUM) { user_esp_platform_init(); }
else { system_deep_sleep(SENSOR_DEEP_SLEEP_TIME); }
}
}
void ICACHE_FLASH_ATTR
at_setupCmdGslp(uint8_t id, char *pPara)
{
uint32_t n;
pPara++;
n = atoi(pPara);
at_backOk;
system_deep_sleep(n*1000);
}
//callback when data is recieved
void ICACHE_FLASH_ATTR recieveCB(void *arg,char *pData,unsigned short len)
{
struct espconn *pNewEspConn = (struct espconn *)arg;
os_printf("Response from Plotly received. Data length = %d\n\r", len);
os_printf("Plotly IP address was: %d. %d. %d. %d \n\r", IP2STR(&(pNewEspConn->proto.tcp->remote_ip)));
int i=0;
for (i=0; i<len; i++) // Read data by each character and print it on the debug screen
{
os_printf("%c", pData[i]);
}
os_printf("\n");
system_deep_sleep(sleep_time_min*60*1000*1000); // go to sleep after recieving data and wake up periodically
}
static v7_val_t dsleep(struct v7 *v7) {
v7_val_t time_v = v7_arg(v7, 0);
uint32 time = v7_to_number(time_v);
v7_val_t flags_v = v7_arg(v7, 1);
uint8 flags = v7_to_number(flags_v);
if (!v7_is_number(time_v) || time < 0) return v7_create_boolean(false);
if (v7_is_number(flags_v)) {
if (!system_deep_sleep_set_option(flags)) return v7_create_boolean(false);
}
system_deep_sleep(time);
return v7_create_boolean(true);
}
void init() {
Serial.begin(SERIAL_BAUD_RATE); // 115200 by default
Serial.systemDebugOutput(false); // Enable debug output to serial
WifiStation.enable(false);
WifiAccessPoint.enable(false);
initDisplay();
ReadTemp.Init(DS_PIN);
ReadTemp.StartMeasure();
displayTemps();
system_deep_sleep(30 * 1000 * 1000);
}
void wifi_callback( System_Event_t *evt )
{
os_printf( "%s: %d\n", __FUNCTION__, evt->event );
char toto[7] = "hello\n\0";
//uart0_tx_buffer(toto, 7);
switch ( evt->event )
{
case EVENT_STAMODE_CONNECTED:
{
char toto[7] = "hello\n\0";
//uart0_tx_buffer(toto, 7);
os_printf("connect to ssid %s, channel %d\n",
evt->event_info.connected.ssid,
evt->event_info.connected.channel);
break;
}
case EVENT_STAMODE_DISCONNECTED:
{
os_printf("disconnect from ssid %s, reason %d\n",
evt->event_info.disconnected.ssid,
evt->event_info.disconnected.reason);
deep_sleep_set_option( 0 );
system_deep_sleep( 60 * 1000 * 1000 ); // 60 seconds
break;
}
case EVENT_STAMODE_GOT_IP:
{
os_printf("ip:" IPSTR ",mask:" IPSTR ",gw:" IPSTR,
IP2STR(&evt->event_info.got_ip.ip),
IP2STR(&evt->event_info.got_ip.mask),
IP2STR(&evt->event_info.got_ip.gw));
os_printf("\n");
break;
}
default:
{
break;
}
}
}
/** for data xchange channel */
bool __plugin_pm_sleep(void *class_ptr, char *method_name, void *input_pack)
{
uint8_t *arg_ptr = (uint8_t *)input_pack;
uint32_t sec;
memcpy(&sec, arg_ptr, sizeof(uint32_t)); arg_ptr += sizeof(uint32_t);
Serial1.printf("deep sleep %lu sec\r\n", sec);
writer_print(TYPE_STRING, "\"ok, deep sleep\"");
response_msg_close(STREAM_DATA);
delay(100);
//turn off grove's power
digitalWrite(SWITCH_GROVE_POWER, 0);
system_deep_sleep(sec * 1000000);
return true;
}
bool SystemClass::deepSleep(uint32 timeMilliseconds, DeepSleepOptions options /* = eDSO_RF_CAL_BY_INIT_DATA */)
{
if (!system_deep_sleep_set_option((uint8)options)) return false;
system_deep_sleep(timeMilliseconds * 1000);
return true;
}
static void ICACHE_FLASH_ATTR
timer_fn(void *timer_data)
{
uint32_t delay = MAX_LOOP_TIMER_MS;
os_timer_disarm(&timer);
PRINTF("state: %d\n\r", state);
switch(state) {
case STATE_LOAD_PERSIST:
if(persist_load()) {
PRINTF("persist data sensor value: %d\r\n", persist_data_ptr()->sensor_value);
PRINTF("persist data sensor poll count: %d\r\n", persist_data_ptr()->poll_counter);
state = STATE_HF_READ;
persist_data_ptr()->poll_counter += 1;
if(persist_data_ptr()->poll_counter >= 10) {
// read low-frequency sensor (temp etc)
persist_data_ptr()->poll_counter = 0;
}
persist_dirty();
} else {
PRINTF("err loading persist\r\n");
// todo: goto error state (blink led?)
state = STATE_IDLE;
}
delay = MIN_LOOP_TIMER_MS;
break;
case STATE_INIT_PERSIST:
persist_init();
state = STATE_HF_READ;
delay = MIN_LOOP_TIMER_MS;
break;
case STATE_HF_READ:
state = STATE_LF_READ;
if(GPIO_INPUT_GET(GPIO_SWITCH)) {
if(!(persist_data_ptr()->sensor_value)) {
persist_data_ptr()->sensor_value = true;
persist_dirty();
state = STATE_HF_WIFI_CONNECT;
}
} else {
if(persist_data_ptr()->sensor_value) {
persist_data_ptr()->sensor_value = false;
persist_dirty();
state = STATE_HF_WIFI_CONNECT;
}
}
break;
case STATE_HF_WIFI_CONNECT:
if(wifi_station_get_connect_status()==STATION_GOT_IP) {
state = STATE_HF_SEND;
} else {
wifi_connect();
state = STATE_HF_WIFI_WAIT;
}
break;
case STATE_HF_WIFI_WAIT:
if(wifi_station_get_connect_status()==STATION_GOT_IP) {
state = STATE_HF_SEND;
}
break;
case STATE_HF_SEND:
state = STATE_HF_SEND_WAIT;
break;
case STATE_HF_SEND_WAIT:
state = STATE_LF_READ;
break;
case STATE_LF_READ:
state = STATE_LF_WIFI_CONNECT;
break;
case STATE_LF_WIFI_CONNECT:
if(wifi_station_get_connect_status()==STATION_GOT_IP) {
state = STATE_LF_SEND;
} else {
wifi_connect();
state = STATE_LF_WIFI_WAIT;
}
break;
case STATE_LF_WIFI_WAIT:
if(wifi_station_get_connect_status()==STATION_GOT_IP) {
state = STATE_LF_SEND;
}
break;
case STATE_LF_SEND:
state = STATE_LF_SEND_WAIT;
break;
case STATE_LF_SEND_WAIT:
state = STATE_IDLE;
break;
case STATE_IDLE:
// go to deep sleep
persist_save();
system_deep_sleep(SLEEP_TIME_US);
return;
break;
default:
// uhoh
PRINTF("invalid state, reset\n\r");
state = STATE_IDLE;
break;
}
os_timer_setfn(&timer, (os_timer_func_t *)timer_fn, NULL);
os_timer_arm(&timer, delay, false);
/*
case STATE_IDLE:
http_get("http://10.1.3.161/text", "", my_http_callback);
state = STATE_HTTP_PENDING;
timeout = 30;
break;
case STATE_HTTP_PENDING:
timeout--;
if(timeout==0) {
PRINTF("timeout!\n\r");
state=STATE_IDLE;
} else {
delay_ms(1000);
}
break;
default:
PRINTF("invalid state, reset\n\r");
state=STATE_IDLE;
break;
}
//system_os_post(user_procTaskPrio, 0, 0 ); */
}
void serialCallBack(Stream& stream, char arrivedChar, unsigned short availableCharsCount) {
if (arrivedChar == '\n') {
char str[availableCharsCount];
for (int i = 0; i < availableCharsCount; i++) {
str[i] = stream.read();
if (str[i] == '\r' || str[i] == '\n') {
str[i] = '\0';
}
}
if (!strcmp(str, "connect")) {
// connect to wifi
WifiStation.config(WIFI_SSID, WIFI_PWD);
WifiStation.enable(true);
} else if (!strcmp(str, "ip")) {
Serial.printf("ip: %s mac: %s\r\n", WifiStation.getIP().toString().c_str(), WifiStation.getMAC().c_str());
} else if (!strcmp(str, "ota")) {
OtaUpdate();
} else if (!strcmp(str, "switch")) {
Switch();
} else if (!strcmp(str, "restart")) {
System.restart();
} else if (!strcmp(str, "ls")) {
Vector<String> files = fileList();
Serial.printf("filecount %d\r\n", files.count());
for (unsigned int i = 0; i < files.count(); i++) {
Serial.println(files[i]);
}
} else if (!strcmp(str, "cat")) {
Vector<String> files = fileList();
if (files.count() > 0) {
Serial.printf("dumping file %s:\r\n", files[0].c_str());
Serial.println(fileGetContent(files[0]));
} else {
Serial.println("Empty spiffs!");
}
} else if (!strcmp(str, "info")) {
ShowInfo();
} else if (!strcmp(str, "help")) {
Serial.println();
Serial.println("available commands:");
Serial.println(" help - display this message");
Serial.println(" ip - show current ip address");
Serial.println(" connect - connect to wifi");
Serial.println(" restart - restart the esp8266");
Serial.println(" switch - switch to the other rom and reboot");
Serial.println(" ota - perform ota update, switch rom and reboot");
Serial.println(" info - show esp8266 info");
Serial.println(" sl - Sleep for 5 seconds");
#ifndef DISABLE_SPIFFS
Serial.println(" ls - list files in spiffs");
Serial.println(" cat - show first file in spiffs");
#endif
Serial.println();
} else if (!strcmp(str, "sl")) {
Serial.println("Going to sleep");
delay(500);
system_deep_sleep(5000000);
delay(500);
Serial.println("Wakeing up");
} else {
Serial.println("unknown command");
}
}
}
/******************************************************************************
* FunctionName : gm_state_run
* Description :
* Parameters : none
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
gm_state_run(greemon_state_t gm_run_state){
switch (gm_run_state) {
// --------------------------------------------------------------------------
case (_STATE_STARTUP):
/* Initialize UART,
* Register Callback for lwip
* set wifi handler
* do not connect to wifi at this point
*/
gm_error_counter = 0;
if ( !gm_startup() ) gm_state_set(_STATE_ERROR);
INFO("Waiting for init callback");
break;
// --------------------------------------------------------------------------
case (_STATE_INIT):
/* Fired after LWIP callback,
* Register interrupt for reset
* Load Configuration
*/
INFO("System initialized. Greemon startup...");
if ( !gm_init() ) gm_state_set(_STATE_ERROR);
break;
// --------------------------------------------------------------------------
case (_STATE_RESET):
break;
// --------------------------------------------------------------------------
case (_STATE_ERROR):
/*
* this state only happens if there was an error
*/
INFO("Wooooooops... there was an ERROR.");
INFO("restart is the only exit")
break;
// --------------------------------------------------------------------------
case (_STATE_INITIALIZED):
/* System is initialized,
* we can load the config before we startup our greemon system
*/
if ( !gm_load_config() ) gm_state_set(_STATE_ERROR);
break;
// --------------------------------------------------------------------------
case (_STATE_CONFIG_USER):
/* magic word has been found in the flash data,
* we start with the user configuration
* but first read sensor data
*/
INFO("user config has been loaded");
if ( !gm_read_sensors() ) gm_state_set(_STATE_ERROR);
gm_state_set(_STATE_SENSOR_DATA_SAVED);
break;
// --------------------------------------------------------------------------
case (_STATE_CONFIG_DEFAULT):
/* magic word has not been found in the flash data,
* we start with the default configuration
*/
INFO("loaded standard configuration");
INFO("webserver starting");
if ( !gm_webserver_start() ) gm_state_set(_STATE_ERROR);
gm_state_set(_STATE_WEBSERVER_RUNNING);
break;
// --------------------------------------------------------------------------
case (_STATE_CONFIG_RECIEVED):
INFO("config recieved - please restart the controller");
break;
// --------------------------------------------------------------------------
case (_STATE_WEBSERVER_PARSING):
break;
// --------------------------------------------------------------------------
case (_STATE_WEBSERVER_RUNNING):
/* Webserver is running as long as
* we did not recieve a new configuration
*/
INFO("webserver running");
INFO("waiting for HTTP requests");
// TEST FOR BH1750
//TODO: DELETEME
// i2ctest();
break;
// --------------------------------------------------------------------------
case (_STATE_SAVED_CONFIGURATION):
INFO("configuration has been saved");
wifi_station_disconnect();
gm_webserver_stop();
INFO("restarting");
system_restart();
while(1) os_delay_us(100);
break;
// --------------------------------------------------------------------------
case (_STATE_TIME_RECIEVED):
INFO("start connecting with server");
if ( !gm_server_connect() ) gm_state_set(_STATE_DEEP_SLEEP);
break;
// --------------------------------------------------------------------------
case (_STATE_SENSOR_DATA_SAVED):
INFO("Sensor data saved");
if ( !gm_connect_ap() ) gm_state_set(_STATE_ERROR);
INFO("connecting.. waiting for wifi-handler");
break;
// --------------------------------------------------------------------------
case (_STATE_WIFI_CONNECTED):
/* Connected to AP and recieved an IP Adress
* Starting SNTP Client
*/
if ( !gm_sntp_start() ) gm_state_set(_STATE_ERROR);
user_sntp_wait_valid_time();
INFO("recieved time from server");
// NEXT STATE ->_STATE_TIME_RECIEVED
gm_state_set(_STATE_TIME_RECIEVED);
break;
// --------------------------------------------------------------------------
case (_STATE_CONNECTION_CLOSED):
break;
// --------------------------------------------------------------------------
case (_STATE_CONNECTION_OPEN):
INFO("sending data..");
if ( !gm_server_send_data() ) gm_state_set(_STATE_ERROR);
break;
// --------------------------------------------------------------------------
case (_STATE_CONNECTION_TRANSMITTED):
INFO("transmitted data successfully")
// A dataset has been transmitted.
// Remove from the flash happend automatically when we popped the data
// Start 16 secs timer because ts only acceps data every 15 secs
if ( 0 == global_cfg.storedData ) {
INFO("all data has been sent");
gm_state_set(_STATE_DEEP_SLEEP);
} else {
INFO("still data(%d) remaining, starting timer", global_cfg.storedData);
os_timer_setfn(&timer_server_wait,timer_server_wait_cb,NULL);
os_timer_arm(&timer_server_wait,GM_SERVER_TRANSMIT_INTERVAL,1);
}
break;
// --------------------------------------------------------------------------
case (_STATE_DEEP_SLEEP):
INFO("Finished work. Deep sleep, yay.");
system_deep_sleep(60*1000*1000); // uint32_t time in us
break;
// --------------------------------------------------------------------------
}
}
void EspClass::deepSleep(uint32_t time_us, WakeMode mode)
{
system_deep_sleep_set_option(static_cast<int>(mode));
system_deep_sleep(time_us);
}
static void ICACHE_FLASH_ATTR deepSleepCb(void *arg) {
system_deep_sleep_set_option(2);
system_deep_sleep(100*1000);
}