Tag Archives: SMS

Texting a Bubble Gun (SMS with Arduino)

I wanted to demonstrate the usage of texting (SMS) for IoT (Internet of Things) and M2M (Machine to Machine communication). Therefore I disassembled a cheap bubble gun (usually less than 5 euros).

bubble_gun_step1
These are the places where soldering is needed.

In the next step I bypassed the batteries and the trigger with soldering two cables directly to the gun’s electronic circuit. That’s the fiddly part.

bubble_gun_step2
The relay on the left acts like a switch for the toy, on the right are the cables to the toy’s electric circuit.

The rest is just using an Arduino with a GSM shield, connecting it to a relay and plugging in the cables from the bubble gun.

Still one issue: The mechanism needs initial a mechanical created film for the bubbles. This would be possible with little effort, but the costs for the extra parts would exceed the gun’s price. Therefore I skipped this and did it manually. A different mechanic as used by the Gazillion Bubble Machine might solve this. By the way, the liquid seems to be very special, because the gun does not work with the standard bubble liquid from my kids.

Controlling this via phone is only one option. You also can use an API with any of your applications like Global SMS API or combine it with voice via Telekom Tropo.

But one tricky thing is still missing: The code for receiving the message. In this case the Arduino frequently checks only for patterns in all received messages.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void loop() {
   checkForInboundMessages();	
}
 
void checkForInboundMessages() {
   char inchar; // Will hold incoming character from the Serial Port  
   String pattern = "+CMT"; 
   String result;
 
   while(mySerial.available()!=0) {
      inchar = gsm.read();
      result = result + inchar;
   }
 
   result.toUpperCase();
   if (result.indexOf(pattern)>-1) {
 
      gsm.print("AT+CMGD=1,0\r");
 
      if (result.indexOf("ON")>-1) {
         digitalWrite(RELAY, HIGH);
      } else if (result.indexOf("OFF")>-1) {
         digitalWrite(RELAY, LOW);
      }
   }
 
}

Once you have built something like this, you are basically able to control every toy with an on-off switch – and not only toys. You only need to bypass the switch with a relay connected to a computer (e.g. Arduino or Raspberry Pi). I am looking forward to your ideas…

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.