// method socket.connect(address)
STATIC mp_obj_t esp_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
esp_socket_obj_t *s = self_in;
if (s->espconn == NULL || s->espconn->state != ESPCONN_NONE) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"transport endpoint is already connected or closed"));
}
espconn_regist_connectcb(s->espconn, esp_socket_connect_callback_client);
espconn_regist_recvcb(s->espconn, esp_socket_recv_callback);
espconn_regist_sentcb(s->espconn, esp_socket_sent_callback);
espconn_regist_disconcb(s->espconn, esp_socket_disconnect_callback);
s->espconn->proto.tcp->remote_port =
netutils_parse_inet_addr(addr_in, s->espconn->proto.tcp->remote_ip,
NETUTILS_BIG);
espconn_connect(s->espconn);
return mp_const_none;
}
//***********************************************************************
void ICACHE_FLASH_ATTR webSocketConnectCb(void *arg) {
struct espconn *connection = (espconn *)arg;
webSocketDebug("\n\nmeshWebSocket received connection !!!\n");
// set time out for this connection in seconds
espconn_regist_time( connection, 120, 1);
//find an empty slot
uint8_t slotId = 0;
while (wsConnections[slotId].connection != NULL && wsConnections[slotId].status != STATUS_CLOSED && slotId < WS_MAXCONN) {
slotId++;
}
webSocketDebug("websocketConnectCb slotId=%d\n", slotId);
if (slotId >= WS_MAXCONN) {
//no more free slots, close the connection
webSocketDebug("No more free slots for WebSockets!\n");
espconn_disconnect(connection);
return;
}
// webSocketDebug("websocketConnectCb2\n");
WSConnection wsConnection;
wsConnection.status = STATUS_UNINITIALISED;
wsConnection.connection = connection;
wsConnection.onMessage = wsOnMessageCallback;
wsConnections[slotId] = wsConnection;
// webSocketDebug("websocketConnectCb3\n");
espconn_regist_recvcb(connection, webSocketRecvCb);
espconn_regist_sentcb(connection, webSocketSentCb);
espconn_regist_reconcb(connection, webSocketReconCb);
espconn_regist_disconcb(connection, webSocketDisconCb);
// webSocketDebug("leaving websocketConnectCb\n");
}
void ICACHE_FLASH_ATTR init_dns()
{
//set softAP DHCP server router info
uint8_t mode = 1;
wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &mode);
//1:station; 2:soft-AP, 3:station+soft-AP
wifi_set_broadcast_if(3);
// espconn_disconnect(&dnsConn);
espconn_delete(&dnsConn);
dnsConn.type=ESPCONN_UDP;
dnsConn.state=ESPCONN_NONE;
dnsUdp.local_port= 53;
dnsConn.proto.udp=&dnsUdp;
espconn_regist_recvcb(&dnsConn, dnsQueryReceived);
int res = espconn_create(&dnsConn);
NODE_DBG("DNS server init, conn=%p , status=%d", &dnsConn,res);
}
/**
* @brief Callback from SDK that socket is connected
* @param arg: contain the ip link information
* @retval None
*/
static void ICACHE_FLASH_ATTR
mqtt_tcpclient_connect_cb(void* arg) {
struct espconn* pCon = (struct espconn *)arg;
MQTT_Client* client = (MQTT_Client *)pCon->reverse;
if (client == NULL) return; // aborted connection
espconn_regist_disconcb(client->pCon, mqtt_tcpclient_discon_cb);
espconn_regist_recvcb(client->pCon, mqtt_tcpclient_recv);
espconn_regist_sentcb(client->pCon, mqtt_tcpclient_sent_cb);
os_printf("MQTT: TCP connected to %s:%d\n", client->host, client->port);
// send MQTT connect message to broker
mqtt_msg_connect(&client->mqtt_connection, &client->connect_info);
PktBuf *buf = PktBuf_New(client->mqtt_connection.message.length);
os_memcpy(buf->data, client->mqtt_connection.message.data,
client->mqtt_connection.message.length);
buf->filled = client->mqtt_connection.message.length;
client->msgQueue = PktBuf_Unshift(client->msgQueue, buf); // prepend to send (rexmit) queue
mqtt_send_message(client);
client->connState = MQTT_CONNECTED; // v3.1.1 allows publishing while still connecting
}
static void ICACHE_FLASH_ATTR connect_callback(void * arg)
{
HTTP_DEBUG("Connected\n");
struct espconn * conn = (struct espconn *)arg;
request_args * req = (request_args *)conn->reverse;
espconn_regist_recvcb(conn, receive_callback);
espconn_regist_sentcb(conn, sent_callback);
const char * method = "GET";
char post_headers[32] = "";
if (req->post_data != NULL) { // If there is data this is a POST request.
method = "POST";
os_sprintf(post_headers, "Content-Length: %d\r\n", strlen(req->post_data));
}
char buf[69 + strlen(method) + strlen(req->path) + strlen(req->hostname) +
strlen(req->headers) + strlen(post_headers)];
char hostname[strlen(req->hostname)+7];
if (req->port != 80) {
os_sprintf(hostname, "%s:%d", req->hostname, req->port);
} else {
os_strcpy(hostname, req->hostname);
}
int len = os_sprintf(buf,
"%s %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n"
"User-Agent: ESP8266\r\n"
"%s"
"%s"
"\r\n",
method, req->path, hostname, req->headers, post_headers);
espconn_sent(conn, (uint8_t *)buf, len);
os_free(req->headers);
req->headers = NULL;
HTTP_DEBUG("Sending request header\n");
}
static void ICACHE_FLASH_ATTR
wifi_event_handler(System_Event_t *e)
{
switch (e->event) {
case EVENT_STAMODE_CONNECTED:
espconn_accept(&s_server_conn);
espconn_regist_recvcb(&s_server_conn, espconn_recv_handler);
break;
case EVENT_STAMODE_DISCONNECTED:
espconn_delete(&s_server_conn);
break;
case EVENT_STAMODE_GOT_IP:
case EVENT_STAMODE_DHCP_TIMEOUT:
case EVENT_STAMODE_AUTHMODE_CHANGE:
case EVENT_SOFTAPMODE_STACONNECTED:
case EVENT_SOFTAPMODE_STADISCONNECTED:
case EVENT_SOFTAPMODE_PROBEREQRECVED:
default: break;
}
}
static void net_socket_connected(void *arg)
{
NODE_DBG("net_socket_connected is called.\n");
struct espconn *pesp_conn = arg;
if(pesp_conn == NULL)
return;
lnet_userdata *nud = (lnet_userdata *)pesp_conn->reverse;
if(nud == NULL)
return;
// can receive and send data, even if there is no connected callback in lua.
espconn_regist_recvcb(pesp_conn, net_socket_received);
espconn_regist_sentcb(pesp_conn, net_socket_sent);
espconn_regist_disconcb(pesp_conn, net_socket_disconnected);
if(nud->cb_connect_ref == LUA_NOREF)
return;
if(nud->self_ref == LUA_NOREF)
return;
lua_rawgeti(gL, LUA_REGISTRYINDEX, nud->cb_connect_ref);
lua_rawgeti(gL, LUA_REGISTRYINDEX, nud->self_ref); // pass the userdata(client) to callback func in lua
lua_call(gL, 1, 0);
}
static void ICACHE_FLASH_ATTR
tcpclient_connect_cb(void *arg) {
struct espconn *pCon = (struct espconn *)arg;
RestClient* client = (RestClient *)pCon->reverse;
#ifdef REST_DBG
os_printf("REST #%d: connected\n", client-restClient);
#endif
espconn_regist_disconcb(client->pCon, tcpclient_discon_cb);
espconn_regist_recvcb(client->pCon, tcpclient_recv);
espconn_regist_sentcb(client->pCon, tcpclient_sent_cb);
client->data_sent = client->data_len <= 1400 ? client->data_len : 1400;
#ifdef REST_DBG
os_printf("REST #%d: sending %d\n", client-restClient, client->data_sent);
#endif
//if(client->security){
// espconn_secure_sent(client->pCon, client->data, client->data_sent);
//}
//else{
espconn_sent(client->pCon, (uint8_t*)client->data, client->data_sent);
//}
}
static void ICACHE_FLASH_ATTR wsConnectCb(void *connection) {
//find an empty slot
uint8_t slotId = 0;
while (wsConnections[slotId].connection != NULL && slotId < WS_MAXCONN) {
slotId++;
}
if (slotId == WS_MAXCONN) {
//no more free slots, close the connection
espconn_disconnect(connection);
return;
}
WSConnection wsConnection;
wsConnection.status = STATUS_UNINITIALISED;
wsConnection.connection = connection;
wsConnections[slotId] = wsConnection;
espconn_regist_recvcb(connection, wsRecvCb);
espconn_regist_sentcb(connection, wsSentCb);
}
static void ICACHE_FLASH_ATTR at_espconn_demo_init(void)
{
uint32 ip = 0;
at_espconn_demo_espconn_ptr = (struct espconn *)os_zalloc(sizeof(struct espconn));
at_espconn_demo_espconn_ptr->type = ESPCONN_TCP;
at_espconn_demo_espconn_ptr->state = ESPCONN_NONE;
at_espconn_demo_espconn_ptr->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
at_espconn_demo_espconn_ptr->proto.tcp->local_port = espconn_port();
at_espconn_demo_espconn_ptr->proto.tcp->remote_port = 8999;
ip = ipaddr_addr("192.168.1.120");
os_memcpy(at_espconn_demo_espconn_ptr->proto.tcp->remote_ip,&ip,sizeof(ip));
espconn_regist_connectcb(at_espconn_demo_espconn_ptr, at_espconn_demo_connect_cb);
espconn_regist_reconcb(at_espconn_demo_espconn_ptr, at_espconn_demo_recon_cb);
espconn_regist_disconcb(at_espconn_demo_espconn_ptr, at_espconn_demo_discon_cb);
espconn_regist_recvcb(at_espconn_demo_espconn_ptr, at_espconn_demo_recv);
espconn_regist_sentcb(at_espconn_demo_espconn_ptr, at_espconn_demo_send_cb);
espconn_connect(at_espconn_demo_espconn_ptr);
at_fake_uart_enable(TRUE,at_espconn_demo_response);
}
/******************************************************************************
* FunctionName : upgrade_connection
* Description : connect with a server
* Parameters : bin -- server number
* url -- the url whitch upgrade files saved
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
upgrade_connect(struct upgrade_server_info *server)
{
UPGRADE_DBG("upgrade_connect\n");
pbuf = server->url;
espconn_regist_connectcb(upgrade_conn, upgrade_connect_cb);
espconn_regist_recvcb(upgrade_conn, upgrade_download);
system_upgrade_init();
system_upgrade_flag_set(UPGRADE_FLAG_START);
#ifdef UPGRADE_SSL_ENABLE
espconn_secure_connect(upgrade_conn);
#else
espconn_connect(upgrade_conn);
#endif
os_timer_disarm(&upgrade_10s);
os_timer_setfn(&upgrade_10s, (os_timer_func_t *)upgrade_10s_cb, upgrade_conn);
os_timer_arm(&upgrade_10s, 10000, 0);
}
LOCAL void ICACHE_FLASH_ATTR
at_tcpserver_listen(void *arg) {
struct espconn *pespconn = (struct espconn *) arg;
int8_t first_free_slot = get_first_free_slot();
if (first_free_slot == -1)
return;
slot[first_free_slot].free = FALSE;
slot[first_free_slot].pCon = pespconn;
slot[first_free_slot].len = 0;
// slot[first_free_slot].linkId = linkId_counter++;
pespconn->reverse = &slot[first_free_slot];
debug_print_str_tcp("at_tcpserver_listen \n\r");
espconn_regist_time(pespconn, 0, 15); // 15s timeout
espconn_regist_recvcb(pespconn, at_tcpclient_recv);
espconn_regist_reconcb(pespconn, at_tcpserver_recon_cb);
espconn_regist_disconcb(pespconn, at_tcpserver_discon_cb);
espconn_regist_sentcb(pespconn, at_tcpclient_sent_cb);
}
static void ICACHE_FLASH_ATTR httpdConnectCb(void *arg) {
struct espconn *conn=arg;
int i;
//Find empty conndata in pool
for (i=0; i<MAX_CONN; i++) if (connData[i].conn==NULL) break;
os_printf("Con req, conn=%p, pool slot %d\n", conn, i);
connData[i].priv=&connPrivData[i];
if (i==MAX_CONN) {
os_printf("Aiee, conn pool overflow!\n");
espconn_disconnect(conn);
return;
}
connData[i].conn=conn;
connData[i].priv->headPos=0;
connData[i].postBuff=NULL;
connData[i].priv->postPos=0;
connData[i].postLen=0;
espconn_regist_recvcb(conn, httpdRecvCb);
espconn_regist_reconcb(conn, httpdReconCb);
espconn_regist_disconcb(conn, httpdDisconCb);
espconn_regist_sentcb(conn, httpdSentCb);
}
// Connect to Jarvis
LOCAL void ICACHE_FLASH_ATTR
connect_to_jarvis(os_event_t *events)
{
os_delay_us(1000000);
// Hit Jarvis
os_printf("Trying to hit Jarvis...\n");
tcp0.remote_port = SERVER_PORT;
*((uint32*)tcp0.remote_ip) = ipaddr_addr(SERVER_IP); // Remote IP
tcp0.local_port = espconn_port(); // Local port
wifi_get_ip_info(STATION_IF, &ip0);
//tcp0.local_ip = ip0.ip; // Local IP
conn0.type = ESPCONN_TCP;
conn0.state = ESPCONN_NONE;
conn0.proto.tcp = &tcp0;
espconn_regist_connectcb(&conn0, on_connect_cb);
espconn_regist_disconcb(&conn0, on_discon_cb);
espconn_regist_reconcb(&conn0, on_recon_cb);
espconn_regist_recvcb(&conn0, on_recv_cb);
espconn_regist_time(&conn0, 30, 1); // Set a 30 sec time-out for this conn
espconn_connect(&conn0);
os_printf("Connection request\n");
}
/**
* @brief Tcp client connect success callback function.
* @param arg: contain the ip link information
* @retval None
*/
static void ICACHE_FLASH_ATTR
at_tcpclient_connect_cb(void *arg)
{
struct espconn *pespconn = (struct espconn *)arg;
at_linkConType *linkTemp = (at_linkConType *)pespconn->reverse;
os_printf("tcp client connect\r\n");
os_printf("pespconn %p\r\n", pespconn);
linkTemp->linkEn = TRUE;
linkTemp->teType = teClient;
linkTemp->repeaTime = 0;
espconn_regist_disconcb(pespconn, at_tcpclient_discon_cb);
espconn_regist_recvcb(pespconn, at_tcpclient_recv);////////
espconn_regist_sentcb(pespconn, at_tcpclient_sent_cb);///////
mdState = m_linked;
// at_linkNum++;
at_backOk;
uart0_sendStr("Linked\r\n");
specialAtState = TRUE;
at_state = at_statIdle;
}
static void ICACHE_FLASH_ATTR connect_callback(void * arg)
{
HTTP_DEBUG("Connected\n");
struct espconn * conn = (struct espconn *)arg;
request_args * req = (request_args *)conn->reverse;
espconn_regist_recvcb(conn, receive_callback);
espconn_regist_sentcb(conn, sent_callback);
const char * method = "GET";
char post_headers[128] = "";
if (req->post_data != NULL) { // If there is data this is a POST request.
method = "POST";
os_sprintf(post_headers,
"Content-Type: application/x-www-form-urlencoded\r\n"
"Content-Length: %d\r\n", strlen(req->post_data));
}
char buf[2048];
int len = os_sprintf(buf,
"%s %s HTTP/1.1\r\n"
"Host: %s:%d\r\n"
"Connection: close\r\n"
"User-Agent: ESP8266\r\n"
"%s"
"\r\n",
method, req->path, req->hostname, req->port, post_headers);
sint8 espsent_status = espconn_sent(conn, (uint8_t *)buf, len);
if(espsent_status == ESPCONN_OK) {
HTTP_DEBUG("Data sent, buf = %s\n", buf);
} else {
HTTP_DEBUG("Error while sending data.\n");
}
HTTP_DEBUG("Sending request header\n");
}
/**
* @brief Get version connection version
* @param arg: contain the ip link information
* @retval None
*/
void ICACHE_FLASH_ATTR
get_version_connect_cb(void *arg)
{
struct espconn *pespconn = (struct espconn *)arg;
fota_client_t *fota_client = (fota_client_t *)pespconn->reverse;
espconn_regist_recvcb(pespconn, get_version_recv);
espconn_regist_sentcb(pespconn, get_version_sent_cb);
uint8_t user_bin[12] = {0};
if(system_upgrade_userbin_check() == UPGRADE_FW_BIN1) {
os_memcpy(user_bin, "user1.bin", 10);
}
else if(system_upgrade_userbin_check() == UPGRADE_FW_BIN2) {
os_memcpy(user_bin, "user2.bin", 10);
}
char *temp = NULL;
temp = (uint8 *) os_zalloc(512);
os_sprintf(temp, "GET /firmware/%s/versions HTTP/1.0\r\nHost: %s\r\n"pHeadStatic""pHeadAuthen"\r\n",
PROJECT,
fota_client->host,
fota_client->uuid, //pHeaderAuthen
fota_client->token,
FOTA_CLIENT,
user_bin,
VERSION
);
#if (FOTA_SECURE)
espconn_secure_sent(pespconn, temp, os_strlen(temp));
#else
espconn_sent(pespconn, temp, os_strlen(temp));
#endif
FREE(temp);
}
static void ICACHE_FLASH_ATTR httpdConnectCb(void *arg) {
debugConn(arg, "httpdConnectCb");
struct espconn *conn=arg;
int i;
//Find empty conndata in pool
for (i=0; i<MAX_CONN; i++) if (connData[i].conn==NULL) break;
//os_printf("Con req, conn=%p, pool slot %d\n", conn, i);
if (i==MAX_CONN) {
os_printf("%s Aiee, conn pool overflow!\n", connStr);
espconn_disconnect(conn);
return;
}
int num = 0;
for (int j=0; j<MAX_CONN; j++) if (connData[j].conn != NULL) num++;
os_printf("%s Connect (%d open)\n", connStr, num+1);
connData[i].priv=&connPrivData[i];
connData[i].conn=conn;
connData[i].remote_port = conn->proto.tcp->remote_port;
os_memcpy(connData[i].remote_ip, conn->proto.tcp->remote_ip, 4);
connData[i].priv->headPos=0;
connData[i].post=&connPostData[i];
connData[i].post->buff=NULL;
connData[i].post->buffLen=0;
connData[i].post->received=0;
connData[i].post->len=-1;
connData[i].startTime = system_get_time();
espconn_regist_recvcb(conn, httpdRecvCb);
espconn_regist_reconcb(conn, httpdReconCb);
espconn_regist_disconcb(conn, httpdDisconCb);
espconn_regist_sentcb(conn, httpdSentCb);
espconn_set_opt(conn, ESPCONN_REUSEADDR|ESPCONN_NODELAY);
}
/**
* @brief Tcp client connect success callback function.
* @param arg: contain the ip link information
* @retval None
*/
void ICACHE_FLASH_ATTR mqtt_tcpclient_connect_cb(void *arg) {
struct espconn *pCon = (struct espconn *)arg;
MQTT_Client *client = (MQTT_Client *) pCon->reverse;
espconn_regist_disconcb(client->pCon, mqtt_tcpclient_discon_cb);
espconn_regist_recvcb(client->pCon, mqtt_tcpclient_recv); ////////
espconn_regist_sentcb(client->pCon, mqtt_tcpclient_sent_cb); ///////
MQTT_INFO("MQTT: Connected to broker %s:%d\r\n", client->host, client->port);
mqtt_msg_init(&client->mqtt_state.mqtt_connection, client->mqtt_state.out_buffer,
client->mqtt_state.out_buffer_length);
client->mqtt_state.outbound_message =
mqtt_msg_connect(&client->mqtt_state.mqtt_connection, client->mqtt_state.connect_info);
client->mqtt_state.pending_msg_type = mqtt_get_type(client->mqtt_state.outbound_message->data);
client->mqtt_state.pending_msg_id =
mqtt_get_id(client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length);
client->sendTimeout = MQTT_SEND_TIMOUT;
MQTT_INFO("MQTT: Sending, type: %d, id: %04X\r\n", client->mqtt_state.pending_msg_type,
client->mqtt_state.pending_msg_id);
if (client->security) {
#ifdef MQTT_SSL_ENABLE
espconn_secure_send(client->pCon, client->mqtt_state.outbound_message->data,
client->mqtt_state.outbound_message->length);
#else
MQTT_INFO("TCP: Do not support SSL\r\n");
#endif
} else {
espconn_send(client->pCon, client->mqtt_state.outbound_message->data,
client->mqtt_state.outbound_message->length);
}
client->mqtt_state.outbound_message = NULL;
client->connState = MQTT_CONNECT_SENDING;
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t) client);
}
void ICACHE_FLASH_ATTR mesh_enable_cb(int8_t res)
{
MESH_DEMO_PRINT("mesh_enable_cb\n");
if (res == MESH_OP_FAILURE) {
MESH_DEMO_PRINT("enable mesh fail, re-enable\n");
espconn_mesh_enable(mesh_enable_cb, MESH_ONLINE);
return;
}
if (espconn_mesh_get_usr_context() &&
espconn_mesh_is_root() &&
res == MESH_LOCAL_SUC)
goto TEST_SCENARIO;
/*
* try to estable user virtual connect
* user can to use the virtual connect to sent packet to any node, server or mobile.
* if you want to sent packet to one node in mesh, please build p2p packet
* if you want to sent packet to server/mobile, please build normal packet (uincast packet)
* if you want to sent bcast/mcast packet, please build bcast/mcast packet
*/
MESH_DEMO_MEMSET(&g_ser_conn, 0 ,sizeof(g_ser_conn));
MESH_DEMO_MEMSET(&ser_tcp, 0, sizeof(ser_tcp));
MESH_DEMO_MEMCPY(ser_tcp.remote_ip, server_ip, sizeof(server_ip));
ser_tcp.remote_port = server_port;
ser_tcp.local_port = espconn_port();
g_ser_conn.proto.tcp = &ser_tcp;
if (espconn_regist_connectcb(&g_ser_conn, esp_mesh_demo_con_cb)) {
MESH_DEMO_PRINT("regist con_cb err\n");
espconn_mesh_disable(NULL);
return;
}
if (espconn_regist_recvcb(&g_ser_conn, esp_recv_entrance)) {
MESH_DEMO_PRINT("regist recv_cb err\n");
espconn_mesh_disable(NULL);
return;
}
/*
* regist the other callback
* sent_cb, reconnect_cb, disconnect_cb
* if you donn't need the above cb, you donn't need to register them.
*/
if (espconn_mesh_connect(&g_ser_conn)) {
MESH_DEMO_PRINT("connect err\n");
if (espconn_mesh_is_root())
espconn_mesh_enable(mesh_enable_cb, MESH_LOCAL);
else
espconn_mesh_enable(mesh_enable_cb, MESH_ONLINE);
return;
}
TEST_SCENARIO:
mesh_device_list_init();
mesh_topo_test_init();
mesh_json_mcast_test_init();
mesh_json_bcast_test_init();
mesh_json_p2p_test_init();
}
/**
* @brief Setup commad of start client.
* @param id: commad id number
* @param pPara: AT input param
* @retval None
*/
void ICACHE_FLASH_ATTR
at_setupCmdCipstart(uint8_t id, char *pPara)
{
char temp[64];
// enum espconn_type linkType;
int8_t len;
enum espconn_type linkType = ESPCONN_INVALID;
uint32_t ip = 0;
char ipTemp[128];
int32_t port;
uint8_t linkID;
// if(mdState != m_unlink)
// {
// uart0_sendStr("no ip\r\n");
// return;
// }
if(at_wifiMode == 1)
{
if(wifi_station_get_connect_status() != STATION_GOT_IP)
{
uart0_sendStr("no ip\r\n");
return;
}
}
pPara++;
if(at_ipMux)
{
linkID = atoi(pPara);
pPara++;
pPara = strchr(pPara, '\"');
}
else
{
linkID = 0;
}
if(linkID >= at_linkMax)
{
uart0_sendStr("ID ERROR\r\n");
return;
}
len = at_dataStrCpy(temp, pPara, 6);
if(len == -1)
{
uart0_sendStr("Link typ ERROR\r\n");
return;
}
if(os_strcmp(temp, "TCP") == 0)
{
linkType = ESPCONN_TCP;
}
else if(os_strcmp(temp, "UDP") == 0)
{
linkType = ESPCONN_UDP;
}
else
{
uart0_sendStr("Link typ ERROR\r\n");
return;
}
pPara += (len+3);
len = at_dataStrCpy(ipTemp, pPara, 64);
if(len == -1)
{
uart0_sendStr("IP ERROR\r\n");
return;
}
pPara += (len+2);
if(*pPara != ',')
{
uart0_sendStr("ENTRY ERROR\r\n");
return;
}
pPara += (1);
port = atoi(pPara);
if(pLink[linkID].linkEn)
{
uart0_sendStr("ALREAY CONNECT\r\n");
return;
}
pLink[linkID].pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
if (pLink[linkID].pCon == NULL)
{
uart0_sendStr("CONNECT FAIL\r\n");
return;
}
pLink[linkID].pCon->type = linkType;
pLink[linkID].pCon->state = ESPCONN_NONE;
pLink[linkID].linkId = linkID;
ip = ipaddr_addr(ipTemp);
switch(linkType)
{
case ESPCONN_TCP:
pLink[linkID].pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
pLink[linkID].pCon->proto.tcp->local_port = espconn_port();
pLink[linkID].pCon->proto.tcp->remote_port = port;
os_memcpy(pLink[linkID].pCon->proto.tcp->remote_ip, &ip, 4);
pLink[linkID].pCon->reverse = &pLink[linkID];
espconn_regist_connectcb(pLink[linkID].pCon, at_tcpclient_connect_cb);
espconn_regist_reconcb(pLink[linkID].pCon, at_tcpclient_recon_cb);
specialAtState = FALSE;
if((ip == 0xffffffff) && (os_memcmp(ipTemp,"255.255.255.255",16) != 0))
{
espconn_gethostbyname(pLink[linkID].pCon, ipTemp, &host_ip, at_dns_found);
}
else
{
espconn_connect(pLink[linkID].pCon);
at_linkNum++;
}
break;
case ESPCONN_UDP:
pLink[linkID].pCon->proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp));
pLink[linkID].pCon->proto.udp->local_port = espconn_port();
pLink[linkID].pCon->proto.udp->remote_port = port;
os_memcpy(pLink[linkID].pCon->proto.udp->remote_ip, &ip, 4);
pLink[linkID].pCon->reverse = &pLink[linkID];
// os_printf("%d\r\n",pLink[linkID].pCon->proto.udp->local_port);///
pLink[linkID].linkId = linkID;
pLink[linkID].linkEn = TRUE;
pLink[linkID].teType = teClient;
espconn_regist_recvcb(pLink[linkID].pCon, at_tcpclient_recv);
espconn_regist_sentcb(pLink[linkID].pCon, at_tcpclient_sent_cb);
if((ip == 0xffffffff) && (os_memcmp(ipTemp,"255.255.255.255",16) != 0))
{
specialAtState = FALSE;
espconn_gethostbyname(pLink[linkID].pCon, ipTemp, &host_ip, at_dns_found);
}
else
{
espconn_create(pLink[linkID].pCon);
at_linkNum++;
at_backOk;
}
break;
default:
break;
}
// os_sprintf(temp, "%d.%d.%d.%d:%d\r\n",/////
// IP2STR(&ip), port);/////
// uart0_sendStr(temp);////
// at_backOk;/////
}
static int ICACHE_FLASH_ATTR server_init_tcp(uint8 ifnum)
{
DEBUG("enter server_init_tcp");
static struct ip_info info;
static struct espconn server_conn;
static esp_tcp server_tcp;
int rc;
if (!wifi_get_ip_info(ifnum, &info)) {
ets_uart_printf("Failed to get ip info.\n");
DEBUG("exit server_init_tcp");
return -1;
}
MessageQueue_clear(&sendq);
MessageQueue_clear(&recvq);
system_os_task(server_task, SERVER_TASK_PRIO, server_task_queue, SERVER_TASK_QUEUE_LEN);
server_tcp.local_port = 80;
os_memcpy(server_tcp.local_ip, &(info.ip.addr), 4);
server_conn.type = ESPCONN_TCP;
server_conn.proto.tcp = &server_tcp;
if (espconn_regist_sentcb(&server_conn, tcpserver_sent_cb) != 0) {
ets_uart_printf("Failed to register sent callback.\n");
DEBUG("exit server_init_tcp");
return -1;
}
if (espconn_regist_recvcb(&server_conn, tcpserver_recv_cb) != 0) {
ets_uart_printf("Failed to register recv callback.\n");
DEBUG("exit server_init_tcp");
return -1;
}
if (espconn_regist_connectcb(&server_conn, tcpserver_connect_cb) != 0) {
ets_uart_printf("Failed to register connect callback.\n");
DEBUG("exit server_init_tcp");
return -1;
}
if (espconn_regist_reconcb(&server_conn, tcpserver_reconnect_cb) != 0) {
ets_uart_printf("Failed to register reconnect callback.\n");
DEBUG("exit server_init_tcp");
return -1;
}
if (espconn_regist_disconcb(&server_conn, tcpserver_disconnect_cb) != 0) {
ets_uart_printf("Failed to register disconnect callback.\n");
DEBUG("exit server_init_tcp");
return -1;
}
server_conn.link_cnt = 0;
server_conn.reverse = NULL;
espconn_disconnect(&server_conn);
if ((rc = espconn_accept(&server_conn)) != 0) {
if (rc == ESPCONN_ISCONN) {
ets_uart_printf("TCP server already connected.\n");
} else {
ets_uart_printf("Failed to accept. %d\n", rc);
DEBUG("exit server_init_tcp");
return -1;
}
} else {
/* Set to 0 for unlimited TCP connection time (no timeout) */
if (espconn_regist_time(&server_conn, 0, 0) != 0) {
ets_uart_printf("Failed to set timeout interval.\n");
DEBUG("exit server_init_tcp");
return -1;
}
}
// tcpserver_conn = &server_conn;
ets_uart_printf("Successfully initialized TCP server.\n\n");
DEBUG("exit server_init_tcp");
return 0;
}
/**
* @brief Setup commad of module as server.
* @param id: commad id number
* @param pPara: AT input param
* @retval None
*/
void ICACHE_FLASH_ATTR
at_setupCmdCipserver(uint8_t id, char *pPara)
{
BOOL serverEnTemp;
int32_t port;
char temp[32];
if(at_ipMux == FALSE)
{
at_backError;
return;
}
pPara++;
serverEnTemp = atoi(pPara);
pPara++;
if(serverEnTemp == 0)
{
if(*pPara != '\r')
{
at_backError;
return;
}
}
else if(serverEnTemp == 1)
{
if(*pPara == ',')
{
pPara++;
port = atoi(pPara);
}
else
{
port = 333;
}
}
else
{
at_backError;
return;
}
if(serverEnTemp == serverEn)
{
uart0_sendStr("no change\r\n");
return;
}
if(serverEnTemp)
{
pTcpServer = (struct espconn *)os_zalloc(sizeof(struct espconn));
if (pTcpServer == NULL)
{
uart0_sendStr("TcpServer Failure\r\n");
return;
}
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_timeover, 0);
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_create(pUdpServer);
// if(pLink[0].linkEn)
// {
// uart0_sendStr("Link is builded\r\n");
// return;
// }
// pLink[0].pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
// if (pLink[0].pCon == NULL)
// {
// uart0_sendStr("Link buile Failure\r\n");
// return;
// }
// pLink[0].pCon->type = ESPCONN_TCP;
// pLink[0].pCon->state = ESPCONN_NONE;
// pLink[0].linkId = 0;
// pLink[0].linkEn = TRUE;
//
// pLink[0].pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
// pLink[0].pCon->proto.tcp->local_port = port;
//
// pLink[0].pCon->reverse = &pLink[0];
//
// espconn_regist_connectcb(pLink[0].pCon, user_test_tcpserver_listen);
// espconn_accept(pLink[0].pCon);
// at_linkNum++;
}
else
{
/* restart */
uart0_sendStr("we must restart\r\n");
return;
}
serverEn = serverEnTemp;
at_backOk;
}
static void ICACHE_FLASH_ATTR tcp_connect_cb(void *arg) {
struct espconn *conn = (struct espconn*) arg;
espconn_regist_recvcb(conn, tcp_receive_cb);
espconn_regist_sentcb(conn, tcp_sent_cb);
}
/**
* Create a new socket.
* if `ipAddress == 0`, creates a server otherwise creates a client (and automatically connects). Returns >=0 on success.
*/
int net_ESP8266_BOARD_createSocket(
JsNetwork *net, //!< The Network we are going to use to create the socket.
uint32_t ipAddress, //!< The address of the partner of the socket or 0 if we are to be a server.
unsigned short port //!< The port number that the partner is listening upon.
) {
os_printf("> net_ESP8266_BOARD_createSocket: host: %d.%d.%d.%d, port:%d \n", ((char *)(&ipAddress))[0], ((char *)(&ipAddress))[1], ((char *)(&ipAddress))[2], ((char *)(&ipAddress))[3], port);
bool isServer = (ipAddress == 0);
struct socketData *pSocketData = allocateNewSocket();
if (pSocketData == NULL) { // No free socket
os_printf("< net_ESP8266_BOARD_createSocket: No free sockets\n");
return -1;
}
int newSocket = pSocketData->socketId;
pSocketData->pEspconn = (struct espconn *)os_malloc(sizeof(struct espconn));
assert(pSocketData->pEspconn);
struct espconn *pEspconn = pSocketData->pEspconn;
pEspconn->type = ESPCONN_TCP;
pEspconn->state = ESPCONN_NONE;
pEspconn->proto.tcp = (esp_tcp *)os_malloc(sizeof(esp_tcp));
pEspconn->reverse = pSocketData;
assert(pEspconn->proto.tcp != NULL);
os_memset(pEspconn->proto.tcp, 0, sizeof(esp_tcp));
// NOTE: We must not call these functions until AFTER we have allocated storage
// for the 'esp_tcp' structure.
espconn_regist_disconcb(pEspconn, esp8266_callback_disconnectCB);
espconn_regist_reconcb(pEspconn, esp8266_callback_reconnectCB);
espconn_regist_sentcb(pEspconn, esp8266_callback_sentCB);
espconn_regist_recvcb(pEspconn, esp8266_callback_recvCB);
espconn_regist_write_finish(pEspconn, esp8266_callback_writeFinishedCB);
struct ip_info ipconfig;
wifi_get_ip_info(STATION_IF, &ipconfig); // Get the local IP address
os_memcpy(pEspconn->proto.tcp->local_ip, &ipconfig.ip, 4);
// If we are not a server ...
if (isServer == false) {
pSocketData->state = SOCKET_STATE_CONNECTING;
pSocketData->creationType = SOCKET_CREATED_OUTBOUND;
pEspconn->proto.tcp->remote_port = port;
pEspconn->proto.tcp->local_port = espconn_port();
*(uint32 *)(pEspconn->proto.tcp->remote_ip) = ipAddress;
// Ensure that we have flagged this socket as NOT connected
pSocketData->isConnected = false;
espconn_regist_connectcb(pEspconn, esp8266_callback_connectCB_outbound);
// Make a call to espconn_connect.
int rc = espconn_connect(pEspconn);
if (rc != 0) {
os_printf("Err: net_ESP8266_BOARD_createSocket -> espconn_connect returned: %d. Using local port: %d\n", rc, pEspconn->proto.tcp->local_port);
setSocketInError(newSocket, "espconn_connect", rc);
}
}
// If the ipAddress IS 0 ... then we are a server.
else
{
// We are going to set ourselves up as a server
pSocketData->state = SOCKET_STATE_IDLE;
pSocketData->creationType = SOCKET_CREATED_SERVER;
pEspconn->proto.tcp->local_port = port;
espconn_regist_connectcb(pEspconn, esp8266_callback_connectCB_inbound);
// Make a call to espconn_accept
int rc = espconn_accept(pEspconn);
if (rc != 0) {
os_printf("Err: net_ESP8266_BOARD_createSocket -> espconn_accept returned: %d. Using local port: %d\n", rc, pEspconn->proto.tcp->local_port);
setSocketInError(newSocket, "espconn_accept", rc);
}
}
dumpEspConn(pEspconn);
os_printf("< net_ESP8266_BOARD_createSocket, socket=%d\n", newSocket);
return newSocket;
}
// TCP Connected callback
void ICACHE_FLASH_ATTR tcpserver_connectcb(void *arg) {
struct espconn *pespconn = (struct espconn *)arg;
espconn_regist_recvcb(pespconn, server_recv_cb);
espconn_regist_disconcb(pespconn, server_discon_cb);
//ets_uart_printf("Server ready\r\n");
}
/**
* Continue creating a socket, the name resolution having completed
*/
static int connectSocket(
struct socketData *pSocketData //!< Allocated socket data structure
) {
struct espconn *pEspconn = pSocketData->pEspconn;
bool isServer = *(uint32_t *)&pEspconn->proto.tcp->remote_ip == 0;
int newSocket = pSocketData->socketId;
assert(pSocketData->rxBufQ == NULL);
assert(pSocketData->currentTx == NULL);
// If we are a client
if (!isServer) {
pSocketData->state = SOCKET_STATE_CONNECTING;
pSocketData->creationType = SOCKET_CREATED_OUTBOUND;
espconn_regist_connectcb(pEspconn, esp8266_callback_connectCB_outbound);
espconn_regist_disconcb(pEspconn, esp8266_callback_disconnectCB);
espconn_regist_reconcb(pEspconn, esp8266_callback_reconnectCB);
espconn_regist_sentcb(pEspconn, esp8266_callback_sentCB);
espconn_regist_recvcb(pEspconn, esp8266_callback_recvCB);
// Make a call to espconn_connect.
#if 0
DBG("%s: connecting socket %d/%p/%p to %d.%d.%d.%d:%d from :%d\n",
DBG_LIB, pSocketData->socketId, pSocketData, pEspconn,
IP2STR(pEspconn->proto.tcp->remote_ip), pEspconn->proto.tcp->remote_port,
pEspconn->proto.tcp->local_port);
#endif
int rc = espconn_connect(pEspconn);
if (rc != 0) {
DBG("%s: error %d connecting socket %d: %s\n", DBG_LIB,
rc, pSocketData->socketId, esp8266_errorToString(rc));
releaseEspconn(pSocketData);
releaseSocket(pSocketData);
return rc;
}
DBG("%s: connecting socket %d to %d.%d.%d.%d:%d\n", DBG_LIB, pSocketData->socketId,
IP2STR(pEspconn->proto.tcp->remote_ip), pEspconn->proto.tcp->remote_port);
}
// If the ipAddress IS 0 ... then we are a server.
else {
// We are going to set ourselves up as a server
pSocketData->state = SOCKET_STATE_IDLE;
pSocketData->creationType = SOCKET_CREATED_SERVER;
pEspconn->proto.tcp->local_port = pEspconn->proto.tcp->remote_port;
pEspconn->proto.tcp->remote_port = 0;
espconn_regist_connectcb(pEspconn, esp8266_callback_connectCB_inbound);
// Make a call to espconn_accept (this should really be called espconn_listen, sigh)
int rc = espconn_accept(pEspconn);
if (rc != 0) {
DBG("%s: error %d creating listening socket %d: %s\n", DBG_LIB,
rc, pSocketData->socketId, esp8266_errorToString(rc));
releaseEspconn(pSocketData);
releaseSocket(pSocketData);
return rc;
}
espconn_regist_time(pEspconn, 600, 0);
DBG("%s: listening socket %d on port %d\n", DBG_LIB,
pSocketData->socketId, pEspconn->proto.tcp->local_port);
}
return newSocket;
}
// Lua: server:listen( port, ip, function(con) )
// Lua: socket:connect( port, ip, function(con) )
static int net_start( lua_State* L, const char* mt )
{
NODE_DBG("net_start is called.\n");
struct espconn *pesp_conn = NULL;
lnet_userdata *nud;
unsigned port;
size_t il;
bool isserver = false;
ip_addr_t ipaddr;
const char *domain;
uint8_t stack = 1;
if (mt!=NULL && c_strcmp(mt, "net.server")==0)
isserver = true;
else if (mt!=NULL && c_strcmp(mt, "net.socket")==0)
isserver = false;
else
{
NODE_DBG("wrong metatable for net_start.\n");
return 0;
}
nud = (lnet_userdata *)luaL_checkudata(L, stack, mt);
luaL_argcheck(L, nud, stack, "Server/Socket expected");
stack++;
if(nud==NULL){
NODE_DBG("userdata is nil.\n");
return 0;
}
pesp_conn = nud->pesp_conn;
port = luaL_checkinteger( L, stack );
stack++;
if( pesp_conn->type == ESPCONN_TCP )
{
if(isserver)
pesp_conn->proto.tcp->local_port = port;
else{
pesp_conn->proto.tcp->remote_port = port;
pesp_conn->proto.tcp->local_port = espconn_port();
}
NODE_DBG("TCP port is set: %d.\n", port);
}
else if (pesp_conn->type == ESPCONN_UDP)
{
if(isserver)
pesp_conn->proto.udp->local_port = port;
else{
pesp_conn->proto.udp->remote_port = port;
pesp_conn->proto.udp->local_port = espconn_port();
}
NODE_DBG("UDP port is set: %d.\n", port);
}
if( lua_isstring(L,stack) ) // deal with the domain string
{
domain = luaL_checklstring( L, stack, &il );
stack++;
if (domain == NULL)
{
if(isserver)
domain = "0.0.0.0";
else
domain = "127.0.0.1";
}
ipaddr.addr = ipaddr_addr(domain);
if( pesp_conn->type == ESPCONN_TCP )
{
if(isserver)
c_memcpy(pesp_conn->proto.tcp->local_ip, &ipaddr.addr, 4);
else
c_memcpy(pesp_conn->proto.tcp->remote_ip, &ipaddr.addr, 4);
NODE_DBG("TCP ip is set: ");
NODE_DBG(IPSTR, IP2STR(&ipaddr.addr));
NODE_DBG("\n");
}
else if (pesp_conn->type == ESPCONN_UDP)
{
if(isserver)
c_memcpy(pesp_conn->proto.udp->local_ip, &ipaddr.addr, 4);
else
c_memcpy(pesp_conn->proto.udp->remote_ip, &ipaddr.addr, 4);
NODE_DBG("UDP ip is set: ");
NODE_DBG(IPSTR, IP2STR(&ipaddr.addr));
NODE_DBG("\n");
}
}
// call back function when a connection is obtained, tcp only
if ( pesp_conn->type == ESPCONN_TCP ) {
if (lua_type(L, stack) == LUA_TFUNCTION || lua_type(L, stack) == LUA_TLIGHTFUNCTION){
lua_pushvalue(L, stack); // copy argument (func) to the top of stack
if(isserver) // for tcp server connected callback
{
if(tcpserver_cb_connect_ref != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, tcpserver_cb_connect_ref);
tcpserver_cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
}
else
{
if(nud->cb_connect_ref != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, nud->cb_connect_ref);
nud->cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
}
}
}
if(!isserver || pesp_conn->type == ESPCONN_UDP){ // self_ref is only needed by socket userdata, or udp server
lua_pushvalue(L, 1); // copy to the top of stack
if(nud->self_ref != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, nud->self_ref);
nud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
}
if( pesp_conn->type == ESPCONN_TCP )
{
if(isserver){ // no secure server support for now
espconn_regist_connectcb(pesp_conn, net_server_connected);
// tcp server, SSL is not supported
#ifdef CLIENT_SSL_ENABLE
// if(nud->secure)
// espconn_secure_accept(pesp_conn);
// else
#endif
espconn_accept(pesp_conn); // if it's a server, no need to dns.
espconn_regist_time(pesp_conn, tcp_server_timeover, 0);
}
else{
espconn_regist_connectcb(pesp_conn, net_socket_connected);
espconn_regist_reconcb(pesp_conn, net_socket_reconnected);
#ifdef CLIENT_SSL_ENABLE
if(nud->secure){
if(pesp_conn->proto.tcp->remote_port || pesp_conn->proto.tcp->local_port)
espconn_secure_disconnect(pesp_conn);
// espconn_secure_connect(pesp_conn);
}
else
#endif
{
if(pesp_conn->proto.tcp->remote_port || pesp_conn->proto.tcp->local_port)
espconn_disconnect(pesp_conn);
// espconn_connect(pesp_conn);
}
}
}
else if (pesp_conn->type == ESPCONN_UDP)
{
espconn_regist_recvcb(pesp_conn, net_socket_received);
espconn_regist_sentcb(pesp_conn, net_socket_sent);
if(pesp_conn->proto.tcp->remote_port || pesp_conn->proto.tcp->local_port)
espconn_delete(pesp_conn);
if(isserver)
espconn_create(pesp_conn); // if it's a server, no need to dns.
}
if(!isserver){
if((ipaddr.addr == IPADDR_NONE) && (c_memcmp(domain,"255.255.255.255",16) != 0))
{
host_ip.addr = 0;
dns_reconn_count = 0;
if(ESPCONN_OK == espconn_gethostbyname(pesp_conn, domain, &host_ip, socket_dns_found)){
socket_dns_found(domain, &host_ip, pesp_conn); // ip is returned in host_ip.
}
}
else
{
socket_connect(pesp_conn);
}
}
return 0;
}
// initialize the custom stuff that goes beyond esp-link
void user_init()
{
// Initialize the GPIO subsystem.
gpio_init();
/* ====================================== */
/* UART */
/* ====================================== */
// Initialize UART0 and UART1
/* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
uart_init( BIT_RATE_115200, BIT_RATE_115200 );
// uart0_sendStr( "\nUART0 - USED TO PROGRAM THE MODULE\n" );
os_printf("\n===================\nUART1 - DEBUG OUPUT\n===================\n");
/* NOTE: PWM CANNOT BE USED SIMULTANEOUSLY WITH HW TIMER */
#if 0
/* ====================================== */
/* PWM */
/* ====================================== */
uint32 pwm_period = 1000;
uint32 pwm_duty[PWM_CHANNEL] = {0};
uint32 io_info[][3] = { {PWM_0_OUT_IO_MUX,PWM_0_OUT_IO_FUNC,PWM_0_OUT_IO_NUM},
{PWM_1_OUT_IO_MUX,PWM_1_OUT_IO_FUNC,PWM_1_OUT_IO_NUM},
};
/* PIN FUNCTION INIT FOR PWM OUTPUT */
pwm_init(pwm_period, pwm_duty, PWM_CHANNEL, io_info);
/* set pwm_duty cycle */
pwm_set_duty (14185, 0);
pwm_set_duty (22222, 1); // todo: explain why 22222 is the highest possible value
/* start PWM */
pwm_start(); // NOTE: PWM causes spikes in other GPIOs
#endif
/* ====================================== */
/* GPIO INTERRPUT */
/* ====================================== */
/* Set GPIO12 in GPIO mode */
PIN_FUNC_SELECT( PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12 );
/* Set GPIO12 as input */
GPIO_DIS_OUTPUT( GPIO_ID_PIN(12) );
/* Disable all GPIO interrupts */
ETS_GPIO_INTR_DISABLE();
/* Set a GPIO callback function */
ETS_GPIO_INTR_ATTACH( gpioCallback, NULL );
/* Configure the type of edge */
gpio_pin_intr_state_set( GPIO_ID_PIN(12), GPIO_PIN_INTR_ANYEDGE );
ETS_GPIO_INTR_ENABLE();
/* ====================================== */
/* SOFTWARE TIMER */
/* ====================================== */
// Set GPIO0 to output mode
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
//Set GPIO0 low
gpio_output_set(0, RELAY_PIN, RELAY_PIN, 0);
/* disarm timer */
os_timer_disarm((ETSTimer*)&some_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&some_timer, (os_timer_func_t *) softwareTimerCallback, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&some_timer, 10, 1);
/* ====================================== */
/* OS TASK */
/* ====================================== */
/* setup OS task */
// system_os_task(user_procTask, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);
/* send a message to OS task (fire task) */
// system_os_post(user_procTaskPrio, 0, 0 );
/* ====================================== */
/* HARDWARE TIMER */
/* ====================================== */
/* The hardware timer is used to indicate when a complete IR message frame should have
* arrived in order to process the received data and calculate the IR command.
*
* It is configured in "one-shot" mode. It is started when the beginning of an
* IR message frame is detected and stopped after the complete message frame has been read.
* This means that the duration of the HW timer should be longer than the duration of
* the longest message frame. In the NEC IR tranmission protocol all message frames have
* a duration of approximately 67.5ms.
*/
/* load the HW TIMER */
uint32 ticks = usToTicks(70000); // 70ms
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, ticks);
/* register callback function */
ETS_FRC_TIMER1_INTR_ATTACH( hwTimerCallback, NULL );
/* enable interrupts */
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
/* don't start timer yet */
/* the timer is started inside the GPIO INT callback */
/* ====================================== */
/* UDP SERVER */
/* ====================================== */
/* usage: echo <data> | nc -wl -u <ip address> <port>
* example: echo "foo" | nc -w1 -u 192.168.1.187 7777 */
/* allocate space for server */
pUdpServer = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pUdpServer, 0, sizeof(struct espconn));
/* create the server */
espconn_create(pUdpServer);
/* set the type of server */
pUdpServer->type = ESPCONN_UDP;
/* allocate memory for UDP settings */
pUdpServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
/* set the port that the server will be listening to */
pUdpServer->proto.udp->local_port = 7777;
/* register the callback */
espconn_regist_recvcb(pUdpServer, udpServerRxCb);
/* start listening */
if (espconn_create(pUdpServer))
{
while (1) { os_printf("Error creating a UDP server\n"); }
}
/* ====================================== */
/* WIFI */
/* ====================================== */
wifi_set_opmode(STATION_MODE);
wifi_station_get_config_default(&stconf);
// os_strncpy((char*) stconf.ssid, "TP-LINK_2.4GHz_FC2E51", 32);
// os_strncpy((char*) stconf.password, "tonytony", 64);
os_strncpy((char*) stconf.ssid, "WLAN-PUB", 32);
os_strncpy((char*) stconf.password, "", 64);
// os_strncpy((char*) stconf.ssid, "MAD air", 32);
// os_strncpy((char*) stconf.password, "glioninlog", 64);
stconf.bssid_set = 0;
wifi_station_set_config(&stconf);
// /* ====================================== */
// /* WS2812 LED STRIP */
// /* ====================================== */
//
// /* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
// ws2812_init();
//
// /* G R B */
// uint8_t ledout[] = {
// 0xff, 0x00, 0x00, //4th
//// 0xff, 0x00, 0x00, //3rd
//// 0x00, 0xff, 0x00, //2nd
//// 0x00, 0x00, 0xff, //1st
// };
//
//#if 0
// os_printf("\r\nB R G: %x %x %x\r\n", ledout[0], ledout[1],ledout[2]);
//#endif
//
// ws2812_push( ledout, sizeof( ledout ) );
/* ====================================== */
/* TCP CONNECTION */
/* ====================================== */
/* allocate space for server */
pTcpConn = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pTcpConn, 0, sizeof(struct espconn));
/* set the type of connection */
pTcpConn->type = ESPCONN_TCP;
/* set state to NONE */
pTcpConn->state = ESPCONN_NONE;
/* allocate memory for TCP settings */
pTcpConn->proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp));
/* set the port that the connection will be listening to */
pTcpConn->proto.tcp->local_port = espconn_port();
/* set the remote port and IP address */
pTcpConn->proto.tcp->remote_port = 80;
os_memcpy(pTcpConn->proto.tcp->remote_ip, server_ip_address, sizeof(server_ip_address));
/* register callbacks */
espconn_regist_connectcb(pTcpConn, tcpConnCb);
espconn_regist_reconcb(pTcpConn, tcpReconnCb);
/* disarm timer */
os_timer_disarm((ETSTimer*)&wifi_setup_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&wifi_setup_timer, (os_timer_func_t *) wifiConnectTimerCb, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&wifi_setup_timer, 5000, 1);
return;
}
static void net_server_connected(void *arg) // for tcp only
{
NODE_DBG("net_server_connected is called.\n");
struct espconn *pesp_conn = arg;
int i = 0;
lnet_userdata *skt = NULL;
if(pesp_conn == NULL)
return;
#if 0
char temp[20] = {0};
c_sprintf(temp, IPSTR, IP2STR( &(pesp_conn->proto.tcp->remote_ip) ) );
NODE_DBG("remote ");
NODE_DBG(temp);
NODE_DBG(":");
NODE_DBG("%d",pesp_conn->proto.tcp->remote_port);
NODE_DBG(" connected.\n");
#endif
for(i=0;i<MAX_SOCKET;i++){
if(socket[i] == LUA_NOREF) // found empty slot
{
break;
}
}
if(i>=MAX_SOCKET) // can't create more socket
{
NODE_ERR("MAX_SOCKET\n");
pesp_conn->reverse = NULL; // not accept this conn
if(pesp_conn->proto.tcp->remote_port || pesp_conn->proto.tcp->local_port)
espconn_disconnect(pesp_conn);
return;
}
if(tcpserver_cb_connect_ref == LUA_NOREF)
return;
if(!gL)
return;
lua_rawgeti(gL, LUA_REGISTRYINDEX, tcpserver_cb_connect_ref); // get function
// create a new client object
skt = (lnet_userdata *)lua_newuserdata(gL, sizeof(lnet_userdata));
if(!skt){
NODE_ERR("can't newudata\n");
lua_pop(gL, 1);
return;
}
// set its metatable
luaL_getmetatable(gL, "net.socket");
lua_setmetatable(gL, -2);
// pre-initialize it, in case of errors
skt->self_ref = LUA_NOREF;
lua_pushvalue(gL, -1); // copy the top of stack
skt->self_ref = luaL_ref(gL, LUA_REGISTRYINDEX); // ref to it self, for module api to find the userdata
socket[i] = skt->self_ref; // save to socket array
socket_num++;
skt->cb_connect_ref = LUA_NOREF; // this socket already connected
skt->cb_reconnect_ref = LUA_NOREF;
skt->cb_disconnect_ref = LUA_NOREF;
skt->cb_receive_ref = LUA_NOREF;
skt->cb_send_ref = LUA_NOREF;
skt->cb_dns_found_ref = LUA_NOREF;
#ifdef CLIENT_SSL_ENABLE
skt->secure = 0; // as a server SSL is not supported.
#endif
skt->pesp_conn = pesp_conn; // point to the espconn made by low level sdk
pesp_conn->reverse = skt; // let espcon carray the info of this userdata(net.socket)
espconn_regist_recvcb(pesp_conn, net_socket_received);
espconn_regist_sentcb(pesp_conn, net_socket_sent);
espconn_regist_disconcb(pesp_conn, net_server_disconnected);
espconn_regist_reconcb(pesp_conn, net_server_reconnected);
// now socket[i] has the client ref, and stack top has the userdata
lua_call(gL, 1, 0); // function(conn)
}
