├── .github └── FUNDING.yml ├── LICENSE ├── README.md ├── bluetooth.c ├── call.c ├── gprs.c ├── gsm.c ├── gsm.h ├── gsmCallback.c ├── gsmConfig.h └── msg.c /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: [nimaltd] 4 | patreon: # Replace with a single Patreon username 5 | open_collective: # Replace with a single Open Collective username 6 | ko_fi: nimaltd 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry 9 | liberapay: nimaltd 10 | issuehunt: nimaltd 11 | otechie: # Replace with a single Otechie username 12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## GSM module library 2 | * Author: Nima Askari 3 | * WebSite: https://www.github.com/NimaLTD 4 | * Instagram: https://www.instagram.com/github.NimaLTD 5 | * LinkedIn: https://www.linkedin.com/in/NimaLTD 6 | * Youtube: https://www.youtube.com/channel/UCUhY7qY1klJm1d2kulr9ckw 7 | -------------------------------------------------------------------------------- 8 | Not recommended for small devices 9 | -------------------------------------------------------------------------------- 10 | * [x] CMSIS V1 Supported. 11 | * [ ] CMSIS V2 Supported. 12 | -------------------------------------------------------------------------------- 13 | * [x] SIM800C tested. 14 | * [ ] SIM800 tested. 15 | * [ ] SIM800A tested. 16 | -------------------------------------------------------------------------------- 17 | * [ ] F0 tested. 18 | * [ ] L0 tested. 19 | * [x] F1 tested. 20 | * [ ] L1 tested. 21 | * [ ] F2 tested. 22 | * [ ] F3 tested. 23 | * [x] F4 tested. 24 | * [ ] L4 tested. 25 | * [ ] F7 tested. 26 | * [ ] H7 tested. 27 | -------------------------------------------------------------------------------- 28 | * Enable USART (LL Library) and RX interrupt. 29 | * Set a Gpio as output open drain to connect gsm power pin. 30 | * Put `gsm_at_rxCallback()` into USART callback. 31 | * Enable FREERTOS and increase heap size at least to 8192 bytes. 32 | * Select `General peripheral Initalizion as a pair of '.c/.h' file per peripheral` on project settings. 33 | * Config `gsmConfig.h`. 34 | * Call `gsm_init(osPriotary_low)` in your task. 35 | 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /bluetooth.c: -------------------------------------------------------------------------------- 1 | #include "gsm.h" 2 | 3 | #if (_GSM_BLUETOOTH_ENABLE == 1) 4 | 5 | 6 | 7 | #endif 8 | 9 | -------------------------------------------------------------------------------- /call.c: -------------------------------------------------------------------------------- 1 | 2 | #include "gsm.h" 3 | 4 | #if (_GSM_CALL_ENABLE == 1) 5 | //############################################################################################# 6 | bool gsm_call_answer(void) 7 | { 8 | if (gsm_at_sendCommand("ATA\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 9 | return false; 10 | gsm.call.busy = 1; 11 | return true; 12 | } 13 | //############################################################################################# 14 | bool gsm_call_dial(const char* number, uint8_t waitSecond) 15 | { 16 | char str[32]; 17 | sprintf(str,"ATD%s;\r\n", number); 18 | uint8_t ans = gsm_at_sendCommand(str, waitSecond * 1000 , NULL, 0, 5, "\r\nNO DIALTONE\r\n", "\r\nBUSY\r\n", "\r\nNO CARRIER\r\n", "\r\nNO ANSWER\r\n", "\r\nOK\r\n"); 19 | if (ans == 5) 20 | { 21 | gsm.call.busy = 1; 22 | return true; 23 | } 24 | else 25 | { 26 | gsm_call_end(); 27 | return false; 28 | } 29 | } 30 | //############################################################################################# 31 | bool gsm_call_end(void) 32 | { 33 | if (gsm_at_sendCommand("ATH\r\n", 20000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 34 | return false; 35 | gsm.call.busy = 0; 36 | return true; 37 | } 38 | //############################################################################################# 39 | #endif 40 | -------------------------------------------------------------------------------- /gprs.c: -------------------------------------------------------------------------------- 1 | #include "gsm.h" 2 | 3 | #if (_GSM_GPRS_ENABLE == 1) 4 | //############################################################################################# 5 | bool gsm_gprs_setApName(char *apName) 6 | { 7 | char str[128]; 8 | if (apName == NULL) 9 | return false; 10 | if (gsm_at_sendCommand("AT+SAPBR=3,1,\"Contype\",\"GPRS\"\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 11 | return false; 12 | sprintf(str, "AT+SAPBR=3,1,\"APN\",\"%s\"\r\n", apName); 13 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 14 | return true; 15 | return false; 16 | } 17 | //############################################################################################# 18 | bool gsm_gprs_connect(void) 19 | { 20 | char str[32]; 21 | gsm_at_sendCommand("AT+SAPBR=0,1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 22 | if (gsm_at_sendCommand("AT+SAPBR=1,1\r\n", 85000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 23 | return false; 24 | if (gsm_at_sendCommand("AT+SAPBR=2,1\r\n", 1000 , str, sizeof(str), 2, "\r\n+SAPBR: 1,1,", "\r\nERROR\r\n") != 1) 25 | { 26 | gsm.gprs.connected = false; 27 | return false; 28 | } 29 | sscanf(str, "\r\n+SAPBR: 1,1,\"%[^\"\r\n]", gsm.gprs.ip); 30 | gsm.gprs.connected = true; 31 | gsm.gprs.connectedLast = true; 32 | return true; 33 | } 34 | //############################################################################################# 35 | bool gsm_gprs_disconnect(void) 36 | { 37 | if (gsm_at_sendCommand("AT+SAPBR=0,1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 38 | { 39 | gsm.gprs.connected = false; 40 | gsm.gprs.connectedLast = false; 41 | return true; 42 | } 43 | return false; 44 | } 45 | //############################################################################################# 46 | bool gsm_gprs_httpInit(void) 47 | { 48 | if (gsm.gprs.connected == false) 49 | return false; 50 | if (gsm_at_sendCommand("AT+HTTPINIT\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 51 | return false; 52 | return true; 53 | } 54 | //############################################################################################# 55 | bool gsm_gprs_httpSetContent(const char *content) 56 | { 57 | if (gsm.gprs.connected == false) 58 | return false; 59 | char str[strlen(content) + 32]; 60 | sprintf(str, "AT+HTTPPARA=\"CONTENT\",\"%s\"\r\n", content); 61 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 62 | return false; 63 | return true; 64 | } 65 | //############################################################################################# 66 | bool gsm_gprs_httpSetUserData(const char *data) 67 | { 68 | if (gsm.gprs.connected == false) 69 | return false; 70 | while (gsm.taskBusy == 1) 71 | osDelay(1); 72 | osThreadSuspend(gsmTaskHandle); 73 | osDelay(100); 74 | gsm_at_sendString("AT+HTTPPARA=\"USERDATA\",\""); 75 | gsm_at_sendString(data); 76 | if (gsm_at_sendCommand("\"\r\n", 1000, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 77 | { 78 | osThreadResume(gsmTaskHandle); 79 | return false; 80 | } 81 | osThreadResume(gsmTaskHandle); 82 | return true; 83 | } 84 | //############################################################################################# 85 | bool gsm_gprs_httpSendData(const char *data, uint16_t timeoutMs) 86 | { 87 | if (gsm.gprs.connected == false) 88 | return false; 89 | char str[32]; 90 | sprintf(str, "AT+HTTPDATA=%d,%d\r\n", strlen(data), timeoutMs); 91 | while (gsm.taskBusy == 1) 92 | osDelay(1); 93 | osThreadSuspend(gsmTaskHandle); 94 | osDelay(100); 95 | do 96 | { 97 | if (gsm_at_sendCommand(str, timeoutMs, NULL, 0, 2, "\r\nDOWNLOAD\r\n", "\r\nERROR\r\n") != 1) 98 | break; 99 | if (gsm_at_sendCommand(data, timeoutMs, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 100 | break; 101 | osDelay(timeoutMs); 102 | osThreadResume(gsmTaskHandle); 103 | return true; 104 | } 105 | while(0); 106 | osThreadResume(gsmTaskHandle); 107 | return false; 108 | } 109 | //############################################################################################# 110 | int16_t gsm_gprs_httpGet(const char *url, bool ssl, uint16_t timeoutMs) 111 | { 112 | if (gsm.gprs.connected == false) 113 | return -1; 114 | gsm.gprs.code = -1; 115 | gsm.gprs.dataLen = 0; 116 | if (gsm_at_sendCommand("AT+HTTPPARA=\"CID\",1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 117 | return gsm.gprs.code; 118 | char str[strlen(url) + 32]; 119 | sprintf(str, "AT+HTTPPARA=\"URL\",\"%s\"\r\n", url); 120 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 121 | return gsm.gprs.code; 122 | if (gsm_at_sendCommand("AT+HTTPPARA=\"REDIR\",1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 123 | return gsm.gprs.code; 124 | if (ssl) 125 | { 126 | if (gsm_at_sendCommand("AT+HTTPSSL=1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 127 | return gsm.gprs.code; 128 | } 129 | else 130 | { 131 | if (gsm_at_sendCommand("AT+HTTPSSL=0\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 132 | return gsm.gprs.code; 133 | } 134 | if (gsm_at_sendCommand("AT+HTTPACTION=0\r\n", timeoutMs , str, sizeof(str), 2, "\r\n+HTTPACTION:", "\r\nERROR\r\n") != 1) 135 | return gsm.gprs.code; 136 | sscanf(str, "\r\n+HTTPACTION: 0,%hd,%d\r\n", &gsm.gprs.code, &gsm.gprs.dataLen); 137 | return gsm.gprs.code; 138 | 139 | } 140 | //############################################################################################# 141 | int16_t gsm_gprs_httpPost(const char *url, bool ssl, uint16_t timeoutMs) 142 | { 143 | if (gsm.gprs.connected == false) 144 | return -1; 145 | gsm.gprs.code = -1; 146 | gsm.gprs.dataLen = 0; 147 | if (gsm_at_sendCommand("AT+HTTPPARA=\"CID\",1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 148 | return gsm.gprs.code; 149 | char str[strlen(url) + 32]; 150 | sprintf(str, "AT+HTTPPARA=\"URL\",\"%s\"\r\n", url); 151 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 152 | return gsm.gprs.code; 153 | if (gsm_at_sendCommand("AT+HTTPPARA=\"REDIR\",1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 154 | return gsm.gprs.code; 155 | if (ssl) 156 | { 157 | if (gsm_at_sendCommand("AT+HTTPSSL=1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 158 | return gsm.gprs.code; 159 | } 160 | else 161 | { 162 | if (gsm_at_sendCommand("AT+HTTPSSL=0\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 163 | return gsm.gprs.code; 164 | } 165 | if (gsm_at_sendCommand("AT+HTTPACTION=1\r\n", timeoutMs , str, sizeof(str), 2, "\r\n+HTTPACTION:", "\r\nERROR\r\n") != 1) 166 | return gsm.gprs.code; 167 | sscanf(str, "\r\n+HTTPACTION: 1,%hd,%d\r\n", &gsm.gprs.code, &gsm.gprs.dataLen); 168 | return gsm.gprs.code; 169 | } 170 | //############################################################################################# 171 | uint32_t gsm_gprs_httpDataLen(void) 172 | { 173 | return gsm.gprs.dataLen; 174 | } 175 | //############################################################################################# 176 | uint16_t gsm_gprs_httpRead(uint16_t len) 177 | { 178 | if (gsm.gprs.connected == false) 179 | return 0; 180 | memset(gsm.gprs.buff, 0, sizeof(gsm.gprs.buff)); 181 | char str[32]; 182 | if (len >= _GSM_RXSIZE - 16) 183 | len = _GSM_RXSIZE - 16; 184 | sprintf(str, "AT+HTTPREAD=%d,%d\r\n", gsm.gprs.dataCurrent, len); 185 | if (gsm_at_sendCommand(str, 1000 , (char*)gsm.gprs.buff, _GSM_RXSIZE, 2, "\r\n+HTTPREAD: ", "\r\nERROR\r\n") != 1) 186 | return 0; 187 | gsm.gprs.dataCurrent += len; 188 | if (gsm.gprs.dataCurrent >= gsm.gprs.dataLen) 189 | gsm.gprs.dataCurrent = gsm.gprs.dataLen; 190 | uint16_t readLen; 191 | char *s = strchr((char*)gsm.gprs.buff, ':'); 192 | s++; 193 | readLen = atoi(s); 194 | s = strchr(s, '\n'); 195 | if (s != NULL) 196 | { 197 | s++; 198 | for (uint16_t i = 0; i < readLen; i++) 199 | gsm.gprs.buff[i] = *s++; 200 | return readLen; 201 | } 202 | return 0; 203 | } 204 | //############################################################################################# 205 | bool gsm_gprs_httpTerminate(void) 206 | { 207 | if (gsm.gprs.connected == false) 208 | return false; 209 | if (gsm_at_sendCommand("AT+HTTPTERM\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 210 | return true; 211 | return false; 212 | } 213 | //############################################################################################# 214 | bool gsm_gprs_ftpLogin(char *ftpAddress, char *ftpUserName, char *ftpPassword, uint16_t port) 215 | { 216 | if (gsm.gprs.connected == false) 217 | return false; 218 | char str[128]; 219 | if (gsm_at_sendCommand("AT+FTPMODE=1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 220 | return false; 221 | if (gsm_at_sendCommand("AT+FTPCID=1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 222 | return false; 223 | sprintf(str, "AT+FTPSERV=\"%s\"\r\n", ftpAddress); 224 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 225 | return false; 226 | sprintf(str, "AT+FTPPORT=%d\r\n", port); 227 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 228 | return false; 229 | sprintf(str, "AT+FTPUN=\"%s\"\r\n", ftpUserName); 230 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 231 | return false; 232 | sprintf(str, "AT+FTPPW=\"%s\"\r\n", ftpPassword); 233 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 234 | return false; 235 | return true; 236 | } 237 | //############################################################################################# 238 | Gsm_Ftp_Error_t gsm_gprs_ftpUploadBegin(bool asciiFile, bool append, const char *path, const char *fileName, const uint8_t *data, uint16_t len) 239 | { 240 | if (gsm.gprs.connected == false) 241 | return Gsm_Ftp_Error_Error; 242 | char *s; 243 | char str[128]; 244 | char answer[64]; 245 | gsm_at_sendCommand("AT+FTPEXTPUT=0\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 246 | if (asciiFile) 247 | sprintf(str, "AT+FTPTYPE=\"A\"\r\n"); 248 | else 249 | sprintf(str, "AT+FTPTYPE=\"I\"\r\n"); 250 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 251 | return Gsm_Ftp_Error_Error; 252 | if (append) 253 | sprintf(str, "AT+FTPPUTOPT=\"APPE\"\r\n"); 254 | else 255 | sprintf(str, "AT+FTPPUTOPT=\"STOR\"\r\n"); 256 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 257 | return Gsm_Ftp_Error_Error; 258 | sprintf(str, "AT+FTPPUTPATH=\"%s\"\r\n", path); 259 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 260 | return Gsm_Ftp_Error_Error; 261 | sprintf(str, "AT+FTPPUTNAME=\"%s\"\r\n", fileName); 262 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 263 | return Gsm_Ftp_Error_Error; 264 | if (gsm_at_sendCommand("AT+FTPPUT=1\r\n", 75000 , answer, sizeof(answer), 2, "\r\n+FTPPUT: 1,", "\r\nERROR\r\n") != 1) 265 | return Gsm_Ftp_Error_Error; 266 | s = strchr(answer, ','); 267 | if (s == NULL) 268 | return Gsm_Ftp_Error_Error; 269 | s++; 270 | if (atoi(s) != 1) 271 | return (Gsm_Ftp_Error_t)atoi(s); 272 | sprintf(str, "AT+FTPPUT=2,%d\r\n", len); 273 | if (gsm_at_sendCommand(str, 5000 , answer, sizeof(answer), 2, "\r\n+FTPPUT: 2,", "\r\nERROR\r\n") != 1) 274 | return Gsm_Ftp_Error_Error; 275 | s = strchr(answer, ','); 276 | if (s == NULL) 277 | return Gsm_Ftp_Error_Error; 278 | s++; 279 | if (atoi(s) != len) 280 | return Gsm_Ftp_Error_Error; 281 | while (gsm.taskBusy == 1) 282 | osDelay(1); 283 | osThreadSuspend(gsmTaskHandle); 284 | osDelay(100); 285 | gsm_at_sendData(data, len); 286 | gsm_at_sendCommand("", 120 * 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 287 | osThreadResume(gsmTaskHandle); 288 | return Gsm_Ftp_Error_None; 289 | } 290 | //############################################################################################# 291 | Gsm_Ftp_Error_t gsm_gprs_ftpUpload(const uint8_t *data, uint16_t len) 292 | { 293 | if (gsm.gprs.connected == false) 294 | return Gsm_Ftp_Error_Error; 295 | char *s; 296 | char str[128]; 297 | char answer[64]; 298 | sprintf(str, "AT+FTPPUT=2,%d\r\n", len); 299 | if (gsm_at_sendCommand(str, 5000 , answer, sizeof(answer), 2, "\r\n+FTPPUT: 2,", "\r\nERROR\r\n") != 1) 300 | return Gsm_Ftp_Error_Error; 301 | s = strchr(answer, ','); 302 | if (s == NULL) 303 | return Gsm_Ftp_Error_Error; 304 | s++; 305 | if (atoi(s) != len) 306 | return Gsm_Ftp_Error_Error; 307 | while (gsm.taskBusy == 1) 308 | osDelay(1); 309 | osThreadSuspend(gsmTaskHandle); 310 | osDelay(100); 311 | gsm_at_sendData(data, len); 312 | gsm_at_sendCommand("", 120 * 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 313 | osThreadResume(gsmTaskHandle); 314 | return Gsm_Ftp_Error_None; 315 | } 316 | //############################################################################################# 317 | bool gsm_gprs_ftpUploadEnd(void) 318 | { 319 | if (gsm.gprs.connected == false) 320 | return false; 321 | if (gsm_at_sendCommand("AT+FTPPUT=2,0\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 322 | return false; 323 | return true; 324 | } 325 | //############################################################################################# 326 | bool gsm_gprs_ftpExtUploadBegin(bool asciiFile, bool append, const char *path, const char *fileName) 327 | { 328 | if (gsm.gprs.connected == false) 329 | return false; 330 | char str[128]; 331 | gsm_at_sendCommand("AT+FTPEXTPUT=0\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 332 | if (asciiFile) 333 | sprintf(str, "AT+FTPTYPE=\"A\"\r\n"); 334 | else 335 | sprintf(str, "AT+FTPTYPE=\"I\"\r\n"); 336 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 337 | return false; 338 | if (append) 339 | sprintf(str, "AT+FTPPUTOPT=\"APPE\"\r\n"); 340 | else 341 | sprintf(str, "AT+FTPPUTOPT=\"STOR\"\r\n"); 342 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 343 | return false; 344 | sprintf(str, "AT+FTPPUTPATH=\"%s\"\r\n", path); 345 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 346 | return false; 347 | sprintf(str, "AT+FTPPUTNAME=\"%s\"\r\n", fileName); 348 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 349 | return false; 350 | if (gsm_at_sendCommand("AT+FTPEXTPUT=1\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 351 | return false; 352 | gsm.gprs.ftpExtOffset = 0; 353 | return true; 354 | } 355 | //############################################################################################# 356 | bool gsm_gprs_ftpExtUpload(uint8_t *data, uint16_t len) 357 | { 358 | if (gsm.gprs.connected == false) 359 | return false; 360 | char str[64]; 361 | char answer[64]; 362 | while (gsm.taskBusy == 1) 363 | osDelay(1); 364 | osThreadSuspend(gsmTaskHandle); 365 | do 366 | { 367 | sprintf(str, "AT+FTPEXTPUT=2,%d,%d,5000\r\n", gsm.gprs.ftpExtOffset, len); 368 | if (gsm_at_sendCommand(str, 5000, answer, sizeof(answer), 2, "\r\n+FTPEXTPUT: ", "\r\nERROR\r\n") != 1) 369 | break; 370 | char *s = strchr(answer, ','); 371 | if (s == NULL) 372 | break; 373 | s++; 374 | uint32_t d = atoi(s); 375 | if (d != len) 376 | break; 377 | osDelay(100); 378 | gsm_at_sendData(data, len); 379 | if (gsm_at_sendCommand("", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 380 | break; 381 | gsm.gprs.ftpExtOffset += len; 382 | osThreadResume(gsmTaskHandle); 383 | return true; 384 | } 385 | while(0); 386 | osThreadResume(gsmTaskHandle); 387 | return false; 388 | } 389 | //############################################################################################# 390 | Gsm_Ftp_Error_t gsm_gprs_ftpExtUploadEnd(void) 391 | { 392 | if (gsm.gprs.connected == false) 393 | return Gsm_Ftp_Error_Error; 394 | char answer[64]; 395 | if (gsm_at_sendCommand("AT+FTPPUT=1\r\n", 75000, answer, sizeof(answer), 2, "\r\n+FTPPUT: 1,", "\r\nERROR\r\n") != 1) 396 | return Gsm_Ftp_Error_Error; 397 | char *s = strchr(answer, ','); 398 | if (s == NULL) 399 | return Gsm_Ftp_Error_Error; 400 | s++; 401 | Gsm_Ftp_Error_t e = (Gsm_Ftp_Error_t)atoi(s); 402 | gsm_at_sendCommand("AT+FTPEXTPUT=0\r\n", 1000, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 403 | return e; 404 | } 405 | //############################################################################################# 406 | Gsm_Ftp_Error_t gsm_gprs_ftpCreateDir(const char *path) 407 | { 408 | if (gsm.gprs.connected == false) 409 | return Gsm_Ftp_Error_Error; 410 | char str[128]; 411 | sprintf(str, "AT+FTPGETPATH=\"%s\"\r\n", path); 412 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 413 | return Gsm_Ftp_Error_Error; 414 | if (gsm_at_sendCommand("AT+FTPMKD\r\n", 75000 , str, sizeof(str), 2, "\r\n+FTPMKD: 1,", "\r\nERROR\r\n") != 1) 415 | return Gsm_Ftp_Error_Error; 416 | char *s = strchr(str, ','); 417 | if (s == NULL) 418 | return Gsm_Ftp_Error_Error; 419 | s++; 420 | return (Gsm_Ftp_Error_t)atoi(s); 421 | } 422 | //############################################################################################# 423 | Gsm_Ftp_Error_t gsm_gprs_ftpRemoveDir(const char *path) 424 | { 425 | if (gsm.gprs.connected == false) 426 | return Gsm_Ftp_Error_Error; 427 | char str[128]; 428 | sprintf(str, "AT+FTPGETPATH=\"%s\"\r\n", path); 429 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 430 | return Gsm_Ftp_Error_Error; 431 | if (gsm_at_sendCommand("AT+FTPRMD\r\n", 75000 , str, sizeof(str), 2, "\r\n+FTPRMD: 1,", "\r\nERROR\r\n") != 1) 432 | return Gsm_Ftp_Error_Error; 433 | char *s = strchr(str, ','); 434 | if (s == NULL) 435 | return Gsm_Ftp_Error_Error; 436 | s++; 437 | return (Gsm_Ftp_Error_t)atoi(s); 438 | } 439 | //############################################################################################# 440 | uint32_t gsm_gprs_ftpGetSize(const char *path, const char *name) 441 | { 442 | if (gsm.gprs.connected == false) 443 | return 0; 444 | char str[128]; 445 | sprintf(str, "AT+FTPGETPATH=\"%s\"\r\n", path); 446 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 447 | return 0; 448 | sprintf(str, "AT+FTPGETNAME=\"%s\"\r\n", name); 449 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 450 | return 0; 451 | if (gsm_at_sendCommand("AT+FTPSIZE\r\n", 75000 , str, sizeof(str), 2, "\r\n+FTPSIZE: 1,", "\r\nERROR\r\n") != 1) 452 | return 0; 453 | char *s = strchr(str, ','); 454 | if (s == NULL) 455 | return 0; 456 | s++; 457 | if (atoi(s) == 0) 458 | { 459 | s = strchr(str, ','); 460 | if (s == NULL) 461 | return 0; 462 | s++; 463 | return atoi(s); 464 | } 465 | return 0; 466 | } 467 | //############################################################################################# 468 | Gsm_Ftp_Error_t gsm_gprs_ftpRemove(const char *path, const char *name) 469 | { 470 | if (gsm.gprs.connected == false) 471 | return Gsm_Ftp_Error_Error; 472 | char str[128]; 473 | sprintf(str, "AT+FTPGETPATH=\"%s\"\r\n", path); 474 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 475 | return Gsm_Ftp_Error_Error; 476 | sprintf(str, "AT+FTPGETNAME=\"%s\"\r\n", name); 477 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 478 | return Gsm_Ftp_Error_Error; 479 | if (gsm_at_sendCommand("AT+FTPDELE\r\n", 75000 , str, sizeof(str), 2, "\r\n+FTPDELE: 1,", "\r\nERROR\r\n") != 1) 480 | return Gsm_Ftp_Error_Error; 481 | char *s = strchr(str, ','); 482 | if (s == NULL) 483 | return Gsm_Ftp_Error_Error; 484 | s++; 485 | return (Gsm_Ftp_Error_t)atoi(s); 486 | } 487 | //############################################################################################# 488 | Gsm_Ftp_Error_t gsm_gprs_ftpIsExistFolder(const char *path) 489 | { 490 | if (gsm.gprs.connected == false) 491 | return Gsm_Ftp_Error_Error; 492 | char str[strlen(path) + 16]; 493 | char answer[32]; 494 | sprintf(str, "AT+FTPGETPATH=\"%s\"\r\n", path); 495 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 496 | return Gsm_Ftp_Error_Error; 497 | if (gsm_at_sendCommand("AT+FTPLIST=1\r\n", 75000 , answer, sizeof(answer), 2, "\r\n+FTPLIST: ", "\r\nERROR\r\n") != 1) 498 | return Gsm_Ftp_Error_Error; 499 | uint8_t i1 = 0,i2 = 0; 500 | if (sscanf(answer,"\r\n+FTPLIST: %hhd,%hhd", &i1, &i2) != 2) 501 | return Gsm_Ftp_Error_Error; 502 | if (i1 == 1 && i2 == 1) 503 | { 504 | gsm_at_sendCommand("AT+FTPQUIT\r\n", 75000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 505 | return Gsm_Ftp_Error_None; 506 | } 507 | if (i1 == 1 && i2 == 77) 508 | return Gsm_Ftp_Error_NotExist; 509 | return Gsm_Ftp_Error_Error; 510 | } 511 | //############################################################################################# 512 | bool gsm_gprs_ftpIsBusy(void) 513 | { 514 | if (gsm.gprs.connected == false) 515 | return false; 516 | if (gsm_at_sendCommand("AT+FTPSTATE\r\n", 75000 , NULL, 0, 3, "\r\n+FTPSTATE: 0\r\n", "\r\n+FTPSTATE: 1\r\n", "\r\nERROR\r\n") == 1) 517 | return true; 518 | return false; 519 | } 520 | //############################################################################################# 521 | bool gsm_gprs_ftpQuit(void) 522 | { 523 | if (gsm.gprs.connected == false) 524 | return false; 525 | if (gsm_at_sendCommand("AT+FTPQUIT\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 526 | return false; 527 | return true; 528 | } 529 | //############################################################################################# 530 | bool gsm_gprs_tcpConnect(const char *address, uint16_t port, bool ssl) 531 | { 532 | if (gsm.gprs.connected == false) 533 | return false; 534 | if(gsm_at_sendCommand("AT+CIPMUX?\r\n", 1000, NULL, 0, 1, "\r\n+CIPMUX: 0\r\n") != 1) 535 | if (gsm_at_sendCommand("AT+CIPMUX=0\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 536 | return false; 537 | if (ssl) 538 | { 539 | if (gsm_at_sendCommand("AT+SSLOPT=1,1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 540 | return false; 541 | if (gsm_at_sendCommand("AT+CIPSSL=1\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 542 | return false; 543 | } 544 | else 545 | { 546 | if (gsm_at_sendCommand("AT+CIPSSL=0\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 547 | return false; 548 | } 549 | char str[128]; 550 | sprintf(str, "AT+CIPSTART=\"TCP\",\"%s\",\"%d\"\r\n", address, port); 551 | uint8_t answer = gsm_at_sendCommand(str, 160000 , NULL, 0, 4, "\r\nCONNECT OK\r\n", "\r\nALREADY CONNECT\r\n", "\r\nCONNECT FAIL\r\n", "\r\nERROR\r\n"); 552 | if ((answer == 1) || (answer == 2)) 553 | { 554 | gsm.gprs.tcpConnection = 1; 555 | return true; 556 | } 557 | return false; 558 | } 559 | //############################################################################################# 560 | bool gsm_gprs_tcpSend(const uint8_t *data, uint16_t len) 561 | { 562 | if (gsm.gprs.connected == false) 563 | return false; 564 | if (gsm.gprs.tcpConnection == 0) 565 | return false; 566 | char str[32]; 567 | bool err = false; 568 | while (gsm.taskBusy == 1) 569 | osDelay(1); 570 | osThreadSuspend(gsmTaskHandle); 571 | osDelay(100); 572 | do 573 | { 574 | sprintf(str, "AT+CIPSEND=%d\r\n", len); 575 | if (gsm_at_sendCommand(str, 10000 , NULL, 0, 2, "\r\n>", "\r\nERROR\r\n") != 1) 576 | break; 577 | osDelay(500); 578 | gsm_at_sendData(data, len); 579 | if (gsm_at_sendCommand("", 10000 , NULL, 0, 2, "\r\nSEND OK\r\n", "\r\nERROR\r\n") != 1) 580 | break; 581 | err = true; 582 | }while(0); 583 | osThreadResume(gsmTaskHandle); 584 | return err; 585 | } 586 | //############################################################################################# 587 | bool gsm_gprs_tcpClose(void) 588 | { 589 | if (gsm.gprs.connected == false) 590 | return false; 591 | if (gsm_at_sendCommand("AT+CIPCLOSE\r\n", 10000 , NULL, 0, 2, "\r\nCLOSE OK\r\n", "\r\nERROR\r\n") != 1) 592 | return false; 593 | gsm.gprs.tcpConnection = 0; 594 | return true; 595 | } 596 | //############################################################################################# 597 | bool gsm_gprs_ntpServer(char *server) 598 | { 599 | if (gsm.gprs.connected == false) 600 | return false; 601 | char str[64]; 602 | sprintf(str, "AT+CNTP=\"%s\",0\r\n", server); 603 | if (gsm_at_sendCommand(str, 10000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 604 | return false; 605 | return true; 606 | } 607 | //############################################################################################# 608 | bool gsm_gprs_ntpGetTime(char *timeString) 609 | { 610 | if (gsm.gprs.connected == false) 611 | return false; 612 | if (timeString == NULL) 613 | return false; 614 | char str[32]; 615 | if (gsm_at_sendCommand("AT+CNTP\r\n", 10000 , NULL, 0, 2, "\r\n+CNTP: 1\r\n", "\r\nERROR\r\n") != 1) 616 | return false; 617 | if (gsm_at_sendCommand("AT+CCLK?\r\n", 10000 , str, sizeof(str), 2, "\r\n+CCLK:", "\r\nERROR\r\n") != 1) 618 | return false; 619 | sscanf(str, "\r\n+CCLK: \"%[^\"\r\n]", timeString); 620 | return true; 621 | } 622 | //############################################################################################# 623 | 624 | #endif 625 | -------------------------------------------------------------------------------- /gsm.c: -------------------------------------------------------------------------------- 1 | 2 | #include "gsm.h" 3 | //############################################################################################# 4 | osThreadId gsmTaskHandle; 5 | osThreadId gsmBufferTaskHandle; 6 | osMutexId gsmMutexID; 7 | #if (_GSM_DTMF_DETECT_ENABLE == 1) 8 | osMessageQId gsmDtmfQueueHandle; 9 | #endif 10 | Gsm_t gsm; 11 | 12 | const char *_GSM_ALWAYS_SEARCH[] = 13 | { 14 | "\r\n+CLIP:", // 0 15 | "POWER DOWN\r\n", // 1 16 | "\r\n+CMTI:", // 2 17 | "\r\nNO CARRIER\r\n", // 3 18 | "\r\n+DTMF:", // 4 19 | "\r\n+CREG:", // 5 20 | "\r\nCLOSED\r\n", // 6 21 | "\r\n+CIPRXGET: 1\r\n", // 7 22 | 23 | }; 24 | //############################################################################################# 25 | void gsm_init_config(void); 26 | //############################################################################################# 27 | void gsm_at_rxCallback(void) 28 | { 29 | if (LL_USART_IsActiveFlag_RXNE(_GSM_USART)) 30 | { 31 | uint8_t tmp = LL_USART_ReceiveData8(_GSM_USART); 32 | if (gsm.at.index < _GSM_RXSIZE - 1) 33 | { 34 | gsm.at.buff[gsm.at.index] = tmp; 35 | gsm.at.index++; 36 | } 37 | gsm.at.rxTime = HAL_GetTick(); 38 | } 39 | } 40 | //############################################################################################# 41 | void gsm_at_checkRxBuffer(void) 42 | { 43 | if ((gsm.at.index > 0) && (HAL_GetTick() - gsm.at.rxTime >= _GSM_RXTIMEOUT)) 44 | { 45 | #if _GSM_DEBUG == 1 46 | printf("%s",(const char*)gsm.at.buff); 47 | #endif 48 | // +++ search answer atcommand 49 | for (uint8_t i = 0; i < _GSM_AT_MAX_ANSWER_ITEMS; i++) 50 | { 51 | if (gsm.at.answerSearch[i] != NULL) 52 | { 53 | char *found = strstr((char*)gsm.at.buff, gsm.at.answerSearch[i]); 54 | if (found != NULL) 55 | { 56 | gsm.at.answerFound = i; 57 | if (gsm.at.answerString != NULL) 58 | strncpy(gsm.at.answerString, found, gsm.at.answerSize); 59 | break; 60 | } 61 | } 62 | else 63 | break; 64 | } 65 | // --- search answer atcommand 66 | 67 | // +++ search always 68 | for (uint8_t i = 0; i < sizeof(_GSM_ALWAYS_SEARCH) / 4; i++) 69 | { 70 | char *str = strstr((char*)gsm.at.buff, _GSM_ALWAYS_SEARCH[i]); 71 | if(str != NULL) 72 | { 73 | switch (i) 74 | { 75 | case 0: // found "\r\n+CLIP:" 76 | #if (_GSM_CALL_ENABLE == 1) 77 | if (sscanf(str,"\r\n+CLIP: \"%[^\"]\"", gsm.call.number) == 1) 78 | gsm.call.ringing = 1; 79 | #endif 80 | break; 81 | case 1: // found "POWER DOWN\r\n" 82 | gsm.power = 0; 83 | gsm.started = 0; 84 | break; 85 | case 2: // found "\r\n+CMTI:" 86 | #if (_GSM_MSG_ENABLE == 1) 87 | str = strchr(str, ','); 88 | if (str != NULL) 89 | { 90 | str++; 91 | gsm.msg.newMsg = atoi(str); 92 | break; 93 | } 94 | #endif 95 | break; 96 | case 3: // found "\r\nNO CARRIER\r\n" 97 | #if (_GSM_CALL_ENABLE == 1) 98 | gsm.call.callbackEndCall = 1; 99 | #endif 100 | break; 101 | case 4: // found "\r\n+DTMF:" 102 | #if ((_GSM_DTMF_DETECT_ENABLE == 1) && (_GSM_CALL_ENABLE == 1)) 103 | if (sscanf(str, "\r\n+DTMF: %c\r\n", &gsm.call.dtmf) == 1) 104 | osMessagePut(gsmDtmfQueueHandle, gsm.call.dtmf, 10); 105 | #endif 106 | break; 107 | case 5: // found "\r\n+CREG:" 108 | if (strstr(str, "\r\n+CREG: 1\r\n") != NULL) 109 | gsm.registred = 1; 110 | else 111 | gsm.registred = 0; 112 | break; 113 | case 6: // found "\r\nCLOSED\r\n" 114 | #if (_GSM_GPRS_ENABLE == 1) 115 | gsm.gprs.tcpConnection = 0; 116 | #endif 117 | break; 118 | case 7: // found "\r\n+CIPRXGET: 1\r\n" 119 | #if (_GSM_GPRS_ENABLE == 1) 120 | gsm.gprs.gotData = 1; 121 | #endif 122 | break; 123 | } 124 | } 125 | // --- search always 126 | } 127 | memset(gsm.at.buff,0, _GSM_RXSIZE); 128 | gsm.at.index = 0; 129 | } 130 | } 131 | //############################################################################################# 132 | void gsm_at_sendString(const char *string) 133 | { 134 | for(uint16_t i = 0; i 0)) 170 | { 171 | gsm.at.answerSize = sizeOfAnswer; 172 | gsm.at.answerString = pvPortMalloc(sizeOfAnswer); 173 | memset(gsm.at.answerString, 0, sizeOfAnswer); 174 | } 175 | gsm.at.answerFound = -1; 176 | uint32_t startTime = HAL_GetTick(); 177 | gsm_at_sendString(command); 178 | while (HAL_GetTick() - startTime < waitMs) 179 | { 180 | if (gsm.at.answerFound != -1) 181 | break; 182 | osDelay(10); 183 | } 184 | for (uint8_t i = 0; i < items; i++) 185 | { 186 | vPortFree(gsm.at.answerSearch[i]); 187 | gsm.at.answerSearch[i] = NULL; 188 | } 189 | if ((answer != NULL) && (sizeOfAnswer > 0)) 190 | { 191 | if (gsm.at.answerFound >= 0) 192 | strncpy(answer, gsm.at.answerString, sizeOfAnswer); 193 | vPortFree(gsm.at.answerString); 194 | gsm.at.answerString = NULL; 195 | } 196 | osMutexRelease(gsmMutexID); 197 | return gsm.at.answerFound + 1; 198 | } 199 | //############################################################################################# 200 | //############################################################################################# 201 | //############################################################################################# 202 | bool gsm_power(bool on_off) 203 | { 204 | if (on_off) // power on 205 | { 206 | if (gsm_at_sendCommand("AT\r\n", 500, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 207 | { 208 | gsm.power = 1; 209 | gsm_init_config(); 210 | gsm.started = 1; 211 | return true; 212 | } 213 | HAL_GPIO_WritePin(_GSM_POWERKEY_GPIO, _GSM_POWERKEY_PIN, GPIO_PIN_RESET); 214 | osDelay(1200); 215 | HAL_GPIO_WritePin(_GSM_POWERKEY_GPIO, _GSM_POWERKEY_PIN, GPIO_PIN_SET); 216 | osDelay(2000); 217 | for (uint8_t i = 0; i < 10; i++) 218 | { 219 | if (gsm_at_sendCommand("AT\r\n", 500, NULL, 0, 1, "\r\nOK\r\n") == 1) 220 | { 221 | gsm.power = 1; 222 | osDelay(4000); 223 | gsm_init_config(); 224 | gsm.started = 1; 225 | return true; 226 | } 227 | } 228 | gsm.power = 0; 229 | gsm.started = 0; 230 | return false; 231 | } 232 | else // power off 233 | { 234 | if (gsm_at_sendCommand("AT\r\n", 500, NULL, 0, 1, "\r\nOK\r\n") == 0) 235 | { 236 | gsm.power = 0; 237 | gsm.started = 0; 238 | return true; 239 | } 240 | HAL_GPIO_WritePin(_GSM_POWERKEY_GPIO, _GSM_POWERKEY_PIN, GPIO_PIN_RESET); 241 | osDelay(1200); 242 | HAL_GPIO_WritePin(_GSM_POWERKEY_GPIO, _GSM_POWERKEY_PIN, GPIO_PIN_SET); 243 | osDelay(2000); 244 | if (gsm_at_sendCommand("AT\r\n", 500, NULL, 0, 1, "\r\nOK\r\n") == 0) 245 | { 246 | gsm.power = 0; 247 | gsm.started = 0; 248 | return true; 249 | } 250 | else 251 | { 252 | gsm.power = 1; 253 | return false; 254 | } 255 | } 256 | } 257 | //############################################################################################# 258 | bool gsm_setDefault(void) 259 | { 260 | if (gsm_at_sendCommand("AT&F0\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 261 | return true; 262 | return false; 263 | } 264 | //############################################################################################# 265 | bool gsm_saveProfile(void) 266 | { 267 | if (gsm_at_sendCommand("AT&W\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 268 | return true; 269 | return false; 270 | } 271 | //############################################################################################# 272 | bool gsm_enterPinPuk(const char* string) 273 | { 274 | char str[32]; 275 | if (string == NULL) 276 | return false; 277 | sprintf(str, "AT+CPIN=%s\r\n", string); 278 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 279 | return false; 280 | return true; 281 | } 282 | //############################################################################################# 283 | bool gsm_getIMEI(char* string, uint8_t sizeOfString) 284 | { 285 | if ((string == NULL) || (sizeOfString < 15)) 286 | return false; 287 | char str[32]; 288 | if (gsm_at_sendCommand("AT+GSN\r\n", 1000 , str, sizeof(str), 2, "AT+GSN", "\r\nERROR\r\n") != 1) 289 | return false; 290 | if (sscanf(str,"\r\nAT+GSN\r\n %[^\r\n]", string) != 1) 291 | return false; 292 | return true; 293 | } 294 | //############################################################################################# 295 | bool gsm_getVersion(char* string, uint8_t sizeOfString) 296 | { 297 | if (string == NULL) 298 | return false; 299 | char str1[16 + sizeOfString]; 300 | char str2[sizeOfString + 1]; 301 | if (gsm_at_sendCommand("AT+CGMR\r\n", 1000 , str1, sizeof(str1), 2, "AT+GMM", "\r\nERROR\r\n") != 1) 302 | return false; 303 | if (sscanf(str1,"\r\nAT+CGMR\r\n %[^\r\n]", str2) != 1) 304 | return false; 305 | strncpy(string, str2, sizeOfString); 306 | return true; 307 | } 308 | //############################################################################################# 309 | bool gsm_getModel(char* string, uint8_t sizeOfString) 310 | { 311 | if (string == NULL) 312 | return false; 313 | char str1[16 + sizeOfString]; 314 | char str2[sizeOfString + 1]; 315 | if (gsm_at_sendCommand("AT+GMM\r\n", 1000 , str1, sizeof(str1), 2, "AT+GMM", "\r\nERROR\r\n") != 1) 316 | return false; 317 | if (sscanf(str1,"\r\nAT+GMM\r\n %[^\r\n]", str2) != 1) 318 | return false; 319 | strncpy(string, str2, sizeOfString); 320 | return true; 321 | } 322 | //############################################################################################# 323 | bool gsm_getServiceProviderName(char* string, uint8_t sizeOfString) 324 | { 325 | if (string == NULL) 326 | return false; 327 | char str1[16 + sizeOfString]; 328 | char str2[sizeOfString + 1]; 329 | if (gsm_at_sendCommand("AT+CSPN?\r\n", 1000 , str1, sizeof(str1), 2, "\r\n+CSPN:", "\r\nERROR\r\n") != 1) 330 | return false; 331 | if (sscanf(str1,"\r\n+CSPN: \"%[^\"]\"", str2) != 1) 332 | return false; 333 | strncpy(string, str2, sizeOfString); 334 | return true; 335 | } 336 | //############################################################################################# 337 | uint8_t gsm_getSignalQuality_0_to_100(void) 338 | { 339 | char str[32]; 340 | uint8_t p1,p2; 341 | if (gsm_at_sendCommand("AT+CSQ\r\n", 1000, str, sizeof(str), 2, "\r\n+CSQ:", "\r\nERROR\r\n") != 1) 342 | return 0; 343 | if (sscanf(str, "\r\n+CSQ: %hhd,%hhd\r\n", &p1, &p2) != 2) 344 | return 0; 345 | if (p1 == 99) 346 | gsm.signal = 0; 347 | else 348 | gsm.signal = (p1 * 100) / 31; 349 | return gsm.signal; 350 | } 351 | //############################################################################################# 352 | bool gsm_ussd(char *command, char *answer, uint16_t sizeOfAnswer, uint8_t waitSecond) 353 | { 354 | if (command == NULL) 355 | { 356 | if (gsm_at_sendCommand("AT+CUSD=2\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 357 | return false; 358 | return true; 359 | } 360 | else if (answer == NULL) 361 | { 362 | char str[16 + strlen(command)]; 363 | sprintf(str, "AT+CUSD=0,\"%s\"\r\n", command); 364 | if (gsm_at_sendCommand(str, waitSecond * 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 365 | return false; 366 | return true; 367 | } 368 | else 369 | { 370 | char str[16 + strlen(command)]; 371 | char str2[sizeOfAnswer + 32]; 372 | sprintf(str, "AT+CUSD=1,\"%s\"\r\n", command); 373 | if (gsm_at_sendCommand(str, waitSecond * 1000 , str2, sizeof(str2), 2, "\r\n+CUSD:", "\r\nERROR\r\n") != 1) 374 | { 375 | gsm_at_sendCommand("AT+CUSD=2\r\n", 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 376 | return false; 377 | } 378 | char *start = strstr(str2, "\""); 379 | char *end = strstr(str2, "\", "); 380 | if (start != NULL && end != NULL) 381 | { 382 | start++; 383 | strncpy(answer, start, end - start); 384 | return true; 385 | } 386 | else 387 | return false; 388 | } 389 | } 390 | //############################################################################################# 391 | bool gsm_waitForStarted(uint8_t waitSecond) 392 | { 393 | uint32_t startTime = HAL_GetTick(); 394 | while (HAL_GetTick() - startTime < (waitSecond * 1000)) 395 | { 396 | osDelay(100); 397 | if (gsm.started == 1) 398 | return true; 399 | } 400 | return false; 401 | } 402 | //############################################################################################# 403 | bool gsm_waitForRegister(uint8_t waitSecond) 404 | { 405 | uint32_t startTime = HAL_GetTick(); 406 | uint8_t idx = 0; 407 | while (HAL_GetTick() - startTime < (waitSecond * 1000)) 408 | { 409 | osDelay(100); 410 | if (gsm.registred == 1) 411 | return true; 412 | idx++; 413 | if (idx % 10 == 0) 414 | { 415 | if (gsm_at_sendCommand("AT+CREG?\r\n", 1000, NULL, 0, 1, "\r\n+CREG: 1,1\r\n") == 1) 416 | gsm.registred = 1; 417 | } 418 | } 419 | return false; 420 | } 421 | //############################################################################################# 422 | bool gsm_tonePlay(Gsm_Tone_t Gsm_Tone_, uint32_t durationMiliSecond, uint8_t level_0_100) 423 | { 424 | char str[32]; 425 | sprintf(str, "AT+SNDLEVEL=0,%d\r\n", level_0_100); 426 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 427 | return false; 428 | sprintf(str, "AT+STTONE=1,%d,%d\r\n", Gsm_Tone_, durationMiliSecond); 429 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 430 | return false; 431 | return true; 432 | } 433 | //############################################################################################# 434 | bool gsm_toneStop(void) 435 | { 436 | if (gsm_at_sendCommand("AT+STTONE=0\r\n", 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 437 | return true; 438 | return false; 439 | } 440 | //############################################################################################# 441 | bool gsm_dtmf(char *string, uint32_t durationMiliSecond) 442 | { 443 | char str[32]; 444 | sprintf(str, "AT+VTS=\"%s\",%d\r\n", string, durationMiliSecond / 100); 445 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 446 | return false; 447 | return true; 448 | } 449 | //############################################################################################# 450 | void gsm_init_config(void) 451 | { 452 | char str1[64]; 453 | char str2[16]; 454 | gsm_setDefault(); 455 | gsm_at_sendCommand("ATE1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 456 | gsm_at_sendCommand("AT+COLP=1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 457 | gsm_at_sendCommand("AT+CLIP=1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 458 | gsm_at_sendCommand("AT+CREG=1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 459 | gsm_at_sendCommand("AT+FSHEX=0\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 460 | #if (_GSM_GPRS_ENABLE == 1) 461 | gsm_at_sendCommand("AT+CIPSHUT\r\n", 65000, NULL, 0, 2, "\r\nSHUT OK\r\n", "\r\nERROR\r\n"); 462 | gsm_at_sendCommand("AT+CIPHEAD=0\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 463 | gsm_at_sendCommand("AT+CIPRXGET=1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 464 | #endif 465 | gsm_getVersion(str1, sizeof(str1)); 466 | osDelay(2000); 467 | for (uint8_t i = 0; i < 5 ; i++) 468 | { 469 | if (gsm_at_sendCommand("AT+CPIN?\r\n", 1000, str1, sizeof(str1), 2, "\r\n+CPIN:", "\r\nERROR\r\n") == 1) 470 | { 471 | if (sscanf(str1, "\r\n+CPIN: %[^\r\n]", str2) == 1) 472 | { 473 | if (strcmp(str2, "READY") == 0) 474 | { 475 | gsm_callback_simcardReady(); 476 | break; 477 | } 478 | if (strcmp(str2, "SIM PIN") == 0) 479 | { 480 | gsm_callback_simcardPinRequest(); 481 | break; 482 | } 483 | if (strcmp(str2, "SIM PUK") == 0) 484 | { 485 | gsm_callback_simcardPukRequest(); 486 | break; 487 | } 488 | } 489 | } 490 | else 491 | { 492 | gsm_callback_simcardNotInserted(); 493 | } 494 | osDelay(2000); 495 | } 496 | #if (_GSM_MSG_ENABLE == 1) 497 | gsm_msg_textMode(true); 498 | gsm_msg_selectStorage(Gsm_Msg_Store_MODULE); 499 | gsm_msg_selectCharacterSet(Gsm_Msg_ChSet_IRA); 500 | #endif 501 | #if (_GSM_DTMF_DETECT_ENABLE == 1) 502 | gsm_at_sendCommand("AT+DDET=1\r\n", 1000, NULL, 0, 1, "\r\nOK\r\n"); 503 | #endif 504 | } 505 | //############################################################################################# 506 | //############################################################################################# 507 | //############################################################################################# 508 | void gsm_task(void const * argument) 509 | { 510 | static uint32_t gsm10sTimer = 0; 511 | static uint32_t gsm60sTimer = 0; 512 | static uint8_t gsmError = 0; 513 | char str[32]; 514 | while (HAL_GetTick() < 2000) 515 | osDelay(100); 516 | gsm_power(true); 517 | #if (_GSM_MSG_ENABLE == 1) 518 | if (gsm.msg.storageUsed > 0) 519 | { 520 | for (uint16_t i = 0; i < 150 ; i++) 521 | { 522 | if (gsm_msg_read(i)) 523 | { 524 | gsm_callback_newMsg(gsm.msg.number, gsm.msg.time, (char*)gsm.msg.buff); 525 | gsm_msg_delete(i); 526 | } 527 | } 528 | } 529 | #endif 530 | while (1) 531 | { 532 | if (gsm.power == 1) 533 | { 534 | #if (_GSM_DTMF_DETECT_ENABLE == 1) 535 | osEvent event = osMessageGet(gsmDtmfQueueHandle, 0); 536 | if (event.status == osEventMessage) 537 | { 538 | gsm.taskBusy = 1; 539 | gsm_callback_dtmf((char)event.value.v); 540 | gsm.taskBusy = 0; 541 | } 542 | #endif 543 | #if (_GSM_CALL_ENABLE == 1) 544 | if (gsm.call.callbackEndCall == 1) // \r\nNO CARRIER\r\n detect 545 | { 546 | gsm.taskBusy = 1; 547 | gsm.call.callbackEndCall = 0; 548 | gsm_callback_endCall(); 549 | gsm.call.busy = 0; 550 | gsm.taskBusy = 0; 551 | } 552 | #endif 553 | #if (_GSM_GPRS_ENABLE == 1) 554 | if (gsm.gprs.gotData == 1) 555 | { 556 | gsm.taskBusy = 1; 557 | gsm.gprs.gotData = 0; 558 | memset(gsm.gprs.buff, 0, sizeof(gsm.gprs.buff)); 559 | sprintf(str, "AT+CIPRXGET=2,%d\r\n", sizeof(gsm.gprs.buff) - 16); 560 | if (gsm_at_sendCommand(str, 1000, (char*)gsm.gprs.buff, sizeof(gsm.gprs.buff), 2, "\r\n+CIPRXGET: 2", "\r\nERROR\r\n") == 1) 561 | { 562 | uint16_t len = 0, read = 0; 563 | if (sscanf((char*)gsm.gprs.buff, "\r\n+CIPRXGET: 2,%hd,%hd\r\n", &len, &read) == 2) 564 | { 565 | 566 | gsm_callback_gprsGotData(gsm.gprs.buff, len); 567 | } 568 | } 569 | gsm.taskBusy = 0; 570 | } 571 | #endif 572 | if (HAL_GetTick() - gsm10sTimer >= 10000) // 10 seconds timer 573 | { 574 | gsm10sTimer = HAL_GetTick(); 575 | gsm.taskBusy = 1; 576 | if ((gsm_getSignalQuality_0_to_100() < 20) || (gsm.registred == 0)) // update signal value every 10 seconds 577 | { 578 | gsmError++; 579 | if (gsmError == 6) // restart after 60 seconds while low signal 580 | { 581 | gsm_power(false); 582 | osDelay(2000); 583 | gsm_power(true); 584 | gsmError = 0; 585 | } 586 | gsm.taskBusy = 0; 587 | } 588 | else 589 | gsmError = 0; 590 | #if (_GSM_GPRS_ENABLE == 1) 591 | gsm.taskBusy = 1; 592 | if (gsm_at_sendCommand("AT+SAPBR=2,1\r\n", 1000 , str, sizeof(str), 2, "\r\n+SAPBR: 1,", "\r\nERROR\r\n") == 1) 593 | { 594 | if (sscanf(str, "\r\n+SAPBR: 1,1,\"%[^\"\r\n]", gsm.gprs.ip) == 1) 595 | { 596 | if (gsm.gprs.connectedLast == false) 597 | { 598 | gsm.gprs.connected = true; 599 | gsm.gprs.connectedLast = true; 600 | gsm_callback_gprsConnected(); 601 | } 602 | } 603 | else 604 | { 605 | if (gsm.gprs.connectedLast == true) 606 | { 607 | gsm.gprs.connected = false; 608 | gsm.gprs.connectedLast = false; 609 | gsm_callback_gprsDisconnected(); 610 | } 611 | } 612 | } 613 | else 614 | { 615 | if (gsm.gprs.connectedLast == true) 616 | { 617 | gsm.gprs.connected = false; 618 | gsm.gprs.connectedLast = false; 619 | gsm_callback_gprsDisconnected(); 620 | } 621 | } 622 | gsm.taskBusy = 0; 623 | #endif 624 | } 625 | if (HAL_GetTick() - gsm60sTimer >= 60000) // 60 seconds timer 626 | { 627 | gsm60sTimer = HAL_GetTick(); 628 | #if (_GSM_MSG_ENABLE == 1) 629 | gsm.taskBusy = 1; 630 | if (gsm_msg_getStorageUsed() > 0) // check sms memory every 60 seconds 631 | { 632 | for (uint16_t i = 0; i < 150 ; i++) 633 | { 634 | if (gsm_msg_read(i)) 635 | { 636 | gsm_callback_newMsg(gsm.msg.number, gsm.msg.time, (char*)gsm.msg.buff); 637 | gsm_msg_delete(i); 638 | } 639 | } 640 | } 641 | gsm.taskBusy = 0; 642 | #endif 643 | } 644 | #if (_GSM_MSG_ENABLE == 1) 645 | gsm.taskBusy = 1; 646 | if (gsm.msg.newMsg != -1) 647 | { 648 | if (gsm_msg_read(gsm.msg.newMsg)) 649 | { 650 | gsm_callback_newMsg(gsm.msg.number, gsm.msg.time, (char*)gsm.msg.buff); 651 | gsm_msg_delete(gsm.msg.newMsg); 652 | } 653 | gsm.msg.newMsg = -1; 654 | } 655 | gsm.taskBusy = 0; 656 | #endif 657 | #if (_GSM_CALL_ENABLE == 1) 658 | gsm.taskBusy = 1; 659 | if (gsm.call.ringing == 1) 660 | { 661 | gsm_callback_newCall(gsm.call.number); 662 | gsm.call.ringing = 0; 663 | } 664 | gsm.taskBusy = 0; 665 | #endif 666 | } 667 | else 668 | { 669 | gsm.taskBusy = 1; 670 | gsm_power(true); // turn on again, after power down 671 | gsm.taskBusy = 0; 672 | } 673 | osDelay(10); 674 | } 675 | } 676 | //############################################################################################# 677 | void gsmBuffer_task(void const * argument) 678 | { 679 | LL_USART_EnableIT_RXNE(_GSM_USART); 680 | while (1) 681 | { 682 | gsm_at_checkRxBuffer(); 683 | osDelay(1); 684 | } 685 | } 686 | //############################################################################################# 687 | bool gsm_init(osPriority osPriority_) 688 | { 689 | if (gsm.inited == 1) 690 | return true; 691 | gsm.inited = 1; 692 | HAL_GPIO_WritePin(_GSM_POWERKEY_GPIO, _GSM_POWERKEY_PIN, GPIO_PIN_SET); 693 | do 694 | { 695 | osMutexDef(gsmMutex); 696 | gsmMutexID = osMutexCreate(osMutex (gsmMutex)); 697 | osThreadDef(gsmTask, gsm_task, osPriority_, 0, _GSM_TASKSIZE); 698 | gsmTaskHandle = osThreadCreate(osThread(gsmTask), NULL); 699 | osThreadDef(gsmBufferTask, gsmBuffer_task, osPriority_, 0, _GSM_BUFFTASKSIZE); 700 | gsmBufferTaskHandle = osThreadCreate(osThread(gsmBufferTask), NULL); 701 | if ((gsmTaskHandle == NULL) || (gsmBufferTaskHandle == NULL) || (gsmMutexID == NULL)) 702 | break; 703 | #if (_GSM_DTMF_DETECT_ENABLE == 1) 704 | osMessageQDef(GsmDtmfQueue, 8, uint8_t); 705 | gsmDtmfQueueHandle = osMessageCreate(osMessageQ(GsmDtmfQueue), NULL); 706 | if (gsmDtmfQueueHandle == NULL) 707 | break; 708 | #endif 709 | return true; 710 | } 711 | while(0); 712 | return false; 713 | } 714 | -------------------------------------------------------------------------------- /gsm.h: -------------------------------------------------------------------------------- 1 | #ifndef _GSM_H 2 | #define _GSM_H 3 | 4 | /* 5 | Author: Nima Askari 6 | WebSite: http://www.github.com/NimaLTD 7 | Instagram: http://instagram.com/github.NimaLTD 8 | Youtube: https://www.youtube.com/channel/UCUhY7qY1klJm1d2kulr9ckw 9 | 10 | Version: 4.1.4 11 | 12 | 13 | Reversion History: 14 | 15 | (4.1.4) 16 | Add gsm_gprs_ftpIsExistFolder(path) function 17 | 18 | (4.1.3) 19 | Fix FTPPUT, Add FTPEXTPUT 20 | 21 | (4.1.2) 22 | Add NTP. 23 | 24 | (4.1.1) 25 | Add FTP Upload,DeleteDir,CreateDIR. 26 | 27 | (4.1.0) 28 | Add GPRS. Change somethings. Improve performance. 29 | 30 | (4.0.4) 31 | Change AT+DDET place. 32 | 33 | (4.0.3) 34 | Change always search to flash memory, Add dtmf detect, fix somethings 35 | 36 | (4.0.2) 37 | Add ussd. 38 | 39 | (4.0.1) 40 | Solve power on problem. 41 | 42 | (4.0.0) 43 | New release. 44 | */ 45 | 46 | #include "FreeRTOS.h" 47 | #include "task.h" 48 | #include "cmsis_os.h" 49 | #include "usart.h" 50 | #include "gsmConfig.h" 51 | #include 52 | #include 53 | #include 54 | #include 55 | #include 56 | 57 | //################################################################### 58 | 59 | typedef struct 60 | { 61 | uint8_t year; 62 | uint8_t month; 63 | uint8_t day; 64 | uint8_t hour; 65 | uint8_t minute; 66 | uint8_t second; 67 | 68 | }Gsm_Time_t; 69 | 70 | typedef enum 71 | { 72 | Gsm_Tone_DialTone = 1, 73 | Gsm_Tone_CalledSubscriberBusy = 2, 74 | Gsm_Tone_Congestion = 3, 75 | Gsm_Tone_RadioPathAcknowledge = 4, 76 | Gsm_Tone_RadioPathNotAvailableOrCallDropped = 5, 77 | Gsm_Tone_ErrorOrSpecialinformation = 6, 78 | Gsm_Tone_CallWaitingTone = 7, 79 | Gsm_Tone_RingingTone = 8, 80 | Gsm_Tone_GeneralBeep = 16, 81 | Gsm_Tone_PositiveAcknowledgementTone = 17, 82 | Gsm_Tone_NegativeAcknowledgementOrErrorTone = 18, 83 | Gsm_Tone_IndianDialTone = 19, 84 | Gsm_Tone_AmericanDialTone = 20 85 | 86 | }Gsm_Tone_t; 87 | 88 | typedef enum 89 | { 90 | Gsm_Msg_ChSet_ERROR = 0, 91 | Gsm_Msg_ChSet_GSM, 92 | Gsm_Msg_ChSet_UCS2, 93 | Gsm_Msg_ChSet_IRA, 94 | Gsm_Msg_ChSet_HEX, 95 | Gsm_Msg_ChSet_PCCP, 96 | Gsm_Msg_ChSet_PCDN, 97 | Gsm_Msg_ChSet_8859_1 98 | 99 | }Gsm_Msg_ChSet_t; 100 | 101 | typedef enum 102 | { 103 | Gsm_Msg_Store_ERROR = 0, 104 | Gsm_Msg_Store_SIMCARD, 105 | Gsm_Msg_Store_MODULE, 106 | Gsm_Msg_Store_SIMCARD_PREFERRED, 107 | Gsm_Msg_Store_MODULE_PREFERRED, 108 | Gsm_Msg_Store_SIMCARD_OR_MODULE, 109 | 110 | }Gsm_Msg_Store_t; 111 | 112 | typedef enum 113 | { 114 | Gsm_Ftp_Error_None = 0, 115 | Gsm_Ftp_Error_Error = 1, 116 | Gsm_Ftp_Error_NetError = 61, 117 | Gsm_Ftp_Error_DNSError = 62, 118 | Gsm_Ftp_Error_ConnectError = 63, 119 | Gsm_Ftp_Error_Timeout = 64, 120 | Gsm_Ftp_Error_ServerError = 65, 121 | Gsm_Ftp_Error_OperationNotAllow = 66, 122 | Gsm_Ftp_Error_ReplayError = 70, 123 | Gsm_Ftp_Error_UserError = 71, 124 | Gsm_Ftp_Error_PasswordError = 72, 125 | Gsm_Ftp_Error_TypeError = 73, 126 | Gsm_Ftp_Error_RestError = 74, 127 | Gsm_Ftp_Error_PassiveError = 75, 128 | Gsm_Ftp_Error_ActiveError = 76, 129 | Gsm_Ftp_Error_OperateError = 77, 130 | Gsm_Ftp_Error_UploadError = 78, 131 | Gsm_Ftp_Error_DownloadError = 79, 132 | Gsm_Ftp_Error_ManualQuit = 86, 133 | Gsm_Ftp_Error_NotExist = 100, 134 | 135 | }Gsm_Ftp_Error_t; 136 | 137 | typedef struct 138 | { 139 | uint32_t rxTime; 140 | uint16_t index; 141 | uint8_t buff[_GSM_RXSIZE]; 142 | int8_t answerFound; 143 | char* answerSearch[_GSM_AT_MAX_ANSWER_ITEMS]; 144 | char* answerString; 145 | uint16_t answerSize; 146 | 147 | }Gsm_At_t; 148 | 149 | typedef struct 150 | { 151 | uint8_t textMode; 152 | uint8_t buff[_GSM_RXSIZE]; 153 | Gsm_Msg_ChSet_t characterSet; 154 | Gsm_Msg_Store_t storage; 155 | uint8_t storageTotal; 156 | uint8_t storageUsed; 157 | Gsm_Time_t time; 158 | int16_t newMsg; 159 | char status[16]; 160 | char number[16]; 161 | 162 | }Gsm_Msg_t; 163 | 164 | typedef struct 165 | { 166 | uint8_t ringing; 167 | uint8_t busy; 168 | uint8_t callbackEndCall; 169 | char number[16]; 170 | #if (_GSM_DTMF_DETECT_ENABLE == 1) 171 | uint8_t dtmf; 172 | #endif 173 | 174 | }Gsm_Call_t; 175 | 176 | typedef struct 177 | { 178 | bool connected; 179 | bool connectedLast; 180 | char ip[16]; 181 | uint32_t dataLen; 182 | uint32_t dataCurrent; 183 | int16_t code; 184 | uint8_t buff[_GSM_RXSIZE]; 185 | uint8_t tcpConnection; 186 | uint8_t gotData; 187 | uint32_t ftpExtOffset; 188 | 189 | }Gsm_Gprs_t; 190 | 191 | typedef struct 192 | { 193 | uint8_t inited; 194 | uint8_t power; 195 | uint8_t started; 196 | uint8_t registred; 197 | uint8_t signal; 198 | uint8_t taskBusy; 199 | Gsm_At_t at; 200 | #if (_GSM_MSG_ENABLE == 1) 201 | Gsm_Msg_t msg; 202 | #endif 203 | #if (_GSM_CALL_ENABLE == 1) 204 | Gsm_Call_t call; 205 | #endif 206 | #if (_GSM_GPRS_ENABLE == 1) 207 | Gsm_Gprs_t gprs; 208 | #endif 209 | 210 | }Gsm_t; 211 | 212 | //################################################################### 213 | extern osThreadId gsmTaskHandle; 214 | extern Gsm_t gsm; 215 | //################################################################### at commands 216 | void gsm_at_rxCallback(void); 217 | void gsm_at_sendString(const char *string); 218 | void gsm_at_sendData(const uint8_t *data, uint16_t len); 219 | uint8_t gsm_at_sendCommand(const char *command, uint32_t waitMs, char *answer, uint16_t sizeOfAnswer, uint8_t items, ...); 220 | //################################################################### general functions 221 | bool gsm_init(osPriority osPriority_); 222 | bool gsm_power(bool on_off); 223 | bool gsm_setDefault(void); 224 | bool gsm_saveProfile(void); 225 | bool gsm_waitForStarted(uint8_t waitSecond); 226 | bool gsm_waitForRegister(uint8_t waitSecond); 227 | bool gsm_enterPinPuk(const char* string); 228 | bool gsm_getIMEI(char* string, uint8_t sizeOfString); 229 | bool gsm_getVersion(char* string, uint8_t sizeOfString); 230 | bool gsm_getModel(char* string, uint8_t sizeOfString); 231 | bool gsm_getServiceProviderName(char* string, uint8_t sizeOfString); 232 | uint8_t gsm_getSignalQuality_0_to_100(void); 233 | bool gsm_ussd(char *command, char *answer, uint16_t sizeOfAnswer, uint8_t waitSecond); 234 | bool gsm_tonePlay(Gsm_Tone_t Gsm_Tone_, uint32_t durationMiliSecond, uint8_t level_0_100); 235 | bool gsm_toneStop(void); 236 | bool gsm_dtmf(char *string, uint32_t durationMiliSecond); 237 | //################################################################### message functions 238 | bool gsm_msg_textMode(bool on_off); 239 | bool gsm_msg_isTextMode(void); 240 | bool gsm_msg_selectStorage(Gsm_Msg_Store_t Gsm_Msg_Store_); 241 | bool gsm_msg_selectCharacterSet(Gsm_Msg_ChSet_t Gsm_Msg_ChSet_); 242 | bool gsm_msg_deleteAll(void); 243 | bool gsm_msg_delete(uint16_t index); 244 | bool gsm_msg_send(const char *number,const char *msg); 245 | bool gsm_msg_read(uint16_t index); 246 | uint16_t gsm_msg_getStorageUsed(void); 247 | uint16_t gsm_msg_getStorageTotal(void); 248 | uint16_t gsm_msg_getStorageFree(void); 249 | //################################################################### call functions 250 | bool gsm_call_answer(void); 251 | bool gsm_call_end(void); 252 | bool gsm_call_dial(const char* number, uint8_t waitSecond); 253 | //################################################################### gprs functions 254 | bool gsm_gprs_setApName(char *apName); 255 | bool gsm_gprs_connect(void); 256 | bool gsm_gprs_disconnect(void); 257 | 258 | bool gsm_gprs_httpInit(void); 259 | bool gsm_gprs_httpSetContent(const char *content); 260 | bool gsm_gprs_httpSetUserData(const char *data); 261 | bool gsm_gprs_httpSendData(const char *data, uint16_t timeoutMs); 262 | int16_t gsm_gprs_httpGet(const char *url, bool ssl, uint16_t timeoutMs); 263 | int16_t gsm_gprs_httpPost(const char *url, bool ssl, uint16_t timeoutMs); 264 | uint16_t gsm_gprs_httpRead(uint16_t len); // data into gsm.gprs.buff 265 | bool gsm_gprs_httpTerminate(void); 266 | 267 | bool gsm_gprs_ftpLogin(char *ftpAddress, char *ftpUserName, char *ftpPassword, uint16_t port); 268 | Gsm_Ftp_Error_t gsm_gprs_ftpUploadBegin(bool asciiFile, bool append, const char *path, const char *fileName, const uint8_t *data, uint16_t len); 269 | Gsm_Ftp_Error_t gsm_gprs_ftpUpload(const uint8_t *data, uint16_t len); 270 | bool gsm_gprs_ftpUploadEnd(void); 271 | bool gsm_gprs_ftpExtUploadBegin(bool asciiFile, bool append, const char *path, const char *fileName); 272 | bool gsm_gprs_ftpExtUpload(uint8_t *data, uint16_t len); 273 | Gsm_Ftp_Error_t gsm_gprs_ftpExtUploadEnd(void); 274 | Gsm_Ftp_Error_t gsm_gprs_ftpCreateDir(const char *path); 275 | Gsm_Ftp_Error_t gsm_gprs_ftpRemoveDir(const char *path); 276 | uint32_t gsm_gprs_ftpGetSize(const char *path, const char *name); 277 | Gsm_Ftp_Error_t gsm_gprs_ftpRemove(const char *path, const char *name); 278 | Gsm_Ftp_Error_t gsm_gprs_ftpIsExistFolder(const char *path); 279 | bool gsm_gprs_ftpIsBusy(void); 280 | bool gsm_gprs_ftpQuit(void); 281 | 282 | bool gsm_gprs_tcpConnect(const char *address, uint16_t port, bool ssl); 283 | bool gsm_gprs_tcpSend(const uint8_t *data, uint16_t len); 284 | 285 | bool gsm_gprs_ntpServer(char *server); 286 | bool gsm_gprs_ntpGetTime(char *timeString); 287 | //################################################################### bluetooth functions 288 | 289 | //################################################################### library callback functions 290 | void gsm_callback_simcardReady(void); 291 | void gsm_callback_simcardPinRequest(void); 292 | void gsm_callback_simcardPukRequest(void); 293 | void gsm_callback_simcardNotInserted(void); 294 | void gsm_callback_newMsg(char *number, Gsm_Time_t time, char *msg); 295 | void gsm_callback_newCall(char *number); 296 | void gsm_callback_endCall(void); 297 | void gsm_callback_nowAnswer(void); 298 | void gsm_callback_dtmf(char key); 299 | void gsm_callback_gprsDisconnected(void); 300 | void gsm_callback_gprsConnected(void); 301 | void gsm_callback_gprsGotData(uint8_t *data, uint16_t len); 302 | //################################################################### 303 | 304 | 305 | #endif 306 | 307 | -------------------------------------------------------------------------------- /gsmCallback.c: -------------------------------------------------------------------------------- 1 | 2 | #include "gsm.h" 3 | 4 | //################################################################################# 5 | __weak void gsm_callback_simcardReady(void) 6 | { 7 | 8 | } 9 | //################################################################################# 10 | __weak void gsm_callback_simcardPinRequest(void) 11 | { 12 | //gsm_enterPinPuk(const char* string); 13 | } 14 | //################################################################################# 15 | __weak void gsm_callback_simcardPukRequest(void) 16 | { 17 | //gsm_enterPinPuk(const char* string); 18 | } 19 | //################################################################################# 20 | __weak void gsm_callback_simcardNotInserted(void) 21 | { 22 | 23 | } 24 | //################################################################################# 25 | __weak void gsm_callback_newMsg(char *number, Gsm_Time_t time, char *msg) 26 | { 27 | //gsm_msg_send(number, "I got a message"); 28 | } 29 | //################################################################################# 30 | __weak void gsm_callback_newCall(char *number) 31 | { 32 | //gsm_call_answer(); 33 | } 34 | //################################################################################# 35 | __weak void gsm_callback_endCall(void) 36 | { 37 | 38 | } 39 | //################################################################################# 40 | __weak void gsm_callback_dtmf(char key) 41 | { 42 | 43 | } 44 | //################################################################################# 45 | __weak void gsm_callback_gprsDisconnected(void) 46 | { 47 | gsm_gprs_connect(); 48 | } 49 | //################################################################################# 50 | __weak void gsm_callback_gprsConnected(void) 51 | { 52 | 53 | } 54 | //################################################################################# 55 | __weak void gsm_callback_gprsGotData(uint8_t *data, uint16_t len) 56 | { 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gsmConfig.h: -------------------------------------------------------------------------------- 1 | #ifndef _GSMCONFIG_H 2 | #define _GSMCONFIG_H 3 | 4 | // board config 5 | #define _GSM_DEBUG 1 6 | #define _GSM_USART USART3 7 | #define _GSM_POWERKEY_GPIO GSM_KEY_GPIO_Port 8 | #define _GSM_POWERKEY_PIN GSM_KEY_Pin 9 | 10 | // enable/disable 11 | #define _GSM_CALL_ENABLE 1 12 | #define _GSM_MSG_ENABLE 1 13 | #define _GSM_DTMF_DETECT_ENABLE 1 14 | #define _GSM_GPRS_ENABLE 1 15 | #define _GSM_BLUETOOTH_ENABLE 0 // not support yet 16 | 17 | // do not change 18 | #define _GSM_AT_MAX_ANSWER_ITEMS 5 19 | #define _GSM_TASKSIZE 512 20 | #define _GSM_BUFFTASKSIZE 128 21 | #define _GSM_RXSIZE 512 22 | #define _GSM_RXTIMEOUT 10 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /msg.c: -------------------------------------------------------------------------------- 1 | 2 | #include "gsm.h" 3 | 4 | #if (_GSM_MSG_ENABLE == 1) 5 | //############################################################################################# 6 | bool gsm_msg_updateStorage(void) 7 | { 8 | char str[64]; 9 | char s[5]; 10 | if (gsm_at_sendCommand("AT+CPMS?\r\n", 1000 , str, sizeof(str), 2, "\r\n+CPMS:", "\r\nERROR\r\n") != 1) 11 | return false; 12 | if (sscanf(str, "\r\n+CPMS: \"%[^\"]\",%*hhd,%*hhd,\"%*[^\"]\",%*hhd,%*hhd,\"%*[^\"]\",%hhd,%hhd\r\n", s, &gsm.msg.storageUsed, &gsm.msg.storageTotal) != 3) 13 | return false; 14 | if (strcmp(s, "SM") == 0) 15 | gsm.msg.storage = Gsm_Msg_Store_SIMCARD; 16 | else if (strcmp(s, "ME") == 0) 17 | gsm.msg.storage = Gsm_Msg_Store_MODULE; 18 | else if (strcmp(s, "SM_P") == 0) 19 | gsm.msg.storage = Gsm_Msg_Store_SIMCARD_PREFERRED; 20 | else if (strcmp(s, "ME_P") == 0) 21 | gsm.msg.storage = Gsm_Msg_Store_MODULE_PREFERRED; 22 | else if (strcmp(s, "MT") == 0) 23 | gsm.msg.storage = Gsm_Msg_Store_SIMCARD_OR_MODULE; 24 | else 25 | gsm.msg.storage = Gsm_Msg_Store_ERROR; 26 | return true; 27 | } 28 | //############################################################################################# 29 | uint16_t gsm_msg_getStorageUsed(void) 30 | { 31 | gsm_msg_updateStorage(); 32 | return gsm.msg.storageUsed; 33 | } 34 | //############################################################################################# 35 | uint16_t gsm_msg_getStorageTotal(void) 36 | { 37 | gsm_msg_updateStorage(); 38 | return gsm.msg.storageTotal; 39 | } 40 | //############################################################################################# 41 | uint16_t gsm_msg_getStorageFree(void) 42 | { 43 | gsm_msg_updateStorage(); 44 | return gsm.msg.storageTotal - gsm.msg.storageUsed; 45 | } 46 | //############################################################################################# 47 | bool gsm_msg_textMode(bool on_off) 48 | { 49 | if (on_off) 50 | { 51 | if (gsm_at_sendCommand("AT+CMGF=1\r\n", 1000, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 52 | { 53 | gsm.msg.textMode = 1; 54 | gsm_at_sendCommand("AT+CSMP=17,167,0,0\r\n", 1000, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n"); 55 | return true; 56 | } 57 | } 58 | else 59 | { 60 | if (gsm_at_sendCommand("AT+CMGF=0\r\n", 1000, NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 61 | { 62 | gsm.msg.textMode = 0; 63 | return true; 64 | } 65 | } 66 | return false; 67 | } 68 | //############################################################################################# 69 | bool gsm_msg_isTextMode(void) 70 | { 71 | uint8_t ans; 72 | ans = gsm_at_sendCommand("AT+CMGF?\r\n", 1000, NULL, 0, 3, "\r\n+CMGF: 0\r\n", "\r\n+CMGF: 1\r\n", "\r\nERROR\r\n"); 73 | if (ans == 1) 74 | { 75 | gsm.msg.textMode = 0; 76 | return false; 77 | } 78 | else if (ans == 1) 79 | { 80 | gsm.msg.textMode = 1; 81 | return true; 82 | } 83 | else 84 | return false; 85 | } 86 | //############################################################################################# 87 | bool gsm_msg_deleteAll(void) 88 | { 89 | if (gsm.msg.textMode) 90 | { 91 | if (gsm_at_sendCommand("AT+CMGDA=\"DEL ALL\"\r\n", 25000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 92 | return false; 93 | return true; 94 | } 95 | else 96 | { 97 | if (gsm_at_sendCommand("AT+CMGDA=6\r\n", 25000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 98 | return false; 99 | return true; 100 | } 101 | } 102 | //############################################################################################# 103 | bool gsm_msg_delete(uint16_t index) 104 | { 105 | char str[32]; 106 | sprintf(str, "AT+CMGD=%d\r\n", index); 107 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") == 1) 108 | return true; 109 | return false; 110 | } 111 | //############################################################################################# 112 | bool gsm_msg_send(const char *number, const char *msg) 113 | { 114 | if ((number == NULL) || (msg == NULL)) 115 | return false; 116 | if (gsm.msg.textMode) 117 | { 118 | char str[32]; 119 | sprintf(str, "AT+CMGS=\"%s\"\r\n", number); 120 | if (gsm_at_sendCommand(str, 5000 , NULL, 0, 2, "\r\r\n> ", "\r\nERROR\r\n") != 1) 121 | { 122 | sprintf(str, "%c", 27); 123 | gsm_at_sendCommand(str, 1000, NULL, 0, 0); 124 | return 0; 125 | } 126 | sprintf((char*)gsm.msg.buff, "%s%c", msg, 26); 127 | if (gsm_at_sendCommand((char*)gsm.msg.buff, 60000 , NULL, 0, 2, "\r\n+CMGS:", "\r\nERROR\r\n") != 1) 128 | return false; 129 | return true; 130 | } 131 | else 132 | return false; 133 | } 134 | //############################################################################################# 135 | bool gsm_msg_selectStorage(Gsm_Msg_Store_t Gsm_Msg_Store_) 136 | { 137 | char str[64]; 138 | switch(Gsm_Msg_Store_) 139 | { 140 | case Gsm_Msg_Store_SIMCARD: 141 | sprintf(str, "AT+CPMS=\"SM\",\"SM\",\"SM\"\r\n"); 142 | break; 143 | case Gsm_Msg_Store_MODULE: 144 | sprintf(str, "AT+CPMS=\"ME\",\"ME\",\"ME\"\r\n"); 145 | break; 146 | case Gsm_Msg_Store_SIMCARD_PREFERRED: 147 | sprintf(str, "AT+CPMS=\"SM_P\",\"SM_P\",\"SM_P\"\r\n"); 148 | break; 149 | case Gsm_Msg_Store_MODULE_PREFERRED: 150 | sprintf(str, "AT+CPMS=\"ME_P\",\"ME_P\",\"ME_P\"\r\n"); 151 | break; 152 | case Gsm_Msg_Store_SIMCARD_OR_MODULE: 153 | sprintf(str, "AT+CPMS=\"MT\",\"MT\",\"MT\"\r\n"); 154 | break; 155 | default: 156 | return false; 157 | } 158 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 159 | return false; 160 | gsm.msg.storage = Gsm_Msg_Store_; 161 | gsm_msg_updateStorage(); 162 | return true; 163 | } 164 | //############################################################################################# 165 | bool gsm_msg_selectCharacterSet(Gsm_Msg_ChSet_t Gsm_Msg_ChSet_) 166 | { 167 | char str[64]; 168 | switch(Gsm_Msg_ChSet_) 169 | { 170 | case Gsm_Msg_ChSet_8859_1: 171 | sprintf(str, "AT+CSCS=\"8859-1\"\r\n"); 172 | break; 173 | case Gsm_Msg_ChSet_GSM: 174 | sprintf(str, "AT+CSCS=\"GSM\"\r\n"); 175 | break; 176 | case Gsm_Msg_ChSet_IRA: 177 | sprintf(str, "AT+CSCS=\"IRA\"\r\n"); 178 | break; 179 | case Gsm_Msg_ChSet_PCCP: 180 | sprintf(str, "AT+CSCS=\"PCCP\"\r\n"); 181 | break; 182 | case Gsm_Msg_ChSet_HEX: 183 | sprintf(str, "AT+CSCS=\"HEX\"\r\n"); 184 | break; 185 | case Gsm_Msg_ChSet_UCS2: 186 | sprintf(str, "AT+CSCS=\"UCS2\"\r\n"); 187 | break; 188 | case Gsm_Msg_ChSet_PCDN: 189 | sprintf(str, "AT+CSCS=\"PCDN\"\r\n"); 190 | break; 191 | default: 192 | return false; 193 | } 194 | if (gsm_at_sendCommand(str, 1000 , NULL, 0, 2, "\r\nOK\r\n", "\r\nERROR\r\n") != 1) 195 | return false; 196 | gsm.msg.characterSet = Gsm_Msg_ChSet_; 197 | return true; 198 | } 199 | //############################################################################################# 200 | bool gsm_msg_read(uint16_t index) 201 | { 202 | // +++ text mode 203 | if (gsm.msg.textMode == 1) 204 | { 205 | char str[20]; 206 | sprintf(str, "AT+CMGR=%d\r\n", index); 207 | if (gsm_at_sendCommand(str, 5000, (char*)gsm.msg.buff, sizeof(gsm.msg.buff), 3, "\r\n+CMGR:", "\r\nOK\r\n","\r\nERROR\r\n") != 1) 208 | return 0; 209 | sscanf((char*)gsm.msg.buff, "\r\n+CMGR: \"%[^\"]\",\"%[^\"]\",\"\",\"%hhd/%hhd/%hhd,%hhd:%hhd:%hhd%*d\"", 210 | gsm.msg.status, gsm.msg.number, &gsm.msg.time.year, &gsm.msg.time.month, &gsm.msg.time.day , &gsm.msg.time.hour, &gsm.msg.time.minute, &gsm.msg.time.second); 211 | uint8_t cnt = 0; 212 | char *s = strtok((char*)gsm.msg.buff, "\""); 213 | while( s != NULL) 214 | { 215 | s = strtok(NULL, "\""); 216 | if (cnt == 6) 217 | { 218 | s+=2; 219 | char *end = strstr(s, "\r\nOK\r\n"); 220 | if (end != NULL) 221 | { 222 | strncpy((char*)&gsm.msg.buff[0], s, end - s); 223 | memset(&gsm.msg.buff[end - s], 0 , sizeof(gsm.msg.buff) - (end - s)); 224 | return true; 225 | } 226 | else 227 | return false; 228 | } 229 | cnt++; 230 | } 231 | } 232 | // --- text mode 233 | 234 | // +++ pdu mode 235 | else 236 | { 237 | 238 | return false; 239 | } 240 | // --- pdu mode 241 | return false; 242 | } 243 | //############################################################################################# 244 | #endif 245 | --------------------------------------------------------------------------------