//set wifi ON or OFF
int
mon_wifi(int argc, char **argv){
if(argc!=2){
printf("specify [on] or [off]\n");
return -1;
}
if(strcmp(argv[1],"on")==0){
b_wifi_enabled = true;
if(wifi_init()!=0){
b_wifi_enabled=false;
printf("error starting wifi\n");
}
else{
//good to go! turn light green
rgb_led_set(LED_LT_GREEN,0);
printf("wifi on\n");
}
return 0;
}
else if(strcmp(argv[1],"off")==0){
b_wifi_enabled = false;
printf("wifi off\n");
rgb_led_set(LED_BLUE,0);
return 0;
}
printf("specify [on] or [off]\n");
return -1;
}
void rgb_led_debug_step(uint8_t index) {
uint8_t color = debug_colors[index % (sizeof(debug_colors)/sizeof(debug_colors[0]))];
uint8_t red = (color & RED) ? 255 : 0;
uint8_t green = (color & GREEN) ? 255 : 0;
uint8_t blue = (color & BLUE) ? 255 : 0;
rgb_led_set(red,green,blue);
}
////////////////////
// Core USB commands
//
void
core_usb_enable(uint8_t port, bool b_enable){
cmd_buf_idx=0;
memset(cmd_buf,0x0,CMD_BUF_SIZE);
if(b_enable){
wemo_config.echo = true;
b_usb_enabled = true;
delay_ms(500);
printf("SmartEE Plug v1.0\n");
printf(" [help] for more information\n");
printf("> ");
rgb_led_set(LED_BLUE,0);
}
else {
b_usb_enabled = false;
rgb_led_set(LED_LT_GREEN,0);
}
}
int
mon_restart(int argc, char **argv){
if(argc==2){
//check for [bootloader] flag
if(strcmp(argv[1],"bootloader")==0){
//set the gpnvm bit to atmel bootloader
efc_perform_command(EFC0, EFC_FCMD_CGPB, 1);
rgb_led_set(LED_OFF,0);
delay_ms(500);
rgb_led_set(LED_GRAY,0); //indicate bootloader mode set
}
else{
printf("[bootloader] to reboot with Atmel bootloader\n");
return -1;
}
}
//detach USB
// udc_detach();
//software reset
rstc_start_software_reset(RSTC);
return 0;
}
//set the RGB LED color and blink rate
int
mon_led(int argc, char **argv){
uint32_t blink;
uint8_t r,g,b;
if(argc!=5){
printf("usage: [red,green,blue,blink (ms)]\n");
return 1;
}
r = atoi(argv[1]);
g = atoi(argv[2]);
b = atoi(argv[3]);
blink = atoi(argv[4]);
if(blink !=0 && (blink<LED_MIN_BLINK_RATE || blink>LED_MAX_BLINK_RATE)){
printf("error, invalid blink rate please use [%d,%d]\n",
LED_MIN_BLINK_RATE,LED_MAX_BLINK_RATE);
blink = 0;
}
rgb_led_set(r,g,b,blink);
return 0;
}
void monitor(void){
uint32_t prev_tick=0;
//allocate memory for buffers and flush them
cmd_buf = membag_alloc(CMD_BUF_SIZE);
if(!cmd_buf)
core_panic();
memset(cmd_buf,0x0,CMD_BUF_SIZE);
//initialize the power packet buffers
tx_pkt = &power_pkts[0];
cur_pkt = &power_pkts[1];
//both are empty
tx_pkt->status = POWER_PKT_EMPTY;
cur_pkt->status = POWER_PKT_EMPTY;
//initialize runtime configs
wemo_config.echo = false;
wemo_config.debug_level = DEBUG_ERROR;
wemo_config.collect_data = true; //collect power data
//check if we are on USB
if(gpio_pin_is_high(VBUS_PIN)){
rgb_led_set(LED_LT_BLUE,0);
//don't start wifi because we are configuring
b_wifi_enabled=false;
//don't collect power data
wemo_config.collect_data = false;
}
//check if the plug is in calibrate mode
if(wemo_config.calibrate){
//start the calibration PWM
pwm_channel_enable_interrupt(PWM,CAL_PWM_CHANNEL,CAL_PWM_CHANNEL);
pwm_channel_enable(PWM,CAL_PWM_CHANNEL);
//don't start wifi because we are in calibration mode
b_wifi_enabled=false;
wemo_config.standalone = true;
wemo_config.collect_data = false;
//indicate cal mode with a purple LED
rgb_led_set(LED_PURPLE,0);
}
//check if reset is pressed
if(gpio_pin_is_low(BUTTON_PIN)){
//erase the configs
memset(wemo_config.nilm_id,0x0,MAX_CONFIG_LEN);
memset(wemo_config.nilm_ip_addr,0x0,MAX_CONFIG_LEN);
memset(wemo_config.wifi_ssid,0x0,MAX_CONFIG_LEN);
memset(wemo_config.wifi_pwd,0x0,MAX_CONFIG_LEN);
//save the erased config
fs_write_config();
core_log("erased config");
//erase the stored data
//spin until button is released
rgb_led_set(LED_ORANGE,500);
while(gpio_pin_is_low(BUTTON_PIN));
rgb_led_set(LED_ORANGE,0); //disable blink
}
//setup WIFI
if(b_wifi_enabled){
if(wifi_init()!=0){
rgb_led_set(LED_PURPLE,0);
}
else{
//good to go! turn light green
rgb_led_set(LED_LT_GREEN,0);
}
}
//initialize the wifi_rx buffer and flag
wifi_rx_buf_full = false;
memset(wifi_rx_buf,0x0,WIFI_RX_BUF_SIZE);
while (1) {
//***** SYS TICK ACTIONS ******
if(sys_tick!=prev_tick){
//check if there is a valid wemo sample
if(wemo_sample.valid==true && wemo_config.collect_data){
core_log_power_data(&wemo_sample);
}
wemo_read_power();
wdt_restart(WDT);
prev_tick = sys_tick;
}
//check for pending data from the Internet
if(wifi_rx_buf_full){
core_process_wifi_data();
wifi_rx_buf_full=false;
}
//see if we have any commands to run
if(cmd_buf_full){
runcmd(cmd_buf); // run it
//clear the buffer
cmd_buf_idx = 0;
memset(cmd_buf,0x0,CMD_BUF_SIZE);
if(wemo_config.echo)
printf("\r> "); //print the prompt
cmd_buf_full=false;
}
}
}
void core_process_wifi_data(void){
int BUF_SIZE=XL_BUF_SIZE;
char *buf;
int chan_num, data_size, r;
unsigned int red,green,blue, blink;
unsigned int yr,mo,dt,dw,hr,mn,sc;
int time_buf_size = MD_BUF_SIZE;
char *time_buf;
//match against the data
if(strlen(wifi_rx_buf)>BUF_SIZE){
printf("can't process rx'd packet, too large\n");
core_log("can't process rx'd packet, too large");
return;
}
//allocate memory
buf = core_malloc(BUF_SIZE);
r=sscanf(wifi_rx_buf,"\r\n+IPD,%d,%d:%s", &chan_num, &data_size, buf);
if(r!=3){
printf("rx'd corrupt data, ignoring\n");
core_log("rx'd corrupt data, ignoring\n");
//free memory
core_free(buf);
return;
}
if(wemo_config.debug_level>DEBUG_INFO)
printf("Got [%d] bytes on channel [%d]\n",
data_size, chan_num);
//discard responses from the NILM to power logging packets, but keep the response
//if another core function has requested some data, this is done with the callback
//function. The requesting core function registers a callback and this function calls
//it and then resets the callback to NULL
if(chan_num==4){
//close the socket
wifi_send_cmd("AT+CIPCLOSE=4","Unlink",buf,BUF_SIZE,1);
//execute the callback
if(tx_callback!=NULL){
(*tx_callback)(wifi_rx_buf);
tx_callback=NULL;
}
//clear the server buffer
memset(wifi_rx_buf,0x0,WIFI_RX_BUF_SIZE);
//free memory
core_free(buf);
return;
}
///////////////////
//this data must be inbound to the server port, process the command
//
// RELAY ON
if(strcmp(buf,"relay_on")==0){
gpio_set_pin_high(RELAY_PIN);
printf("relay ON\n");
//return "OK" to indicate success
wifi_send_txt(0,"OK");
}
// RELAY OFF
else if(strcmp(buf,"relay_off")==0){
gpio_set_pin_low(RELAY_PIN);
printf("relay OFF\n");
//return "OK" to indicate success
wifi_send_txt(0,"OK");
}
// LED SET
else if(strstr(buf,"set_led")==buf){
if(sscanf(buf,"set_led_%u_%u_%u_%u.",&red,&green,&blue,&blink)!=4){
core_log("corrupt led_set request");
} else {
rgb_led_set(red,green,blue,blink);
if(wemo_config.echo)
printf("set led: [%u, %u, %u, %u]\n",red,green,blue,blink);
wifi_send_txt(0,"OK");
}
}
// RTC SET
else if(strstr(buf,"set_rtc")==buf){
if(sscanf(buf,"set_rtc_%u_%u_%u_%u_%u_%u_%u.",
&yr,&mo,&dt,&dw,&hr,&mn,&sc)!=7){
core_log("corrupt rtc_set request");
} else {
if(i2c_rtc_set_time(sc,mn,hr,dw,dt,mo,yr)!=0)
printf("error setting RTC\n");
else{
time_buf = membag_alloc(time_buf_size);
if(time_buf==NULL)
core_panic();
rtc_get_time_str(time_buf,time_buf_size);
if(wemo_config.echo)
printf("wifi set rtc to: %s\n",time_buf);
core_log("wifi set rtc");
membag_free(time_buf);
wifi_send_txt(0,"OK");
}
}
}
// SEND DATA
else if(strcmp(buf,"send_data")==0){
if(tx_pkt->status!=POWER_PKT_READY){
r = wifi_send_txt(chan_num,"error: no data");
if(r==TX_ERR_MODULE_RESET)
while(wifi_init()!=0); //fail!!! anger!!!! reset the module
} else {
//send the data
r=wifi_send_raw(chan_num,(uint8_t*)tx_pkt,sizeof(*tx_pkt));
if(r==TX_ERR_MODULE_RESET){
while(wifi_init()!=0); //fail!! anger!!! reset the module
} else {
//clear out the packet so we can start again
memset(tx_pkt,0,sizeof(*tx_pkt));
tx_pkt->status=POWER_PKT_EMPTY;
if(wemo_config.debug_level>=DEBUG_INFO)
printf("sent data\n");
}
}
}
else{
printf("unknown command: %s\n",buf);
wifi_send_txt(chan_num,"error: unknown command");
//free memory
core_free(buf);
return;
}
//clear the server buffer
memset(wifi_rx_buf,0x0,WIFI_RX_BUF_SIZE);
//free the memory
core_free(buf);
return;
}
//Core Panic
// set light red, spin forever
void
core_panic(void){
rgb_led_set(LED_RED,250);
while(1);
}
