void setup_server ( void ) { register struct espconn *c = &server_conn; char *x; c->type = ESPCONN_TCP; c->state = ESPCONN_NONE; my_tcp_conn.local_port=88; c->proto.tcp=&my_tcp_conn; espconn_regist_reconcb ( c, tcp_reconnect_cb); espconn_regist_connectcb ( c, tcp_connect_cb); espconn_regist_disconcb ( c, tcp_disconnect_cb); if ( espconn_accept(c) != ESPCONN_OK ) { os_printf("Error starting server %d\n", 0); return; } /* Interval in seconds to timeout inactive connections */ espconn_regist_time(c, 20, 0); // x = (char *) os_zalloc ( 4 ); // os_printf ( "Got mem: %08x\n", x ); os_printf ( "Server ready\n" ); }
void user_init() { #ifdef ESP8266_GDBSTUB gdbstub_init(); #endif //Uncomment the line below if you want to step through the initialization function in the debugger without getting a reset from a watchdog. //system_soft_wdt_stop(); struct ip_info info; struct softap_config cfg; wifi_softap_get_config(&cfg); strcpy((char *)cfg.ssid, "$$com.sysprogs.esp8266.http.ssid$$"); cfg.ssid_len = strlen((char*)cfg.ssid); wifi_softap_set_config_current(&cfg); wifi_set_opmode(SOFTAP_MODE); wifi_softap_dhcps_stop(); IP4_ADDR(&info.ip, 192, 168, $$com.sysprogs.esp8266.http.subnet$$, 1); IP4_ADDR(&info.gw, 192, 168, $$com.sysprogs.esp8266.http.subnet$$, 1); IP4_ADDR(&info.netmask, 255, 255, 255, 0); wifi_set_ip_info(SOFTAP_IF, &info); dhcps_lease_test(); wifi_softap_dhcps_start(); static struct espconn httpdConn; static esp_tcp httpdTcp; httpdConn.type = ESPCONN_TCP; httpdConn.state = ESPCONN_NONE; httpdTcp.local_port = 80; httpdConn.proto.tcp = &httpdTcp; espconn_regist_connectcb(&httpdConn, httpdConnectCb); espconn_accept(&httpdConn); }
void user_init(void) { //gpio_init(); uart_init(BIT_RATE_115200, BIT_RATE_115200); int at_wifiMode = wifi_get_opmode(); uart0_sendStr("\r\nCustom Server\r\n"); wifi_set_opmode( 2 ); //We broadcast our ESSID, wait for peopel to join. pTcpServer = (struct espconn *)os_zalloc(sizeof(struct espconn)); pTcpServer->type = ESPCONN_TCP; pTcpServer->state = ESPCONN_NONE; pTcpServer->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp)); pTcpServer->proto.tcp->local_port = PORT; espconn_regist_connectcb(pTcpServer, at_tcpserver_listen); espconn_accept(pTcpServer); espconn_regist_time(pTcpServer, SERVER_TIMEOUT, 0); printf("Hello, world. Starting server.\n" ); InitDumbcraft(); os_sprintf( my_server_name, "ESP8266Dumb" ); system_os_task(at_procTask, at_procTaskPrio, at_procTaskQueue, at_procTaskQueueLen); uart0_sendStr("\r\nCustom Server\r\n"); system_os_post(at_procTaskPrio, 0, 0 ); }
void TcpServer::listen() { LOGF(" Listen on port : %d ", _local_port); if (espconn_accept(_conn) != ESPCONN_OK) { LOGF("ERR : espconn_accept"); } espconn_regist_connectcb(_conn, connectCb); }
void user_init(void) { uart_init(BIT_RATE_115200, BIT_RATE_115200); int at_wifiMode = wifi_get_opmode(); uart0_sendStr("\r\nCustom Server\r\n"); wifi_set_opmode( 2 ); //We broadcast our ESSID, wait for peopel to join. pUdpServer = (struct espconn *)os_zalloc(sizeof(struct espconn)); if (pUdpServer == NULL) { uart0_sendStr("UdpServer Failure\r\n"); return; } pUdpServer->type = ESPCONN_UDP; pUdpServer->state = ESPCONN_NONE; pUdpServer->proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp)); pUdpServer->proto.udp->local_port = PORT; pUdpServer->reverse = NULL; espconn_regist_recvcb(pUdpServer, at_udpserver_recv); espconn_accept(pUdpServer); char outbuffer[] = { 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff }; WS2812OutBuffer( outbuffer, sizeof(outbuffer) ); system_os_task(at_procTask, at_procTaskPrio, at_procTaskQueue, at_procTaskQueueLen); uart0_sendStr("\r\nCustom Server\r\n"); system_os_post(at_procTaskPrio, 0, 0 ); }
void ICACHE_FLASH_ATTR tcpserver_init(void) { int8_t res; tcp_server.type = ESPCONN_TCP; tcp_server.state = ESPCONN_NONE; tcp_server.proto.tcp = &tcp_config; tcp_server.proto.tcp->local_port = TCP_SERVER_LOCAL_PORT; espconn_regist_connectcb(&tcp_server, incoming_connection_callback); espconn_tcp_set_max_con_allow(&tcp_server, 1); //Allow 1 connection max res = espconn_accept(&tcp_server); if(res == 0) os_printf("Created TCP server on port %d, running on ROM %d, AP RSSI: %ddBm, WiFi mode: %d.\r\n", tcp_server.proto.tcp->local_port, system_upgrade_userbin_check(), wifi_station_get_rssi(), wifi_get_phy_mode()); else os_printf("Failed to create TCP server, error code: %d.\r\n", res); }
void ICACHE_FLASH_ATTR http_ws_server_start(){ NODE_DBG("Websocket server start, conn=%p", &ws_config.server_conn); espconn_regist_connectcb(&ws_config.server_conn, http_ws_connect_callback); espconn_accept(&ws_config.server_conn); }
void start_http_eval_server() { printf("\nStarting HTTP eval server\n"); server.type = ESPCONN_TCP; server.proto.tcp = &server_tcp; server_tcp.local_port = 80; espconn_regist_connectcb(&server, server_connect_cb); espconn_accept(&server); }
void ICACHE_FLASH_ATTR serverConnect(void) { sint8 res; res = espconn_regist_connectcb(serverConn, serverConnectCb); DBG_MSG("espconn_regist_connectcb, res: %d\r\n", res); res = espconn_accept(serverConn); DBG_MSG("espconn_accept, res: %d\r\n", res); res = espconn_regist_time(serverConn, SERVER_TIMEOUT, 0); DBG_MSG("espconn_regist_time, res: %d\r\n", res); }
void ICACHE_FLASH_ATTR setup_server() { server.type = ESPCONN_TCP; server.state = ESPCONN_NONE; server.proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp)); server.proto.tcp->local_port = 80; espconn_regist_connectcb(&server, tcpserver_connectcb); espconn_accept(&server); espconn_regist_time(&server, server_timeover, 0); }
//Initialize listening socket, do general initialization void ICACHE_FLASH_ATTR httpdPlatInit(int port, int maxConnCt) { httpdConn.type=ESPCONN_TCP; httpdConn.state=ESPCONN_NONE; httpdTcp.local_port=port; httpdConn.proto.tcp=&httpdTcp; espconn_regist_connectcb(&httpdConn, platConnCb); espconn_accept(&httpdConn); espconn_regist_time(&httpdConn, HTTPD_CONN_TIMEOUT, 0); // Configure timeout espconn_tcp_set_max_con_allow(&httpdConn, (uint8) maxConnCt); }
void start_data_gen_server(int port) { struct espconn *server = (struct espconn *) calloc(1, sizeof(*server)); esp_tcp *tcp = (esp_tcp *) calloc(1, sizeof(*tcp)); server->type = ESPCONN_TCP; server->proto.tcp = tcp; tcp->local_port = port; espconn_regist_connectcb(server, echo_connect_cb); espconn_accept(server); }
LOCAL void ICACHE_FLASH_ATTR setupTCP() { conn1.type = ESPCONN_TCP; conn1.state = ESPCONN_NONE; tcp1.local_port = 8080; conn1.proto.tcp = &tcp1; espconn_accept(&conn1); espconn_create(&conn1); espconn_regist_connectcb(&conn1, recvCB); //espconn_regist_recvcb(&conn1, recvCB); os_printf("Listening for data\n"); } // End of setupUDP
void ICACHE_FLASH_ATTR user_tcpserver_init(uint32 port) { esp_conn.type = ESPCONN_TCP; esp_conn.state = ESPCONN_NONE; esp_conn.proto.tcp = &esptcp; esp_conn.proto.tcp->local_port = port; espconn_regist_connectcb(&esp_conn, tcpserver_listen); sint8 ret = espconn_accept(&esp_conn); os_printf("ESP listen to incoming tcp connections [%d]!\r\n", ret); }
/** @brief Accept an incomming connection, setup connect_callback @param[in] *esp_config, ESP8266 network type an mode configuration structure @param[in] *esp_tcp_config, network protocol structure @param[in] port, network port to listen on @param[in] connect_callback: connection callback function pointer @return void */ MEMSPACE static void tcp_accept(struct espconn *esp_config, esp_tcp *esp_tcp_config, uint16_t port, void (*connect_callback)(struct espconn *)) { memset(esp_tcp_config, 0, sizeof(*esp_tcp_config)); esp_tcp_config->local_port = port; memset(esp_config, 0, sizeof(*esp_config)); esp_config->type = ESPCONN_TCP; esp_config->state = ESPCONN_NONE; esp_config->proto.tcp = esp_tcp_config; espconn_regist_connectcb(esp_config, (espconn_connect_callback)connect_callback); espconn_accept(esp_config); espconn_tcp_set_max_con_allow(esp_config, 1); }
void ICACHE_FLASH_ATTR dhap_httpd_init() { struct espconn *httpdConn = (struct espconn *)os_zalloc(sizeof(struct espconn )); esp_tcp *httpdTcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp)); httpdConn->type = ESPCONN_TCP; httpdConn->state = ESPCONN_NONE; httpdTcp->local_port = HTTPD_PORT; httpdConn->proto.tcp = httpdTcp; espconn_regist_connectcb(httpdConn, dhap_httpd_connect_cb); espconn_regist_reconcb(httpdConn, dhap_httpd_reconnect_cb); sint8 res = espconn_accept(httpdConn); if(res) dhdebug("espconn_accept returned: %d", res); }
void esp8266_tcp_stream_bind(lws_sockfd_type fd, int port, struct lws *wsi) { fd->proto.tcp->local_port = port; fd->reverse = wsi; hacky_context = wsi->context; espconn_regist_connectcb(fd, esp8266_cb_connect); /* hmmm it means, listen() + accept() */ espconn_accept(fd); espconn_tcp_set_max_con_allow(fd, 10); }
static int do_listen(int argc, const char* argv[]) { int port = skip_atoi(&argv[1]); console_printf("Listening (TCP) on port %d\n", port); esp_conn.type = ESPCONN_TCP; esp_conn.state = ESPCONN_NONE; esp_conn.proto.tcp = &esptcp; esp_conn.proto.tcp->local_port = port; espconn_regist_connectcb(&esp_conn, webserver_listen); espconn_accept(&esp_conn); linebuffer = os_malloc(LINEBUFFER_SIZE); lineptr = 0; console_lock(1); }
void ICACHE_FLASH_ATTR websocketdInit(int port, WSOnConnection onConnection) { wsOnConnectionCallback = onConnection; wsConn.type = ESPCONN_TCP; wsConn.state = ESPCONN_NONE; wsTcp.local_port = port; wsConn.proto.tcp = &wsTcp; espconn_regist_connectcb(&wsConn, wsConnectCb); espconn_accept(&wsConn); espconn_regist_time(&wsConn, CONN_TIMEOUT, 0); }
void ICACHE_FLASH_ATTR user_server_init(uint32 port) { LOCAL struct espconn esp_conn; LOCAL esp_tcp esptcp; esp_conn.type = ESPCONN_TCP; esp_conn.state = ESPCONN_NONE; esp_conn.proto.tcp = &esptcp; esp_conn.proto.tcp->local_port = port; espconn_regist_connectcb(&esp_conn, server_listen); espconn_accept(&esp_conn); }
void ICACHE_FLASH_ATTR httpdInit(HttpdBuiltInUrl *fixedUrls, int port) { int i; for (i=0; i<MAX_CONN; i++) { connData[i].conn=NULL; } httpdConn.type=ESPCONN_TCP; httpdConn.state=ESPCONN_NONE; httpdTcp.local_port=port; httpdConn.proto.tcp=&httpdTcp; builtInUrls=fixedUrls; os_printf("Httpd init, conn=%p\n", &httpdConn); espconn_regist_connectcb(&httpdConn, httpdConnectCb); espconn_accept(&httpdConn); }
LOCAL ICACHE_FLASH_ATTR void webserver_start(int port) { LOCAL struct espconn esp_conn; LOCAL esp_tcp esptcp; esp_conn.type = ESPCONN_TCP; esp_conn.state = ESPCONN_NONE; esp_conn.proto.tcp = &esptcp; esp_conn.proto.tcp->local_port = port; os_printf("tcp port:%d\n", port); espconn_regist_connectcb(&esp_conn, webserver_listen);//web有连接时调用webserver_listen espconn_accept(&esp_conn); // os_timer_setfn(&led_timer,yeelinkget,NULL); // os_timer_arm(&led_timer,15000,1); }
//*********************************************************************** void ICACHE_FLASH_ATTR webSocketInit( void ) { webSocketConn.type = ESPCONN_TCP; webSocketConn.state = ESPCONN_NONE; webSocketConn.proto.tcp = &webSocketTcp; webSocketConn.proto.tcp->local_port = WEB_SOCKET_PORT; espconn_regist_connectcb(&webSocketConn, webSocketConnectCb); espconn_set_opt( &webSocketConn, ESPCONN_NODELAY ); // remove nagle for low latency sint8 ret = espconn_accept(&webSocketConn); if ( ret == 0 ) webSocketDebug("webSocket server established on port %d\n", WEB_SOCKET_PORT ); else webSocketDebug("webSocket server on port %d FAILED ret=%d\n", WEB_SOCKET_PORT, ret); return; }
void ICACHE_FLASH_ATTR user_server_init(uint32 port) { esp_conn.type = ESPCONN_TCP; esp_conn.state = ESPCONN_NONE; esp_conn.proto.tcp = &esptcp; esp_conn.proto.tcp->local_port = port; espconn_regist_connectcb(&esp_conn, server_listen); espconn_regist_time(&esp_conn, 65535, 0); #ifdef SERVER_SSL_ENABLE espconn_secure_accept(&esp_conn); #else espconn_accept(&esp_conn); #endif }
// method socket.listen(backlog) STATIC mp_obj_t esp_socket_listen(mp_obj_t self_in, mp_obj_t backlog) { esp_socket_obj_t *s = self_in; if (esp_socket_listening != NULL) { nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "only one espconn can listen at a time")); } esp_socket_listening = s; s->connlist = mp_obj_new_list(0, NULL); espconn_regist_connectcb(s->espconn, esp_socket_connect_callback_server); espconn_accept(s->espconn); espconn_regist_time(s->espconn, 1500, 0); return mp_const_none; }
void httpd_init() { static struct espconn httpdconn; static esp_tcp httpdtcp; memset(&httpdconn,0,sizeof(struct espconn)); memset(&httpdtcp,0,sizeof(esp_tcp)); httpdconn.type=ESPCONN_TCP; httpdconn.state=ESPCONN_NONE; httpdtcp.local_port=HTTPD_PORT; httpdconn.proto.tcp=&httpdtcp; espconn_regist_connectcb(&httpdconn, httpd_connect_callback); espconn_accept(&httpdconn); #ifdef PLATFORM_DEBUG ets_uart_printf("HTTP server init done.\r\n"); #endif }
void ICACHE_FLASH_ATTR ssServerInit() { struct espconn * pSimpleServer; pSimpleServer = (struct espconn *)os_zalloc(sizeof(struct espconn)); ets_memset( pSimpleServer, 0, sizeof( struct espconn ) ); espconn_create( pSimpleServer ); pSimpleServer->type = ESPCONN_TCP; pSimpleServer->state = ESPCONN_NONE; pSimpleServer->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp)); pSimpleServer->proto.tcp->local_port = 80; //espconn_set_opt(pSimpleServer, ESPCONN_REUSEADDR); espconn_regist_connectcb(pSimpleServer, ssConnCb); espconn_accept(pSimpleServer); espconn_regist_time(pSimpleServer, 0, 0); }
void ICACHE_FLASH_ATTR createServer() { init_slots(); fifo_init(msg_queue, SENT_QUEUE_LENGTH); pTcpServer = (struct espconn *) os_zalloc(sizeof(struct espconn)); if (pTcpServer == NULL) { debug_print_str_uart("TcpServer Failure\r\n"); return; } debug_print_str_uart("createServer \n\r"); pTcpServer->type = ESPCONN_TCP; pTcpServer->state = ESPCONN_NONE; pTcpServer->proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp)); pTcpServer->proto.tcp->local_port = 300; espconn_regist_connectcb(pTcpServer, at_tcpserver_listen); espconn_accept(pTcpServer); espconn_regist_time(pTcpServer, 180, 0); }
void ICACHE_FLASH_ATTR tfp_open_connection(void) { // Common initialisations. ringbuffer_init(&tfp_rb, tfp_rb_buffer, TFP_RING_BUFFER_SIZE); brickd_init(); com_init(); for(uint8_t i = 0; i < TFP_MAX_CONNECTIONS; i++) { tfp_init_con(i); } /* * When mesh mode is enabled all the socket setup is done from mesh specific * callbacks. Existing TFP socket callbacks and implementation are used but as * a layer underneath the mesh layer. */ if(!configuration_current.mesh_enable) { ets_memset(&tfp_con_listen, 0, sizeof(struct espconn)); // Initialize the ESPConn espconn_create(&tfp_con_listen); tfp_con_listen.type = ESPCONN_TCP; tfp_con_listen.state = ESPCONN_NONE; // Make it a TCP connection tfp_con_listen.proto.tcp = &tfp_con_listen_tcp; tfp_con_listen.proto.tcp->local_port = configuration_current.general_port; espconn_regist_reconcb(&tfp_con_listen, tfp_reconnect_callback); espconn_regist_connectcb(&tfp_con_listen, tfp_connect_callback); // Start listening espconn_accept(&tfp_con_listen); // Set server timeout (in seconds) espconn_regist_time(&tfp_con_listen, 7200, 0); } else { logi("MSH:TFP init\n"); } }
bool ICACHE_FLASH_ATTR tcp_listen(unsigned int port) { int ret; httpConn.type = ESPCONN_TCP; httpConn.state = ESPCONN_NONE; httpConn.proto.tcp = &httpTcp; httpConn.proto.tcp->local_port = port; espconn_regist_connectcb(&httpConn, tcp_connect_cb); espconn_regist_reconcb(&httpConn, tcp_reconnect_cb); espconn_regist_disconcb(&httpConn, tcp_disconnect_cb); ret = espconn_accept(&httpConn); espconn_regist_time(&httpConn, 15, 0); //timeout if (ret != ESPCONN_OK) { TESTP("Error when starting the listener: %d.\n", ret); ets_delay_us(2000); return false; } return true; }