diff --git a/README.md b/README.md index 03ed40e..69bd13f 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ ## 1. 简介 ## -AT device 软件包是由 RT-Thread AT 组件针对不同 AT 设备的移植文件和示例代码组成，目前支持的 AT 设备有：ESP8266、ESP32、M26、MC20、RW007、MW31、SIM800C、W60X 、SIM76XX、A9/A9G、BC26 、AIR720、ME3616系列设备等，目前上述设备都完成对 `AT socket` 功能的移植，及设备通过 AT 命令实现标准 socket 编程接口，完成 socket 通讯的功能，具体功能介绍可参考 [《RT-Thread 编程指南》](https://www.rt-thread.org/document/site/programming-manual/at/at/)AT 命令章节 。 +AT device 软件包是由 RT-Thread AT 组件针对不同 AT 设备的移植文件和示例代码组成，目前支持的 AT 设备有：ESP8266、ESP32、M26、MC20、RW007、MW31、SIM800C、W60X 、SIM76XX、A9/A9G、BC26 、AIR720、ME3616、M6315系列设备等，目前上述设备都完成对 `AT socket` 功能的移植，及设备通过 AT 命令实现标准 socket 编程接口，完成 socket 通讯的功能，具体功能介绍可参考 [《RT-Thread 编程指南》](https://www.rt-thread.org/document/site/programming-manual/at/at/)AT 命令章节 。 ### 1.1. 目录结构 ### @@ -26,6 +26,7 @@ AT device 软件包是由 RT-Thread AT 组件针对不同 AT 设备的移植文 | class/bc26 | bc26 设备针对 AT 组件的移植目录，实现 AT Socket 功能 | | class/air720 | air720 设备针对 AT 组件的移植目录，实现 AT Socket 功能 | | class/me3616 | me3616 设备针对 AT 组件的移植目录，实现 AT Socket 功能 | +| class/m6315 | m6315 设备针对 AT 组件的移植目录，实现 AT Socket 功能 | ### 1.2 许可证 ### at_device package 遵循 LGPLv2.1 许可，详见 `LICENSE` 文件。 @@ -69,7 +70,7 @@ AT device 软件包目前已经发布多个版本，各个版本之间选项配 Version (V1.6.0) ---> - **Enable at device init by thread**: 配置开启设备网络初始化是否通过创建线程完成； -- **AT socket device modules**: AT 设备选择，目前支持 RW007、ESP8266、M26/MC20、EC20、SIM800C、SIM76XX、A9/A9G、BC26 、air720、ME3616等设备； +- **AT socket device modules**: AT 设备选择，目前支持 RW007、ESP8266、M26/MC20、EC20、SIM800C、SIM76XX、A9/A9G、BC26 、air720、ME3616、M6315等设备； - **Version**: 下载软件包版本； **V2.X.X (laster) 版本配置选项介绍** @@ -105,6 +106,7 @@ RT-Thread online packages ---> [ ] Quectel BC26 ---> [ ] Luat air720 ---> [ ] GOSUNCN ME3616 ---> + [ ] ChinaMobile M6315 ---> Version (latest) ---> ``` @@ -133,6 +135,7 @@ RT-Thread online packages ---> - **Quectel BC26**：开启 BC26（NB-IOT 模块）设备支持； - **Luat Air720**：开启 air720（4g 模块）设备支持； - **GOSUNCN ME3616**：开启 ME3616（NB-IOT 模块）设备支持； +- **ChinaMobile M6315**：开启 M6315 （2G 模块）设备支持； - **Version** 下载软件包版本； 上面配置选项以 2G 模块和 WIFI 模块选项为例，介绍了`V2.X.X` 版本 AT device 软件包配置方式，如下几点值得注意： diff --git a/SConscript b/SConscript index 6143da2..c0059da 100644 --- a/SConscript +++ b/SConscript @@ -121,6 +121,15 @@ if GetDepend(['AT_DEVICE_USING_ME3616']): if GetDepend(['AT_DEVICE_ME3616_SAMPLE']): src += Glob('samples/at_sample_me3616.c') +# M6315 +if GetDepend(['AT_DEVICE_USING_M6315']): + path += [cwd + '/class/m6315'] + src += Glob('class/m6315/at_device_m6315.c') + if GetDepend(['AT_USING_SOCKET']): + src += Glob('class/m6315/at_socket_m6315.c') + if GetDepend(['AT_DEVICE_M6315_SAMPLE']): + src += Glob('samples/at_sample_m6315.c') + # BC28 if GetDepend(['AT_DEVICE_USING_BC28']): path += [cwd + '/class/bc28'] diff --git a/class/m6315/at_device_m6315.c b/class/m6315/at_device_m6315.c new file mode 100644 index 0000000..69f3770 --- /dev/null +++ b/class/m6315/at_device_m6315.c @@ -0,0 +1,969 @@ +/* + * File : at_socket_m6315.c + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2018-06-12 malongwei first version + * 2019-05-13 chenyong multi AT socket client support + */ + +#include +#include +#include + +#include + +#define LOG_TAG "at.dev.m6315" +#include + +#ifdef AT_DEVICE_USING_M6315 + +#define M6315_WAIT_CONNECT_TIME 5000 +#define M6315_THREAD_STACK_SIZE 2048 +#define M6315_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2) + + +static void m6315_power_on(struct at_device *device) +{ + struct at_device_m6315 *m6315 = RT_NULL; + + m6315 = (struct at_device_m6315 *) device->user_data; + + /* not nead to set pin configuration for m26 device power on */ + if (m6315->power_pin == -1 || m6315->power_status_pin == -1) + { + return; + } + + if (rt_pin_read(m6315->power_status_pin) == PIN_HIGH) + { + return; + } + rt_pin_write(m6315->power_pin, PIN_HIGH); + + while (rt_pin_read(m6315->power_status_pin) == PIN_LOW) + { + rt_thread_mdelay(10); + } + rt_pin_write(m6315->power_pin, PIN_LOW); +} + +static void m6315_power_off(struct at_device *device) +{ + struct at_device_m6315 *m6315 = RT_NULL; + + m6315 = (struct at_device_m6315 *) device->user_data; + + /* not nead to set pin configuration for m6315 device power on */ + if (m6315->power_pin == -1 || m6315->power_status_pin == -1) + { + return; + } + + if (rt_pin_read(m6315->power_status_pin) == PIN_LOW) + { + return; + } + rt_pin_write(m6315->power_pin, PIN_HIGH); + + while (rt_pin_read(m6315->power_status_pin) == PIN_HIGH) + { + rt_thread_mdelay(10); + } + rt_pin_write(m6315->power_pin, PIN_LOW); +} + +/* ============================= m6315 network interface operations ============================= */ + +/* set m6315 network interface device status and address information */ +static int m6315_netdev_set_info(struct netdev *netdev) +{ +#define M6315_IMEI_RESP_SIZE 32 +#define M6315_IPADDR_RESP_SIZE 32 +#define M6315_DNS_RESP_SIZE 96 +#define M6315_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; + + RT_ASSERT(netdev); + + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed."); + 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(M6315_IMEI_RESP_SIZE, 0, M6315_INFO_RESP_TIMO); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + result = -RT_ENOMEM; + goto __exit; + } + + /* set network interface device hardware address(IMEI) */ + { + #define M6315_NETDEV_HWADDR_LEN 8 + #define M6315_IMEI_LEN 15 + + char imei[M6315_IMEI_LEN] = {0}; + int i = 0, j = 0; + + /* send "AT+GSN" commond to get device IMEI */ + if (at_obj_exec_cmd(device->client, resp, "AT+GSN") < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args(resp, 2, "%s", imei) <= 0) + { + LOG_E("%s device prase \"AT+GSN\" cmd error.", device->name); + result = -RT_ERROR; + goto __exit; + } + + LOG_D("%s device IMEI number: %s", device->name, imei); + + netdev->hwaddr_len = M6315_NETDEV_HWADDR_LEN; + /* get hardware address by IMEI */ + for (i = 0, j = 0; i < M6315_NETDEV_HWADDR_LEN && j < M6315_IMEI_LEN; i++, j += 2) + { + if (j != M6315_IMEI_LEN - 1) + { + netdev->hwaddr[i] = (imei[j] - '0') * 10 + (imei[j + 1] - '0'); + } + else + { + netdev->hwaddr[i] = (imei[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, M6315_IPADDR_RESP_SIZE, 2, M6315_INFO_RESP_TIMO); + + /* send "AT+QILOCIP" commond to get IP address */ + if (at_obj_exec_cmd(device->client, resp, "AT+QILOCIP") < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args_by_kw(resp, ".", "%s", ipaddr) <= 0) + { + LOG_E("%s device prase \"AT+QILOCIP\" cmd error.", device->name); + result = -RT_ERROR; + goto __exit; + } + + LOG_D("%s device 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 DNS_ADDR_SIZE_MAX 16 + char dns_server1[DNS_ADDR_SIZE_MAX] = {0}, dns_server2[DNS_ADDR_SIZE_MAX] = {0}; + + at_resp_set_info(resp, M6315_DNS_RESP_SIZE, 0, M6315_INFO_RESP_TIMO); + + /* send "AT+QIDNSCFG?" commond to get DNS servers address */ + if (at_obj_exec_cmd(device->client, resp, "AT+QIDNSCFG?") < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args_by_kw(resp, "PrimaryDns:", "PrimaryDns:%s", dns_server1) <= 0 || + at_resp_parse_line_args_by_kw(resp, "SecondaryDns:", "SecondaryDns:%s", dns_server2) <= 0) + { + LOG_E("%s device prase \"AT+QIDNSCFG?\" cmd error.", device->name); + result = -RT_ERROR; + goto __exit; + } + + LOG_D("%s device primary DNS server address: %s", device->name, dns_server1); + LOG_D("%s device secondary DNS server address: %s", device->name, dns_server2); + + inet_aton(dns_server1, &addr); + netdev_low_level_set_dns_server(netdev, 0, &addr); + + inet_aton(dns_server2, &addr); + netdev_low_level_set_dns_server(netdev, 1, &addr); + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +static void check_link_status_entry(void *parameter) +{ +#define M6315_LINK_STATUS_OK 1 +#define M6315_LINK_RESP_SIZE 64 +#define M6315_LINK_RESP_TIMO (3 * RT_TICK_PER_SECOND) +#define M6315_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 device(%s) failed.", netdev->name); + return; + } + + resp = at_create_resp(M6315_LINK_RESP_SIZE, 0, M6315_LINK_RESP_TIMO); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + 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(M6315_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 ((M6315_LINK_STATUS_OK == link_status) != netdev_is_link_up(netdev)) + { + netdev_low_level_set_link_status(netdev, (M6315_LINK_STATUS_OK == link_status)); + } + + rt_thread_mdelay(M6315_LINK_DELAY_TIME); + } +} + +static int m6315_netdev_check_link_status(struct netdev *netdev) +{ +#define M6315_LINK_THREAD_TICK 20 +#define M6315_LINK_THREAD_STACK_SIZE (1024 + 512) +#define M6315_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2) + + rt_thread_t tid; + char tname[RT_NAME_MAX] = {0}; + + RT_ASSERT(netdev); + + rt_snprintf(tname, RT_NAME_MAX, "%s", netdev->name); + + tid = rt_thread_create(tname, check_link_status_entry, (void *) netdev, + M6315_LINK_THREAD_STACK_SIZE, M6315_LINK_THREAD_PRIORITY, M6315_LINK_THREAD_TICK); + if (tid) + { + rt_thread_startup(tid); + } + + return RT_EOK; +} + +static int m6315_net_init(struct at_device *device); + +static int m6315_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 device(%s) failed.", netdev->name); + return -RT_ERROR; + } + + if (device->is_init == RT_FALSE) + { + m6315_net_init(device); + device->is_init = RT_TRUE; + + netdev_low_level_set_status(netdev, RT_TRUE); + LOG_D("network interface device(%s) set up status.", netdev->name); + } + + return RT_EOK; +} + +static int m6315_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 device(%s) failed.", netdev->name); + return -RT_ERROR; + } + + if (device->is_init == RT_TRUE) + { + m6315_power_off(device); + device->is_init = RT_FALSE; + + netdev_low_level_set_status(netdev, RT_FALSE); + LOG_D("network interface device(%s) set down status.", netdev->name); + } + + return RT_EOK; +} + +static int m6315_netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, ip_addr_t *dns_server) +{ +#define M6315_DNS_RESP_LEN 8 +#define M6315_DNS_RESP_TIMEO rt_tick_from_millisecond(300) + + int result = RT_EOK; + at_response_t resp = RT_NULL; + struct at_device *device = RT_NULL; + + RT_ASSERT(netdev); + RT_ASSERT(dns_server); + + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed.", netdev->name); + return -RT_ERROR; + } + + resp = at_create_resp(M6315_DNS_RESP_LEN, 0, M6315_DNS_RESP_TIMEO); + if (resp == RT_NULL) + { + LOG_D("no memory for resp create."); + result = -RT_ENOMEM; + goto __exit; + } + + /* send "AT+QIDNSCFG=[,]" commond to set dns servers */ + if (at_obj_exec_cmd(device->client, resp, "AT+QIDNSCFG=\"%s\"", inet_ntoa(*dns_server)) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + netdev_low_level_set_dns_server(netdev, dns_num, dns_server); + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + + +#ifdef NETDEV_USING_PING +static int m6315_netdev_ping(struct netdev *netdev, const char *host, + size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp) +{ +#define M6315_PING_RESP_SIZE 128 +#define M6315_PING_IP_SIZE 16 +#define M6315_PING_TIMEO (5 * RT_TICK_PER_SECOND) + int result = -RT_ERROR; + int response, time, ttl, bytes; + char ip_addr[M6315_PING_IP_SIZE] = {0}; + at_response_t resp = RT_NULL; + struct at_device *device = RT_NULL; + int sent, recv, lost, min, max, avg; + + 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 device(%s) failed.", netdev->name); + return -RT_ERROR; + } + + /* Response line number set six because no \r\nOK\r\n at the end*/ + resp = at_create_resp(M6315_PING_RESP_SIZE, 6, M6315_PING_TIMEO); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + result = -RT_ERROR; + goto __exit; + } + + /* send "AT+QPING=""[,[][,]]" timeout:1-255 second, pingnum:1-10, commond to send ping request */ + at_obj_exec_cmd(device->client, resp, "AT+QPING= \"%s\", 100, 1", host); + sscanf(at_resp_get_line_by_kw(resp, "+QPING:"), "+QPING:%d,%*s", &response); + switch (response) + { + case 0: + if (at_resp_parse_line_args(resp, 4, "+QPING: %d, %[^,], %d, %d, %d", + &response, ip_addr, &bytes, &time, &ttl) != RT_NULL) + { + /* ping result reponse at the sixth line */ + if (at_resp_parse_line_args(resp, 6, "+QPING: %d, %d, %d, %d, %d, %d, %d", + &response, &sent, &recv, &lost, &min, &max, &avg) != RT_NULL) + { + // ping result 2 + if (response == 2) + { + inet_aton(ip_addr, &(ping_resp->ip_addr)); + ping_resp->data_len = bytes; + ping_resp->ticks = time; + ping_resp->ttl = ttl; + result = RT_EOK; + } + } + } + break; + case 1: + LOG_E("%s device Ping request timeout.", device->name); + break; + case 3: + LOG_E("%s device TCP/IP stack is busy.", device->name); + break; + case 4: + LOG_E("%s device Remote server not found.", device->name); + break; + case 5: + LOG_E("%s device Activate PDP context failed.", device->name); + break; + default: + break; + } + + + __exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} +#endif /* NETDEV_USING_PING */ + +const struct netdev_ops m6315_netdev_ops = +{ + m6315_netdev_set_up, + m6315_netdev_set_down, + + RT_NULL, /* not support set ip, netmask, gatway address */ + m6315_netdev_set_dns_server, + RT_NULL, /* not support set DHCP status */ + +#ifdef NETDEV_USING_PING + m6315_netdev_ping, +#endif + RT_NULL, +}; + +static struct netdev *m6315_netdev_add(const char *netdev_name) +{ +#define M6315_NETDEV_MTU 1500 + struct netdev *netdev = RT_NULL; + + RT_ASSERT(netdev_name); + + netdev = (struct netdev *) rt_calloc(1, sizeof(struct netdev)); + if (netdev == RT_NULL) + { + LOG_E("no memory for netdev create."); + return RT_NULL; + } + + netdev->mtu = M6315_NETDEV_MTU; + netdev->ops = &m6315_netdev_ops; + +#ifdef SAL_USING_AT + extern int sal_at_netdev_set_pf_info(struct netdev *netdev); + /* set the network interface socket/netdb operations */ + sal_at_netdev_set_pf_info(netdev); +#endif + + netdev_register(netdev, netdev_name, RT_NULL); + + return netdev; +} + +/* ============================= m6315 device operations ============================= */ + +#define AT_SEND_CMD(client, resp, resp_line, timeout, cmd) \ + do { \ + (resp) = at_resp_set_info((resp), 128, (resp_line), rt_tick_from_millisecond(timeout)); \ + if (at_obj_exec_cmd((client), (resp), (cmd)) < 0) \ + { \ + result = -RT_ERROR; \ + goto __exit; \ + } \ + } while(0) \ + +/* init for m6315 */ +static void m6315_init_thread_entry(void *parameter) +{ +#define INIT_RETRY 5 +#define CPIN_RETRY 10 +#define CSQ_RETRY 10 +#define CREG_RETRY 10 +#define CGREG_RETRY 20 +#define CGATT_RETRY 10 +#define IPADDR_RETRY 10 +#define COMMON_RETRY 10 + + int i, qimux, retry_num = INIT_RETRY; + char parsed_data[10] = {0}; + rt_err_t result = RT_EOK; + at_response_t resp = RT_NULL; + struct at_device *device = (struct at_device *)parameter; + struct at_client *client = device->client; + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(500)); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + return; + } + + LOG_D("start init %s device", device->name); + + while (retry_num--) + { + rt_memset(parsed_data, 0, sizeof(parsed_data)); + rt_thread_mdelay(500); + m6315_power_on(device); + rt_thread_mdelay(1000); + + /* wait m6315 startup finish */ + if (at_client_obj_wait_connect(client, M6315_WAIT_CONNECT_TIME)) + { + result = -RT_ETIMEOUT; + goto __exit; + } + + /* disable echo */ + AT_SEND_CMD(client, resp, 0, 300, "ATE0"); + /* get module version */ + AT_SEND_CMD(client, resp, 0, 300, "ATI"); + /* show module version */ + for (i = 0; i < (int)resp->line_counts - 1; i++) + { + LOG_D("%s", at_resp_get_line(resp, i + 1)); + } + /* check SIM card */ + for (i = 0; i < CPIN_RETRY; i++) + { + AT_SEND_CMD(client, resp, 2, 5 * RT_TICK_PER_SECOND, "AT+CPIN?"); + + if (at_resp_get_line_by_kw(resp, "READY")) + { + LOG_D("%s device SIM card detection success.", device->name); + break; + } + rt_thread_mdelay(1000); + } + if (i == CPIN_RETRY) + { + LOG_E("%s device SIM card detection failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + /* waiting for dirty data to be digested */ + rt_thread_mdelay(10); + + /* check the GSM network is registered */ + for (i = 0; i < CREG_RETRY; i++) + { + AT_SEND_CMD(client, resp, 0, 300, "AT+CREG?"); + at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", strlen(parsed_data)) || + !strncmp(parsed_data, "0,5", strlen(parsed_data))) + { + LOG_D("%s device GSM is registered(%s),", device->name, parsed_data); + break; + } + rt_thread_mdelay(1000); + } + if (i == CREG_RETRY) + { + LOG_E("%s device GSM is register failed(%s).", device->name, parsed_data); + result = -RT_ERROR; + goto __exit; + } + + + /* check packet domain attach or detach */ + for (i = 0; i < CGATT_RETRY; i++) + { + AT_SEND_CMD(client, resp, 0, 300, "AT+CGATT?"); + at_resp_parse_line_args_by_kw(resp, "+CGATT:", "+CGATT: %s", &parsed_data); + if (!strncmp(parsed_data, "1", 1)) + { + LOG_D("%s device Packet domain attach.", device->name); + break; + } + + rt_thread_mdelay(1000); + } + if (i == CGATT_RETRY) + { + LOG_E("%s device GPRS attach failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* Define PDP Context */ + for (i = 0; i < COMMON_RETRY; i++) + { + if (at_obj_exec_cmd(device->client, resp, "AT+CGDCONT=1,\"IP\",\"CMNET\"") == RT_EOK) + { + LOG_D("%s device Define PDP Context Success.", device->name); + break; + } + rt_thread_mdelay(1000); + } + if (i == COMMON_RETRY) + { + LOG_E("%s device Define PDP Context failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* PDP Context Activate*/ + for (i = 0; i < COMMON_RETRY; i++) + { + if (at_obj_exec_cmd(device->client, resp, "AT+CGACT=1,1") == RT_EOK) + { + LOG_D("%s device PDP Context Activate Success.", device->name); + break; + } + rt_thread_mdelay(1000); + } + if (i == COMMON_RETRY) + { + LOG_E("%s device PDP Context Activate failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* check the GPRS network is registered */ + for (i = 0; i < CGREG_RETRY; i++) + { + AT_SEND_CMD(client, resp, 0, 300, "AT+CGREG?"); + at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", strlen(parsed_data)) || + !strncmp(parsed_data, "0,5", strlen(parsed_data))) + { + LOG_D("%s device GPRS is registered(%s).", device->name, parsed_data); + break; + } + rt_thread_mdelay(1000); + } + if (i == CGREG_RETRY) + { + LOG_E("%s device GPRS is register failed(%s).", device->name, parsed_data); + result = -RT_ERROR; + goto __exit; + } + + /* check signal strength */ + for (i = 0; i < CSQ_RETRY; i++) + { + AT_SEND_CMD(client, resp, 2, 300, "AT+CSQ"); + at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %s", &parsed_data); + if (strncmp(parsed_data, "99,99", strlen(parsed_data))) + { + LOG_D("%s device signal strength: %s", device->name, parsed_data); + break; + } + rt_thread_mdelay(1000); + } + if (i == CSQ_RETRY) + { + LOG_E("%s device signal strength check failed (%s)", device->name, parsed_data); + result = -RT_ERROR; + goto __exit; + } + + /* check the GPRS network IP address */ + for (i = 0; i < IPADDR_RETRY; i++) + { + if (at_obj_exec_cmd(device->client, resp, "AT+CGPADDR=1") == RT_EOK) + { + #define IP_ADDR_SIZE_MAX 16 + char ipaddr[IP_ADDR_SIZE_MAX] = {0}; + + /* parse response data "+CGPADDR: 1," */ + if (at_resp_parse_line_args_by_kw(resp, "+CGPADDR:", "+CGPADDR: %*d,%s", ipaddr) > 0) + { + LOG_D("%s device IP address: %s", device->name, ipaddr); + break; + } + } + rt_thread_mdelay(1000); + } + if (i == IPADDR_RETRY) + { + LOG_E("%s device GPRS is get IP address failed", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* Set to multiple connections */ + AT_SEND_CMD(client, resp, 0, 300, "AT+QIMUX?"); + at_resp_parse_line_args_by_kw(resp, "+QIMUX:", "+QIMUX: %d", &qimux); + if (qimux == 0) + { + AT_SEND_CMD(client, resp, 0, 300, "AT+QIMUX=1"); + } + else if (qimux == 1) + { + /* Close Already Opened GPRS/CSD PDP*/ + AT_SEND_CMD(device->client, resp, 2, 300, "AT+QIDEACT"); + if (at_resp_get_line_by_kw(resp, "DEACT OK") == RT_NULL) + { + LOG_E("%s device prase \"AT+QIDEACT\" cmd error.", device->name); + result = -RT_ERROR; + goto __exit; + } + } + + /* Start task & set entry point default apn,username,password */ + if (at_obj_exec_cmd(device->client, resp, "AT+QIREGAPP") < 0) + { + LOG_E("%s device Start task & set default params failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* PDP Context Activate */ + if (at_obj_exec_cmd(device->client, resp, "AT+QIACT") < 0) + { + LOG_E("%s device PDP Context Activate failed.", device->name); + result = -RT_ERROR; + goto __exit; + } + + /* initialize successfully */ + result = RT_EOK; + break; + + __exit: + if (result != RT_EOK) + { + /* power off the m6315 device */ + m6315_power_off(device); + rt_thread_mdelay(1000); + + LOG_I("%s device initialize retry...", device->name); + } + } + + if (resp) + { + at_delete_resp(resp); + } + + if (result == RT_EOK) + { + /* set network interface device status and address information */ + m6315_netdev_set_info(device->netdev); + /* check and create link staus sync thread */ + if (rt_thread_find(device->netdev->name) == RT_NULL) + { + m6315_netdev_check_link_status(device->netdev); + } + + LOG_I("%s device network initialize success!", device->name); + + } + else + { + LOG_E("%s device network initialize failed(%d)!", device->name, result); + } +} + +static int m6315_net_init(struct at_device *device) +{ +#ifdef AT_DEVICE_M6315_INIT_ASYN + rt_thread_t tid; + + tid = rt_thread_create("m6315_net", m6315_init_thread_entry, (void *)device, + M6315_THREAD_STACK_SIZE, M6315_THREAD_PRIORITY, 20); + if (tid) + { + rt_thread_startup(tid); + } + else + { + LOG_E("create %s device init thread failed.", device->name); + return -RT_ERROR; + } +#else + m6315_init_thread_entry(device); +#endif /* AT_DEVICE_M6315_INIT_ASYN */ + + return RT_EOK; +} + +static void urc_func(struct at_client *client, const char *data, rt_size_t size) +{ + RT_ASSERT(data); + + LOG_I("URC data : %.*s", size, data); +} + + +/* m6315 device URC table for the device control */ +static const struct at_urc urc_table[] = +{ + {"RDY", "\r\n", urc_func}, + {"+PDP DEACT", "\r\n", urc_func}, +}; + +static int m6315_init(struct at_device *device) +{ + struct at_device_m6315 *m6315 = (struct at_device_m6315 *) device->user_data; + + /* initialize AT client */ + at_client_init(m6315->client_name, m6315->recv_line_num); + + device->client = at_client_get(m6315->client_name); + if (device->client == RT_NULL) + { + LOG_E("get AT client(%s) failed.", m6315->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 + m6315_socket_init(device); +#endif + + /* add m6315 device to the netdev list */ + device->netdev = m6315_netdev_add(m6315->device_name); + if (device->netdev == RT_NULL) + { + LOG_E("get netdev(%s) failed.", m6315->device_name); + return -RT_ERROR; + } + + /* initialize m6315 pin configuration */ + if (m6315->power_pin != -1 && m6315->power_status_pin != -1) + { + rt_pin_mode(m6315->power_pin, PIN_MODE_OUTPUT); + rt_pin_mode(m6315->power_status_pin, PIN_MODE_INPUT); + } + + /* initialize m6315 device network */ + return m6315_netdev_set_up(device->netdev); +} + +static int m6315_deinit(struct at_device *device) +{ + return m6315_netdev_set_down(device->netdev); +} + +static int m6315_control(struct at_device *device, int cmd, void *arg) +{ + int result = -RT_ERROR; + + RT_ASSERT(device); + + switch (cmd) + { + case AT_DEVICE_CTRL_POWER_ON: + case AT_DEVICE_CTRL_POWER_OFF: + case AT_DEVICE_CTRL_RESET: + case AT_DEVICE_CTRL_LOW_POWER: + case AT_DEVICE_CTRL_SLEEP: + case AT_DEVICE_CTRL_WAKEUP: + case AT_DEVICE_CTRL_NET_CONN: + case AT_DEVICE_CTRL_NET_DISCONN: + case AT_DEVICE_CTRL_SET_WIFI_INFO: + case AT_DEVICE_CTRL_GET_SIGNAL: + case AT_DEVICE_CTRL_GET_GPS: + case AT_DEVICE_CTRL_GET_VER: + LOG_W("not support the control command(%d).", cmd); + break; + default: + LOG_E("input error control command(%d).", cmd); + break; + } + + return result; +} + +const struct at_device_ops m6315_device_ops = +{ + m6315_init, + m6315_deinit, + m6315_control, +}; + +static int m6315_device_class_register(void) +{ + struct at_device_class *class = RT_NULL; + + class = (struct at_device_class *) rt_calloc(1, sizeof(struct at_device_class)); + if (class == RT_NULL) + { + LOG_E("no memory for device class create."); + return -RT_ENOMEM; + } + + /* fill m6315 device class object */ +#ifdef AT_USING_SOCKET + m6315_socket_class_register(class); +#endif + class->device_ops = &m6315_device_ops; + + return at_device_class_register(class, AT_DEVICE_CLASS_M6315); +} +INIT_DEVICE_EXPORT(m6315_device_class_register); + +#endif /* AT_DEVICE_USING_M6315 */ diff --git a/class/m6315/at_device_m6315.h b/class/m6315/at_device_m6315.h new file mode 100644 index 0000000..660a0a2 --- /dev/null +++ b/class/m6315/at_device_m6315.h @@ -0,0 +1,66 @@ +/* + * File : at_device_m6315.h + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2019-05-16 chenyong first version + */ + +#ifndef __AT_DEVICE_M6315_H__ +#define __AT_DEVICE_M6315_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include + +/* The maximum number of sockets supported by the m6315 device */ +#define AT_DEVICE_M6315_SOCKETS_NUM 8 + +struct at_device_m6315 +{ + char *device_name; + char *client_name; + + int power_pin; + int power_status_pin; + size_t recv_line_num; + struct at_device device; + + void *user_data; +}; + +#ifdef AT_USING_SOCKET + +/* m6315 device socket initialize */ +int m6315_socket_init(struct at_device *device); + +/* m6315 device class socket register */ +int m6315_socket_class_register(struct at_device_class *class); + +#endif /* AT_USING_SOCKET */ + +#ifdef __cplusplus +} +#endif + +#endif /* __AT_DEVICE_M6315_H__ */ diff --git a/class/m6315/at_socket_m6315.c b/class/m6315/at_socket_m6315.c new file mode 100644 index 0000000..af460cc --- /dev/null +++ b/class/m6315/at_socket_m6315.c @@ -0,0 +1,636 @@ +/* + * File : at_socket_m6315.c + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2018-06-12 malongwei first version + * 2019-05-13 chenyong multi AT socket client support + */ + +#include +#include + +#include + +#define LOG_TAG "at.skt.m6315" +#include + +#if defined(AT_DEVICE_USING_M6315) && defined(AT_USING_SOCKET) + +#define M6315_MODULE_SEND_MAX_SIZE 1000 + +/* set real event by current socket and current state */ +#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event)) + +/* AT socket event type */ +#define M6315_EVENT_CONN_OK (1L << 0) +#define M6315_EVENT_SEND_OK (1L << 1) +#define M6315_EVENT_RECV_OK (1L << 2) +#define M6315_EVNET_CLOSE_OK (1L << 3) +#define M6315_EVENT_CONN_FAIL (1L << 4) +#define M6315_EVENT_SEND_FAIL (1L << 5) +#define M6315_EVENT_CONN_ALREADY (1L << 6) + +static at_evt_cb_t at_evt_cb_set[] = { + [AT_SOCKET_EVT_RECV] = NULL, + [AT_SOCKET_EVT_CLOSED] = NULL, +}; + +static int m6315_socket_event_send(struct at_device *device, uint32_t event) +{ + return (int) rt_event_send(device->socket_event, event); +} + +static int m6315_socket_event_recv(struct at_device *device, uint32_t event, uint32_t timeout, rt_uint8_t option) +{ + int result = RT_EOK; + rt_uint32_t recved; + + result = rt_event_recv(device->socket_event, event, option | RT_EVENT_FLAG_CLEAR, timeout, &recved); + if (result != RT_EOK) + { + return -RT_ETIMEOUT; + } + + return recved; +} + +/** + * close socket by AT commands. + * + * @param current socket + * + * @return 0: close socket success + * -1: send AT commands error + * -2: wait socket event timeout + * -5: no memory + */ +static int m6315_socket_close(struct at_socket *socket) +{ + uint32_t event = 0; + int result = RT_EOK; + int device_socket = (int) socket->user_data; + struct at_device *device = (struct at_device *) socket->device; + + /* clear socket close event */ + event = SET_EVENT(device_socket, M6315_EVNET_CLOSE_OK); + m6315_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR); + + if (at_obj_exec_cmd(device->client, NULL, "AT+QICLOSE=%d", device_socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (m6315_socket_event_recv(device, event, rt_tick_from_millisecond(300*3), RT_EVENT_FLAG_AND) < 0) + { + LOG_E("%s device socket(%d) wait close OK timeout.", device->name, device_socket); + result = -RT_ETIMEOUT; + goto __exit; + } + +__exit: + return result; +} + + +/** + * create TCP/UDP client or server connect by AT commands. + * + * @param socket current socket + * @param ip server or client IP address + * @param port server or client port + * @param type connect socket type(tcp, udp) + * @param is_client connection is client + * + * @return 0: connect success + * -1: connect failed, send commands error or type error + * -2: wait socket event timeout + * -5: no memory + */ +static int m6315_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; + rt_bool_t retryed = RT_FALSE; + at_response_t resp = RT_NULL; + int result = RT_EOK, event_result = 0; + int device_socket = (int) socket->user_data; + struct at_device *device = (struct at_device *) socket->device; + + RT_ASSERT(ip); + RT_ASSERT(port >= 0); + + resp = at_create_resp(128, 0, 5 * RT_TICK_PER_SECOND); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + return -RT_ENOMEM; + } + +__retry: + + /* clear socket connect event */ + event = SET_EVENT(device_socket, M6315_EVENT_CONN_OK | M6315_EVENT_CONN_FAIL | M6315_EVENT_CONN_ALREADY); + m6315_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR); + + if (is_client) + { + switch (type) + { + 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, + "AT+QIOPEN=%d,\"TCP\",\"%s\",%d", device_socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + case AT_SOCKET_UDP: + if (at_obj_exec_cmd(device->client, RT_NULL, + "AT+QIOPEN=%d,\"UDP\",\"%s\",%d", device_socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + default: + LOG_E("%s device not supported connect type : %d.", device->name, type); + result = -RT_ERROR; + goto __exit; + } + } + + /* waiting result event from AT URC, the device default connection timeout is 75 seconds, but it set to 10 seconds is convenient to use */ + if (m6315_socket_event_recv(device, SET_EVENT(device_socket, 0), 10 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR) < 0) + { + LOG_E("%s device socket(%d) wait connect result timeout.", device->name, device_socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + event_result = m6315_socket_event_recv(device, + M6315_EVENT_CONN_OK | M6315_EVENT_CONN_FAIL | M6315_EVENT_CONN_ALREADY, 1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR); + if (event_result < 0) + { + LOG_E("%s device socket(%d) wait connect OK|FAIL|ALREADY timeout.", device->name, device_socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & M6315_EVENT_CONN_FAIL) + { + if (retryed == RT_FALSE) + { + LOG_D("%s device socket(%d) connect failed, the socket was not be closedand now will connect retry.", + device->name, device_socket); + if (m6315_socket_close(socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + retryed = RT_TRUE; + goto __retry; + } + LOG_E("%s device socket(%d) connect failed.", device->name, device_socket); + result = -RT_ERROR; + goto __exit; + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +/** + * send data to server or client by AT commands. + * + * @param socket current socket + * @param buff send buffer + * @param bfsz send buffer size + * @param type connect socket type(tcp, udp) + * + * @return >=0: the size of send success + * -1: send AT commands error or send data error + * -2: waited socket event timeout + * -5: no memory + */ +static int m6315_socket_send(struct at_socket *socket, const char *buff, size_t bfsz, enum at_socket_type type) +{ + uint32_t event = 0; + int result = RT_EOK, event_result = 0; + size_t cur_pkt_size = 0, sent_size = 0; + at_response_t resp = RT_NULL; + int device_socket = (int) socket->user_data; + struct at_device *device = (struct at_device *) socket->device; + rt_mutex_t lock = device->client->lock; + + RT_ASSERT(buff); + + resp = at_create_resp(128, 2, 20 * RT_TICK_PER_SECOND); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + return -RT_ENOMEM; + } + + rt_mutex_take(lock, RT_WAITING_FOREVER); + + /* clear socket connect event */ + event = SET_EVENT(device_socket, M6315_EVENT_SEND_OK | M6315_EVENT_SEND_FAIL); + m6315_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR); + + /* set AT client end sign to deal with '>' sign.*/ + at_obj_set_end_sign(device->client, '>'); + + while (sent_size < bfsz) + { + if (bfsz - sent_size < M6315_MODULE_SEND_MAX_SIZE) + { + cur_pkt_size = bfsz - sent_size; + } + else + { + cur_pkt_size = M6315_MODULE_SEND_MAX_SIZE; + } + + /* send the "AT+QISEND" commands to AT server than receive the '>' response on the first line. */ + if (at_obj_exec_cmd(device->client, resp, "AT+QISEND=%d,%d", device_socket, cur_pkt_size) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* send the real data to server or client */ + result = (int) at_client_obj_send(device->client, buff + sent_size, cur_pkt_size); + if (result == 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* waiting result event from AT URC */ + if (m6315_socket_event_recv(device, SET_EVENT(device_socket, 0), 20 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR) < 0) + { + LOG_E("%s device socket(%d) wait send result timeout.", device->name, device_socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + event_result = m6315_socket_event_recv(device, + M6315_EVENT_SEND_OK | M6315_EVENT_SEND_FAIL, 15 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR); + if (event_result < 0) + { + LOG_E("%s device socket(%d) wait send connect OK|FAIL timeout.", device->name, device_socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & M6315_EVENT_SEND_FAIL) + { + LOG_E("%s device socket(%d) send failed.", device->name, device_socket); + result = -RT_ERROR; + goto __exit; + } + + sent_size += cur_pkt_size; + } + +__exit: + /* reset the end sign for data conflict */ + at_obj_set_end_sign(device->client, 0); + + rt_mutex_release(lock); + + if (resp) + { + at_delete_resp(resp); + } + + return result > 0 ? sent_size : result; +} + +/** + * domain resolve by AT commands. + * + * @param name domain name + * @param ip parsed IP address, it's length must be 16 + * + * @return 0: domain resolve success + * -1: send AT commands error or response error + * -2: wait socket event timeout + * -5: no memory + */ +static int m6315_domain_resolve(const char *name, char ip[16]) +{ +#define RESOLVE_RETRY 5 + + int i, result = RT_EOK; + char recv_ip[16] = { 0 }; + at_response_t resp = RT_NULL; + struct at_device *device = RT_NULL; + + RT_ASSERT(name); + RT_ASSERT(ip); + + device = at_device_get_first_initialized(); + if (device == RT_NULL) + { + LOG_E("get first init device failed."); + return -RT_ERROR; + } + + /* The maximum response time is 20 seconds, affected by network status */ + resp = at_create_resp(128, 4, 20 * RT_TICK_PER_SECOND); + if (resp == RT_NULL) + { + LOG_E("no memory for resp create."); + return -RT_ENOMEM; + } + + for (i = 0; i < RESOLVE_RETRY; i++) + { + + if (at_obj_exec_cmd(device->client, resp, "AT+QIDNSGIP=\"%s\"", name) < 0) //MODIFY name + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args(resp, 4, "%s", recv_ip) < 0) + { + rt_thread_mdelay(100); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + + if (rt_strlen(recv_ip) < 8) + { + rt_thread_mdelay(100); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + else + { + rt_thread_mdelay(10); + rt_strncpy(ip, recv_ip, 15); + ip[15] = '\0'; + break; + } + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; + +} + +/** + * set AT socket event notice callback + * + * @param event notice event + * @param cb notice callback + */ +static void m6315_socket_set_event_cb(at_socket_evt_t event, at_evt_cb_t cb) +{ + if (event < sizeof(at_evt_cb_set) / sizeof(at_evt_cb_set[1])) + { + at_evt_cb_set[event] = cb; + } +} + +static void urc_connect_func(struct at_client *client, const char *data, rt_size_t size) +{ + int device_socket = 0; + struct at_device *device = 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); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed.", client_name); + return; + } + + if (strstr(data, "ALREADY CONNECT")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVENT_CONN_ALREADY)); + return; + } + + /* get the current socket by receive data */ + sscanf(data, "%d,%*s", &device_socket); + + if (strstr(data, "CONNECT OK")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVENT_CONN_OK)); + } + else if (strstr(data, "CONNECT FAIL")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVENT_CONN_FAIL)); + } +} + +static void urc_send_func(struct at_client *client, const char *data, rt_size_t size) +{ + int device_socket = 0; + struct at_device *device = 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); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed.", client_name); + return; + } + + /* get the current socket by receive data */ +// sscanf(data, "%d,%*s", &device_socket); + + if (rt_strstr(data, "SEND OK")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVENT_SEND_OK)); + } + else if (rt_strstr(data, "SEND FAIL")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVENT_SEND_FAIL)); + } +} + +static void urc_close_func(struct at_client *client, const char *data, rt_size_t size) +{ + int device_socket = 0; + struct at_device *device = 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); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed.", client_name); + return; + } + + /* get the current socket by receive data */ + sscanf(data, "%d,%*s", &device_socket); + + if (rt_strstr(data, "CLOSE OK")) + { + m6315_socket_event_send(device, SET_EVENT(device_socket, M6315_EVNET_CLOSE_OK)); + } + else if (rt_strstr(data, "CLOSED")) + { + struct at_socket *socket = RT_NULL; + + /* get AT socket object by device socket descriptor */ + socket = &(device->sockets[device_socket]); + + /* notice the socket is disconnect by remote */ + if (at_evt_cb_set[AT_SOCKET_EVT_CLOSED]) + { + at_evt_cb_set[AT_SOCKET_EVT_CLOSED](socket, AT_SOCKET_EVT_CLOSED, RT_NULL, 0); + } + } +} + +static void urc_recv_func(struct at_client *client, const char *data, rt_size_t size) +{ + int device_socket = 0; + rt_int32_t timeout; + rt_size_t bfsz = 0, temp_size = 0; + 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; + + RT_ASSERT(data && size); + + /* get the current socket and receive buffer size by receive data */ + sscanf(data, "+RECEIVE:%d,%d:", &device_socket, (int *) &bfsz); + /* set receive timeout by receive buffer length, not less than 10 ms */ + timeout = bfsz > 10 ? bfsz : 10; + + if (device_socket < 0 || bfsz == 0) + { + return; + } + + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_CLIENT, client_name); + if (device == RT_NULL) + { + LOG_E("get device(%s) failed.", client_name); + return; + } + + recv_buf = (char *) rt_calloc(1, bfsz); + if (recv_buf == RT_NULL) + { + LOG_E("no memory for receive buffer(%d).", bfsz); + /* read and clean the coming data */ + while (temp_size < bfsz) + { + if (bfsz - temp_size > sizeof(temp)) + { + at_client_obj_recv(client, temp, sizeof(temp), timeout); + } + else + { + at_client_obj_recv(client, temp, bfsz - temp_size, timeout); + } + temp_size += sizeof(temp); + } + return; + } + + /* sync receive data */ + if (at_client_obj_recv(client, recv_buf, bfsz, timeout) != bfsz) + { + LOG_E("%s device receive size(%d) data failed.", device->name, bfsz); + rt_free(recv_buf); + return; + } + + /* get AT socket object by device socket descriptor */ + socket = &(device->sockets[device_socket]); + + /* notice the receive buffer and buffer size */ + if (at_evt_cb_set[AT_SOCKET_EVT_RECV]) + { + at_evt_cb_set[AT_SOCKET_EVT_RECV](socket, AT_SOCKET_EVT_RECV, recv_buf, bfsz); + } +} + +/* m6315 device URC table for the socket data */ +static const struct at_urc urc_table[] = +{ + {"", ", CONNECT OK\r\n", urc_connect_func}, + {"", ", CONNECT FAIL\r\n", urc_connect_func}, + {"", "ALREADY CONNECT\r\n", urc_connect_func}, + {"", "SEND OK\r\n", urc_send_func}, + {"", "SEND FAIL\r\n", urc_send_func}, + {"", ", CLOSE OK\r\n", urc_close_func}, + {"", ", CLOSED\r\n", urc_close_func}, + {"+RECEIVE:", "\r\n", urc_recv_func}, +}; + +static const struct at_socket_ops m6315_socket_ops = +{ + m6315_socket_connect, + m6315_socket_close, + m6315_socket_send, + m6315_domain_resolve, + m6315_socket_set_event_cb, +}; + +int m6315_socket_init(struct at_device *device) +{ + RT_ASSERT(device); + + /* register URC data execution function */ + at_obj_set_urc_table(device->client, urc_table, sizeof(urc_table) / sizeof(urc_table[0])); + + return RT_EOK; +} + +int m6315_socket_class_register(struct at_device_class *class) +{ + RT_ASSERT(class); + + class->socket_num = AT_DEVICE_M6315_SOCKETS_NUM; + class->socket_ops = &m6315_socket_ops; + + return RT_EOK; +} + +#endif /* AT_DEVICE_USING_M6315 && AT_USING_SOCKET */ diff --git a/inc/at_device.h b/inc/at_device.h index 764ce67..adee60f 100644 --- a/inc/at_device.h +++ b/inc/at_device.h @@ -40,8 +40,8 @@ extern "C" { #include #endif /* RT_USING_NETDEV */ -#define AT_DEVICE_SW_VERSION "2.0.2" -#define AT_DEVICE_SW_VERSION_NUM 0x20002 +#define AT_DEVICE_SW_VERSION "2.0.3" +#define AT_DEVICE_SW_VERSION_NUM 0x20003 /* AT device class ID */ #define AT_DEVICE_CLASS_ESP8266 0x01U @@ -57,7 +57,8 @@ extern "C" { #define AT_DEVICE_CLASS_BC26 0x0BU #define AT_DEVICE_CLASS_AIR720 0x0CU #define AT_DEVICE_CLASS_ME3616 0x0DU -#define AT_DEVICE_CLASS_BC28 0x0EU +#define AT_DEVICE_CLASS_M6315 0x0EU +#define AT_DEVICE_CLASS_BC28 0x0FU /* Options and Commands for AT device control opreations */ #define AT_DEVICE_CTRL_POWER_ON 0x01L diff --git a/samples/at_sample_m6315.c b/samples/at_sample_m6315.c new file mode 100644 index 0000000..cdc2739 --- /dev/null +++ b/samples/at_sample_m6315.c @@ -0,0 +1,52 @@ +/* + * File : at_sample_m6315.c + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2019-05-13 chenyong first version + */ + +#include + +#define LOG_TAG "at.sample.m6315" +#include + +#define M6315_SAMPLE_DEIVCE_NAME "m6315" + +static struct at_device_m6315 m6315_dev = +{ + M6315_SAMPLE_DEIVCE_NAME, + M6315_SAMPLE_CLIENT_NAME, + + M6315_SAMPLE_POWER_PIN, + M6315_SAMPLE_STATUS_PIN, + M6315_SAMPLE_RECV_BUFF_LEN, +}; + +static int m6315_device_register(void) +{ + struct at_device_m6315 *m6315 = &m6315_dev; + + return at_device_register(&(m6315->device), + m6315->device_name, + m6315->client_name, + AT_DEVICE_CLASS_M6315, + (void *) m6315); +} +INIT_APP_EXPORT(m6315_device_register);