libs/at_device
libs
/
at_device
4
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #63 from Lawlieta/master 

修复 sim76xx 设备已知问题，修复部分设备线程栈过小问题，格式化代码
This commit is contained in:
朱天龙 (Armink) 2019-08-25 09:58:09 +08:00 committed by GitHub
parent dd11316384 4db8bb797c
commit 35c0a87449
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 618 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -15,7 +15,7 @@ AT device 软件包是由 RT-Thread AT 组件针对不同 AT 设备的移植文
| class/esp8266 | ESP8266 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/rw007 | RW007 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/sim800c | SIM800C 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/sim76xx | SIM76XX 设备针对 AT 组件的移植目录，实现 AT Socket 功能（未完整适配，不建议使用） |
| class/sim76xx | SIM76XX 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/m26 | M26/MC20 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/ec20 | EC20 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |
| class/mw31 | MW31 设备针对 AT 组件的移植目录，实现 AT Socket 功能 |

46
class/ec20/at_device_ec20.c
View File

@ -35,7 +35,7 @@
#ifdef AT_DEVICE_USING_EC20
#define EC20_WAIT_CONNECT_TIME 5000
#define EC20_THREAD_STACK_SIZE 1024
#define EC20_THREAD_STACK_SIZE 2048
#define EC20_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2)
/* AT+QICSGP command default*/
@ -299,7 +299,7 @@ static int ec20_netdev_set_info(struct netdev *netdev)
{
#define IP_ADDR_SIZE_MAX 16
char ipaddr[IP_ADDR_SIZE_MAX] = {0};
resp = at_resp_set_info(resp, EC20_IPADDR_RESP_SIZE, 0, EC20_INFO_RESP_TIMO);
/* send "AT+QIACT?" commond to get IP address */
@ -316,7 +316,7 @@ static int ec20_netdev_set_info(struct netdev *netdev)
result = -RT_ERROR;
goto __exit;
}
LOG_D("ec20 device(%s) IP address: %s", device->name, ipaddr);
/* set network interface address information */
@ -339,7 +339,7 @@ static int ec20_netdev_set_info(struct netdev *netdev)
}
/* parse response data "+QIDNSCFG: <contextID>,<pridnsaddr>,<secdnsaddr>" */
if (at_resp_parse_line_args_by_kw(resp, "+QIDNSCFG:", "+QIDNSCFG: 1,\"%[^\"]\",\"%[^\"]\"",
if (at_resp_parse_line_args_by_kw(resp, "+QIDNSCFG:", "+QIDNSCFG: 1,\"%[^\"]\",\"%[^\"]\"",
dns_server1, dns_server2) <= 0)
{
LOG_E("ec20 device(%s) prase \"AT+QIDNSCFG=1\" commands resposne data error.", device->name);
@ -362,7 +362,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
@ -376,7 +376,7 @@ static void ec20_check_link_status_entry(void *parameter)
at_response_t resp = RT_NULL;
struct at_device *device = RT_NULL;
struct netdev *netdev = (struct netdev *) parameter;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
@ -400,7 +400,7 @@ static void ec20_check_link_status_entry(void *parameter)
{
netdev_low_level_set_link_status(netdev, RT_FALSE);
}
rt_thread_mdelay(EC20_LINK_DELAY_TIME);
continue;
}
@ -432,7 +432,7 @@ static void ec20_check_link_status_entry(void *parameter)
static int ec20_netdev_check_link_status(struct netdev *netdev)
{
#define EC20_LINK_THREAD_TICK 20
#define EC20_LINK_THREAD_STACK_SIZE 1024
#define EC20_LINK_THREAD_STACK_SIZE (1024 + 512)
#define EC20_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2)
rt_thread_t tid;
@ -444,7 +444,7 @@ static int ec20_netdev_check_link_status(struct netdev *netdev)
}
/* create ec20 link status polling thread */
tid = rt_thread_create("ec20_link", ec20_check_link_status_entry, (void *) netdev,
tid = rt_thread_create("ec20_link", ec20_check_link_status_entry, (void *) netdev,
EC20_LINK_THREAD_STACK_SIZE, EC20_LINK_THREAD_PRIORITY, EC20_LINK_THREAD_TICK);
if (tid != RT_NULL)
{
@ -520,7 +520,7 @@ static int ec20_netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, ip
LOG_E("get ec20 device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
resp = at_create_resp(EC20_DNS_RESP_LEN, 0, EC20_DNS_RESP_TIMEO);
if (resp == RT_NULL)
{
@ -543,12 +543,12 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
#ifdef NETDEV_USING_PING
static int ec20_netdev_ping(struct netdev *netdev, const char *host,
static int ec20_netdev_ping(struct netdev *netdev, const char *host,
size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp)
{
#define EC20_PING_RESP_SIZE 128
@ -621,7 +621,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
#endif /* NETDEV_USING_PING */
@ -748,7 +748,7 @@ static void ec20_init_thread_entry(void *parameter)
}
/* Use AT+GSN to query the IMEI of module */
AT_SEND_CMD(client, resp, 0, 300, "AT+GSN");
/* check SIM card */
AT_SEND_CMD(client, resp, 2, 5 * 1000, "AT+CPIN?");
if (!at_resp_get_line_by_kw(resp, "READY"))
@ -759,8 +759,8 @@ static void ec20_init_thread_entry(void *parameter)
}
/* waiting for dirty data to be digested */
rt_thread_mdelay(10);
/* Use AT+CIMI to query the IMSI of SIM card */
// AT_SEND_CMD(client, resp, 2, 300, "AT+CIMI");
i = 0;
@ -786,7 +786,7 @@ static void ec20_init_thread_entry(void *parameter)
at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &qi_arg[0], &qi_arg[1]);
if (qi_arg[0] != 99)
{
LOG_D("ec20 device(%s) signal strength: %d, channel bit error rate: %d",
LOG_D("ec20 device(%s) signal strength: %d, channel bit error rate: %d",
device->name, qi_arg[0], qi_arg[1]);
break;
}
@ -803,7 +803,7 @@ static void ec20_init_thread_entry(void *parameter)
{
AT_SEND_CMD(client, resp, 0, 300, "AT+CREG?");
at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data);
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
!rt_strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("ec20 device(%s) GSM network is registered(%s)", device->name, parsed_data);
@ -822,7 +822,7 @@ static void ec20_init_thread_entry(void *parameter)
{
AT_SEND_CMD(client, resp, 0, 300, "AT+CGREG?");
at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data);
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
!rt_strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("ec20 device(%s) GPRS network is registered(%s)", device->name, parsed_data);
@ -928,7 +928,7 @@ static int ec20_net_init(struct at_device *device)
#else
ec20_init_thread_entry(device);
#endif /* AT_DEVICE_EC20_INIT_ASYN */
return RT_EOK;
}
@ -965,7 +965,7 @@ static int ec20_init(struct at_device *device)
rt_pin_mode(ec20->power_pin, PIN_MODE_OUTPUT);
rt_pin_mode(ec20->power_status_pin, PIN_MODE_INPUT);
}
/* initialize ec20 device network */
return ec20_netdev_set_up(device->netdev);
}
@ -1005,7 +1005,7 @@ static int ec20_control(struct at_device *device, int cmd, void *arg)
return result;
}
const struct at_device_ops ec20_device_ops =
const struct at_device_ops ec20_device_ops =
{
ec20_init,
ec20_deinit,
@ -1028,7 +1028,7 @@ static int ec20_device_class_register(void)
ec20_socket_class_register(class);
#endif
class->device_ops = &ec20_device_ops;
return at_device_class_register(class, AT_DEVICE_CLASS_EC20);
}
INIT_DEVICE_EXPORT(ec20_device_class_register);

2
class/ec20/at_device_ec20.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_EC20_SOCKETS_NUM 5
struct at_device_ec20
{
{
char *device_name;
char *client_name;

40
class/ec20/at_socket_ec20.c
View File

@ -52,7 +52,7 @@ static at_evt_cb_t at_evt_cb_set[] = {
[AT_SOCKET_EVT_RECV] = NULL,
[AT_SOCKET_EVT_CLOSED] = NULL,
};
static void at_tcp_ip_errcode_parse(int result)//TCP/IP_QIGETERROR
{
switch(result)
@ -308,7 +308,7 @@ static int ec20_socket_close(struct at_socket *socket)
at_response_t resp = RT_NULL;
int device_socket = (int) socket->user_data;
struct at_device *device = (struct at_device *) socket->device;
resp = at_create_resp(64, 0, 5 * RT_TICK_PER_SECOND);
if (resp == RT_NULL)
{
@ -318,7 +318,7 @@ static int ec20_socket_close(struct at_socket *socket)
/* default connection timeout is 10 seconds, but it set to 1 seconds is convenient to use.*/
result = at_obj_exec_cmd(device->client, resp, "AT+QICLOSE=%d,1", device_socket);
if (resp)
{
at_delete_resp(resp);
@ -341,7 +341,7 @@ static int ec20_socket_close(struct at_socket *socket)
* -2: wait socket event timeout
* -5: no memory
*/
static int ec20_socket_connect(struct at_socket *socket, char *ip, int32_t port,
static int ec20_socket_connect(struct at_socket *socket, char *ip, int32_t port,
enum at_socket_type type, rt_bool_t is_client)
{
uint32_t event = 0;
@ -361,7 +361,7 @@ static int ec20_socket_connect(struct at_socket *socket, char *ip, int32_t port,
return -RT_ENOMEM;
}
__retry:
__retry:
/* clear socket connect event */
event = SET_EVENT(device_socket, EC20_EVENT_CONN_OK | EC20_EVENT_CONN_FAIL);
ec20_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR);
@ -376,7 +376,7 @@ __retry:
/* contextID = 1 : use same contextID as AT+QICSGP & AT+QIACT */
/* local_port = 0 : local port assigned automatically */
/* access_mode = 1 : Direct push mode */
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+QIOPEN=1,%d,\"TCP\",\"%s\",%d,0,1", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -385,7 +385,7 @@ __retry:
break;
case AT_SOCKET_UDP:
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+QIOPEN=1,%d,\"UDP\",\"%s\",%d,0,1", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -407,7 +407,7 @@ __retry:
goto __exit;
}
/* waiting OK or failed result */
event_result = ec20_socket_event_recv(device,
event_result = ec20_socket_event_recv(device,
EC20_EVENT_CONN_OK | EC20_EVENT_CONN_FAIL, 1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -420,7 +420,7 @@ __retry:
{
if (retryed == RT_FALSE)
{
LOG_D("ec20 device(%s) socket(%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
LOG_D("ec20 device(%s) socket(%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
device->name, device_socket);
/* default connection timeout is 10 seconds, but it set to 1 seconds is convenient to use.*/
if (ec20_socket_close(socket) < 0)
@ -579,7 +579,7 @@ static int ec20_socket_send(struct at_socket *socket, const char *buff, size_t b
goto __exit;
}
/* waiting OK or failed result */
event_result = ec20_socket_event_recv(device,
event_result = ec20_socket_event_recv(device,
EC20_EVENT_SEND_OK | EC20_EVENT_SEND_FAIL, 1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -645,7 +645,7 @@ static int ec20_domain_resolve(const char *name, char ip[16])
{
LOG_E("get first initialization ec20 device failed.");
return -RT_ERROR;
}
}
/* the maximum response time is 60 seconds, but it set to 10 seconds is convenient to use. */
resp = at_create_resp(128, 0, 10 * RT_TICK_PER_SECOND);
@ -654,7 +654,7 @@ static int ec20_domain_resolve(const char *name, char ip[16])
LOG_E("no memory for ec20 device(%s) response structure.", device->name);
return -RT_ENOMEM;
}
/* clear EC20_EVENT_DOMAIN_OK */
ec20_socket_event_recv(device, EC20_EVENT_DOMAIN_OK, 0, RT_EVENT_FLAG_OR);
@ -663,7 +663,7 @@ static int ec20_domain_resolve(const char *name, char ip[16])
{
goto __exit;
}
if (result == RT_EOK)
{
for(i = 0; i < RESOLVE_RETRY; i++)
@ -694,7 +694,7 @@ static int ec20_domain_resolve(const char *name, char ip[16])
}
}
}
/* response timeout */
if (i == RESOLVE_RETRY)
{
@ -760,7 +760,7 @@ static void urc_send_func(struct at_client *client, const char *data, rt_size_t
struct at_device *device = RT_NULL;
struct at_device_ec20 *ec20 = RT_NULL;
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_CLIENT, client_name);
@ -820,7 +820,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_CLIENT, client_name);
if (device == RT_NULL)
{
@ -865,7 +865,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
rt_free(recv_buf);
return;
}
/* get at socket object by device socket descriptor */
socket = &(device->sockets[device_socket]);
@ -927,7 +927,7 @@ static void urc_dnsqip_func(struct at_client *client, const char *data, rt_size_
}
}
rt_memcpy(ec20->socket_data, recv_ip, sizeof(recv_ip));
ec20_socket_event_send(device, EC20_EVENT_DOMAIN_OK);
}
@ -962,7 +962,7 @@ static void urc_qiurc_func(struct at_client *client, const char *data, rt_size_t
}
}
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"SEND OK", "\r\n", urc_send_func},
{"SEND FAIL", "\r\n", urc_send_func},
@ -970,7 +970,7 @@ static const struct at_urc urc_table[] =
{"+QIURC:", "\r\n", urc_qiurc_func},
};
static const struct at_socket_ops ec20_socket_ops =
static const struct at_socket_ops ec20_socket_ops =
{
ec20_socket_connect,
ec20_socket_close,

48
class/esp8266/at_device_esp8266.c
View File

@ -35,7 +35,7 @@
#ifdef AT_DEVICE_USING_ESP8266
#define ESP8266_WAIT_CONNECT_TIME 5000
#define ESP8266_THREAD_STACK_SIZE 1024
#define ESP8266_THREAD_STACK_SIZE 2048
#define ESP8266_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
/* ============================= esp8266 network interface operations ============================= */
@ -51,7 +51,7 @@ static void esp8266_get_netdev_info(struct rt_work *work, void *work_data)
const char *resp_dns = "+CIPDNS_CUR:%s";
ip_addr_t ip_addr;
rt_uint32_t mac_addr[6] = {0};
rt_uint32_t num = 0;
rt_uint32_t num = 0;
rt_uint8_t dhcp_stat = 0;
struct rt_delayed_work *delay_work = (struct rt_delayed_work *)work;
struct at_device *device = (struct at_device *)work_data;
@ -69,7 +69,7 @@ static void esp8266_get_netdev_info(struct rt_work *work, void *work_data)
LOG_E("no memory for esp8266 device(%d) response structure.", device->name);
return;
}
/* send mac addr query commond "AT+CIFSR" and wait response */
if (at_obj_exec_cmd(client, resp, "AT+CIFSR") < 0)
{
@ -104,7 +104,7 @@ static void esp8266_get_netdev_info(struct rt_work *work, void *work_data)
netdev_low_level_set_netmask(netdev, &ip_addr);
inet_aton(ip, &ip_addr);
netdev_low_level_set_ipaddr(netdev, &ip_addr);
sscanf(mac, "%x:%x:%x:%x:%x:%x",
sscanf(mac, "%x:%x:%x:%x:%x:%x",
&mac_addr[0], &mac_addr[1], &mac_addr[2], &mac_addr[3], &mac_addr[4], &mac_addr[5]);
for (num = 0; num < netdev->hwaddr_len; num++)
{
@ -165,14 +165,14 @@ static int esp8266_net_init(struct at_device *device);
static int esp8266_netdev_set_up(struct netdev *netdev)
{
struct at_device *device = RT_NULL;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get esp8266 device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
if (device->is_init == RT_FALSE)
{
esp8266_net_init(device);
@ -186,19 +186,19 @@ static int esp8266_netdev_set_up(struct netdev *netdev)
static int esp8266_netdev_set_down(struct netdev *netdev)
{
struct at_device *device = RT_NULL;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get esp8266 device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
if (device->is_init == RT_TRUE)
{
device->is_init = RT_FALSE;
netdev_low_level_set_status(netdev, RT_FALSE);
LOG_D("the network interface device(%s) set down status", netdev->name);
LOG_D("the network interface device(%s) set down status", netdev->name);
}
return RT_EOK;
@ -251,7 +251,7 @@ static int esp8266_netdev_set_addr_info(struct netdev *netdev, ip_addr_t *ip_add
rt_memcpy(esp8266_netmask_addr, inet_ntoa(netdev->netmask), IPADDR_SIZE);
/* send addr info set commond "AT+CIPSTA_CUR=<ip>[,<gateway>,<netmask>]" and wait response */
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSTA_CUR=\"%s\",\"%s\",\"%s\"",
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSTA_CUR=\"%s\",\"%s\",\"%s\"",
esp8266_ip_addr, esp8266_gw_addr, esp8266_netmask_addr) < 0)
{
LOG_E("esp8266 device(%s) set address information failed.", device->name);
@ -374,7 +374,7 @@ __exit:
}
#ifdef NETDEV_USING_PING
static int esp8266_netdev_ping(struct netdev *netdev, const char *host,
static int esp8266_netdev_ping(struct netdev *netdev, const char *host,
size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp)
{
#define ESP8266_PING_IP_SIZE 16
@ -608,7 +608,7 @@ static void esp8266_init_thread_entry(void *parameter)
rt_size_t i = 0, retry_num = INIT_RETRY;
LOG_D("esp8266 device(%s) initialize start.", device->name);
/* wait esp8266 device startup finish */
if (at_client_obj_wait_connect(client, ESP8266_WAIT_CONNECT_TIME))
{
@ -621,7 +621,7 @@ static void esp8266_init_thread_entry(void *parameter)
LOG_E("no memory for esp8266 device(%d) response structure.", device->name);
return;
}
while (retry_num--)
{
/* reset module */
@ -643,10 +643,10 @@ static void esp8266_init_thread_entry(void *parameter)
AT_SEND_CMD(client, resp, "AT+CIPMUX=1");
/* connect to WiFi AP */
if (at_obj_exec_cmd(client, at_resp_set_info(resp, 128, 0, 20 * RT_TICK_PER_SECOND),
if (at_obj_exec_cmd(client, at_resp_set_info(resp, 128, 0, 20 * RT_TICK_PER_SECOND),
"AT+CWJAP=\"%s\",\"%s\"", esp8266->wifi_ssid, esp8266->wifi_password) != RT_EOK)
{
LOG_E("AT device(%s) network initialize failed, check ssid(%s) and password(%s).",
LOG_E("AT device(%s) network initialize failed, check ssid(%s) and password(%s).",
device->name, esp8266->wifi_ssid, esp8266->wifi_password);
result = -RT_ERROR;
goto __exit;
@ -658,7 +658,7 @@ static void esp8266_init_thread_entry(void *parameter)
break;
}
else
{
{
rt_thread_mdelay(1000);
LOG_I("esp8266 device(%s) initialize retry...", device->name);
}
@ -738,7 +738,7 @@ static void urc_func(struct at_client *client, const char *data, rt_size_t size)
if (device->is_init)
{
netdev_low_level_set_link_status(device->netdev, RT_TRUE);
esp8266_netdev_start_delay_work(device);
}
}
@ -753,7 +753,7 @@ static void urc_func(struct at_client *client, const char *data, rt_size_t size)
}
}
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"busy p", "\r\n", urc_busy_p_func},
{"busy s", "\r\n", urc_busy_s_func},
@ -764,14 +764,14 @@ static const struct at_urc urc_table[] =
static int esp8266_init(struct at_device *device)
{
struct at_device_esp8266 *esp8266 = (struct at_device_esp8266 *) device->user_data;
/* initialize AT client */
at_client_init(esp8266->client_name, esp8266->recv_line_num);
device->client = at_client_get(esp8266->client_name);
if (device->client == RT_NULL)
{
LOG_E("esp8266 device(%s) initialize failed, get AT client(%s) failed.",
LOG_E("esp8266 device(%s) initialize failed, get AT client(%s) failed.",
esp8266->device_name, esp8266->client_name);
return -RT_ERROR;
}
@ -819,7 +819,7 @@ static int esp8266_reset(struct at_device *device)
/* initialize esp8266 device network */
esp8266_net_init(device);
device->is_init = RT_TRUE;
return result;
@ -843,11 +843,11 @@ static int esp8266_wifi_info_set(struct at_device *device, struct at_device_ssid
LOG_E("no memory for esp8266 device(%s) response structure.", device->name);
return -RT_ENOMEM;
}
/* connect to input wifi ap */
if (at_obj_exec_cmd(device->client, resp, "AT+CWJAP=\"%s\",\"%s\"", info->ssid, info->password) != RT_EOK)
{
LOG_E("esp8266 device(%s) wifi connect failed, check ssid(%s) and password(%s).",
LOG_E("esp8266 device(%s) wifi connect failed, check ssid(%s) and password(%s).",
device->name, info->ssid, info->password);
result = -RT_ERROR;
}
@ -894,7 +894,7 @@ static int esp8266_control(struct at_device *device, int cmd, void *arg)
return result;
}
static const struct at_device_ops esp8266_device_ops =
static const struct at_device_ops esp8266_device_ops =
{
esp8266_init,
esp8266_deinit,

2
class/esp8266/at_device_esp8266.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_ESP8266_SOCKETS_NUM 5
struct at_device_esp8266
{
{
char *device_name;
char *client_name;

16
class/esp8266/at_socket_esp8266.c
View File

@ -99,7 +99,7 @@ static int esp8266_socket_close(struct at_socket *socket)
{
at_delete_resp(resp);
}
return result;
}
@ -142,7 +142,7 @@ __retry:
{
case AT_SOCKET_TCP:
/* send AT commands to connect TCP server */
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+CIPSTART=%d,\"TCP\",\"%s\",%d,60", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -150,7 +150,7 @@ __retry:
break;
case AT_SOCKET_UDP:
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+CIPSTART=%d,\"UDP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -166,7 +166,7 @@ __retry:
if (result != RT_EOK && retryed == RT_FALSE)
{
LOG_D("esp8266 device(%s) socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
LOG_D("esp8266 device(%s) socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
device->name, device_socket);
if (esp8266_socket_close(socket) < 0)
{
@ -262,7 +262,7 @@ static int esp8266_socket_send(struct at_socket *socket, const char *buff, size_
goto __exit;
}
/* waiting OK or failed result */
event_result = esp8266_socket_event_recv(device, ESP8266_EVENT_SEND_OK | ESP8266_EVENT_SEND_FAIL,
event_result = esp8266_socket_event_recv(device, ESP8266_EVENT_SEND_OK | ESP8266_EVENT_SEND_FAIL,
5 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -436,7 +436,7 @@ static void urc_close_func(struct at_client *client, const char *data, rt_size_t
int index = 0;
struct at_socket *socket = RT_NULL;
struct at_device *device = RT_NULL;
char *client_name = client->device->parent.name;
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
@ -465,7 +465,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
char *recv_buf = RT_NULL, temp[8] = {0};
struct at_socket *socket = RT_NULL;
struct at_device *device = RT_NULL;
char *client_name = client->device->parent.name;
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
@ -523,7 +523,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
}
}
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"SEND OK", "\r\n", urc_send_func},
{"SEND FAIL", "\r\n", urc_send_func},

46
class/m26/at_device_m26.c
View File

@ -34,7 +34,7 @@
#ifdef AT_DEVICE_USING_M26
#define M26_WAIT_CONNECT_TIME 5000
#define M26_THREAD_STACK_SIZE 1024
#define M26_THREAD_STACK_SIZE 2048
#define M26_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2)
static void m26_power_on(struct at_device *device)
@ -172,7 +172,7 @@ static int m26_netdev_set_info(struct netdev *netdev)
{
#define IP_ADDR_SIZE_MAX 16
char ipaddr[IP_ADDR_SIZE_MAX] = {0};
at_resp_set_info(resp, M26_IPADDR_RESP_SIZE, 2, M26_INFO_RESP_TIMO);
/* send "AT+QILOCIP" commond to get IP address */
@ -188,7 +188,7 @@ static int m26_netdev_set_info(struct netdev *netdev)
result = -RT_ERROR;
goto __exit;
}
LOG_D("m26 device(%s) IP address: %s", device->name, ipaddr);
/* set network interface address information */
@ -233,7 +233,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
@ -264,8 +264,8 @@ static void check_link_status_entry(void *parameter)
}
while (1)
{
{
/* send "AT+QNSTATUS" commond to check netweork interface device link status */
if (at_obj_exec_cmd(device->client, resp, "AT+QNSTATUS") < 0)
{
@ -273,7 +273,7 @@ static void check_link_status_entry(void *parameter)
continue;
}
link_status = -1;
at_resp_parse_line_args_by_kw(resp, "+QNSTATUS:", "+QNSTATUS: %d", &link_status);
@ -290,7 +290,7 @@ static void check_link_status_entry(void *parameter)
static int m26_netdev_check_link_status(struct netdev *netdev)
{
#define M26_LINK_THREAD_TICK 20
#define M26_LINK_THREAD_STACK_SIZE 512
#define M26_LINK_THREAD_STACK_SIZE (1024 + 512)
#define M26_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2)
rt_thread_t tid;
@ -304,7 +304,7 @@ static int m26_netdev_check_link_status(struct netdev *netdev)
rt_snprintf(tname, RT_NAME_MAX, "%s_link", netdev->name);
tid = rt_thread_create(tname, check_link_status_entry, (void *)netdev,
tid = rt_thread_create(tname, check_link_status_entry, (void *)netdev,
M26_LINK_THREAD_STACK_SIZE, M26_LINK_THREAD_PRIORITY, M26_LINK_THREAD_TICK);
if (tid)
{
@ -406,7 +406,7 @@ __exit:
}
#ifdef NETDEV_USING_PING
static int m26_netdev_ping(struct netdev *netdev, const char *host,
static int m26_netdev_ping(struct netdev *netdev, const char *host,
size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp)
{
#define M26_PING_RESP_SIZE 128
@ -452,7 +452,7 @@ static int m26_netdev_ping(struct netdev *netdev, const char *host,
{
result = -RT_ERROR;
goto __exit;
}
}
}
/* prase response number */
@ -485,7 +485,7 @@ static int m26_netdev_ping(struct netdev *netdev, const char *host,
#ifdef NETDEV_USING_NETSTAT
static void m26_netdev_netstat(struct netdev *netdev)
{
{
// TODO netstat support
}
#endif /* NETDEV_USING_NETSTAT */
@ -586,7 +586,7 @@ static void m26_init_thread_entry(void *parameter)
result = -RT_ETIMEOUT;
goto __exit;
}
/* disable echo */
AT_SEND_CMD(client, resp, 0, 300, "ATE0");
/* get module version */
@ -639,7 +639,7 @@ static void m26_init_thread_entry(void *parameter)
{
AT_SEND_CMD(client, resp, 0, 300, "AT+CREG?");
at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data);
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
!rt_strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("m26 device(%s) GSM network is registered(%s).", device->name, parsed_data);
@ -658,7 +658,7 @@ static void m26_init_thread_entry(void *parameter)
{
AT_SEND_CMD(client, resp, 0, 300, "AT+CGREG?");
at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data);
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
if (!rt_strncmp(parsed_data, "0,1", sizeof(parsed_data)) ||
!rt_strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("m26 device(%s) GPRS network is registered(%s).", device->name, parsed_data);
@ -714,7 +714,7 @@ static void m26_init_thread_entry(void *parameter)
rt_thread_mdelay(1000);
LOG_I("m26 device(%s) initialize retry...", device->name);
}
}
}
if (resp)
@ -740,7 +740,7 @@ static int m26_net_init(struct at_device *device)
#ifdef AT_DEVICE_M26_INIT_ASYN
rt_thread_t tid;
tid = rt_thread_create("m26_net_init", m26_init_thread_entry, (void *)device,
tid = rt_thread_create("m26_net_init", m26_init_thread_entry, (void *)device,
M26_THREAD_STACK_SIZE, M26_THREAD_PRIORITY, 20);
if (tid)
{
@ -754,7 +754,7 @@ static int m26_net_init(struct at_device *device)
#else
m26_init_thread_entry(device);
#endif /* AT_DEVICE_M26_INIT_ASYN */
return RT_EOK;
}
@ -785,10 +785,10 @@ static int m26_init(struct at_device *device)
LOG_E("m26 device(%s) initialize failed, get AT client(%s) failed.", m26->device_name, m26->client_name);
return -RT_ERROR;
}
/* register URC data execution function */
at_obj_set_urc_table(device->client, urc_table, sizeof(urc_table) / sizeof(urc_table[0]));
#ifdef AT_USING_SOCKET
m26_socket_init(device);
#endif
@ -800,14 +800,14 @@ static int m26_init(struct at_device *device)
LOG_E("m26 device(%s) initialize failed, get network interface device failed.", m26->device_name);
return -RT_ERROR;
}
/* initialize m26 pin configuration */
if (m26->power_pin != -1 && m26->power_status_pin != -1)
{
rt_pin_mode(m26->power_pin, PIN_MODE_OUTPUT);
rt_pin_mode(m26->power_status_pin, PIN_MODE_INPUT);
}
/* initialize m26 device network */
return m26_netdev_set_up(device->netdev);
}
@ -846,7 +846,7 @@ static int m26_control(struct at_device *device, int cmd, void *arg)
return result;
}
static const struct at_device_ops m26_device_ops =
static const struct at_device_ops m26_device_ops =
{
m26_init,
m26_deinit,

2
class/m26/at_device_m26.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_M26_SOCKETS_NUM 6
struct at_device_m26
{
{
char *device_name;
char *client_name;

26
class/m26/at_socket_m26.c
View File

@ -46,7 +46,7 @@
#define M26_EVENT_CONN_FAIL (1L << 4)
#define M26_EVENT_SEND_FAIL (1L << 5)
static at_evt_cb_t at_evt_cb_set[] =
static at_evt_cb_t at_evt_cb_set[] =
{
[AT_SOCKET_EVT_RECV] = NULL,
[AT_SOCKET_EVT_CLOSED] = NULL,
@ -87,7 +87,7 @@ static int m26_socket_close(struct at_socket *socket)
at_response_t resp = RT_NULL;
int device_socke = (int) socket->user_data;
struct at_device *device = (struct at_device *) socket->device;
resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
if (resp == RT_NULL)
{
@ -104,7 +104,7 @@ static int m26_socket_close(struct at_socket *socket)
goto __exit;
}
if (m26_socket_event_recv(device, SET_EVENT(device_socke, M26_EVNET_CLOSE_OK),
if (m26_socket_event_recv(device, SET_EVENT(device_socke, M26_EVNET_CLOSE_OK),
rt_tick_from_millisecond(300 * 3), RT_EVENT_FLAG_AND) < 0)
{
LOG_E("m26 device(%s) socket(%d) close failed, wait close OK timeout.", device->name, device_socke);
@ -165,7 +165,7 @@ __retry:
{
case AT_SOCKET_TCP:
/* send AT commands(eg: AT+QIOPEN=0,"TCP","x.x.x.x", 1234) to connect TCP server */
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+QIOPEN=%d,\"TCP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -174,7 +174,7 @@ __retry:
break;
case AT_SOCKET_UDP:
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+QIOPEN=%d,\"UDP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -196,7 +196,7 @@ __retry:
goto __exit;
}
/* waiting OK or failed result */
if ((event_result = m26_socket_event_recv(device, M26_EVENT_CONN_OK | M26_EVENT_CONN_FAIL,
if ((event_result = m26_socket_event_recv(device, M26_EVENT_CONN_OK | M26_EVENT_CONN_FAIL,
1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR)) < 0)
{
LOG_E("m26 device(%s) socket(%d) connect failed, wait connect OK|FAIL timeout.", device->name, device_socket);
@ -208,7 +208,7 @@ __retry:
{
if (retryed == RT_FALSE)
{
LOG_D("m26 device(%s) socket(%d) connect failed, maybe the socket was not be closed and now will retry.",
LOG_D("m26 device(%s) socket(%d) connect failed, maybe the socket was not be closed and now will retry.",
device->name, device_socket);
if (m26_socket_close(socket) < 0)
{
@ -365,7 +365,7 @@ static int m26_socket_send(struct at_socket *socket, const char *buff, size_t bf
goto __exit;
}
/* waiting OK or failed result */
if ((event_result = m26_socket_event_recv(device, M26_EVENT_SEND_OK | M26_EVENT_SEND_FAIL,
if ((event_result = m26_socket_event_recv(device, M26_EVENT_SEND_OK | M26_EVENT_SEND_FAIL,
1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR)) < 0)
{
LOG_E("m26 device(%s) socket(%d) send failed, wait connect OK|FAIL timeout.", device->name, device_socket);
@ -511,7 +511,7 @@ static void urc_connect_func(struct at_client *client, const char *data, rt_size
}
sscanf(data, "%d%*[^0-9]", &device_socket);
if (rt_strstr(data, "CONNECT OK"))
{
m26_socket_event_send(device, SET_EVENT(device_socket, M26_EVENT_CONN_OK));
@ -562,7 +562,7 @@ static void urc_close_func(struct at_client *client, const char *data, rt_size_t
if (device == RT_NULL)
{
LOG_E("get m26 device by client name(%s) failed.", client_name);
return;
return;
}
sscanf(data, "%d%*s", &device_socket);
@ -597,7 +597,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_CLIENT, client_name);
if (device == RT_NULL)
{
@ -654,7 +654,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
}
}
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"", ", CONNECT OK\r\n", urc_connect_func},
{"", ", CONNECT FAIL\r\n", urc_connect_func},
@ -665,7 +665,7 @@ static const struct at_urc urc_table[] =
{"+RECEIVE:", "\r\n", urc_recv_func},
};
static const struct at_socket_ops m26_socket_ops =
static const struct at_socket_ops m26_socket_ops =
{
m26_socket_connect,
m26_socket_close,

2
class/mw31/at_device_mw31.c
View File

@ -34,7 +34,7 @@
#ifdef AT_DEVICE_USING_MW31
#define MW31_WAIT_CONNECT_TIME 5000
#define MW31_THREAD_STACK_SIZE 1024
#define MW31_THREAD_STACK_SIZE 2048
#define MW31_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
/* ============================= mw31 network interface operations ============================= */

16
class/rw007/at_device_rw007.c
View File

@ -35,7 +35,7 @@
#ifdef AT_DEVICE_USING_RW007
#define RW007_WAIT_CONNECT_TIME 5000
#define RW007_THREAD_STACK_SIZE 1024
#define RW007_THREAD_STACK_SIZE 2048
#define RW007_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
/* ============================= rw007 network interface operations ============================= */
@ -130,10 +130,10 @@ static void rw007_init_thread_entry(void *parameter)
LOG_D("%s", at_resp_get_line(resp, i + 1));
}
/* connect to WiFi AP */
if (at_obj_exec_cmd(client, at_resp_set_info(resp, 128, 0, 20 * RT_TICK_PER_SECOND),
if (at_obj_exec_cmd(client, at_resp_set_info(resp, 128, 0, 20 * RT_TICK_PER_SECOND),
"AT+CWJAP=\"%s\",\"%s\"", rw007->wifi_ssid, rw007->wifi_password) != RT_EOK)
{
LOG_E("rw007 device(%s) network initialize failed, check ssid(%s) and password(%s).",
LOG_E("rw007 device(%s) network initialize failed, check ssid(%s) and password(%s).",
device->name, rw007->wifi_ssid, rw007->wifi_password);
result = -RT_ERROR;
goto __exit;
@ -175,7 +175,7 @@ int rw007_net_init(struct at_device *device)
#ifdef AT_DEVICE_RW007_INIT_ASYN
rt_thread_t tid;
tid = rt_thread_create("rw007_net_init", rw007_init_thread_entry,
tid = rt_thread_create("rw007_net_init", rw007_init_thread_entry,
(void *)device, RW007_THREAD_STACK_SIZE, RW007_THREAD_PRIORITY, 20);
if (tid)
{
@ -244,7 +244,7 @@ static int rw007_init(struct at_device *device)
device->client = at_client_get(rw007->client_name);
if (device->client == RT_NULL)
{
LOG_E("rw007 device(%s) initialize failed, get AT client(%s) failed.",
LOG_E("rw007 device(%s) initialize failed, get AT client(%s) failed.",
rw007->device_name, rw007->client_name);
return -RT_ERROR;
}
@ -294,7 +294,7 @@ static int rw007_reset(struct at_device *device)
/* initialize rw007 device network */
rw007_net_init(device);
device->is_init = RT_TRUE;
return result;
@ -322,7 +322,7 @@ static int rw007_wifi_info_set(struct at_device *device, struct at_device_ssid_p
/* connect to input wifi ap */
if (at_obj_exec_cmd(device->client, resp, "AT+CWJAP=\"%s\",\"%s\"", info->ssid, info->password) != RT_EOK)
{
LOG_E("rw007 device(%s) wifi connect failed, check ssid(%s) and password(%s).",
LOG_E("rw007 device(%s) wifi connect failed, check ssid(%s) and password(%s).",
device->name, info->ssid, info->password);
result = -RT_ERROR;
}
@ -368,7 +368,7 @@ static int rw007_control(struct at_device *device, int cmd, void *arg)
return result;
}
const struct at_device_ops rw007_device_ops =
const struct at_device_ops rw007_device_ops =
{
rw007_init,
rw007_deinit,

2
class/rw007/at_device_rw007.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_RW007_SOCKETS_NUM 5
struct at_device_rw007
{
{
char *device_name;
char *client_name;

16
class/rw007/at_socket_rw007.c
View File

@ -99,7 +99,7 @@ static int rw007_socket_close(struct at_socket *socket)
{
at_delete_resp(resp);
}
return result;
}
@ -142,7 +142,7 @@ __retry:
{
case AT_SOCKET_TCP:
/* send AT commands to connect TCP server */
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+CIPSTART=%d,\"TCP\",\"%s\",%d,60", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -150,7 +150,7 @@ __retry:
break;
case AT_SOCKET_UDP:
if (at_obj_exec_cmd(device->client, resp,
if (at_obj_exec_cmd(device->client, resp,
"AT+CIPSTART=%d,\"UDP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -166,7 +166,7 @@ __retry:
if (result != RT_EOK && retryed == RT_FALSE)
{
LOG_D("rw007 device(%s) socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
LOG_D("rw007 device(%s) socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
device->name, socket);
if (rw007_socket_close(socket) < 0)
{
@ -262,7 +262,7 @@ static int rw007_socket_send(struct at_socket *socket, const char *buff, size_t
goto __exit;
}
/* waiting OK or failed result */
event_result = rw007_socket_event_recv(device, RW007_EVENT_SEND_OK | RW007_EVENT_SEND_FAIL,
event_result = rw007_socket_event_recv(device, RW007_EVENT_SEND_OK | RW007_EVENT_SEND_FAIL,
5 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -436,7 +436,7 @@ static void urc_close_func(struct at_client *client, const char *data, rt_size_t
int device_socket = 0;
struct at_socket *socket = RT_NULL;
struct at_device *device = RT_NULL;
char *client_name = client->device->parent.name;
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
@ -466,7 +466,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
char *recv_buf = RT_NULL, temp[8] = {0};
struct at_socket *socket = RT_NULL;
struct at_device *device = RT_NULL;
char *client_name = client->device->parent.name;
char *client_name = client->device->parent.name;
RT_ASSERT(data && size);
@ -525,7 +525,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
}
}
static struct at_urc urc_table[] =
static struct at_urc urc_table[] =
{
{"SEND OK", "\r\n", urc_send_func},
{"SEND FAIL", "\r\n", urc_send_func},

554
class/sim76xx/at_device_sim76xx.c
View File

@ -23,6 +23,7 @@
* 2019-03-06 thomasonegd fix udp connection.
* 2019-03-08 thomasonegd add power_on & power_off api
* 2019-05-14 chenyong multi AT socket client support
* 2019-08-24 chenyong add netdev support
*/
#include <stdio.h>
@ -36,12 +37,10 @@
#ifdef AT_DEVICE_USING_SIM76XX
#define SIM76XX_WAIT_CONNECT_TIME 5000
#define SIM76XX_THREAD_STACK_SIZE 1024
#define SIM76XX_THREAD_STACK_SIZE 2048
#define SIM76XX_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
/**
* power up sim76xx modem
*/
/* power up sim76xx modem */
static void sim76xx_power_on(struct at_device *device)
{
struct at_device_sim76xx *sim76xx = RT_NULL;
@ -67,6 +66,7 @@ static void sim76xx_power_on(struct at_device *device)
rt_pin_write(sim76xx->power_pin, PIN_LOW);
}
/* power off sim76xx modem */
static void sim76xx_power_off(struct at_device *device)
{
struct at_device_sim76xx *sim76xx = RT_NULL;
@ -94,6 +94,348 @@ static void sim76xx_power_off(struct at_device *device)
/* ============================= sim76xx network interface operations ============================= */
/* set sim76xx network interface device status and address information */
static int sim76xx_netdev_set_info(struct netdev *netdev)
{
#define SIM76XX_IEMI_RESP_SIZE 256
#define SIM76XX_IPADDR_RESP_SIZE 64
#define SIM76XX_DNS_RESP_SIZE 96
#define SIM76XX_INFO_RESP_TIMO rt_tick_from_millisecond(300)
int result = RT_EOK;
ip_addr_t addr;
at_response_t resp = RT_NULL;
struct at_device *device = RT_NULL;
if (netdev == RT_NULL)
{
LOG_E("input network interface device is NULL.");
return -RT_ERROR;
}
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get sim76xx device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
/* set network interface device status */
netdev_low_level_set_status(netdev, RT_TRUE);
netdev_low_level_set_link_status(netdev, RT_TRUE);
netdev_low_level_set_dhcp_status(netdev, RT_TRUE);
resp = at_create_resp(SIM76XX_IEMI_RESP_SIZE, 0, SIM76XX_INFO_RESP_TIMO);
if (resp == RT_NULL)
{
LOG_E("sim76xx device(%s) set IP address failed, no memory for response object.", device->name);
result = -RT_ENOMEM;
goto __exit;
}
/* set network interface device hardware address(IEMI) */
{
#define SIM76XX_NETDEV_HWADDR_LEN 8
#define SIM76XX_IEMI_LEN 15
char iemi[SIM76XX_IEMI_LEN] = {0};
int i = 0, j = 0;
/* send "ATI" commond to get device IEMI */
if (at_obj_exec_cmd(device->client, resp, "ATI") < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (at_resp_parse_line_args_by_kw(resp, "IMEI:", "IMEI: %s", iemi) <= 0)
{
LOG_E("sim76xx device(%s) prase \"ATI\" commands resposne data error.", device->name);
result = -RT_ERROR;
goto __exit;
}
LOG_D("sim76xx device(%s) IEMI number: %s", device->name, iemi);
netdev->hwaddr_len = SIM76XX_NETDEV_HWADDR_LEN;
/* get hardware address by IEMI */
for (i = 0, j = 0; i < SIM76XX_NETDEV_HWADDR_LEN && j < SIM76XX_IEMI_LEN; i++, j += 2)
{
if (j != SIM76XX_IEMI_LEN - 1)
{
netdev->hwaddr[i] = (iemi[j] - '0') * 10 + (iemi[j + 1] - '0');
}
else
{
netdev->hwaddr[i] = (iemi[j] - '0');
}
}
}
/* set network interface device IP address */
{
#define IP_ADDR_SIZE_MAX 16
char ipaddr[IP_ADDR_SIZE_MAX] = {0};
at_resp_set_info(resp, SIM76XX_IPADDR_RESP_SIZE, 2, SIM76XX_INFO_RESP_TIMO);
/* send "AT+IPADDR" commond to get IP address */
if (at_obj_exec_cmd(device->client, resp, "AT+IPADDR") < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (at_resp_parse_line_args_by_kw(resp, "+IPADDR:", "+IPADDR: %s", ipaddr) <= 0)
{
LOG_E("sim76xx device(%s) prase \"AT+IPADDR\" commands resposne data error!", device->name);
result = -RT_ERROR;
goto __exit;
}
LOG_D("sim76xx device(%s) IP address: %s", device->name, ipaddr);
/* set network interface address information */
inet_aton(ipaddr, &addr);
netdev_low_level_set_ipaddr(netdev, &addr);
}
/* set network interface device dns server */
{
#define DEF_DNS_ADDR "114.114.114.114"
const char *dns_server = DEF_DNS_ADDR;
ip_addr_t addr;
/* not support get dns server address, using default dns server address */
inet_aton(dns_server, &addr);
netdev_low_level_set_dns_server(netdev, 0, &addr);
}
__exit:
if (resp)
{
at_delete_resp(resp);
}
return result;
}
/* check sim76xx device link_up status */
static void check_link_status_entry(void *parameter)
{
#define SIM76XX_LINK_STATUS_OK 1
#define SIM76XX_LINK_RESP_SIZE 64
#define SIM76XX_LINK_RESP_TIMO (3 * RT_TICK_PER_SECOND)
#define SIM76XX_LINK_DELAY_TIME (30 * RT_TICK_PER_SECOND)
at_response_t resp = RT_NULL;
int result_code, link_status;
struct at_device *device = RT_NULL;
struct netdev *netdev = (struct netdev *)parameter;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get sim76xx device by netdev name(%s) failed.", netdev->name);
return;
}
resp = at_create_resp(SIM76XX_LINK_RESP_SIZE, 0, SIM76XX_LINK_RESP_TIMO);
if (resp == RT_NULL)
{
LOG_E("sim76xx device(%s) set check link status failed, no memory for response object.", device->name);
return;
}
while (1)
{
/* send "AT+CGREG?" commond to check netweork interface device link status */
if (at_obj_exec_cmd(device->client, resp, "AT+CGREG?") < 0)
{
rt_thread_mdelay(SIM76XX_LINK_DELAY_TIME);
continue;
}
link_status = -1;
at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %d,%d", &result_code, &link_status);
/* check the network interface device link status */
if ((SIM76XX_LINK_STATUS_OK == link_status) != netdev_is_link_up(netdev))
{
netdev_low_level_set_link_status(netdev, (SIM76XX_LINK_STATUS_OK == link_status));
}
rt_thread_mdelay(SIM76XX_LINK_DELAY_TIME);
}
}
static int sim76xx_netdev_check_link_status(struct netdev *netdev)
{
#define SIM76XX_LINK_THREAD_TICK 20
#define SIM76XX_LINK_THREAD_STACK_SIZE (1024 + 512)
#define SIM76XX_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2)
rt_thread_t tid;
char tname[RT_NAME_MAX] = {0};
if (netdev == RT_NULL)
{
LOG_E("input network interface device is NULL.\n");
return -RT_ERROR;
}
rt_snprintf(tname, RT_NAME_MAX, "%s_link", netdev->name);
tid = rt_thread_create(tname, check_link_status_entry, (void *) netdev,
SIM76XX_LINK_THREAD_STACK_SIZE, SIM76XX_LINK_THREAD_PRIORITY, SIM76XX_LINK_THREAD_TICK);
if (tid)
{
rt_thread_startup(tid);
}
return RT_EOK;
}
static int sim76xx_net_init(struct at_device *device);
/* sim76xx network interface device set up status */
static int sim76xx_netdev_set_up(struct netdev *netdev)
{
struct at_device *device = RT_NULL;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get sim76xx device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
if (device->is_init == RT_FALSE)
{
sim76xx_net_init(device);
device->is_init = RT_TRUE;
netdev_low_level_set_status(netdev, RT_TRUE);
LOG_D("the network intterface device(%s) set up status.", netdev->name);
}
return RT_EOK;
}
/* sim76xx network interface device set down status */
static int sim76xx_netdev_set_down(struct netdev *netdev)
{
struct at_device *device = RT_NULL;
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get sim76xx device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
if (device->is_init == RT_TRUE)
{
sim76xx_power_off(device);
device->is_init = RT_FALSE;
netdev_low_level_set_status(netdev, RT_FALSE);
LOG_D("the network interface device(%s) set down status.", netdev->name);
}
return RT_EOK;
}
#ifdef NETDEV_USING_PING
/* sim76xx network interface device ping feature */
static int sim76xx_netdev_ping(struct netdev *netdev, const char *host,
size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp)
{
#define SIM76XX_PING_RESP_SIZE 128
#define SIM76XX_PING_IP_SIZE 16
#define SIM76XX_PING_TIMEO (12 * RT_TICK_PER_SECOND)
int result = RT_EOK;
int response, pkg_size, time, ttl;
char ip_addr[SIM76XX_PING_IP_SIZE] = {0};
at_response_t resp = RT_NULL;
struct at_device *device = RT_NULL;
RT_ASSERT(netdev);
RT_ASSERT(host);
RT_ASSERT(ping_resp);
device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name);
if (device == RT_NULL)
{
LOG_E("get sim76xx device by netdev name(%s) failed.", netdev->name);
return -RT_ERROR;
}
resp = at_create_resp(SIM76XX_PING_RESP_SIZE, 6, SIM76XX_PING_TIMEO);
if (resp == RT_NULL)
{
LOG_E("sim76xx device(%s) set dns server failed, no memory for response object.", device->name);
result = -RT_ERROR;
goto __exit;
}
/* send "AT+CIPPING=<dest_addr>,<dest_addr_type>[,<num_pings>[,<package_size>[,<interval_time>[,<wait_timer>[,<TTL>]]]]]"
commond to send ping request */
if (at_obj_exec_cmd(device->client, resp, "AT+CPING=\"%s\",1,1,%d,,,64", host, data_len) < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (at_resp_parse_line_args_by_kw(resp, "+CPING:", "+CPING:%d,%[^,],%d,%d,%d",
&response, ip_addr, &pkg_size, &time, &ttl) <= 0)
{
result = -RT_ERROR;
goto __exit;
}
/* 2 - ping timeout */
if (response == 2)
{
result = -RT_ETIMEOUT;
goto __exit;
}
inet_aton(ip_addr, &(ping_resp->ip_addr));
ping_resp->data_len = pkg_size;
/* reply time, in units of ms */
ping_resp->ticks = rt_tick_from_millisecond(time);
ping_resp->ttl = ttl;
__exit:
if (resp)
{
at_delete_resp(resp);
}
return result;
}
#endif /* NETDEV_USING_PING */
/* sim76xx network interface device operations */
const struct netdev_ops sim76xx_netdev_ops =
{
sim76xx_netdev_set_up,
sim76xx_netdev_set_down,
RT_NULL, /* not support set ip, netmask, gatway address */
RT_NULL, /* not support set DNS server address */
RT_NULL, /* not support set DHCP status */
#ifdef NETDEV_USING_PING
sim76xx_netdev_ping,
#endif
RT_NULL, /* not support netstat feature */
};
/* register sim76xx network interface */
static struct netdev *sim76xx_netdev_add(const char *netdev_name)
{
#define ETHERNET_MTU 1500
@ -111,7 +453,7 @@ static struct netdev *sim76xx_netdev_add(const char *netdev_name)
netdev->mtu = ETHERNET_MTU;
netdev->hwaddr_len = HWADDR_LEN;
netdev->ops = RT_NULL;
netdev->ops = &sim76xx_netdev_ops;
#ifdef SAL_USING_AT
extern int sal_at_netdev_set_pf_info(struct netdev * netdev);
@ -121,12 +463,6 @@ static struct netdev *sim76xx_netdev_add(const char *netdev_name)
netdev_register(netdev, netdev_name, RT_NULL);
/*TODO: improve netdev adaptation */
netdev_low_level_set_status(netdev, RT_TRUE);
netdev_low_level_set_link_status(netdev, RT_TRUE);
netdev_low_level_set_dhcp_status(netdev, RT_TRUE);
netdev->flags |= NETDEV_FLAG_INTERNET_UP;
return netdev;
}
@ -142,13 +478,14 @@ static struct netdev *sim76xx_netdev_add(const char *netdev_name)
} \
} while(0) \
/* initialize the sim76xx device network connection by command */
static void sim76xx_init_thread_entry(void *parameter)
{
#define INIT_RETRY 5
#define CSQ_RETRY 20
#define CPIN_RETRY 5
#define CSQ_RETRY 10
#define CREG_RETRY 10
#define CGREG_RETRY 20
#define CGREG_RETRY 10
#define CGATT_RETRY 10
#define CCLK_RETRY 10
@ -173,7 +510,6 @@ static void sim76xx_init_thread_entry(void *parameter)
{
/* power-up sim76xx */
sim76xx_power_on(device);
rt_thread_mdelay(1000);
/* wait SIM76XX startup finish, Send AT every 5s, if receive OK, SYNC success*/
if (at_client_wait_connect(SIM76XX_WAIT_CONNECT_TIME))
@ -195,10 +531,21 @@ static void sim76xx_init_thread_entry(void *parameter)
}
/* check SIM card */
AT_SEND_CMD(client, resp, "AT+CPIN?");
if (!at_resp_get_line_by_kw(resp, "READY"))
rt_thread_mdelay(1000);
for (i = 0; i < CPIN_RETRY; i++)
{
at_obj_exec_cmd(client, resp, "AT+CPIN?");
if (at_resp_get_line_by_kw(resp, "READY"))
{
LOG_D("sim76xx device(%s) SIM card detection failed.", device->name);
break;
}
LOG_I("\"AT+CPIN\" commands send retry...");
rt_thread_mdelay(1000);
}
if (i == CPIN_RETRY)
{
LOG_E("sim76xx device(%s) SIM card detection failed.", device->name);
result = -RT_ERROR;
goto __exit;
}
@ -246,6 +593,7 @@ static void sim76xx_init_thread_entry(void *parameter)
result = -RT_ERROR;
goto __exit;
}
/* check the GPRS network is registered */
for (i = 0; i < CGREG_RETRY; i++)
{
@ -273,7 +621,7 @@ static void sim76xx_init_thread_entry(void *parameter)
at_resp_parse_line_args_by_kw(resp, "+CGATT:", "+CGATT: %s", &parsed_data);
if (!strncmp(parsed_data, "1", 1))
{
LOG_I("sim76xx device(%s) Packet domain attach.", device->name);
LOG_D("sim76xx device(%s) Packet domain attach.", device->name);
break;
}
@ -287,6 +635,26 @@ static void sim76xx_init_thread_entry(void *parameter)
goto __exit;
}
/* configure context */
AT_SEND_CMD(client, resp, "AT+CGDCONT=1,\"IP\",\"CMNET\"");
/* activate context */
{
int net_status = 0;
AT_SEND_CMD(client, resp, "AT+NETOPEN?");
at_resp_parse_line_args_by_kw(resp, "+NETOPEN:", "+NETOPEN: %d", &net_status);
/* 0 - netwoek close, 1 - network open */
if (net_status == 0)
{
AT_SEND_CMD(client, resp, "AT+NETOPEN");
}
}
/* set active PDP context's profile number */
AT_SEND_CMD(client, resp, "AT+CSOCKSETPN=1");
#ifdef RT_USING_RTC
/* get real time */
int year, month, day, hour, min, sec;
@ -317,16 +685,14 @@ static void sim76xx_init_thread_entry(void *parameter)
result = -RT_ERROR;
goto __exit;
}
#endif /* RT_USING_RTC */
/* set active PDP context's profile number */
AT_SEND_CMD(client, resp, "AT+CSOCKSETPN=1");
/* initialize successfully */
result = RT_EOK;
break;
__exit:
if (result == RT_EOK)
{
break;
}
else
if (result != RT_EOK)
{
/* power off the sim76xx device */
sim76xx_power_off(device);
@ -343,6 +709,10 @@ static void sim76xx_init_thread_entry(void *parameter)
if (result == RT_EOK)
{
/* set network interface device status and address information */
sim76xx_netdev_set_info(device->netdev);
sim76xx_netdev_check_link_status(device->netdev);
LOG_I("sim76xx devuce(%s) network initialize success!", device->name);
}
else
@ -374,128 +744,12 @@ int sim76xx_net_init(struct at_device *device)
return RT_EOK;
}
int sim76xx_ping(int argc, char **argv)
{
at_response_t resp = RT_NULL;
struct at_device *device = RT_NULL;
if (argc != 2)
{
rt_kprintf("Please input: at_ping <host address>\n");
return -RT_ERROR;
}
device = at_device_get_first_initialized();
if (device == RT_NULL)
{
rt_kprintf("get first initialized sim76xx device failed.\n");
return -RT_ERROR;
}
resp = at_create_resp(64, 0, 5 * RT_TICK_PER_SECOND);
if (resp == RT_NULL)
{
rt_kprintf("no memory for sim76xx device(%s) response structure.\n", device->name);
return -RT_ENOMEM;
}
if (at_obj_exec_cmd(device->client, resp, "AT+CPING=\"%s\",1,4,64,1000,10000,255", argv[1]) < 0)
{
if (resp)
{
at_delete_resp(resp);
}
rt_kprintf("sim76xx device(%s) send ping commands error.\n", device->name);
return -RT_ERROR;
}
if (resp)
{
at_delete_resp(resp);
}
return RT_EOK;
}
int sim76xx_ifconfig(void)
{
at_response_t resp = RT_NULL;
char resp_arg[AT_CMD_MAX_LEN] = {0};
rt_err_t result = RT_EOK;
struct at_device *device = RT_NULL;
device = at_device_get_first_initialized();
if (device == RT_NULL)
{
rt_kprintf("get first initialized sim76xx device failed.\n");
return -RT_ERROR;
}
resp = at_create_resp(128, 2, rt_tick_from_millisecond(300));
if (resp == RT_NULL)
{
rt_kprintf("no memory for sim76xx device(%s) response structure.\n", device->name);
return -RT_ENOMEM;
}
/* Show PDP address */
AT_SEND_CMD(device->client, resp, "AT+CGPADDR");
at_resp_parse_line_args_by_kw(resp, "+CGPADDR:", "+CGPADDR: %s", &resp_arg);
rt_kprintf("IP adress : %s\n", resp_arg);
__exit:
if (resp)
{
at_delete_resp(resp);
}
return result;
}
#ifdef FINSH_USING_MSH
#include <finsh.h>
MSH_CMD_EXPORT_ALIAS(sim76xx_net_init, at_net_init, initialize AT network);
MSH_CMD_EXPORT_ALIAS(sim76xx_ping, at_ping, AT ping network host);
MSH_CMD_EXPORT_ALIAS(sim76xx_ifconfig, at_ifconfig, list the information of network interfaces);
#endif
static void urc_ping_func(struct at_client *client, const char *data, rt_size_t size)
{
static int icmp_seq = 0;
int i, j = 0;
int result, recv_len, time, ttl;
int sent, rcvd, lost, min, max, avg;
char dst_ip[16] = {0};
RT_ASSERT(data);
for (i = 0; i < size; i++)
{
if (*(data + i) == '.')
j++;
}
if (j != 0)
{
sscanf(data, "+CPING: %d,%[^,],%d,%d,%d", &result, dst_ip, &recv_len, &time, &ttl);
if (result == 1)
LOG_I("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms", recv_len, dst_ip, icmp_seq++, ttl, time);
}
else
{
sscanf(data, "+CPING: %d,%d,%d,%d,%d,%d,%d", &result, &sent, &rcvd, &lost, &min, &max, &avg);
if (result == 3)
LOG_I("%d sent %d received %d lost, min=%dms max=%dms average=%dms", sent, rcvd, lost, min, max, avg);
if (result == 2)
LOG_I("ping requst timeout");
}
}
/* sim76xx device URC table for the device control */
static struct at_urc urc_table[] =
{
{"+CPING:", "\r\n", urc_ping_func},
};
/* initialize the sim76xx device network connection and register network interface device */
static int sim76xx_init(struct at_device *device)
{
struct at_device_sim76xx *sim76xx = (struct at_device_sim76xx *) device->user_data;
@ -510,9 +764,6 @@ static int sim76xx_init(struct at_device *device)
return -RT_ERROR;
}
/* register URC data execution function */
at_obj_set_urc_table(device->client, urc_table, sizeof(urc_table) / sizeof(urc_table[0]));
#ifdef AT_USING_SOCKET
sim76xx_socket_init(device);
#endif
@ -533,18 +784,16 @@ static int sim76xx_init(struct at_device *device)
}
/* initialize sim76xx device network */
sim76xx_net_init(device);
return RT_EOK;
return sim76xx_netdev_set_up(device->netdev);
}
/* deinit sim76xx device network connect */
static int sim76xx_deinit(struct at_device *device)
{
// TODO netdev operation
device->is_init = RT_FALSE;
return RT_EOK;
return sim76xx_netdev_set_down(device->netdev);
}
/* custom device control operations */
static int sim76xx_control(struct at_device *device, int cmd, void *arg)
{
int result = -RT_ERROR;
@ -582,6 +831,7 @@ const struct at_device_ops sim76xx_device_ops =
sim76xx_control,
};
/* register sim76xx class to the global at_device class list */
static int sim76xx_device_class_register(void)
{
struct at_device_class *class = RT_NULL;

2
class/sim76xx/at_device_sim76xx.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_SIM76XX_SOCKETS_NUM 10
struct at_device_sim76xx
{
{
char *device_name;
char *client_name;

273
class/sim76xx/at_socket_sim76xx.c
View File

@ -23,6 +23,7 @@
* 2019-03-06 thomasonegd fix udp connection.
* 2019-03-08 thomasonegd add power_on & power_off api
* 2019-05-14 chenyong multi AT socket client support
* 2019-08-24 chenyong add netdev support
*/
#include <stdio.h>
@ -37,6 +38,7 @@
#define SIM76XX_MODULE_SEND_MAX_SIZE 1500
#define SIM76XX_MAX_CONNECTIONS 10
#define SIM76XX_IPADDR_LEN 16
/* set real event by current socket and current state */
#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event))
@ -49,25 +51,25 @@
#define SIM76XX_EVENT_CONN_FAIL (1L << 4)
#define SIM76XX_EVENT_SEND_FAIL (1L << 5)
static at_evt_cb_t at_evt_cb_set[] =
static at_evt_cb_t at_evt_cb_set[] =
{
[AT_SOCKET_EVT_RECV] = NULL,
[AT_SOCKET_EVT_CLOSED] = NULL,
};
static char udp_ipstr[SIM76XX_MAX_CONNECTIONS][16];
static int udp_port[SIM76XX_MAX_CONNECTIONS];
static char udp_ipstr[SIM76XX_MAX_CONNECTIONS][SIM76XX_IPADDR_LEN] = {0};
static int udp_port[SIM76XX_MAX_CONNECTIONS] = {0};
/* unsolicited TCP/IP command<err> codes */
static void at_tcp_ip_errcode_parse(int result)
static void at_tcp_ip_errcode_parse(int result)
{
switch(result)
{
case 0 : LOG_D("%d : operation succeeded ", result); break;
case 0 : LOG_D("%d : operation succeeded ", result); break;
case 1 : LOG_E("%d : UNetwork failure", result); break;
case 2 : LOG_E("%d : Network not opened", result); break;
case 3 : LOG_E("%d : Wrong parameter", result); break;
case 4 : LOG_E("%d : Operation not supported", result); break;
case 4 : LOG_D("%d : Operation not supported", result); break;
case 5 : LOG_E("%d : Failed to create socket", result); break;
case 6 : LOG_E("%d : Failed to bind socket", result); break;
case 7 : LOG_E("%d : TCP server is already listening", result); break;
@ -111,8 +113,7 @@ static int sim76xx_socket_event_recv(struct at_device *device, uint32_t event, u
static int sim76xx_socket_close(struct at_socket *socket)
{
int result = RT_EOK;
int activated = 0;
uint8_t lnk_stat[10] = {0};
int lnk_stat[10] = {0};
at_response_t resp = RT_NULL;
int device_socket = (int) socket->user_data;
struct at_device *device = (struct at_device *) socket->device;
@ -134,7 +135,7 @@ static int sim76xx_socket_close(struct at_socket *socket)
}
if (at_resp_parse_line_args_by_kw(resp, "+CIPCLOSE:", "+CIPCLOSE: %d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
&lnk_stat[0], &lnk_stat[1], &lnk_stat[1], &lnk_stat[2], &lnk_stat[3], &lnk_stat[4],
&lnk_stat[0], &lnk_stat[1], &lnk_stat[2], &lnk_stat[3], &lnk_stat[4],
&lnk_stat[5], &lnk_stat[6], &lnk_stat[7], &lnk_stat[8], &lnk_stat[9]) < 0)
{
result = -RT_ERROR;
@ -143,33 +144,33 @@ static int sim76xx_socket_close(struct at_socket *socket)
if (lnk_stat[device_socket])
{
#define CLOSE_COUNTS 5
int i = 0;
/* close tcp or udp socket if connected */
if (at_obj_exec_cmd(device->client, resp, "AT+CIPCLOSE=%d", device_socket) < 0)
{
result = -RT_ERROR;
goto __exit;
}
}
/* check the network open or not */
if (at_obj_exec_cmd(device->client, resp, "AT+NETOPEN?") < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (at_resp_parse_line_args_by_kw(resp, "+NETOPEN:", "+NETOPEN: %d", &activated) < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (activated)
{
/* if already open,then close it */
if (at_obj_exec_cmd(device->client, resp, "AT+NETCLOSE") < 0)
/* wait sim76xx device sockt closed */
for (i = 0; i < CLOSE_COUNTS; i++)
{
result = -RT_ERROR;
goto __exit;
if (at_obj_exec_cmd(device->client, resp, "AT+CIPCLOSE?") < 0)
{
result = -RT_ERROR;
goto __exit;
}
at_resp_parse_line_args_by_kw(resp, "+CIPCLOSE:", "+CIPCLOSE: %d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
&lnk_stat[0], &lnk_stat[1], &lnk_stat[2], &lnk_stat[3], &lnk_stat[4],
&lnk_stat[5], &lnk_stat[6], &lnk_stat[7], &lnk_stat[8], &lnk_stat[9]);
if (lnk_stat[device_socket] == 0)
{
break;
}
rt_thread_delay(1000);
}
}
@ -182,59 +183,6 @@ static int sim76xx_socket_close(struct at_socket *socket)
return result;
}
/**
* open packet network
*/
static int sim76xx_network_socket_open(struct at_socket *socket)
{
int result = RT_EOK, activated = 0;
at_response_t resp = RT_NULL;
struct at_device *device = (struct at_device *) socket->device;
resp = at_create_resp(128, 0, 5 * RT_TICK_PER_SECOND);
if (resp == RT_NULL)
{
LOG_E("no memory for sim76xx device(%s) response structure.", device->name);
return -RT_ENOMEM;
}
/* check the network open or not */
if (at_obj_exec_cmd(device->client, resp, "AT+NETOPEN?") < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (at_resp_parse_line_args_by_kw(resp, "+NETOPEN:", "+NETOPEN: %d", &activated) < 0)
{
result = -RT_ERROR;
goto __exit;
}
if (activated)
{
/* network socket is already opened */
goto __exit;
}
else
{
/* if not opened the open it */
if (at_obj_exec_cmd(device->client, resp, "AT+NETOPEN") < 0)
{
result = -RT_ERROR;
goto __exit;
}
}
__exit:
if (resp)
{
at_delete_resp(resp);
}
return result;
}
/**
* create TCP/UDP client or server connect by AT commands.
*
@ -268,14 +216,14 @@ static int sim76xx_socket_connect(struct at_socket *socket, char *ip, int32_t po
return -RT_ENOMEM;
}
rt_mutex_take(lock, RT_WAITING_FOREVER);
rt_mutex_take(lock, RT_WAITING_FOREVER);
/* check and close current socket */
sim76xx_socket_close(socket);
__retry:
if (is_client)
{
/* open network socket first(AT+NETOPEN) */
sim76xx_network_socket_open(socket);
switch (type)
{
case AT_SOCKET_TCP:
@ -291,7 +239,7 @@ __retry:
{
result = -RT_ERROR;
}
strcpy(udp_ipstr[device_socket], ip);
rt_strncpy(udp_ipstr[device_socket], ip, SIM76XX_IPADDR_LEN);
udp_port[device_socket] = port;
break;
@ -314,16 +262,16 @@ __retry:
1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
LOG_E("sim76xx device(%s) socket(%d) connect failed, wait connect OK|FAIL timeout.", device->name, socket);
LOG_E("sim76xx device(%s) socket(%d) connect failed, wait connect OK|FAIL timeout.", device->name, device_socket);
result = -RT_ETIMEOUT;
goto __exit;
}
/* check result */
if (event_result & SIM76XX_EVENT_CONN_FAIL)
{
if (!retryed)
if (retryed == RT_FALSE)
{
LOG_E("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", socket);
LOG_D("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", device_socket);
if (sim76xx_socket_close(socket) < 0)
{
result = -RT_ERROR;
@ -332,23 +280,11 @@ __retry:
retryed = RT_TRUE;
goto __retry;
}
LOG_E("socket (%d) connect failed, failed to establish a connection.", socket);
LOG_E("socket (%d) connect failed, failed to establish a connection.", device_socket);
result = -RT_ERROR;
goto __exit;
}
if (result != RT_EOK && !retryed)
{
LOG_D("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", socket);
if (sim76xx_socket_close(socket) < 0)
{
goto __exit;
}
retryed = RT_TRUE;
result = RT_EOK;
goto __retry;
}
__exit:
rt_mutex_release(lock);
@ -411,12 +347,12 @@ static int sim76xx_socket_send(struct at_socket *socket, const char *buff, size_
{
cur_pkt_size = SIM76XX_MODULE_SEND_MAX_SIZE;
}
switch (socket->type)
{
case AT_SOCKET_TCP:
/* send the "AT+CIPSEND" commands to AT server than receive the '>' response on the first line. */
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSEND=%d,%d", device_socket, cur_pkt_size) < 0)
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSEND=%d,%d", device_socket, cur_pkt_size) < 0)
{
result = -RT_ERROR;
goto __exit;
@ -424,15 +360,18 @@ static int sim76xx_socket_send(struct at_socket *socket, const char *buff, size_
break;
case AT_SOCKET_UDP:
/* send the "AT+CIPSEND" commands to AT server than receive the '>' response on the first line. */
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSEND=%d,%d,\"%s\",%d",
if (at_obj_exec_cmd(device->client, resp, "AT+CIPSEND=%d,%d,\"%s\",%d",
device_socket, cur_pkt_size, udp_ipstr[device_socket], udp_port[device_socket]) < 0)
{
result = -RT_ERROR;
goto __exit;
}
break;
default:
LOG_E("input socket type(%d) error.", socket->type);
break;
}
/* send the real data to server or client */
result = (int) at_client_send(buff + sent_size, cur_pkt_size);
if (result == 0)
@ -465,11 +404,6 @@ static int sim76xx_socket_send(struct at_socket *socket, const char *buff, size_
goto __exit;
}
if (type == AT_SOCKET_TCP)
{
//cur_pkt_size = cur_send_bfsz;
}
sent_size += cur_pkt_size;
}
@ -599,43 +533,9 @@ static void urc_send_func(struct at_client *client, const char *data, rt_size_t
}
sscanf(data, "+CIPSEND: %d,%d,%d", &device_socket, &rqst_size, &cnf_size);
//cur_send_bfsz = cnf_size;
sim76xx_socket_event_send(device, SET_EVENT(device_socket, SIM76XX_EVENT_SEND_OK));
}
static void urc_ping_func(struct at_client *client, const char *data, rt_size_t size)
{
static int icmp_seq = 0;
int i, j = 0;
int result, recv_len, time, ttl;
int sent, rcvd, lost, min, max, avg;
char dst_ip[16] = {0};
RT_ASSERT(data);
for (i = 0; i < size; i++)
{
if (*(data + i) == '.')
j++;
}
if (j != 0)
{
sscanf(data, "+CPING: %d,%[^,],%d,%d,%d", &result, dst_ip, &recv_len, &time, &ttl);
if (result == 1)
LOG_I("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms", recv_len, dst_ip, icmp_seq++, ttl, time);
}
else
{
sscanf(data, "+CPING: %d,%d,%d,%d,%d,%d,%d", &result, &sent, &rcvd, &lost, &min, &max, &avg);
if (result == 3)
LOG_I("%d sent %d received %d lost, min=%dms max=%dms average=%dms", sent, rcvd, lost, min, max, avg);
if (result == 2)
LOG_I("ping requst timeout");
}
}
static void urc_connect_func(struct at_client *client, const char *data, rt_size_t size)
{
int device_socket = 0, result = 0;
@ -681,20 +581,6 @@ static void urc_close_func(struct at_client *client, const char *data, rt_size_t
}
sscanf(data, "+IPCLOSE %d,%d", &device_socket, &reason);
switch (reason)
{
case 0:
LOG_E("socket is closed by local,active");
break;
case 1:
LOG_E("socket is closed by remote,passive");
break;
case 2:
LOG_E("socket is closed for sending timeout");
break;
}
/* get AT socket object by device socket descriptor */
socket = &(device->sockets[device_socket]);
@ -775,78 +661,15 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
}
}
static struct at_urc urc_table[] =
static struct at_urc urc_table[] =
{
{"+CIPSEND:", "\r\n", urc_send_func},
{"+CIPOPEN:", "\r\n", urc_connect_func},
{"+CPING:", "\r\n", urc_ping_func},
{"+IPCLOSE", "\r\n", urc_close_func},
{"+IPD", "\r\n", urc_recv_func},
};
int sim76xx_connect(int argc, char **argv)
{
int32_t port;
if (argc != 3)
{
rt_kprintf("Please input: at_connect <host address>\n");
return -RT_ERROR;
}
sscanf(argv[2], "%d", &port);
sim76xx_socket_connect(at_get_socket(0), argv[1], port, AT_SOCKET_TCP, 1);
return RT_EOK;
}
int sim76xx_close(int argc, char **argv)
{
if (sim76xx_socket_close(at_get_socket(0)) < 0)
{
rt_kprintf("sim76xx_socket_close fail\n");
}
else
{
rt_kprintf("sim76xx_socket_closeed\n");
}
return RT_EOK;
}
int sim76xx_send(int argc, char **argv)
{
const char *buff = "1234567890\n";
if (sim76xx_socket_send(at_get_socket(0), buff, 11, AT_SOCKET_TCP) < 0)
{
rt_kprintf("sim76xx_socket_send fail\n");
}
return RT_EOK;
}
int sim76xx_domain(int argc, char **argv)
{
char ip[16];
if (sim76xx_domain_resolve("www.baidu.com", ip) < 0)
{
rt_kprintf("sim76xx_socket_send fail\n");
}
else
{
rt_kprintf("baidu.com : %s\n", ip);
}
return RT_EOK;
}
#ifdef FINSH_USING_MSH
#include <finsh.h>
MSH_CMD_EXPORT_ALIAS(sim76xx_connect, at_connect, AT connect network host);
MSH_CMD_EXPORT_ALIAS(sim76xx_close, at_close, AT close a socket);
MSH_CMD_EXPORT_ALIAS(sim76xx_send, at_send, AT send a pack);
MSH_CMD_EXPORT_ALIAS(sim76xx_domain, at_domain, AT domain resolve);
#endif
static const struct at_socket_ops sim76xx_socket_ops =
static const struct at_socket_ops sim76xx_socket_ops =
{
sim76xx_socket_connect,
sim76xx_socket_close,
@ -855,6 +678,7 @@ static const struct at_socket_ops sim76xx_socket_ops =
sim76xx_socket_set_event_cb,
};
/* initialize sim76xx device network URC feature */
int sim76xx_socket_init(struct at_device *device)
{
RT_ASSERT(device);
@ -865,6 +689,7 @@ int sim76xx_socket_init(struct at_device *device)
return RT_EOK;
}
/* resgiter sim76xx device socket operations */
int sim76xx_socket_class_register(struct at_device_class *class)
{
RT_ASSERT(class);

18
class/sim800c/at_device_sim800c.c
View File

@ -35,7 +35,7 @@
#ifdef AT_DEVICE_USING_SIM800C
#define SIM800C_WAIT_CONNECT_TIME 5000
#define SIM800C_THREAD_STACK_SIZE 1024
#define SIM800C_THREAD_STACK_SIZE 2048
#define SIM800C_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2)
/* AT+CSTT command default*/
@ -238,7 +238,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
@ -294,7 +294,7 @@ static void check_link_status_entry(void *parameter)
static int sim800c_netdev_check_link_status(struct netdev *netdev)
{
#define SIM800C_LINK_THREAD_TICK 20
#define SIM800C_LINK_THREAD_STACK_SIZE 512
#define SIM800C_LINK_THREAD_STACK_SIZE (1024 + 512)
#define SIM800C_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2)
rt_thread_t tid;
@ -308,7 +308,7 @@ static int sim800c_netdev_check_link_status(struct netdev *netdev)
rt_snprintf(tname, RT_NAME_MAX, "%s_link", netdev->name);
tid = rt_thread_create(tname, check_link_status_entry, (void *) netdev,
tid = rt_thread_create(tname, check_link_status_entry, (void *) netdev,
SIM800C_LINK_THREAD_STACK_SIZE, SIM800C_LINK_THREAD_PRIORITY, SIM800C_LINK_THREAD_TICK);
if (tid)
{
@ -459,7 +459,7 @@ __exit:
}
#ifdef NETDEV_USING_PING
static int sim800c_netdev_ping(struct netdev *netdev, const char *host,
static int sim800c_netdev_ping(struct netdev *netdev, const char *host,
size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp)
{
#define SIM800C_PING_RESP_SIZE 128
@ -518,7 +518,7 @@ static int sim800c_netdev_ping(struct netdev *netdev, const char *host,
}
/* send "AT+CIPPING=<IP addr>[,<retryNum>[,<dataLen>[,<timeout>[,<ttl>]]]]" commond to send ping request */
if (at_obj_exec_cmd(device->client, resp, "AT+CIPPING=%s,1,%d,%d,64",
if (at_obj_exec_cmd(device->client, resp, "AT+CIPPING=%s,1,%d,%d,64",
host, data_len, SIM800C_PING_TIMEO / (RT_TICK_PER_SECOND / 10)) < 0)
{
result = -RT_ERROR;
@ -557,7 +557,7 @@ static int sim800c_netdev_ping(struct netdev *netdev, const char *host,
#ifdef NETDEV_USING_NETSTAT
void sim800c_netdev_netstat(struct netdev *netdev)
{
{
// TODO netstat support
}
#endif /* NETDEV_USING_NETSTAT */
@ -856,7 +856,7 @@ static void urc_func(struct at_client *client, const char *data, rt_size_t size)
}
/* sim800c device URC table for the device control */
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"RDY", "\r\n", urc_func},
};
@ -936,7 +936,7 @@ static int sim800c_control(struct at_device *device, int cmd, void *arg)
return result;
}
const struct at_device_ops sim800c_device_ops =
const struct at_device_ops sim800c_device_ops =
{
sim800c_init,
sim800c_deinit,

2
class/sim800c/at_device_sim800c.h
View File

@ -37,7 +37,7 @@ extern "C" {
#define AT_DEVICE_SIM800C_SOCKETS_NUM 6
struct at_device_sim800c
{
{
char *device_name;
char *client_name;

22
class/sim800c/at_socket_sim800c.c
View File

@ -87,7 +87,7 @@ static int sim800c_socket_close(struct at_socket *socket)
at_response_t resp = RT_NULL;
int device_socket = (int) socket->user_data;
struct at_device *device = (struct at_device *) socket->device;
resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
if (resp == RT_NULL)
{
@ -98,7 +98,7 @@ static int sim800c_socket_close(struct at_socket *socket)
/* clear socket close event */
event = SET_EVENT(device_socket, SIM800C_EVNET_CLOSE_OK);
sim800c_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR);
if (at_obj_exec_cmd(device->client, resp, "AT+CIPCLOSE=%d", device_socket) < 0)
{
result = -RT_ERROR;
@ -117,7 +117,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
@ -167,7 +167,7 @@ __retry:
{
case AT_SOCKET_TCP:
/* send AT commands(eg: AT+QIOPEN=0,"TCP","x.x.x.x", 1234) to connect TCP server */
if (at_obj_exec_cmd(device->client, RT_NULL,
if (at_obj_exec_cmd(device->client, RT_NULL,
"AT+CIPSTART=%d,\"TCP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -176,7 +176,7 @@ __retry:
break;
case AT_SOCKET_UDP:
if (at_obj_exec_cmd(device->client, RT_NULL,
if (at_obj_exec_cmd(device->client, RT_NULL,
"AT+CIPSTART=%d,\"UDP\",\"%s\",%d", device_socket, ip, port) < 0)
{
result = -RT_ERROR;
@ -199,7 +199,7 @@ __retry:
goto __exit;
}
/* waiting OK or failed result */
event_result = sim800c_socket_event_recv(device,
event_result = sim800c_socket_event_recv(device,
SIM800C_EVENT_CONN_OK | SIM800C_EVENT_CONN_FAIL, 1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -212,7 +212,7 @@ __retry:
{
if (retryed == RT_FALSE)
{
LOG_D("sim800c device(%s) socket(%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
LOG_D("sim800c device(%s) socket(%d) connect failed, maybe the socket was not be closed at the last time and now will retry.",
device->name, device_socket);
if (sim800c_socket_close(socket) < 0)
{
@ -232,7 +232,7 @@ __exit:
{
at_delete_resp(resp);
}
return result;
}
@ -311,7 +311,7 @@ static int sim800c_socket_send(struct at_socket *socket, const char *buff, size_
goto __exit;
}
/* waiting OK or failed result */
event_result = sim800c_socket_event_recv(device,
event_result = sim800c_socket_event_recv(device,
SIM800C_EVENT_SEND_OK | SIM800C_EVENT_SEND_FAIL, 5 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
if (event_result < 0)
{
@ -611,7 +611,7 @@ static void urc_recv_func(struct at_client *client, const char *data, rt_size_t
}
/* sim800c device URC table for the socket data */
static const struct at_urc urc_table[] =
static const struct at_urc urc_table[] =
{
{"", ", CONNECT OK\r\n", urc_connect_func},
{"", ", CONNECT FAIL\r\n", urc_connect_func},
@ -622,7 +622,7 @@ static const struct at_urc urc_table[] =
{"+RECEIVE,", "\r\n", urc_recv_func},
};
static const struct at_socket_ops sim800c_socket_ops =
static const struct at_socket_ops sim800c_socket_ops =
{
sim800c_socket_connect,
sim800c_socket_close,

24
src/at_device.c
View File

@ -60,7 +60,7 @@ struct at_device *at_device_get_first_initialized(void)
}
rt_hw_interrupt_enable(level);
return RT_NULL;
}
@ -87,15 +87,15 @@ struct at_device *at_device_get_by_name(int type, const char *name)
device = rt_slist_entry(node, struct at_device, list);
if (device)
{
if (((type == AT_DEVICE_NAMETYPE_DEVICE) || (type == AT_DEVICE_NAMETYPE_NETDEV)) &&
if (((type == AT_DEVICE_NAMETYPE_DEVICE) || (type == AT_DEVICE_NAMETYPE_NETDEV)) &&
(rt_strncmp(device->name, name, rt_strlen(name)) == 0))
{
rt_hw_interrupt_enable(level);
return device;
}
else if ((type == AT_DEVICE_NAMETYPE_CLIENT) &&
else if ((type == AT_DEVICE_NAMETYPE_CLIENT) &&
(rt_strncmp(device->client->device->parent.name, name, rt_strlen(name)) == 0))
{
{
rt_hw_interrupt_enable(level);
return device;
}
@ -103,18 +103,18 @@ struct at_device *at_device_get_by_name(int type, const char *name)
}
rt_hw_interrupt_enable(level);
return RT_NULL;
}
#ifdef AT_USING_SOCKET
/**
* This function will get AT device by ip address.
*
*
* @param ip_addr input ip address
* network
* @return != NULL: network interface device object
* NULL: get failed
* NULL: get failed
*/
struct at_device *at_device_get_by_ipaddr(ip_addr_t *ip_addr)
{
@ -135,9 +135,9 @@ struct at_device *at_device_get_by_ipaddr(ip_addr_t *ip_addr)
}
rt_hw_interrupt_enable(level);
return RT_NULL;
return RT_NULL;
}
#endif /* AT_USING_SOCKET */
@ -150,7 +150,7 @@ struct at_device *at_device_get_by_ipaddr(ip_addr_t *ip_addr)
* @param arg the argument of command
*
* @return = 0: perform successfully
* < 0: perform failed
* < 0: perform failed
*/
int at_device_control(struct at_device *device, int cmd, void *arg)
{
@ -308,7 +308,7 @@ int at_device_register(struct at_device *device, const char *device_name,
}
rt_hw_interrupt_enable(level);
/* Initialize AT device */
result = class->device_ops->init(device);
if (result < 0)