IoT: Chancen und Herausforderungen für Software-Entwickler:innen
Das Internet of Things ermöglicht uns, in Software-Systemen auf Geräte in der "echten" (physischen) Welt zuzugreifen. Durch immer günstigere Hardware sowie die Erforschung neuer Einsatzmöglichkeiten findet das IoT mittlerweile Einzug in fast alle Lebensbereiche – von Haushalten (Smart Home) über Gesundheit (Quantify Me) und Pflege bis zur industriellen Produktion (Industrie 4.0). Die Entwicklung von Software, welche die Möglichkeiten dieser IoT-Geräte ausschöpft und erweitert, erlaubt es Software-Entwickler:innen, die damit einhergehende Innovation aktiv mitzugestalten. In diesem Artikel gehen wir darauf ein, welche Chancen wir als Software-Entwickler:innen nutzen können, indem wir Software für das IoT entwickeln, und welchen Herausforderungen wir bei der Entwicklung solcher Software gegenüberstehen.
Chancen für Software-Entwickler:innen
Software ist der Grundpfeiler des IoT, der es erst ermöglicht, das Potenzial von verknüpften Geräten tatsächlich auszuschöpfen. Um dieses Potenzial möglichst effizient auszunutzen, benötigt es jedoch das Know-how von Expert:innen im Bereich Software Engineering. Doch weshalb sollten wir uns als Software-Entwickler:innen nun mit dem Thema IoT befassen? Konkret ergeben sich dabei folgende Chancen (Abb. 1 für einen Überblick).
Entwicklung innovativer Software-Lösungen
Das IoT ermöglicht eine Vielzahl neuer Einsatzmöglichkeiten von Software. Durch Interaktion mit Geräten und deren Simulationen kann Software proaktiv auf laufende Prozesse Einfluss nehmen, um diese zu optimieren oder Fehlern frühzeitig vorzubeugen. Durch Entwicklung solcher Lösungen können wir die Innovationen, welche die Verbreitung von IoT-Geräten in den nächsten Jahren vorantreiben werden, aktiv mitgestalten. Dafür können wir Wissenslücken über die Spezifika von IoT-Anwendungen und die Herausforderungen bei deren Entwicklung durch eine Vielzahl bestehender Workshops und Schulungen effizient füllen. Dieser Artikel soll dabei einen ersten Einblick in diese Themen geben.
Wiederverwendung bestehenden Software-Engineering-Wissens
Der große Mehrwert, den wir als Software-Entwickler:innen in die IoT-Welt einbringen können, ist das Wissen zur effizienten Entwicklung und Wartung von Software, welches wir über die letzten Jahrzehnte erarbeitet haben. Aktuell entwickeln oft noch Hardware-Spezialist:innen viele IoT-Anwendungen. Da diesen Expert:innen jedoch in der Regel dieses Software-Engineering-Wissen fehlt, ist die verwendete Software häufig mangelhaft, fehleranfällig und sehr schwer erweiterbar. Solche Eigenschaften sind jedoch gerade im IoT-Bereich unvorteilhaft, da ein Software-Fehler Hardware im Wert von tausenden Euro zerstören kann oder Systeme meist im Nachhinein Schritt für Schritt um Geräte erweitert werden. Als Ergebnis ist heutzutage ein großer Teil des möglichen Innovationspotenzials noch nicht ausgeschöpft, aufgrund des Mangels an Software-Engineering-Expert:innen bei der Entwicklung von IoT-Lösungen.
Um nun das Wissen und die Techniken, die wir Software-Entwickler:innen bereits tagtäglich nutzen, auch auf das IoT anzuwenden, müssen wir diese bestehenden Techniken jedoch an die neuen Anforderungen anpassen, welche das IoT an die entsprechende Software stellt. Auf die konkreten Herausforderungen, gehen wir am Ende dieses Artikels noch genau ein. Zuvor untersuchen wir aber, was die Entwicklung von Software für IoT-Systeme nun von klassischer Software-Entwicklung unterscheidet.
Charakteristika von IoT-Systemen
Was unterscheidet nun die Entwicklung von Software für das IoT konkret von klassischer Client/Server- oder Microservice-Entwicklung?
Abb. 2 zeigt ein Beispiel, wie in einem solchen IoT-System ein Set an Software-Komponenten ein unerwartetes Hindernis während der Bewegung eines Industrieroboters erkennen und entsprechend gegensteuern kann. Dieses Beispiel zeigt klar folgende Charakteristika von IoT-Systemen auf:
- Verschmelzung von Hardware und Software: Die verwendete Software interagiert in diesem Beispiel nahtlos mit der Hardware unseres IoT-Systems. Die Abweichungserkennung holt sich laufend Daten über den Betrieb der Roboter, wie beispielsweise die aktuelle Position jedes einzelnen Greifarms. Die Ausführungs-Engine führt Befehle auf dem laufenden System aus, um so Einfluss auf dessen Verhalten zu nehmen. Dieses Verhalten beeinflusst wiederum die Daten, welche der Roboter an die Abweichungserkennung sendet.
- Verschmelzung von physischer und simulierter Welt: Neben dem tatsächlichen physischen Gerät benötigen viele Anwendungen auch Simulationen dieses Geräts. Solche Simulationen bilden das physische Verhalten nach. Dadurch können Anwendungen auf dieses Verhalten zugreifen, ohne Einfluss auf das tatsächliche physische Gerät zu nehmen. Das ist hilfreich beim einfachen Testen von Hardware bis zur Fehlererkennung für Predictive Maintenance.
Wenn wir zum Beispiel testen wollen, ob unser Roboter in einem Szenario überhitzt oder nicht, sollten wir dies am besten in einer Simulation überprüfen – beim echten Roboter können wir im Fehlerfall nicht einfach auf "Restart" drücken. Die Simulation ermöglicht uns hingegen eine virtuelle Spielwiese, in der wir Fehlerfälle testen können. Das ist bereits sehr hilfreich bei der Entwicklung von Software für das IoT. Wirklich interessant wird diese simulierte Welt aber erst, sobald wir sie mit unseren realen Geräten verschmelzen, wie im Beispiel aus Abbildung 2. In diesem Beispiel holt sich die Software-Komponente zur Abweichungserkennung regelmäßig die aktuelle Position sowohl vom echten Roboter als auch von dessen Simulation. Sobald diese Daten nicht mehr übereinstimmen, muss die Abweichungserkennung gemeinsam mit dem Planner (auch jeweils eigene Software-Komponenten) eine geeignete Gegenmaßnahme ermitteln, um den physischen Zwilling wieder auf Kurs zu bringen. Dafür müssen diese Software-Komponenten die Ursache für die Abweichung identifizieren (1) sowie die Simulation entsprechend anpassen, um die neuen Umstände in der physischen Welt zu berücksichtigen (2). Zum Beispiel kann ein Hindernis in der physischen Welt, welches die Simulation noch nicht berücksichtigt, dazu führen, dass der Roboter plötzlich unerwartet stoppt. Die Simulation muss dann einen neuen Weg errechnen, um trotz dieses Hindernisses zum geplanten Ziel zu kommen. Die Ausführungs-Engine führt diesen neuen Weg dann anschließend am echten Roboter aus, um diesen wieder mit seiner Simulation zu synchronisieren.
Herausforderungen für Software-Entwickler:innen
Aus den oben beschriebenen Charakteristika ergeben sich eine Reihe von Herausforderungen, wenn wir bestehende Software-Entwicklungs-Methoden im IoT einsetzen wollen. Als Software-Entwickler:innen können wir uns aber bereits erster Lösungsansätze bedienen, um diese Herausforderungen erfolgreich zu meistern und so möglichst effizient hochqualitative Software für das IoT zu entwickeln.
class DeviationChecker{
Analyzer analyzer;
float threshold;
void compareXValues(Robot robot1) throws InterruptedException{
while(true){
Date time = null; // challenge: wie finde ich den Zeitpunkt, an dem die Datenpunkte vergleichbar sind?
float deviation = robot1.physical.getX(time) - robot1.simulation.getX(time);
if(deviation > threshold){
analyzer.handleDeviationXValues(robot1, deviation);
}
Thread.sleep(10);
}
}
}Herausforderung 1: Arbeiten mit Zeitseriendaten
Als Software-Entwickler:innen sind wir daran gewöhnt, mit Zuständen von Objekten zu arbeiten, die meist durch die zugehörigen Klassen eine klar vorgegebene Struktur haben. Wie bereits beschrieben, sind IoT-Systeme jedoch durch Daten von Geräten oder Simulationen geprägt. Hierbei handelt es sich in der Regel um sogenannte Zeitseriendaten (engl. timeseries data) – jeder Datenpunkt ist dabei durch ein Tripel Zeitpunkt: Attribut=Wert (zum Beispiel T1: x=5) definiert. Mit anderen Worten: Ein Gerät sendet zu einem gewissen Zeitpunkt den aktuellen Wert eines konkreten Attributs. Diese Werte ändern sich natürlich über die Zeit. In Abb. 3 sendet zum Beispiel der Roboter seine Position entlang der X-Achse zu verschiedenen Zeitpunkten.
Die erste Herausforderung für Software-Entwickler:innen im IoT besteht also darin, Code zu schreiben, der mit diesen Zeitseriendaten umgehen kann. Dabei geht es vor allem darum, traditionelle Annahmen der objektorientierten Software-Entwicklung zu überdenken. Man arbeitet nicht mehr auf einem konkreten, wohldefinierten Zustand eines Objektes – sondern Objekte sind vielmehr Datenlieferanten, deren Zustände sich kontinuierlich anpassen. Dabei liefern die Geräte selbst laufend neue Daten, ohne dass man sie bewusst manipuliert (im Gegensatz zu klassischen Softwareobjekten, bei denen eine Zustandsänderung in der Regel durch einen Methodenaufruf ausgelöst wird).
Lösungsansatz: Software-Frameworks für Zeitseriendaten
Glücklicherweise gibt es hier jedoch bereits Hilfe – von Frameworks zur asynchronen Verarbeitung von Datenströmen wie Apache Kafka oder Azure IoT-Hub und Stream Analytics bis zur effizienten Speicherung und dem Zugriff auf gespeicherte Daten über sogenannte Zeitseriendatenbanken wie InfluxDB.
Herausforderung 2: Gleichzeitiges Arbeiten mit mehreren Datenlieferanten
Meistens arbeiten wir im IoT jedoch nicht nur mit einer einzelnen Datenquelle, sondern verarbeiten und verwalten gleichzeitig Daten verschiedener Geräte sowie mehrerer Simulationen pro Gerät. Abb. 3 zeigt hier ein vereinfachtes Beispiel, in dem eine einzige Simulation Daten über die Position des Roboters parallel zum echten Gerät sendet. Selbst an diesem einfachen Beispiel sieht man bereits, dass es sehr schwierig ist, diese verschiedenen Daten vergleichbar zu machen. Die Simulation liefert deutlich weniger Datenpunkte und kommt auch schneller zum erwarteten Ergebnis (x=4.0). Wenn die Abweichungserkennung nun Unterschiede identifizieren will: Welche Datenpunkte des echten Roboters und der Simulation soll es jeweils miteinander vergleichen?
Sobald wir jedoch mehrere Roboter oder eine größere Zahl an Datenlieferanten pro Roboter verwalten müssen, wird auch relativ schnell klar, dass hierfür eine reine Zeitreihendarstellung wie in Abb. 3 nicht mehr ausreicht. Die Datenquellen pro Gerät zu erhöhen macht zum Beispiel Sinn, wenn man nicht auf die Korrektheit einer einzelnen Simulation vertrauen will. Dann kann man zuerst das Ergebnis mehrerer Simulationen vergleichen und den aus diesen Simulationen ermittelten Wert im Anschluss dem laufenden System gegenüberstellen. Wenn wir die Daten jedoch nur in der Form Zeitpunkt: Attribut=Wert erhalten, können wir nicht zwischen den einzelnen Simulationen oder dem echten Gerät unterscheiden.
Lösungsansatz: Vordefinierte Struktur
Wir müssen die Zeitseriendaten also in eine vordefinierte Struktur bringen, wie wir es aus der klassischen objektorientierten Software-Entwicklung kennen. Diese Struktur muss uns ermöglichen, Daten klar Datenlieferanten zuzuordnen (1) und mehrere Lieferanten, die Daten über dasselbe Gerät liefern zu gruppieren (2). Abb. 3 zeigt hier eine Möglichkeit, bei welcher die Methode compareXValues ein Objekt (robot1) mit mehreren Attributen für die einzelnen Datenlieferanten (in diesem Fall physical und simulation) erwartet. Jedes Attribut referenziert wiederum ein eigenes Objekt, das über vorgegebene Methoden eine Interaktion mit dem jeweiligen Datenlieferanten ermöglicht. Als Software-Entwickler:innen reicht es uns aber natürlich noch nicht, diese Strukturinformationen händisch im Code abbilden zu müssen. Deshalb gibt es bereits erste Datenbanken, die es erlauben, die Struktur hinter Zeitserien gemeinsam mit den laufend aktualisierten Werten abzuspeichern, ohne dabei auf die Vorteile von Zeitseriendatenbanken verzichten zu müssen. Timescale ermöglicht das beispielsweise durch eine Erweiterung von PostgreSQL für Zeitserien, während die kommerzielle Alternative von Microsoft (TimeSeries Insights) auf In-Memory-Datenbanken setzt.
Herausforderung 3: Heterogenität von Datenlieferanten
Der Roboter aus Abb. 3 ist jedoch nicht die einzige Maschine, auf die wir in unseren IoT-Anwendungen zugreifen wollen. In Maschinenhallen arbeiten meist hunderte Förderbänder ineinander, während verschiedene stationäre oder mobile Roboter genauso wie Menschen Werkteile von einem Förderband zum nächsten transportieren. Da diese Geräte in der Regel von verschiedenen Herstellern produziert werden, verwenden sie alle unterschiedliche Kommunikationsprotokolle, Programmiersprachen und Austauschformate. Unsere Software, welche nun auf diese Geräte zugreifen will, muss dafür all diese unterschiedlichen Formate und Protokolle kennen, verstehen und dem korrekten Gerät zuordnen können. Damit jedoch noch nicht genug: Wir wollen ja auch mit den Simulationen dieser Geräte interagieren können. Hier gibt es natürlich auch verschiedene Tools mit unterschiedlichen Protokollen. Hinzu kommen dabei jedoch unterschiedliche Arten von Simulationen mit ihren Eigenheiten bei der Interaktion. Ein Beispiel: Eine kontinuierliche Simulation kann die Bewegung eines Förderbandes oder Greifarms abbilden, während eine diskrete Simulation generelle Auskunft darüber gibt, ob ein Förderband gerade läuft oder nicht bzw. der Greifarm etwas ablegen oder aufnehmen soll. Diese Heterogenität in der physischen und simulierten Welt macht die Entwicklung von Software für das IoT enorm komplex.
Lösungsansatz: Digitale Zwillinge
Auch zum Lösen dieser Herausforderung gibt es bereits Unterstützung. Digitale Zwillinge als "virtuelles Abbild eines physischen Systems" bilden eine einheitliche Methodik, um die Funktionalitäten von IoT-Geräten mithilfe von Software zu erweitern. Dabei verwalten diese Zwillinge die Heterogenität in der physischen Welt durch eine einheitliche Schnittstelle zwischen Geräten und deren Simulationen auf der einen Seite und Software auf der anderen Seite. Diese Schnittstelle erfordert ein einheitliches Format von jedem einzelnen Datenlieferanten und bietet dieses Format mit den zugehörigen Daten über ein Software-Kommunikationsprotokoll an. Das erfordert natürlich einen Wrapper der anbieterspezifischen Daten in diese neutrale Schnittstelle wie in Abb. 4 angedeutet. Als Ergebnis ist es für Software-Komponenten des digitalen Zwillings dann ausreichend, diese neutrale Schnittstelle zu verstehen, um mit allen möglichen Geräten und Simulationen des dahinterliegenden IoT-Systems zu interagieren.
Zusammenfassung und Ausblick
Dieser Artikel zeigt auf, warum wir uns als Software-Entwickler:innen möglichst bald mit dem Thema IoT auseinandersetzen sollten. Durch die besonderen Charakteristika von IoT-Systemen (Verschmelzung von Software und Hardware und Verschmelzung von echter und simulierter Welt) ergeben sich eine Reihe von Herausforderungen, wenn wir mit klassischen Software-Entwicklungs-Techniken Software für das IoT entwickeln wollen. Lösungsansätze wie Zeitseriendatenbanken und digitale Zwillinge erweitern bereits bestehende Software-Engineering-Ansätze, um diese Herausforderungen möglichst effizient zu bestehen.
Durch Verwendung dieser Lösungsansätze und Berücksichtigung der dahinterliegenden Herausforderungen können wir so mit innovativer Software für das IoT die digitalisierte Zukunft aktiv mitgestalten. Dafür ist natürlich die technische Vertiefung der in diesem Artikel vorgestellten Themen nötig – Fähigkeiten, welche wir durch aktive Teilnahme an Workshops und Schulungen effizient erlernen können.
