From 1eee9d17483bd37a2933320b1f4202cafd31485a Mon Sep 17 00:00:00 2001 From: Matthew Date: Tue, 27 Aug 2024 20:46:33 +0800 Subject: [PATCH] at_device from s938 --- LICENSE | 504 +++++++++++ README.md | 60 +- SConscript | 19 + at_client_sample.c | 134 +++ at_socket_ec20.c | 2031 +++++++++++++++++++++++++++++++++++++++++++ at_socket_esp8266.c | 720 +++++++++++++++ at_socket_m26.c | 934 ++++++++++++++++++++ 7 files changed, 4401 insertions(+), 1 deletion(-) create mode 100644 LICENSE create mode 100644 SConscript create mode 100644 at_client_sample.c create mode 100644 at_socket_ec20.c create mode 100644 at_socket_esp8266.c create mode 100644 at_socket_m26.c diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..19e3071 --- /dev/null +++ b/LICENSE @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +(This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.) + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + {description} + Copyright (C) {year} {fullname} + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 + USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random + Hacker. + + {signature of Ty Coon}, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/README.md b/README.md index 4d9eb3e..3c71976 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,60 @@ -# ec20 +# AT device # +## 1. 简介 ## + +AT device 软件包是由 RT-Thread AT 组件针对不同 AT 设备的移植文件和示例代码组成，目前支持的 AT 设备有：ESP32、ESP8266、M26等，其中 ESP8266 和 M26 设备完成对 `AT socket` 功能的移植，及设备通过 AT 命令实现标准 socket 编程接口，完成 socket 通讯的功能，具体功能介绍可参考 [《RT-Thread 编程指南》](https://github.com/RT-Thread/rtthread-manual-doc)AT 命令章节 。 + +### 1.1. 文件结构 ### + +| 名称 | 说明 | +| ---- | ---- | +| at_socket_esp8266.c | ESP8266 模块针对 AT 组件的移植文件，实现 AT socket | +| at_socket_m26.c | M26/MC20 模块针对 AT 组件的移植文件，实现 AT socket | +| at_socket_ec20.c | EC20 模块针对 AT 组件的移植文件，实现 AT socket | +| at_client_sample.c | ESP8266 模块 AT Client 功能示例文件 | + +### 1.2 许可证 ### + +at_device package 遵循 LGPLv2.1 许可，详见 `LICENSE` 文件。 + +### 1.3 依赖 ### + +- RT_Thread 3.0+ +- RT_Thread AT 组件 1.0.0 +- RT_Thread SAL 组件 + +## 2. 获取方式 ## + +AT device 软件包是对 AT 组件库和 AT socket 功能的移植，需开启 AT 组件库和 AT socket 功能来获取 AT device 软件包。 + +先要开启 AT 组件库和 AT socket 功能， 具体路径如下所示： + + RT-Thread Components ---> + Network stack ---> + Socket abstraction layer ---> + protocol stack implement ---> + [ ] Support lwIP stack + [*] Support AT Commands stack + +开启 AT socket 功能之后，默认开启 AT device 软件包， 具体路径如下所示： + + RT-Thread online packages ---> + IoT - internet of things ---> + -*- AT DEVICE: RT-Thread AT component porting or samples for different device + [ ] Enable at device init by thread + AT socket device modules (Not selected, please select) ---> + Version (latest) ---> + +- `Enable at device init by thread`: 配置开启设备网络初始化是否通过创建线程完成； +- `AT socket device modules`: AT 设备选择，目前支持 ESP8266、M26/MC20、EC20 等设备； +- `Version`: 下载软件包版本； + +## 3. 注意事项 ## + +- AT device 软件包默认设备类型为未选择，使用时需要指定使用设备型号； +- AT device 软件包目前处于 `beta` 测试阶段, 推荐在 menuconfig 选项中选择 `latest` 版本； + +## 5. 联系方式 + +* 维护：RT-Thread 开发团队及社区开发者 +* 主页：https://github.com/RT-Thread-packages/at_device \ No newline at end of file diff --git a/SConscript b/SConscript new file mode 100644 index 0000000..0554c31 --- /dev/null +++ b/SConscript @@ -0,0 +1,19 @@ +from building import * + +cwd = GetCurrentDir() + +if GetDepend(['AT_DEVICE_M26']): + src = Glob('at_socket_m26.c') + +if GetDepend(['AT_DEVICE_EC20']): + src = Glob('at_socket_ec20.c') + +if GetDepend(['AT_DEVICE_ESP8266']): + src = Glob('at_socket_esp8266.c') + +if GetDepend(['AT_DEVICE_NOT_SELECTED']): + src = Glob('*.c') + +group = DefineGroup('at_device', src, depend = ['PKG_USING_AT_DEVICE','AT_USING_SOCKET'], CPPPATH = [cwd]) + +Return('group') diff --git a/at_client_sample.c b/at_client_sample.c new file mode 100644 index 0000000..655e186 --- /dev/null +++ b/at_client_sample.c @@ -0,0 +1,134 @@ +/* + * File : at_client_sample.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-07-06 chenyong first version + */ + +#include +#include + +#include +#include + +#define LOG_TAG "at.sample" +#include + +/* AT+CIFSR Query local IP address and MAC */ +int at_client_test(int argc, char **argv) +{ + at_response_t resp = RT_NULL; + int result = 0; + + if (argc != 1) + { + LOG_E("at_client_test - AT client send commands to AT server."); + return -1; + } + + resp = at_create_resp(256, 0, rt_tick_from_millisecond(5000)); + if (resp == RT_NULL) + { + LOG_E("No memory for response structure!"); + return -2; + } + + /* close echo */ + at_exec_cmd(resp, "ATE0"); + + result = at_exec_cmd(resp, "AT+CIFSR"); + if (result != RT_EOK) + { + LOG_E("AT client send commands failed or return response error!"); + goto __exit; + } + + /* Print response line buffer */ + { + const char *line_buffer = RT_NULL; + + LOG_D("Response buffer"); + + for(rt_size_t line_num = 1; line_num <= resp->line_counts; line_num++) + { + if((line_buffer = at_resp_get_line(resp, line_num)) != RT_NULL) + { + LOG_D("line %d buffer : %s", line_num, line_buffer); + } + else + { + LOG_E("Parse line buffer error!"); + } + } + } + + { + char resp_arg[AT_CMD_MAX_LEN] = { 0 }; + const char * resp_expr = "%*[^\"]\"%[^\"]\""; + + LOG_D(" Parse arguments"); + if (at_resp_parse_line_args(resp, 1, resp_expr, resp_arg) == 1) + { + LOG_D("Station IP : %s", resp_arg); + memset(resp_arg, 0x00, AT_CMD_MAX_LEN); + } + else + { + LOG_E("Parse error, current line buff : %s", at_resp_get_line(resp, 4)); + } + + if (at_resp_parse_line_args(resp, 2, resp_expr, resp_arg) == 1) + { + LOG_D("Station MAC : %s", resp_arg); + } + else + { + LOG_E("Parse error, current line buff : %s", at_resp_get_line(resp, 5)); + goto __exit; + } + } +__exit: + if(resp) + { + at_delete_resp(resp); + } + + return result; +} + +int at_client_test_init(int argc, char **argv) +{ +#define AT_CLIENT_RECV_BUFF_LEN 512 + + if (argc != 2) + { + rt_kprintf("at_client_init -- AT client initialize.\n"); + return -RT_ERROR; + } + + at_client_init(argv[1], AT_CLIENT_RECV_BUFF_LEN); + + return RT_EOK; +} +#ifdef FINSH_USING_MSH +#include +MSH_CMD_EXPORT(at_client_test, AT client send cmd and get response); +MSH_CMD_EXPORT_ALIAS(at_client_test_init, at_client_init, initialize AT client); +#endif diff --git a/at_socket_ec20.c b/at_socket_ec20.c new file mode 100644 index 0000000..fc1c2c6 --- /dev/null +++ b/at_socket_ec20.c @@ -0,0 +1,2031 @@ +/* + * File : at_socket_ec20.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 chenyong first version + * 2018-08-12 Marcus port to ec20 + */ + +#include +#include + +#include +#include +#include "protocol_common.h" + +#include +#include + +#if !defined(AT_SW_VERSION_NUM) || AT_SW_VERSION_NUM < 0x10200 +#error "This AT Client version is older, please check and update latest AT Client!" +#endif + +#define LOG_TAG "at.ec20" +#include + +#ifdef AT_DEVICE_EC20 + +#define EC20_MODULE_SEND_MAX_SIZE 1460 +#define EC20_WAIT_CONNECT_TIME 6000 +#define EC20_THREAD_STACK_SIZE 1024 +#define EC20_THREAD_PRIORITY 11 //(RT_THREAD_PRIORITY_MAX/2) + +/* set real event by current socket and current state ��16λΪsocket��,��16λΪ�¼�*/ +#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event)) + +/* AT socket event type */ +#define EC20_EVENT_CONN_OK (1L << 0) +#define EC20_EVENT_SEND_OK (1L << 1) +#define EC20_EVENT_RECV_OK (1L << 2) +#define EC20_EVNET_CLOSE_OK (1L << 3) +#define EC20_EVENT_CONN_FAIL (1L << 4) +#define EC20_EVENT_SEND_FAIL (1L << 5) +#define EC20_EVENT_DOMAIN_OK (1L << 6) + +#define MAX_MESSAGE_SIZE 256 +#define EC20_REDIAL (1<<0) + + +/* AT+QICSGP command default*/ +char *QICSGP_CHINA_MOBILE = "AT+QICSGP=1,1,\"CMNET\",\"\",\"\",0"; +char *QICSGP_CHINA_UNICOM = "AT+QICSGP=1,1,\"UNINET\",\"\",\"\",0"; +char *QICSGP_CHINA_TELECOM = "AT+QICSGP=1,1,\"CTNET\",\"\",\"\",0"; + +static int cur_socket; +static char lte_ip[16] = { 0 }; +static rt_event_t at_socket_event; +static rt_mutex_t at_event_lock; +static at_evt_cb_t at_evt_cb_set[] = { + [AT_SOCKET_EVT_RECV] = NULL, //�����¼��ص� + [AT_SOCKET_EVT_CLOSED] = NULL,//�ر��¼��ص� +}; + +/*add by tmb*/ +static struct rt_event ec20_dial_evt; +static rt_uint32_t ec20_online=0; +static rt_int32_t lte_rssi=0; +uint32_t ec20_get_online(void) +{ + return ec20_online; +} + +char *get_lte_ip(void) +{ + return lte_ip; +} + +int32_t ec20_send_evt(rt_uint32_t e) +{ + return rt_event_send(&ec20_dial_evt,e); +} +/*add by tmb*/ + +int32_t get_rssi(void) +{ + return lte_rssi; +} +/* +static void at_cme_errcode_parse(int result) +{ + switch(result) + { + case 0 : LOG_E("%d : Phone failure", result); break; + case 1 : LOG_E("%d : No connection to phone", result); break; + case 2 : LOG_E("%d : Phone-adaptor link reserved", result); break; + case 3 : LOG_E("%d : Operation not allowed", result); break; + case 4 : LOG_E("%d : Operation not supported", result); break; + case 5 : LOG_E("%d : PH-SIM PIN required", result); break; + case 6 : LOG_E("%d : PH-FSIM PIN required", result); break; + case 7 : LOG_E("%d : PH-FSIM PUK required", result); break; + case 10 : LOG_E("%d : SIM not inserted", result); break; + case 11 : LOG_E("%d : SIM PIN required", result); break; + case 12 : LOG_E("%d : SIM PUK required", result); break; + case 13 : LOG_E("%d : SIM failure", result); break; + case 14 : LOG_E("%d : SIM busy", result); break; + case 15 : LOG_E("%d : SIM wrong", result); break; + case 16 : LOG_E("%d : Incorrect password", result); break; + case 17 : LOG_E("%d : SIM PIN2 required", result); break; + case 18 : LOG_E("%d : SIM PUK2 required", result); break; + case 20 : LOG_E("%d : Memory full", result); break; + case 21 : LOG_E("%d : Invalid index", result); break; + case 22 : LOG_E("%d : Not found", result); break; + case 23 : LOG_E("%d : Memory failure", result); break; + case 24 : LOG_E("%d : Text string too long", result); break; + case 25 : LOG_E("%d : Invalid characters in text string", result); break; + case 26 : LOG_E("%d : Dial string too long", result); break; + case 27 : LOG_E("%d : Invalid characters in dial string", result); break; + case 30 : LOG_E("%d : No network service", result); break; + case 31 : LOG_E("%d : Network timeout", result); break; + case 32 : LOG_E("%d : Network not allowed - emergency calls only", result); break; + case 40 : LOG_E("%d : Network personalization PIN required", result); break; + case 41 : LOG_E("%d : Network personalization PUK required", result); break; + case 42 : LOG_E("%d : Network subset personalization PIN required", result); break; + case 43 : LOG_E("%d : Network subset personalization PUK required", result); break; + case 44 : LOG_E("%d : Service provider personalization PIN required", result); break; + case 45 : LOG_E("%d : Service provider personalization PUK required", result); break; + case 46 : LOG_E("%d : Corporate personalization PIN required", result); break; + case 47 : LOG_E("%d : Corporate personalization PUK required", result); break; + case 901 : LOG_E("%d : Audio unknown error", result); break; + case 902 : LOG_E("%d : Audio invalid parameters", result); break; + case 903 : LOG_E("%d : Audio operation not supported", result); break; + case 904 : LOG_E("%d : Audio device busy", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} +*/ +/* +static void at_cms_errcode_parse(int result) +{ + switch(result) + { + case 300 : LOG_E("%d : ME failure", result); break; + case 301 : LOG_E("%d : SMS ME reserved", result); break; + case 302 : LOG_E("%d : Operation not allowed", result); break; + case 303 : LOG_E("%d : Operation not supported", result); break; + case 304 : LOG_E("%d : Invalid PDU mode", result); break; + case 305 : LOG_E("%d : Invalid text mode", result); break; + case 310 : LOG_E("%d : SIM not inserted", result); break; + case 311 : LOG_E("%d : SIM pin necessary", result); break; + case 312 : LOG_E("%d : PH SIM pin necessary", result); break; + case 313 : LOG_E("%d : SIM failure", result); break; + case 314 : LOG_E("%d : SIM busy", result); break; + case 315 : LOG_E("%d : SIM wrong", result); break; + case 316 : LOG_E("%d : SIM PUK required", result); break; + case 317 : LOG_E("%d : SIM PIN2 required", result); break; + case 318 : LOG_E("%d : SIM PUK2 required", result); break; + case 320 : LOG_E("%d : Memory failure", result); break; + case 321 : LOG_E("%d : Invalid memory index", result); break; + case 322 : LOG_E("%d : Memory full", result); break; + case 330 : LOG_E("%d : SMSC address unknown", result); break; + case 331 : LOG_E("%d : No network", result); break; + case 332 : LOG_E("%d : Network timeout", result); break; + case 500 : LOG_E("%d : Unknown", result); break; + case 512 : LOG_E("%d : SIM not ready", result); break; + case 513 : LOG_E("%d : Message length exceeds", result); break; + case 514 : LOG_E("%d : Invalid request parameters", result); break; + case 515 : LOG_E("%d : ME storage failure", result); break; + case 517 : LOG_E("%d : Invalid service mode", result); break; + case 528 : LOG_E("%d : More message to send state error", result); break; + case 529 : LOG_E("%d : MO SMS is not allow", result); break; + case 530 : LOG_E("%d : GPRS is suspended", result); break; + case 531 : LOG_E("%d : ME storage full", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_mms_errcode_parse(int result)//MMS +{ + switch(result) + { + case 751 : LOG_E("%d : Unknown error", result); break; + case 752 : LOG_E("%d : URL length error", result); break; + case 753 : LOG_E("%d : URL error", result); break; + case 754 : LOG_E("%d : Invalid proxy type", result); break; + case 755 : LOG_E("%d : Proxy address error", result); break; + case 756 : LOG_E("%d : Invalid parameter", result); break; + case 757 : LOG_E("%d : Recipient address full", result); break; + case 758 : LOG_E("%d : CC recipient address full", result); break; + case 759 : LOG_E("%d : BCC recipient address full", result); break; + case 760 : LOG_E("%d : Attachments full", result); break; + case 761 : LOG_E("%d : File error", result); break; + case 762 : LOG_E("%d : No recipient", result); break; + case 763 : LOG_E("%d : File not found", result); break; + case 764 : LOG_E("%d : MMS busy", result); break; + case 765 : LOG_E("%d : Server response failed", result); break; + case 766 : LOG_E("%d : Error response of HTTP(S) post", result); break; + case 767 : LOG_E("%d : Invalid report of HTTP(S) post", result); break; + case 768 : LOG_E("%d : PDP activation failed", result); break; + case 769 : LOG_E("%d : PDP deactivated", result); break; + case 770 : LOG_E("%d : Socket creation failed", result); break; + case 771 : LOG_E("%d : Socket connection failed", result); break; + case 772 : LOG_E("%d : Socket read failed", result); break; + case 773 : LOG_E("%d : Socket write failed", result); break; + case 774 : LOG_E("%d : Socket closed", result); break; + case 775 : LOG_E("%d : Timeout", result); break; + case 776 : LOG_E("%d : Encode data error", result); break; + case 777 : LOG_E("%d : HTTP(S) decode data error", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} +*/ +static void at_tcp_ip_errcode_parse(int result)//TCP/IP_QIGETERROR +{ + switch(result) + { + case 0 : LOG_D("%d : Operation successful", result); break; + case 550 : LOG_E("%d : Unknown error", result); break; + case 551 : LOG_E("%d : Operation blocked", result); break; + case 552 : LOG_E("%d : Invalid parameters", result); break; + case 553 : LOG_E("%d : Memory not enough", result); break; + case 554 : LOG_E("%d : Create socket failed", result); break; + case 555 : LOG_E("%d : Operation not supported", result); break; + case 556 : LOG_E("%d : Socket bind failed", result); break; + case 557 : LOG_E("%d : Socket listen failed", result); break; + case 558 : LOG_E("%d : Socket write failed", result); break; + case 559 : LOG_E("%d : Socket read failed", result); break; + case 560 : LOG_E("%d : Socket accept failed", result); break; + case 561 : LOG_E("%d : Open PDP context failed", result); break; + case 562 : LOG_E("%d : Close PDP context failed", result); break; + case 563 : LOG_E("%d : Socket identity has been used", result); break; + case 564 : LOG_E("%d : DNS busy", result); break; + case 565 : LOG_E("%d : DNS parse failed", result); break; + case 566 : LOG_E("%d : Socket connect failed", result); break; + case 567 : LOG_E("%d : Socket has been closed", result); break; + case 568 : LOG_E("%d : Operation busy", result); break; + case 569 : LOG_E("%d : Operation timeout", result); break; + case 570 : LOG_E("%d : PDP context broken down", result); break; + case 571 : LOG_E("%d : Cancel send", result); break; + case 572 : LOG_E("%d : Operation not allowed", result); break; + case 573 : LOG_E("%d : APN not configured", result); break; + case 574 : LOG_E("%d : Port busy", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} +/* +static void at_http_errcode_parse(int result)//HTTP +{ + switch(result) + { + case 0 : LOG_D("%d : Operation successful", result); break; + case 701 : LOG_E("%d : HTTP(S) unknown error", result); break; + case 702 : LOG_E("%d : HTTP(S) timeout", result); break; + case 703 : LOG_E("%d : HTTP(S) busy", result); break; + case 704 : LOG_E("%d : HTTP(S) UART busy", result); break; + case 705 : LOG_E("%d : HTTP(S) no GET/POST requests", result); break; + case 706 : LOG_E("%d : HTTP(S) network busy", result); break; + case 707 : LOG_E("%d : HTTP(S) network open failed", result); break; + case 708 : LOG_E("%d : HTTP(S) network no configuration", result); break; + case 709 : LOG_E("%d : HTTP(S) network deactivated", result); break; + case 710 : LOG_E("%d : HTTP(S) network error", result); break; + case 711 : LOG_E("%d : HTTP(S) URL error", result); break; + case 712 : LOG_E("%d : HTTP(S) empty URL", result); break; + case 713 : LOG_E("%d : HTTP(S) IP address error", result); break; + case 714 : LOG_E("%d : HTTP(S) DNS error", result); break; + case 715 : LOG_E("%d : HTTP(S) socket create error", result); break; + case 716 : LOG_E("%d : HTTP(S) socket connect error", result); break; + case 717 : LOG_E("%d : HTTP(S) socket read error", result); break; + case 718 : LOG_E("%d : HTTP(S) socket write error", result); break; + case 719 : LOG_E("%d : HTTP(S) socket closed", result); break; + case 720 : LOG_E("%d : HTTP(S) data encode error", result); break; + case 721 : LOG_E("%d : HTTP(S) data decode error", result); break; + case 722 : LOG_E("%d : HTTP(S) read timeout", result); break; + case 723 : LOG_E("%d : HTTP(S) response failed", result); break; + case 724 : LOG_E("%d : Incoming call busy", result); break; + case 725 : LOG_E("%d : Voice call busy", result); break; + case 726 : LOG_E("%d : Input timeout", result); break; + case 727 : LOG_E("%d : Wait data timeout", result); break; + case 728 : LOG_E("%d : Wait HTTP(S) response timeout", result); break; + case 729 : LOG_E("%d : Memory allocation failed", result); break; + case 730 : LOG_E("%d : Invalid parameter", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_http_rsponsecode_parse(int result)//HTTP +{ + switch(result) + { + case 200 : LOG_D("%d : OK", result); break; + case 400 : LOG_E("%d : Bad request", result); break; + case 403 : LOG_E("%d : Forbidden", result); break; + case 404 : LOG_E("%d : Not found", result); break; + case 409 : LOG_E("%d : Conflict", result); break; + case 411 : LOG_E("%d : Length required", result); break; + case 500 : LOG_E("%d : Internal server error", result); break; + case 502 : LOG_E("%d : Bad gate way", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_ftp_errcode_parse(int result)//FTP +{ + switch(result) + { + case 0 : LOG_D("%d : Operation successful", result); break; + case 601 : LOG_E("%d : Unknown error", result); break; + case 602 : LOG_E("%d : FTP(S) server blocked", result); break; + case 603 : LOG_E("%d : FTP(S) server busy", result); break; + case 604 : LOG_E("%d : DNS parse failed", result); break; + case 605 : LOG_E("%d : Network error", result); break; + case 606 : LOG_E("%d : Control connection closed.", result); break; + case 607 : LOG_E("%d : Data connection closed", result); break; + case 608 : LOG_E("%d : Socket closed by peer", result); break; + case 609 : LOG_E("%d : Timeout error", result); break; + case 610 : LOG_E("%d : Invalid parameter", result); break; + case 611 : LOG_E("%d : Failed to open file", result); break; + case 612 : LOG_E("%d : File position invalid", result); break; + case 613 : LOG_E("%d : File error", result); break; + case 614 : LOG_E("%d : Service not available, closing control connection", result); break; + case 615 : LOG_E("%d : Open data connection failed", result); break; + case 616 : LOG_E("%d : Connection closed; transfer aborted", result); break; + case 617 : LOG_E("%d : Requested file action not taken", result); break; + case 618 : LOG_E("%d : Requested action aborted: local error in processing", result); break; + case 619 : LOG_E("%d : Requested action not taken: insufficient system storage", result); break; + case 620 : LOG_E("%d : Syntax error, command unrecognized", result); break; + case 621 : LOG_E("%d : Syntax error in parameters or arguments", result); break; + case 622 : LOG_E("%d : Command not implemented", result); break; + case 623 : LOG_E("%d : Bad sequence of commands", result); break; + case 624 : LOG_E("%d : Command parameter not implemented", result); break; + case 625 : LOG_E("%d : Not logged in", result); break; + case 626 : LOG_E("%d : Need account for storing files", result); break; + case 627 : LOG_E("%d : Requested action not taken", result); break; + case 628 : LOG_E("%d : Requested action aborted: page type unknown", result); break; + case 629 : LOG_E("%d : Requested file action aborted", result); break; + case 630 : LOG_E("%d : Requested file name invalid", result); break; + case 631 : LOG_E("%d : SSL authentication failed", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_ftp_protocol_errcode_parse(int result)//FTP_Protocol +{ + switch(result) + { + case 421 : LOG_E("%d : Service not available, closing control connection", result); break; + case 425 : LOG_E("%d : Open data connection failed", result); break; + case 426 : LOG_E("%d : Connection closed; transfer aborted", result); break; + case 450 : LOG_E("%d : Requested file action not taken", result); break; + case 451 : LOG_E("%d : Requested action aborted: local error in processing", result); break; + case 452 : LOG_E("%d : Requested action not taken: insufficient system storage", result); break; + case 500 : LOG_E("%d : Syntax error, command unrecognized", result); break; + case 501 : LOG_E("%d : Syntax error in parameters or arguments", result); break; + case 502 : LOG_E("%d : Command not implemented", result); break; + case 503 : LOG_E("%d : Bad sequence of commands", result); break; + case 504 : LOG_E("%d : Command parameter not implemented", result); break; + case 530 : LOG_E("%d : Not logged in", result); break; + case 532 : LOG_E("%d : Need account for storing files", result); break; + case 550 : LOG_E("%d : Requested action not taken: file unavailable", result); break; + case 551 : LOG_E("%d : Requested action aborted: page type unknown", result); break; + case 552 : LOG_E("%d : Requested file action aborted: exceeded storage allocation", result); break; + case 553 : LOG_E("%d : Requested action not taken: file name not allowed", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_smtp_errcode_parse(int result)//Email +{ + switch(result) + { + case 651 : LOG_E("%d : Unknown error", result); break; + case 652 : LOG_E("%d : The SMTP server is busy, such as uploading the body or sending an email.", result); break; + case 653 : LOG_E("%d : Failed to get IP address according to the domain name.", result); break; + case 654 : LOG_E("%d : Network error, such as failed to activate GPRS/CSD context, failed to establish the TCP connection with the SMTP server or failed to send an email to the SMTP server, etc.", result); break; + case 655 : LOG_E("%d : Unsupported authentication type", result); break; + case 656 : LOG_E("%d : The connection for the SMTP server is closed by peer.", result); break; + case 657 : LOG_E("%d : GPRS/CSD context is deactivated.", result); break; + case 658 : LOG_E("%d : Timeout", result); break; + case 659 : LOG_E("%d : No recipient for the SMTP server", result); break; + case 660 : LOG_E("%d : Failed to send an email", result); break; + case 661 : LOG_E("%d : Failed to open a file", result); break; + case 662 : LOG_E("%d : No enough memory for the attachment", result); break; + case 663 : LOG_E("%d : Failed to save the attachment", result); break; + case 664 : LOG_E("%d : The input parameter is wrong", result); break; + case 665 : LOG_E("%d : SSL authentication failed", result); break; + case 666 : LOG_E("%d : Service not available, closing transmission channel", result); break; + case 667 : LOG_E("%d : Requested mail action not taken: mailbox unavailable", result); break; + case 668 : LOG_E("%d : Requested action aborted: local error in processing", result); break; + case 669 : LOG_E("%d : Requested action not taken: insufficient system storage", result); break; + case 670 : LOG_E("%d : Syntax error, command unrecognized", result); break; + case 671 : LOG_E("%d : Syntax error in parameters or arguments", result); break; + case 672 : LOG_E("%d : Command not implemented", result); break; + case 673 : LOG_E("%d : Bad sequence of commands", result); break; + case 674 : LOG_E("%d : Command parameter not implemented", result); break; + case 675 : LOG_E("%d : does not accept mail (see RFC1846)", result); break; + case 676 : LOG_E("%d : Access denied", result); break; + case 677 : LOG_E("%d : Authentication failed", result); break; + case 678 : LOG_E("%d : Requested action not taken: mailbox unavailable", result); break; + case 679 : LOG_E("%d : User not local; please try ", result); break; + case 680 : LOG_E("%d : Requested mail action aborted: exceeded storage allocation", result); break; + case 681 : LOG_E("%d : Requested action not taken: mailbox name not allowed", result); break; + case 682 : LOG_E("%d : Transaction failed", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} + +static void at_smtp_protocol_errcode_parse(int result)//Email_Protocol +{ + switch(result) + { + case 421 : LOG_E("%d : Service not available, closing transmission channel", result); break; + case 450 : LOG_E("%d : Requested mail action not taken: mailbox unavailable", result); break; + case 451 : LOG_E("%d : Requested action aborted: local error in processing", result); break; + case 452 : LOG_E("%d : Requested action not taken: insufficient system storage", result); break; + case 500 : LOG_E("%d : Syntax error, command unrecognized", result); break; + case 501 : LOG_E("%d : Syntax error in parameters or arguments", result); break; + case 502 : LOG_E("%d : Command not implemented", result); break; + case 503 : LOG_E("%d : Bad sequence of commands", result); break; + case 504 : LOG_E("%d : Command parameter not implemented", result); break; + case 521 : LOG_E("%d : does not accept mail (see RFC1846)", result); break; + case 530 : LOG_E("%d : Access denied", result); break; + case 535 : LOG_E("%d : Authentication failed", result); break; + case 550 : LOG_E("%d : Requested action not taken: mailbox unavailable", result); break; + case 551 : LOG_E("%d : User not local; please try ", result); break; + case 552 : LOG_E("%d : Requested mail action aborted: exceeded storage allocation", result); break; + case 553 : LOG_E("%d : Requested action not taken: mailbox name not allowed", result); break; + case 554 : LOG_E("%d : Transaction failed", result); break; + default : LOG_E("%d : Unknown err code", result); break; + } +} +*/ +static int at_socket_event_send(uint32_t event) +{ + return (int) rt_event_send(at_socket_event, event); +} + +static int at_socket_event_recv(uint32_t event, uint32_t timeout, rt_uint8_t option) +{ + int result = 0; + rt_uint32_t recved; + + result = rt_event_recv(at_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 ec20_socket_close(int socket) +{ + int result = 0; + at_response_t resp = RT_NULL; + + resp = at_create_resp(64, 2, rt_tick_from_millisecond(2 * 1000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + /* default connection timeout is 10 seconds, but it set to 1 seconds is convenient to use.*/ + result = at_exec_cmd(resp, "AT+QICLOSE=%d,1", socket); + if (result < 0) + { + LOG_E("socket (%d) close failed, wait close OK timeout or ERROR.", socket); + } + +//__exit: + if (resp) + { + at_delete_resp(resp); + } + 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 ec20_socket_connect(int socket, char *ip, int32_t port, enum at_socket_type type, rt_bool_t is_client) +{ + int result = 0, event_result = 0; + rt_bool_t retryed = RT_FALSE; + + RT_ASSERT(ip); + RT_ASSERT(port >= 0); + + /* lock AT socket connect */ + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + +__retry: + + if (is_client) + { + switch (type) + { + case AT_SOCKET_TCP: + /* send AT commands(AT+QIOPEN=,,"","/",,,) to connect TCP server */ + /* 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_exec_cmd(RT_NULL, "AT+QIOPEN=1,%d,\"TCP\",\"%s\",%d,0,1", socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + case AT_SOCKET_UDP: + if (at_exec_cmd(RT_NULL, "AT+QIOPEN=1,%d,\"UDP\",\"%s\",%d,0,1", socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + default: + LOG_E("Not supported connect type : %d.", type); + return -RT_ERROR; + } + } + + /* 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 (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(10 * 1000), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("socket (%d) connect failed, wait connect result timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + if ((event_result = at_socket_event_recv(EC20_EVENT_CONN_OK | EC20_EVENT_CONN_FAIL, rt_tick_from_millisecond(1 * 1000), + RT_EVENT_FLAG_OR)) < 0) + { + LOG_E("socket (%d) connect failed, wait connect OK|FAIL timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & EC20_EVENT_CONN_FAIL) + { + if (!retryed) + { + LOG_E("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", socket); + if (ec20_socket_close(socket) < 0) + { + goto __exit; + } + retryed = RT_TRUE; + goto __retry; + } + LOG_E("socket (%d) connect failed, failed to establish a connection.", socket); + result = -RT_ERROR; + goto __exit; + } + +__exit: + /* unlock AT socket connect */ + rt_mutex_release(at_event_lock); + + return result; +} + +int net_socket_connect(int socket, char *ip, int32_t port,enum at_socket_type type) +{ + return ec20_socket_connect(socket,ip,port,type,1); +} + +static int at_get_send_size(int socket, size_t *size, size_t *acked, size_t *nacked) +{ + at_response_t resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000)); + int result = 0; + + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + + if (at_exec_cmd(resp, "AT+QISEND=%d,0", socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args_by_kw(resp, "+QISEND:", "+QISEND: %d,%d,%d", size, acked, nacked) <= 0) + { + result = -RT_ERROR; + goto __exit; + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +static int at_wait_send_finish(int socket, size_t settings_size) +{ + /* get the timeout by the input data size */ + rt_tick_t timeout = rt_tick_from_millisecond(settings_size); + rt_tick_t last_time = rt_tick_get(); + size_t size = 0, acked = 0, nacked = 0xFFFF; + + while (rt_tick_get() - last_time <= timeout) + { + at_get_send_size(socket, &size, &acked, &nacked); + if (nacked == 0) + { + return RT_EOK; + } + rt_thread_delay(rt_tick_from_millisecond(50)); + } + + return -RT_ETIMEOUT; +} + +/** + * 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 ec20_socket_send(int socket, const char *buff, size_t bfsz, enum at_socket_type type) +{ + int result = 0, event_result = 0; + at_response_t resp = RT_NULL; + size_t cur_pkt_size = 0, sent_size = 0; + + RT_ASSERT(buff); + + resp = at_create_resp(128, 2, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + /* set current socket for send URC event */ + cur_socket = socket; + /* set AT client end sign to deal with '>' sign.*/ + at_set_end_sign('>'); + + while (sent_size < bfsz) + { + if (bfsz - sent_size < EC20_MODULE_SEND_MAX_SIZE) + { + cur_pkt_size = bfsz - sent_size; + } + else + { + cur_pkt_size = EC20_MODULE_SEND_MAX_SIZE; + } + + /* send the "AT+QISEND" commands to AT server than receive the '>' response on the first line. */ + if (at_exec_cmd(resp, "AT+QISEND=%d,%d", socket, cur_pkt_size) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* send the real data to server or client */ + result = (int) at_client_send(buff + sent_size, cur_pkt_size); + if (result == 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* waiting result event from AT URC */ + if (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(300*3), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("socket (%d) send failed, wait connect result timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + if ((event_result = at_socket_event_recv(EC20_EVENT_SEND_OK | EC20_EVENT_SEND_FAIL, rt_tick_from_millisecond(1 * 1000), + RT_EVENT_FLAG_OR)) < 0) + { + LOG_E("socket (%d) send failed, wait connect OK|FAIL timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & EC20_EVENT_SEND_FAIL) + { + LOG_E("socket (%d) send failed, return failed.", socket); + result = -RT_ERROR; + goto __exit; + } + + if (type == AT_SOCKET_TCP) + { + at_wait_send_finish(socket, cur_pkt_size); + } + + sent_size += cur_pkt_size; + } + + +__exit: + /* reset the end sign for data conflict */ + at_set_end_sign(0); + + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + return result; +} + +int32_t net_socket_send(int socket, const char *buff, size_t bfsz,enum at_socket_type type) +{ + return ec20_socket_send(socket,buff,bfsz,type); +} + +/* +AT+CMGF=1 //Set SMS message format as text mode +OK +AT+CSCS="GSM" //Set character set as GSM which is used by the TE +OK +AT+CMGS="18601285716" +> ++CMGS: 247 +OK +*/ +int ec20_sms_send(char *ph,const char *fmt, ...) +{ + va_list args; + rt_size_t length; + char *msg_buf; + int result = 0; + at_response_t resp = RT_NULL; + + + RT_ASSERT(ph); + + msg_buf=rt_malloc(MAX_MESSAGE_SIZE); + if(!msg_buf) + { + LOG_E("No memory for short message structure!"); + return -RT_ENOMEM; + } + va_start(args, fmt); + length = rt_vsnprintf(msg_buf,MAX_MESSAGE_SIZE-2,fmt,args); + //length = vsnprintf(msg_buf,MAX_MESSAGE_SIZE-2,fmt,args); + if(length > (MAX_MESSAGE_SIZE-2)) + length = MAX_MESSAGE_SIZE-2; + va_end(args); + msg_buf[length++]=0x1A;//ctrl+z + msg_buf[length]=0;//������ + resp = at_create_resp(MAX_MESSAGE_SIZE,2,rt_tick_from_millisecond(300)); + if(!resp) + { + LOG_E("No memory for response structure!"); + rt_free(msg_buf); + return -RT_ENOMEM; + } + + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + /* set AT client end sign to deal with '>' sign.*/ + at_set_end_sign('>'); + /* send the "AT+CMGS" commands to AT server than receive the '>' response on the first line. */ + if(at_exec_cmd(resp,"AT+CMGS=\"%s\"",ph) < 0) + { + result = -RT_ERROR; + /* reset the end sign for data conflict */ + at_set_end_sign(0); + goto __exit; + } + /* reset the end sign for data conflict */ + at_set_end_sign(0); + + /* send the real short message data */ + result = (int) at_client_send(msg_buf,length); + if(result == 0) + { + result = -RT_ERROR; + goto __exit; + } +__exit: + rt_mutex_release(at_event_lock); + rt_free(msg_buf); + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +int sms_send(int argc,char **argv) +{ + return ec20_sms_send(argv[1],argv[2]); +} + +MSH_CMD_EXPORT(sms_send,send a short message:phone_num message); + +/** + * 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 ec20_domain_resolve(const char *name, char ip[16]) +{ +#define RESOLVE_RETRY 5 + + int i, result; + char recv_ip[16] = { 0 }; + at_response_t resp = RT_NULL; + + + RT_ASSERT(name); + RT_ASSERT(ip); + + /* The maximum response time is 60 seconds, but it set to 10 seconds is convenient to use. */ + resp = at_create_resp(128, 0, rt_tick_from_millisecond(10 * 1000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + /* Clear EC20_EVENT_DOMAIN_OK */ + at_socket_event_recv(EC20_EVENT_DOMAIN_OK, 0, RT_EVENT_FLAG_OR); + for(i = 0; i < RESOLVE_RETRY; i++) + { + if (at_exec_cmd(resp, "AT+QIDNSGIP=1,\"%s\"", name) < 0) + { + LOG_E("Domain \"%s\" resolve return ERROR (%d).", name, i); + result = -RT_ERROR; + continue; + } + else + { + result = RT_EOK; + break; + } + } + if (result == RT_EOK) + { + for(i = 0; i < RESOLVE_RETRY; i++) + { + /* waiting result event from AT URC, the device default connection timeout is 60 seconds.*/ + if (at_socket_event_recv(EC20_EVENT_DOMAIN_OK, rt_tick_from_millisecond(10 * 1000), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("Domain \"%s\" resolve failed, wait dns result timeout.", name); + result = -RT_ETIMEOUT; + continue; + } + else + { + if (strlen(recv_ip) < 8) + { + rt_thread_delay(rt_tick_from_millisecond(100)); + /* resolve failed, maybe receive an URC CRLF */ + result = -RT_ERROR; + continue; + } + else + { + strncpy(ip, recv_ip, 15); + ip[15] = '\0'; + result = RT_EOK; + break; + } + } + } + } + + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + return result; + +} + +/** + * set AT socket event notice callback + * + * @param event notice event + * @param cb notice callback + */ +static void ec20_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_ping_func(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); + //LOG_I("%s",data); + for (i=0;i,0" command to close socket */ + at_exec_cmd(RT_NULL, "AT+QICLOSE=%d,0\r\n", socket); + rt_thread_delay(rt_tick_from_millisecond(100)); +} + +static void urc_recv_func(const char *data, rt_size_t size) +{ + extern void pkt_rx_cb(void *buff,rt_size_t len); + int socket = 0; + rt_size_t bfsz = 0, temp_size = 0; + rt_int32_t timeout; + char *recv_buf = RT_NULL, temp[8]; + + RT_ASSERT(data && size); + + /* get the current socket and receive buffer size by receive data */ + sscanf(data, "+QIURC: \"recv\",%d,%d", &socket, (int *) &bfsz); + /* get receive timeout by receive buffer length */ + timeout = bfsz; + + if (socket < 0 || bfsz == 0) + return; + + recv_buf = rt_calloc(1, bfsz); + if (!recv_buf) + { + LOG_E("no memory for URC receive buffer (%d)!", bfsz); + /* read and clean the coming data */ + while (temp_size < bfsz) + { + if (bfsz - temp_size > sizeof(temp)) + { + at_client_recv(temp, sizeof(temp), timeout); + } + else + { + at_client_recv(temp, bfsz - temp_size, timeout); + } + temp_size += sizeof(temp); + } + return; + } + + /* sync receive data */ + if (at_client_recv(recv_buf, bfsz, timeout) != bfsz) + { + LOG_E("receive size(%d) data failed!", bfsz); + rt_free(recv_buf); + return; + } + pkt_rx_cb(recv_buf,bfsz); + /* 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); + } +} + +static void urc_pdpdeact_func(const char *data, rt_size_t size) +{ + int connectID = 0; + + RT_ASSERT(data && size); + + sscanf(data, "+QIURC: \"pdpdeact\",%d", &connectID); + + LOG_E("Context (%d) is deactivated.", connectID); +} + +static void urc_dnsqip_func(const char *data, rt_size_t size) +{ + int i = 0, j = 0; + int result, ip_count, dns_ttl; + static uint8_t resolved = 0; + char recv_ip[16] = { 0 }; + RT_ASSERT(data && size); + + for(i=0;i0) + { + //LOG_I("receive short message from %s,content=%s",phone_num,content); + sms_pkt_process(phone_num,content,len); + } + else + { + LOG_E("receive short message failed:can not receiv content"); + } + rt_free(content); +} + +static void urc_qiurc_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + +// LOG_D("qiurc : %s", data); + switch(*(data+9)) + { + case 'c' : urc_close_func(data, size); break;//+QIURC: "closed" + case 'r' : urc_recv_func(data, size); break;//+QIURC: "recv" + case 'p' : urc_pdpdeact_func(data, size); break;//+QIURC: "pdpdeact" + case 'd' : urc_dnsqip_func(data, size); break;//+QIURC: "dnsgip" + default : urc_func(data, size); break;// + } +} + +static const struct at_urc urc_table[] = { + {"SEND OK", "\r\n", urc_send_func}, + {"SEND FAIL", "\r\n", urc_send_func}, + {"+QPING:", "\r\n", urc_ping_func}, + {"+QIOPEN:", "\r\n", urc_connect_func}, + {"+QIURC:", "\r\n", urc_qiurc_func}, + {"+CMT:", "\r\n", urc_sms_func}, +}; + +/* +//��������ģʽ���� +�Զ�ģʽ +AT+QCFG="nwscanmode",0,1 +GSM onlyģʽ +AT+QCFG="nwscanmode",1,1 +LTE onlyģʽ +AT+QCFG="nwscanmode",3,1 +//��������˳������ +�Զ� +AT+QCFG=��nwscanseq��,00,1 +GSM +AT+QCFG=��nwscanseq��,01,1 +TD-SCDMA +AT+QCFG=��nwscanseq��,02,1 +WCDMA +AT+QCFG=��nwscanseq��,03,1 +LTE +AT+QCFG=��nwscanseq��,04,1 +*/ + +/* +AT+CMGF=1 //Set SMS message format as text mode +OK +AT+CSCS="GSM" //Set character set as GSM which is used by the TE +OK +AT+CMGS="18601285716" +> ++CMGS: 247 +OK +*/ + +#define AT_SEND_CMD(resp, resp_line, timeout, cmd) \ + do \ + { \ + if (at_exec_cmd(at_resp_set_info(resp, 256, resp_line, rt_tick_from_millisecond(timeout)), cmd) < 0) \ + { \ + result = -RT_ERROR; \ + goto __exit; \ + } \ + } while(0); \ + + +/* init for EC20 �������ѷ���,����ʹ��*/ +/* +static void ec20_init_thread_entry(void *parameter) +{ +#define AT_RETRY 10 +#define CIMI_RETRY 10 +#define CSQ_RETRY 20 +#define CREG_RETRY 10 +#define CGREG_RETRY 20 + +//#define LED_LTE_PWR GET_PIN(I,10) +//#define LED_LTE_RST GET_PIN(F,10) +//#define LED_LTE_WKP GET_PIN(H,2) + int ctrlz=26; + at_response_t resp = RT_NULL; + int i, qi_arg[3]; + char parsed_data[64]; + rt_err_t result = RT_EOK; + + rt_uint32_t e; + rt_uint32_t offline_tick=0; + +// rt_pin_mode(LED_LTE_PWR,PIN_MODE_OUTPUT_OD);//PI10 LTE_PWR +// rt_pin_mode(LED_LTE_WKP,PIN_MODE_OUTPUT);//PH2 LTE_WKUP +// rt_pin_mode(LED_LTE_RST,PIN_MODE_OUTPUT_OD);//PF10 LTE_RST + + + //ec20_send_evt(EC20_REDIAL); + while(1) + {//RT_WAITING_FOREVER + if(rt_event_recv(&ec20_dial_evt,(EC20_REDIAL|(1<<1)|(1<<2)),RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,RT_TICK_PER_SECOND*60,&e)==RT_EOK) + { + //pm_work_start(); + //rt_pin_write(LED_LTE_RST,PIN_HIGH);//LTE_RST + //rt_pin_write(LED_LTE_PWR,PIN_HIGH);//LTE_PWR + //rt_thread_delay(RT_TICK_PER_SECOND*6); + //rt_pin_write(LED_LTE_PWR,PIN_LOW);//LTE_PWR + + //rt_pin_write(LED_LTE_WKP,PIN_HIGH);//LTE_WKP + //rt_thread_delay(RT_TICK_PER_SECOND*8); + result = RT_EOK; + if(e&EC20_REDIAL) + { + resp = at_create_resp(256, 0, rt_tick_from_millisecond(300)); + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + LOG_D("Start initializing the EC20 module"); + // wait EC20 startup finish, Send AT every 500ms, if receive OK, SYNC success + if (at_client_wait_connect(EC20_WAIT_CONNECT_TIME)) + { + result = -RT_ETIMEOUT; + goto __exit; + } + // set response format to ATV1 + AT_SEND_CMD(resp, 0, 300, "ATV1"); + // disable echo + AT_SEND_CMD(resp, 0, 300, "ATE0"); + // Use AT+CMEE=2 to enable result code and use verbose values + AT_SEND_CMD(resp, 0, 300, "AT+CMEE=2"); + // Get the baudrate + AT_SEND_CMD(resp, 0, 300, "AT+IPR?"); + at_resp_parse_line_args_by_kw(resp, "+IPR:", "+IPR: %d", &i); + LOG_D("Baudrate %d", i); + // get module version + AT_SEND_CMD(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)); + } + // Use AT+GSN to query the IMEI of module + AT_SEND_CMD(resp, 0, 300, "AT+GSN"); + + // check SIM card + AT_SEND_CMD(resp, 2, 5 * 1000, "AT+CPIN?"); + if (!at_resp_get_line_by_kw(resp, "READY")) + { + LOG_E("SIM card detection failed"); + result = -RT_ERROR; + goto __exit; + } + // waiting for dirty data to be digested + rt_thread_delay(rt_tick_from_millisecond(10)); + + + // Use AT+CIMI to query the IMSI of SIM card +// AT_SEND_CMD(resp, 2, 300, "AT+CIMI"); + i = 0; + while(at_exec_cmd(at_resp_set_info(resp, 128, 0, rt_tick_from_millisecond(300)), "AT+CIMI") < 0) + { + i++; + LOG_D("AT+CIMI %d", i); + if(i > CIMI_RETRY) + { + LOG_E("Read CIMI failed"); + result = -RT_ERROR; + goto __exit; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + + // Use AT+QCCID to query ICCID number of SIM card + AT_SEND_CMD(resp, 0, 300, "AT+QCCID"); + // check signal strength + for (i = 0; i < CSQ_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CSQ"); + at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &qi_arg[0], &qi_arg[1]); + lte_rssi=qi_arg[0]; + if (qi_arg[0] != 99) + { + LOG_D("Signal strength: %d Channel bit error rate: %d", qi_arg[0], qi_arg[1]); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CSQ_RETRY) + { + LOG_E("Signal strength check failed (%s)", parsed_data); + result = -RT_ERROR; + //goto __exit; + } + + + AT_SEND_CMD(resp,0,300,"AT+QCFG=\"nwscanmode\",1,1"); + + // check the GSM network is registered + for (i = 0; i < CREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CREG?"); + at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GSM network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CREG_RETRY) + { + LOG_E("The GSM network is register failed (%s)", parsed_data); + result = -RT_ERROR; + //goto __exit; + } + // check the GPRS network is registered + for (i = 0; i < CGREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CGREG?"); + at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GPRS network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CGREG_RETRY) + { + LOG_E("The GPRS network is register failed (%s)", parsed_data); + result = -RT_ERROR; + //goto __exit; + } + + + + //Use AT+CEREG? to query current EPS Network Registration Status + AT_SEND_CMD(resp, 0, 300, "AT+CEREG?"); + // Use AT+COPS? to query current Network Operator + AT_SEND_CMD(resp, 0, 1000, "AT+COPS?"); + at_resp_parse_line_args_by_kw(resp, "+COPS:", "+COPS: %*[^\"]\"%[^\"]", &parsed_data); + LOG_I("%s", parsed_data); + if(strcmp(dev_para.dial_apn,"any")==0) + { + if(strcmp(parsed_data,"CHINA MOBILE") == 0) + { + // "CMCC" + //LOG_I("%s", parsed_data); + AT_SEND_CMD(resp, 0, 300, QICSGP_CHINA_MOBILE); + } + else if(strcmp(parsed_data,"CHN-UNICOM") == 0) + { + // "UNICOM" + //LOG_I("%s", parsed_data); + AT_SEND_CMD(resp, 0, 300, QICSGP_CHINA_UNICOM); + } + else if(strcmp(parsed_data,"CHN-CT") == 0) + { + AT_SEND_CMD(resp, 0, 300, QICSGP_CHINA_TELECOM); + // "CT" + //LOG_I("%s", parsed_data); + } + } + else + { + //set APN + memset(parsed_data,0,sizeof(parsed_data)); + //rt_sprintf(parsed_data,"AT+QICSGP=1,1,\"ahdl02.vpdn.ah\",\"\",\"\",0"); + rt_sprintf(parsed_data,"AT+QICSGP=1,1,\"%s\",\"%s\",\"%s\",0",dev_para.dial_apn,dev_para.dial_usr,dev_para.dial_pwd); + AT_SEND_CMD(resp,0,2000,parsed_data); + } + + //Query the configuration of context 1 + AT_SEND_CMD(resp,0,1000,"AT+QICSGP=1"); + at_resp_parse_line_args_by_kw(resp,"+QICSGP:","+QICSGP: %s",&parsed_data); + LOG_I("%s",parsed_data); + + AT_SEND_CMD(resp,0,300,"AT+QNWINFO"); + at_resp_parse_line_args_by_kw(resp,"+QNWINFO:","+QNWINFO: %s",&parsed_data); + LOG_I("%s",parsed_data); + + if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+QURCCFG=\"urcport\",\"uart1\"")<0) + { + LOG_E("Set uartport to uart1 failed"); + } + else + { + LOG_D("Set uartport to uart1 ok"); + } + + if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CMGF=1")<0) + { + LOG_E("Set SMS message format as text mode failed"); + } + else + { + LOG_D("Set SMS message format as text mode ok"); + } + + if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CSCS=\"GSM\"")<0) + { + LOG_E("Set character set as GSM which is used by the TE failed"); + } + else + { + LOG_D("Set character set as GSM which is used by the TE ok"); + } + //if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CNMI=1,2,0,0,0")<0) + if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CNMI=1,2,0,1,0")<0) + { + LOG_E("Set SMS-DELIVERs are routed directly to the TE failed"); + } + else + { + LOG_D("Set SMS-DELIVERs are routed directly to the TE ok"); + } + +//+CMT: ��+8615021012496��,,��15/03/18,17:07:21+32��,145,4,0,0,��+8613800551500��,145,28 +//This is a test from Quectel. //Short message is outputted directly when SMS is incoming + + // Enable automatic time zone update via NITZ and update LOCAL time to RTC + AT_SEND_CMD(resp, 0, 300, "AT+CTZU=3"); + // Get RTC time + AT_SEND_CMD(resp, 0, 300, "AT+CCLK?"); + + // Deactivate context profile + AT_SEND_CMD(resp, 0, 40 * 1000, "AT+QIDEACT=1");//�˳�����״̬ + // Activate context profile + AT_SEND_CMD(resp, 0, 150 * 1000, "AT+QIACT=1");//���¼��������� + // Query the status of the context profile + AT_SEND_CMD(resp, 0, 150 * 1000, "AT+QIACT?");//��ѯ����״̬ + at_resp_parse_line_args_by_kw(resp, "+QIACT:", "+QIACT: %*[^\"]\"%[^\"]", &parsed_data); + LOG_I("%s", parsed_data); + +__exit: + if(!result) + { + LOG_I("AT network initialize success!"); + + //Esc����ת���Ϊ\e ctrl+z��ת���Ϊ'\x1A' + //AT_SEND_CMD(resp, 0, 300, "AT+CMGF=1"); + //if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CMGF=1")<0) + //{ + // LOG_E("Set SMS message format as text mode failed"); + //} + //else + //{ + // LOG_D("Set SMS message format as text mode ok"); + //} + //AT_SEND_CMD(resp, 0, 2 * 1000, "AT+CSCS=\"GSM\""); + //if(at_exec_cmd(at_resp_set_info(resp,128,0,rt_tick_from_millisecond(300)),"AT+CSCS=\"GSM\"")<0) + //{ + // LOG_E("Set character set as GSM which is used by the TE failed"); + //} + //else + //{ + // LOG_D("Set character set as GSM which is used by the TE ok"); + //} + ec20_sms_send("18601285716","shxy short message test"); + ec20_online=1; + } + else + { + LOG_E("AT network initialize failed (%d)!", result); + ec20_online=0;//���� + } + + if(resp) + { + at_delete_resp(resp); + } + } + //pm_work_end(); + }//end if(rt_event_recv(&ec20_dial_evt,((1<<0)|(1<<1)|(1<<2)),RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,RT_TICK_PER_SECOND*60,&e)==RT_EOK) + else + { + //ͳ������ʱ�� + if(ec20_online!=1) + { //ec20_online==0��ʾ���� + offline_tick++;//������ʱ + if(offline_tick>=10) + { //������ʱ����10���� + offline_tick=0; + ec20_send_evt(EC20_REDIAL);//�������²����¼� + LOG_I("EC20 now redial\n"); + } + } + else + { //ec20_online==1��ʾ���� + offline_tick=0; + } + } + }//end while(1) +} +*/ + +// init for EC20 +rt_err_t ec20_net_dial(void *parameter) +{ +#define AT_RETRY 10 +#define CIMI_RETRY 10 +#define CSQ_RETRY 30 +#define CREG_RETRY 20 +#define CGREG_RETRY 30 +#define DEF_TIME_TICK 1000 +// int ctrlz=26; + at_response_t resp = RT_NULL; + int i, qi_arg[3]; + char parsed_data[64]; + rt_err_t result = RT_EOK; + +// rt_uint32_t e; +// rt_uint32_t offline_tick=0; + + + + //pm_work_start(); + + + result = RT_EOK; + + resp = at_create_resp(256, 0, rt_tick_from_millisecond(DEF_TIME_TICK)); + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + LOG_D("Start initializing the EC20 module"); + // wait EC20 startup finish, Send AT every 500ms, if receive OK, SYNC success + if (at_client_wait_connect(EC20_WAIT_CONNECT_TIME)) + { + result = -RT_ETIMEOUT; + goto __exit; + } + // set response format to ATV1 + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "ATV1"); + // disable echo + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "ATE0"); + // Use AT+CMEE=2 to enable result code and use verbose values + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CMEE=2"); + // Get the baudrate + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+IPR?"); + at_resp_parse_line_args_by_kw(resp, "+IPR:", "+IPR: %d", &i); + LOG_D("Baudrate %d", i); + // get module version + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"ATI"); + // show module version + for (i = 0; i < (int) resp->line_counts - 1; i++) + { + LOG_D("%s", at_resp_get_line(resp, i + 1)); + } + // Use AT+GSN to query the IMEI of module + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+GSN"); + + // check SIM card + AT_SEND_CMD(resp, 2, 6 * 1000, "AT+CPIN?"); + if(!at_resp_get_line_by_kw(resp, "READY")) + { + LOG_E("SIM card detection failed,try again"); + AT_SEND_CMD(resp, 2, 6 * 1000, "AT+CPIN?"); + if(!at_resp_get_line_by_kw(resp,"READY")) + { + LOG_E("SIM card detection failed"); + result = -RT_ERROR; + goto __exit; + } + } + // waiting for dirty data to be digested + rt_thread_delay(rt_tick_from_millisecond(100)); + + //AT_SEND_CMD(resp, 2, 2 * 1000, "AT+CNUM");//查询SIM卡号 + //LOG_D("sim_card=%s", at_resp_get_line(resp,1)); + //LOG_D("%s", at_resp_get_line(resp,2)); + // Use AT+CIMI to query the IMSI of SIM card +// AT_SEND_CMD(resp, 2, 300, "AT+CIMI"); + i = 0; + while(at_exec_cmd(at_resp_set_info(resp, 256, 0, rt_tick_from_millisecond(500)), "AT+CIMI") < 0) + { + i++; + LOG_D("AT+CIMI %d", i); + if(i > CIMI_RETRY) + { + LOG_E("Read CIMI failed"); + result = -RT_ERROR; + goto __exit; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + + if(dev_para.dial_mode==DIAL_4G_ONLY) + { + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"AT+QCFG=\"nwscanmode\",3,1"); + } + else if(dev_para.dial_mode==DIAL_2G_ONLY) + { + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"AT+QCFG=\"nwscanmode\",1,1"); + } + else + { + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"AT+QCFG=\"nwscanmode\",0,1"); + //AT_SEND_CMD(resp,0,600,"AT+QCFG=\"cdmaruim\",1");//����3G��Ҫ���� + } + + // Use AT+QCCID to query ICCID number of SIM card + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+QCCID"); + // check signal strength + for (i = 0; i < CSQ_RETRY; i++) + { + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CSQ"); + at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &qi_arg[0], &qi_arg[1]); + lte_rssi=qi_arg[0]; + if (qi_arg[0] != 99) + { + LOG_D("Signal strength: %d Channel bit error rate: %d", qi_arg[0], qi_arg[1]); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CSQ_RETRY) + { + LOG_E("Signal strength check failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + + + + // check the GSM network is registered + for (i = 0; i < CREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CREG?"); + at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GSM network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CREG_RETRY) + { + LOG_E("The GSM network is register failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + // check the GPRS network is registered + for (i = 0; i < CGREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CGREG?"); + at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GPRS network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CGREG_RETRY) + { + LOG_E("The GPRS network is register failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + + + //Use AT+CEREG? to query current EPS Network Registration Status + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CEREG?");//��ѯlteע��״̬ + // Use AT+COPS? to query current Network Operator + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+COPS?");//��ѯע���������ʽ + //+COPS: %*[^\"]\"%[^\"]��ʾ��ȡ��һ��˫"�ڵ�����:���ظ�ʽ+COPS: 0,0,"CHN-CT",100 + at_resp_parse_line_args_by_kw(resp, "+COPS:", "+COPS: %*[^\"]\"%[^\"]", &parsed_data); + LOG_I("%s", parsed_data);//��ӡ������ʽ + if(strcmp(dev_para.dial_apn,"any")==0) + { + if(strcmp(parsed_data,"CHINA MOBILE") == 0) + { + // "CMCC" + //LOG_I("%s", parsed_data); + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, QICSGP_CHINA_MOBILE); + } + else if(strcmp(parsed_data,"CHN-UNICOM") == 0) + { + // "UNICOM" + //LOG_I("%s", parsed_data); + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, QICSGP_CHINA_UNICOM); + } + else if(strcmp(parsed_data,"CHN-CT") == 0) + { + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, QICSGP_CHINA_TELECOM); + // "CT" + //LOG_I("%s", parsed_data); + } + } + else + { + //set APN + rt_memset(parsed_data,0,sizeof(parsed_data)); + //rt_sprintf(parsed_data,"AT+QICSGP=1,1,\"ahdl02.vpdn.ah\",\"\",\"\",0"); + rt_sprintf(parsed_data,"AT+QICSGP=1,1,\"%s\",\"%s\",\"%s\",0",dev_para.dial_apn,dev_para.dial_usr,dev_para.dial_pwd); + AT_SEND_CMD(resp,0,DEF_TIME_TICK,parsed_data); + } + + //Query the configuration of context 1 + //��ѯ����������Ϣ + rt_memset(parsed_data,0,sizeof(parsed_data)); + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"AT+QICSGP=1"); + at_resp_parse_line_args_by_kw(resp,"+QICSGP:","+QICSGP: %s",&parsed_data); + LOG_I("%s",parsed_data); + // + rt_memset(parsed_data,0,sizeof(parsed_data)); + AT_SEND_CMD(resp,0,DEF_TIME_TICK,"AT+QNWINFO"); + at_resp_parse_line_args_by_kw(resp,"+QNWINFO:","+QNWINFO: %s",&parsed_data); + LOG_I("%s",parsed_data); + + if(at_exec_cmd(at_resp_set_info(resp,256,0,rt_tick_from_millisecond(DEF_TIME_TICK)),"AT+QURCCFG=\"urcport\",\"uart1\"")<0) + { + LOG_E("Set uartport to uart1 failed"); + } + + if(at_exec_cmd(at_resp_set_info(resp,256,0,rt_tick_from_millisecond(DEF_TIME_TICK)),"AT+CMGF=1")<0) + { + LOG_E("Set SMS message format as text mode failed"); + } + + + if(at_exec_cmd(at_resp_set_info(resp,256,0,rt_tick_from_millisecond(DEF_TIME_TICK)),"AT+CSCS=\"GSM\"")<0) + { + LOG_E("Set character set as GSM which is used by the TE failed"); + } + + if(at_exec_cmd(at_resp_set_info(resp,256,0,rt_tick_from_millisecond(DEF_TIME_TICK)),"AT+CNMI=1,2,0,1,0")<0) + { + LOG_E("Set SMS-DELIVERs are routed directly to the TE failed"); + } + + // Enable automatic time zone update via NITZ and update LOCAL time to RTC + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CTZU=3"); + // Get RTC time + AT_SEND_CMD(resp, 0, DEF_TIME_TICK, "AT+CCLK?"); + + // Deactivate context profile + AT_SEND_CMD(resp, 0, 40 * 1000, "AT+QIDEACT=1"); + // Activate context profile + AT_SEND_CMD(resp, 0, 150 * 1000, "AT+QIACT=1"); + // Query the status of the context profile + AT_SEND_CMD(resp, 0, 150 * 1000, "AT+QIACT?"); + //��ѯIP��Ϣ + at_resp_parse_line_args_by_kw(resp, "+QIACT:", "+QIACT: %*[^\"]\"%[^\"]", &parsed_data); + LOG_I("%s", parsed_data); + rt_memcpy(lte_ip,parsed_data,sizeof(lte_ip)); +__exit: + if(!result) + { + LOG_I("AT network initialize success!"); + //ec20_sms_send("18601285716","shxy short message test"); + } + else + { + LOG_E("AT network initialize failed (%d)!",result); + } + + if(resp) + { + at_delete_resp(resp); + } + //pm_work_end(); + + return result; +} + +void ec20_net_init(void) +{ +#ifdef PKG_AT_INIT_BY_THREAD + //rt_thread_t tid; + //tid = rt_thread_create("ec20_net_init", ec20_init_thread_entry, RT_NULL, EC20_THREAD_STACK_SIZE, EC20_THREAD_PRIORITY, 20); + // if (tid) + //{ + // rt_thread_startup(tid); + // } + // else + // { + LOG_E("Create AT initialization thread fail!"); + // } +#else + return ec20_init_thread_entry(RT_NULL); +#endif +} + +int ec20_ping(int argc, char **argv) +{ + at_response_t resp = RT_NULL; + + if (argc != 2) + { + rt_kprintf("Please input: at_ping \n"); + return -RT_ERROR; + } + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + rt_kprintf("No memory for response structure!\n"); + return -RT_ENOMEM; + } + + if (at_exec_cmd(resp, "AT+QPING=1,\"%s\"", argv[1]) < 0) + { + rt_kprintf("AT send ping commands error!\n"); + return -RT_ERROR; + } + + if (resp) + { + at_delete_resp(resp); + } + + return RT_EOK; +} + +int ec20_connect(int argc, char **argv) +{ + int32_t port; + + if (argc != 3) + { + rt_kprintf("Please input: at_connect \n"); + return -RT_ERROR; + } + sscanf(argv[2],"%d",&port); + ec20_socket_connect(0, argv[1], port, AT_SOCKET_TCP, 1); + + return RT_EOK; +} + +int ec20_close(int argc, char **argv) +{ + if (ec20_socket_close(0) < 0) + { + rt_kprintf("ec20_socket_close fail\n"); + } + else + { + rt_kprintf("ec20_socket_closeed\n"); + } + return RT_EOK; +} + +int ec20_send(int argc, char **argv) +{ + const char *buff = "1234567890\n"; + if (ec20_socket_send(0, buff, 11, AT_SOCKET_TCP) < 0) + { + rt_kprintf("ec20_socket_send fail\n"); + } + + return RT_EOK; +} + +int ec20_domain(int argc, char **argv) +{ + char ip[16]; + if (ec20_domain_resolve("baidu.com", ip) < 0) + { + rt_kprintf("ec20_socket_send fail\n"); + } + else + { + rt_kprintf("baidu.com : %s\n", ip); + } + + return RT_EOK; +} + +int ec20_ifconfig(void) +{ + at_response_t resp = RT_NULL; + char resp_arg[AT_CMD_MAX_LEN] = { 0 }; + rt_err_t result = RT_EOK; + + resp = at_create_resp(128, 2, rt_tick_from_millisecond(300)); + if(!resp) + { + rt_kprintf("No memory for response structure!\n"); + return -RT_ENOMEM; + } + + /* Query the status of the context profile */ + AT_SEND_CMD(resp, 0, 150 * 1000, "AT+QIACT?"); + at_resp_parse_line_args_by_kw(resp, "+QIACT:", "+QIACT: %*[^\"]\"%[^\"]", &resp_arg); + rt_kprintf("IP adress : %s\n", resp_arg); + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +#ifdef FINSH_USING_MSH +#include +MSH_CMD_EXPORT_ALIAS(ec20_net_init, at_net_init, initialize AT network); +MSH_CMD_EXPORT_ALIAS(ec20_ping, at_ping, AT ping network host); +MSH_CMD_EXPORT_ALIAS(ec20_ifconfig, at_ifconfig, list the information of network interfaces); +MSH_CMD_EXPORT_ALIAS(ec20_connect, at_connect, AT connect network host); +MSH_CMD_EXPORT_ALIAS(ec20_close, at_close, AT close a socket); +MSH_CMD_EXPORT_ALIAS(ec20_send, at_send, AT send a pack); +MSH_CMD_EXPORT_ALIAS(ec20_domain, at_domain, AT domain resolve); +#endif + +static const struct at_device_ops ec20_socket_ops = { + ec20_socket_connect, + ec20_socket_close, + ec20_socket_send, + ec20_domain_resolve, + ec20_socket_set_event_cb, +}; + +static int at_socket_device_init(void) +{ + //add by tmb + rt_event_init(&ec20_dial_evt, "dialevt",RT_IPC_FLAG_FIFO); + + /* create current AT socket event */ + at_socket_event = rt_event_create("at_se", RT_IPC_FLAG_FIFO); + if (!at_socket_event) + { + LOG_E("AT client port initialize failed! at_sock_event create failed!"); + return -RT_ENOMEM; + } + + /* create current AT socket lock */ + at_event_lock = rt_mutex_create("at_se", RT_IPC_FLAG_FIFO); + if (!at_event_lock) + { + LOG_E("AT client port initialize failed! at_sock_lock create failed!"); + rt_event_delete(at_socket_event); + return -RT_ENOMEM; + } + + /* initialize AT client */ + at_client_init(AT_DEVICE_NAME, AT_DEVICE_RECV_BUFF_LEN); + + /* register URC data execution function */ + at_set_urc_table(urc_table, sizeof(urc_table) / sizeof(urc_table[0])); + + /* initialize EC20 network */ + //ec20_net_init(); + + /* set EC20 AT Socket options */ + at_socket_device_register(&ec20_socket_ops); + + return 0; +} +INIT_ENV_EXPORT(at_socket_device_init); + +#endif /* AT_DEVICE_EC20 */ diff --git a/at_socket_esp8266.c b/at_socket_esp8266.c new file mode 100644 index 0000000..008b647 --- /dev/null +++ b/at_socket_esp8266.c @@ -0,0 +1,720 @@ +/* + * File : at_socket_esp8266.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-20 chenyong first version + */ + +#include +#include +#include + +#include +#include + +#include + +#if !defined(AT_SW_VERSION_NUM) || AT_SW_VERSION_NUM < 0x10200 +#error "This AT Client version is older, please check and update latest AT Client!" +#endif + +#define LOG_TAG "at.esp8266" +#include + +#ifdef AT_DEVICE_ESP8266 + +#define ESP8266_MODULE_SEND_MAX_SIZE 2048 +#define ESP8266_WAIT_CONNECT_TIME 5000 +#define ESP8266_THREAD_STACK_SIZE 1024 +#define ESP8266_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2) + +/* set real event by current socket and current state */ +#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event)) + +/* AT socket event type */ +#define ESP8266_EVENT_CONN_OK (1L << 0) +#define ESP8266_EVENT_SEND_OK (1L << 1) +#define ESP8266_EVENT_RECV_OK (1L << 2) +#define ESP8266_EVNET_CLOSE_OK (1L << 3) +#define ESP8266_EVENT_CONN_FAIL (1L << 4) +#define ESP8266_EVENT_SEND_FAIL (1L << 5) + +static int cur_socket; +static int cur_send_bfsz; +static rt_event_t at_socket_event; +static rt_mutex_t at_event_lock; +static at_evt_cb_t at_evt_cb_set[] = { + [AT_SOCKET_EVT_RECV] = NULL, + [AT_SOCKET_EVT_CLOSED] = NULL, +}; + +static int at_socket_event_send(uint32_t event) +{ + return (int) rt_event_send(at_socket_event, event); +} + +static int at_socket_event_recv(uint32_t event, uint32_t timeout, rt_uint8_t option) +{ + int result = 0; + rt_uint32_t recved; + + result = rt_event_recv(at_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 esp8266_socket_close(int socket) +{ + at_response_t resp = RT_NULL; + int result = RT_EOK; + + resp = at_create_resp(64, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + if (at_exec_cmd(resp, "AT+CIPCLOSE=%d", socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + __exit: + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + 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 esp8266_socket_connect(int socket, char *ip, int32_t port, enum at_socket_type type, rt_bool_t is_client) +{ + at_response_t resp = RT_NULL; + int result = RT_EOK; + rt_bool_t retryed = RT_FALSE; + + RT_ASSERT(ip); + RT_ASSERT(port >= 0); + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + +__retry: + if (is_client) + { + switch (type) + { + case AT_SOCKET_TCP: + /* send AT commands to connect TCP server */ + if (at_exec_cmd(resp, "AT+CIPSTART=%d,\"TCP\",\"%s\",%d,60", socket, ip, port) < 0) + { + result = -RT_ERROR; + } + break; + + case AT_SOCKET_UDP: + if (at_exec_cmd(resp, "AT+CIPSTART=%d,\"UDP\",\"%s\",%d", socket, ip, port) < 0) + { + result = -RT_ERROR; + } + break; + + default: + LOG_E("Not supported connect type : %d.", type); + 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 (esp8266_socket_close(socket) < 0) + { + goto __exit; + } + retryed = RT_TRUE; + result = RT_EOK; + goto __retry; + } + +__exit: + rt_mutex_release(at_event_lock); + + 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 esp8266_socket_send(int socket, const char *buff, size_t bfsz, enum at_socket_type type) +{ + int result = RT_EOK; + int event_result = 0; + at_response_t resp = RT_NULL; + size_t cur_pkt_size = 0, sent_size = 0; + + RT_ASSERT(buff); + RT_ASSERT(bfsz > 0); + + resp = at_create_resp(128, 2, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + /* set current socket for send URC event */ + cur_socket = socket; + /* set AT client end sign to deal with '>' sign.*/ + at_set_end_sign('>'); + + while (sent_size < bfsz) + { + if (bfsz - sent_size < ESP8266_MODULE_SEND_MAX_SIZE) + { + cur_pkt_size = bfsz - sent_size; + } + else + { + cur_pkt_size = ESP8266_MODULE_SEND_MAX_SIZE; + } + + /* send the "AT+CIPSEND" commands to AT server than receive the '>' response on the first line. */ + if (at_exec_cmd(resp, "AT+CIPSEND=%d,%d", socket, cur_pkt_size) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* send the real data to server or client */ + result = (int) at_client_send(buff + sent_size, cur_pkt_size); + if (result == 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* waiting result event from AT URC */ + if (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(5 * 1000), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("socket (%d) send failed, wait connect result timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + if ((event_result = at_socket_event_recv(ESP8266_EVENT_SEND_OK | ESP8266_EVENT_SEND_FAIL, rt_tick_from_millisecond(5 * 1000), + RT_EVENT_FLAG_OR)) < 0) + { + LOG_E("socket (%d) send failed, wait connect OK|FAIL timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & ESP8266_EVENT_SEND_FAIL) + { + LOG_E("socket (%d) send failed, return failed.", socket); + result = -RT_ERROR; + goto __exit; + } + + if (type == AT_SOCKET_TCP) + { + cur_pkt_size = cur_send_bfsz; + } + + sent_size += cur_pkt_size; + } + +__exit: + /* reset the end sign for data */ + at_set_end_sign(0); + + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + return 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 + * -2: wait socket event timeout + * -5: no memory + */ +static int esp8266_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; + + RT_ASSERT(name); + RT_ASSERT(ip); + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + for(i = 0; i < RESOLVE_RETRY; i++) + { + if (at_exec_cmd(resp, "AT+CIPDOMAIN=\"%s\"", name) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* parse the third line of response data, get the IP address */ + if(at_resp_parse_line_args_by_kw(resp, "+CIPDOMAIN:", "+CIPDOMAIN:%s", recv_ip) < 0) + { + rt_thread_delay(rt_tick_from_millisecond(100)); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + + if (strlen(recv_ip) < 8) + { + rt_thread_delay(rt_tick_from_millisecond(100)); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + else + { + strncpy(ip, recv_ip, 15); + ip[15] = '\0'; + break; + } + } + +__exit: + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + return result; + +} + +/** + * set AT socket event notice callback + * + * @param event notice event + * @param cb notice callback + */ +static void esp8266_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_send_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + + if (strstr(data, "SEND OK")) + { + at_socket_event_send(SET_EVENT(cur_socket, ESP8266_EVENT_SEND_OK)); + } + else if (strstr(data, "SEND FAIL")) + { + at_socket_event_send(SET_EVENT(cur_socket, ESP8266_EVENT_SEND_FAIL)); + } +} + +static void urc_send_bfsz_func(const char *data, rt_size_t size) +{ + int send_bfsz = 0; + + RT_ASSERT(data && size); + + sscanf(data, "Recv %d bytes", &send_bfsz); + + cur_send_bfsz = send_bfsz; +} + +static void urc_close_func(const char *data, rt_size_t size) +{ + int socket = 0; + + RT_ASSERT(data && size); + + sscanf(data, "%d,CLOSED", &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(const char *data, rt_size_t size) +{ + int socket = 0; + rt_size_t bfsz = 0, temp_size = 0; + rt_int32_t timeout; + char *recv_buf = RT_NULL, temp[8]; + + RT_ASSERT(data && size); + + /* get the current socket and receive buffer size by receive data */ + sscanf(data, "+IPD,%d,%d:", &socket, (int *) &bfsz); + /* get receive timeout by receive buffer length */ + timeout = bfsz; + + if (socket < 0 || bfsz == 0) + return; + + recv_buf = rt_calloc(1, bfsz); + if (!recv_buf) + { + LOG_E("no memory for URC receive buffer (%d)!", bfsz); + /* read and clean the coming data */ + while (temp_size < bfsz) + { + if (bfsz - temp_size > sizeof(temp)) + { + at_client_recv(temp, sizeof(temp), timeout); + } + else + { + at_client_recv(temp, bfsz - temp_size, timeout); + } + temp_size += sizeof(temp); + } + return; + } + + /* sync receive data */ + if (at_client_recv(recv_buf, bfsz, timeout) != bfsz) + { + LOG_E("receive size(%d) data failed!", bfsz); + rt_free(recv_buf); + return; + } + + /* 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); + } +} + +static void urc_busy_p_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + + LOG_D("system is processing a commands and it cannot respond to the current commands."); +} + +static void urc_busy_s_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + + LOG_D("system is sending data and it cannot respond to the current commands."); +} + +static void urc_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + + if(strstr(data, "WIFI CONNECTED")) + { + LOG_I("ESP8266 WIFI is connected."); + } + else if(strstr(data, "WIFI DISCONNECT")) + { + LOG_I("ESP8266 WIFI is disconnect."); + } +} + +static struct at_urc urc_table[] = { + {"SEND OK", "\r\n", urc_send_func}, + {"SEND FAIL", "\r\n", urc_send_func}, + {"Recv", "bytes\r\n", urc_send_bfsz_func}, + {"", ",CLOSED\r\n", urc_close_func}, + {"+IPD", ":", urc_recv_func}, + {"busy p", "\r\n", urc_busy_p_func}, + {"busy s", "\r\n", urc_busy_s_func}, + {"WIFI CONNECTED", "\r\n", urc_func}, + {"WIFI DISCONNECT", "\r\n", urc_func}, +}; + +#define AT_SEND_CMD(resp, cmd) \ + do \ + { \ + if (at_exec_cmd(at_resp_set_info(resp, 256, 0, rt_tick_from_millisecond(5000)), cmd) < 0) \ + { \ + LOG_E("RT AT send commands(%s) error!", cmd); \ + result = -RT_ERROR; \ + goto __exit; \ + } \ + } while(0); \ + +static void esp8266_init_thread_entry(void *parameter) +{ + at_response_t resp = RT_NULL; + rt_err_t result = RT_EOK; + rt_size_t i; + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + + rt_thread_delay(rt_tick_from_millisecond(5000)); + /* reset module */ + AT_SEND_CMD(resp, "AT+RST"); + /* reset waiting delay */ + rt_thread_delay(rt_tick_from_millisecond(1000)); + /* disable echo */ + AT_SEND_CMD(resp, "ATE0"); + /* set current mode to Wi-Fi station */ + AT_SEND_CMD(resp, "AT+CWMODE=1"); + /* get module version */ + AT_SEND_CMD(resp, "AT+GMR"); + /* show module version */ + for (i = 0; i < resp->line_counts - 1; i++) + { + LOG_D("%s", at_resp_get_line(resp, i + 1)); + } + /* connect to WiFi AP */ + if (at_exec_cmd(at_resp_set_info(resp, 128, 0, 20 * RT_TICK_PER_SECOND), "AT+CWJAP=\"%s\",\"%s\"", + AT_DEVICE_WIFI_SSID, AT_DEVICE_WIFI_PASSWORD) != RT_EOK) + { + LOG_E("AT network initialize failed, check ssid(%s) and password(%s).", AT_DEVICE_WIFI_SSID, AT_DEVICE_WIFI_PASSWORD); + result = -RT_ERROR; + goto __exit; + } + + AT_SEND_CMD(resp, "AT+CIPMUX=1"); + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + if (!result) + { + LOG_I("AT network initialize success!"); + } + else + { + LOG_E("AT network initialize failed (%d)!", result); + } +} + +int esp8266_net_init(void) +{ +#ifdef PKG_AT_INIT_BY_THREAD + rt_thread_t tid; + + tid = rt_thread_create("esp8266_net_init", esp8266_init_thread_entry, RT_NULL,ESP8266_THREAD_STACK_SIZE, ESP8266_THREAD_PRIORITY, 20); + if (tid) + { + rt_thread_startup(tid); + } + else + { + LOG_E("Create AT initialization thread fail!"); + } +#else + esp8266_init_thread_entry(RT_NULL); +#endif + + return RT_EOK; +} + +int esp8266_ping(int argc, char **argv) +{ + at_response_t resp = RT_NULL; + static int icmp_seq; + int req_time; + + if (argc != 2) + { + rt_kprintf("Please input: at_ping \n"); + return -RT_ERROR; + } + + resp = at_create_resp(64, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + rt_kprintf("No memory for response structure!\n"); + return -RT_ENOMEM; + } + + for(icmp_seq = 1; icmp_seq <= 4; icmp_seq++) + { + if (at_exec_cmd(resp, "AT+PING=\"%s\"", argv[1]) < 0) + { + rt_kprintf("ping: unknown remote server host\n"); + at_delete_resp(resp); + return -RT_ERROR; + } + + if(at_resp_parse_line_args_by_kw(resp, "+", "+%d", &req_time) < 0) + { + continue; + } + + if (req_time) + { + rt_kprintf("32 bytes from %s icmp_seq=%d time=%d ms\n", argv[1], icmp_seq, req_time); + } + } + + if (resp) + { + at_delete_resp(resp); + } + + return RT_EOK; +} + +#ifdef FINSH_USING_MSH +#include +MSH_CMD_EXPORT_ALIAS(esp8266_net_init, at_net_init, initialize AT network); +MSH_CMD_EXPORT_ALIAS(esp8266_ping, at_ping, AT ping network host); +#endif + +static const struct at_device_ops esp8266_socket_ops = { + esp8266_socket_connect, + esp8266_socket_close, + esp8266_socket_send, + esp8266_domain_resolve, + esp8266_socket_set_event_cb, +}; + +static int at_socket_device_init(void) +{ + /* create current AT socket event */ + at_socket_event = rt_event_create("at_se", RT_IPC_FLAG_FIFO); + if (at_socket_event == RT_NULL) + { + LOG_E("RT AT client port initialize failed! at_sock_event create failed!"); + return -RT_ENOMEM; + } + + /* create current AT socket event lock */ + at_event_lock = rt_mutex_create("at_se", RT_IPC_FLAG_FIFO); + if (at_event_lock == RT_NULL) + { + LOG_E("RT AT client port initialize failed! at_sock_lock create failed!"); + rt_event_delete(at_socket_event); + return -RT_ENOMEM; + } + + /* initialize AT client */ + at_client_init(AT_DEVICE_NAME, AT_DEVICE_RECV_BUFF_LEN); + + /* register URC data execution function */ + at_set_urc_table(urc_table, sizeof(urc_table) / sizeof(urc_table[0])); + + /* initialize esp8266 network */ + esp8266_net_init(); + + /* set esp8266 AT Socket options */ + at_socket_device_register(&esp8266_socket_ops); + + return RT_EOK; +} +INIT_APP_EXPORT(at_socket_device_init); + +#endif /* AT_DEVICE_ESP8266 */ diff --git a/at_socket_m26.c b/at_socket_m26.c new file mode 100644 index 0000000..2ae84ea --- /dev/null +++ b/at_socket_m26.c @@ -0,0 +1,934 @@ +/* + * File : at_socket_m26.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 chenyong first version + */ + +#include +#include + +#include +#include + +#include +#include + +#if !defined(AT_SW_VERSION_NUM) || AT_SW_VERSION_NUM < 0x10200 +#error "This AT Client version is older, please check and update latest AT Client!" +#endif + +#define LOG_TAG "at.m26|mc20" +#include + +#ifdef AT_DEVICE_M26 + +#define M26_MODULE_SEND_MAX_SIZE 1460 +#define M26_WAIT_CONNECT_TIME 5000 +#define M26_THREAD_STACK_SIZE 1024 +#define M26_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2) + +/* set real event by current socket and current state */ +#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event)) + +/* AT socket event type */ +#define M26_EVENT_CONN_OK (1L << 0) +#define M26_EVENT_SEND_OK (1L << 1) +#define M26_EVENT_RECV_OK (1L << 2) +#define M26_EVNET_CLOSE_OK (1L << 3) +#define M26_EVENT_CONN_FAIL (1L << 4) +#define M26_EVENT_SEND_FAIL (1L << 5) + +static int cur_socket; +static rt_event_t at_socket_event; +static rt_mutex_t at_event_lock; +static at_evt_cb_t at_evt_cb_set[] = { + [AT_SOCKET_EVT_RECV] = NULL, + [AT_SOCKET_EVT_CLOSED] = NULL, +}; + +static int at_socket_event_send(uint32_t event) +{ + return (int) rt_event_send(at_socket_event, event); +} + +static int at_socket_event_recv(uint32_t event, uint32_t timeout, rt_uint8_t option) +{ + int result = 0; + rt_uint32_t recved; + + result = rt_event_recv(at_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 m26_socket_close(int socket) +{ + int result = 0; + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + cur_socket = socket; + + if (at_exec_cmd(RT_NULL, "AT+QICLOSE=%d", socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_socket_event_recv(SET_EVENT(socket, M26_EVNET_CLOSE_OK), rt_tick_from_millisecond(300*3), RT_EVENT_FLAG_AND) < 0) + { + LOG_E("socket (%d) close failed, wait close OK timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + +__exit: + rt_mutex_release(at_event_lock); + + 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 m26_socket_connect(int socket, char *ip, int32_t port, enum at_socket_type type, rt_bool_t is_client) +{ + int result = 0, event_result = 0; + rt_bool_t retryed = RT_FALSE; + + RT_ASSERT(ip); + RT_ASSERT(port >= 0); + + /* lock AT socket connect */ + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + +__retry: + + 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_exec_cmd(RT_NULL, "AT+QIOPEN=%d,\"TCP\",\"%s\",%d", socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + case AT_SOCKET_UDP: + if (at_exec_cmd(RT_NULL, "AT+QIOPEN=%d,\"UDP\",\"%s\",%d", socket, ip, port) < 0) + { + result = -RT_ERROR; + goto __exit; + } + break; + + default: + LOG_E("Not supported connect type : %d.", type); + return -RT_ERROR; + } + } + + /* 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 (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(10 * 1000), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("socket (%d) connect failed, wait connect result timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + if ((event_result = at_socket_event_recv(M26_EVENT_CONN_OK | M26_EVENT_CONN_FAIL, rt_tick_from_millisecond(1 * 1000), + RT_EVENT_FLAG_OR)) < 0) + { + LOG_E("socket (%d) connect failed, wait connect OK|FAIL timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & M26_EVENT_CONN_FAIL) + { + if (!retryed) + { + LOG_E("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", socket); + if (m26_socket_close(socket) < 0) + { + goto __exit; + } + retryed = RT_TRUE; + goto __retry; + } + LOG_E("socket (%d) connect failed, failed to establish a connection.", socket); + result = -RT_ERROR; + goto __exit; + } + +__exit: + /* unlock AT socket connect */ + rt_mutex_release(at_event_lock); + + return result; +} + +static int at_get_send_size(int socket, size_t *size, size_t *acked, size_t *nacked) +{ + at_response_t resp = at_create_resp(64, 0, rt_tick_from_millisecond(5000)); + int result = 0; + + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + + if (at_exec_cmd(resp, "AT+QISACK=%d", socket) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args_by_kw(resp, "+QISACK:", "+QISACK: %d, %d, %d", size, acked, nacked) <= 0) + { + result = -RT_ERROR; + goto __exit; + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +static int at_wait_send_finish(int socket, size_t settings_size) +{ + /* get the timeout by the input data size */ + rt_tick_t timeout = rt_tick_from_millisecond(settings_size); + rt_tick_t last_time = rt_tick_get(); + size_t size = 0, acked = 0, nacked = 0xFFFF; + + while (rt_tick_get() - last_time <= timeout) + { + at_get_send_size(socket, &size, &acked, &nacked); + if (nacked == 0) + { + return RT_EOK; + } + rt_thread_delay(rt_tick_from_millisecond(50)); + } + + return -RT_ETIMEOUT; +} + +/** + * 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 m26_socket_send(int socket, const char *buff, size_t bfsz, enum at_socket_type type) +{ + int result = 0, event_result = 0; + at_response_t resp = RT_NULL; + size_t cur_pkt_size = 0, sent_size = 0; + + RT_ASSERT(buff); + + resp = at_create_resp(128, 2, rt_tick_from_millisecond(5000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + /* set current socket for send URC event */ + cur_socket = socket; + /* set AT client end sign to deal with '>' sign.*/ + at_set_end_sign('>'); + + while (sent_size < bfsz) + { + if (bfsz - sent_size < M26_MODULE_SEND_MAX_SIZE) + { + cur_pkt_size = bfsz - sent_size; + } + else + { + cur_pkt_size = M26_MODULE_SEND_MAX_SIZE; + } + + /* send the "AT+QISEND" commands to AT server than receive the '>' response on the first line. */ + if (at_exec_cmd(resp, "AT+QISEND=%d,%d", socket, cur_pkt_size) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* send the real data to server or client */ + result = (int) at_client_send(buff + sent_size, cur_pkt_size); + if (result == 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* waiting result event from AT URC */ + if (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(300*3), RT_EVENT_FLAG_OR) < 0) + { + LOG_E("socket (%d) send failed, wait connect result timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* waiting OK or failed result */ + if ((event_result = at_socket_event_recv(M26_EVENT_SEND_OK | M26_EVENT_SEND_FAIL, rt_tick_from_millisecond(1 * 1000), + RT_EVENT_FLAG_OR)) < 0) + { + LOG_E("socket (%d) send failed, wait connect OK|FAIL timeout.", socket); + result = -RT_ETIMEOUT; + goto __exit; + } + /* check result */ + if (event_result & M26_EVENT_SEND_FAIL) + { + LOG_E("socket (%d) send failed, return failed.", socket); + result = -RT_ERROR; + goto __exit; + } + + if (type == AT_SOCKET_TCP) + { + at_wait_send_finish(socket, cur_pkt_size); + } + + sent_size += cur_pkt_size; + } + + +__exit: + /* reset the end sign for data conflict */ + at_set_end_sign(0); + + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + return 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 m26_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; + + RT_ASSERT(name); + RT_ASSERT(ip); + + /* The maximum response time is 14 seconds, affected by network status */ + resp = at_create_resp(128, 4, rt_tick_from_millisecond(14 * 1000)); + if (!resp) + { + LOG_E("No memory for response structure!"); + return -RT_ENOMEM; + } + + rt_mutex_take(at_event_lock, RT_WAITING_FOREVER); + + for(i = 0; i < RESOLVE_RETRY; i++) + { + if (at_exec_cmd(resp, "AT+QIDNSGIP=\"%s\"", name) < 0) + { + result = -RT_ERROR; + goto __exit; + } + + /* parse the third line of response data, get the IP address */ + if(at_resp_parse_line_args_by_kw(resp, ".", "%s", recv_ip) < 0) + { + rt_thread_delay(rt_tick_from_millisecond(100)); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + + if (strlen(recv_ip) < 8) + { + rt_thread_delay(rt_tick_from_millisecond(100)); + /* resolve failed, maybe receive an URC CRLF */ + continue; + } + else + { + strncpy(ip, recv_ip, 15); + ip[15] = '\0'; + break; + } + } + +__exit: + rt_mutex_release(at_event_lock); + + if (resp) + { + at_delete_resp(resp); + } + + return result; + +} + +/** + * set AT socket event notice callback + * + * @param event notice event + * @param cb notice callback + */ +static void m26_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(const char *data, rt_size_t size) +{ + int socket = 0; + + RT_ASSERT(data && size); + + sscanf(data, "%d%*[^0-9]", &socket); + + if (strstr(data, "CONNECT OK")) + { + at_socket_event_send(SET_EVENT(socket, M26_EVENT_CONN_OK)); + } + else + { + at_socket_event_send(SET_EVENT(socket, M26_EVENT_CONN_FAIL)); + } +} + +static void urc_send_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data && size); + + if (strstr(data, "SEND OK")) + { + at_socket_event_send(SET_EVENT(cur_socket, M26_EVENT_SEND_OK)); + } + else if (strstr(data, "SEND FAIL")) + { + at_socket_event_send(SET_EVENT(cur_socket, M26_EVENT_SEND_FAIL)); + } +} + +static void urc_close_func(const char *data, rt_size_t size) +{ + int socket = 0; + + RT_ASSERT(data && size); + + if (strstr(data, "CLOSE OK")) + { + at_socket_event_send(SET_EVENT(cur_socket, M26_EVNET_CLOSE_OK)); + } + else if (strstr(data, "CLOSED")) + { + sscanf(data, "%d, CLOSED", &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, NULL, 0); + } + } +} + +static void urc_recv_func(const char *data, rt_size_t size) +{ + int socket = 0; + rt_size_t bfsz = 0, temp_size = 0; + rt_int32_t timeout; + char *recv_buf = RT_NULL, temp[8]; + + RT_ASSERT(data && size); + + /* get the current socket and receive buffer size by receive data */ + sscanf(data, "+RECEIVE: %d, %d", &socket, (int *) &bfsz); + /* get receive timeout by receive buffer length */ + timeout = bfsz; + + if (socket < 0 || bfsz == 0) + return; + + recv_buf = rt_calloc(1, bfsz); + if (!recv_buf) + { + LOG_E("no memory for URC receive buffer (%d)!", bfsz); + /* read and clean the coming data */ + while (temp_size < bfsz) + { + if (bfsz - temp_size > sizeof(temp)) + { + at_client_recv(temp, sizeof(temp), timeout); + } + else + { + at_client_recv(temp, bfsz - temp_size, timeout); + } + temp_size += sizeof(temp); + } + return; + } + + /* sync receive data */ + if (at_client_recv(recv_buf, bfsz, timeout) != bfsz) + { + LOG_E("receive size(%d) data failed!", bfsz); + rt_free(recv_buf); + return; + } + + /* 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); + } +} + +static void urc_ping_func(const char *data, rt_size_t size) +{ + static int icmp_seq = 0; + int result, recv_len, time, ttl; + char dst_ip[16] = { 0 }; + + RT_ASSERT(data); + + sscanf(data, "+QPING: %d,%[^,],%d,%d,%d", &result, dst_ip, &recv_len, &time, &ttl); + + switch(result) + { + case 0: + rt_kprintf("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", recv_len, dst_ip, icmp_seq++, ttl, time); + break; + case 1: + rt_kprintf("ping request timeout!\n"); + break; + case 2: + icmp_seq = 0; + break; + case 3: + rt_kprintf("ping: TCP/IP protocol stack is busy\n"); + break; + case 4: + rt_kprintf("ping: unknown remote server host\n"); + break; + default: + break; + } + +} + +static void urc_func(const char *data, rt_size_t size) +{ + RT_ASSERT(data); + + LOG_I("URC data : %.*s", size, data); +} + +static const struct at_urc urc_table[] = { + {"RING", "\r\n", urc_func}, + {"Call Ready", "\r\n", urc_func}, + {"RDY", "\r\n", urc_func}, + {"NO CARRIER", "\r\n", urc_func}, + {"", ", CONNECT OK\r\n", urc_connect_func}, + {"", ", CONNECT FAIL\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}, + {"+QPING:", "\r\n", urc_ping_func}, +}; + +#define AT_SEND_CMD(resp, resp_line, timeout, cmd) \ + do \ + { \ + if (at_exec_cmd(at_resp_set_info(resp, 128, resp_line, rt_tick_from_millisecond(timeout)), cmd) < 0) \ + { \ + result = -RT_ERROR; \ + goto __exit; \ + } \ + } while(0); \ + +/* init for M26 or MC20 */ +static void m26_init_thread_entry(void *parameter) +{ +#define CPIN_RETRY 10 +#define CSQ_RETRY 10 +#define CREG_RETRY 10 +#define CGREG_RETRY 20 + + at_response_t resp = RT_NULL; + int i, qimux, qimode; + char parsed_data[10]; + rt_err_t result = RT_EOK; + + resp = at_create_resp(128, 0, rt_tick_from_millisecond(300)); + if (!resp) + { + LOG_E("No memory for response structure!"); + result = -RT_ENOMEM; + goto __exit; + } + LOG_D("Start initializing the M26/MC20 module"); + /* wait M26 startup finish */ + if (at_client_wait_connect(M26_WAIT_CONNECT_TIME)) + { + result = -RT_ETIMEOUT; + goto __exit; + } + /* disable echo */ + AT_SEND_CMD(resp, 0, 300, "ATE0"); + /* get module version */ + AT_SEND_CMD(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_exec_cmd(at_resp_set_info(resp, 128, 2, rt_tick_from_millisecond(5000)), "AT+CPIN?"); + + if (at_resp_get_line_by_kw(resp, "READY")) + { + LOG_D("SIM card detection success"); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CPIN_RETRY) + { + LOG_E("SIM card detection failed!"); + result = -RT_ERROR; + goto __exit; + } + /* waiting for dirty data to be digested */ + rt_thread_delay(rt_tick_from_millisecond(10)); + /* check signal strength */ + for (i = 0; i < CSQ_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CSQ"); + at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %s", &parsed_data); + if (strncmp(parsed_data, "99,99", sizeof(parsed_data))) + { + LOG_D("Signal strength: %s", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CSQ_RETRY) + { + LOG_E("Signal strength check failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + /* check the GSM network is registered */ + for (i = 0; i < CREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CREG?"); + at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GSM network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CREG_RETRY) + { + LOG_E("The GSM network is register failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + /* check the GPRS network is registered */ + for (i = 0; i < CGREG_RETRY; i++) + { + AT_SEND_CMD(resp, 0, 300, "AT+CGREG?"); + at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data); + if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data))) + { + LOG_D("GPRS network is registered (%s)", parsed_data); + break; + } + rt_thread_delay(rt_tick_from_millisecond(1000)); + } + if (i == CGREG_RETRY) + { + LOG_E("The GPRS network is register failed (%s)", parsed_data); + result = -RT_ERROR; + goto __exit; + } + + AT_SEND_CMD(resp, 0, 300, "AT+QIFGCNT=0"); + AT_SEND_CMD(resp, 0, 300, "AT+QICSGP=1, \"CMNET\""); + AT_SEND_CMD(resp, 0, 300, "AT+QIMODE?"); + + at_resp_parse_line_args_by_kw(resp, "+QIMODE:", "+QIMODE: %d", &qimode); + if (qimode == 1) + { + AT_SEND_CMD(resp, 0, 300, "AT+QIMODE=0"); + } + + /* the device default response timeout is 40 seconds, but it set to 15 seconds is convenient to use. */ + AT_SEND_CMD(resp, 2, 20 * 1000, "AT+QIDEACT"); + + /* Set to multiple connections */ + AT_SEND_CMD(resp, 0, 300, "AT+QIMUX?"); + at_resp_parse_line_args_by_kw(resp, "+QIMUX:", "+QIMUX: %d", &qimux); + if (qimux == 0) + { + AT_SEND_CMD(resp, 0, 300, "AT+QIMUX=1"); + } + + AT_SEND_CMD(resp, 0, 300, "AT+QIREGAPP"); + + /* the device default response timeout is 150 seconds, but it set to 20 seconds is convenient to use. */ + AT_SEND_CMD(resp, 0, 20 * 1000, "AT+QIACT"); + + AT_SEND_CMD(resp, 2, 300, "AT+QILOCIP"); + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + if (!result) + { + LOG_I("AT network initialize success!"); + } + else + { + LOG_E("AT network initialize failed (%d)!", result); + } + +} + +int m26_net_init(void) +{ +#ifdef PKG_AT_INIT_BY_THREAD + rt_thread_t tid; + + tid = rt_thread_create("m26_net_init", m26_init_thread_entry, RT_NULL, M26_THREAD_STACK_SIZE, M26_THREAD_PRIORITY, 20); + if (tid) + { + rt_thread_startup(tid); + } + else + { + LOG_E("Create AT initialization thread fail!"); + } +#else + m26_init_thread_entry(RT_NULL); +#endif + + return RT_EOK; +} + +int m26_ping(int argc, char **argv) +{ + at_response_t resp = RT_NULL; + + if (argc != 2) + { + rt_kprintf("Please input: at_ping \n"); + return -RT_ERROR; + } + + resp = at_create_resp(64, 0, rt_tick_from_millisecond(5000)); + if (!resp) + { + rt_kprintf("No memory for response structure!\n"); + return -RT_ENOMEM; + } + + if (at_exec_cmd(resp, "AT+QPING=\"%s\"", argv[1]) < 0) + { + rt_kprintf("AT send ping commands error!\n"); + return -RT_ERROR; + } + + if (resp) + { + at_delete_resp(resp); + } + + return RT_EOK; +} + +int m26_ifconfig(void) +{ + at_response_t resp = RT_NULL; + char resp_arg[AT_CMD_MAX_LEN] = { 0 }; + const char * resp_expr = "%s"; + rt_err_t result = RT_EOK; + + resp = at_create_resp(64, 2, rt_tick_from_millisecond(300)); + if (!resp) + { + rt_kprintf("No memory for response structure!\n"); + return -RT_ENOMEM; + } + + if (at_exec_cmd(resp, "AT+QILOCIP") < 0) + { + rt_kprintf("AT send ip commands error!\n"); + result = RT_ERROR; + goto __exit; + } + + if (at_resp_parse_line_args(resp, 2, resp_expr, resp_arg) == 1) + { + rt_kprintf("IP address : %s\n", resp_arg); + } + else + { + rt_kprintf("Parse error, current line buff : %s\n", at_resp_get_line(resp, 2)); + result = RT_ERROR; + goto __exit; + } + +__exit: + if (resp) + { + at_delete_resp(resp); + } + + return result; +} + +#ifdef FINSH_USING_MSH +#include +MSH_CMD_EXPORT_ALIAS(m26_net_init, at_net_init, initialize AT network); +MSH_CMD_EXPORT_ALIAS(m26_ping, at_ping, AT ping network host); +MSH_CMD_EXPORT_ALIAS(m26_ifconfig, at_ifconfig, list the information of network interfaces); +#endif + +static const struct at_device_ops m26_socket_ops = { + m26_socket_connect, + m26_socket_close, + m26_socket_send, + m26_domain_resolve, + m26_socket_set_event_cb, +}; + +static int at_socket_device_init(void) +{ + /* create current AT socket event */ + at_socket_event = rt_event_create("at_se", RT_IPC_FLAG_FIFO); + if (at_socket_event == RT_NULL) + { + LOG_E("AT client port initialize failed! at_sock_event create failed!"); + return -RT_ENOMEM; + } + + /* create current AT socket event lock */ + at_event_lock = rt_mutex_create("at_se", RT_IPC_FLAG_FIFO); + if (at_event_lock == RT_NULL) + { + LOG_E("AT client port initialize failed! at_sock_lock create failed!"); + rt_event_delete(at_socket_event); + return -RT_ENOMEM; + } + + /* initialize AT client */ + at_client_init(AT_DEVICE_NAME, AT_DEVICE_RECV_BUFF_LEN); + + /* register URC data execution function */ + at_set_urc_table(urc_table, sizeof(urc_table) / sizeof(urc_table[0])); + + /* initialize m26 network */ + m26_net_init(); + + /* set m26 AT Socket options */ + at_socket_device_register(&m26_socket_ops); + + return RT_EOK; +} +INIT_APP_EXPORT(at_socket_device_init); + +#endif /* AT_DEVICE_M26 */