Mikrocontroller.net - Benutzerbeiträge [de]

Datei:Layout.zip

2012-05-15T19:22:35Z

Remote1: Eagle Layout

Eagle Layout

Receiver-Mainboard Plattform Philips PNX8950

2011-04-05T05:52:42Z

Remote1: /* Wichtige Links */

= Wichtige Links =
Hier nur die wichtigsten Links (Hauptdiskussionsthread und andere Wikis), den Rest unter "weitergehende Infos im Netz"
* Diskussionsthread [http://www.mikrocontroller.net/topic/210759 Pollin - Receiver-Mainboard mit Twin DVB-T/C Tuner, NXP PNX8950EH]

* Bedienungsanleitung [http://www1.medion.de/downloads/download.pl?lang=de&filename=bda_md29052_de.pdf&id=7946&type=anleitungen MEDION LIFE S27200 - MD 29052]

= Wichtiger Hinweis =

'''Vor dem Arbeiten an der Platine oder Öffnen des Gehäuses ist der Netzstecker (230V) zu ziehen. Denn: Der Kühlkörper (des Netzteils) führt eine Spannung von 115V!!!'''


= Betriebssysteme =

== Bestehenden Inhalt aus dem Flash auslesen ==

Von Benutzer AgentData wird freundlicherweise die [http://www.mikrocontroller.net/attachment/106071/complete_nand_layout.rar gesamte Firmware mit Erklärung sowie der Source für den Dumper] zur Verfügung gestellt. Der für den direkten Zugriff auf das NAND benötigte Code befand sich in der Datei $F/Windows/TmToolbox.dll (read/write/erase).

Damit dürfte der Grundstein für jegliche Weiterentwicklung gelegt sein.

== Neues Firmwareimage aufspielen ==

# Auf einen mit FAT32 formatierten USB-Stick folgende Datein kopieren: flashing.txt, phStbRootApp_256M_0_t.mi, phStbRootApp_256M_1_t.mi sowie WinCe1.nb0. Diese befinden sich beispielsweise im Ordner WCE1 der Datei swu.zip
# Receiver hinten am Netzteil ausschalten
# SW1 auf ON (DIL Schalter auf Pollin Board)
# USB-Stick am Rückwärtigen USB-Port des Receivers anschließen
# Receiver hinten am Netzteil einschalten
# Am Receiver vorne auf Power drücken. Bei Fehlermeldung auf Bildschirm: Anderen USB Stick (oder per SD-Karte + Reader) probieren und/oder Receiver per Fernbedienung einschalten. Wenn alles funktioniert, erscheint eine Anzeige auf dem Bildschirm, daß das Update durchgeführt wird und man den Receiver nicht ausschalten soll, bis das Update eingespielt ist. Falls irgend etwas falsch läuft, startet das Windows CE und zeigt den Telegen-Desktop. Dann nochmal alles überprüfen.
# Auf dem roten, 4-stelligen Frontdisplay der Box wird nun für die insgesamt 4 Flash-Vorgänge jeweils der Fortschritt in Prozent angezeigt. Achtung: Es werden insgesamt 4 Dateien einzeln geflasht, die Prozentzahl klettert also vier Mal bis auf die 100%.
# Nach kurzer Zeit (1 oder 2 Minuten) erscheint eine Meldung, dass das Software Update erfolgreich war
# Receiver am Netzteil ausschalten.
# SW1 auf OFF setzen.

Nun wird die Box beim Einschalten auf dem TV einen hin- und herwandernden roten Balken zeigen. Die weiteren Programmpunkte sind selbsterklärend.

== WindowsCE ==

*Windows CE 5.0
*Windows CE Kernel for MIPS (Built on Mar 29 2005 at 14:00:54)
*Telegent Kernel V0.9.3.16 (Built on Sep 4 2006 at 22:23:55)

User AgentData hat das [http://www.mikrocontroller.net/attachment/106025/org_firmware_dump.zip im Auslieferungszustand auf dem Gerät befindliche WindowsCE] ausgelesen (siehe hierzu [http://www.mikrocontroller.net/articles/Receiver-Mainboard_Plattform_Philips_PNX8950#Bestehenden_Inhalt_aus_dem_Flash_auslesen Inhalt aus dem Flash auslesen]). Dadurch kann beispielsweise eine [http://www.mikrocontroller.net/articles/Receiver-Mainboard_Plattform_Philips_PNX8950#MoreTv_als_Medion_gelabelt mit MoreTV "aktualisierte"] Box nun auch wieder in den Auslieferungszustand zurückversetzt werden. Die [http://www.mikrocontroller.net/articles/Receiver-Mainboard_Plattform_Philips_PNX8950#Neues_Firmwareimage_aufspielen Update-Prozedur] ist identisch.

== MoreTv als Medion gelabelt ==

Benötigt wird:
# SATA-HD mit 160GB oder mehr (im Original 250GB)
# USB-Stick (FAT32)
# [https://www.more.tv/softwareupdate/SWU_Finland/SWU_Finland_V1.0.3.454/swu.zip SoftWareUpdate (SWU_Finland_V1.0.3.454)]

'''Ein großes Danke gilt den Usern Fritz und M. W.'''

Hier die Kurzanleitung zum 'Tuning':
* Erster Start der Box
:WindowsCE meldet sich und kann mittels USB-Maus und Tastatur bedient werden. Nach erfolgtem Flash-Vorgang ist dies nicht mehr möglich.

* Den Inhalt des Ordner WCE1, aus der Datei [https://www.more.tv/softwareupdate/SWU_Finland/SWU_Finland_V1.0.3.454/swu.zip swu.zip] (SWU_Finland_V1.0.3.454), auf einen formatierten USB-Stick (FAT32) kopieren und [http://www.mikrocontroller.net/articles/Receiver-Mainboard_Plattform_Philips_PNX8950#Neues_Firmwareimage_aufspielen wie beschrieben] aufspielen

* SATA-HD vorbereiten
:# Auf der einzubauenden SATA-HD zuvor eine Extended Partition mit zwei logischen Laufwerken anlegen. (FAT32, Typ 'b' bei fdisk unter Linux). Mit dem kostenlosen Windows Programm "[http://www.easeus.com/download.htm EASEUS Partition Master 8.0.1 Home Edition]" lässt sich dies ebenfalls einfach erreichen.
:# Auf das ersten logischen Laufwerk (minimum 2GB, im Original 19,53GB, das entspricht exakt 20000MB) den gesamten Inhalt des zuvor ausgepackten [https://www.more.tv/softwareupdate/SWU_Finland/SWU_Finland_V1.0.3.454/swu.zip SoftWareUpdates] kopieren.
:# Die Ordner moreTVn und moreTVn.INIT zu moreTV und moreTV.INIT umbenenen.
:# Das zweite Laufwerk (je größer desto besser, im Original 213,4GB) bleibt leer.

: Die fehlenden Ordner auf der Festplatte werden beim ersten Starten der Box automatisch angelegt.
: ACHTUNG: Die USB-Anschlüsse werden nach dem Aufspielen der MoreTV Firmware nicht mehr unterstützt. Eine Ausnahme bildet einzig und alleine das [http://www.mikrocontroller.net/articles/Receiver-Mainboard_Plattform_Philips_PNX8950#Neues_Firmwareimage_aufspielen Flash-Update].

== Linux ==

:Die CPU wird pauschal von Linux unterstützt.

== Interessant zum weiteren Testen ==

*elecard firmware
*MontaVista Linux Professional Edition

= Unterstützte Codecs =

Quelle: [http://www.synnex.com.tw/oem/mic_link/seminar%20download/y70303.pdf]

*dual: SD MPEG-1/2
*single: SD MPEG-4, WM9, H264,DivX; HD MPEG-2 (1080i), WM9(720p)
*Audio: dual stereo (2.0 + 2.0),MPEG-1, Dolby AC-3

= Bezugsquellen =

===Platinen===
* [http://www.pollin.de/shop/dt/NzQ5OTA2OTk-/Bausaetze_Module/Module/Receiver_Mainboard_mit_Twin_DVB_T_Tuner.html Pollin : Receiver-Mainboard mit Twin DVB-T Tuner (390 052, 7,95€)]
* [http://www.pollin.de/shop/dt/NjQ5OTA2OTk-/Bausaetze_Module/Module/Receiver_Mainboard_mit_Twin_DVB_C_Tuner.html Pollin : Receiver-Mainboard mit Twin DVB-C Tuner (390 053, 7,95€)]
* [http://www.pollin.de/shop/dt/MzQxODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/RS232_Einbaubuchse.html Pollin : RS232-Einbaubuchse (721 856, 0,25€)], zur Befestigung werden noch zwei passende Sechskant-Schraubbolzen benötigt
* [http://www.pollin.de/shop/dt/NDQxODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/USB_2_0_Einbaubuchse.html Pollin : USB 2.0-Einbaubuchse (721 855, 0,25€)]

===Zubehör===
:Netzteil, Gehäuse, Fernbedienung:
*[http://www.pollin.de/shop/dt/NjUwOTQ2OTk-/Stromversorgung/Netzgeraete/Festspannungs_Netzgeraete/Schaltnetzteil_DELTA_EADP_50DF_12_V_4_16_A.html Pollin : Schaltnetzteil DELTA EADP-50DF, 12 V-/4,16 A (350 943 , 4,95€)]
*[http://www.pollin.de/shop/dt/MDg4OTM1OTk-/Bauelemente_Bauteile/Gehaeuse/Stahlblech_Gehaeuse_mit_Frontblende.html Pollin : Stahlblech-Gehäuse mit Frontblende (460 119, 2,95€)]
*[http://www.pollin.de/shop/dt/Nzc5OTczOTk-/SAT_Antennentechnik/Satelliten_Technik/Fernbedienungen/Infrarot_Fernbedienung_RCX155.html Pollin : Infrarot-Fernbedienung RCX155 (620 022, 1,95€)]
:SATA:
*[http://www.pollin.de/shop/dt/NTQxODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/SATA_Kabel.html Pollin : SATA-Kabel, 2x SATA-Stecker, 0,35m (721 854, 0,50€)]
*[http://www.pollin.de/shop/dt/MDM0OTcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/HDD_Stromversorgungskabel.html Pollin : PC-Stromversorgungskabel, 2x 5,25"- Stecker, 2x HDD-Stecker, 70mm (720 569, 0,20€)]
*[http://www.pollin.de/shop/dt/NDI1ODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/SATA_Stromversorgungsadapter.html Pollin : SATA-Stromversorgungsadapter (721 475, 0,85)] oder alternativ
*[http://www.pollin.de/shop/dt/MTUwOTcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/SATA_Stromversorgungsadapter.html Pollin : SATA-Stromversorgungsadapter, mit Rastnase! (720 948, 0,55)]
:WLAN:
*[http://www.pollin.de/shop/dt/NDY5ODgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/WLAN_miniPCI_Karte_XG_603.html Pollin : WLAN miniPCI-Karte XG-603 (711 035, 3,95€)]
*[http://www.pollin.de/shop/dt/MjUwOTgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Antennen_Adapterkabel.html Pollin : WLAN-Antennen-Adapterkabel (710 947, 4,95€)]
*[http://www.pollin.de/shop/dt/MTM5ODgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Rundstrahlantenne.html Pollin : WLAN-Antenne 4 dBi. Länge 140 mm Reverse-SMA (710 068, 1,95€)] oder alternativ
*[http://www.pollin.de/shop/dt/NzY3ODgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/WLAN_Antenne_FSC_5_dBi_RP_SMA.html Pollin : WLAN-Antenne, mit Standfuß, Reverse-SMA, 5 dBi (711 232, 3,95€)] oder alternativ
*[http://www.pollin.de/shop/dt/NDE0OTgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Rundstrahlantenne.html Pollin : WLAN-Antenne, Reverse-SMA, 5 dBi (710 585, 6,95€)] oder alternativ
*[http://www.pollin.de/shop/dt/ODI5ODgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Antenne.html Pollin : WLAN-Antenne, mit magnetischem Standfuß, Reverse-SMA, 7 dBi (711 071, 6,95€)] oder alternativ
*[http://www.reichelt.de/?ACTION=3;ARTICLE=61136;PROVID=2402 Reichelt: LAN DN-70100, WLAN-Antenne, Reverse-SMA, 5 dBi (LAN DN-70100, 3,65€)]

:DVB-T und DVB-C:
*[http://www.pollin.de/shop/dt/MzQ3ODI0OTk-/SAT_Antennentechnik/Kabel/Antennen_Anschlusskabel_75_150_mm.html Pollin : Antennen-Anschlusskabel 75 Ω, 150 mm (571 256, 0,15€)] zum Durchschleifen des DVB-Signals
:DVB-T:
*Bitte beachten: Passive antennen sind grundsätzlich nicht zu empfehlen. Zumindest nicht im Zimmer. Ausser man wohnt am Sender :D
*[http://www.pollin.de/shop/dt/MTc4ODI0OTk-/SAT_Antennentechnik/DVB_T_DVB_C/Antennen/DVB_T_Antenne_QOSMIO.html Pollin : DVB-T Antenne QOSMIO, passiv (571 128, 2,95€)]
:DVB-S:
*[http://www.elsner-computer.de/product_info.php?info=p430032_Dream-Multimedia-Tuner-7020S---7020Si---DVB-S.html Tuner 7020S Elsner Shop 39€. ]
*[http://www.hm-sat-shop.de/receiver-digital-dreambox/sat-tuner-fuer-dreambox-7020-philips.html HM Sat Shop:DVB-S Tuner zum Sat-Umbau, 49€.]
*[http://www.devilcards.de/Ersatzteile-Dreambox/Dream-Multimedia-Tuner-7020S-7020Si-DVB-S::225.html DevilCards Dream Multimedia Tuner 7020S DVB-S 37€ ]
Entweder zwei bestücken oder exklusiv einen. Mischbetrieb scheinbar nicht möglich!

*...außerdem Plexiglas/Kunststoff-Zuschnitt (13cm x 15cm) als HD-Träger sowie diverse Schrauben aus der PC-Grabbelkiste (7* Gehäuse, 1* Front-USB, 4* Schaltnetzteil, 6* Mainboard, 4* HD-Träger, 4* HD, 3* Frontpanel)

= Hardware =
== technische Daten ==
* Betriebsspannung 12 V-
* Stromaufnahme ohne HDD max. 2 A
* 2x Philips DVB-T Tuner TU1216L/IVP
* HDD-Stromversorgung on Board
* Anschlüsse extern: 2x Tuner In, 2x Tuner Out, LAN 10/100 Mbps, USB 2.0, optischer Audioausgang, AV-Out (Cinch), S-Video, 2x Scart
* interne Ports/Anschlüsse: 3x USB 2.0, 2x SATA, RS232, miniPCI für WLAN-Karte (XG-603), Smartcard-Reader, CI-Slot

== Jumper ==
* J1: (Header 2x5, nicht bestückt)
* J2: RS-232 Console (3:RX=RS232.3, 5:TX=RS232.2, 9:GND=RS232.5, Header 2x5)
* J4: (Header 2*10)
* J6: (Header 2x1, neben HD-Power)
* J8: (Header 2x3 nicht bestückt)
* J27: Massepunkt(1:GND, 2:GND, Header 2*1, zwischen SCART und Audio-Buchse)
* J30: USB Port 4 (über 4 pol Kabel verbunden mit Front USB, Header 1x4)
* J31: USB Port 3 (Header 1x4)
* J32: (Header 2x1, nicht bestückt, neben SW1)
* J34: an PIN 32 DVB-T-Tuner (Header 2x1, neben Tuner 1, bei DVB-C-Tuner nicht benutzt)
* J35: (Header 2x1, nicht bestückt, neben Tuner 1)
* J36: an PIN 32 DVB-T-Tuner (Header 2x1, neben Tuner 2, bei DVB-C-Tuner nicht benutzt)
* J37: (Header 2x1, nicht bestückt, neben Tuner 2)
* J41: Anschluß Bedien-PCB, Infrarot-Receiver (5 pol)
* J42: Anschluß Bedien-PCB, Tastatur + Display (10 pol)
* J43: 12V von Schaltnetzteil
* J45: nicht bestückt, Hohlbuchse, 12V Spannungsversorgung
* J46: USB Port 2 (Header 1x4)
* J47: SPDIF-Ausgang

== LEDs ==
* LED1: grün, blinkt, wenn am rückwärtigen USB-Anschluss beispielsweise eine Maus angeschlossen ist (zwischen U1 und nicht bestücktem HDMI-Chip U42)
* LED2: blau (neben Befestigungsloch H3)
* LED3: rot, wahrscheinlich Netzkontroll-LED(Nähe J4)
* LED4: grün, leuchtet nur ganz schwach (neben LED3, Nähe J4)
* LED5: grün (neben Prozessor)
* LED6: blau (neben Prozessor)
* LED7: rot (neben LED5)
* LED8: grün, zeigt HD-Schreibzugriff bei einer Aufnahme an (neben J6, USB Port 2)

==Varianten==
===DVB-T===
===DVB-C===
Die Box kann mit großer Sicherheit keine QAM256 modulierten Programme wiedergeben.
Programme, die QAM64 moduliert sind werden problemlos und sicher wiedergegeben

== Bilder/Innenleben ==

<gallery widths="300" heights="225" perrow="3">
Bild:moretv_1.jpg|Gesamtansicht
Bild:moretv_2.jpg|JTAG-Anschluss für LPC921F (unter anderem) und Platz zur Montage einer 3,5" Festplatte
Bild:moretv_3.jpg|Board komplett
Bild:moretv_4.jpg|DVI – nicht bestückt
Bild:moretv_5.jpg|DVB-T Tuner
Bild:moretv_6.jpg|CPU RAM etc.
Bild:moretv_7.jpg|mini PCI, Sata, CI-Slot, Smartcard
Bild:moretv_8.jpg|Rückseite komplett
Bild:moretv_9.jpg|CI-Controller
Bild:moretv_10.jpg|Sata-Controller
Bild:moretv_11.jpg|RAM und TDA8024T SmartCard-Interface
Bild:moretv_12.jpg|LAN DP83816 (fast identisch zu SiS 900)
Bild:moretv_13.jpg|SW1 auf ON = SW-Update SW2 auf ON = JTAG Enable
Bild:moretv_14.jpg|Stromversorgung
Bild:moretv_15.jpg|Anschluss J4
Bild:EJTAG.jpg|CON1: EJTAG für den PNX8950
Bild:Tuner_Jumper1.JPG|Wie man sieht, müssen keinerlei Jumper gesetzt sein, um DVB-T empfangen zu können.
Bild:Console.png|RS-232 Console auf J2
Bild:lpc_8051_power.png|3,3Volt auf J4
</gallery>

== Schnittstellen ==

* 4x USB
** 3x intern: J31 USB Port3, J46 USB Port2
** 2x extern: J30 USB Port4 (Frontpanel), CON9
** Pinout: PIN4:GND/Schwarz, PIN3:D+/Grün, PIN2:D-/Weiss, Pin1:+5V/Rot

* 2x RS-232
:* 1x intern, Pinbelegung (J2)
::* '''hier einfügen'''

:*1x extern, Pinbelegung (J33):
::* 6 gnd
::* 5 rx1 r2in MAX2333 (U10)
::* 4 rx2 r1in MAX2333 (U10)
::* 3 tx1 T2out MAX2333 (U10)
::* 2 tx2 T1out MAX2333 (U10)
::* 1 gnd 0
::* das O ist die Markierung auf der Platine

== Chips ==
Übersicht über die verwendeten Bausteine mit Links auf ensprechende Datenblätter, Quellen etc.

* Multimedia-CPU Philips PNX8950EH/M2/S1
**[http://datasheet.octopart.com/PNX8950EH/M2/S1%2C55-NXP-datasheet-8325175.pdf Datasheet PNX8950EH/M2/S1]
**[http://www.brightsign.biz/documents/HD2000HardwareGuide.pdf Brightsign Hardwareguide]
**[http://www.kanecomputing.co.uk/pdfs/mds_mds810.pdf MDS-810]
*[http://www.alldatasheet.com/datasheet-pdf/pdf/98585/SAMSUNG/K4H511638C-UCCC.html 4x 512 MBit DDR SDRAM SAMSUNG K4H511638C-UCCC]
* [http://www.hynix.com/datasheet/pdf/flash/HY27(U_S)S(08_16)121A%20Series(Rev1.3).pdf HYNIX HY27US08121A 512 Mbit NAND Flash]
* [http://www.siliconimage.com/docs/SiI-DS-0102-D.pdf SiI3512 SATA150 Controller]
*[http://www.national.com/ds/DP/DP83816.pdf 10/100 Mbps PCI Ethernet-Controller NATIONAL DP83816]
* High Speed USB PCI Host Controller Philips ISP1561BM [http://www.nxp.com/acrobat_download2/expired_datasheets/ISP1561_2.pdf Datasheet]
* [http://www.maxim-ic.com/datasheet/index.mvp/id/1068 MAX3222]
* PNX8510HW [http://www.datasheetcatalog.org/datasheet/philips/PNX8510_PNX8511_4.pdf Datasheet]
* Bedienteil mit LED-Display, Infrarotempfänger usw.
* In der DVB-C-Version: Philips CU1216 DVB-C Tuner [http://read.pudn.com/downloads138/sourcecode/others/589797/CU1216L-3-datasheet.pdf Datasheet]
** Philips TDA10023 (DVB-C Channel Decoder) [http://www.datasheetdownload.com/download.php?id=677273 Datasheet]
* In der DVB-T-Version: Philips TU1216 DVB-T Tuner
** Philips TDA10046 (DVB-T Channel Decoder) [http://www.nxp.com/acrobat/literature/9397/75009522.pdf Spec Sheet] [http://git.linuxtv.org/media_tree.git?a=blob;f=drivers/media/dvb/frontends/tda1004x.c - linuxtv.org Frontend Treiber]
** Philips TDA6650 (5 V mixer/oscillator and low noise PLL synthesizer for hybrid terrestrial tuner) [http://www.nxp.com/documents/data_sheet/TDA6650TT_6651TT.pdf Datasheet] [http://git.linuxtv.org/media_tree.git?a=blob;f=drivers/media/dvb/frontends/tda665x.c - linuxtv.org Tuner Treiber]
* Philips TDA8024T (IC Card Interface) [http://www.nxp.com/documents/data_sheet/TDA8024.pdf Datasheet]

Nicht bestückte ICs:
* U42 DVI (wahrscheinlich [http://www.nxp.com/documents/data_sheet/TDA9983B.pdf Philips TDA9983])
* U40 ????
* U41 ????
* U44 ????
* U45 ????
* U48 ????
* U51 ????
* U59 ????

== Fernbedienung ==

[[IRMP]] Codes:

Protokoll: NEC 
Geräte ID: 0x6B44 
Tastencodes: 
* 00 0
* 01 EXIT
* 02 8
* 03 INFO
* 04 4

* 06 HELP
* 07 OK
* 08 2
* 09 REC

* 0B Marker
* 0C 6

* 0E Down
* 0F V-
* 10 1
* 11 AV
* 12 9
* 13 Right
* 14 5
* 15 Archiv

* 17 P-
* 18 3
* 19 Up
* 1A Yellow
* 1B Left
* 1C 7
* 1D Stop/LIVE
* 1E RED

* 40 MORE
* 41 LIST
* 42 FFWD

* 48 TV
* 49 #
* 4A GREEN

* 4C EPG

* 4E SLOW

* 50 P+
* 51 *
* 52 POWER

* 54 FREW

* 56 PAUSE

* 58 Setup
* 59 TEXT
* 5A BLUE

* 5C Chap+

* 5E PiP

Die Tasten Stumm, Chapter+ und Play funktionieren bei meiner FB nicht.
Die hatte einen Dauerkontakt auf einer dieser Tasten. Darum musste ich eine Leiterbahn durchtrennen.

= Software =
Übersicht über verwendete Software (Betriebssysteme, Compiler, Tools, etc)

* Software Update: [http://www.mikrocontroller.net/attachment/105209/swu.zip swu.zip]

* Bootloader
:Eventuell [http://www.denx.de/wiki/U-Boot/SourceCode U-Boot] support mit diesen 4 patches:
:# [http://lists.denx.de/pipermail/u-boot/attachents/20061204/e9922ec2/attachment.obj pnx8550support.diff.gz]
:# [http://lists.denx.de/pipermail/u-boot/attachments/20061206/556029b0/attachment.obj nxp_i2c.diff.gz]
:# [http://lists.denx.de/pipermail/u-boot/attachments/20061211/bff13619/attachment.obj nxp_pci.diff.gz]
:# [http://lists.denx.de/pipermail/u-boot/attachments/20061211/8d42666e/attachment.obj mips_timer2.diff]
<pre>
Overview
+The Silverbox is a development platform based on the NXP PNX8550
+(Nexperia) media processor. It consists of a MIPS32 compatible PR4450
+core, accompanied by two TriMedia processors. Typical use for the
+PNX8550 is in settop box and advanced analogue and digital TV sets.
+
+This first version of U-Boot for this platform supports a minimal set
+of commands and hardware. Feature to be added in the near future are
+PCI bus, Ethernet, NAND flash and USB support.
+
+Boot Methods
+U-Boot for the Silverbox is typically loaded into SDRAM using an EJTAG
+probe. The load address and entry point is 0xA0010000.
+
+As NAND flash support is not yet available a single page NAND flash
+loader is also not available. This limits this U-Boot version, but
+a single page loader based on U-Boot 1.1.3 is available on request.
</pre>
Screenshot der Windows CE 5.0 Oberfläche (über VNC mit der Box verbunden http://efonvnc.sourceforge.net/)

[[Datei:CEscreenshot.png]]

= Anwendungen und Ideen =
==Realisierte Projekte/Anwendungen==

=== ftp-Server unterschieben ===
* Auf der Festplatte in der Datei "moreTV.cfg" im Abschnitt "Shell_startup" die Zeile für den Start des ftp-Servers einfügen
<Shell_startup>
<run cmd="$H\ftpsvr.exe"/> #### diese Zeile einfügen ohne diesen Kommentar!
<run cmd="$H\moreTV\DC.exe"/>

<run cmd="$H\moreTV\MaxAktiv.exe"/>
</Shell_startup>
* Den FTP-Server [http://www.mikrocontroller.net/attachment/104995/ftpsvr.exe hier] downloaden und nach $H kopieren, also die erste Partition der Festplatte.
* Für's Login des FTP-Servers irgendwelche Werte eingeben, z.B.
Benutzer: root
Passwort: root
* Die Exe-Dateien aus dem Windows-Verzeichnis können aber nicht bzw. nicht alle kopiert werden. Im Totalcommander werden die Attribute 555 angezeigt. Vielleicht hat ja noch jemand eine Idee, wie man das überwinden kann.

==Anwendungsideen==

'''Unter Linux:'''
Festplattenreceiver,
Asterisk Server,
NAS,
Car-PC,
Multimedia Client/Server,
Wetterstation logging Server,
Solar logging Server

'''Unter WinCE''':
Festplattenreceiver,
NAS,
Car-PC,
Media Portal Client/Server,
Kamera Server,
Spielekonsole für minigames,
Download Server

= weitergehende Infos im Netz =
Alles was noch weiterführende Infos bietet. Andere Wikis, Beiträge, etc.

* [http://www.oohito.com/wince/mips_o_j.htm MIPS FTP Server]

[[Kategorie:Projekte]]

Receiver-Mainboard Plattform Philips PNX8950

2011-03-28T12:32:30Z

Remote1: /* Betriebssysteme */

= Wichtige Links =
Hier nur die wichtigsten Links (Hauptdiskussionsthread und andere Wikis), den Rest unter "weitergehende Infos im Netz"
* Disskussionsthread [http://www.mikrocontroller.net/topic/210759 Pollin - Receiver-Mainboard mit Twin DVB-T/C Tuner, NXP PNX8950EH]

= Übersicht Features =
===Betriebssysteme===

*"Windows CE 5.0"
**Windows CE Kernel for MIPS Built on Mar 29 2005 at 14:00:54
**Telegent Kernel V0.9.3.16, Built on Sep 4 2006 at 22:23:55

*"MoreTv! Als Medion gelabelt"
** How to fläsch
**1. SW1 auf ON (DIL Schalter auf Pollin Board)
**2. Inhalt von [http://www.mikrocontroller.net/attachment/105209/swu.zip WCE1] auf USB-Stick (Fat32) kopieren und HINTEN an den Receiver stecken.
**3. Receiver hinten am Netzteil einschalten
**4. Am Receiver vorne auf Power drücken. Bei Fehlermeldung auf Bildschirm: Anderen USB Stick probieren und/oder Receiver per Fernbedienung einschalten. Wenn alles funktioniert, erscheint eine Anzeige auf dem Bildschirm, daß das Update durchgeführt wird und man den Receiver nicht ausschalten soll, bis das Update eingespielt ist. Falls irgend etwas falsch läuft, startet das Windows CE und zeigt den Telegen-Desktop. Dann nochmal alles überprüfen.
**5. Nach kurzer Zeit (1 Minute oder 2) erscheint eine Meldung SW Update succeeded oder so, habe ich schon wieder vergessen.
**6. Receiver am Netzteil ausschalten.
**7. SW1 auf OFF setzen.

*"Linux"
:Der uC wird pauschal von Linux unterstützt.
:Interessante Versionen zum weiteren Testen sind:
**Dreambox Image
**elecard firmware
**MontaVista Linux Professional Edition

===Unterstützte Codecs===

*dual:
:SD MPEG-1/2
*single:
:SD MPEG-4, WM9, H264,DivX; HD MPEG-2 (1080i), WM9(720p)

*Audio:
:dual stereo (2.0 + 2.0),MPEG-1, Dolby AC-3

[http://www.synnex.com.tw/oem/mic_link/seminar%20download/y70303.pdf Quelle Codecs]

= Bezugsquellen =

===Platinen:===
* [http://www.pollin.de/shop/dt/NzQ5OTA2OTk-/Bausaetze_Module/Module/Receiver_Mainboard_mit_Twin_DVB_T_Tuner.html Pollin : Receiver-Mainboard mit Twin DVB-T Tuner (390 052, 7,95€)]
* [http://www.pollin.de/shop/dt/NjQ5OTA2OTk-/Bausaetze_Module/Module/Receiver_Mainboard_mit_Twin_DVB_C_Tuner.html Pollin : Receiver-Mainboard mit Twin DVB-C Tuner (390 053, 7,95€)]
* [http://www.pollin.de/shop/dt/MzQxODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/RS232_Einbaubuchse.html Pollin : RS232-Einbaubuchse (721 856, 0,25€)]
* [http://www.pollin.de/shop/dt/NDQxODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/USB_2_0_Einbaubuchse.html Pollin : USB 2.0-Einbaubuchse (721 855, 0,25€)]

===Zubehör:===
*[http://www.pollin.de/shop/dt/NjUwOTQ2OTk-/Stromversorgung/Netzgeraete/Festspannungs_Netzgeraete/Schaltnetzteil_DELTA_EADP_50DF_12_V_4_16_A.html Pollin : Schaltnetzteil DELTA EADP-50DF, 12 V-/4,16 A (350 943 , 4,95€)]
*[http://www.pollin.de/shop/dt/MDg4OTM1OTk-/Bauelemente_Bauteile/Gehaeuse/Stahlblech_Gehaeuse_mit_Frontblende.html Pollin : Stahlblech-Gehäuse mit Frontblende (460 119, 2,95€)]
*[http://www.pollin.de/shop/dt/Nzc5OTczOTk-/SAT_Antennentechnik/Satelliten_Technik/Fernbedienungen/Infrarot_Fernbedienung_RCX155.html Pollin : Infrarot-Fernbedienung RCX155 (620 022, 1,95€)]
*[http://www.pollin.de/shop/dt/NDY5ODgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/WLAN_miniPCI_Karte_XG_603.html Pollin : WLAN miniPCI-Karte XG-603 (711 035, 3,95€)]
*[http://www.pollin.de/shop/dt/MzQ3ODI0OTk-/SAT_Antennentechnik/Kabel/Antennen_Anschlusskabel_75_150_mm.html Pollin : Antennen-Anschlusskabel 75 Ω, 150 mm (571 256, 0,15€)]
*Pollin : SATA-Kabel, 2x SATA-Stecker, 0,35m (721 854, 0,50€)]
*[http://www.pollin.de/shop/dt/NDI1ODcyOTk-/Computer_und_Zubehoer/Hardware/Kabel_Stecker_Adapter/SATA_Stromversorgungsadapter.html Pollin : SATA-Stromversorgungsadapter (721 475, 0,85)]
*Pollin : PC-Stromversorgungskabel, 2x 5,25"- Stecker, 70mm (720 569, 0,20€)]
*[http://www.pollin.de/shop/dt/MjUwOTgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Antennen_Adapterkabel.html Pollin : Wireless LAN Antennen-Adapterkabel (710 947, 4,95€)]
*[http://www.pollin.de/shop/dt/NjAwOTgyOTk-/Computer_und_Zubehoer/Netzwerktechnik/Wireless_LAN/Wireless_LAN_Rundstrahl_Antenne.html Pollin : Wireless LAN Rundstrahl-Antenne (710 993, 1,95€)]

= Hardware =
== Daten ==
* Betriebsspannung 12 V-
* Stromaufnahme ohne HDD max. 2 A
* 2x Philips DVB-T Tuner TU1216L/IVP
* HDD-Stromversorgung on Board
* Anschlüsse extern: 2x Tuner In, 2x Tuner Out, LAN 10/100 Mbps, USB 2.0, optischer Audioausgang, AV-Out (Cinch), S-Video, 2x Scart
* interne Ports/Anschlüsse: 3x USB 2.0, 2x SATA, RS232, miniPCI für WLAN-Karte (XG-603), Smartcard-Reader, CI-Slot

* Flash Hynix HY27US08121A 8bit 64MByte 2.7V - 3.6 Volt

==Varianten==
===DVB-T===
===DVB-C===

== Bilder/Innenleben ==
'''Gesamtansicht'''

[[Bild:moretv_1.jpg|700px]]

'''JTAG Anschluss für LPC921F (unter anderem) + Platz zur Montage einer 3,5" Festplatte'''

[[Bild:moretv_2.jpg|700px]]

'''Board komplett'''

[[Bild:moretv_3.jpg|700px]]

'''DVI - nicht bestückt'''

[[Bild:moretv_4.jpg|700px]]

'''DVB-T Tuner'''

[[Bild:moretv_5.jpg|700px]]

'''CPU RAM etc.'''

[[Bild:moretv_6.jpg|700px]]

'''mini PCI, Sata, CI-Slot, Smartcard'''

[[Bild:moretv_7.jpg|700px]]

'''Rückseite komplett'''

[[Bild:moretv_8.jpg|700px]]

'''CI Controller'''

[[Bild:moretv_9.jpg|700px]]

'''Sata Controller'''

[[Bild:moretv_10.jpg|700px]]

'''RAM und TDA8024T SmartCard Interface'''

[[Bild:moretv_11.jpg|700px]]

'''LAN DP83816''' (fast identisch zu SiS 900)

[[Bild:moretv_12.jpg|700px]]

'''SW1 auf ON = SW-Update / SW2 auf ON = JTAG Enable'''

[[Bild:moretv_13.jpg|700px]]

'''Stromversorgung'''

[[Bild:moretv_14.jpg|700px]]

'''Anschluss J4'''

[[Bild:moretv_15.jpg|700px]]

'''EJTAG für den PNX8950'''

[[Bild:EJTAG.jpg|700px]]

'''Wie man sieht, müssen keinerlei Jumper gesetzt sein, um DVB-T'''
'''empfangen zu können.'''

[[Bild:Tuner_Jumper1.JPG|700px]]

'''RS-232 Console auf J2'''

[[Bild:Console.png|268px]]

'''3,3Volt auf J4'''

[[Bild:lpc_8051_power.png|400px]]

== Schnittstellen ==

3x USB intern: (J30 USB Port4, J31 USB Port3, J46 USB Port2)
Pinout:

PIN4:GND/Schwarz, PIN3:D+/Grün, PIN2:D-/Weiss, Pin1:+5V/Rot

== Chips ==
Übersicht über die verwendeten Bausteine mit Links auf ensprechende Datenblätter, Quellen etc.

* Multimedia-CPU Philips PNX8950EH/M2/S1
**[http://datasheet.octopart.com/PNX8950EH/M2/S1%2C55-NXP-datasheet-8325175.pdf Datasheet PNX8950EH/M2/S1]
**[http://www.brightsign.biz/documents/HD2000HardwareGuide.pdf Brightsign Hardwareguide]
**[http://www.kanecomputing.co.uk/pdfs/mds_mds810.pdf MDS-810]
*[http://www.alldatasheet.com/datasheet-pdf/pdf/98585/SAMSUNG/K4H511638C-UCCC.html 4x 512 MBit DDR SDRAM SAMSUNG K4H511638C-UCCC]
* [http://www.hynix.com/datasheet/pdf/flash/HY27(U_S)S(08_16)121A%20Series(Rev1.3).pdf HYNIX HY27US08121A 512 Mbit NAND Flash]
* [http://www.siliconimage.com/docs/SiI-DS-0102-D.pdf SiI3512 SATA150 Controller]
*[http://www.national.com/ds/DP/DP83816.pdf 10/100 Mbps PCI Ethernet-Controller NATIONAL DP83816]
* High Speed USB PCI Host Controller Philips ISP1561BM [http://www.nxp.com/acrobat_download2/expired_datasheets/ISP1561_2.pdf Datasheet]
* [http://www.maxim-ic.com/datasheet/index.mvp/id/1068 MAX3222]
* PNX8510HW [http://www.datasheetcatalog.org/datasheet/philips/PNX8510_PNX8511_4.pdf Datasheet]
* Bedienteil mit LED-Display, Infrarotempfänger usw.
* In der DVB-C-Version: Philips CU1216 DVB-C Tuner [http://read.pudn.com/downloads138/sourcecode/others/589797/CU1216L-3-datasheet.pdf Datasheet]
** Philips TDA10023 (DVB-C Channel Decoder) [http://www.datasheetdownload.com/download.php?id=677273 Datasheet]
* In der DVB-T-Version: Philips TU1216 DVB-T Tuner
** Philips TDA10046 (DVB-T Channel Decoder) [http://www.nxp.com/acrobat/literature/9397/75009522.pdf Spec Sheet] [http://git.linuxtv.org/media_tree.git?a=blob;f=drivers/media/dvb/frontends/tda1004x.c - linuxtv.org Frontend Treiber]
** Philips TDA6650 (5 V mixer/oscillator and low noise PLL synthesizer for hybrid terrestrial tuner) [http://www.nxp.com/documents/data_sheet/TDA6650TT_6651TT.pdf Datasheet] [http://git.linuxtv.org/media_tree.git?a=blob;f=drivers/media/dvb/frontends/tda665x.c - linuxtv.org Tuner Treiber]
* Philips TDA8024T (IC Card Interface) [http://www.nxp.com/documents/data_sheet/TDA8024.pdf Datasheet]

Nicht bestückte ICs:
* U42 DVI (?)
* U40 ????
* U41 ????
* U44 ????
* U45 ????
* U48 ????
* U51 ????
* U59 ????

= Software =
Übersicht über verwendete Software (Betriebssysteme, Compiler, Tools, etc)

* Bootloader
**Eventuell [http://www.denx.de/wiki/U-Boot/SourceCode U-Boot] support mit diesen 4 patches:
# [http://lists.denx.de/pipermail/u-boot/attachments/20061204/e9922ec2/attachment.obj pnx8550support.diff.gz]
# [http://lists.denx.de/pipermail/u-boot/attachments/20061206/556029b0/attachment.obj nxp_i2c.diff.gz]
# [http://lists.denx.de/pipermail/u-boot/attachments/20061211/bff13619/attachment.obj nxp_pci.diff.gz]
# [http://lists.denx.de/pipermail/u-boot/attachments/20061211/8d42666e/attachment.obj mips_timer2.diff]
<pre>
Overview
+The Silverbox is a development platform based on the NXP PNX8550
+(Nexperia) media processor. It consists of a MIPS32 compatible PR4450
+core, accompanied by two TriMedia processors. Typical use for the
+PNX8550 is in settop box and advanced analogue and digital TV sets.
+
+This first version of U-Boot for this platform supports a minimal set
+of commands and hardware. Feature to be added in the near future are
+PCI bus, Ethernet, NAND flash and USB support.
+
+Boot Methods
+U-Boot for the Silverbox is typically loaded into SDRAM using an EJTAG
+probe. The load address and entry point is 0xA0010000.
+
+As NAND flash support is not yet available a single page NAND flash
+loader is also not available. This limits this U-Boot version, but
+a single page loader based on U-Boot 1.1.3 is available on request.
</pre>
Screenshot der Windows CE 5.0 Oberfläche (über VNC mit der Box verbunden http://efonvnc.sourceforge.net/)

[[Datei:CEscreenshot.png]]

= Anwendungen und Ideen =
==Realisierte Projekte/Anwendungen==
==Anwendungsideen==

'''Unter Linux:'''
Festplattenreceiver,
Asterisk Server,
NAS,
Car-PC,
Multimedia Client/Server,
Wetterstation logging Server,
Solar logging Server

'''Unter WinCE''':
Festplattenreceiver,
NAS,
Car-PC,
Media Portal Client/Server

= weitergehende Infos im Netz =
Alles was noch weiterführende Infos bietet. Andere Wikis, Beiträge, etc.

* [http://www.oohito.com/wince/mips_o_j.htm MIPS FTP Server]

[[Kategorie:Projekte]]

Minila Version MockUp

2011-02-27T12:13:39Z

Remote1: /* Software */

== Bilder der Platine ==
=== Gerenderte Platine ===
[[Bild:MockUpMiniLALayoutTop.jpg|400px]]
[[Bild:MockUpMiniLALayoutBottom.jpg|400px]]

=== Platine der Sammelbestellung bestückt ===
[[Bild:MockUpMiniLALayoutTopPrototyp.jpg|400px]]
[[Bild:MockUpMiniLALayoutBottomPrototyp.jpg|400px]]

== Informationen über den MiniLA ==

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== RAM-Speicher ===
512K*32:
* 512K*32 Kanäle
* TQFP100 0,65mm Pinabstand
* GS816036
* [http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]
* wird in der Sammelbestellung verwendet

1M*32:
* 1M*32 Kanäle
* TQFP100 0,65mm Pinabstand
* CY7C1441AV33-133AXC/CY7C1441AV33-133AXI
* 60eur/stk
* dazu muss eine Brücke zwischen TP1 am CPLD und TP2 am SRAM eingelötet werden
[[Bild:MockUpMiniLALayout1MBitRAM.png|200px]]

=== USB ===
Der FTDI FT2232D wird immer im Bus Powerd Modus betrieben und über USB versorgt.

=== Spannungsversorgung ===
* 3,3V, Versorgung über externe 5V bis 16V oder über den DCDC USB powered (Regler wird über den FTDI An/Aus geschaltet)
* 5V über DCDC (galvanisch getrennt) mit Spannungsregler dahinter oder DCDC überbrückt direkt über USB

Dadurch kann der MiniLA mit einem Y-Kabel USB versorgt werden oder über ein externes Netzteil.

=== Galvanische Trennung ===
Als Zusatzoption über den ADUM4160, einem DCDC-Wandler und einem zusätzlichem Spannungsregler.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt (siehe auch: Platinen)

=== JTAG ===
* JTAG-Signale liegen an einem MicroMatch Steckverbinder an.
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale liegen an einem MicroMatch Steckverbinder an

=== LEDs ===
Je nach Wunsch in SMD 0805 oder als 5mm LED

=== Gehäuse ===
Passende Gehäusen:
* Hammond 1455L1602 (Mouser, RS, Conrad usw.)
* Fischer AKG 105 30 160 (RS, DK, Conrad usw.)
* Fischer AKG 105 34 160 (RS, DK, Conrad usw.)
* RFS RF-1599 (rfsupplier.com)

Auch 3,5" USB/eSATA Festplatten-Gehäuse sind bestens geeignet.

== Schaltplan und Layout ==
=== Schaltplan ===
'''Seite 1 & 2''' 
[[Bild:MockUpMiniLASchaltplanSheet1.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet2.png|350px]]

'''Seite 3 & 4''' 
[[Bild:MockUpMiniLASchaltplanSheet3.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet4.png|350px]]

'''Seite 5 & 6''' 
[[Bild:MockUpMiniLASchaltplanSheet5.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet6.png|350px]]

'''Seite 7''' 
[[Bild:MockUpMiniLASchaltplanSheet7.png|350px]]

=== Layout ===
''' Platine Mini-LA ''' 
[[Bild:MockUpMiniLALayoutEagleTop.png.png|350px]]
[[Bild:MockUpMiniLALayoutEagleBottom.png|350px]]
* 2-lagig
* über den 5mm LEDs sind die SMD0805 LEDs angeordnet
* [[Datei:MiniLAVersionMockUpV1_05a.zip]]
* [[Datei:MiniLAVersionMockUpTeileliste.zip]]
''' Platine Tastköpfe '''
* Sind über Wigbert zu beziehen. Er hat noch Tastköpfe von der ersten Sammelbestellung.

=== Steckverbinder auf der Platine ===
{| class="wikitable"
|+ '''Steckverbinder'''
|-
! || nicht gesteckt || gesteckt 1-2 || gesteckt 2-3
|-
| JP2 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP3 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP4 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP5 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP6 || - || - || -
|-
| JP7 || Platine "AUS" || Platine "AN" || -
|-
| JP9 || - || externe Versorgung || USB Versorgung
|}

JP6 - Spannungsversorgung für einen Externen Programmieradapter ('''nicht Brücken!''')

== Erste Inbetriebnahme ==
* 1. Platine liegt unangeschlossen (ohne USB und externe Versorgung) vor euch
* 2. Jumper JP7 stecken (USB-Interface wird mit Strom versorgt)
* 3. Jumper JP9 nicht stecken (CPLD wird erstmal nicht mit Strom versorgt, der Sicherheit halber)
* 4. USB-Kabel anschließen, LED7 sollte AN und LED8 Aus sein, FTDI sollte sich am PC anmelden
* 4.1 Wenn er nicht erkannt wird, Spannung über C45 ~9V, Spannung über C46 5V, Alles um IC4, IC5 und IC6 prüfen
* 5. [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#FTDI FTDI-Treiber installieren]
* 6. [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#LibUSB LibUSB installieren]
* 7. MiniLA vom PC trennen
* 8. [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#Steckverbinder_auf_der_Platine JP9 nach Wahl stecken]
* 9. [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#Steckverbinder_auf_der_Platine JP2-JP5] auf 2-3 stecken (wenn der USB-Stecker links, dann sind das die unteren Kontakte
*10. [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#Firmware schon mal alles vorbereiten, in den Ordner wechseln, alles eintippen]
*11. eventuell externe Versorgung und USB-Kabel anstecken, LED8 sollte nun auch leuchten
*12. Enter drücken, CPLD sollte programmiert werden.

Hinweis: Der Spannungsregler für die 3,3V wird erst eingeschaltet wenn die USB-Verbindung steht und Windows den FTDI erkannt hat. LED8 leuchtet dann auch.

== Programmierung ==
[[Image:MiniLAVersionMockUpFTPROG1.png|thumb|150px|right|Programmierung des FTDIs, Bild1]][[Image:MiniLAVersionMockUpFTPROG2.png|thumb|150px|right|Programmierung des FTDIs, Bild2]]
=== FTDI ===
Zum Programmieren werden die [http://www.ftdichip.com/Drivers/D2XX.htm FTDI-Treiber für D2XX] und das Programm [http://www.ftdichip.com/Support/Utilities.htm FT_PROG] benötigt.

*1. MiniLA über ein USB Kabel an den PC anschließen und die heruntergeladenen FTDI-Treiber Installieren
*2. Das Programm FT_PROG starten
*3. Im Programm auf "Scan and Parse" drücken (1)(Bild1)
*4. rechte Maustaste auf den erkannten FTDI, "Aply Template" und "From File" [http://www.mikrocontroller.net/attachment/95887/MiniLA.xml diese Datei] auswählen (2)(Bild1)
*5. Im Programm auf "Program Devices" drücken (3)(Bild1), ein neues Fenster öffnet sich (Bild2)
*6. Haken setzen (4)(Bild2)
*7. Auf "Program" drücken (5)(Bild2)
*8. MiniLA abstecken und wieder anklemmen
*9. Fertig

=== LibUSB ===
[[Image:MiniLAVersionMockUplibUSB1.png|thumb|150px|right|LibUSB einrichten, Bild1]][[Image:MiniLAVersionMockUplibUSB2.png|thumb|150px|right|LibUSB einrichten, Bild2]]
'''Mit der [http://www.mikrocontroller.net/attachment/96598/xc3sprog.exe neuen xc3sprog Revision 483] ist LibUSB nicht mehr notwendig. Dieses greift direkt auf den FTDI-Treiber zu.'''

LibUSB funktioniert nur unter 32Bit Windows.
Zur Programmierung des CPLDs über xc3prog wurde LibUSB benötigt. Dies bekommt man [http://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/ hier]. Die letzte Version anklicken und dann "libusb-win32-bin-x.x.x.x.zip" herunterladen und entpacken.
*1. In den Ordner "bin" und "x86" für Windows XP 32Bit wechseln
*2. "install-filter-win.exe" starten
*3. "Install a device filter" und "Next" drücken
*4. In der Liste auf "USB Serial Converter A" drücken (1) und danach auf Install (2) (Bild1)
*5. In der Liste auf "USB Serial Converter B" drücken (3) und danach noch einmal auf Install (4) (Bild2)
*6. Mit "Cancel" (5) Abbrechen (Bild2)
*7. Fertig

Es gibt im Forum auch eine Version von xc3sprog, die kein libusb benötigt http://www.mikrocontroller.net/topic/174860#1995201

=== Firmware ===
[[Image:MiniLAVersionMockUpxc3prog.png|thumb|150px|right|Programmierung des CPLDs]]
Zum Programmieren wird [http://sourceforge.net/projects/xc3sprog/ xc3sprog] benötigt. [http://www.mikrocontroller.net/attachment/96598/xc3sprog.exe Hier eine angepasste Version (Mit der anderen gab es Probleme beim CPLD löschen).]

*1. Auf dem MiniLA die Jumper JP2-JP5 in die Stellung [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#Steckverbinder_auf_der_Platine 2-3] umstecken und den MiniLA anschließen.
*2. Kommandozeile öffnen
*3. In den Ordner wechseln, in der xc3prog und die jed-Datei liegt. (Die jed-Datei aus dem Archiv "Timeanalysis" bzw. "Stateanalysis" - siehe weiter unten - extrahieren. Sie ist im Ordner xilinx zu finden.)
*4. "xc3sprog -c ftdi -v miniLA.jed" eingeben und Enter drücken.
*5. Der FTDI sollte programmiert werden, ähnlich dem nebenstehendem Bild.

'''Hilfreiche Befehle'''
* "xc3sprog -c ftdi -v -j" - Erkennung des CPLDs
* "xc3sprog -c ftdi -v -e" - Löschen des CPLDs

'''Die Firmware ist nur lauffähig mit der Version des MockUp MiniLAs und es sollte auch keine der originalen Firmwares verwendet werden, weil diese nicht kompatibel sind mit der neuen Hardware!!!'''
* [http://www.mikrocontroller.net/wikifiles/c/c0/MiniLAVersionMockUpFirmwareLEDTest.zip LED-Test] (Blinkfrequenz: ~6,0Hz, ~1,5Hz, ~0,4Hz)
* [http://www.mikrocontroller.net/wikifiles/f/f5/Fw_timeanalysis_v1.8_for_MockUp_miniLA.zip Timeanalysis v1.8]
* [http://www.mikrocontroller.net/wikifiles/2/27/Fw_stateanalysis_v2.3_for_MockUp_miniLA.zip Stateanalysis v2.3]

{| class="wikitable"
|+ '''LED-Bedeutungen'''
|-
! || LED1 || LED3 || LED5
|-
| nach dem Einschalten
| style="text-align:center" | X || ||
|-
| Idle
| style="text-align:center" | X || ||
|-
| Pre-Trigger
||
| style="text-align:center" | X ||
|-
| Wait for Trigger || ||
| style="text-align:center" | X
|-
| Trigger || ||
| style="text-align:center" | X
|-
| Post-Trigger||
| style="text-align:center" | X ||
|-
| Transfer zum PC
| style="text-align:center" | X
| style="text-align:center" | X
| style="text-align:center" | X
|}

== Software ==

Minila Windows EXE Vers 0.6.4 für 256k und 512K Sample Speicher gibts hier
http://www.mikrocontroller.net/attachment/97534/minila.zip 
[[Media: inpout32.dll | Programmbibliothek, welche für die Nutzung der Software benötigt wird]] 

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

[[Kategorie:Projekte]]

Datei:Inpout32.zip

2011-02-27T12:12:21Z

Remote1:

AVR-Tutorial: Arithmetik8

2011-02-09T14:48:52Z

Remote1: /* Die Umwandlung von Dezimal in das Binärsystem */

Eine der Hauptaufgaben eines Mikrokontrollers bzw. eines Computers allgemein, ist es, irgendwelche Berechnungen anzustellen. Der Löwenanteil an den meisten Berechnungen entfällt dabei auf einfache Additionen bzw. Subtraktionen. Multiplikationen bzw. Divisionen kommen schon seltener vor, bzw. können oft durch entsprechende Additionen bzw. Subtraktionen ersetzt werden. Weitergehende mathematische Konstrukte werden zwar auch ab und an benötigt, können aber in der Assemblerprogrammierung durch geschickte Umformungen oft vermieden werden.

== Hardwareunterstützung ==

Praktisch alle Mikroprozessoren unterstützen Addition und Subtraktion direkt in Hardware, das heißt: Sie haben eigene Befehle dafür. Einige bringen auch Unterstützung für eine Hardwaremultiplikation mit (so zum Beispiel der [[ATmega8]]), während Division in Hardware schon seltener zu finden ist.

== 8 Bit versus 16 Bit ==

In diesem Abschnitt des Tutorials wird gezielt auf 8 Bit Arithmetik eingegangen, um zunächst die Grundlagen des Rechnens mit einem µC zu zeigen. Die Erweiterung von 8 Bit auf 16 Bit Arithmetik ist in einigen Fällen wie Addition und Subtraktion trivial, kann sich aber bei Multiplikation und Division in einem beträchtlichen Codezuwachs niederschlagen.

Der im Tutorial verwendete ATmega8 besitzt eine sog. 8-Bit Architektur. Das heißt, dass seine Rechenregister (mit Ausnahmen) nur 8 Bit breit sind und sich daher eine 8-Bit Arithmetik als die natürliche Form der Rechnerei auf diesem Prozessor anbietet. Berechnungen, die mehr als 8 Bit erfordern, müssen dann durch Kombinationen von Rechenvorgängen realisiert werden. Eine Analogie wäre z. B. das Rechnen, wie wir alle es in der Grundschule gelernt haben. Auch wenn wir in der Grundschule (in den Anfängen) nur die Additionen mit Zahlen kleiner als 10 auswendig gelernt haben, so können wir dennoch durch die Kombination von mehreren derartigen Additionen beliebig große Zahlen addieren. Das gleiche gilt für Multiplikationen. In der Grundschule musste wohl jeder von uns das 'Kleine Einmaleins' auswendig lernen, um Multiplikationen im Zahlenraum bis 100 quasi 'in Hardware' zu berechnen. Und doch können wir durch Kombinationen solcher Einfachmultiplikationen und zusätzlichen Additionen in beliebig große Zahlenräume vorstoßen.

Die Einschränkung auf 8 Bit ist also keineswegs eine Einschränkung in dem Sinne, dass es eine prinzipielle Obergrenze für Berechnungen gäbe. Sie bedeutet lediglich eine obere Grenze dafür, bis zu welchen Zahlen in einem Rutsch gerechnet werden kann. Alles, was darüber hinausgeht, muss dann mittels Kombinationen von Berechnungen gemacht werden.

== 8-Bit Arithmetik ohne Berücksichtigung eines Vorzeichens ==

Die Bits des Registers besitzen dabei eine Wertigkeit, die sich aus der Stelle des Bits im Byte ergibt. Dies ist völlig analog zu dem uns vertrauten Dezimalsystem. Auch dort besitzt eine Ziffer in einer Zahl eine bestimmte Wertigkeit, je nach dem, an welcher Position diese Ziffer in der Zahl auftaucht. So hat z. B. die Ziffer 1 in der Zahl 12 die Wertigkeit 'Zehn', während sie in der Zahl 134 die Wertigkeit 'Hundert' besitzt. Und so wie im Dezimalsystem die Wertigkeit einer Stelle immer das Zehnfache der Wertigkeit der Stelle unmittelbar rechts von ihr ist, so ist im Binärsystem die Wertigkeit einer Stelle immer das 2-fache der Stelle rechts von ihr.

Die Zahl 4632 im Dezimalsystem kann also so aufgefasst werden:

4632 = 4 * 1000 ( 1000 = 10 hoch 3 )
+ 6 * 100 ( 100 = 10 hoch 2 )
+ 3 * 10 ( 10 = 10 hoch 1 )
+ 2 * 1 ( 1 = 10 hoch 0 )

=== Die Umwandlung von Binär in das Dezimalystem ===

Völlig analog ergibt sich daher folgendes für z. B. die 8 Bit Binärzahl 0b10011011 (um Binärzahlen von Dezimalzahlen zu unterscheiden, wird ein 0b vorangestellt):

0b10011011 = 1 * 128 ( 128 = 2 hoch 7 )
+ 0 * 64 ( 64 = 2 hoch 6 )
+ 0 * 32 ( 32 = 2 hoch 5 )
+ 1 * 16 ( 16 = 2 hoch 4 )
+ 1 * 8 ( 8 = 2 hoch 3 )
+ 0 * 4 ( 4 = 2 hoch 2 )
+ 1 * 2 ( 2 = 2 hoch 1 )
+ 1 * 1 ( 1 = 2 hoch 0 )

Ausgerechnet (um die entsprechende Dezimalzahl zu erhalten) ergibt das
128 + 16 + 8 + 2 + 1 = 155. Die Binärzahl 0b10011011 entspricht also der Dezimalzahl 155. Es ist wichtig, sich klar zu machen, dass es zwischen Binär- und Dezimalzahlen keinen grundsätzlichen Unterschied gibt. Beides sind nur verschiedene Schreibweisen für das Gleiche: Eine Zahl. Während wir Menschen an das Dezimalsystem gewöhnt sind, ist das Binärsystem für einen Computer geeigneter, da es nur aus den 2 Ziffern 0 und 1 besteht, welche sich leicht in einem Computer darstellen lassen (Spannung, keine Spannung).

Welches ist nun die größte Zahl, die mit 8 Bit dargestellt werden kann? Dabei handelt es sich offensichtlich um die Zahl 0b11111111. In Dezimalschreibweise wäre das die Zahl

0b11111111 = 1 * 128
+ 1 * 64
+ 1 * 32
+ 1 * 16
+ 1 * 8
+ 1 * 4
+ 1 * 2
+ 1 * 1

oder ausgerechnet: 255

Wird also mit 8 Bit Arithmetik betrieben, wobei alle 8 Bit als signifikante Ziffern benutzt werden (also kein Vorzeichenbit, dazu später mehr), so kann damit im Zahlenraum 0 bis 255 gerechnet werden.

Binär Dezimal Binär Dezimal

0b00000000 0 0b10000000 128
0b00000001 1 0b10000001 129
0b00000010 2 0b10000010 130
0b00000011 3 0b10000011 131
0b00000100 4 0b10000100 132
0b00000101 5 0b10000101 133
... ...
0b01111100 124 0b11111100 252
0b01111101 125 0b11111101 253
0b01111110 126 0b11111110 254
0b01111111 127 0b11111111 255

=== Die Umwandlung von Dezimal in das Binärsystem ===

Aus dem vorhergehenden ergibt sich völlig zwanglos die Vorschrift, wie Binärzahlen ins Dezimalsystem umgewandelt werden können (nicht vergessen: Die Zahl selber wird ja gar nicht verändert. Binär- und Dezimalsystem sind ja nur verschiedene Schreibweisen): Durch Anwendung der Vorschrift, wie denn eigentlich ein Stellenwertsystem aufgebaut ist.
Aber wie macht man den umgekehrten Schritt, die Wandlung vom Dezimal ins Binärsystem. Der Weg führt über die Umkehrung des vorhergehenden Prinzips. Fortgesetzte Division durch 2

Es sei die Zahl 92 ins Binärsystem zu wandeln.

92 / 2 = 46 Rest 0
46 / 2 = 23 Rest 0
23 / 2 = 11 Rest 1
11 / 2 = 5 Rest 1
5 / 2 = 2 Rest 1
2 / 2 = 1 Rest 0
1 / 2 = 0 Rest 1

Die Division wird solange durchgeführt, bis sich ein Divisionergebnis von 0 ergibt. Die Reste, von unten nach oben gelesen, ergeben dann die Binärzahl. Die zu 92 gehörende Binärzahl lautet also 1011100. Es wird noch eine führende 0 ergänzt um sie auf die standardmässigen 8-Bit zu bringen: 0b01011100.

== 8-Bit Arithmetik mit Berücksichtigung eines Vorzeichens ==

Soll mit Vorzeichen (also positiven und negativen Zahlen) gerechnet werden, so erhebt sich die Frage: Wie werden eigentlich positive bzw. negative Zahlen dargestellt? Alles was wir haben sind ja 8 Bit in einem Byte.

=== Problem der Kodierung des Vorzeichens ===

Die Lösung des Problems besteht darin, dass ein Bit zur Anzeige des Vorzeichens benutzt wird. Im Regelfall wird dazu das am weitesten links stehende Bit benutzt. Von den verschiedenen Möglichkeiten, die sich hiermit bieten, wird in der Praxis fast ausschließlich mit dem sog. 2-er Komplement gearbeitet, da es Vorteile bei der Addition bzw. Subtraktion von Zahlen bringt. In diesem Fall muß nämlich das Vorzeichen einer Zahl überhaupt nicht berücksichtigt werden. Durch die Art und Weise der Bildung von negativen Zahlen kommt am Ende das Ergebnis mit dem korrekten Vorzeichen heraus.

=== 2-er Komplement ===

Das 2-er Komplement verwendet das höchstwertige Bit eines Byte, das sog. MSB (= Most Significant Bit) zur Anzeige des Vorzeichens. Ist dieses Bit 0, so ist die Zahl positiv. Ist es 1, so handelt es sich um eine negative Zahl. Die 8-Bit Kombination 0b10010011 stellt also eine negative Zahl dar, wenn und nur wenn diese Bitkombination überhaupt als vorzeichenbehaftete Zahl aufgefasst werden soll. Anhand der Bitkombination alleine ist es also nicht möglich, eine definitive Aussage zu treffen, ob es sich um eine vorzeichenbehaftete Zahl handelt oder nicht. Erst wenn durch den Zusammenhang klar ist, dass man es mit vorzeichenbehafteten Zahlen zu tun hat, bekommt das MSB die Sonderbedeutung des Vorzeichens.

Um bei einer Zahl das Vorzeichen zu wechseln, geht man wie folgt vor:
* Zunächst wird das 1-er Komplement gebildet, indem alle Bits umgedreht werden. Aus 0 wird 1 und aus 1 wird 0
* Danach wird aus diesem Zwischenergebnis das 2-er Komplement gebildet, indem noch 1 addiert wird.

Diese Vorschrift kann immer dann benutzt werden, wenn das Vorzeichen einer Zahl gewechselt werden soll. Er macht aus positiven Zahlen negative und aus negativen Zahlen positive.

'''Beispiel:''' Es soll die Binärdarstellung für -92 gebildet werden. Dazu benötigt man zunächst die Binärdarstellung für +92, welche 0b01011100 lautet. Diese wird jetzt nach der Vorschrift für 2-er Komplemente negiert und damit negativ gemacht.

0b01011100 Ausgangszahl
0b10100011 1-er Komplement, alle Bits umdrehen
0b10100100 noch 1 addieren

Die Binärdarstellung für -92 lautet also 0b10100100. Das gesetzte MSB weist diese Binärzahl auch tatsächlich als negative Zahl aus.

'''Beispiel:''' Gegeben sei die Binärzahl 0b00111000, welche als vorzeichenbehaftete Zahl anzusehen ist. Welcher Dezimalzahl entspricht diese Binärzahl?

Da das MSB nicht gesetzt ist, handelt es sich um eine positive Zahl und die Umrechnung kann wie im Fall der vorzeichenlosen 8-Bit Zahlen erfolgen. Das Ergebnis lautet also +56 ( = 0 * 128 + 0 * 64 + 1 * 32 + 1 * 16 + 1 * 8 + 0 * 4 + 0 * 2 + 0 * 1 )

'''Beispiel:''' Gegeben sei die Binärzahl 0b10011001, welche als vorzeichenbehaftete Zahl anzusehen ist. Welcher Dezimalzahl entspricht diese Binärzahl?

Da das MSB gesetzt ist, handelt es sich um eine negative Zahl. Daher wird diese Zahl zunächst negiert um dadurch eine positive Zahl zu erhalten.

0b10011001 Originalzahl
0b01100110 1-er Komplement, alle Bits umdrehen
0b01100111 2-er Komplement, noch 1 addiert

Die zu 0b10011001 gehörende positive Binärzahl lautet also 0b01100111. Da es sich um eine positive Zahl handelt, kann sie wiederum ganz normal, wie vorzeichenlose Zahlen, in eine Dezimalzahl umgerechnet werden. Das Ergebnis lautet 103 ( = 0 * 128 + 1 * 64 + 1 * 32 + 0 * 16 + 0 * 8 + 1 * 4 + 1 * 2 + 1 * 1). Da aber von einer negativen Zahl ausgegangen wurde, ist 0b10011001 die binäre Darstellung der Dezimalzahl -103.

'''Beispiel:''' Gegeben sei dieselbe Binärzahl 0b10011001. Aber diesmal sei sie als vorzeichenlose Zahl aufzufassen. Welcher Dezimalzahl entspricht diese Binärzahl?

Da die Binärzahl als vorzeichenlose Zahl aufzufassen ist, hat das MSB keine spezielle Bedeutung. Die Umrechnung erfolgt also ganz normal: 0b10011001 = 1 * 128 + 0 * 64 + 0 * 32 + 1 * 16 + 1 * 8 + 0 * 4 + 0 * 2 + 1 * 1 = 153.

'''Beispiel:''' Wie lautet die Binärzahl zu -74?

Da es sich hier offensichtlich im eine vorzeichenbehaftete Zahl handelt, müssen die Regeln des 2-er Komplemnts angewendet werden. Zunächst ist also die Binärrepräsentierung von +74 zu bestimmen, welche dann durch Anwendung des 2-er Komplements negiert wird.

74 / 2 = 37 Rest 0
37 / 2 = 18 Rest 1
18 / 2 = 9 Rest 0
9 / 2 = 4 Rest 1
4 / 2 = 2 Rest 0
2 / 2 = 1 Rest 0
1 / 2 = 0 Rest 1

Die Binärdarstellung für +74 lautet daher 0b01001010

0b01001010 +74
0b10110101 1-er Komplement, alle Bits umdrehen
0b10110110 noch 1 addieren

Die Binärdarstellung für -74 lautet daher 0b10110110

== Arithmetikflags ==

Im Statusregister des Prozessors gibt es eine Reihe von Flags, die durch Rechenergebnisse beeinflusst werden, bzw. in Berechnungen einfließen können.

=== Carry ===
Das Carry-Flag '''C''' zeigt an, ob bei einer Berechnung mit vorzeichenlosen Zahlen ein Über- oder Unterlauf erfolgt ist, d.h. das Ergebnis der Berechnung liegt außerhalb des darstellbaren Bereiches 0...255.

Wie das?

Angenommen es müssen zwei 8-Bit-Zahlen addiert werden.

10100011
+ 11110011
---------
110010110

Das Ergebnis der Addition umfasst neun Bit und liegt außerhalb des in einem Register darstellbaren Zahlenbereiches 0...255; die Addition ''ist übergelaufen''. Werden dieselben Zahlen subtrahiert,

10100011
- 11110011
---------
10110000

verbleibt an der höchstwertigsten Stelle ein "geborgtes" Bit, welches durch das Carry angezeigt wird.

=== Signed- und Overflowflag ===
Wird mit vorzeichenbehafteten Zahlen gerechnet, so wird das Verlassen des 8-Bit-Zahlenbereiches -128...+127 durch die Flags '''S''' und '''V''' angezeigt. Der Prozessor selbst unterscheidet nicht zwischen vorzeichenlosen und -behafteten Zahlen. Der Programmierer legt durch Wahl der ausgewerteten Flags (C bei vorzeichenlosen bzw. S/V bei vorzeichenbehafteten) die Interpretation der Zahlen fest.

=== Weitere Flags ===
Das Zero-Flag '''Z''' wird gesetzt, wenn das 8-Bit-Ergebnis der Berechnung null ist. Dies kann bei der Addition auch durch Überlauf geschehen, was durch zusätzliches Carryflag angezeigt wird.

Das Negative-Flag '''N''' wird gesetzt, wenn im Ergebnis das höchstwertige Bit gesetzt ist. Bei vorzeichenbehafteter Arithmetik ist dies als negative Zahl zu interpretieren, sofern nicht durch das V-Flag ein Verlassen des Zahlbereichs angezeigt wird.

Das Half-Carry-Flag '''H''' zeigt, analog zum Carry-Flag, einen Übertrag zwischen Bit 3 und 4 an. Dies kann in speziellen Anwendungen (z. B. zwei simultane Vier-Bit-Berechnungen mit einem Befehl) nützlich sein.

=== Übersicht über die arithmetischen Flags ===

Ergebnis des Befehls '''ADD Rd, Rr'''

Rr| 0 | 1 | 64 | 127 | 128 | 129 | 192 | 255
Rd |( +0)|( +1)|( +64)|(+127)|(-128)|(-127)|( -64)|( -1)
----------+------+------+------+------+------+------+------+------
0 ( +0)| Z | | | |S N |S N |S N |S N
1 ( +1)| | | | VN |S N |S N |S N | CZ
64 ( +64)| | | VN | VN |S N |S N | CZ | C
127 (+127)| | VN | VN | VN |S N | CZ | C | C
128 (-128)|S N |S N |S N |S N |SV CZ |SV C |SV C |SV C
129 (-127)|S N |S N |S N | CZ |SV C |SV C |SV C |S NC
192 ( -64)|S N |S N | CZ | C |SV C |SV C |S NC |S NC
255 ( -1)|S N | CZ | C | C |SV C |S NC |S NC |S NC

Man erkennt: C=1 genau dann wenn die Addition Rd + Rr mit vorzeichenlosen Zahlen überläuft. V=1 genau dann wenn die Addition mit vorzeichenbehafteten Zahlen überläuft.

Ergebnis des Befehls '''SUB Rd, Rr''' bzw. '''CP Rd, Rr'''

Rr| 0 | 63 | 64 | 127 | 128 | 191 | 192 | 255
Rd |( +0)|( +63)|( +64)|(+127)|(-128)|( -65)|( -64)|( -1)
----------+------+------+------+------+------+------+------+------
0 ( +0)| Z |S NC |S NC |S NC | VNC | C | C | C
63 ( +63)| | Z |S NC |S NC | VNC | VNC | C | C
64 ( +64)| | | Z |S NC | VNC | VNC | VNC | C
127 (+127)| | | | Z | VNC | VNC | VNC | VNC
128 (-128)|S N |SV |SV |SV | Z |S NC |S NC |S NC
191 ( -65)|S N |S N |SV |SV | | Z |S NC |S NC
192 ( -64)|S N |S N |S N |SV | | | Z |S NC
255 ( -1)|S N |S N |S N |S N | | | | Z

Man erkennt: C=1 genau dann wenn die Subtraktion Rd - Rr mit vorzeichenlosen Zahlen unterläuft; äquivalent dazu ist Rd < Rr (vorzeichenlos). S=1 genau dann wenn die Subtraktion mit vorzeichenbehafteten Zahlen unterläuft bzw. Rd > Rr (vorzeichenbehaftet).

== Inkrementieren / Dekrementieren ==

Erstaunlich viele Operationen in einem Computer-Programm entfallen auf die Operationen 'Zu einer Zahl 1 addieren' bzw. 'Von einer Zahl 1 subtrahieren'. Dementsprechend enthalten die meisten Mikroprozessoren die Operationen ''Inkrementieren'' (um 1 erhöhen) bzw. ''Dekrementieren'' (um 1 verringern) als eigenständigen Assemblerbefehl. So auch der ATmega8.

=== AVR-Befehle ===
<avrasm>
inc r16
</avrasm>

bzw.

<avrasm>
dec r16
</avrasm>

Die Operation ist einfach zu verstehen. Das jeweils angegebene Register (hier wieder am Register r16 gezeigt) wird um 1 erhöht bzw. um 1 verringert. Dabei wird die Zahl im Register als vorzeichenlose Zahl angesehen. Enthält das Register bereits die größtmögliche Zahl (0b11111111 oder dezimal 255), so erzeugt ein weiteres Inkrementieren die kleinstmögliche Zahl (0b00000000 oder dezimal 0) bzw. umgekehrt dekrementiert 0 zu 255.

== Addition ==
Auf einem Mega8 gibt es nur eine Möglichkeit, um eine Addition durchzuführen: Die beiden zu addierenden Zahlen müssen in zwei Registern stehen.

=== AVR-Befehle ===
<avrasm>
add r16, r17 ; Addition der Register r16 und r17. Das Ergebnis wird
; im Register r16 abgelegt
adc r16, r17 ; Addition der Register r16 und r17, wobei das Carry-Bit
; noch zusätzlich mit addiert wird.
</avrasm>

Bei der Addition zweier Register wird ein möglicher Überlauf in allen Fällen im Carry Bit abgelegt. Daraus erklärt sich dann auch das Vorhandensein eines Additionsbefehls, der das Carry-Bit noch zusätzlich mitaddiert: Man benötigt ihn zum Aufbau einer Addition die mehr als 8 Bit umfasst. Die niederwertigsten Bytes werden mit einem add addiert und alle weiteren höherwertigen Bytes werden, vom Niederwertigsten zum Höchstwertigsten, mittels adc addiert. Dadurch werden eventuelle Überträge automatisch berücksichtigt.

== Subtraktion ==
Subtraktionen können auf einem AVR in zwei unterschiedlichen Arten ausgeführt werden. Entweder es werden zwei Register voneinander subtrahiert oder es wird von einem Register eine konstante Zahl abgezogen. Beide Varianten gibt es wiederrum in den Ausführungen mit und ohne Berücksichtigung des Carry Flags

=== AVR-Befehle ===

<avrasm>
sub r16, r17 ; Subtraktion des Registers r17 von r16. Das Ergebnis wird
; im Register r16 abgelegt
sbc r16, r17 ; Subtraktion des Registers r17 von r16, wobei das Carry-Bit
; noch zusätzlich mit subtrahiert wird. Das Ergebnis wird
; im Register r16 abgelegt
subi r16, zahl ; Die Zahl (als Konstante) wird vom Register r16 subtrahiert.
; Das Ergebnis wird im Register r16 abgelegt
sbci r16, zahl ; Subtraktion einer konstanten Zahl vom Register r16, wobei
; zusätzlich noch das Carry-Bit mit subtrahiert wird.
; Das Ergebnis wird im Register r16 abgelegt.
</avrasm>

== Multiplikation ==
Multiplikation kann auf einem AVR je nach konkretem Typ auf zwei unterschiedliche Arten ausgeführt werden. Während die größeren ATMega Prozessoren über einen Hardwaremultiplizierer verfügen, ist dieser bei den kleineren Tiny Prozessoren nicht vorhanden. Hier muß die Multiplikation quasi zu Fuß durch entsprechende Addition von Teilresultaten erfolgen.

=== Hardwaremultiplikation ===
Vorzeichenbehaftete und vorzeichenlose Zahlen werden unterschiedlich multipliziert. Denn im Falle eines Vorzeichens darf ein gesetztes 7. Bit natürlich nicht in die eigentliche Berechnung mit einbezogen werden. Statt dessen steuert dieses Bit (eigentlich die beiden MSB der beiden beteiligten Zahlen) das Vorzeichen des Ergebnisses. Die Hardwaremultiplikation ist auch dahingehend eingeschränkt, dass das Ergebnis einer Multiplikation immer in den Registerpärchen ''r0'' und ''r1'' zu finden ist. Dabei steht das LowByte (also die unteren 8 Bit) des Ergebnisses in ''r0'' und das HighByte in ''r1''.

==== AVR-Befehl ====
<avrasm>
mul r16, r17 ; multipliziert r16 mit r17. Beide Registerinhalte werden
; als vorzeichenlose Zahlen aufgefasst.
; Das Ergebnis der Multiplikation ist in den Registern r0 und r1
; zu finden.

muls r16, r17 ; multipliziert r16 mit r17. Beide Registerinhalte werden
; als vorzeichenbehaftete Zahlen aufgefasst.
; Das Ergebnis der Multiplikation ist in den Registern r0 und r1
; zu finden und stellt ebenfalls eine vorzeichenbehaftete
; Zahl dar.

mulsu r16, r17 ; multipliziert r16 mit r17, wobei r16 als vorzeichenbehaftete
; Zahl aufgefasst wird und r17 als vorzeichenlose Zahl.
; Das Ergebnis der Multiplikation ist in den Registern r0 und r1
; zu finden und stellt eine vorzeichenbehaftete Zahl dar.
</avrasm>

=== Multiplikation in Software ===
Multiplikation in Software ist nicht weiter schwierig. Man erinnere sich daran, wie Multiplikationen in der Grundschule gelehrt wurden:
Zunächst stand da das kleine Einmal-Eins, welches auswendig gelernt wurde. Mit diesen Kenntnissen konnten dann auch größere Multiplikationen angegangen werden, indem der Multiplikand mit jeweils einer Stelle des Multiplikators multipliziert wurde und die Zwischenergebnisse, geeignet verschoben, addiert wurden. Die Verschiebung um eine Stelle entspricht dabei einer Multiplikation mit 10.

'''Beispiel:''' Zu multiplizieren sei 3456 * 7812

3456 * 7812
---------------
24192 <-+|||
+ 27648 <--+||
+ 3456 <---+|
+ 6912 <----+
--------
26998272

Im Binärsystem funktioniert Multiplikation völlig analog. Nur ist hier das kleine Einmaleins sehr viel einfacher! Es gibt nur 4 Multiplikationen (anstatt 100 im Dezimalsystem):

0 * 0 = 0
0 * 1 = 0
1 * 0 = 0
1 * 1 = 1

Es gibt lediglich einen kleinen Unterschied gegenüber dem Dezimalsystem: Anstatt zunächst alle Zwischenergebnisse aufzulisten und erst danach die Summe zu bestimmen, werden wir ein neues Zwischenergebnis gleich in die Summe einrechnen. Dies deshalb, da Additionen von mehreren Zahlen im Binärsystem im Kopf sehr leicht zu Flüchtigkeitsfehlern führen (durch die vielen 0-en und 1-en). Weiters wird eine einfache Tatsache benutzt: 1 mal eine Zahl ergibt wieder die Zahl, während 0 mal eine Zahl immer 0 ergibt. Dadurch braucht man im Grunde bei einer Multiplikation überhaupt nicht zu multiplizieren, sondern eigentlich nur die Entscheidung treffen: Muss die Zahl geeignet verschoben addiert werden oder nicht?

0b00100011 * 0b10001001
--------------------------------
00100011 <--+|||||||
+ 00000000 <---+||||||
--------- ||||||
001000110 ||||||
+ 00000000 <----+|||||
---------- |||||
0010001100 |||||
+ 00000000 <-----+||||
----------- ||||
00100011000 ||||
+ 00100011 <------+|||
------------ |||
001001010011 |||
+ 00000000 <-------+||
------------- ||
0010010100110 ||
+ 00000000 <--------+|
-------------- |
00100101001100 |
+ 00100011 <---------+
---------------
001001010111011

Man sieht auch, wie bei der Multiplikation zweier 8 Bit Zahlen sehr schnell ein 16 Bit Ergebnis entsteht. Dies ist auch der Grund, warum die Hardwaremultiplikation immer 2 Register zur Aufnahme des Ergebnisses benötigt.

Ein Assembler Code, der diese Strategie im wesentlichen verwirklicht, sieht z. B. so aus. Dieser Code wurde nicht auf optimale Laufzeit getrimmt, sondern es soll im Wesentlichen eine 1:1 Umsetzung des oben gezeigten Schemas sein. Einige der verwendeten Befehle wurden im Rahmen dieses Tutorials an dieser Stelle noch nicht besprochen. Speziell die Schiebe- (lsl) und Rotier- (rol) Befehle sollten in der AVR Befehlsübersicht genau studiert werden, um ihr Zusammenspiel mit dem Carry Flag zu verstehen. Nur soviel als Hinweis: Das Carry Flag dient in der lsl / rol Sequenz als eine Art Zwischenspeicher, um das höherwertigste Bit aus dem Register r0 beim Verschieben in das Register r1 verschieben zu können. Der lsl verschiebt alle Bits des Registers um 1 Stelle nach links, wobei das vorhergehende MSB ins Carry Bit wandert und rechts ein 0-Bit nachrückt. Der rol verschiebt ebenfalls alle Stellen eines Registers um 1 Stelle nach links. Diesmal wird aber rechts nicht mit einem 0-Bit aufgefüllt, sondern an dieser Stelle wird der momentane Inhalt des Carry Bits eingesetzt.

<avrasm>
ldi r16, 0b00100011 ; Multiplikator
ldi r17, 0b10001001 ; Multiplikand
; Berechne r16 * r17

ldi r18, 8 ; 8 mal verschieben und gegebenenfalls addieren
clr r19 ; 0 wird für die 16 Bit Addition benötigt
clr r0 ; Ergebnis Low Byte auf 0 setzen
clr r1 ; Ergebnis High Byte auf 0 setzen

mult:
lsl r0 ; r1:r0 einmal nach links verschieben
rol r1
lsl r17 ; Das MSB von r17 ins Carry schieben
brcc noadd ; Ist dieses MSB (jetzt im Carry) eine 1?
add r0,r16 ; Wenn ja, dann r16 zum Ergebnis addieren
adc r1,r19

noadd:
dec r18 ; Wurden alle 8 Bit von r17 abgearbeitet?
brne mult ; Wenn nicht, dann ein erneuter Verschiebe/Addier Zyklus

; r0 enthält an dieser Stelle den Wert 0b10111011
; r1 enthält 0b00010010
; Gemeinsam bilden r1 und r0 also die Zahl
; 0b0001001010111011
</avrasm>

== Division ==
Anders als bei der Multiplikation, gibt es auch auf einem ATMega-Prozessor keine hardwaremässige Divisionseinheit. Divisionen müssen also in jedem Fall mit einer speziellen Routine, die im wesentlichen auf Subtraktionen beruht, erledigt werden.
=== Division in Software ===

Um die Vorgangsweise bei der binären Division zu verstehen, wollen wir wieder zunächst anhand der gewohnten dezimalen Division untersuchen wie sowas abläuft.

Angenommen es soll dividiert werden: 938 / 4 ( 938 ist der Dividend, 4 ist der Divisor)

Wie haben Sie es in der Grundschule gelernt? Wahrscheinlich so wie der Autor auch:

938 : 4 = 234
---
-8
----
1
13
-12
---
1
18
-16
--
2 Rest

Der Vorgang war: Man nimmt die erste Stelle des Dividenden (9) und ruft seine gespeicherte Einmaleins Tabelle ab, um festzustellen, wie oft der Divisor in dieser Stelle enthalten ist. In diesem konkreten Fall ist die erste Stelle 9 und der Divisor 4. 4 ist in 9 zweimal enthalten. Also ist 2 die erste Ziffer des Ergebnisses. 2 mal 4 ergibt aber 8 und diese 8 werden von den 9 abgezogen, übrig bleibt 1.
Aus dem Dividenden wird die nächste Ziffer (3) heruntergezogen und man erhält mit der 1 aus dem vorhergehenden Schritt 13.
Wieder dasselbe Spiel: Wie oft ist 4 in 13 enthalten? 3 mal (3 ist die nächste Ziffer des Ergebnisses) und 3 * 4 ergibt 12. Diese 12 von den 13 abgezogen macht 1. Zu dieser 1 gesellt sich wieder die nächste Ziffer des Dividenden, 8, um so 18 zu bilden.
Wie oft ist 4 in 18 enthalten? 4 mal (4 ist die nächste Ziffer des Ergebnisses), denn 4 mal 4 macht 16, und das von den 18 abgezogen ergibt 2.
Da es keine nächste Ziffer im Dividenden mehr gibt, lautet also das Resultat:
938 : 4 ergibt 234 und es bleiben 2 Rest.

Die binäre Division funktioniert dazu völlig analog. Es gibt nur einen kleinen Unterschied, der einem sogar das Leben leichter macht. Es geht um den Schritt: Wie oft ist x in y enthalten?
Dieser Schritt ist in der binären Division besonders einfach, da das Ergebnis dieser Fragestellung nur 0 oder 1 sein kann. Das bedeutet aber auch: Entweder ist der Divisior in der zu untersuchenden Zahl enthalten, oder er ist es nicht. Das kann aber ganz leicht entschieden werden: Ist die Zahl größer oder gleich dem Divisior, dann ist der Divisor enthalten und zum Ergebnis kann eine 1 hinzugefügt werden. Ist die Zahl kleiner als der Divisior, dann ist der Divisior nicht enthalten und die nächste Ziffer des Ergebnisses ist eine 0.

Beispiel: Es soll die Division 0b01101100 : 0b00001001 ausgeführt werden.

Es wird wieder mit der ersten Stelle begonnen und die oben ausgeführte Vorschrift angewandt.

0b01101101 : 0b00001001 = 0b00001100
^^^^^^^^
||||||||
0 ---------+||||||| 1001 ist in 0 0-mal enthalten
-0 |||||||
-- |||||||
0 |||||||
01 ----------+|||||| 1001 ist in 1 0-mal enthalten
- 0 ||||||
-- ||||||
01 ||||||
011 -----------+||||| 1001 ist in 11 0-mal enthalten
- 0 |||||
--- |||||
011 |||||
0110 ------------+|||| 1001 ist in 110 0-mal enthalten
- 0 ||||
---- ||||
0110 ||||
01101 -------------+||| 1001 ist in 1101 1-mal enthalten
- 1001 |||
----- |||
0100 |||
01001 --------------+|| 1001 ist in 1001 1-mal enthalten
- 1001 ||
----- ||
00000 ||
000000 ---------------+| 1001 ist in 0 0-mal enthalten
- 0 |
------ |
0000001 ----------------+ 1001 ist in 1 0-mal enthalten
- 0
-------
1 Rest

Die Division liefert also das Ergebnis 0b00001100, wobei ein Rest von 1 bleibt. Der Dividend 0b01101101 entspricht der Dezimalzahl 109, der Divisor 0b00001001 der Dezimalzahl 9. Und wie man sich mit einem Taschenrechner leicht überzeugen kann, ergibt die Division von 109 durch 9 einen Wert von 12, wobei 1 Rest bleibt. Die Binärzahl für 12 lautet 0b00001100, das Ergebnis stimmt also.

<avrasm>
ldi r16, 109 ; Dividend
ldi r17, 9 ; Divisor

; Division r16 : r17

ldi r18, 8 ; 8 Bit Division
clr r19 ; Register für die Zwischenergebnisse / Rest
clr r20 ; Ergebnis

divloop:
lsl r16 ; Zwischenergebnis mal 2 nehmen und das
rol r19 ; nächste Bit des Dividenden anhängen

lsl r20 ; das Ergebnis auf jeden Fall mal 2 nehmen,
; das hängt effektiv eine 0 an das Ergebnis an.
; Sollte das nächste Ergebnis-Bit 1 sein, dann wird
; diese 0 in Folge durch eine 1 ausgetauscht

cp r19, r17 ; ist der Divisor größer?
brlo div_zero ; wenn nein, dann bleibt die 0
sbr r20, 1 ; wenn ja, dann jetzt die 0 durch eine 1 austauschen ...
sub r19, r17 ; ... und den Divisor abziehen

div_zero:
dec r18 ; das Ganze 8 mal wiederholen
brne divloop

; in r20 steht das Ergebnis der Division
; in r19 steht der bei der Division entstehende Rest
</avrasm>

== Arithmetik mit mehr als 8 Bit ==

Es gibt eine [[AVR_Arithmetik|Sammlung von Algorithmen zur AVR-Arithmetik]] mit mehr als 8 Bit, deren Grundprinzipien im wesentlichen identisch zu den in diesem Teil ausgeführten Prinzipien sind.

----

{{Navigation_zurückhochvor|
zurücktext=Logik|
zurücklink=AVR-Tutorial: Logik|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Stack|
vorlink=AVR-Tutorial: Stack}}

[[Category:AVR-Tutorial]]
[[Kategorie:AVR-Arithmetik]]

Versenden von SMS mittels Mobiltelefon

2011-01-21T09:22:20Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende Textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Baudrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010 (Bugfix in sms_decode behoben)]] [[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Versenden von SMS mittels Mobiltelefon

2010-12-28T13:33:03Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010 (Bugfix in sms_decode behoben)]] [[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Versenden von SMS mittels Mobiltelefon

2010-12-28T13:32:49Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010 (Bugfix in sms_decode)]] [[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Versenden von SMS mittels Mobiltelefon

2010-12-28T13:31:45Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010]] [[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Versenden von SMS mittels Mobiltelefon

2010-12-28T13:31:22Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010]]
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Datei:Software Stand 28.12.2010.zip

2010-12-28T13:30:58Z

Remote1:

Versenden von SMS mittels Mobiltelefon

2010-12-28T13:30:39Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 28.12.2010.zip | Software Stand 28.12.2010]] 
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum Versenden von SMS mit BASCOM und Delphi]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Funk]]
[[Kategorie:Datenübertragung]]

Versenden von SMS mittels Mobiltelefon

2010-10-04T06:55:27Z

Remote1: /* Allgmeine Quellen zum Thema */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets and language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-10-04T06:52:04Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-10-04T06:51:48Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-10-04T06:51:23Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-10-04T06:48:51Z

Remote1: /* Einleitung */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das verbraucht zwar mehr Speicher, trägt aber meines Erachtens zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist High-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (High-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Lumberg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versand]

[[Category:Projekte]]

Datei:Elektronik.zip

2010-08-19T13:19:12Z

Remote1:

Elektronik Lagerverwaltung

2010-08-19T13:16:12Z

Remote1: /* Download */

== Allgemeine Infos ==

Verwaltung von elektronischen Bauteilen. Speichermöglichkeit von
Bildern, anlegen von Gehäuse, Bestellungs-Verwaltung, Stückzahlen und
Preise. Unterstützt unterschiedliche Datenbank-Systeme, so kann es auch
mit mehreren Rechnern gleichzeitig benutzt werden (Client/Server,
MySQL).

* Bauteile
* Gehäuse
* Lieferanten
* Bestellvorschlag
* Typunterscheidung
* Suche
* Drucken

== Download ==

[[Media: Elektronik.zip | aktuelle Version]]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/186629 Diskussion zum Artikel]
* [http://www.mmvisual.de Homepage Autor]

[[Category:Projekte]]

Elektronik Lagerverwaltung

2010-08-19T13:14:43Z

Remote1: /* Download */

== Allgemeine Infos ==

Verwaltung von elektronischen Bauteilen. Speichermöglichkeit von
Bildern, anlegen von Gehäuse, Bestellungs-Verwaltung, Stückzahlen und
Preise. Unterstützt unterschiedliche Datenbank-Systeme, so kann es auch
mit mehreren Rechnern gleichzeitig benutzt werden (Client/Server,
MySQL).

* Bauteile
* Gehäuse
* Lieferanten
* Bestellvorschlag
* Typunterscheidung
* Suche
* Drucken

== Download ==

[[Datei:Elektronik.zip | aktuelle Version]]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/186629 Diskussion zum Artikel]
* [http://www.mmvisual.de Homepage Autor]

[[Category:Projekte]]

AVR TWI

2010-08-03T13:40:44Z

Remote1: /* Grundlagen */

''von Alexander Starke''

== Grundlagen ==

Das TWI (Two Wire Interface) ist begründet durch seinen Aufbau ideal auf typische Mikrocontroller Applikationen zugeschnitten. Durch seinen 7 Bit breiten Adressraum können bis zu 128 (27 = 128) Geräte miteinander verschaltet werden. Im Gegensatz zum SPI ([[Serial Peripheral Interface]]) werden nur zwei Busleitungen benötigt. Eine dient der Bereitstellung des Taktes (SCL) und die andere dem Datentransport (SDA). Die einzige zusätzlich benötigt Hardware besteht aus zwei Pull-Up Widerständen, welche von jeweils einer Busleitung gegen Vcc (5V) geschalten werden. Da alle Bustreiber mit offenem Kollektor bzw. Drain am Bus anliegen, ergibt sich eine logische UND-Verknüpfung. D.h., sobald irgendein Gerät auf einer der Busleitungen Low-Pegel anlegt, liegt automatisch die gesamte Busleitung auf Low. Der BUS hat nur High-Pegel, wenn alle angeschlossenen Geräte auch High-Pegel an ihrer entsprechenden Schnittstelle haben.

Genau wie beim SPI initiiert auch beim TWI der Master den Datentransfer und beendet selbigen auch wieder. Gestartet wird eine Transmission durch eine Start-Bedingung und entsprechend beendet durch eine Stop-Bedingung. Während einer Transmission gilt der Bus als "busy" (beschäftigt) und kein anderer Master darf versuchen, Kontrolle über ihn zu erlangen. Einzige Ausnahme bildet hier der Fall, dass vor einer Stop-Bedingung durch den gerade aktiven Master noch eine zusätzliche Start-Bedingung auf den Bus gegeben wird. Dieser Fall tritt normalerweise dann ein, wenn der Master noch weitere Daten zu versenden hat und nicht die Kontrolle über den Bus verlieren möchte. Nach solch einem wiederholten Start (Repeated Start) ist der Bus wieder beschäftigt, bis zum nächsten Stop.
Start- und Stop-Bedingungen werden signalisiert, indem der Pegel der SDA-Leitung wechselt, während SCL High-Pegel hat.

Alle Adresspakete auf dem TWI Bus haben eine Länge von 9 Bit. Davon beinhalten 7 Bit wie bereits eingangs erwähnt die Adresse der angesprochenen Komponente. Zusätzlich gibt es noch ein Bit, dass darüber bestimmt, ob ein Lese- oder ein Schreibzugriff durchgeführt werden soll (R/W=1 -> Lesen; RW=0 -> Schreiben). Das 9 Bit dient der Bestätigung. Wenn ein Slave bemerkt, dass er angesprochen wird, so bestätigt er dies, indem er mit dem 9. Taktzyklus (ACK) von SCL SDA auf Low-Pegel legt. Sollte der angesprochene Slave aus irgendwelchen Gründen nicht antworten können, so sollte SDA auf H-Pegel bleiben. Der Master hat dann die Wahl, ob er ein Stop sendet oder einen wiederholten Start durchführt.

* SLA +R --> Adresspaket mit einer Slave-Adresse und einem Lese-Bit
* SLA +W --> Adresspaket mit einer Slave-Adresse und einem Schreib-Bit

Das höchstwertige Bit wird prinzipiell zuerst übertragen (MSB Most Significant Bit). Die Slave-Adressen können durch den Anwender frei gewählt werden, nur 0000 000 ist reserviert, hiermit werden alle Slaves angesprochen. Wird ein solcher Zugriff durchgeführt, so sollten alle Slaves im ACK-Zyklus SDA auf L-Pegel legen.
Benutzt wird diese Aktion, wenn der Master die selben Daten an mehrere Slaves senden möchte. Sinn macht die Verwendung nur in Verbindung mit dem Schreib-Bit. Ein Setzen des Lese-Bits hätte zur Folge, dass verschiedene Slaves ja verschiedene Daten auf den Bus stellen könnten, was zu einem Durcheinander führen würde. Wird das Schreib-Bit gesetzt, so setzen im ACK-Zyklus alle Slaves SDA auf L-Pegel, welche den allgemeinen Adressaufruf erhalten und ausgewertet haben (also die nicht beschäftigt waren). Die folgenden Datenpakete werden dann von allen Slaves empfangen, welche SDA auf L-Pegel gelegt hatten.

Alle Datenpakete auf dem TWI-Bus haben analog zu den Adresspaketen 9 Bit. Hiervon sind 8 Datenbits. Das 9. dient der Bestätigung. Während einer Datenübertragung ist es Aufgabe des Masters, den Takt, das Start- und das Stopzeichen bereitzustellen. Aufgabe des Empfängers ist die Bestätigung der erhaltenen Daten, indem er die SDA-Leitung während des 9. SCL-Zyklus auf L-Pegel legt. Dieses wird als ACK bezeichnet (Acknowledge). Bleibt SDA auf H-Pegel, so wird dem Sender signalisiert, dass die gesendeten Daten nicht empfangen wurden (NACK). Das MSB wird zuerst übertragen.

Wenn man nun Adress- und Datenpakete kombiniert, hat man schon eine fertige Transmission. Diese besteht aus:

* START --> SLA R/W --> ein oder mehr Datenpakete --> STOP

Ein START gefolgt von einem STOP ist nicht zulässig. Wenn der Takt des Masters für den Slave zu schnell ist oder er noch mehr Zeit zur Bearbeitung braucht, so kann er SCL einfach länger auf L-Pegel halten. Die Verlängerung der L-Phase von SCL hat allerdings keinen Einfluss auf die Länge der H-Phase, da diese vom Master zur Verfügung gestellt wird. Dadurch kann es allerdings zu einer Reduzierung des Datentransfers kommen.

== Multi-Master-Bussysteme ==

Das TWI-Bussystem erlaubt den Multi-Master Betrieb. Es wurden spezielle Vorkehrungen getroffen, so dass auch wenn mehrere Master zur selben Zeit eine Transmission beginnen wollen keine Probleme auftreten und der Bus normal funktioniert. Nur die zwei folgenden Probleme sollten beachtet werden:

# Es ist Sache des Anwenders, seine Algorithmen so auszulegen, dass in diesem Fall nur ein Master seine Transmission fortsetzt. Alle anderen Master sollten ihre Transmission sofort abbrechen. Diesen Auswahlprozess zwischen den Mastern nennt man Arbitrierung (Entscheidung). Wenn ein Master bemerkt, dass er den Entscheidungsprozess (die Arbitrierung) verloren hat, sollte er sofort in den Slave-Modus gehen, da es sein kann, dass der Master welcher den Prozess gewonnen hat ihn adressieren will. Die Tatsache, dass mehrere Master versucht hatten, eine Übertragung zu starten, sollte für die Slaves nicht feststellbar sein, die Daten auf dem Bus dürfen nicht beschädigt sein.
# Da verschiedene Master mit verschiedenen Taktfrequenzen auf dem Bus arbeiten könnten, ist eine Festlegung zu treffen, wie man diese synchronisiert. Dieses erleichtert auch den Arbitrierungsprozess.

Diese Lösung dieses Problems stellt die schon oben angesprochene UND-Verknüpfung aller Komponenten auf dem Bus dar. So werden alle seriellen Taktraten der einzelnen Master UND verknüpft. Somit ergibt sich ein High-Pegel entsprechend dem des Masters mit dem kürzesten H-Pegel, der Low-Pegel ist durch den Master mit der geringsten Taktrate gegeben.

Da der Multi-Master Betrieb für meine Anwendung keinen Belang hat, werde ich hier nicht näher darauf eingehen.

==Aufbau des TWI==

Der SCL- und der SDA-Pin stellen die Schnittstelle des einzelnen MC mit dem Bus dar. Zusätzlich ist intern vorgesehen, dass Spannungsspitzen, welche kürzer als 50ns sind, herausgefiltert werden. Es besteht bei manchen Konfigurationen die Möglichkeit, die internen Pull-Up Widerstände zu verwenden, dies kann die Verwendung der externen überflüssig machen.

Zusätzlich verfügt der ATmega über einen Bitraten-Generator, welcher im Masterbetrieb das entsprechende Signal auf SCL gibt. Die Taktrate wird durch das TWBR (TWI Bit Rate Register) und TWSR (TWI Status Register) festgelegt. Zu beachten ist, dass die interne Taktfrequenz der einzelnen Slaves mindestens 16 mal höher als die Taktrate des Bus ist. Diese ergibt sich nach folgender Formel:

http://www.mikrocontroller.net/mc-project/Pages/AVR/TWI/twi_formel.gif

* TWBR - TWI Bit Rate Register
* TWPS - TWI Prescaler Bits im TWI Status Register

Des weiteren verfügt der MC über je ein Daten- und Adressschieberegister, einen START/STOP Controller und die Arbitrierungslogik. Das TWDR (TWI Data Register) beinhaltet entweder die Adresse und Daten welche gesendet werden sollen oder die empfangene Adresse samt Daten. Zusätzlich existiert noch ein Register, welches das (N)ACK-Bit enthält, das aber nicht direkt zugänglich ist. Jedoch kann es im Empfangsmodus durch verändern von TWCR (TWI Control Register) bzw. im Empfangsmodus durch verändern von TWSR manipuliert werden.

Der START/STOP Controller ist wie sein Name bereits sagt, dafür verantwortlich, den anderen Teilnehmern am Bus mitzuteilen, dass der entsprechende Master eine Übertragung plant bzw. beendet. Zusätzlich führt er auch den bereits erwähnten REPEATED START durch. Eine Besonderheit ist, dass er solche START/STOP-Zeichen auf dem Bus sogar detektieren kann, wenn sich der Controller in einem der Sleep-Modi befindet. Er kann somit "aufgeweckt" werden, wenn er von einem Master adressiert wird.

Ein weiterer Bestandteil des TWI ist die "Adress Match Unit". Diese überwacht, ob die empfangenen Adress-Bytes mit denen im TWAR (TWI Adress Register) übereinstimmen. Wenn TWGCE (TWI General Call Recognition Enable) in TWAR gesetzt ist, werden alle eingehenden Adress-Bytes zusätzlich noch daraufhin überprüft, ob eine allgemeine Ruf (0000 000) vorliegt. Sollte eine Übereinstimmung vorliegen, wird die Kontrolleinheit informiert, eventuelle Korrekturmaßnahmen können durchgeführt werden. Die TWI-Logik kann nun die Anforderung bestätigen, je nach dem welche Einstellungen in TWCR getroffen wurden. Wie bereits oben angesprochen wurde, arbeitet die Adress-Vergleichs-Logik sogar, wenn sich der MC in einem der Sleep-Modi befindet. Man kann den MC somit per TWI reaktivieren. Einzige Ausnahme bildet der Fall, dass der Controller zuvor durch einen anderen Interrupt reaktiviert wurde. Danach geht die TWI-Logik sofort in den Leerlauf. Sollte das bei der vorgesehenen Problemstellung zu Problemen führen, bleibt nur der Ausweg sämtliche anderen Interrupts in der Hinsicht zu sperren, dass sie den Controller nicht mehr reaktivieren können.

Die Kontrolleinheit des TWI beobachtet ständig den Bus und antwortet auf Anfragen entsprechend den Einstellungen in TWCR. Tritt ein Ereignis ein, auf welches die angesprochene Einheit reagieren soll, so wird automatisch TWINT (TWI Interrupt Flag) gesetzt. Im nächsten Taktzyklus wird dann TWSR aktualisiert, in ihm steht jetzt ein Code mit welchem das Ereignis spezifiziert werden kann. TWSR beinhaltet nur relevante Informationen, wenn TWINT gesetzt wird, andernfalls beinhaltet es bloß einen Statuscode, welcher aussagt, dass keine relevanten Informationen vorliegen. Solange TWINT gesetzt ist, wird SCL auf Low Pegel belassen. Dies gibt dem angesprochenen MC die Chance, alle Anwendungen erst zu beenden, bevor er sich der Transmission widmet. TWINT wird gesetzt wenn:

* wenn das TWI START/REPEATED START gesendet hat
* wenn das TWI SLA +R/W gesendet hat
* wenn das TWI ein Adress-Byte gesendet hat
* wenn das TWI seine "Vormacht" auf dem Bus verloren hat
* wenn das TWI durch seine eigene Slave-Adresse bzw. einen allgemeinen Ruf (general call) adressiert wurde
* wenn das TWI ein Datenbyte empfangen hat
* wenn ein STOP oder REPEATED START empfangen wurde, während es immer noch als Slave angesprochen ist
* wenn ein Busfehler durch einen illegalen START bzw. STOP aufgetreten ist

== Benutzung des TWI ==

Das TWI ist wie bereits ausführlich dargestellt wurde, byte- bzw. interruptbasiert. Dadurch ist es der Anwendersoftware möglich, parallel zum Datenversand bzw. -empfang auf dem TWI Bus noch weitere Anwendungen (Operationen) auszuführen. Die Ausführung einer ISR ist allein durch das Setzen von TWIE (TWI Interrupt Enable) in TWCR bedingt (die Interrupts müssen natürlich auch global freigegeben sein). Es ist Sache des Anwenders, ob das Setzen von TWINT einen Interrupt verursachen soll. Ist TWIE nicht gesetzt, so ist es dem Programm selbst überlassen, ständig TWINT zu prüfen, um sämtliche Ereignisse auf dem Bus mit zu bekommen.

Bei jedem Setzen von TWINT ist eine Operation auf dem Bus abgeschlossen worden und es wird eine Antwort erwartet. In diesem Fall beinhaltet TWSR einen Wert, welcher ein direktes Maß für den aktuellen Status des Bus ist. Die Software legt nun fest, welche Aktion mit dem nächsten Buszyklus durchgeführt werden soll, indem sie TWCR und TWDR entsprechend verändert. Im folgenden wird schrittweise ein Beispiel für den Ablauf einer Übertragung gegeben.

Zuerst muss vom Master ein START-Signal auf den Bus gegeben werden. Dies erfolgt durch Schreiben eines speziellen Wertes in TWCR. Nach Abschluss der Operation wird TWINT gesetzt. Die Logik wartet nun so lange, bis durch den Anwender das Flag wieder gelöscht wurde (durch Schreiben einer '1'). Unmittelbar nach dem Löschen von TWINT beginnt die Logik damit das START-Signal zu senden.

<c>
TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); //TWSTA = TWI START Condition Bit
</c>

Nach dem Senden des START wird sofort wieder TWINT in TWCR gesetzt. Zusätzlich beinhaltet TWSR jetzt den entsprechenden Status Code, welcher mitteilt, dass START erfolgreich gesendet wurde.

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nachdem durch die Applikation TWSR daraufhin überprüft wurde, dass START erfolgreich gesendet wurde, kann es nun weitergehen. Im Fehlerfall könnte beispielsweise eine vom Anwender definierte Fehlerroutine greifen.

Nun muss SLA_W in TWDR geladen werden. Ist dies abgeschlossen, muss wiederum ein spezieller Wert in TWCR geschrieben werden, um der TWI-Logik mitzuteilen, dass die Adresse und der Schreibbefehl aus TWDR gesendet werden können. Unmittelbar nachdem durch den Anwender dann TWINT in TWCR gelöscht wurde (Schreiben einer '1') sendet das TWI das Adresspaket.

<c>
if ((TWSR & 0xF8) != START)
ERROR(); //Fehlerbehandlung
TWDR = SLA_W;
TWCR = (1<<TWINT) | (1<<TWEN);
</c>

Nach Abschluss der Sendung wird wiederum TWINT gesetzt in TWSR steht der entsprechende Statuscode, welcher über Erfolg bzw. Misserfolg der Sendung urteilt. In ihm ist auch das ACK-Bit des angesprochenen Slaves enthalten (oder auch nicht, was dann einen Fehler bedeuten würde).

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nach der Prüfung von TWSR ob bei der Sendung keine Fehler aufgetreten sind, kann das Datenpaket in TWDR geladen werden. Erneut muss ein spezieller Wert in TWCR geschrieben werden, welcher der Logik sagt, dass ein Datenpaket aus TWDR versendet werden soll. Nach dem Löschen von TWINT wird dieses automatisch versendet.

<c>
if ((TWSR & 0xF8) != MT_SLA_ACK)
ERROR();
TWDR = DATA;
TWCR = (1<<TWINT) | (1<<TWEN);
</c>

Nachdem TWINT gesetzt wurde kann mit Hilfe von TWSR überprüft werden, ob das Datenpaket erfolgreich gesendet und vom angesprochenen Slave angenommen wurde (ACK-Bit).

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nachdem bis hierhin alles funktioniert hat (angenommen), muss nun nur noch ein STOP gesendet werden. Dies erfolgt analog zu den obigen Ausführungen durch Schreiben eines speziellen Wertes in TWCR. Nach dem Löschen von TWINT wird dieses gesendet. Allerdings wird danach TWINT nicht automatisch wieder gesetzt, wie es zuvor immer der Fall war.

<c>
if ((TWSR & 0xF8) != MT_DATA_ACK)
ERROR();
TWCR = (1<<TWINT)|(1<<TWEN)|
(1<<TWSTO);
</c>

Anmerkung: Selbstverständlich muss zuvor beim anzusprechenden Slave in TWAR (TWI Adress Register) eine Adresse festgelegt werden, damit er auch gezielt angesprochen werden kann.

----
== Übertragungsmodi ==

Das TWI kann prinzipiell in vier verschiedenen Modi arbeiten: Master Transmitter (MT), Master Receiver (MR), Slave Transmitter (ST), Slave Receiver (SR). Diese können natürlich alle in einer Anwendung verwendet werden, je nachdem, wie sie es erfordert.

=== Master Transmitter Mode ===

Im MTM wird eine Abfolge von Bytes (Daten) an einen SR gesendet. Um ihn zu benutzen, muss das Adresspaket nach dem gesendeten START eine bestimmte Form aufweisen. Wird SLA+W gesendet, liegt der MTM vor, für SLA+R wäre es der MRM.
Das Senden eines START gestaltet sich wie folgt (TWCR):

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

* TWEN: Aktivierung des TWI
* TWSTA: Senden des START
* TWINT: um TWINT zu löschen

Das TWI wartet nun solange, bis der Bus frei ist und sendet dann START. Danach wird TWINT wieder gesetzt und TWSR aktualisiert. Es sollte jetzt 0x08 enthalten. Beim Auslesen des Status-Code müssen die Prescaler-Bits mit Null maskiert werden. Um den MTM zu benutzen, muss SLA+W in TWDR geschrieben werden. Nachdem TWINT gelöscht wurde, wird dies gesendet. TWCR muss dazu die folgende Form haben:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |0 |X |1 |0 |X
}}

Nachdem SLA+W gesendet und das ACK-Bit empfangen wurde, wird TWINT erneut gesetzt. Der Statuscode in TWSR kann nun unter anderem folgende Formen haben: 0x18, 0x20, 0x38.

Nachdem bis hierhin alles erfolgreich funktioniert hat, kann jetzt ein Datenpaket versendet werden. Dies erfolgt durch Schreiben der Daten in TWDR. TWDR kann nur aktualisiert werden, wenn TWINT gesetzt ist, andernfalls kommt es zu einem Fehler, TWWC (TWI Write Collision Bit) wird gesetzt. Um die Daten zu senden, muss TWINT erneut gelöscht werden. TWCR sollte so aussehen:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Dieses Schema wiederholt sich nun solange, bis alle Daten versendet wurden und ein STOP gesendet werden kann. Dies erfolgt folgendermaßen:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |1 |X |1 |0 |X
}}

Ein erneuter Start (REPEATED START) erfolgt durch Schreiben der folgenden Werte in TWCR:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Nach einem REPEATED START kann der Master denselben Slave erneut kontaktieren oder auch einen anderen, ohne ein STOP zu senden. Der REPEATED START erlaubt dem Master das Wechseln zwischen Slaves, MTM und MRM ohne die Kontrolle über den Bus zu verlieren.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.176 zu entnehmen.

=== Master Receiver Mode ===

Im MRM empfängt der Master Daten von einem ST. Zunächst muss wieder START gesendet werden. Das folgende Adresspaket sollte dann SLA+R enthalten.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

* TWEN: Aktivierung des TWI
* TWSTA: Senden des START
* TWINT: um TWINT zu löschen

Das TWI wartet nun solange, bis der Bus frei ist und sendet dann START. Danach wird TWINT wieder gesetzt und TWSR aktualisiert. Es sollte jetzt 0x08 enthalten. Beim Auslesen des Status-Code müssen die Prescaler-Bits mit Null maskiert werden. Um den MTM zu benutzen, muss SLA+R in TWDR geschrieben werden. Nachdem TWINT gelöscht wurde, wird dies gesendet. TWCR muss dazu die folgende Form haben:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |0 |X |1 |0 |X
}}

Nachdem SLA+R gesendet und das ACK-Bit empfangen wurde, wird TWINT erneut gesetzt. Der Statuscode in TWSR kann nun unter anderem folgende Formen haben: 0x38, 0x40, 0x48.
Die empfangenen Daten können aus TWDR gelesen werden, so denn TWINT gesetzt ist. Dieses Schema kann sich bis zum Empfang des letzten Bytes immer wieder wiederholen. Nachdem das letzte Byte empfangen wurde, kann der Master dem Slave durch senden von NACK klar machen, dass keine Daten mehr erwartet werden. Beendet wird der Transfer durch senden von STOP oder REPEATED START.
Für STOP muss folgendes in TWCR geschrieben werden:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |1 |X |1 |0 |X
}}

Für einen REPEATED START muss folgendes in TWCR geschrieben werden:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Nach einem REPEATED START kann der Master denselben Slave erneut kontaktieren oder auch einen anderen, ohne ein STOP zu senden. Der REPEATED START erlaubt dem Master das Wechseln zwischen Slaves, MTM und MRM ohne die Kontrolle über den Bus zu verlieren.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.179 zu entnehmen.

=== Slave Receiver Mode ===

Im SRM werden Daten vom MT empfangen. Um einen Atmega8 im SRM zu betreiben, müssen TWAR und TWCR die folgende Form haben:

TWAR:
Die oberen 7 Bit stellen die Adress dar, an die das TWI antwortet, wenn es von einem Master angesprochen wird. Wenn das LSB (Least Significant Bit) in Form von TWGCE gesetzt ist, antwortet der Slave auch auf allgemeine Rufe (general calls), andernfalls natürlich nicht.

{{ByteWithValues|
|TWA6|TWA5|TWA4|TWA3|TWA2|TWA1|TWA0|TWGCE
|Hier|steht|dann|die|Adresse|des|Slave!|X
}}

TWCR:
TWEN muss zum aktivieren des TWI gesetzt werden. TWEA muss gesetzt werden, damit der Slave antwortet, falls er von einem Master oder gegeben falls durch einen general call angesprochen wird. TWSTA und TWSTO müssen auf Null gesetzt werden.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|0 |1 |0 |0 |0 |1 |0 |X
}}

Wenn TWAR und TWCR initialisiert wurden, wartet der Slave ab, bis er mit seiner Adresse bzw. gegebenen falls durch einen generall call angesprochen wird gefolgt von einem Datenrichtungs-Bit. Hierbei steht eine '0' für Schreiben (SR) und eine '1' für Lesen (ST).
Nachdem die Logik ihre eigene Adresse und ein Schreib-Bit erhalten hat, wird TWINT gesetzt und TWSR beinhaltet den entsprechenden Statuscode. Mit seiner Hilfe kann die Software dann eine sinnvolle Reaktion einleiten. Der Eintritt in den SRM kann auch erfolgen, wenn ein Master sein Vorrecht auf dem Bus verloren hat (0x68, 0x78).

Wenn TWEA während eines Transfers zurückgesetzt wird, wird das TWI ein NACK (Not Acknowledge) auf den Bus nach Empfang des nächsten Bytes geben. Dies kann verwendet werden, wenn der Slave nicht mehr in der Lage ist, mehr Bytes zu empfangen. Solange TWEA '0' ist, reagiert das TWI nicht mehr auf seine eigene Slave-Adresse. Jedoch wird der Bus weiterhin beobachtet und das TWI ist nach dem Setzen von TWEA sofort wieder einsatzbereit. Somit kann dieses Feature verwendet werden, um einen Baustein für eine bestimmte Zeitspanne vom Bus zu nehmen.

In sämtlichen Sleep-Modi (außer Idle Mode) ist der Systemtakt des TWI inaktiv. Dessen zu trotz kann das TWI durch setzen von TWEA allein mit Hilfe des Bustaktes erfassen, wenn es mit seiner Adresse bzw. durch einen general call angesprochen wird. Somit kann das TWI den Controller aufwecken. Während der Aufweck-Phase kann SCL auf L-Pegel gehalten werden wenn TWINT gelöscht ist (Schreiben einer '1'). Der Datenempfang kann wieder im Normalbetrieb stattfinden. Zu beachten ist, dass solange SCL auf L-Pegel ist keine anderen Transmissionen stattfinden können. Wichtig ist, dass TWDR nach dem Aufwecken nicht mehr das letzte Byte, welches auf dem Bus war, enthält.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.182 zu entnehmen.

=== Slave Transmitter Mode ===

Im STM werden Daten an einen MR gesendet. Um den Controller im STM zu betreiben, müssen TWAR und TWCR wie folgt initialisiert werden.

TWAR:
Die oberen 7 Bit stellen die Adress dar, an die das TWI antwortet, wenn es von einem Master angesprochen wird. Wenn das LSB (Least Significant Bit) in Form von TWGCE gesetzt ist, antwortet der Slave auch auf allgemeine Rufe (general calls), andernfalls natürlich nicht.

{{ByteWithValues|
|TWA6|TWA5|TWA4|TWA3|TWA2|TWA1|TWA0|TWGCE
|Hier|steht|dann|die|Adresse|des|Slave!|X
}}

TWCR:
TWEN muss zum aktivieren des TWI gesetzt werden. TWEA muss gesetzt werden, damit der Slave antwortet, falls er von einem Master oder gegeben falls durch einen general call angesprochen wird. TWSTA und TWSTO müssen auf Null gesetzt werden.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|0 |1 |0 |0 |0 |1 |0 |X
}}

Nach der Initialisierung wartet das TWI auf eine Anfrage gefolgt von einem Datenrichtungsbit. Wird das TWI angesprochen wird TWINT gesetzt und TWSR beinhaltet den Statuscode. Mit seiner Hilfe kann das weitere Vorgehen festgelegt werden. Ein Controller kann auch in den STM gelangen, wenn er die Hoheit auf dem Bus an einen anderen Master verliert (0xB0).

Wird TWEA während eines Transfers gesetzt, wird das aktuelle Byte noch fertig gesendet und Status 0xC0 oder 0xC8 tritt ein, je nachdem ob der Master ACK oder NACK nach dem letzten Byte gesendet hatte. Das TWI wird in einen Blockierzustand gehen, unabhängig davon, ob der Master den Transfer fortsetzt. So erhält der Master nur noch '1' auf dem seriellen Bus. Status 0xC8 tritt ein, wenn der Master weitere Daten fordert (durch Senden von ACK), obwohl der Slave bereits das letzte Byte gesendet hat (TWEA '0' und erwartet NACK).

Trotz des Blockierzustandes wird der Bus weiter beobachtet und das TWI kann durch setzen von TWEA jederzeit wieder daran teilnehmen. Somit kann der Slave mit Hilfe von TWEA kurzzeitig vom Bus isoliert werden.

In sämtlichen Sleep-Modi (außer Idle Mode) ist der Systemtakt des TWI inaktiv. Dessen zu trotz kann das TWI durch setzen von TWEA allein mit Hilfe des Bustaktes erfassen, wenn es mit seiner Adresse bzw. durch einen general call angesprochen wird. Somit kann das TWI den Controller aufwecken. Während der Aufweck-Phase kann SCL auf L-Pegel gehalten werden wenn TWINT gelöscht ist (Schreiben einer '1'). Der Datenversand kann wieder im Normalbetrieb stattfinden. Zu beachten ist, dass solange SCL auf L-Pegel ist keine anderen Transmissionen stattfinden können. Wichtig ist, dass TWDR nach dem Aufwecken nicht mehr das letzte Byte, welches auf dem Bus war, enthält.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.185 zu entnehmen.

Zusätzlich zu den Betriebsart bezogenen Statuscodes gibt es noch zwei, welche davon unabhängig sind.
Status 0xF8 bedeutet, dass keine relevanten Informationen vorhanden sind, da TWINT nicht gesetzt ist. Dieser Fall tritt bei einem Statuswechsel ein oder wenn TWI im Moment nicht am Bus beteiligt ist.

Status 0x00 steht für einen Busfehler während einer Übertragung. Ursache kann das Senden von START oder STOP zu einem nicht zulässigem Zeitpunkt sein. Bei solch einem Fehler wird TWINT automatisch gesetzt. Um die Fehlerroutine zu verlassen, muss TWSTO gesetzt und TWINT gelöscht werden. Dieses führt dazu, dass das TWI in den nicht adressierten Slave-Modus geht und SDA und SCL wieder freigegeben werden. Es wird kein STOP gesendet.



----

== Weblinks ==

=== Bibliotheken ===
* [http://www.jtronics.de/elektronik-avr/lib-i2ctwi-avr.html AVR TWI Slave]
* [http://jump.to/fleury Peter Fleury's AVR I2C Library]

===I²C-Bausteine===

----

[[Category:AVR]]
[[Category:Mc-project.de]]
[[Category:I2C]]

AVR TWI

2010-08-03T13:34:20Z

Remote1: /* Grundlagen */

''von Alexander Starke''

== Grundlagen ==

Das TWI (Two Wire Interface) ist begründet durch seinen Aufbau ideal auf typische Mikrocontroller Applikationen zugeschnitten. Durch seinen 7 Bit breiten Adressraum können bis zu 128 (27 = 128) Geräte miteinander verschaltet werden. Im Gegensatz zum SPI ([[Serial Peripheral Interface]]) werden nur zwei Busleitungen benötigt. Eine dient der Bereitstellung des Taktes (SCL) und die andere dem Datentransport (SDA). Die einzige zusätzlich benötigt Hardware besteht aus zwei Pull-Up Widerständen, welche von jeweils einer Busleitung gegen Vcc (5V) geschalten werden. Da alle Bustreiber mit offenem Kollektor bzw. Drain am Bus anliegen, ergibt sich eine logische UND-Verknüpfung. D.h., sobald irgendein Gerät auf einer der Busleitungen Low-Pegel anlegt, liegt automatisch die gesamte Busleitung auf Low. Der BUS hat nur High-Pegel, wenn alle angeschlossenen Geräte auch High-Pegel an ihrer entsprechenden Schnittstelle haben.

Genau wie beim SPI initiiert auch beim TWI der Master den Datentransfer und beendet selbigen auch wieder. Gestartet wird eine Transmission durch eine Start-Bedingung und entsprechend beendet durch eine Stop-Bedingung. Während einer Transmission gilt der Bus als "busy" (beschäftigt) und kein anderer Master darf versuchen, Kontrolle über ihn zu erlangen. Einzige Ausnahme bildet hier der Fall, dass vor einer Stop-Bedingung durch den gerade aktiven Master noch eine zusätzliche Start-Bedingung auf den Bus gegeben wird. Dieser Fall tritt normalerweise dann ein, wenn der Master noch weitere Daten zu versenden hat und nicht die Kontrolle über den Bus verlieren möchte. Nach solch einem wiederholten Start (Repeated Start) ist der Bus wieder beschäftigt, bis zum nächsten Stop.
Start- und Stop-Bedingungen werden signalisiert, indem der Pegel der SDA-Leitung wechselt, während SCL High-Pegel hat.

Alle Adresspakete auf dem TWI Bus haben eine Länge von 8 Bit. Davon beinhalten 7 Bit wie bereits eingangs erwähnt die Adresse der angesprochenen Komponente. Zusätzlich gibt es noch ein Bit, dass darüber bestimmt, ob ein Lese- oder ein Schreibzugriff durchgeführt werden soll (R/W=1 -> Lesen; RW=0 -> Schreiben). Das 9 Bit dient der Bestätigung. Wenn ein Slave bemerkt, dass er angesprochen wird, so bestätigt er dies, indem er mit dem 9. Taktzyklus (ACK) von SCL SDA auf Low-Pegel legt. Sollte der angesprochene Slave aus irgendwelchen Gründen nicht antworten können, so sollte SDA auf H-Pegel bleiben. Der Master hat dann die Wahl, ob er ein Stop sendet oder einen wiederholten Start durchführt.

* SLA +R --> Adresspaket mit einer Slave-Adresse und einem Lese-Bit
* SLA +W --> Adresspaket mit einer Slave-Adresse und einem Schreib-Bit

Das höchstwertige Bit wird prinzipiell zuerst übertragen (MSB Most Significant Bit). Die Slave-Adressen können durch den Anwender frei gewählt werden, nur 0000 000 ist reserviert, hiermit werden alle Slaves angesprochen. Wird ein solcher Zugriff durchgeführt, so sollten alle Slaves im ACK-Zyklus SDA auf L-Pegel legen.
Benutzt wird diese Aktion, wenn der Master die selben Daten an mehrere Slaves senden möchte. Sinn macht die Verwendung nur in Verbindung mit dem Schreib-Bit. Ein Setzen des Lese-Bits hätte zur Folge, dass verschiedene Slaves ja verschiedene Daten auf den Bus stellen könnten, was zu einem Durcheinander führen würde. Wird das Schreib-Bit gesetzt, so setzen im ACK-Zyklus alle Slaves SDA auf L-Pegel, welche den allgemeinen Adressaufruf erhalten und ausgewertet haben (also die nicht beschäftigt waren). Die folgenden Datenpakete werden dann von allen Slaves empfangen, welche SDA auf L-Pegel gelegt hatten.

Alle Datenpakete auf dem TWI-Bus haben analog zu den Adresspaketen 9 Bit. Hiervon sind 8 Datenbits. Das 9. dient der Bestätigung. Während einer Datenübertragung ist es Aufgabe des Masters, den Takt, das Start- und das Stopzeichen bereitzustellen. Aufgabe des Empfängers ist die Bestätigung der erhaltenen Daten, indem er die SDA-Leitung während des 9. SCL-Zyklus auf L-Pegel legt. Dieses wird als ACK bezeichnet (Acknowledge). Bleibt SDA auf H-Pegel, so wird dem Sender signalisiert, dass die gesendeten Daten nicht empfangen wurden (NACK). Das MSB wird zuerst übertragen.

Wenn man nun Adress- und Datenpakete kombiniert, hat man schon eine fertige Transmission. Diese besteht aus:

* START --> SLA R/W --> ein oder mehr Datenpakete --> STOP

Ein START gefolgt von einem STOP ist nicht zulässig. Wenn der Takt des Masters für den Slave zu schnell ist oder er noch mehr Zeit zur Bearbeitung braucht, so kann er SCL einfach länger auf L-Pegel halten. Die Verlängerung der L-Phase von SCL hat allerdings keinen Einfluss auf die Länge der H-Phase, da diese vom Master zur Verfügung gestellt wird. Dadurch kann es allerdings zu einer Reduzierung des Datentransfers kommen.

== Multi-Master-Bussysteme ==

Das TWI-Bussystem erlaubt den Multi-Master Betrieb. Es wurden spezielle Vorkehrungen getroffen, so dass auch wenn mehrere Master zur selben Zeit eine Transmission beginnen wollen keine Probleme auftreten und der Bus normal funktioniert. Nur die zwei folgenden Probleme sollten beachtet werden:

# Es ist Sache des Anwenders, seine Algorithmen so auszulegen, dass in diesem Fall nur ein Master seine Transmission fortsetzt. Alle anderen Master sollten ihre Transmission sofort abbrechen. Diesen Auswahlprozess zwischen den Mastern nennt man Arbitrierung (Entscheidung). Wenn ein Master bemerkt, dass er den Entscheidungsprozess (die Arbitrierung) verloren hat, sollte er sofort in den Slave-Modus gehen, da es sein kann, dass der Master welcher den Prozess gewonnen hat ihn adressieren will. Die Tatsache, dass mehrere Master versucht hatten, eine Übertragung zu starten, sollte für die Slaves nicht feststellbar sein, die Daten auf dem Bus dürfen nicht beschädigt sein.
# Da verschiedene Master mit verschiedenen Taktfrequenzen auf dem Bus arbeiten könnten, ist eine Festlegung zu treffen, wie man diese synchronisiert. Dieses erleichtert auch den Arbitrierungsprozess.

Diese Lösung dieses Problems stellt die schon oben angesprochene UND-Verknüpfung aller Komponenten auf dem Bus dar. So werden alle seriellen Taktraten der einzelnen Master UND verknüpft. Somit ergibt sich ein High-Pegel entsprechend dem des Masters mit dem kürzesten H-Pegel, der Low-Pegel ist durch den Master mit der geringsten Taktrate gegeben.

Da der Multi-Master Betrieb für meine Anwendung keinen Belang hat, werde ich hier nicht näher darauf eingehen.

==Aufbau des TWI==

Der SCL- und der SDA-Pin stellen die Schnittstelle des einzelnen MC mit dem Bus dar. Zusätzlich ist intern vorgesehen, dass Spannungsspitzen, welche kürzer als 50ns sind, herausgefiltert werden. Es besteht bei manchen Konfigurationen die Möglichkeit, die internen Pull-Up Widerstände zu verwenden, dies kann die Verwendung der externen überflüssig machen.

Zusätzlich verfügt der ATmega über einen Bitraten-Generator, welcher im Masterbetrieb das entsprechende Signal auf SCL gibt. Die Taktrate wird durch das TWBR (TWI Bit Rate Register) und TWSR (TWI Status Register) festgelegt. Zu beachten ist, dass die interne Taktfrequenz der einzelnen Slaves mindestens 16 mal höher als die Taktrate des Bus ist. Diese ergibt sich nach folgender Formel:

http://www.mikrocontroller.net/mc-project/Pages/AVR/TWI/twi_formel.gif

* TWBR - TWI Bit Rate Register
* TWPS - TWI Prescaler Bits im TWI Status Register

Des weiteren verfügt der MC über je ein Daten- und Adressschieberegister, einen START/STOP Controller und die Arbitrierungslogik. Das TWDR (TWI Data Register) beinhaltet entweder die Adresse und Daten welche gesendet werden sollen oder die empfangene Adresse samt Daten. Zusätzlich existiert noch ein Register, welches das (N)ACK-Bit enthält, das aber nicht direkt zugänglich ist. Jedoch kann es im Empfangsmodus durch verändern von TWCR (TWI Control Register) bzw. im Empfangsmodus durch verändern von TWSR manipuliert werden.

Der START/STOP Controller ist wie sein Name bereits sagt, dafür verantwortlich, den anderen Teilnehmern am Bus mitzuteilen, dass der entsprechende Master eine Übertragung plant bzw. beendet. Zusätzlich führt er auch den bereits erwähnten REPEATED START durch. Eine Besonderheit ist, dass er solche START/STOP-Zeichen auf dem Bus sogar detektieren kann, wenn sich der Controller in einem der Sleep-Modi befindet. Er kann somit "aufgeweckt" werden, wenn er von einem Master adressiert wird.

Ein weiterer Bestandteil des TWI ist die "Adress Match Unit". Diese überwacht, ob die empfangenen Adress-Bytes mit denen im TWAR (TWI Adress Register) übereinstimmen. Wenn TWGCE (TWI General Call Recognition Enable) in TWAR gesetzt ist, werden alle eingehenden Adress-Bytes zusätzlich noch daraufhin überprüft, ob eine allgemeine Ruf (0000 000) vorliegt. Sollte eine Übereinstimmung vorliegen, wird die Kontrolleinheit informiert, eventuelle Korrekturmaßnahmen können durchgeführt werden. Die TWI-Logik kann nun die Anforderung bestätigen, je nach dem welche Einstellungen in TWCR getroffen wurden. Wie bereits oben angesprochen wurde, arbeitet die Adress-Vergleichs-Logik sogar, wenn sich der MC in einem der Sleep-Modi befindet. Man kann den MC somit per TWI reaktivieren. Einzige Ausnahme bildet der Fall, dass der Controller zuvor durch einen anderen Interrupt reaktiviert wurde. Danach geht die TWI-Logik sofort in den Leerlauf. Sollte das bei der vorgesehenen Problemstellung zu Problemen führen, bleibt nur der Ausweg sämtliche anderen Interrupts in der Hinsicht zu sperren, dass sie den Controller nicht mehr reaktivieren können.

Die Kontrolleinheit des TWI beobachtet ständig den Bus und antwortet auf Anfragen entsprechend den Einstellungen in TWCR. Tritt ein Ereignis ein, auf welches die angesprochene Einheit reagieren soll, so wird automatisch TWINT (TWI Interrupt Flag) gesetzt. Im nächsten Taktzyklus wird dann TWSR aktualisiert, in ihm steht jetzt ein Code mit welchem das Ereignis spezifiziert werden kann. TWSR beinhaltet nur relevante Informationen, wenn TWINT gesetzt wird, andernfalls beinhaltet es bloß einen Statuscode, welcher aussagt, dass keine relevanten Informationen vorliegen. Solange TWINT gesetzt ist, wird SCL auf Low Pegel belassen. Dies gibt dem angesprochenen MC die Chance, alle Anwendungen erst zu beenden, bevor er sich der Transmission widmet. TWINT wird gesetzt wenn:

* wenn das TWI START/REPEATED START gesendet hat
* wenn das TWI SLA +R/W gesendet hat
* wenn das TWI ein Adress-Byte gesendet hat
* wenn das TWI seine "Vormacht" auf dem Bus verloren hat
* wenn das TWI durch seine eigene Slave-Adresse bzw. einen allgemeinen Ruf (general call) adressiert wurde
* wenn das TWI ein Datenbyte empfangen hat
* wenn ein STOP oder REPEATED START empfangen wurde, während es immer noch als Slave angesprochen ist
* wenn ein Busfehler durch einen illegalen START bzw. STOP aufgetreten ist

== Benutzung des TWI ==

Das TWI ist wie bereits ausführlich dargestellt wurde, byte- bzw. interruptbasiert. Dadurch ist es der Anwendersoftware möglich, parallel zum Datenversand bzw. -empfang auf dem TWI Bus noch weitere Anwendungen (Operationen) auszuführen. Die Ausführung einer ISR ist allein durch das Setzen von TWIE (TWI Interrupt Enable) in TWCR bedingt (die Interrupts müssen natürlich auch global freigegeben sein). Es ist Sache des Anwenders, ob das Setzen von TWINT einen Interrupt verursachen soll. Ist TWIE nicht gesetzt, so ist es dem Programm selbst überlassen, ständig TWINT zu prüfen, um sämtliche Ereignisse auf dem Bus mit zu bekommen.

Bei jedem Setzen von TWINT ist eine Operation auf dem Bus abgeschlossen worden und es wird eine Antwort erwartet. In diesem Fall beinhaltet TWSR einen Wert, welcher ein direktes Maß für den aktuellen Status des Bus ist. Die Software legt nun fest, welche Aktion mit dem nächsten Buszyklus durchgeführt werden soll, indem sie TWCR und TWDR entsprechend verändert. Im folgenden wird schrittweise ein Beispiel für den Ablauf einer Übertragung gegeben.

Zuerst muss vom Master ein START-Signal auf den Bus gegeben werden. Dies erfolgt durch Schreiben eines speziellen Wertes in TWCR. Nach Abschluss der Operation wird TWINT gesetzt. Die Logik wartet nun so lange, bis durch den Anwender das Flag wieder gelöscht wurde (durch Schreiben einer '1'). Unmittelbar nach dem Löschen von TWINT beginnt die Logik damit das START-Signal zu senden.

<c>
TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); //TWSTA = TWI START Condition Bit
</c>

Nach dem Senden des START wird sofort wieder TWINT in TWCR gesetzt. Zusätzlich beinhaltet TWSR jetzt den entsprechenden Status Code, welcher mitteilt, dass START erfolgreich gesendet wurde.

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nachdem durch die Applikation TWSR daraufhin überprüft wurde, dass START erfolgreich gesendet wurde, kann es nun weitergehen. Im Fehlerfall könnte beispielsweise eine vom Anwender definierte Fehlerroutine greifen.

Nun muss SLA_W in TWDR geladen werden. Ist dies abgeschlossen, muss wiederum ein spezieller Wert in TWCR geschrieben werden, um der TWI-Logik mitzuteilen, dass die Adresse und der Schreibbefehl aus TWDR gesendet werden können. Unmittelbar nachdem durch den Anwender dann TWINT in TWCR gelöscht wurde (Schreiben einer '1') sendet das TWI das Adresspaket.

<c>
if ((TWSR & 0xF8) != START)
ERROR(); //Fehlerbehandlung
TWDR = SLA_W;
TWCR = (1<<TWINT) | (1<<TWEN);
</c>

Nach Abschluss der Sendung wird wiederum TWINT gesetzt in TWSR steht der entsprechende Statuscode, welcher über Erfolg bzw. Misserfolg der Sendung urteilt. In ihm ist auch das ACK-Bit des angesprochenen Slaves enthalten (oder auch nicht, was dann einen Fehler bedeuten würde).

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nach der Prüfung von TWSR ob bei der Sendung keine Fehler aufgetreten sind, kann das Datenpaket in TWDR geladen werden. Erneut muss ein spezieller Wert in TWCR geschrieben werden, welcher der Logik sagt, dass ein Datenpaket aus TWDR versendet werden soll. Nach dem Löschen von TWINT wird dieses automatisch versendet.

<c>
if ((TWSR & 0xF8) != MT_SLA_ACK)
ERROR();
TWDR = DATA;
TWCR = (1<<TWINT) | (1<<TWEN);
</c>

Nachdem TWINT gesetzt wurde kann mit Hilfe von TWSR überprüft werden, ob das Datenpaket erfolgreich gesendet und vom angesprochenen Slave angenommen wurde (ACK-Bit).

<c>
while (!(TWCR & (1<<TWINT)));
</c>

Nachdem bis hierhin alles funktioniert hat (angenommen), muss nun nur noch ein STOP gesendet werden. Dies erfolgt analog zu den obigen Ausführungen durch Schreiben eines speziellen Wertes in TWCR. Nach dem Löschen von TWINT wird dieses gesendet. Allerdings wird danach TWINT nicht automatisch wieder gesetzt, wie es zuvor immer der Fall war.

<c>
if ((TWSR & 0xF8) != MT_DATA_ACK)
ERROR();
TWCR = (1<<TWINT)|(1<<TWEN)|
(1<<TWSTO);
</c>

Anmerkung: Selbstverständlich muss zuvor beim anzusprechenden Slave in TWAR (TWI Adress Register) eine Adresse festgelegt werden, damit er auch gezielt angesprochen werden kann.

----
== Übertragungsmodi ==

Das TWI kann prinzipiell in vier verschiedenen Modi arbeiten: Master Transmitter (MT), Master Receiver (MR), Slave Transmitter (ST), Slave Receiver (SR). Diese können natürlich alle in einer Anwendung verwendet werden, je nachdem, wie sie es erfordert.

=== Master Transmitter Mode ===

Im MTM wird eine Abfolge von Bytes (Daten) an einen SR gesendet. Um ihn zu benutzen, muss das Adresspaket nach dem gesendeten START eine bestimmte Form aufweisen. Wird SLA+W gesendet, liegt der MTM vor, für SLA+R wäre es der MRM.
Das Senden eines START gestaltet sich wie folgt (TWCR):

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

* TWEN: Aktivierung des TWI
* TWSTA: Senden des START
* TWINT: um TWINT zu löschen

Das TWI wartet nun solange, bis der Bus frei ist und sendet dann START. Danach wird TWINT wieder gesetzt und TWSR aktualisiert. Es sollte jetzt 0x08 enthalten. Beim Auslesen des Status-Code müssen die Prescaler-Bits mit Null maskiert werden. Um den MTM zu benutzen, muss SLA+W in TWDR geschrieben werden. Nachdem TWINT gelöscht wurde, wird dies gesendet. TWCR muss dazu die folgende Form haben:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |0 |X |1 |0 |X
}}

Nachdem SLA+W gesendet und das ACK-Bit empfangen wurde, wird TWINT erneut gesetzt. Der Statuscode in TWSR kann nun unter anderem folgende Formen haben: 0x18, 0x20, 0x38.

Nachdem bis hierhin alles erfolgreich funktioniert hat, kann jetzt ein Datenpaket versendet werden. Dies erfolgt durch Schreiben der Daten in TWDR. TWDR kann nur aktualisiert werden, wenn TWINT gesetzt ist, andernfalls kommt es zu einem Fehler, TWWC (TWI Write Collision Bit) wird gesetzt. Um die Daten zu senden, muss TWINT erneut gelöscht werden. TWCR sollte so aussehen:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Dieses Schema wiederholt sich nun solange, bis alle Daten versendet wurden und ein STOP gesendet werden kann. Dies erfolgt folgendermaßen:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |1 |X |1 |0 |X
}}

Ein erneuter Start (REPEATED START) erfolgt durch Schreiben der folgenden Werte in TWCR:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Nach einem REPEATED START kann der Master denselben Slave erneut kontaktieren oder auch einen anderen, ohne ein STOP zu senden. Der REPEATED START erlaubt dem Master das Wechseln zwischen Slaves, MTM und MRM ohne die Kontrolle über den Bus zu verlieren.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.176 zu entnehmen.

=== Master Receiver Mode ===

Im MRM empfängt der Master Daten von einem ST. Zunächst muss wieder START gesendet werden. Das folgende Adresspaket sollte dann SLA+R enthalten.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

* TWEN: Aktivierung des TWI
* TWSTA: Senden des START
* TWINT: um TWINT zu löschen

Das TWI wartet nun solange, bis der Bus frei ist und sendet dann START. Danach wird TWINT wieder gesetzt und TWSR aktualisiert. Es sollte jetzt 0x08 enthalten. Beim Auslesen des Status-Code müssen die Prescaler-Bits mit Null maskiert werden. Um den MTM zu benutzen, muss SLA+R in TWDR geschrieben werden. Nachdem TWINT gelöscht wurde, wird dies gesendet. TWCR muss dazu die folgende Form haben:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |0 |X |1 |0 |X
}}

Nachdem SLA+R gesendet und das ACK-Bit empfangen wurde, wird TWINT erneut gesetzt. Der Statuscode in TWSR kann nun unter anderem folgende Formen haben: 0x38, 0x40, 0x48.
Die empfangenen Daten können aus TWDR gelesen werden, so denn TWINT gesetzt ist. Dieses Schema kann sich bis zum Empfang des letzten Bytes immer wieder wiederholen. Nachdem das letzte Byte empfangen wurde, kann der Master dem Slave durch senden von NACK klar machen, dass keine Daten mehr erwartet werden. Beendet wird der Transfer durch senden von STOP oder REPEATED START.
Für STOP muss folgendes in TWCR geschrieben werden:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |0 |1 |X |1 |0 |X
}}

Für einen REPEATED START muss folgendes in TWCR geschrieben werden:

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|1 |X |1 |0 |X |1 |0 |X
}}

Nach einem REPEATED START kann der Master denselben Slave erneut kontaktieren oder auch einen anderen, ohne ein STOP zu senden. Der REPEATED START erlaubt dem Master das Wechseln zwischen Slaves, MTM und MRM ohne die Kontrolle über den Bus zu verlieren.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.179 zu entnehmen.

=== Slave Receiver Mode ===

Im SRM werden Daten vom MT empfangen. Um einen Atmega8 im SRM zu betreiben, müssen TWAR und TWCR die folgende Form haben:

TWAR:
Die oberen 7 Bit stellen die Adress dar, an die das TWI antwortet, wenn es von einem Master angesprochen wird. Wenn das LSB (Least Significant Bit) in Form von TWGCE gesetzt ist, antwortet der Slave auch auf allgemeine Rufe (general calls), andernfalls natürlich nicht.

{{ByteWithValues|
|TWA6|TWA5|TWA4|TWA3|TWA2|TWA1|TWA0|TWGCE
|Hier|steht|dann|die|Adresse|des|Slave!|X
}}

TWCR:
TWEN muss zum aktivieren des TWI gesetzt werden. TWEA muss gesetzt werden, damit der Slave antwortet, falls er von einem Master oder gegeben falls durch einen general call angesprochen wird. TWSTA und TWSTO müssen auf Null gesetzt werden.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|0 |1 |0 |0 |0 |1 |0 |X
}}

Wenn TWAR und TWCR initialisiert wurden, wartet der Slave ab, bis er mit seiner Adresse bzw. gegebenen falls durch einen generall call angesprochen wird gefolgt von einem Datenrichtungs-Bit. Hierbei steht eine '0' für Schreiben (SR) und eine '1' für Lesen (ST).
Nachdem die Logik ihre eigene Adresse und ein Schreib-Bit erhalten hat, wird TWINT gesetzt und TWSR beinhaltet den entsprechenden Statuscode. Mit seiner Hilfe kann die Software dann eine sinnvolle Reaktion einleiten. Der Eintritt in den SRM kann auch erfolgen, wenn ein Master sein Vorrecht auf dem Bus verloren hat (0x68, 0x78).

Wenn TWEA während eines Transfers zurückgesetzt wird, wird das TWI ein NACK (Not Acknowledge) auf den Bus nach Empfang des nächsten Bytes geben. Dies kann verwendet werden, wenn der Slave nicht mehr in der Lage ist, mehr Bytes zu empfangen. Solange TWEA '0' ist, reagiert das TWI nicht mehr auf seine eigene Slave-Adresse. Jedoch wird der Bus weiterhin beobachtet und das TWI ist nach dem Setzen von TWEA sofort wieder einsatzbereit. Somit kann dieses Feature verwendet werden, um einen Baustein für eine bestimmte Zeitspanne vom Bus zu nehmen.

In sämtlichen Sleep-Modi (außer Idle Mode) ist der Systemtakt des TWI inaktiv. Dessen zu trotz kann das TWI durch setzen von TWEA allein mit Hilfe des Bustaktes erfassen, wenn es mit seiner Adresse bzw. durch einen general call angesprochen wird. Somit kann das TWI den Controller aufwecken. Während der Aufweck-Phase kann SCL auf L-Pegel gehalten werden wenn TWINT gelöscht ist (Schreiben einer '1'). Der Datenempfang kann wieder im Normalbetrieb stattfinden. Zu beachten ist, dass solange SCL auf L-Pegel ist keine anderen Transmissionen stattfinden können. Wichtig ist, dass TWDR nach dem Aufwecken nicht mehr das letzte Byte, welches auf dem Bus war, enthält.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.182 zu entnehmen.

=== Slave Transmitter Mode ===

Im STM werden Daten an einen MR gesendet. Um den Controller im STM zu betreiben, müssen TWAR und TWCR wie folgt initialisiert werden.

TWAR:
Die oberen 7 Bit stellen die Adress dar, an die das TWI antwortet, wenn es von einem Master angesprochen wird. Wenn das LSB (Least Significant Bit) in Form von TWGCE gesetzt ist, antwortet der Slave auch auf allgemeine Rufe (general calls), andernfalls natürlich nicht.

{{ByteWithValues|
|TWA6|TWA5|TWA4|TWA3|TWA2|TWA1|TWA0|TWGCE
|Hier|steht|dann|die|Adresse|des|Slave!|X
}}

TWCR:
TWEN muss zum aktivieren des TWI gesetzt werden. TWEA muss gesetzt werden, damit der Slave antwortet, falls er von einem Master oder gegeben falls durch einen general call angesprochen wird. TWSTA und TWSTO müssen auf Null gesetzt werden.

{{ByteWithValues|
|TWINT|TWEA|TWSTA|TWSTO|TWWC|TWEN|–|TWIE
|0 |1 |0 |0 |0 |1 |0 |X
}}

Nach der Initialisierung wartet das TWI auf eine Anfrage gefolgt von einem Datenrichtungsbit. Wird das TWI angesprochen wird TWINT gesetzt und TWSR beinhaltet den Statuscode. Mit seiner Hilfe kann das weitere Vorgehen festgelegt werden. Ein Controller kann auch in den STM gelangen, wenn er die Hoheit auf dem Bus an einen anderen Master verliert (0xB0).

Wird TWEA während eines Transfers gesetzt, wird das aktuelle Byte noch fertig gesendet und Status 0xC0 oder 0xC8 tritt ein, je nachdem ob der Master ACK oder NACK nach dem letzten Byte gesendet hatte. Das TWI wird in einen Blockierzustand gehen, unabhängig davon, ob der Master den Transfer fortsetzt. So erhält der Master nur noch '1' auf dem seriellen Bus. Status 0xC8 tritt ein, wenn der Master weitere Daten fordert (durch Senden von ACK), obwohl der Slave bereits das letzte Byte gesendet hat (TWEA '0' und erwartet NACK).

Trotz des Blockierzustandes wird der Bus weiter beobachtet und das TWI kann durch setzen von TWEA jederzeit wieder daran teilnehmen. Somit kann der Slave mit Hilfe von TWEA kurzzeitig vom Bus isoliert werden.

In sämtlichen Sleep-Modi (außer Idle Mode) ist der Systemtakt des TWI inaktiv. Dessen zu trotz kann das TWI durch setzen von TWEA allein mit Hilfe des Bustaktes erfassen, wenn es mit seiner Adresse bzw. durch einen general call angesprochen wird. Somit kann das TWI den Controller aufwecken. Während der Aufweck-Phase kann SCL auf L-Pegel gehalten werden wenn TWINT gelöscht ist (Schreiben einer '1'). Der Datenversand kann wieder im Normalbetrieb stattfinden. Zu beachten ist, dass solange SCL auf L-Pegel ist keine anderen Transmissionen stattfinden können. Wichtig ist, dass TWDR nach dem Aufwecken nicht mehr das letzte Byte, welches auf dem Bus war, enthält.

Eine Tabelle mit sämtlichen Status-Codes und den zugehörigen Ereignissen ist dem Datenblatt S.185 zu entnehmen.

Zusätzlich zu den Betriebsart bezogenen Statuscodes gibt es noch zwei, welche davon unabhängig sind.
Status 0xF8 bedeutet, dass keine relevanten Informationen vorhanden sind, da TWINT nicht gesetzt ist. Dieser Fall tritt bei einem Statuswechsel ein oder wenn TWI im Moment nicht am Bus beteiligt ist.

Status 0x00 steht für einen Busfehler während einer Übertragung. Ursache kann das Senden von START oder STOP zu einem nicht zulässigem Zeitpunkt sein. Bei solch einem Fehler wird TWINT automatisch gesetzt. Um die Fehlerroutine zu verlassen, muss TWSTO gesetzt und TWINT gelöscht werden. Dieses führt dazu, dass das TWI in den nicht adressierten Slave-Modus geht und SDA und SCL wieder freigegeben werden. Es wird kein STOP gesendet.



----

== Weblinks ==

=== Bibliotheken ===
* [http://www.jtronics.de/elektronik-avr/lib-i2ctwi-avr.html AVR TWI Slave]
* [http://jump.to/fleury Peter Fleury's AVR I2C Library]

===I²C-Bausteine===

----

[[Category:AVR]]
[[Category:Mc-project.de]]
[[Category:I2C]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:09:20Z

Remote1: /* Nutzung der Funktionen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:08:12Z

Remote1: /* sms_decode (char* pdu, SMS_DECODE_DATA_T* data) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:05:49Z

Remote1: /* Nutzung der Funktionen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:05:00Z

Remote1: /* Voreinstellungen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define UART_MAXSTRLEN 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:03:19Z

Remote1: /* sms_decode (char* pdu, SMS_DECODE_DATA_T* data) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[SMS_MESSAGE_MAX_LEN+1]; /**< decodierte PDU Nachricht */
char telnr[SMS_TELNR_MAX_LEN+1]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[UART_MAXSTRLEN+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:01:18Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] [[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:00:35Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]] 
[[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T13:00:15Z

Remote1: /* Download */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 08.05.2010.zip | Software Stand 08.05.2010]]
[[Media: Hilfe.zip | Doxygen Hilfe des Projektes]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Datei:Hilfe.zip

2010-05-24T13:00:08Z

Remote1:

Datei:Software Stand 08.05.2010.zip

2010-05-24T12:59:43Z

Remote1:

Versenden von SMS mittels Mobiltelefon

2010-05-24T12:58:07Z

Remote1: /* Nutzung der Funktionen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer bzw. mit den aus der SIM-Karte ausgelesenen TElefonnummern (siehe SMS_TELNR_LIST_MAX) erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Die Telefonnummer des letzten Anrufers kann mit Hilfe der globalen Variable sms_last_caller weiter verarbeitet werden. So wäre es z. B. denkbar, eine Textnachricht an diesen zu senden.

Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T12:53:03Z

Remote1: /* Voreinstellungen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine().
Ein weiteres wichtiges Makro ist
<c>
/**
* definiert die maximale Anzahl der Telefonnummern in der Telefonnummernliste
* Dies kann zur Anrufernummernerkennung genutzt werden.Dabei werden immer die ersten \ref SMS_TELNR_LIST_MAX Nummern der SIM-Karte verwendet (siehe \ref sms_init)
*/
#define SMS_TELNR_LIST_MAX 5
</c>
Darüber lässt sich steuern, wie viele Telefonnummern aus der SIM-Karte zum Vergleich mit herangezogen werden sollen. Das heißt, ein Wert von fünf würde bedeuten, dass die ersten fünf Telefonnummern der SIM-Karte analog zu SMS_TELNR in der sms_state_machine ausgewertet werden. Ein korrekter Vergleich mit den Telefonnummern kann über die Rückgabewerte der Funktion sms_state_machine realisiert werden.
Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-05-24T12:47:50Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten. Des Weiteren werden ebenso die ersten Telefonnummern aus der SIM-Karte ausgelesen und zum späteren Vergleich in einer Datenstruktur abgelegt.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_RETRIEVE_nTELNR,/**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und nicht korrekt mit \ref SMS_TELNR bzw. \ref SMS_TELNR_LIST_T verglichen - über \ref sms_last_caller kann jetzt der Anrufer identifiziert werden */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Minila Version MockUp

2010-04-29T05:50:14Z

Remote1: /* LEDs */

== Voting einiger Dinge die im Thread angesprochen wurden ==
=== Spannungsversorgung ===
(Nach 5 Strichen "|" bitte ein Leerzeichen)
* USB Versorgt ohne galvanische Trennung der USB-Seite: |
* USB Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite: ||||| ||
* ext. Versorgt ohne galvanische Trennung der USB-Seite:
* ext. Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite:
Anmerkung: Es steht noch nicht fest ob der Stromverbrauch USB-Konform ist!!!

=== Bestückung ===
* SMD-Teile bestückt: |||||
* unbestückt als Bausatz: ||||

=== LEDs ===
* SMD RGB LED: ||
* SMD0805 LED: ||
* 5mm LED: |
* SMD0805 und 5mm LED (je nach Bestückung): |||

== Wünsche ==
=== Gehäuse ===
Fals einer eins gut findet, kann er das ja hier einbinden.

=== Andere Dinge können hier ebenfals hinzugefügt werden ===

== Feststehende Dinge ==
=== Spannungsversorgung ===
* Wahrscheinlich ein 3,3V sowie 5V Regler
* wenn USB-Versorgt abschaltbar um die Spezifikationen zu erfüllen

=== RAM-Speicher ===
* 512K*32 Kanäle steht ausser frage
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== USB ===
Je nach dem ob per USB versorgt oder nicht wird der FTDI FT2232D im:
* Bus Powerd Modus oder
* Self Powerd Modus
betrieben werden.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt

=== JTAG ===
* wird per Steckbrücke an den FTDI anklemmbar sein. Keine Litze notwendig
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale als Stiftleiste oder ähnliches herrausgeführt

=== Layout ===
* 2 Lagig

'''Top-Layer'''

[[Bild:MockUpMiniLALayoutEagleTop.png.png|500px]]

* zwischen dem oberen und dem mittleren Steckverbinder ist ~1cm.
* über der 5mm LED ist die SMD0805 LED angeordnet

== Planungsstand ==
* 32 Kanäle
* 100MHz Samplerate
* 512K Speichertiefe pro Kanal
* Geschätzter Preis steht noch aus

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

Minila Version MockUp

2010-04-29T05:49:50Z

Remote1: /* Spannungsversorgung */

== Voting einiger Dinge die im Thread angesprochen wurden ==
=== Spannungsversorgung ===
(Nach 5 Strichen "|" bitte ein Leerzeichen)
* USB Versorgt ohne galvanische Trennung der USB-Seite: |
* USB Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite: ||||| ||
* ext. Versorgt ohne galvanische Trennung der USB-Seite:
* ext. Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite:
Anmerkung: Es steht noch nicht fest ob der Stromverbrauch USB-Konform ist!!!

=== Bestückung ===
* SMD-Teile bestückt: |||||
* unbestückt als Bausatz: ||||

=== LEDs ===
* SMD RGB LED: |
* SMD0805 LED: ||
* 5mm LED: |
* SMD0805 und 5mm LED (je nach Bestückung): |||

== Wünsche ==
=== Gehäuse ===
Fals einer eins gut findet, kann er das ja hier einbinden.

=== Andere Dinge können hier ebenfals hinzugefügt werden ===

== Feststehende Dinge ==
=== Spannungsversorgung ===
* Wahrscheinlich ein 3,3V sowie 5V Regler
* wenn USB-Versorgt abschaltbar um die Spezifikationen zu erfüllen

=== RAM-Speicher ===
* 512K*32 Kanäle steht ausser frage
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== USB ===
Je nach dem ob per USB versorgt oder nicht wird der FTDI FT2232D im:
* Bus Powerd Modus oder
* Self Powerd Modus
betrieben werden.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt

=== JTAG ===
* wird per Steckbrücke an den FTDI anklemmbar sein. Keine Litze notwendig
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale als Stiftleiste oder ähnliches herrausgeführt

=== Layout ===
* 2 Lagig

'''Top-Layer'''

[[Bild:MockUpMiniLALayoutEagleTop.png.png|500px]]

* zwischen dem oberen und dem mittleren Steckverbinder ist ~1cm.
* über der 5mm LED ist die SMD0805 LED angeordnet

== Planungsstand ==
* 32 Kanäle
* 100MHz Samplerate
* 512K Speichertiefe pro Kanal
* Geschätzter Preis steht noch aus

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

Minila Version MockUp

2010-04-28T14:47:33Z

Remote1: /* LEDs */

== Voting einiger Dinge die im Thread angesprochen wurden ==
=== Spannungsversorgung ===
(Nach 5 Strichen "|" bitte ein Leerzeichen)
* USB Versorgt ohne galvanische Trennung der USB-Seite:
* USB Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite: |
* ext. Versorgt ohne galvanische Trennung der USB-Seite:
* ext. Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite:
Anmerkung: Es steht noch nicht fest ob der Stromverbrauch USB-Konform ist!!!

=== Bestückung ===
* SMD-Teile bestückt: |
* unbestückt als Bausatz:

=== LEDs ===
* SMD0805 LED:
* 5mm LED: |
* SMD0805 und 5mm LED (je nach Bestückung):

== Wünsche ==
=== Gehäuse ===
Fals einer eins gut findet, kann er das ja hier einbinden.

=== Andere Dinge können hier ebenfals hinzugefügt werden ===

== Feststehende Dinge ==
=== Spannungsversorgung ===
* Wahrscheinlich ein 3,3V sowie 5V Regler
* wenn USB-Versorgt abschaltbar um die Spezifikationen zu erfüllen

=== RAM-Speicher ===
* 512K*32 Kanäle steht ausser frage
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== USB ===
Je nach dem ob per USB versorgt oder nicht wird der FTDI FT2232D im:
* Bus Powerd Modus oder
* Self Powerd Modus
betrieben werden.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt

=== JTAG ===
* wird per Steckbrücke an den FTDI anklemmbar sein. Keine Litze notwendig
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale als Stiftleiste oder ähnliches herrausgeführt

=== Layout ===
* 2 Lagig

'''Top-Layer'''

[[Bild:MockUpMiniLALayoutEagleTop.png.png|500px]]

* zwischen dem oberen und dem mittleren Steckverbinder ist ~1cm.
* über der 5mm LED ist die SMD0805 LED angeordnet

== Plannungsstand ==
* 32 Kanäle
* 100MHz Samplerate
* 512K Speichertiefe pro Kanal
* Geschätzter Preis steht noch aus

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

Minila Version MockUp

2010-04-28T14:47:10Z

Remote1: /* Bestückung */

== Voting einiger Dinge die im Thread angesprochen wurden ==
=== Spannungsversorgung ===
(Nach 5 Strichen "|" bitte ein Leerzeichen)
* USB Versorgt ohne galvanische Trennung der USB-Seite:
* USB Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite: |
* ext. Versorgt ohne galvanische Trennung der USB-Seite:
* ext. Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite:
Anmerkung: Es steht noch nicht fest ob der Stromverbrauch USB-Konform ist!!!

=== Bestückung ===
* SMD-Teile bestückt: |
* unbestückt als Bausatz:

=== LEDs ===
* SMD0805 LED:
* 5mm LED:
* SMD0805 und 5mm LED (je nach Bestückung):

== Wünsche ==
=== Gehäuse ===
Fals einer eins gut findet, kann er das ja hier einbinden.

=== Andere Dinge können hier ebenfals hinzugefügt werden ===

== Feststehende Dinge ==
=== Spannungsversorgung ===
* Wahrscheinlich ein 3,3V sowie 5V Regler
* wenn USB-Versorgt abschaltbar um die Spezifikationen zu erfüllen

=== RAM-Speicher ===
* 512K*32 Kanäle steht ausser frage
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== USB ===
Je nach dem ob per USB versorgt oder nicht wird der FTDI FT2232D im:
* Bus Powerd Modus oder
* Self Powerd Modus
betrieben werden.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt

=== JTAG ===
* wird per Steckbrücke an den FTDI anklemmbar sein. Keine Litze notwendig
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale als Stiftleiste oder ähnliches herrausgeführt

=== Layout ===
* 2 Lagig

'''Top-Layer'''

[[Bild:MockUpMiniLALayoutEagleTop.png.png|500px]]

* zwischen dem oberen und dem mittleren Steckverbinder ist ~1cm.
* über der 5mm LED ist die SMD0805 LED angeordnet

== Plannungsstand ==
* 32 Kanäle
* 100MHz Samplerate
* 512K Speichertiefe pro Kanal
* Geschätzter Preis steht noch aus

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

Minila Version MockUp

2010-04-28T14:46:08Z

Remote1: /* Spannungsversorgung */

== Voting einiger Dinge die im Thread angesprochen wurden ==
=== Spannungsversorgung ===
(Nach 5 Strichen "|" bitte ein Leerzeichen)
* USB Versorgt ohne galvanische Trennung der USB-Seite:
* USB Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite: |
* ext. Versorgt ohne galvanische Trennung der USB-Seite:
* ext. Versorgt mit galvanische Trennung (ADuM4160) der USB-Seite:
Anmerkung: Es steht noch nicht fest ob der Stromverbrauch USB-Konform ist!!!

=== Bestückung ===
* SMD-Teile bestückt:
* unbestückt als Bausatz:

=== LEDs ===
* SMD0805 LED:
* 5mm LED:
* SMD0805 und 5mm LED (je nach Bestückung):

== Wünsche ==
=== Gehäuse ===
Fals einer eins gut findet, kann er das ja hier einbinden.

=== Andere Dinge können hier ebenfals hinzugefügt werden ===

== Feststehende Dinge ==
=== Spannungsversorgung ===
* Wahrscheinlich ein 3,3V sowie 5V Regler
* wenn USB-Versorgt abschaltbar um die Spezifikationen zu erfüllen

=== RAM-Speicher ===
* 512K*32 Kanäle steht ausser frage
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== USB ===
Je nach dem ob per USB versorgt oder nicht wird der FTDI FT2232D im:
* Bus Powerd Modus oder
* Self Powerd Modus
betrieben werden.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt

=== JTAG ===
* wird per Steckbrücke an den FTDI anklemmbar sein. Keine Litze notwendig
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale als Stiftleiste oder ähnliches herrausgeführt

=== Layout ===
* 2 Lagig

'''Top-Layer'''

[[Bild:MockUpMiniLALayoutEagleTop.png.png|500px]]

* zwischen dem oberen und dem mittleren Steckverbinder ist ~1cm.
* über der 5mm LED ist die SMD0805 LED angeordnet

== Plannungsstand ==
* 32 Kanäle
* 100MHz Samplerate
* 512K Speichertiefe pro Kanal
* Geschätzter Preis steht noch aus

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

Versenden von SMS mittels Mobiltelefon

2010-04-23T17:36:18Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern uint8_t foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in die Datei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-04-23T17:35:26Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmega8 ([http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 siehe MyAVR]).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.
Dabei ist zu beachten, dass die angelegten Funktionen stets vom Typ
<c>
uint8_t foo (uint8_t dat);
</c>
sind. In der Bibliothek muss der entsprechende Prototyp in der Datei sms.h angegeben werden. Z. B könnte das folgendermaßen aussehen:
<c>
extern foo (uint8_t dat);
</c>
Die eigentliche Funktion kann in dieDatei main.c geschrieben werden.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-31T08:52:59Z

Remote1: /* Hardware */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h). Alternativ dazu wäre auch die Verwendung der pinkompatiblen Controller ATmega168 bzw. ATmega328 denkbar. Diese haben 16KiB bzw. 32KiB Flash und sind unwesentlich teurer als der ATmeag8. Schaut einfach einmal bei [http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=8 myAVR] vorbei.

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T15:38:09Z

Remote1: /* Nutzung der Funktionen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
// main loop
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T15:37:39Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus '''Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T15:37:19Z

Remote1: /* SMS_MSG sms_state_machine(void) */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die '''Schlüsselwörter müssen dabei immer aus Kleinbuchstaben''' bestehen, da die eintreffende Textnachricht in Kleinbuchstaben konvertiert wird. Das erleichtert den Vergleich und verhindert ungewollte Schreibfehler bei Groß- und Kleinschreibung. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T11:35:22Z

Remote1: /* Voreinstellungen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus Kleinbuchstaben bestehen. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T11:35:04Z

Remote1: /* Voreinstellungen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus Kleinbuchstaben bestehen. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60+5 = 345</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können (60 ist die maximale Größe des PDU Header und 5 eine Kleine Reserve für Steuerzeichen wie new line).

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]

Versenden von SMS mittels Mobiltelefon

2010-03-30T11:17:46Z

Remote1: /* Voreinstellungen */

== '''Einleitung''' ==
Im Forum kommt immer häufiger die Frage "Wie werden Textnachrichten mittels eines handelsüblichen Mobilfunkgerätes versandt?". Im Rahmen einer Projektarbeit entstand dabei eine recht umfangreiche Bibliothek zu diesem Thema. Diese soll hier nun kurz vorgestellt werden.
Die Software beinhaltet unter anderem:
* Reaktion auf einen bestimmten Anrufer
* Versand von Textnachrichten im PDU Format
* Auslesen von Textnachrichten im PDU Format und Decodierung
* Auslesen des aktuellen Datums und der Zeit des Mobiltelefons
* Anzeigen von Text auf dem Display des Mobiltelefons
* Textphrasing von empfangenen Textnachrichten und Ausführen vorher eingestellter Aktionen/Funktionen auf bestimmte Schlüsselwörter
Die einzelnen Algorithmen sind dabei sehr einfach gehalten. Das bedeutet, dass es sicherlich sehr viel kürzere Varianten gibt, um z. B. einen Text in das PDU Format zu transformieren. Ich habe mich aber lieber auf mehr und damit für andere auch verständlicheren Code beschränkt. Das Verbraucht zwar mehr Speicher, trägt aber meines Erachtens mehr zum Verständnis bei.

== '''Hardware''' ==
[[Bild:ATmega8-Board.png|thumb|400px|Schaltplan des ATmega8 Boards mit I2C Temperatursensor]]
[[Bild:ATmega8-Board3D.png|thumb|250px|3D Ansicht des ATmega8 Boards]]

Ich arbeite selber mit einem Siemens SL55 Mobiltelefon. In einschlägigen Auktionshäusern sind diese betagten Mobilfunktelefone sehr günstig zu erwerben und damit ideal zum experimentieren geeignet. Neben dem Mobilfunktelefon wird natürlich auch ein entsprechendes serielles Datenkabel benötigt. Das Datenkabel wird über Pegelwander direkt mit dem Mobiltelefon und dem Mikrocontroller verbunden. Dadurch ist es möglich die serielle Schnittstelle des Mobilfunkgerätes anzusprechen.

Als erstes sollte die Kommunikation mit einem Computer überprüft werden. Dazu ist das Datenkabel an das Mobilfunkgerät anzuschließen. Mit einem Terminalprogramm wie hterm kann nun eine Kommunikation erfolgen. Dazu muss die serielle Schnittstelle entsprechen eingestellt werden. Bei dem SL55 ist eine Baudrate von 19200 im 8N1 Modus erforderlich.

Bei der Kommunikation mit einem Mikrocontroller ist darauf zu achten, dass die meisten Datenkabel einen Pegelwandler enthalten. Das bedeutet, dass der Pegel des Mobilfunkgerätes (meist Hight-Pegel 3,3V) auf den Pegel der seriellen Schnittstelle angepasst wird (Hight-Pegel -15V). Ein Mikrocontroller arbeitet dagegen mit Spannungen von 5V bzw. 3,3V. Die Anpassung geschieht mittels eines Pegelwandlers wie dem MAX232. Dabei ist zu beachten, dass im Kommunikationsweg nun 2 Pegelwandler vorhanden sind (Datenkabel und am Mikrocontroller). Das bedeutet, dass für eine Kommunikation mit einem Mobilfunkgerät die Leitungen Rx und Tx gekreuzt werden müssen. Dieser Umstand hat mir am Anfang relativ viel Zeit gekostet, da eine einfache Kommunikation mit einem Computer 1:1 geschehen kann. Es muss also zwischen Datenkabel und Mikrocontroller noch ein gekreuztes serielles Kabel dazwischen geschaltet werden.

Eine weitere Möglichkeit ist natürlich der direkte Anschluss der seriellen Schnittstelle des Mikrocontrollers am Mobiltelefon. Dabei ist zu beachten, dass im Fall einer Spannungsversorgung des Mikrocontrollers von 5V Pegelwandler für die Leitungen Tx und Rx nötig sind. Das können im einfachsten Fall 3,3V Z-Dioden sein.

Ich habe mich dafür entschieden, gleich eine kleine Platine mit einem ATmega8 anzufertigen. Dabei hab ich darauf geachtet, dass ich über Jumper die Leitungen Tx und Rx 1:1 bzw. gekreuzt schalten kann. Dadurch kann ich ohne zusätzliches gekreuztes serielles Kabel eine Kommunikation mit dem Mobilfunkgerät aufbauen. Die aktuelle Software passt nicht mehr in einen ATmega8. Ich arbeite aktuell mit einem ATmega32. Mit ein paar Anpassungen sollte es aber problemlos möglich sein, den Code in der Größe stark zu reduzieren. So können z.B. die Bibliotheken zur Ansteuerung des Temperatursensors entfallen (twi.c, twi.h, ds75lv.c und ds75lv.h).

== '''Software''' ==
Allgemein wird bei dem Softwarekonzept eine Mischung aus Interrupt und Polling genutzt. So werden z.B. Nachrichten vom Mobilfunkgerät über die serielle Schnittstelle des Mikrocontroller mittels UART Receive Interrupt empfangen, das Senden von Befehlen erfolgt aber mittels Polling. Wie die Kommunikation mit der seriellen Schnittstelle des Mikrocontrollers funktioniert, ist in einem anderen Artikel nachzulesen (siehe [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Der UART]) und soll an dieser Stelle vorausgesetzt werden. Für die einfachere Arbeit mit der seriellen Schnittstelle habe ich die Low-Level Funktionen auf die Standard Ein- und Ausgabe umgeleitet. Dadurch können die allseits bekannten Funktionen wie printf oder scanf für eine komfortable Kommunikation genutzt werden. Das vergrößert zwar den Code, ist aber dank einfacherer formatierten Ein- und Ausgabe mehr als gerechtfertigt.

c
AT-Kommandos sind spezielle Steuerkommandos, welche es ermöglichen das Mobilfunkgerät zu steuern. Für jedes Mobilfunkgerät gibt es einen AT-Command Set in dem alle relevaten Kommandos erklärt sind. Diese Kommandos sollten vorab mit einem Terminalprogramm wie hterm am Computer getestet werden. Von Mobilfunkgerät zu Mobilfunkgerät kann es bei den einzelnen Kommandos kleinere Unterschiede geben, so dass evtl. auch der Quellcode angepasst werden müsste.

=== '''Das PDU Format''' ===
Viele Mobilfunkgeräte können nur im PDU Format Textnachrichten versenden. Bei neueren Mobilfunkgeräten ist es zum Teil möglich, auch im Klartext Nachrichten zu verschicken. Das PDU Format soll an dieser Stelle einmal am Beispiel des AT-Kommandos AT+CMGS zum versenden von Textnachrichten näher erläutert werden.

Eine Kurznachricht mit dem Inhalt „Hallo Welt“ an die Nummer 01621234567 sieht z. B. folgendermaßen aus:

AT+CMGS=22<cr> 
0001000B811026214365F700000AC8309BFD065DCB6C3A<subst>

Die Zeichen <cr> und <subst> sind dabei Steuerzeichen, welche das Mobiltelefon benötigt. Das Steuerzeichen <cr> stellt dabei ein new line (dezimal 10) mit anschließendem carriage return (dezimal 13) dar und <subst> ein so genanntes substitute (dezimal 26).
Im Folgenden soll nun einzeln erläutert werden, inwieweit die Nachricht „Hallo Welt“ in das PDU Format kodiert werden kann.
Nach dem AT Kommando folgt die Länge der Hex Paare der PDU Zeichenkette ohne die beiden führenden Nullen. Das heißt, dass im obigen Beispiel 23 Hex Paare an das Mobiltelefon gesendet werden, aber lediglich 22 angegeben werden müssen. Die eigentliche PDU Zeichenkette beginnt mit „00“ und gibt die Länge der Short Massage Service Centre Nummer (SMSC) wieder. Die Längenangabe von null bedeutet, dass das Mobiltelefon selbst die eingespeicherte SMSC Nummer wählt. Mit Hilfe des zweiten Hex Paares können verschiedene Optionen eingestellt werden. Die Angabe von „01“ bedeutet, dass die SMS an das SMSC geschickt wird. Das nächste Hex Paar dient zum Zuordnen weiterer Nachrichten wie z. B. Berichten und ist die Referenznummer der Nachricht. Die Angabe von „00“ veranlasst dabei das Mobiltelefon dazu, die Referenznummer selbst zu wählen. Als nächstes folgen die Angabe der Länge der Empfängernummer, der Nummerntyp und entsprechend nachfolgend die Nummer. Die Länge der Empfängernummer wird durch das Hex Paar „0B“ angegeben und ist somit 11 Zeichen lang. Das Hex Paar „81“ gibt an, dass die nachfolgende Empfängernummer eine nationale Nummer ist. Bei der Angabe der Empfängernummer ist zu beachten, dass die einzelnen Ziffern der Paare der Nummer vertauscht werden. Aus der Nummer 01 62 12 34 56 7 wird dementsprechend 10 26 21 43 65 F7. Wie im Beispiel zu sehen, werden unvollständige Paare mit „F“ aufgefüllt. Die nächsten beiden Hex Paare sind der so genannte Protocoll Identifier und das Data Coding Scheme. Hier genügt jeweils die Angabe von „00“. Es folgt die Angabe der Länge der zu sendende Nachricht, hier „0A“. Im Anschluss daran wird die eigentliche Nachricht als PDU codierter String angehängt. Die Vorgehensweise ist dabei in unten stehender Tabelle dargestellt.

{| class="wikitable"
|+ '''Vorgehen beim Umwandeln einer Zeichenkette in das PDU Format'''
|-
| style="background-color:#B3B7FF;" | '''ASCII Zeichen''' || H || a || l || l || o || || W || e || l || t
|-
| style="background-color:#B3B7FF;" |'''8 Bit Binär''' || 01001000 || 01100001 || 01101100 || 01101100 || 01101111 || 00100000 || 01010111 || 01100101 || 01101100 || 01110100
|-
| style="background-color:#B3B7FF;" | '''7 Bit Biär''' || 1001000 || 110000'''1''' || 11011'''00''' || 1101'''100''' || 110'''1111''' || 01'''00000''' || 1'''010111''' || '''1100101''' || 1101100 || 111010'''0'''
|-
| style="background-color:#B3B7FF;" | '''8 Binär PDU''' || '''1'''1001000|| '''00'''110000|| '''100'''11011 || '''1111'''1101 || '''00000'''110 || '''010111'''01 || '''1100101'''1 || || '''0'''1101100 || '''00'''111010
|-
| style="background-color:#B3B7FF;" | '''8 Bit Hex PDU''' || C8 || 30 || 9B || FD || 06 || 5D || CB || || 6C || 3A
|}

Bei der Umwandlung wird zunächst der ASCII Text in eine 7Bit Darstellung überführt, indem das erste Bit gelöscht wird. Das bedeutet, dass nicht der gesamte ASCII Zeichensatz zur Verfügung steht (Zeichensatz siehe 3GPP 23.038). Als nächstes wird die 7Bit Darstellung wiederum in eine 8Bit Darstellung umgewandelt, indem beim ersten Zeichen das letzte Bit des nachfolgenden Zeichens am Anfang angefügt wird (siehe rote Markierungen in obiger Tabelle). Beim zweiten Zeichen werden entsprechend die letzten beiden Bits des nachfolgenden Zeichens angefügt. Dies wird solange fortgeführt, bis die kompletten 7Bit eines Zeichens an das vorhergehende angefügt worden und der Algorithmus von Anfang an beginnt. Stehen keine Zeichen mehr zur Verfügung, so wird mit Nullen aufgefüllt, bis das Oktett vollständig ist (siehe blaue Markierungen obiger Tabelle). Durch die Umwandlung von 8Bit ASCII Zeichen in eine PDU Zeichenkette konnte im obigen Beispiel ein Zeichen bei der Übertragung eingespart werden. Die zu übertragende Nachricht „Hallo Welt“ wird damit durch „C8309BFD065DCB6C3A“ repräsentiert.

=== '''Funktionsbeschreibung''' ===
Ich beschränke mich bei der Funktionsbeschreibung lediglich auf die wesentlichen Funktionen in sms.c. Die Funktionen der anderen Bibliotheken wie die der seriellen Schnittstelle, des Temperatursensors und der I2C-Schnittstellen sind der Quelltextdokumentation zu entnehmen. Die Dokumentation der einzelnen Funktionen erfolgt mittels Doxygen tags. Das heißt, mit Hilfe von Doxygen kann eine komplette HTML-Hilfe generiert werden.

===='''sms_init(void)'''====
Diese Funktion initialisiert die serielle Schnittstelle des Mikrocontrollers, leitet die Low-Level Funktionen der serielle Schnittstelle auf die Standard Ein- und Ausgabe um und nimmt einige Konfigurationen am Mobiltelefon vor. So wird z.B. das Echo beim senden von AT-Kommandos deaktiviert und der Speicherplatz für empfangene Textnachrichten auf den internen Speicher des Mobiltelefons eingestellt. Zudem wird die new message indication eingestellt. Das bedeutet, dass bei einer eingehenden Textnachricht dies über die serielle Schnittstelle dem Mikrocontroller mitgeteilt wird. Das erspart lästiges pollen nach neu eingetroffenen Textnachrichten.

===='''sms_time( unsigned char *year,unsigned char *month, unsigned char *day,unsigned char *hour, unsigned char *minute,unsigned char *second)'''====
Diese Funktion ließt das Datum und die aktuelle Zeit des Mobiltelefons aus.
Beispielaufruf:
<c>
...
unsigned char year=0;
unsigned char month=0;
unsigned char day=0;
unsigned char hour=0;
unsigned char minute=0;
unsigned char second=0;
sms_time (&year, &month, &day, &hour, &minute, &second);
...
</c>

===='''sms_send(char* zielnr, char* nachricht)'''====
Diese Funktion sendet ein Textnachricht an eine bestimmte Zielnummer
Beispielaufruf:
<c>
...
sms_send(SMS_TELNR,"Hallo Welt");
...
</c>
Dabei ist zu beachten, dass SMS_TELNR in der Headerdatei sms.h korrekt angegeben werden muss. Diese Nummer wird ebenso zur Reaktion auf eingehende Anrufe genutzt (siehe sms_state_machine).
Der Aufruf kann auch direkt erfolgen:
<c>
...
sms_send("01621234567","Hallo Welt");
...
</c>

===='''sms_decode (char* pdu, SMS_DECODE_DATA_T* data)'''====
Diese Funktion dekodiert empfangene Textnachrichten und legt diese in einer Datenstruktur ab.
Die Datenstruktur ist dabei folgendermaßen aufgebaut:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
Der Funktion muss dabei der komplette PDU String des AT-Kommandos AT+CMGR übergeben werden.
<c>
#define uart_maxstrlen 160
...
SMS_DECODE_DATA_T sms_dec_data;
char sms_tmp[uart_maxstrlen+1]={'0'};
int sms_index=0;
int dummy=0;
...
printf("AT+CMGR=%i\r\n",sms_index);
gets(sms_tmp); // führendes \r\n verwerfen
scanf("+CMGR: %i,,%i\r\n%s\r\n",&dummy,&dummy,sms_tmp);
...
sms_decode(sms_tmp,&sms_dec_data);
...
</c>

===='''sms_display_text(char* nachricht)'''====
Diese Funktion stellt eine Nachricht auf dem Mobiltelefon-Display dar.
Beispielaufruf:
<c>
...
sms_display_text("Hallo Welt");
...
</c>

===='''SMS_MSG sms_state_machine(void)'''====
Diese Funktion wertet alle einkommenden Daten des Mobiltelefons aus und wird in der main loop fortlaufend ausgeführt. Der Rückgabewert der Funktion entspricht dem zuletzt empfangenen Datensatz.
<c>
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Diese Funktion führt ebenso das Textphrasing bei empfangenen Textnachrichten durch. Die Zuordnung von Schlüsselwörtern erfolgt wiederum durch eine spezielle Datenstruktur:
<c>
typedef struct SMS_CMD_LIST_S{
char cmd[10]; /**< Zeichenkette für Kommando */
uint8_t (*fp)(uint8_t dat); /**< Funktionspointer auf Funktion, welche Kommando \ref cmd zugeordnet werden soll */
}SMS_CMD_LIST_T;
</c>
Die Parametrisierung der Datenstruktur erfolgt in der Datei sms.c.
Beispielhaft könnte diese wie folgt aussehen:
<c>
const SMS_CMD_LIST_T sms_cmd_list[] = {
{"set",sms_cmdset},
{"test",sms_cmdtest}
};
</c>
Die Schlüsselwörter müssen dabei immer aus Kleinbuchstaben bestehen. Die Definition der Trennzeichen zwischen den einzelnen Schlüsselwörtern erfolgt in der Headerdatei sms.h. Hier beispielhaft Komma, Semikolon, Doppelpunkt und Leerzeichen:
<c>
#define SMS_DELIMITER ",;: "
</c>
Eine eingehende textnachricht mit dem Inhalt "set, test" würde demnach die Funktionen sms_cmdset und sms_cmdtest ausführen.

==='''Verwendung der Bibliothek in eigenen Projekten'''===
Die Software wird als komplett kompilierbares Projekt zum Download bereitgestellt in dem auch die Hauptfunktionen und deren Anwendung erläutert werden. Zunächst müssen natürlich einige Einstellungen vorgenommen werden.
===='''Voreinstellungen'''====
Die Bausrate für die Kommunikation mit dem Mobiltelefon kann in der Datei uart.h über
<c>
/**
* definiert Baudrate für serielle Schnittstelle
*/
#define UART_BAUD 19200UL
</c>
geändert werden. Die Einstellung von 19200 Baud sollte aber bei den meisten Mobiltelefonen korrekt sein. Des Weiteren kann in der Headerdatei auch die Größe des Empfangspuffer über
<c>
/**
* Definiert die maximale Anzahl von Zeichen, welche über die

Rx-Interruptroutine empfangen werden können.
* Dient damit auch zum Festlegen der Größe der globalen Variable /ref

uart_string.
*/
#define uart_maxstrlen 380
</c>
eingestellt werden. Der relativ groß eingestellte Puffer kommt durch das PDU Format eingehender Textnachrichten zustande. Neben der eigentlichen codierten Nachricht wird noch der Header mit Telefonnummer, Zeitstempel und anderen Angaben zum Mikrocontroller übertragen. Die Textnachricht kann maximal 160 Zeichen enthalten. Im PDU Format werden 240 Zeichen für diese Textnachricht übertragen. Die minimale Puffergröße sollte 
<math>min Anz = 2\cdot\left(160-\frac{160}8\right)+60 = 340</math> 
sein, um korrekt Textnachrichten bis zu einer Länge von 160 Zeichen empfangen zu können.

Die Nächsten Einstellungen sind in der Headerdatei sms.h vorzunehmen. Hier muss zunächst die Telefonnummer über
<c>
/**
* Adressat, an welche SMS geschickt werden soll
* (immer führende 0 mitschreiben, NICHT +49)
*/
#define SMS_TELNR "01623456789"
</c>
angepasst werden. Dieses Makro kann zum einen genutzt werden, um mit Hilfe von sms_send() Textnachrichten zu verschicken, zum anderen dient es aber auch der Anrufererkennung in sms_state_machine(). Neben der Telefonnummer können in der Headerdatei auch die Trennzeichen für die Schlüsselwörter einer empfangenen Textnachricht eingestellt werden.
<c>
/**
* Trennzeichen um Befehle aus empfangenen Textnachrichten zu selektieren
*/
#define SMS_DELIMITER ",;: "
</c>
Dies sind die wichtigsten Einstellungen welche vorab überprüft werden müssen.

===='''Nutzung der Funktionen'''====
Neben der bereits erfolgten kurzen Funktionsbeschreibung, soll an dieser Stelle noch einmal auf die Besonderheit der Funktion sms_state_machine() eingegangen werden. Die Funktion wird zyklische in der main loop aufgerufen und hat als Rückgabewert folgenden Aufzählungstyp SMS_MSG:
<c>
/**
* zusammengefasste Auflistung als Rückgabewert der State Machine (\ref sms_state_machine)
*/
typedef enum {
SMS_OK, /**< OK von Mobiltelefon empfangen */
SMS_ERROR, /**< ERROR von Mobiltelefon empgangen */
SMS_MSG_DECODE, /**< Textnachricht eingegangen, decodiert und in \ref SMS_DECODE_DATA_T Struktur gespeichert */
SMS_INCOMING_RING, /**< eingehender Anruf */
SMS_CANCEL_RING, /**< eingehender Anruf wurde abgewiesen */
SMS_REQUEST_TELNR, /**< Telefonnummer des eingehenden Anruft wurde abgefragt */
SMS_RETRIEVE_TELNR, /**< Anrufer wurde abgewiesen, Telefonnummer ermittelt und korrekt mit \ref SMS_TELNR verglichen */
SMS_IDLE /**< empfangene Zeichenkette wurde nicht in sms_state_machine "gefunden" (kein Eintrag) */
} SMS_MSG;
</c>
Über diesen Aufzählungstyp kann der zuletzt empfangene Datensatz vom Mobiltelefon verifiziert werden. So bedeutet der Rückgabewert SMS_RETRIEVE_TELNR z. B. dass ein eingehender Anruf mit der in SMS_TELNR angegebenen Telefonnummer erfolgte. Auf diesen Anruf kann nun in der main loop entsprechend reagiert werden. Das erfolgt nach dem Schema:
<c>
...
uint8_t flag;
while(1){
flag = sms_state_machine();
if (flag == SMS_RETRIEVE_TELNR){
// mache irgend etwas
}
}
</c>
Neben SMS_RETRIEVE_TELNR ist ebenso der Rückgabewert SMS_MSG_DECODE von Relevanz. Er zeigt an, dass eine Textnachricht empfangen, decodiert und in der Datenstruktur sms_dec_data abgelegt wurde. Die Struktur der globalen Variable sieht dabei wie folgt aus:
<c>
/**
* @brief
* Struktur mit Datums- und Zeitangaben einer empfangenen Textnachricht
*/
typedef struct {
uint8_t year; /**< Jahresangabe YY */
uint8_t month; /**< Monatsangabe MM */
uint8_t day; /**< Tagangabe DD */
uint8_t hour; /**< Stundenangabe hh */
uint8_t minute; /**< Minutenangabe mm */
uint8_t second; /**< Sekundenangabe ss */
} DATE_T;

/**
* @brief
* Struktur zum speichern der decodierten Daten aus einer empfangenen Textnachricht
*/
typedef struct {
char nachricht[161]; /**< decodierte PDU Nachricht */
char telnr[16]; /**< Telefonnummer des Absenders */
DATE_T date; /**< Struktur mit Datums- und Zeitelementen (siehe \ref DATE_T) */
} SMS_DECODE_DATA_T;
</c>
So kann über sms_dec_data.nachricht die zuletzt eingegangene Textnachricht oder über sms_dec_data.date.day der Tag ausgelesen werden.

Ein weiterer wichtiger Aspekt der Bibliothek ist das Textphrasing empfangener Textnachrichten und das ausführen entsprechender Funktionen bei bestimmten Schlüsselwörtern. Nähere Erläuterungen zur Vorgehensweise und Einstellung der Schlüsselwörter sind dazu bereits in der obigen Funktionsbeschreibung zu sms_state_machine erfolgt.

== '''Download''' ==
[[Media: Software Stand 22.03.2010.zip | Software Stand 22.03.2010]]
[[Media: AT Command Set For L55 Siemens Mobile Phones And Modems.pdf|AT Command Set For L55 Siemens Mobile Phones And Modems]] 
[[Media: 3GPP 23.038 Alphabets ans language-specific information.zip| Länderspezifischer Zeichensatz der Mobiltelefone nach 3GPP 23.038 - Alphabets and language-specific information]] 
[[Media: GSM11-14V5-2-0.pdf|Nähere Erläuterungen zu den AT^SSTK Kommandos - Specification of the SIM Application Toolkit (GSM 11.14)]] 
[[Media: Application Note 323 - Interfacing GSM modems.pdf|ATMEL Application Note 323 - Interfacing GSM modems]]

== '''Quellen''' ==
==='''Allgmeine Quellen zum Thema'''===
* [http://twit88.com/home/utility/sms-pdu-encode-decode Online PDU Encoder und Decoder]
* [http://www.dreamfabric.com/sms/ SMS and the PDU Format]
* [http://www.mdetroy.de/reload.html?/hp_files/prog/s45/pdu.htm SMS PDU Dokumentation]
* [http://www.allpinouts.org/index.php/Siemens_Slim_Lumberg_%28A55,_C55,_S55,_SL55,_ST55,_M55%29 Siemens Slim Linburg Steckerbelegung]
* [http://www.3gpp.org/ftp/Specs/html-info/23038.htm 3GPP: Alphabets ans language-specific information]
* [https://bugs.cihar.com/file_download.php?file_id=86&type=bug Siemens Mobile: AT Command Set For L55 Siemens Mobile Phones And Modems]
* [http://www.atmel.com/dyn/resources/prod_documents/doc8016.pdf ATMEL: Application Note 323 - Interfacing GSM modems]

==='''Forenbeiträge'''===
* [http://www.mikrocontroller.net/topic/172516 Forumsbeitrag zu diesem Artikel]
* [http://www.mikrocontroller.net/topic/149989#new Beitrag zum versenden von SMS mit BASCOM]
* [http://www.mikrocontroller.net/topic/38862#new Sourcecode von Ulrich Radig zum SMS-Versandt]

[[Category:Projekte]]