//delay , then call OTA reboot,3s*level
void ICACHE_FLASH_ATTR
debug_OtaRebootStart(uint32 t_ms)
{
os_timer_disarm(&reboot_t);
os_timer_setfn(&reboot_t,debug_OtaReboot,NULL);
struct ip_info sta_ip;
wifi_get_ip_info(STATION_IF,&sta_ip);
uint16 mesh_level = 0;
#if ESP_MESH_SUPPORT
if( espconn_mesh_local_addr(&sta_ip.ip)){
uint32 mlevel = sta_ip.ip.addr&0xff;
mesh_level = mlevel;
ESP_DBG("THIS IS A MESH SUB NODE..level: %d\r\n",mesh_level);
}else if(sta_ip.ip.addr!= 0){
ESP_DBG("THIS IS A MESH ROOT..\r\n");
mesh_level = 1;
}else{
//why?
mesh_level = 1;
}
#endif
os_timer_arm(&reboot_t,t_ms+3000*(mesh_level-1),0);
ESP_DBG("upgrade reboot in %d ms\r\n",t_ms+3000*mesh_level);
}
/******************************************************************************
* FunctionName : user_esp_platform_device_action
* Description : Execute the actions of minimum wait time
* Parameters : pwait_action -- point the list of actions which need execute
*
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_device_action(struct wait_param *pwait_action)
{
uint8 i = 0;
uint16 count = pwait_action->count;
uint16 action_number = pwait_action->action_number;
ESP_DBG("there is %d action at the same time\n", pwait_action->action_number);
#if PLUG_DEVICE
for (i = 0; i < action_number && pwait_action->action[i][0] != '0'; i++) {
ESP_DBG("%s\n",pwait_action->action[i]);
if (os_strcmp(pwait_action->action[i], "on_switch", 9) == 0) {
user_plug_set_status(0x01);
} else if (os_strcmp(pwait_action->action[i], "off_switch", 10) == 0) {
user_plug_set_status(0x00);
} else if (os_strcmp(pwait_action->action[i], "on_off_switch", 13) == 0) {
if (user_plug_get_status() == 0) {
user_plug_set_status(0x01);
} else {
user_plug_set_status(0x00);
}
} else {
return;
}
}
user_platform_timer_first_start(count);
#endif
}
void ICACHE_FLASH_ATTR
espnow_debug_send(uint8* data,uint16 len)
{
if(espnow_debug_enable){
ESP_DBG("espnow send to "MACSTR"\r\n",MAC2STR(debug_target_mac));
ESP_DBG("data: %s \r\n",data);
esp_now_send(debug_target_mac,data,len);
}
//FLASH buf init
void ICACHE_FLASH_ATTR
debug_FlashBufInit(flashDebugBuf* flashDbgBuf,uint32 idx_sec)
{
//spi_flash_read(idx_sec*0x1000,(uint32*)flashDbgBuf,sizeof(flashDebugBuf));
config_ParamLoadWithProtect(idx_sec,0,(uint8*)flashDbgBuf,sizeof(flashDebugBuf));
if(debug_FlashParamCsumCheck(flashDbgBuf) && debug_FlashAddrCheck(flashDbgBuf)){
ESP_DBG("flash debug check sum ok..\r\n");
}else{
ESP_DBG("flash debug info reset...\r\n");
debug_FlashBufReset(flashDbgBuf,idx_sec);
}
}
//OTA reboot function
void ICACHE_FLASH_ATTR
debug_OtaReboot()
{
#if ESP_MESH_SUPPORT
ESP_DBG("deinit for OTA\r\n");
espconn_mesh_disable(NULL);
wifi_station_disconnect();
wifi_set_opmode(NULL_MODE);
#endif
user_esp_clr_upgrade_finish_flag();//clear flag and reboot
system_upgrade_flag_set(UPGRADE_FLAG_FINISH);
ESP_DBG("call system upgrade reboot...\r\n");
system_upgrade_reboot();
}
//print exception log to Flash
void ICACHE_FLASH_ATTR
stack_dump(struct rst_info *info, uint32 sp)
{
uint32 i;
uint8 log_buf[200];
const char* pad = " ";
int len;
if(info->reason == REASON_WDT_RST || info->reason == REASON_SOFT_WDT_RST
|| info->reason == REASON_EXCEPTION_RST) {
ets_memset(log_buf,0,sizeof(log_buf));
ets_sprintf(log_buf,"stack sp is %08x\n",sp);
len = os_strlen(log_buf);
if(len%4!=0) ets_memcpy(log_buf+len,pad, 4 - (len%4));
ESP_DBG("Stack sp is %08x\n",sp);
debug_DumpToFlash(log_buf,os_strlen(log_buf));
ets_memset(log_buf,0,sizeof(log_buf));
ets_sprintf(log_buf,"*** stack dump start ***\n");
len = os_strlen(log_buf);
if(len%4!=0) os_memcpy(log_buf+len,pad, 4 - (len%4));
debug_DumpToFlash(log_buf,os_strlen(log_buf));
ESP_DBG("*** Stack dump start ***\n");
ets_memset(log_buf,0,sizeof(log_buf));
ets_sprintf(log_buf,"PC = 0x%08x\n",info->epc1);
len = os_strlen(log_buf);
if(len%4!=0) os_memcpy(log_buf+len,pad, 4 - (len%4));
debug_DumpToFlash(log_buf,os_strlen(log_buf));
ESP_DBG("DBG PC = 0x%08x\n",info->epc1);
for (i = sp; i < 0x40000000; i+=16) {
uint32 *val = (uint32 *)i;
ets_memset(log_buf,0,sizeof(log_buf));
ets_sprintf(log_buf,"%08x: %08x %08x %08x %08x\n", i, *val, *(val + 1), *(val + 2), *(val + 3));
len = os_strlen(log_buf);
if(len%4!=0) os_memcpy(log_buf+len,pad, 4 - (len%4));
debug_DumpToFlash(log_buf,os_strlen(log_buf));
ESP_DBG("%08x: %08x %08x %08x %08x\n", i, *val, *(val + 1), *(val + 2), *(val + 3));
}
ets_memset(log_buf,0,sizeof(log_buf));
ets_sprintf(log_buf,"*** stack dump end ***\n");
len = os_strlen(log_buf);
if(len%4!=0) os_memcpy(log_buf+len,pad, 4 - (len%4));
debug_DumpToFlash(log_buf,os_strlen(log_buf));
ESP_DBG("*** Stack dump end ***\n");
}
//upload debug info to esp-server
void ICACHE_FLASH_ATTR
debug_UploadExceptionInfo(void* arg)
{
struct espconn *pespconn = (struct espconn *)arg;
ESP_DBG("reset reason: %x\n", rtc_info_dbg.reason);
uint8 debug_upload_buf[DEBUG_UPLOAD_BUF_LEN];
uint8* pInfo = debug_upload_buf;
os_memset(debug_upload_buf,0,DEBUG_UPLOAD_BUF_LEN);
uint8 devkey[41];
os_memset(devkey,0,sizeof(devkey));
user_esp_platform_get_devkey(devkey);
if (rtc_info_dbg.reason == REASON_WDT_RST ||
rtc_info_dbg.reason == REASON_EXCEPTION_RST ||
rtc_info_dbg.reason == REASON_SOFT_WDT_RST) {
os_sprintf(pInfo,UPLOAD_DEBUG_LOG,rtc_info_dbg.reason,rtc_info_dbg.exccause,rtc_info_dbg.epc1,
rtc_info_dbg.epc2,rtc_info_dbg.epc3,rtc_info_dbg.excvaddr,
rtc_info_dbg.depc,FlashDebugBufParam.DebugVersion ,devkey);
}else{
return;
}
#if ESP_MESH_SUPPORT
mesh_json_add_elem(pInfo, sizeof(pInfo), (char*)mesh_GetMdevMac(), ESP_MESH_JSON_DEV_MAC_ELEM_LEN);
#endif
uint8 *dst = NULL,*src = NULL;
#if ESP_MESH_SUPPORT
uint8 dst_t[6],src_t[6];
if(pespconn && pespconn->proto.tcp){
os_memcpy(dst_t,pespconn->proto.tcp->remote_ip,4);
os_memcpy(dst_t+4,&pespconn->proto.tcp->remote_port,2);
}
wifi_get_macaddr(STATION_IF,src_t);
dst = dst_t;
src = src_t;
#endif
ESP_DBG("debug Info: %s \r\n",pInfo);
if(0 == user_JsonDataSend(pespconn, pInfo, os_strlen(pInfo),0,src,dst)){
debug_DropExceptionInfo();
ESP_DBG("upload success...\r\n");
}else{
ESP_DBG("upload fail...\r\n");
}
}
//write reset info to flash
void ICACHE_FLASH_ATTR
debug_FlashSvExceptInfo(struct rst_info* pInfo)
{
debug_FlashBufInit(&FlashDebugBufParam,Flash_DEBUG_INFO_ADDR);
uint8 InfoBuf[200];
os_memset(InfoBuf,0,200);
uint8* ptmp = InfoBuf;
ptmp += os_sprintf(ptmp,"reset reason:%x\n", pInfo->reason);
if (pInfo->reason == REASON_WDT_RST ||
pInfo->reason == REASON_EXCEPTION_RST ||
pInfo->reason == REASON_SOFT_WDT_RST) {
if (pInfo->reason == REASON_EXCEPTION_RST) {
ptmp += os_sprintf(ptmp,"Fatal exception (%d):\n", pInfo->exccause);
}
ptmp+=os_sprintf(ptmp,"debug_version:%d\r\n",FlashDebugBufParam.DebugVersion);
ptmp+=os_sprintf(ptmp,"epc1=0x%08x, epc2=0x%08x, epc3=0x%08x, excvaddr=0x%08x, depc=0x%08x\r\n",
pInfo->epc1, pInfo->epc2, pInfo->epc3, pInfo->excvaddr, pInfo->depc);
}
int len = os_strlen(InfoBuf);
uint8 pad_len = 0;
if(len%4 != 0){
pad_len = 4 - (len%4);
os_memcpy(ptmp," ",pad_len);
}
len += pad_len;
ESP_DBG("============\r\nSV DBUG INFO:\r\n%s\r\n==============\r\n",InfoBuf);
debug_PrintToFlash(InfoBuf,len,&FlashDebugBufParam,Flash_DEBUG_INFO_ADDR);
}
//write mesh reconn info to flash
void ICACHE_FLASH_ATTR
debug_FlashSvMeshReconInfo(char* time_str,sint8 err)
{
uint8 reconInfo[200];
int len;
os_memset(reconInfo,0,sizeof(reconInfo));
struct ip_info ipconfig;
wifi_get_ip_info(STATION_IF, &ipconfig);
len = os_sprintf(reconInfo,"MESH RECONN AT %s,ERR:%d,IP:"IPSTR";\r\n",time_str,err,IP2STR(&(ipconfig.ip)));
//int len = os_strlen(reconInfo);
char* ptmp = reconInfo + len;
uint8 pad_len = 0;
if(len%4 != 0){
pad_len = 4 - (len%4);
os_memcpy(ptmp," ",pad_len);
}
len += pad_len;
ESP_DBG("%s\r\n",reconInfo);
debug_PrintToFlash(reconInfo,len,&FlashDebugBufParam,Flash_DEBUG_INFO_ADDR);
}
void ICACHE_FLASH_ATTR
debug_FlashPrintParamInit()
{
//debug_FlashBufInit(&FlashPrintBufParam,FLASH_PRINT_INDEX_ADDR);
//spi_flash_read(idx_sec*0x1000,(uint32*)flashDbgBuf,sizeof(flashDebugBuf));
config_ParamLoadWithProtect(FLASH_PRINT_INDEX_ADDR,0,(uint8*)&FlashPrintBufParam,sizeof(flashDebugBuf));
if(debug_FlashParamCsumCheck(&FlashPrintBufParam) && debug_FlashAddrCheck(&FlashPrintBufParam)){
ESP_DBG("flash debug check sum ok..\r\n");
}else{
ESP_DBG("flash debug info reset...\r\n");
//debug_FlashBufReset(&FlashPrintBufParam,FLASH_PRINT_INDEX_ADDR);
debug_FlashPrintParamReset();
}
}
/*
串口错误应答
*/
void ICACHE_FLASH_ATTR cus_uart_error_echo(u8 error, u8 id)
{
ESP_DBG(("cus_uart_error_echo"));
frame_t frame;
frame.crc = 0;
frame.head = FRAME_HEADER;
frame.crc += frame.head;
frame.len = FRAME_ERROR_ECHO_DATA_LEN;
frame.crc += frame.len;
frame.type = FRAME_CUS_ERRECHO_TYPE;
frame.crc += frame.type;
frame.id = id;
frame.crc += frame.id;
frame.data[0] = error;
frame.crc += error;
frame.data[1] = 0;//保留
//uart0_tx_buffer((uint8_t *)&frame, frame.len);
Enqueue(&frame);
return;
}
//write string to flash
void ICACHE_FLASH_ATTR
debug_DumpToFlash(uint8* data, uint16 len)
{
if(len%4 != 0){
ESP_DBG("4Bytes ...\r\n");
return;
}
if(FlashDumpBufParam.InPos % 0x1000 ==0)
spi_flash_erase_sector(FlashDumpBufParam.InPos / 0x1000);
if(FlashDumpBufParam.InPos+len < FlashDumpBufParam.StartAddr+FlashDumpBufParam.Size ){
spi_flash_write(FlashDumpBufParam.InPos,(uint32 *)data,len);
ESP_DBG("addr: 0x%08x : %d \r\n",FlashDumpBufParam.InPos,len);
FlashDumpBufParam.InPos+=len;
}
}
/******************************************************************************
* FunctionName : user_esp_platform_upgrade_cb
* Description : Processing the downloaded data from the server
* Parameters : pespconn -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
v_user_esp_platform_upgrade_rsp(void *arg)
{
struct upgrade_server_info *server = arg;
if (server->upgrade_flag == true) {
ESP_DBG("user_esp_platform_upgrade_successful\n");
} else {
ESP_DBG("user_esp_platform_upgrade_failed\n");
}
os_free(server->url);
server->url = NULL;
os_free(server);
server = NULL;
}
void ICACHE_FLASH_ATTR user_uart_task(void *pvParameters)
{
CusUartIntrPtr uartptrData;
u32 sys_time_value = system_get_time();
while (1)
{
if (EmptyQueue() == false && (system_get_time() - sys_time_value) >= 100) {
ESP_DBG(("***heap_size %d\n", system_get_free_heap_size()));
frame_t frame;
if (Dequeue(&frame)) {
uart0_tx_buffer((uint8_t *)&frame, frame.len);
}
sys_time_value = system_get_time();
}
if (xQueueReceive(xQueueCusUart, (void *)&uartptrData, (portTickType)20/*portMAX_DELAY*/)) // wait about 20msec
{
ESP_DBG(("data uart recv.."));
debug_print_hex_data(uartptrData.rx_buf, uartptrData.rx_len);
if (uartptrData.rx_len>0x00) {
cus_uart_data_handle(uartptrData.rx_buf, uartptrData.rx_len, NULL);
}
}
/*
if ((system_get_time() - sys_time_value) >= (60 * 1000 * 1000)) //about 1min, send data to uart0, demo beat data
{
ESP_DBG(("uart beat data***heap_size %d\n", system_get_free_heap_size()));
//uart0_write_data(uart_beat_data, sizeof(uart_beat_data));//heatbeat sent to MCU
sys_time_value = system_get_time();
}
*/
}
vTaskDelete(NULL);
}
/******************************************************************************
* FunctionName : user_esp_platform_device_action
* Description : Execute the actions of minimum wait time
* Parameters : pwait_action -- point the list of actions which need execute
*
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_device_action(struct wait_param *pwait_action)
{
uint8 i = 0;
uint16 count = pwait_action->count;
uint16 action_number = pwait_action->action_number;
ESP_DBG("there is %d action at the same time\n", pwait_action->action_number);
}
/******************************************************************************
* FunctionName : user_platform_timer_start
* Description : Processing the message about timer from the server
* Parameters : timer_wait_param -- The received data from the server
* count -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_wait_time_overflow_check(struct wait_param *pwait_action)
{
ESP_DBG("min_wait_second = %d", min_wait_second);
if (pwait_action->min_time_backup >= 3600) {
os_timer_disarm(&device_timer);
os_timer_setfn(&device_timer, (os_timer_func_t *)user_esp_platform_wait_time_overflow_check, pwait_action);
os_timer_arm(&device_timer, 3600000, 0);
ESP_DBG("min_wait_second is extended\n");
} else {
os_timer_disarm(&device_timer);
os_timer_setfn(&device_timer, (os_timer_func_t *)user_esp_platform_device_action, pwait_action);
os_timer_arm(&device_timer, pwait_action->min_time_backup * 1000, 0);
ESP_DBG("min_wait_second is = %dms\n", pwait_action->min_time_backup * 1000);
}
pwait_action->min_time_backup -= 3600;
}
//save flash debug param
void ICACHE_FLASH_ATTR
debug_FlashParamSv(flashDebugBuf* flashDbgBuf,uint32 sec_addr)
{
ESP_DBG("debug_FlashParamSv\r\n");
debug_FlashParamCsumSet(flashDbgBuf);
//spi_flash_erase_sector(Flash_DEBUG_INFO_ADDR);
//spi_flash_write(Flash_DEBUG_INFO_ADDR*0x1000,(uint32*)&FlashDebugBufParam,sizeof(FlashDebugBufParam));
config_ParamSaveWithProtect(sec_addr,(uint32*)flashDbgBuf,sizeof(flashDebugBuf));
}
/******************************************************************************
* FunctionName : user_esp_platform_get_connect_status
* Description : get each connection step's status
* Parameters : none
* Returns : status
*******************************************************************************/
uint8 ICACHE_FLASH_ATTR
user_esp_platform_get_connect_status(void)
{
uint8 status = wifi_station_get_connect_status();
if (status == STATION_GOT_IP) {
status = (device_status == 0) ? DEVICE_CONNECTING : device_status;
}
ESP_DBG("status %d\n", status);
return status;
}
void ICACHE_FLASH_ATTR
mem_leak_debug_hook(void* buf,uint16_t len)
{
ESP_DBG("mem_leak_debug_hook\r\n");
static bool hook_called = false;
if(hook_called == false){
debug_DumpBufReset();
hook_called = true;
}
#if 0
extern uint8 time_stamp_str[32];
char time_buf[128];
os_memset(time_buf,' ',sizeof(time_buf));
if(os_strchr(time_stamp_str,':')){
//debug_FlashPrint((uint8*)time_stamp_str,32);
os_sprintf(time_buf,"last time recorded: %s \r\n",time_stamp_str);
}else{
os_sprintf(time_buf,"time not recorded\r\n");
}
debug_FlashPrint((uint8*)time_buf,sizeof(time_buf));
#endif
int tmp = 4-len%4;
int length = len;
if(tmp != 0){
int i;
for(i=0;i<tmp;i++)
*(((uint8*)buf)+len+i)= ' ';
length = len+tmp;
}
ESP_DBG("len: %d ; length: %d \r\n",len,length);
debug_FlashPrint((uint8*)buf,length);
ESP_DBG(
"------------AFTER-------------\r\n");
ESP_DBG("flash debug : CURSEC: %02x\r\n",FlashPrintBufParam.CurrentSec);
ESP_DBG("flash debug : size: %d\r\n",FlashPrintBufParam.Size);
ESP_DBG("flash debug : START: %08x\r\n",FlashPrintBufParam.StartAddr);
ESP_DBG("flash debug : InPos: %08x\r\n",FlashPrintBufParam.InPos);
ESP_DBG("flash debug : OutPos: %08x\r\n",FlashPrintBufParam.OutPos);
ESP_DBG("flash debug : length : %d \r\n",debug_GetFlashDebugInfoLen(&FlashPrintBufParam));
/*
模块状态查询应答
*/
void ICACHE_FLASH_ATTR cus_uart_data_echo()
{
ESP_DBG((" "));
uint8_t i;
frame_t frame;
for (i = 0; i < FRAME_STATUS_ECHO_DATA_LEN - 5; i++)
frame.data[i] = 0;
frame.crc = 0;
frame.head = FRAME_HEADER;
frame.crc += frame.head;
frame.len = FRAME_STATUS_ECHO_DATA_LEN;
frame.crc += frame.len;
frame.type = FRAME_CUS_QUERY_TYPE;
frame.crc += frame.type;
frame.id = _ID++;
frame.crc += frame.id;
i = 0;
frame.data[i] = FRAME_CMD_STATUS_QUERY; //work model, 01:STA,02:AP,03:STA+AP
frame.crc += frame.data[i++];
//add mode status
frame.data[i] = wifi_get_opmode(); //work model, 01:STA,02:AP,03:STA+AP
frame.crc += frame.data[i++];
//add AP connected status
if (wifi_station_get_connect_status()) {
frame.data[i] = 0x01;
}
else {
frame.data[i] = 0x02;
}
frame.crc += frame.data[i++];
//add CLOUD connected status
frame.data[i] = cloud_connect_status;
frame.crc += frame.data[i++];
//add RSSI
int rssi = wifi_station_get_rssi();
frame.data[i] = ((128 + rssi) / 128.0 * 4 + 1);
frame.crc += frame.data[i++];
frame.data[i++] = 0;//保留
frame.data[i] = frame.crc;
uint8_t *p = (uint8_t *)&frame;
//uart0_tx_buffer(p, frame.len);
Enqueue(&frame);
return;
}
/******************************************************************************
* FunctionName : user_esp_platform_ap_change
* Description : add the user interface for changing to next ap ID.
* Parameters :
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_ap_change(void)
{
uint8 current_id;
uint8 i = 0;
ESP_DBG("user_esp_platform_ap_is_changing\n");
current_id = wifi_station_get_current_ap_id();
ESP_DBG("current ap id =%d\n", current_id);
if (current_id == AP_CACHE_NUMBER - 1) {
i = 0;
} else {
i = current_id + 1;
}
while (wifi_station_ap_change(i) != true) {
i++;
if (i == AP_CACHE_NUMBER - 1) {
i = 0;
}
}
}
//check flash debug info address
bool ICACHE_FLASH_ATTR
debug_FlashAddrCheck(flashDebugBuf* flashDbgBuf)
{
#if 0
if(FlashDebugBufParam.InPos >= FlashDebugBufParam.OutPos &&
FlashDebugBufParam.InPos< FlashDebugBufParam.StartAddr+FlashDebugBufParam.Size &&
FlashDebugBufParam.InPos>=FlashDebugBufParam.StartAddr){
ESP_DBG("debug flash addr check ok...\r\n");
return true;
}else{
ESP_DBG("debug flash addr check error...\r\n");
return false;
}
#endif
if((flashDbgBuf->InPos>=flashDbgBuf->StartAddr)&&(flashDbgBuf->InPos<=flashDbgBuf->StartAddr+flashDbgBuf->Size)
&&(flashDbgBuf->OutPos>=flashDbgBuf->StartAddr)&&(flashDbgBuf->OutPos<=flashDbgBuf->StartAddr+flashDbgBuf->Size)){
ESP_DBG("debug flash addr check ok...\r\n");
return true;
}else{
ESP_DBG("debug flash addr check error...\r\n");
return false;
}
}
//cal checksum and check
bool ICACHE_FLASH_ATTR
debug_FlashParamCsumCheck(flashDebugBuf* flashDbgBuf)
{
uint8 csum_cal=0;
int i ;
char* tmp = (char*)(flashDbgBuf);
for(i=1;i<sizeof(flashDebugBuf);i++){
csum_cal+= *(tmp+i);
}
ESP_DBG("flash csum cal: %d ; ori: %d \r\n",csum_cal,flashDbgBuf->csum);
if(csum_cal==flashDbgBuf->csum)
return true;
else
return false;
}
/******************************************************************************
* FunctionName : user_esp_platform_upgrade_begin
* Description : Processing the received data from the server
* Parameters : pespconn -- the espconn used to connetion with the host
* server -- upgrade param
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
v_user_esp_platform_upgrade_begin(struct espconn *pespconn, struct upgrade_server_info *server)
{
uint8 user_bin[9] = {0};
server->pespconn = pespconn;
server->port = 80;
server->check_cb = v_user_esp_platform_upgrade_rsp;
server->check_times = 120000;
const char esp_server_ip[4] = {52,68,48,85};
os_memcpy(server->ip, esp_server_ip, 4);
if (server->url == NULL) {
server->url = (uint8 *)os_zalloc(512);
}
#if 0 // in general, we need to check user bin here
if (system_upgrade_userbin_check() == UPGRADE_FW_BIN1) {
os_memcpy(user_bin, "user2.bin", 10);
} else if (system_upgrade_userbin_check() == UPGRADE_FW_BIN2) {
os_memcpy(user_bin, "user1.bin", 10);
}
os_sprintf(server->url, "GET /%s HTTP/1.0\r\nHost: "IPSTR":%d\r\n"pheadbuffer"",
user_bin, IP2STR(server->ip),
80);
#else
os_sprintf(server->url, "GET /%s HTTP/1.0\r\nHost: "IPSTR":%d\r\n"pheadbuffer"",
"download/file/user1.1024.new.bin", IP2STR(server->ip),
80);
//http://192.168.31.229/test/user1.1024.new.2.bin
//52.68.48.85/download/file/user1.1024.new.bin
#endif
if (system_upgrade_start(server) == false) {
ESP_DBG("upgrade is already started\n");
}
}
//dump exception log into Flash
void ICACHE_FLASH_ATTR
system_restart_hook(struct rst_info *info)
{
register uint32 sp asm("a1");
uint32 offset = 0;
#if 0
if (info->reason == REASON_SOFT_WDT_RST) {
offset = 0x1c0;
}
else if (info->reason == REASON_EXCEPTION_RST) {
offset = 0x1b0;
}
#endif
debug_DumpBufReset();
uint8 InfoBuf[200];
os_memset(InfoBuf,0,200);
uint8* ptmp = InfoBuf;
os_sprintf(ptmp,"reset reason:%x\n", info->reason);
ptmp+=os_strlen(ptmp);
if (info->reason == REASON_WDT_RST ||
info->reason == REASON_EXCEPTION_RST ||
info->reason == REASON_SOFT_WDT_RST) {
if (info->reason == REASON_EXCEPTION_RST) {
os_sprintf(ptmp,"Fatal exception (%d):\n", info->exccause);
ptmp += os_strlen(ptmp);
}
ptmp+=os_strlen(ptmp);
os_sprintf(ptmp,"epc1=0x%08x, epc2=0x%08x, epc3=0x%08x, excvaddr=0x%08x, depc=0x%08x\r\n",
info->epc1, info->epc2, info->epc3, info->excvaddr, info->depc);
ptmp+=os_strlen(ptmp);
}
int len = os_strlen(InfoBuf);
uint8 pad_len = 0;
if(len%4 != 0){
pad_len = 4 - (len%4);
os_memcpy(ptmp," ",pad_len);
}
len += pad_len;
ESP_DBG("============\r\nSV DBUG INFO:\r\n%s\r\n==============\r\n",InfoBuf);
debug_DumpToFlash(InfoBuf,len);
stack_dump(info, sp + offset);
/******************************************************************************
* FunctionName : user_platform_timer_start
* Description : Processing the message about timer from the server
* Parameters : timer_wait_param -- The received data from the server
* count -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
esp_platform_timer_action(struct esp_platform_wait_timer_param *timer_wait_param, uint16 count)
{
uint16 i = 0;
uint16 action_number;
struct wait_param pwait_action = {0};
pwait_action.count = count;
action_number = 0;
for (i = 0; i < count ; i++) {
if (timer_wait_param[i].wait_time_second == min_wait_second) {
os_memcpy(pwait_action.action[action_number], timer_wait_param[i].wait_action, os_strlen(timer_wait_param[i].wait_action));
ESP_DBG("*****%s*****\n", timer_wait_param[i].wait_action);
action_number++;
}
}
pwait_action.action_number = action_number;
pwait_action.min_time_backup = min_wait_second;
user_esp_platform_wait_time_overflow_check(&pwait_action);
}
//get flash debug info
void ICACHE_FLASH_ATTR
debug_GetFlashExceptInfo(uint8* buf, uint16 max_len,uint16 offset)
{
ESP_DBG("flash debug : InPos: %08x\r\n",FlashDebugBufParam.InPos);
ESP_DBG("flash debug : OutPos: %08x\r\n",FlashDebugBufParam.OutPos);
int size = (FlashDebugBufParam.InPos-FlashDebugBufParam.OutPos-offset);
if(size>max_len) size = max_len;
offset = offset - offset%4;
if(size>0){
//debug_str = (uint8*)os_zalloc(size+1);
spi_flash_read(FlashDebugBufParam.OutPos+offset,(uint32*)buf,size);
ESP_DBG("-----------------------\r\n");
ESP_DBG("FLASH DEBUG INFO: \r\n");
ESP_DBG("%s\r\n",buf);
ESP_DBG("-----------------------\r\n");
}
}
void user_esp_pwm_test_task(void *pvParameters)
{
uint32 r,g,b,cw,ww,period;
r = 0;
g = 0;
b = 0;
cw = 0;
period = 1000;
while(1) // a demo test pwm
{
ESP_DBG(("*****test****r:%d,g:%d,b:%d,cw:%d,ww:%d",r,g,b,cw,ww));
light_set_aim(r,g,b,cw,ww,period);
r+=5;
g+=5;
b+=5;
cw+=5;
ww+=5;
if(r>100)
r = 0;
if(g>100)
g = 0;
if(b>100)
b = 0;
if(cw>100)
cw = 0;
if(ww>100)
ww = 0;
vTaskDelay(50);
}
vTaskDelete(NULL);
return;
}
void ICACHE_FLASH_ATTR
debug_DispFlashExceptInfo(flashDebugBuf* flashDbgBuf)
{
ESP_DBG("flash debug : version: %d \r\n",flashDbgBuf->DebugVersion);
ESP_DBG("flash debug : InPos: %08x\r\n",flashDbgBuf->InPos);
ESP_DBG("flash debug : OutPos: %08x\r\n",flashDbgBuf->OutPos);
uint8* debug_str = NULL;
int size = (flashDbgBuf->InPos-flashDbgBuf->OutPos);
if(size>0){
debug_str = (uint8*)os_zalloc(size+1);
spi_flash_read(flashDbgBuf->OutPos,(uint32*)debug_str,size);
ESP_DBG("-----------------------\r\n");
ESP_DBG("FLASH DEBUG INFO: \r\n");
ESP_DBG("%s\r\n",debug_str);
ESP_DBG("-----------------------\r\n");
}
if(debug_str){
os_free(debug_str);
debug_str = NULL;
}
}
/******************************************************************************
* FunctionName : user_platform_timer_first_start
* Description : calculate the wait time of each timer
* Parameters : count -- The number of timers given by server
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_platform_timer_first_start(uint16 count)
{
int i = 0;
struct esp_platform_wait_timer_param timer_wait_param[100] = {0};
ESP_DBG("current timestamp= %ds\n", timestamp);
timestamp = timestamp + min_wait_second;
for (i = 0 ; i < count ; i++) {
char *str = timer_splits[i];
if (indexof(str, "f", 0) == 0) {
char *fixed_wait[2];
ESP_DBG("timer is fixed mode\n");
split(str, "=", fixed_wait);
os_memcpy(timer_wait_param[i].wait_time_param, fixed_wait[0] + 1, os_strlen(fixed_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, fixed_wait[1], os_strlen(fixed_wait[1]));
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - timestamp;
os_free(fixed_wait[0]);
os_free(fixed_wait[1]);
}
else if (indexof(str, "l", 0) == 0) {
char *loop_wait[2];
ESP_DBG("timer is loop mode\n");
split(str, "=", loop_wait);
os_memcpy(timer_wait_param[i].wait_time_param, loop_wait[0] + 1, os_strlen(loop_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, loop_wait[1], os_strlen(loop_wait[1]));
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - (timestamp % atoi(timer_wait_param[i].wait_time_param));
os_free(loop_wait[0]);
os_free(loop_wait[1]);
} else if (indexof(str, "w", 0) == 0) {
char *week_wait[2];
int monday_wait_time = 0;
ESP_DBG("timer is weekend mode\n");
split(str, "=", week_wait);
os_memcpy(timer_wait_param[i].wait_time_param, week_wait[0] + 1, os_strlen(week_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, week_wait[1], os_strlen(week_wait[1]));
monday_wait_time = (timestamp - 1388937600) % (7 * 24 * 3600);
ESP_DBG("monday_wait_time == %d", monday_wait_time);
if (atoi(timer_wait_param[i].wait_time_param) > monday_wait_time) {
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - monday_wait_time;
} else {
timer_wait_param[i].wait_time_second = 7 * 24 * 3600 - monday_wait_time + atoi(timer_wait_param[i].wait_time_param);
}
os_free(week_wait[0]);
os_free(week_wait[1]);
}
}
esp_platform_find_min_time(timer_wait_param, count);
if(min_wait_second == 0) {
return;
}
esp_platform_timer_action(timer_wait_param, count);
}
