fritzler-avr.de
Library Archiv
SIM900D Library History

SIM900D Beschreibung
Library Dokumentation
Library Download v0.1

SIM900D Beschreibung

Das GSM Modul beinhaltet bereits alle Module um einfach mit dem GSM Netz zu kommunizieren, nur eine SIM Karte wird dazu noch benötigt. Selbst Lautsprecher und Mikrofon lassen sich direkt anschließen um mit dem Modul zu telefonieren. Das Modul ist für den direkten Akkubetrieb vorgesehen und kann diesen auch Laden. Über einen RS232 Anschluss wird das Modul gesteuert.

Das Modul muss nicht dringend mit einem Akku versorgt werden, 3,7V - 4V auf den VBat Anschlüssen tuns auch. Allerdings zieht das Modul 2A Bursts beim senden und dabei darf die Spannung nicht zu start einbrechen. Um zB. aus 12V die 4V zu gewinnen reicht ein MC34063 mit einem 2200µF Elko dahinter für die Stromspitzen.

Die SIM Karte ist recht einfach angeschlossen. Die Widerstände und Schutzdioden können vernachlässigt werden insofern die SIM Karte nicht oft getauscht wird.

Zum Einschalten des Moduls muss natürlich erstmal Spannung anliegen, danach wird der PWRKEY Pin mit einem Transistor auf GND gezogen. Dies sollte für mehr als 1s geschehen, dann bootet das Modul und ist Einsatzbereit.

Zum Abschalten ist die Prozedur ähnlich, durch ein auf GND ziehen des PWRKEY Pin für ~2s wird das Modul abgeschalten.

So sieht die Minimalbeschaltung des SIM900D aus. Die UART Spannung liegt bei 3,0V, daher muss bei einem AVR der auf 5V läuft eine Signalanpassung vorgenommen werden mit R1/R2. Bei einem AVR der auf 3,3V daher leider auch (wer hat sich den Mist mit den 3V ausgedaxcht?!). Die Spannung für die restlichen IO ist 3,3V. Die Batterie dient zur Pufferung der internen Uhr und kann weggelassen werden wenn nicht benötigt.

Beim Starten das Moduls kommen ein paar undefinierte Zeichen raus. Es empfielt sich sowieso vor jedem senden eines Befehls dne Eingangspuffer der benutzten UART LIbrary zu leeren.

Jeder AT Befehl muss mit einem \r\n enden damit das Modul weis, dass der Befehl zuende ist. Das Modul selbst sendet den String verpackt in \r\n . Wenn das Modul gestartet ist, folgt ein OK auf AT.

Standardmäßig wird jeder Befehl wiederholt, da das meist nicht benötigt wird, sollte dies abgeschalten werden.

Bisher konnte bereits mit dem Modul kommuniziert werden, da die Baudrate automatisch erkannt wird (1200, 2400, 4800, 9600, 19200, 38400, 57600). Jedoch sollte die Baudrate manuell festgelegt werden. Die Library kommuniziert mit 38400baud, diese sollte bedacht werden bei eigenen UART Routinen.

Hier wird die SMS Formatierung auf Text festgelegt, das andere SMS Verfahren ist um ein vielfaches komplizierter und ist deshalb nicht implementiert.

Als aktives Telefonbuch wird das auf der SIM Karte gewählt, ein internes ist auch vorhanden.

Jetzt mal prüfen ob die Einwahl ins Handynetz bereits erfolgte. -> 0,1 steht für ins Heimatnetz eingewählt und 0,2 für Netzsuche. Ist noch keine Einwahl erfolgt, sind die Nachfolgenden befehle nicht möglich, daher sollte die Software stets wissen ob das GSM Modul im Netz eingeloggt ist oder nicht!

Mit Cops kann der Providernahme abgefragt werden, hier die Telekom.

Die Empfangsstärke zu wissen ist auch immer recht hilfreich.

Ein eingehender Anruf wird durch RING Signalisiert, zusätzlich wechselt auch der RI Pin des UART auf Low. Nach dem ersten RING wird CLCC gesendet um herauzufinden wer anruft. Die Ziffern vor der Telefonnummer sind irrelevant wenn nicht gemakelt werden soll. In den ersten Anführungszeichen steht die Telefonnummer des Anrufenden in den Anführungszeichen dahinter der Name des Eintrages im aktiven Telefonbuch. Bei unbekannter Nummer/kein Eintrag steht nichts zwischen den Anführungszeichen. NO CARRIER signalisiert schlussendlich, dass der Anrufer aufgelegt hat, erfolgt auch wenn man selbst auflegt.

So wird eine SMS signalisiert. SM bedeutet, dass diese auf der SIM karte gespeichert wurde. Die SMS ist unter dem SMS Index 2 abrufbar.

Telefonbucheintrag anlegen

Eine Webseite der gängigsten GSM Befehle und leicht erklärt.

Weitere AT befehle folgen vllt., wenn ich das Gerät wieder in den Händen halte.

Library Dokumentation

Prozedurenübersicht

  1. /** \brief ließt den Input vom GSM Modul und bereitet diesen auf
  2.  
  3. Falls vorhanden ist der String vom GSM Modul geliefert, ohne \r\n. <br>
  4. RING, NO_CARRIER und eingehende SMS (CMTI) werden herausgefiltert. <br>
  5. Die Statusvariablen sind entsprechend gesetzt.
  6.  
  7. \param String Buffer zum speichern des Strings vom GSM Modul
  8. \param maxchar maximale Länge des Strings
  9.  
  10. \return 1 wenn ein String gelesen wurde, sonst 0
  11. */
  12. uint8_t get_GSM(char *String, uint8_t maxchar);
  13.  
  14. /** \brief leert den UART Empfangsbuffer
  15. */
  16. void empty_ser_in(void);
  17.  
  18. /** \brief initialisierung des GSM Moduls
  19. */
  20. void init_GSM(void);
  21.  
  22. /** \brief GSM Modul abschalten
  23. */
  24. void off_GSM(void);
  25.  
  26. //***************************Profile Commands******************************
  27.  
  28. /** \brief prüft ob das GSM Modul auf dem UART Befehle empfängt
  29.  
  30. \return 1 wenn AT Interpreter des GSM Modul aktiv
  31. \return 0 wenn AT Interpreter inaktiv
  32. */
  33. uint8_t AT_active(void);
  34.  
  35. /** \brief ließt den Namen des GSM Modul aus
  36.  
  37. \param String Pointer auf Buffer für den GSM Modul Namen
  38. \param maxchar maximale Länge des Strings
  39.  
  40. \return 1 bei Erfolg
  41. */
  42. uint8_t GSM_Modul(char *String, uint8_t maxchar);
  43.  
  44. /** \brief ließt die Empfangsstärke aus
  45.  
  46. 0 - weniger als -115dBm <br>
  47. 1 - -111dBm <br>
  48. 2...30 - -110...-54dBm <br>
  49. 31 - mehr als -52dBm <br>
  50. 99 - unbekannt
  51.  
  52. \param String Pointer auf Buffer der Länge 3
  53.  
  54. \return 1 bei Erfolg
  55. */
  56. uint8_t Empfang(char *String);
  57.  
  58.  
  59. //**************************General Commands*******************************
  60.  
  61. /** \brief ließt den Netzstatus aus
  62.  
  63. 0: fehlgeschlagen <br>
  64. 1: eingebucht, Heimatnetz <br>
  65. 2: nicht eingebucht, Netzsuche <br>
  66. 3: nicht eingebucht, Einbuchung abgelehnt <br>
  67. 4: Status unbekannt <br>
  68. 5: eingebucht, Fremdnetz
  69.  
  70. \return 1 bei Erfolg
  71. */
  72. uint8_t Netzstatus (void);
  73.  
  74. /** \brief ließt den Providernamen aus
  75.  
  76. \param String ausreichend langer Buffer für den Namen
  77.  
  78. \return 1 bei Erfolg
  79. */
  80. uint8_t Provider(char *String);
  81.  
  82. //****************************Telefoncommands***************
  83.  
  84. /** \brief hat jemand angerufen?
  85.  
  86. \return 1 bei anruf, sonst 0
  87. */
  88. uint8_t get_ring(void);
  89.  
  90. /** \brief Rufnummer des momentanen Anrufers auslesen
  91.  
  92. Der String ist leer bei unterdrückter Nummer. Maximale länge: 20 zeichen.
  93.  
  94. \param String Buffer mit der Länge 21
  95.  
  96. \return 1 bei Erfolg
  97. */
  98. uint8_t get_ringingnumber(char *String);
  99.  
  100. /** \brief Telefonbuchname des momentanen Anrufers
  101.  
  102. Der Name des Anrufers ist geliefert, insofern er im Telefonbuch steht.
  103. Der String ist leer bei keinem auffindbaren Eintrag. Maximale länge: 16 zeichen.
  104.  
  105. \param String Buffer mit der Länge 17
  106.  
  107. \return 1 bei Erfolg
  108. */
  109. uint8_t get_anrufer(char *String);
  110.  
  111. /** \brief auflegen des momentanen anrufs
  112.  
  113. \return 1 bei Erfolg
  114. */
  115. uint8_t auflegen(void);
  116.  
  117. /** \brief annehmen des momentanen anrufs
  118.  
  119. \return 1 bei Erfolg
  120. */
  121. uint8_t annehmen(void);
  122.  
  123. /** \brief einen Anruf tätigen
  124.  
  125. \param Nummer String im Format +49xxxx
  126.  
  127. \return 1 bei Erfolg
  128. */
  129. uint8_t anrufen(char* Nummer);
  130.  
  131.  
  132. //*************************Telefonbuch*******************
  133.  
  134. /** \brief einen EIntrag im SIM Telefonbuch anlegen
  135.  
  136. \param Index Der Telefonbuchindex in den geschrieben werden soll (1 - 230)
  137. \param Nummer Die Nummer die geschrieben werden soll im Format "145" (+49xxx), max 20 Zeichen
  138. \param Titel Der Name des Eintrags, max 16 Zeichen
  139.  
  140. \return 1 bei Erfolg
  141. */
  142. uint8_t write_entry(const char* Index, const char* Nummer, const char * Titel);
  143.  
  144. /** \brief einen Eintrag aus dem SIM Telefonbuch lesen
  145.  
  146. \param Index Der Telefonbuchindex der gelesen werden soll (1 - 230)
  147. \param Nummer Buffer in den die Nummer im Format "145" (+49xxx) geschrieben wird, max 20 Zeichen
  148. \param Titel Buffer in den der Name des Eintrags geschrieben wird, max 16 Zeichen
  149.  
  150. \return 1 bei Erfolg
  151. */
  152. uint8_t read_entry(const char* Index, char* Nummer, char* Titel);
  153.  
  154.  
  155. //***************************Datum/Uhrzeit*******************
  156.  
  157. /** \brief Uhrzeit aus der RTC des SIM900D auslesen
  158.  
  159. \param String Buffer in dem die Zeit im Format hh:mm:ss gespeichert wird
  160.  
  161. \return 1 bei Erfolg
  162. */
  163. uint8_t get_time(char* String);
  164.  
  165. /** \brief Datum aus der RTC des SIM900D auslesen
  166.  
  167. \param String Buffer in dem das Datum im Format yy/mm/dd gespeichert wird
  168.  
  169. \return 1 bei Erfolg
  170. */
  171. uint8_t get_date(char* String);
  172.  
  173. /** \brief setzt Uhrzeit und Datum der RTC des SIM900D
  174.  
  175. \param String Zeit und Datum im Format yy/mm/dd,hh:mm:ss+00
  176.  
  177. \return 1 bei Erfolg
  178. */
  179. uint8_t set_datetime(const char* String);
  180.  
  181.  
  182. //********************************SMS****************************
  183.  
  184. /** \brief sind neue SMS eingetroffen?
  185.  
  186. \return 1 bei neuer SMS, sonst 0
  187. */
  188. uint8_t get_newsms(void);
  189.  
  190. /** \brief auf welchem SIM Speicherplatz liegt die neue SMS?
  191.  
  192. \return Der Index der neuen SMS
  193. */
  194. uint8_t get_newsms_index(void);
  195.  
  196. /** \brief löschen von ganzen SMS Gruppen
  197.  
  198. READ <br>
  199. UNREAD <br>
  200. SENT <br>
  201. UNSENT <br>
  202. INBOX <br>
  203. ALL <br>
  204.  
  205. \param mode einer der oben genannten
  206.  
  207. \return 1 bei Erfolg
  208. */
  209. uint8_t sms_deleteall(const char* mode);
  210.  
  211. //Vor.: UART init und GSM init, eine löschbare SMS.
  212. //Eff.: Die SMS mit dem Index ist gelöscht.
  213. /** \brief löschen einer SMS
  214.  
  215. \param index der Index des SIM Speichers der zu löschenden SMS
  216.  
  217. \return 1 bei Erfolg
  218. */
  219. uint8_t sms_delete(const char* index);
  220.  
  221. /** \brief ließt die Nummer des SMS Absenders aus
  222.  
  223. \param index der Index des SIM Speichers
  224. \param Nummer Buffer zum speichern der Nummer, max 20 Zeichen
  225.  
  226. \return 1 bei Erfolg
  227. */
  228. uint8_t get_sms_nummer(const char* Index, char* Nummer);
  229.  
  230. /** \brief ließt den Absender der SMS aus dem SIM Telefonbuch aus
  231.  
  232. Eintrag im Telefonbuch nicht enthalten -> leerer String.
  233.  
  234. \param Index der Index des SIM Speichers
  235. \param Absender Buffer für den Absender, max 20 Zeichen
  236.  
  237. \return 1 bei Erfolg
  238. */
  239. uint8_t get_sms_absender(const char* Index, char* Absender);
  240.  
  241. //return: Speicherplatz
  242. /** \brief sendet eine SMS
  243.  
  244. \param nummer String im Format +49xxxx
  245. \param text Text der gesendet werden soll, max 160 Zeichen
  246.  
  247. \return Speicherplatz Index der gesendet SMS
  248. \return 0 bei Sendefehler
  249. */
  250. uint8_t send_sms(const char* nummer, const char* text);

Benutzen der Library

  1. //Stringspeicher
  2. char tmp[61] = "\0";
  3.  
  4. //GSM Modul init und einwählen
  5. init_GSM();
  6.  
  7. //einloggen
  8. uint8_t netz = 0;
  9. while (netz != 1) {//warten bis eingeloggt
  10.    netz = Netzstatus();
  11.    //urgendeine Einwahlsimulation möglich oder Anzeige
  12. }
  13.  
  14. //aufrufen damit Statusvariablen aktualisiert werden
  15. get_GSM((char*)&tmp, 60);
  16. if(get_ring()){
  17.    get_ringingnumber((char*)&tmp); //Nummer rausfinden
  18.    annehmen();
  19.    //telefonieren
  20.    auflegen();
  21. }
  22. if (get_newsms()){
  23.    get_sms_nummer((char*)&get_newsms_index(), (char*)&tmp); //Nummer rausfinden
  24. }
  25.  
  26. anrufen((char*)"+4930123456789\0");
  27. //telefonieren
  28. auflegen();
  29.  

SIM900D Library Version 0.1

Die Library enthält Prozeduren zum Anrufen, Anruf annehmen, Anrufer identifizieren sowie auflegen. Weitere Prozeduren zum Senden, Empfangen und Bearbeiten von SMS. Telefonbuch und Uhrzeit/Datum können auch bearbeitet werden.

Achtung! Die Library ist momentan eher im Laborstadium und wird nochmal komplett neu geschrieben.

Datenblatt vom SIM900D
AT Befehle vom SIM900D
Download SIM300D/900D Eagle Library von ComWebNet
C Library DOWNLOAD

WebSVN lädt Loading confirmation image

Home - Librarys

Kontakt - Haftungsausschluss - Impressum