Tag Archives: M2M

Send SMS mit dem Developer Garden SDK

Die Global SMS API zum Senden und Empfangen von Kurznachrichten kann auf verschiedene Arten genutzte werden. Letztendlich mündet dann zwar alles meist in JSON/XML über REST, aber wer das nicht mag, kann dank der Developer Garden SDKs vorbereitete Bibliotheken nutzen. Diverse Programmierwelten werden unterstützt, darunter Java, .NET, PHP, Objective-C und Python. Diese Bibliotheken verstecken auch viel Komplexität – beispielsweise die Abläufe bei der Authentifizierung – und erleichtern so den Einstieg. Außerdem hilft der bereitgestellte Quellcode, die Funktionsweise der API besser zu verstehen, möchte man doch einmal Low-level direkt mit der RESTful API arbeiten.

Download und Doku

global_sms_02 (Time 0_01_08;07)

Die SDKs sowie die Dokumentation stehen im Developer Garden zum Download bereit.

global_sms_02 (Time 0_01_33;29)

Natürlich ist der letzte Stand der Dokumentation als HTML dort auch online einsehbar.

Ein kleiner Tipp am Rande: Die Global SMS API folgt einem Anbieter-übergreifenden Standard namens One API der GSM Association. Bei der GSMA handelt es sich um die 1987 gegründete Industrievereinigung der GSM-Mobilfunkanbieter mit mittlerweile mehr als 800 Mobilfunkanbieter. Dort ist unter http://www.gsma.com/oneapi/sms-restful-netapi auch eine weitere hilfreiche Dokumentation zum Thema SMS API erhältlich.

global_sms_02 (Time 0_02_02;18)

Nachdem die Entscheidung für ein SDK gefallen ist (hier in diesem Beispiel .Net) muss die darin enthaltene Funktionalität noch bereitgestellt werden. Da sich im SDK der Quellcode befindet, kann wahlweise dieser eingebunden oder eine Bibliothek erzeugt werden. So oder so muss unter Windows das heruntergeladene ZIP-Archiv noch entsperrt (dies gelingt am leichtesten über das Kontextmenü der Datei im Bereich Eigenschaften) und entpackt werden.

global_sms_02 (Time 0_02_33;29)

Einmal entpackt, kann nun der Quellcode, der auch zahlreiche Beispiele umfasst, eingesehen werden. Die relevante Projektmappe (Solution) für die Bearbeitung mit Visual Studio ist Telekom.sln.

global_sms_02 (Time 0_02_48;10)

Falls man in seine eigenen Projekte nicht immer den ganzen Quellcode einbinden möchte, kann nun innerhalb von Visual Studio die Bibliothek (DLL) erstellt werden, indem man das Projekt einmal „baut“ (Menü Build -> Build Solution). Standardmäßig findet sich die fertige Bibliothek dann im Quellcodeverzeichnis unter src/Telekom/bin/Debug. Neben der Telekom.dll liegt dort die ebenfalls notwendige Bibliothek Newtonsoft.Json.dll für die Verarbeitung von JSON.

Aktivierung und Zugangsdaten

global_sms_01 (Time 0_00_54;00)

Doch bevor es nun ans Programmieren einer eigenen Anwendung geht, muss man sich erst einmal im Developer Garden anmelden und die Global SMS API aktivieren.

global_sms_01 (Time 0_02_00;02)

Letzteres gelingt nach erfolgreicher Anmeldung durch Klick auf „Mein Konto“ und die anschließende Aktivierung von Global SMS API innerhalb der API-Verwaltung. Hier werden übrigens auch die Rufnummern für den Versand und Empfang verwaltet.

global_sms_01 (Time 0_03_18;14)

In der Applikationsverwaltung wird nun – als letzter Schritt bevor es an die Programmierung geht – eine neue Applikation erstellt und dort die Global SMS API verfügbar gemacht.

global_sms_01 (Time 0_04_12;26)

Hier finden sich auch die für die Nutzung der API wichtigen Angaben Scope, Client ID und Sicherheitstoken. Für die Programmierung werden diese unbedingt gebraucht.

Programmierung

global_sms_02 (Time 0_03_54;05)

Die Nutzung der Global SMS API ist wie hier in einer WPF Anwendung (oder sonst einem Anwendungstypen aus der .Net-Welt wie z. B. Windows Forms) nun sehr einfach. Alles was wir dafür brauchen sind die Bibliotheken und die Nutzungsdaten (Scope, Client ID und Sicherheitstoken).

global_sms_02 (Time 0_04_30;16)

Als erstes füge n wir die beiden Bibliotheken Telekom.dll und Newtonsoft.Json.dll dem Projekt hinzu. Sollte die Datei Telekom.dll sich nicht im SDK-Verzeichnis unter src/Telekom/bin/Debug finden, dann muss diese wie oben beschrieben noch erzeugt werden.

global_sms_02 (Time 0_05_17;21)

Nun legen wir eine Klasse mit den Nutzungsdaten an, um Zugriff auf die API zu erhalten. Die Nutzungsdaten finden sich wie oben beschreiben für jede Anwendung innerhalb Ihres Developer Garden Kontos (My Account) in der Applikationsverwaltung unter https://www.developergarden.com/my-account/application-management/.

global_sms_02 (Time 0_06_30;13)

Als nächstes legen wir ein Interaktionselement fest, das den SMS-Versand auslöst. Hier eine Schaltfläche, die durch Klicken die notwendigen Befehle startet.

global_sms_02 (Time 0_12_15;07)

Innerhalb der Ereignismethode für die Schaltfläche wird zuerst die Authentifizierung unter Angabe der Nutzungsdaten durchgeführt:

1
2
TelekomOAuth2Auth authentication = new TelekomOAuth2Auth(Credentials.CLIENT_ID, Credentials.CLIENT_SECRET, Credentials.SCOPE);
authentication.RequestAccessToken();

Als nächstes müssen die Parameter für die SMS festgelegt werden. Darunter die Rufnummer des oder der Empfänger als Liste, die eigentliche Nachricht und die Absenderadresse – sofern noch keine validierte Rufnummer verfügbar ist, kommt als Absender 0191011 zum Einsatz. Andernfalls die gewünschte Rufnummer, diese dann aber mit dem Prefix „tel:“:

1
2
3
4
5
6
List receiverNumbers = new List();
receiverNumbers.Add("tel:+4915112345678");
SendSmsRequest request = new SendSmsRequest();
request.Numbers = receiverNumbers;
request.Message = "Developer Garden rocks!";
request.SenderAddress = "0191011";

Und im letzten Schritt wird die API noch aufgerufen (in diesem Beispiel durch einen synchronen Aufruf, es kann aber auch asynchron gearbeitet werden). Die Angabe ServiceEnvironment.Sandbox steht übrigens für die kostenlose aber auf 10 SMS am Tag beschränkte Nutzung:

1
2
SendSmsClient client = new SendSmsClient(authentication, ServiceEnvironment.Sandbox);
SmsResponse response = client.SendSms(request);

In der Code-Behind-Datei legen wir noch die notwendigen Usings zum Einbinden der Namensräume fest, sofern das nicht bereits automatisch geschehen ist:

1
2
3
4
5
6
using System.Collections.Generic;
using Telekom.Common;
using Telekom.Common.Auth;
using Telekom.Common.Model;
using Telekom.SendSms;
using Telekom.SendSms.Model;

global_sms_02 (Time 0_12_29;28)

Das war es soweit. Starten der Anwendung und das anschließende Klicken auf die Schaltfläche sollte nun eine SMS versenden. Sofern wie in der Abbildung ein Unterbrechungspunkt gesetzt und der Debugger aktiv ist, kann man auch den erfolgreiche Aufruf der API sehen. Übrigens gibt es im Developer Garden auch ein Forum für Ideen und Fragen zum Thema. Viel Spaß…

Connected Things mit Arduino und (fast) ohne Internet

Arduino und SMS in Action

Es gibt unzählige Möglichgeiten, Geräte mit dem Internet zu verbinden. Doch oft ist es gar nicht so einfach, eine Internetverbindung mit all den Protokollen auf eher schwachbrüstigen Geräten umzusetzen. Außerdem ist Internet auch nicht immer vorhanden (wenn man z. B. von landwirtschaftlichen Anwendungsfällen ausgeht). Und manchmal ist Internet auch nicht erforderlich, wenn man nur Statusmeldungen und einfache Steuerbefehle austauschen möchte.

Arduino-kompatibles GBoard mit SIM900 GSM-Chip

Wer hiermit erste Erfahrungen sammeln möchte, für den bietet sich ein Embedded-Device als Entwicklerplattform an. Beispielsweise Arduino. Wer eher einen General-Purpose-Computer in vergleichbar kompakter Bauform nutzen möchte, kann natürlich auch auf einen Rapberry Pi zurückgreifen. Beiden fehlt jedoch ein GSM-Modem, um ganz ohne Internetverbindung Daten unabhängig von der Entfernung auszutauschen. Dies lässt sich aber in beiden Fällen leicht nachrüsten. Beim Raspberry gibt es kompatible USB-Sticks, für Arduino ist eine Auswahl an sogenannten Shields mit GSM/GPRS-Funktion erhältlich. Im letzteren Falle kann man aber auch gleich auf das GBoard zurückgreifen. Dabei handelts es sich um ein Arduino-kompatibles Board mit GSM-Modem.

Im Falle von Arduino findet sich ein hervorragender Einstieg in die Nutzung des GSM-Modems für das Internet unter http://www.cumulocity.com/guides/developers-guide/startwitharduino. Es geht aber noch einfacher, wenn man Daten nur per Kurznachricht Senden und Empfangen möchte.

Im Wesentlichen benötigt man nur eine serielle Verbindung zum GSM-Modem. Bei normaler Konfiguration gelingt das mit der standardmäßig eh vorhandenen Arduino-Bibliothek SoftwareSerial – beim GBoard sieht das dann meist so aus:

1
2
3
4
5
6
7
8
9
#include 
SoftwareSerial mySerial(2, 3); // RX, TX
void setup() {
   // Open serial communications
   Serial.begin(9600); // Serial Monitor
   mySerial.begin(9600); // GSM Shield
   sendMessage();
   ...
}

Sobald man hier die richtigen Datenleitungen und Baudrate (hier 9600) gefunden und eingestellt hat, geht es an die Programmierung mit sogenannten AT-Kommandos:

1
2
3
4
5
6
7
8
9
10
11
void sendMessage() {
   // mySerial.print("AT+CPIN=1234\r"); // Do not forget your PIN
   // delay(100);
   mySerial.print("AT+CMGF=1\r"); // Because we want to send the SMS in text mode
   delay(200);
   mySerial.print("AT+CMGS=\"+49151987654321\"\r"); // Send message, be careful need to add a country code before the cellphone number
   delay(200);
   mySerial.print("Alarm, something was activated!"); // The content of the message
   delay(200);
   mySerial.print((char)26); // Finish message and use the ASCII code for ctrl+z
}

Wenn das kleine Programm nun gestartet ist, wird eine Kurznachricht gesandt. Zumindest sofern das Modem auch eingeschaltet ist. Leider muss man das meist selber per Hand erledigen oder dafür noch zusätzlichen etwas trickreicheren Programmcode verfassen (weshalb wir uns hier mit der händischen Methode begnügen).

Eine Alarmanlage wäre damit bereits einfach möglich. Aber wenn Sensordaten gesammelt und ausgewertet werden sollen, dann müssen die Kurznachrichten doch letztendlich irgendwie wieder in einen Computer. Klar, eine Gegenstelle mit einem GSM-Modem wäre eine Option. Doch eleganter und ganz ohne Hardware geht es mit der Global SMS API.

Buchtipp: Durchstarten mit Raspberry Pi

Eine große Stärke des Einplatinen-Computers Raspberry Pi sind die vielfältigen Einsatz- und Erweiterungs-Möglichkeiten. Doch wie legt man eigentlich los? Erik Bartmann beantwortet diese Frage und hilft beim „Durchstarten mit Raspberry Pi“.

Unterstützt durch ein ansprechendes und mehrfarbiges Layout liest sich das Buch gut – sofern man die eher flapsige Art des Autors mag. Klasse sind die zahlreichen Hinweise, die typische Fragen und Stolperfalle hervorheben und anschaulich erklären. Verwirrend ist jedoch der Wechsel zwischen virtualisierten Linux-Umgebungen und dem echten Raspberry Pi. Zumal auch mehrere Betriebssystem-Versionen wie Debian Squeeze und das neuere Debian Wheeze im Buch vorkommen. In Anbetracht des frühen Erscheinungstermins des Buches ist klar, dass die neueste Hardware-Revision fehlt: Hier ist unbedingt Vorsicht geboten, wenn man sich mit den Hardware-nahen Beispielen im Buch befasst. Aber der Autor hat darauf reagiert und bereits einen entsprechenden Artikel (PDF) verfasst. Gut gefällt der Rundumschlag zu Linux, inklusive Kommandozeile und der grafischen Benutzungsoberfläche. Das nötigste wird bereits im Buch vermittelt und am Ende gibt es noch einmal ein hilfreiches Zusatzkapitel mit Linux-Grundlagen.

Der umfangreiche Einstieg in die Raspberry Pi Welt umfasst neben Installation und Konfiguration auch die Paketverwaltung. Darauf folgt ein Schnelleinstieg in die Programmierung mit Python und C. Dass diese rund 40 Seiten Programmierkurs einem Einsteiger viel nützen, bezweifle ich. Dennoch ist es ein schöner Überblick, um mit Hilfe von Zusatzliteratur oder Vorkenntnissen schnell zu einem Raspberry-Pi-Programmierer zu werden.

Eine Stärke des Buches sind die Themen, bei denen es um die Erweiterungsfähigkeiten des Raspberry Pis geht. Sowohl das Zusammenspiel mit Arduino als auch die GPIO-Pins und Erweiterungsplatinen wie Gertboard und PiFace werden behandelt. Schade ist, dass dem Leser hier wenig Entscheidungshilfe gegeben wird, welcher Weg sich für was eignet. Drum herum werden noch elektrotechnische Grundlagen vermittelt und das so anschaulich und gut, so dass man sich davon mehr wünschen würde – gerade wenn man eher von der Code-Seite kommt.

Wer einen ansprechenden Einstieg in die Erweiterungsmöglichkeiten des Raspberry Pi sucht, erhält mit diesem Buch einen umfassenden Überblick. Die Breite der behandelten Themen ist groß. Darunter leidet zwar ab und zu der Tiefgang, doch entsprechende Vorkenntnisse oder Zusatzliteratur vorausgesetzt, kann das auch ein Vorteil sein. Das Buch ist durchaus für den ambitionierten Einsteiger geeignet ohne den Fortgeschrittenen zu langweilen.

„Durchstarten mit Raspberry Pi“
Autor: Erik Bartmann
Preis: ca. Euro 25,-
ISBN: 3868994106
Erscheinungsdatum: O’Reilly, 28. Oktober 2012
Link: Amazon