PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
da61aa0a499a8a3273fb6a47a771a0b717a81749
TencentOS-tiny/examples/event_driven_at_module/esp8266_evtdrv/esp8266_evtdrv.c
SheldonDai 9727512631 add event-driven framework 
see examples/event_driven_at_module and examples/event_driven_hello_world, demo project: TencentOS-tiny\board\TencentOS_tiny_EVB_MX\KEIL\event_driven_hello_world
2019-09-24 17:21:58 +08:00

688 lines
21 KiB
C
Raw Blame History

#include "tos_at_evtdrv.h"
#include "esp8266_evtdrv.h"
#include "sal_module_wrapper.h"
#include "stdio.h"
#include "stdbool.h"
#include "ctype.h"
typedef struct esp8266_send_info_st {
int sockid;
void *buf;
size_t len;
} esp8266_send_info_t;
typedef struct esp8266_domain_parse_info_st {
char *host_ip;
size_t host_ip_len;
} esp8266_domain_parse_info_t;
typedef struct esp8266_context_st {
at_echo_t echo;
char echo_buffer[64];
int try;
evtdrv_task_id_t self_task_id;
int sockid;
evtdrv_task_id_t caller_task_id;
char *ssid;
char *pwd;
esp8266_send_info_t send_info;
esp8266_domain_parse_info_t domain_parse_info;
} esp8266_context_t;
esp8266_context_t esp8266_context;
#define CONTEXT(field) (esp8266_context.##field)
static void esp8266_restore(void)
{
tos_at_echo_create(&CONTEXT(echo), NULL, 0, NULL, CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_RESTORE);
tos_at_cmd_exec(&CONTEXT(echo), 3000, "AT+RESTORE\r\n");
}
static void esp8266_echo_close(void)
{
tos_at_echo_create(&CONTEXT(echo), NULL, 0, NULL, CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_ECHO_CLOSE);
tos_at_cmd_exec(&CONTEXT(echo), 1000, "ATE0\r\n");
}
static void esp8266_net_mode_set(sal_net_mode_t mode)
{
char *cmd = NULL;
switch (mode) {
case SAL_NET_MODE_STA:
cmd = "AT+CWMODE=1\r\n";
break;
case SAL_NET_MODE_AP:
cmd = "AT+CWMODE=2\r\n";
break;
case SAL_NET_MODE_STA_AP:
cmd = "AT+CWMODE=3\r\n";
break;
default:
return;
}
tos_at_echo_create(&CONTEXT(echo), NULL, 0, "no change", CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_NET_MODE_SET);
tos_at_cmd_exec(&CONTEXT(echo), 1000, cmd);
}
static void esp8266_send_mode_set(sal_send_mode_t mode)
{
tos_at_echo_create(&CONTEXT(echo), NULL, 0, NULL, CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_SEND_MODE_SET);
tos_at_cmd_exec(&CONTEXT(echo), 1000, "AT+CIPMODE=%d\r\n", mode == SAL_SEND_MODE_NORMAL ? 0 : 1);
}
static void esp8266_multilink_set(sal_multilink_state_t state)
{
tos_at_echo_create(&CONTEXT(echo), NULL, 0, NULL, CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_MULTILINK_SET);
tos_at_cmd_exec(&CONTEXT(echo), 500, "AT+CIPMUX=%d\r\n", state == SAL_MULTILINK_STATE_ENABLE ? 1 : 0);
}
static void esp8266_do_join_ap(const char *ssid, const char *pwd)
{
tos_at_echo_create(&CONTEXT(echo), NULL, 0, "OK", CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_JOIN_AP);
tos_at_cmd_exec(&CONTEXT(echo), 1000, "AT+CWJAP=\"%s\",\"%s\"\r\n", ssid, pwd);
}
static int esp8266_do_connect(const char *ip, const char *port, sal_proto_t proto)
{
CONTEXT(sockid) = tos_at_channel_alloc(ip, port);
if (CONTEXT(sockid) == -1) {
return -1;
}
tos_at_echo_create(&CONTEXT(echo), NULL, 0, "OK", CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_CONNECT);
tos_at_cmd_exec(&CONTEXT(echo), 10000,
"AT+CIPSTART=%d,\"%s\",\"%s\",%s\r\n",
CONTEXT(sockid), proto == TOS_SAL_PROTO_UDP ? "UDP" : "TCP", ip, port);
return 0;
}
static int esp8266_recv_timeout(int id, void *buf, size_t len, uint32_t timeout)
{
return tos_at_channel_read_timed(id, buf, len, timeout);
}
static int esp8266_recv(int id, void *buf, size_t len)
{
return esp8266_recv_timeout(id, buf, len, (uint32_t)4000);
}
static int esp8266_is_link_broken(const char *echo_buffer)
{
if (strstr(echo_buffer, "CLOSED") ||
strstr(echo_buffer, "link is not valid")) {
return 1;
}
return 0;
}
static int esp8266_do_send(int id, const void *buf, size_t len)
{
tos_at_echo_create(&CONTEXT(echo), CONTEXT(echo_buffer), sizeof(CONTEXT(echo_buffer)), "SEND OK", CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_SEND);
/*
ATTENTION: we should wait util "SEND OK" is echoed, otherwise the next
time we execute at command, the esp8266 maybe in a "busy s ..." state.
*/
tos_at_raw_data_send(&CONTEXT(echo), 10000, (uint8_t *)buf, len);
return 0;
}
static int esp8266_do_send_ready(int id, const void *buf, size_t len)
{
if (!tos_at_channel_is_working(id)) {
return -1;
}
CONTEXT(sockid) = id;
tos_at_echo_create(&CONTEXT(echo), CONTEXT(echo_buffer), sizeof(CONTEXT(echo_buffer)), ">", CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_SEND_READY);
tos_at_cmd_exec(&CONTEXT(echo), 1000,
"AT+CIPSEND=%d,%d\r\n",
id, len);
return 0;
}
static int esp8266_do_close(int id)
{
tos_at_cmd_exec(NULL, 1000, "AT+CIPCLOSE=%d\r\n", id);
tos_at_channel_free(id);
return 0;
}
static int esp8266_close(int id)
{
esp8266_imsg_close_t *msg_close;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_close_t));
msg_close = (esp8266_imsg_close_t *)msg_body;
msg_close->header.event = EVENT_IMSG_ESP8266_CLOSE;
msg_close->header.sender_id = tos_evtdrv_task_self();
msg_close->sockid = id;
if (tos_evtdrv_msg_send(CONTEXT(self_task_id), (evtdrv_msg_body_t)msg_close) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
static int esp8266_send(int id, const void *buf, size_t len)
{
esp8266_imsg_send_t *msg_send;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_send_t));
msg_send = (esp8266_imsg_send_t *)msg_body;
msg_send->header.event = EVENT_IMSG_ESP8266_SEND;
msg_send->header.sender_id = tos_evtdrv_task_self();
msg_send->sockid = id;
msg_send->buf = (void *)buf;
msg_send->len = len;
if (tos_evtdrv_msg_send(CONTEXT(self_task_id), (evtdrv_msg_body_t)msg_send) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
static int esp8266_connect(const char *ip, const char *port, sal_proto_t proto)
{
esp8266_imsg_connect_t *msg_connect;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_connect_t));
msg_connect = (esp8266_imsg_connect_t *)msg_body;
msg_connect->header.event = EVENT_IMSG_ESP8266_CONNECT;
msg_connect->header.sender_id = tos_evtdrv_task_self();
msg_connect->ip = (char *)ip;
msg_connect->port = (char *)port;
msg_connect->proto = proto;
if (tos_evtdrv_msg_send(CONTEXT(self_task_id), (evtdrv_msg_body_t)msg_connect) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
static int esp8266_do_parse_domain(const char *host_name, char *host_ip, size_t host_ip_len)
{
tos_at_echo_create(&CONTEXT(echo), CONTEXT(echo_buffer), sizeof(CONTEXT(echo_buffer)), NULL, CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_DOMAIN_PARSE);
tos_at_cmd_exec(&CONTEXT(echo), 2000, "AT+CIPDOMAIN=\"%s\"\r\n", host_name);
return 0;
}
static int esp8266_parse_domain(const char *host_name, char *host_ip, size_t host_ip_len)
{
esp8266_imsg_domain_parse_t *msg_domain_parse;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_domain_parse_t));
msg_domain_parse = (esp8266_imsg_domain_parse_t *)msg_body;
msg_domain_parse->header.event = EVENT_IMSG_ESP8266_DOMAIN_PARSE;
msg_domain_parse->header.sender_id = tos_evtdrv_task_self();
msg_domain_parse->host_name = (char *)host_name;
msg_domain_parse->host_ip = (char *)host_ip;
msg_domain_parse->host_ip_len = host_ip_len;
if (tos_evtdrv_msg_send(CONTEXT(self_task_id), (evtdrv_msg_body_t)msg_domain_parse) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
static int esp8266_init(void)
{
if (tos_evtdrv_event_set(CONTEXT(self_task_id), EVENT_INTERNAL_ESP8266_INIT) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
__STATIC__ uint8_t incoming_data_buffer[512];
__STATIC__ void esp8266_incoming_data_process(void)
{
uint8_t data;
int channel_id = 0, data_len = 0;
/*
+IPD,0,44:1234...
+IPD: prefix
0: link id
44: data length
1234...: data content
*/
while (1) {
if (tos_at_uart_read(&data, 1) != 1) {
return;
}
if (data == ',') {
break;
}
channel_id = channel_id * 10 + (data - '0');
}
while (1) {
if (tos_at_uart_read(&data, 1) != 1) {
return;
}
if (data == ':') {
break;
}
data_len = data_len * 10 + (data - '0');
}
if (data_len > sizeof(incoming_data_buffer)) {
data_len = sizeof(incoming_data_buffer);
}
if (tos_at_uart_read(incoming_data_buffer, data_len) != data_len) {
return;
}
tos_at_channel_write(channel_id, incoming_data_buffer, data_len);
}
at_event_t esp8266_at_event[] = {
{ "+IPD,", esp8266_incoming_data_process },
};
sal_module_t sal_module_esp8266 = {
.init = esp8266_init,
.connect = esp8266_connect,
.send = esp8266_send,
.recv_timeout = esp8266_recv_timeout,
.recv = esp8266_recv,
.close = esp8266_close,
.parse_domain = esp8266_parse_domain,
};
int esp8266_join_ap(const char *ssid, const char *pwd)
{
esp8266_imsg_join_ap_t *msg_join_ap;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_join_ap_t));
msg_join_ap = (esp8266_imsg_join_ap_t *)msg_body;
msg_join_ap->header.event = EVENT_IMSG_ESP8266_JOIN_AP;
msg_join_ap->header.sender_id = tos_evtdrv_task_self();
msg_join_ap->ssid = (char *)ssid;
msg_join_ap->pwd = (char *)pwd;
if (tos_evtdrv_msg_send(CONTEXT(self_task_id), (evtdrv_msg_body_t)msg_join_ap) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
int esp8266_sal_init(hal_uart_port_t uart_port, evtdrv_task_id_t at_task_id, evtdrv_task_id_t esp8266_task_id)
{
esp8266_imsg_init_t *msg_init;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_imsg_init_t));
msg_init = (esp8266_imsg_init_t *)msg_body;
msg_init->header.event = EVENT_IMSG_ESP8266_INIT;
msg_init->header.sender_id = tos_evtdrv_task_self();
msg_init->uart_port = uart_port;
msg_init->at_task_id = at_task_id;
msg_init->esp8266_task_id = esp8266_task_id;
if (tos_evtdrv_msg_send(esp8266_task_id, (evtdrv_msg_body_t)msg_init) != EVTDRV_ERR_NONE) {
return -1;
}
return 0;
}
static void esp8266_send_msg_reply(int write_len)
{
esp8266_omsg_send_t *omsg_send;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_omsg_send_t));
omsg_send = (esp8266_omsg_send_t *)msg_body;
omsg_send->header.event = EVENT_OMSG_ESP8266_SEND;
omsg_send->header.sender_id = tos_evtdrv_task_self();
omsg_send->write_len = write_len;
tos_evtdrv_msg_send(CONTEXT(caller_task_id), (evtdrv_msg_body_t)omsg_send);
}
static void esp8266_connect_msg_reply(int sockid)
{
esp8266_omsg_connect_t *omsg_connect;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_omsg_connect_t));
omsg_connect = (esp8266_omsg_connect_t *)msg_body;
omsg_connect->header.event = EVENT_OMSG_ESP8266_CONNECT;
omsg_connect->header.sender_id = tos_evtdrv_task_self();
omsg_connect->sockid = sockid;
tos_evtdrv_msg_send(CONTEXT(caller_task_id), (evtdrv_msg_body_t)omsg_connect);
}
static void esp8266_common_msg_reply(evtdrv_event_flag_t event_flag, int return_code)
{
esp8266_omsg_common_t *omsg_common;
evtdrv_msg_body_t msg_body;
msg_body = tos_evtdrv_msg_alloc(sizeof(esp8266_omsg_common_t));
omsg_common = (esp8266_omsg_common_t *)msg_body;
omsg_common->header.event = event_flag;
omsg_common->header.sender_id = tos_evtdrv_task_self();
omsg_common->return_code = return_code;
tos_evtdrv_msg_send(CONTEXT(caller_task_id), (evtdrv_msg_body_t)omsg_common);
}
evtdrv_event_flag_t esp8266_task(evtdrv_event_flag_t event)
{
esp8266_event_hdr_t *event_hdr;
esp8266_imsg_init_t *imsg_init;
esp8266_imsg_join_ap_t *imsg_join_ap;
esp8266_imsg_connect_t *imsg_connect;
esp8266_imsg_send_t *imsg_send;
esp8266_imsg_close_t *imsg_close;
esp8266_imsg_domain_parse_t *imsg_domain_parse;
if (event & TOS_EVTDRV_SYS_EVENT_INIT) {
return TOS_EVTDRV_SYS_EVENT_INIT;
}
if (event & TOS_EVTDRV_SYS_EVENT_MSG) {
while (event_hdr = (esp8266_event_hdr_t *)tos_evtdrv_msg_recv()) {
switch (event_hdr->event) {
case EVENT_IMSG_ESP8266_INIT:
imsg_init = (esp8266_imsg_init_t *)event_hdr;
CONTEXT(caller_task_id) = event_hdr->sender_id;
CONTEXT(self_task_id) = imsg_init->esp8266_task_id;
CONTEXT(try) = 0;
if (tos_at_init(imsg_init->uart_port, imsg_init->at_task_id, esp8266_at_event,
sizeof(esp8266_at_event) / sizeof(esp8266_at_event[0])) != 0) {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
break;
}
if (tos_sal_module_register(&sal_module_esp8266) != 0) {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
break;
}
tos_sal_module_init();
break;
case EVENT_IMSG_ESP8266_JOIN_AP:
imsg_join_ap = (esp8266_imsg_join_ap_t *)event_hdr;
CONTEXT(ssid) = imsg_join_ap->ssid;
CONTEXT(pwd) = imsg_join_ap->pwd;
esp8266_do_join_ap(imsg_join_ap->ssid, imsg_join_ap->pwd);
break;
case EVENT_IMSG_ESP8266_CONNECT:
imsg_connect = (esp8266_imsg_connect_t *)event_hdr;
if (esp8266_do_connect(imsg_connect->ip, imsg_connect->port, imsg_connect->proto) < 0) {
esp8266_connect_msg_reply(-1);
}
break;
case EVENT_IMSG_ESP8266_SEND:
imsg_send = (esp8266_imsg_send_t *)event_hdr;
CONTEXT(send_info).sockid = imsg_send->sockid;
CONTEXT(send_info).buf = imsg_send->buf;
CONTEXT(send_info).len = imsg_send->len;
if (esp8266_do_send_ready(imsg_send->sockid, imsg_send->buf, imsg_send->len) != 0) {
esp8266_send_msg_reply(-1);
}
break;
case EVENT_IMSG_ESP8266_CLOSE:
imsg_close = (esp8266_imsg_close_t *)event_hdr;
esp8266_do_close(imsg_close->sockid);
break;
case EVENT_IMSG_ESP8266_DOMAIN_PARSE:
imsg_domain_parse = (esp8266_imsg_domain_parse_t *)event_hdr;
CONTEXT(domain_parse_info).host_ip = imsg_domain_parse->host_ip;
CONTEXT(domain_parse_info).host_ip_len = imsg_domain_parse->host_ip_len;
esp8266_do_parse_domain(imsg_domain_parse->host_name, imsg_domain_parse->host_ip, imsg_domain_parse->host_ip_len);
break;
}
tos_evtdrv_msg_free((evtdrv_msg_body_t)event_hdr);
}
return TOS_EVTDRV_SYS_EVENT_MSG;
}
if (event & EVENT_INTERNAL_ESP8266_INIT) {
esp8266_restore();
return EVENT_INTERNAL_ESP8266_INIT;
}
if (event & EVENT_INTERNAL_ESP8266_RESTORE) {
at_delay_ms(3000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
if (CONTEXT(try)++ < 10) {
esp8266_restore();
} else {
printf("restore failed\n");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
}
} else {
esp8266_echo_close();
}
CONTEXT(try) = 0;
return EVENT_INTERNAL_ESP8266_RESTORE;
}
if (event & EVENT_INTERNAL_ESP8266_ECHO_CLOSE) {
at_delay_ms(2000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
printf("echo close failed\n");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
} else {
esp8266_net_mode_set(SAL_NET_MODE_STA);
}
return EVENT_INTERNAL_ESP8266_ECHO_CLOSE;
}
if (event & EVENT_INTERNAL_ESP8266_NET_MODE_SET) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK &&
CONTEXT(echo).status != AT_ECHO_STATUS_EXPECT) {
if (CONTEXT(try)++ < 10) {
esp8266_net_mode_set(SAL_NET_MODE_STA);
} else {
printf("net mode set failed\n");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
}
} else {
esp8266_send_mode_set(SAL_SEND_MODE_NORMAL);
}
CONTEXT(try) = 0;
return EVENT_INTERNAL_ESP8266_NET_MODE_SET;
}
if (event & EVENT_INTERNAL_ESP8266_SEND_MODE_SET) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
if (CONTEXT(try)++ < 10) {
esp8266_send_mode_set(SAL_SEND_MODE_NORMAL);
} else {
printf("send mode set failed\n");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
}
} else {
esp8266_multilink_set(SAL_MULTILINK_STATE_ENABLE);
}
CONTEXT(try) = 0;
return EVENT_INTERNAL_ESP8266_SEND_MODE_SET;
}
if (event & EVENT_INTERNAL_ESP8266_MULTILINK_SET) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
if (CONTEXT(try)++ < 10) {
esp8266_multilink_set(SAL_MULTILINK_STATE_ENABLE);
} else {
printf("multilink set failed\n");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, -1);
}
} else {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_INIT, 0);
}
CONTEXT(try) = 0;
return EVENT_INTERNAL_ESP8266_MULTILINK_SET;
}
if (event & EVENT_INTERNAL_ESP8266_JOIN_AP) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_EXPECT) {
if (CONTEXT(try)++ < 10) {
esp8266_do_join_ap(CONTEXT(ssid), CONTEXT(pwd));
} else {
printf("esp8266 join ap failed");
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_JOIN_AP, -1);
}
} else {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_JOIN_AP, 0);
}
CONTEXT(try) = 0;
return EVENT_INTERNAL_ESP8266_JOIN_AP;
}
if (event & EVENT_INTERNAL_ESP8266_CONNECT) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_EXPECT &&
CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
printf("esp8266 connect failed\n");
esp8266_connect_msg_reply(-1);
} else {
esp8266_connect_msg_reply(CONTEXT(sockid));
}
return EVENT_INTERNAL_ESP8266_CONNECT;
}
if (event & EVENT_INTERNAL_ESP8266_SEND_READY) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK &&
CONTEXT(echo).status != AT_ECHO_STATUS_EXPECT) {
if (esp8266_is_link_broken((const char *)CONTEXT(echo).buffer)) {
tos_at_channel_set_broken(CONTEXT(sockid));
}
esp8266_send_msg_reply(-1);
} else {
esp8266_do_send(CONTEXT(send_info).sockid, CONTEXT(send_info).buf, CONTEXT(send_info).len);
}
return EVENT_INTERNAL_ESP8266_SEND_READY;
}
if (event & EVENT_INTERNAL_ESP8266_SEND) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_EXPECT) {
if (esp8266_is_link_broken((const char *)CONTEXT(echo).buffer)) {
tos_at_channel_set_broken(CONTEXT(sockid));
}
esp8266_send_msg_reply(-1);
} else {
esp8266_send_msg_reply(CONTEXT(send_info).len);
}
return EVENT_INTERNAL_ESP8266_SEND;
}
if (event & EVENT_INTERNAL_ESP8266_DOMAIN_PARSE) {
at_delay_ms(1000);
if (CONTEXT(echo).status != AT_ECHO_STATUS_OK) {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_DOMAIN_PARSE, -1);
} else {
/*
+CIPDOMAIN:183.232.231.172
*/
char *str = strstr((const char *)CONTEXT(echo_buffer), "+CIPDOMAIN:");
if (!str) {
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_DOMAIN_PARSE, -1);
} else {
char *host_ip_buffer = CONTEXT(domain_parse_info).host_ip;
size_t host_ip_buffer_len = CONTEXT(domain_parse_info).host_ip_len;
sscanf(str, "+CIPDOMAIN:%s", host_ip_buffer);
host_ip_buffer[host_ip_buffer_len - 1] = '\0';
printf("GOT IP: %s\n", host_ip_buffer);
esp8266_common_msg_reply(EVENT_OMSG_ESP8266_DOMAIN_PARSE, 0);
}
}
return EVENT_INTERNAL_ESP8266_DOMAIN_PARSE;
}
return TOS_EVTDRV_EVENT_NONE;
}
Reference in New Issue View Git Blame Copy Permalink