/****************************************************************************** * FunctionName : user_init * Description : entry of user application, init user function here * Parameters : none * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR user_init(void) { sys_read_cfg(); if(!syscfg.cfg.b.debug_print_enable) system_set_os_print(0); uart_init(); #if USE_TMP2NET_PORT GPIO0_MUX = 0; #else GPIO0_MUX = VAL_MUX_GPIO0_SDK_DEF; #endif GPIO4_MUX = VAL_MUX_GPIO4_SDK_DEF; GPIO5_MUX = VAL_MUX_GPIO5_SDK_DEF; GPIO12_MUX = VAL_MUX_GPIO12_SDK_DEF; GPIO14_MUX = VAL_MUX_GPIO14_SDK_DEF; system_timer_reinit(); #if DEBUGSOO > 0 os_printf("\nSimple WEB version: " WEB_SVERSION "\nOpenLoaderSDK v1.2\n"); #endif if(syscfg.cfg.b.pin_clear_cfg_enable) test_pin_clr_wifi_config(); set_cpu_clk(); // select cpu frequency 80 or 160 MHz #if DEBUGSOO > 0 if(eraminfo.size > 0) os_printf("Found free IRAM: base: %p, size: %d bytes\n", eraminfo.base, eraminfo.size); os_printf("System memory:\n"); system_print_meminfo(); os_printf("Start 'heap' size: %d bytes\n", system_get_free_heap_size()); #endif #if DEBUGSOO > 0 os_printf("Set CPU CLK: %u MHz\n", ets_get_cpu_frequency()); #endif Setup_WiFi(); #if USE_TMP2NET_PORT tpm2net_init(); #endif #ifdef USE_NETBIOS if(syscfg.cfg.b.netbios_ena) netbios_init(); #endif /* #ifdef USE_SNTP if(syscfg.cfg.b.sntp_ena) sntp_init(); #endif */ #ifdef UDP_TEST_PORT if(syscfg.udp_port) udp_test_port_init(syscfg.udp_port); #endif // инициализация и запуск tcp серверa(ов) #ifdef USE_SRV_WEB_PORT if(syscfg.web_port) webserver_init(syscfg.web_port); #endif /// if(syscfg.tcp2uart_port) tcp2uart_init(syscfg.tcp2uart_port); #ifdef USE_MODBUS mdb_tcp_init(502); #endif #ifdef USE_WDRV init_wdrv(); #endif system_deep_sleep_set_option(0); system_init_done_cb(init_done_cb); }
// Main routine to initialize esp-link. void user_init(void) { // get the flash config so we know how to init things //configWipe(); // uncomment to reset the config for testing purposes bool restoreOk = configRestore(); // Init gpio pin registers gpio_init(); gpio_output_set(0, 0, 0, (1<<15)); // some people tie it to GND, gotta ensure it's disabled // init UART uart_init(flashConfig.baud_rate, 115200); logInit(); // must come after init of uart // Say hello (leave some time to cause break in TX after boot loader's msg os_delay_us(10000L); os_printf("\n\n** %s\n", esp_link_version); os_printf("Flash config restore %s\n", restoreOk ? "ok" : "*FAILED*"); // Status LEDs statusInit(); serledInit(); // Wifi wifiInit(); // init the flash filesystem with the html stuff espFsInit(&_binary_espfs_img_start); //EspFsInitResult res = espFsInit(&_binary_espfs_img_start); //os_printf("espFsInit %s\n", res?"ERR":"ok"); // mount the http handlers httpdInit(builtInUrls, 80); // init the wifi-serial transparent bridge (port 23) serbridgeInit(23, 2323); uart_add_recv_cb(&serbridgeUartCb); #ifdef SHOW_HEAP_USE os_timer_disarm(&prHeapTimer); os_timer_setfn(&prHeapTimer, prHeapTimerCb, NULL); os_timer_arm(&prHeapTimer, 10000, 1); #endif struct rst_info *rst_info = system_get_rst_info(); NOTICE("Reset cause: %d=%s", rst_info->reason, rst_codes[rst_info->reason]); NOTICE("exccause=%d epc1=0x%x epc2=0x%x epc3=0x%x excvaddr=0x%x depc=0x%x", rst_info->exccause, rst_info->epc1, rst_info->epc2, rst_info->epc3, rst_info->excvaddr, rst_info->depc); uint32_t fid = spi_flash_get_id(); NOTICE("Flash map %s, manuf 0x%02X chip 0x%04X", flash_maps[system_get_flash_size_map()], fid & 0xff, (fid&0xff00)|((fid>>16)&0xff)); NOTICE("** %s: ready, heap=%ld", esp_link_version, (unsigned long)system_get_free_heap_size()); // Init SNTP service cgiServicesSNTPInit(); #ifdef MQTT NOTICE("initializing MQTT"); mqtt_client_init(); #endif NOTICE("initializing user application"); app_init(); NOTICE("Waiting for work to do..."); }
int ICACHE_FLASH_ATTR mqttStatusMsg(char *buf) { sint8 rssi = wifi_station_get_rssi(); if (rssi > 0) rssi = 0; // not connected or other error //os_printf("timer rssi=%d\n", rssi); // compose MQTT message return os_sprintf(buf, "{\"rssi\":%d, \"heap_free\":%ld}", rssi, (unsigned long)system_get_free_heap_size()); }
/****************************************************************************** * FunctionName : espconn_server_recv * Description : Data has been received on this pcb. * Parameters : arg -- Additional argument to pass to the callback function * pcb -- The connection pcb which received data * p -- The received data (or NULL when the connection has been closed!) * err -- An error code if there has been an error receiving * Returns : ERR_ABRT: if you have called tcp_abort from within the function! *******************************************************************************/ static err_t ICACHE_FLASH_ATTR espconn_server_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) { espconn_msg *precv_cb = arg; tcp_arg(pcb, arg); espconn_printf("server has application data received: %d\n", system_get_free_heap_size()); if (p != NULL) { tcp_recved(pcb, p->tot_len); } if (err == ERR_OK && p != NULL) { u8_t *data_ptr = NULL; u32_t data_cntr = 0; precv_cb->pcommon.recv_check = 0; data_ptr = (u8_t *)os_zalloc(p ->tot_len + 1); data_cntr = pbuf_copy_partial(p, data_ptr, p ->tot_len, 0); pbuf_free(p); if (data_cntr != 0) { precv_cb->pespconn ->state = ESPCONN_READ; precv_cb->pcommon.pcb = pcb; if (precv_cb->pespconn->recv_callback != NULL) { precv_cb->pespconn->recv_callback(precv_cb->pespconn, data_ptr, data_cntr); } precv_cb->pespconn ->state = ESPCONN_CONNECT; } os_free(data_ptr); data_ptr = NULL; espconn_printf("server's application data has been processed: %d\n", system_get_free_heap_size()); } else { if (p != NULL) { pbuf_free(p); } espconn_server_close(precv_cb, pcb); } return ERR_OK; }
LOCAL void ICACHE_FLASH_ATTR info_cb(void *arg) { wdt_feed(); uart0_sendStr("System Info\r\n"); os_printf("Time=%ld\r\n", system_get_time()); os_printf("Chip id=%ld\r\n", system_get_chip_id()); os_printf("Free heap size=%ld\r\n", system_get_free_heap_size()); uart0_sendStr("Mem info:\r\n"); system_print_meminfo(); uart0_sendStr("\r\n"); }
//Retires a connection for re-use static void ICACHE_FLASH_ATTR httpdRetireConn(HttpdConnData *conn) { uint32 dt = conn->startTime; if (dt > 0) dt = (system_get_time() - dt)/1000; os_printf("%s Closed, took %ums, heap=%ld\n", connStr, dt, (unsigned long)system_get_free_heap_size()); if (conn->post->buff!=NULL) os_free(conn->post->buff); conn->post->buff=NULL; conn->cgi=NULL; conn->conn=NULL; conn->remote_port = 0; conn->remote_ip[0] = 0; }
time_t mg_mgr_poll(struct mg_mgr *mgr, int timeout_ms) { int n = 0; time_t now = time(NULL); struct mg_connection *nc, *tmp; (void) timeout_ms; DBG(("begin poll, now=%u, hf=%u, sf lwm=%u", (unsigned int) now, system_get_free_heap_size(), 0U)); for (nc = mgr->active_connections; nc != NULL; nc = tmp) { struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; (void) cs; tmp = nc->next; n++; if (nc->flags & MG_F_CLOSE_IMMEDIATELY) { mg_close_conn(nc); continue; } mg_if_poll(nc, now); mg_if_timer(nc, now); if (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE) && !(nc->flags & MG_F_WANT_WRITE)) { mg_close_conn(nc); continue; } #ifdef SSL_KRYPTON if (nc->ssl != NULL && cs != NULL && cs->pcb.tcp != NULL && cs->pcb.tcp->state == ESTABLISHED) { if (((nc->flags & MG_F_WANT_WRITE) || nc->send_mbuf.len > 0) && cs->pcb.tcp->snd_buf > 0) { /* Can write more. */ if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { if (!(nc->flags & MG_F_CONNECTING)) mg_lwip_ssl_send(nc); } else { mg_lwip_ssl_do_hs(nc); } } if (cs->rx_chain != NULL) { if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { if (!(nc->flags & MG_F_CONNECTING)) mg_lwip_ssl_recv(nc); } else { mg_lwip_ssl_do_hs(nc); } } } else #endif /* SSL_KRYPTON */ { if (!(nc->flags & (MG_F_CONNECTING | MG_F_UDP))) { if (nc->send_mbuf.len > 0) mg_lwip_send_more(nc); } } } DBG(("end poll, %d conns", n)); return now; }
/****************************************************************************** * FunctionName : user_init * Description : entry of user application, init user function here * Parameters : none * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR user_init(void) { if(eraminfo.size > 0) os_printf("Found free IRAM: base: %p, size: %d bytes\n", eraminfo.base, eraminfo.size); os_printf("System memory:\n"); system_print_meminfo(); os_printf("bssi : 0x%x ~ 0x%x, len: %d\n", &_lit4_start, &_lit4_end, (uint32)(&_lit4_end) - (uint32)(&_lit4_start)); os_printf("free : 0x%x ~ 0x%x, len: %d\n", (uint32)(&_lit4_end), (uint32)(eraminfo.base) + eraminfo.size, (uint32)(eraminfo.base) + eraminfo.size - (uint32)(&_lit4_end)); os_printf("Start 'heap' size: %d bytes\n", system_get_free_heap_size()); os_printf("Set CPU CLK: %u MHz\n", ets_get_cpu_frequency()); system_deep_sleep_set_option(0); wifi_set_event_handler_cb(wifi_handle_event_cb); system_init_done_cb(init_done_cb); }
EXP_FUNC void * ICACHE_FLASH_ATTR ax_zalloc(size_t s, const char* file, int line) { void *x; if ((x = (void*)zalloc(s)) == NULL) exit_now("out of memory %s %d\n", file, line); else { debug_now("%s %d point[%p] size[%d] heap[%d]\n", file, line, x, s, system_get_free_heap_size()); //add_mem_info(x, s, file, line); } return x; }
dce_result_t SECTION_ATTR dce_handle_GMEM(dce_t* dce, void* group_ctx, int kind, size_t argc, arg_t* argv) { char line[12]; int length = sprintf(line, "%d", system_get_free_heap_size()); dce_emit_information_response(dce, line, length); int debug_enabled = uart_get_debug(); uart_set_debug(1); system_print_meminfo(); uart_set_debug(debug_enabled); dce_emit_basic_result_code(dce, DCE_RC_OK); }
/****************************************************************************** * FunctionName : mesh_EnableCb * Description : callback func for espconn_mesh_enable enable callback will only be called if the device has already joined a mesh network *******************************************************************************/ void ICACHE_FLASH_ATTR mesh_EnableCb() { mesh_StopCheckTimer(); _LINE_DESP(); MESH_INFO("TEST IN MESH ENABLE CB\r\n"); MESH_INFO("%s\n", __func__); MESH_INFO("HEAP: %d \r\n",system_get_free_heap_size()); _LINE_DESP(); if(LightMeshProc.mesh_suc_cb){ LightMeshProc.mesh_suc_cb(NULL); } }
EXP_FUNC void * ICACHE_FLASH_ATTR ax_calloc(size_t n, size_t s, const char* file, int line) { void *x; //unsigned total_size =0; if ((x = calloc(n, s)) == NULL) exit_now("out of memory %s %d\n", file, line); else { debug_now("%s %d point[%p] size[%d] heap[%d]\n", file, line, x, s, system_get_free_heap_size()); //total_size = n * s; //add_mem_info (x, total_size, file, line); } return x; }
void ICACHE_FLASH_ATTR dhsender_queue_init() { mQueueMaxSize = (system_get_free_heap_size() - MEMORY_RESERVER) / sizeof(DHSENDER_QUEUE); if(mQueueMaxSize > MAX_QUEUE_LENGTH) mQueueMaxSize = MAX_QUEUE_LENGTH; mQueue = (DHSENDER_QUEUE *)os_malloc(mQueueMaxSize * sizeof(DHSENDER_QUEUE)); if(mQueue == 0) { dhdebug("ERROR: can not allocate memory for queue"); } else { if(mQueueMaxSize < 10) dhdebug("Warning: queue is very shot - %u", mQueueMaxSize); else dhdebug("Queue created, size %u", mQueueMaxSize); } }
static void ICACHE_FLASH_ATTR MQTT_exit(MQTT_Client *client) { if(client == NULL) { return; } if(client->host != NULL) { os_free(client->host); client->host = NULL; } if(client->connect_info.password != NULL) { os_free(client->connect_info.password); client->connect_info.password = NULL; } if(client->connect_info.client_id != NULL) { os_free(client->connect_info.client_id); client->connect_info.client_id = NULL; } if(client->connect_info.username != NULL) { os_free(client->connect_info.username); client->connect_info.username = NULL; } if(client->mqtt_state.in_buffer != NULL) { os_free(client->mqtt_state.in_buffer); client->mqtt_state.in_buffer = NULL; } if(client->mqtt_state.out_buffer != NULL) { os_free(client->mqtt_state.out_buffer); client->mqtt_state.out_buffer = NULL; } if(client->msgQueue.buf != NULL) { os_free(client->msgQueue.buf); client->msgQueue.buf = NULL; } INFO("mqtt exit:\n"); INFO("available heap size:%d\n", system_get_free_heap_size()); if(client->errorCb != NULL) { (client->errorCb)((uint32_t*)client); } }
void ICACHE_FLASH_ATTR init_done_cb(void) { os_printf("\nSDK Init - Ok\nCurrent 'heap' size: %d bytes\n", system_get_free_heap_size()); #ifdef USE_WEB web_fini(inifname); #endif switch(system_get_rst_info()->reason) { case REASON_SOFT_RESTART: case REASON_DEEP_SLEEP_AWAKE: break; default: New_WiFi_config(WIFI_MASK_ALL); break; } }
//////////////////// // make html footer //////////////////// String MakeHTTPFooter() { String sResponse; sResponse = F("<FONT SIZE=-2><BR>Aufrufzähler="); sResponse += ulReqcount; sResponse += F(" - Verbindungszähler="); sResponse += ulReconncount; sResponse += F(" - Freies RAM="); sResponse += (uint32_t)system_get_free_heap_size(); sResponse += F(" - Max. Datenpunkte="); sResponse += ulNoMeasValues; sResponse += F("<BR>SMASE 03/2016 | Tobias Winter -> Mail: [email protected] <BR></body></html>"); return (sResponse); }
/* ====================================================================== Function: getSpiffsJSONData Purpose : Return JSON string containing list of SPIFFS files Input : Response String Output : - Comments: - ====================================================================== */ void getSpiffsJSONData(String & response) { char buffer[32]; bool first_item = true; // Json start response = FPSTR(FP_JSON_START); // Files Array response += F("\"files\":[\r\n"); // Loop trough all files Dir dir = SPIFFS.openDir("/"); while (dir.next()) { String fileName = dir.fileName(); size_t fileSize = dir.fileSize(); if (first_item) first_item=false; else response += ","; response += F("{\"na\":\""); response += fileName.c_str(); response += F("\",\"va\":\""); response += fileSize; response += F("\"}\r\n"); } response += F("],\r\n"); // SPIFFS File system array response += F("\"spiffs\":[\r\n{"); // Get SPIFFS File system informations FSInfo info; SPIFFS.info(info); response += F("\"Total\":"); response += info.totalBytes ; response += F(", \"Used\":"); response += info.usedBytes ; response += F(", \"ram\":"); response += system_get_free_heap_size() ; response += F("}\r\n]"); // Json end response += FPSTR(FP_JSON_END); }
int ICACHE_FLASH_ATTR alink_get_debuginfo(info_type type, char *status) { int used; switch (type) { case MEMUSED: used = 100 - ((system_get_free_heap_size() * 100) / (96 * 1024)); sprintf(status, "%d%%", used); break; case WIFISTRENGTH: sprintf(status, "%ddB", wifi_station_get_rssi()); break; default: status[0] = '\0'; break; } return 0; }
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); }
// Handle system information variables and print their value, returns the number of // characters appended to buff int ICACHE_FLASH_ATTR printGlobalInfo(char *buff, int buflen, char *token) { if (TOKEN("si_chip_id")) { return os_sprintf(buff, "0x%x", system_get_chip_id()); } else if (TOKEN("si_freeheap")) { return os_sprintf(buff, "%dKB", system_get_free_heap_size()/1024); } else if (TOKEN("si_uptime")) { uint32 t = system_get_time() / 1000000; // in seconds return os_sprintf(buff, "%dd%dh%dm%ds", t/(24*3600), (t/(3600))%24, (t/60)%60, t%60); } else if (TOKEN("si_boot_version")) { return os_sprintf(buff, "%d", system_get_boot_version()); } else if (TOKEN("si_boot_address")) { return os_sprintf(buff, "0x%x", system_get_userbin_addr()); } else if (TOKEN("si_cpu_freq")) { return os_sprintf(buff, "%dMhz", system_get_cpu_freq()); } else { return 0; } }
/** * Perform the main loop processing. * This is where work is performed * as often as possible. */ static void mainLoop() { if (suspendMainLoopFlag == true) { return; } jsiLoop(); #ifdef EPS8266_BOARD_HEARTBEAT if (system_get_time() - lastTime > 1000 * 1000 * 5) { lastTime = system_get_time(); os_printf("tick: %u, heap: %u\n", (uint32)(jshGetSystemTime()), system_get_free_heap_size()); } #endif // Setup for another callback //queueTaskMainLoop(); suspendMainLoop(0); // HACK to get around SDK 1.4 bug }
void ICACHE_FLASH_ATTR show_sysinfo() { uint32 chipid = system_get_chip_id(); uint32 heepsize = system_get_free_heap_size(); uint32 rtctime = system_get_rtc_time(); uint32 systime = system_get_time(); os_printf("\n\nSDK version: [%s]\n", system_get_sdk_version()); os_printf("SYSTEM INIT OVER\n"); os_printf("==========SYS INFO==========\n"); system_print_meminfo(); os_printf("CHIP ID: [%d]\n", chipid); os_printf("HEAP SIZE: [%d]\n", heepsize); os_printf("RTC TIME: [%d]\n", rtctime); os_printf("SYS TIME: [%d]\n", systime); os_printf("==========SYS INFO==========\n"); }
//Template code for the counter on the index page. void ICACHE_FLASH_ATTR tplCounter(HttpdConnData *connData, char *token, void **arg) { char buff[128]; if (token==NULL) return; if (os_strcmp(token, "counter")==0) { hitCounter++; os_sprintf(buff, "%ld", hitCounter); } if (os_strcmp(token, "freeheap")==0) { os_sprintf(buff,"Free heap size:%d\n",system_get_free_heap_size()); } if (os_strcmp(token, "fwver")==0) { os_sprintf(buff,"%s",FWVER); } httpdSend(connData, buff, -1); }
void wsConnected(WebSocket& socket) { totalActiveSockets++; lastPositionMessage = ""; // Notify everybody about new connection uint8 slotNo = rboot_get_current_rom(); String slotNoStr = String(slotNo); uint32 heapSize = system_get_free_heap_size(); String heapSizeStr = String(heapSize); WebSocketsList &clients = server.getActiveWebSockets(); for (int i = 0; i < clients.count(); i++) { clients[i].sendString( "Connected to station: " + wifi_sid.get(currWifiIndex) + ", ROM:" + slotNoStr + ", heapSize: " + heapSizeStr + ", appVer:1.22, SDK version: " + system_get_sdk_version()); } }
/****************************************************************************** * FunctionName : user_init * Description : entry of user application, init user function here * Parameters : none * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR user_init(void) { sys_read_cfg(); if(!syscfg.cfg.b.debug_print_enable) system_set_os_print(0); GPIO0_MUX = VAL_MUX_GPIO0_SDK_DEF; GPIO4_MUX = VAL_MUX_GPIO4_SDK_DEF; GPIO5_MUX = VAL_MUX_GPIO5_SDK_DEF; GPIO12_MUX = VAL_MUX_GPIO12_SDK_DEF; GPIO13_MUX = VAL_MUX_GPIO13_SDK_DEF; GPIO14_MUX = VAL_MUX_GPIO14_SDK_DEF; GPIO15_MUX = VAL_MUX_GPIO15_SDK_DEF; // vad7 //power_meter_init(); // //uart_init(); // in tcp2uart.h system_timer_reinit(); #if (DEBUGSOO > 0 && defined(USE_WEB)) os_printf("\nSimple WEB version: " WEB_SVERSION "\n"); #endif //if(syscfg.cfg.b.pin_clear_cfg_enable) test_pin_clr_wifi_config(); // сброс настроек, если замкнут пин RX set_cpu_clk(); // select cpu frequency 80 or 160 MHz #ifdef USE_GDBSTUB extern void gdbstub_init(void); gdbstub_init(); #endif #if DEBUGSOO > 0 if(eraminfo.size > 0) os_printf("Found free IRAM: base: %p, size: %d bytes\n", eraminfo.base, eraminfo.size); os_printf("System memory:\n"); system_print_meminfo(); os_printf("bssi : 0x%x ~ 0x%x, len: %d\n", &_lit4_start, &_lit4_end, (uint32)(&_lit4_end) - (uint32)(&_lit4_start)); os_printf("free : 0x%x ~ 0x%x, len: %d\n", (uint32)(&_lit4_end), (uint32)(eraminfo.base) + eraminfo.size, (uint32)(eraminfo.base) + eraminfo.size - (uint32)(&_lit4_end)); os_printf("Start 'heap' size: %d bytes\n", system_get_free_heap_size()); #endif #if DEBUGSOO > 0 os_printf("Set CPU CLK: %u MHz\n", ets_get_cpu_frequency()); #endif Setup_WiFi(); WEBFSInit(); // файловая система system_deep_sleep_set_option(0); system_init_done_cb(init_done_cb); }
void esp_uart_print_status(void *arg) { struct esp_uart_state *us = (struct esp_uart_state *) arg; struct esp_uart_stats *s = &us->stats; struct esp_uart_stats *ps = &us->prev_stats; int uart_no = us->cfg->uart_no; fprintf( stderr, "UART%d ints %u/%u/%u; rx en %d bytes %u buf %u fifo %u, ovf %u, lcs %u; " "tx %u %u %u, thr %u; hf %u i 0x%03x ie 0x%03x cts %d\n", uart_no, s->ints - ps->ints, s->rx_ints - ps->rx_ints, s->tx_ints - ps->tx_ints, us->rx_enabled, s->rx_bytes - ps->rx_bytes, us->rx_buf.used, rx_fifo_len(us->cfg->uart_no), s->rx_overflows - ps->rx_overflows, s->rx_linger_conts - ps->rx_linger_conts, s->tx_bytes - ps->tx_bytes, us->tx_buf.used, tx_fifo_len(us->cfg->uart_no), s->tx_throttles - ps->tx_throttles, system_get_free_heap_size(), READ_PERI_REG(UART_INT_RAW(uart_no)), READ_PERI_REG(UART_INT_ENA(uart_no)), cts(uart_no)); memcpy(ps, s, sizeof(*s)); }
void ICACHE_FLASH_ATTR user_event_progress(uint8 progress) { LOCAL uint8 prev = 0; uint32 heap = system_get_free_heap_size(); if (abs(progress - prev) < 3 || heap < 5000) { return; } prev = progress; char status[WEBSERVER_MAX_VALUE]; char progress_str[WEBSERVER_MAX_VALUE]; json_status(status, ESP8266, json_sprintf(progress_str, "Progress: %d\%", progress), NULL); #if EVENTS_DEBUG debug("EVENTS: Progress [%d]\n", progress); #endif char event[WEBSERVER_MAX_VALUE + os_strlen(webserver_chunk_url()) + os_strlen(status)]; user_event_build(event, webserver_chunk_url(), status); websocket_send_message(EVENTS_URL, event, NULL); }
void mainsetup() { // setup globals ulReqcount = 0; ulReconncount = 0; WiFiStart(); delay(1); server.begin(); // allocate ram for data storage uint32_t free = system_get_free_heap_size() - KEEP_MEM_FREE; ulNoMeasValues = free / (sizeof(float) * 5 + sizeof(unsigned long)); // humidity & temp --> 2 + time pulTime = new unsigned long[ulNoMeasValues]; pfTemp1 = new float[ulNoMeasValues]; pfTemp2 = new float[ulNoMeasValues]; pfTemp3 = new float[ulNoMeasValues]; pfTemp4 = new float[ulNoMeasValues]; if (pulTime == NULL || pfTemp1 == NULL || pfTemp2 == NULL || pfTemp3 == NULL || pfTemp4 == NULL) { ulNoMeasValues = 0; Serial.println("Error in memory allocation!"); } else { Serial.print("Allocated storage for "); Serial.print(ulNoMeasValues); Serial.println(" data points."); float fMeasDelta_sec = MEAS_SPAN_H * 3600. / ulNoMeasValues; ulMeasDelta_ms = ( (unsigned long)(fMeasDelta_sec + 0.5) ) * 1000; // round to full sec Serial.print("Measurements will happen each "); Serial.print(ulMeasDelta_ms); Serial.println(" ms."); ulNextMeas_ms = millis() + ulMeasDelta_ms; } }
void ShowInfo() { Serial.printf("\r\nSDK: v%s\r\n", system_get_sdk_version()); Serial.printf("Free Heap: %d\r\n", system_get_free_heap_size()); Serial.printf("CPU Frequency: %d MHz\r\n", system_get_cpu_freq()); Serial.printf("System Chip ID: %x\r\n", system_get_chip_id()); Serial.printf("SPI Flash ID: %x\r\n", spi_flash_get_id()); //Serial.printf("SPI Flash Size: %d\r\n", (1 << ((spi_flash_get_id() >> 16) & 0xff))); Vector<String> files = fileList(); if (files.count() > 0) { Serial.println("\n\rSpiff files:"); Serial.println("----------------------------"); { for (int i = 0; i < files.count(); i++) { Serial.println(files[i]); } } Serial.println("----------------------------"); } else { Serial.println("Empty spiffs!"); } }
static void disp_task(void *params) { struct mg_connection *conn = NULL; struct conn_ctx ctx; printf("Starting network test...\n"); memset(data, 'A', sizeof(data)); memset(&ctx, 0, sizeof(ctx)); wifi_connect(); int i = 0; while (1) { mongoose_poll(2); if (!wifi_connected) continue; switch (ctx.state) { case DISCONNECTED: memset(&ctx, 0, sizeof(ctx)); conn = mg_connect(&sj_mgr, ADDR_TO_CONNECT, conn_handler); if (conn == NULL) { vTaskDelay(100); printf("reconnecting\n"); continue; } printf("conn = %p\n", conn); conn->user_data = &ctx; ctx.state = CONNECTING; break; case CONNECTING: break; case CONNECTED: i++; if (i % 10000 == 0) { printf("sent %u, recv %u heap free: %u uptime %d\n", ctx.num_sent, ctx.num_received, system_get_free_heap_size(), system_get_time() / 1000000); } break; } } }