Herausforderungen bei IoT- und Smart Products Projekten

Heutzutage ist Embedded Software Entwicklung nicht mehr vergleichbar mit dem, was noch vor 10 Jahren Stand der Technik war. Die IoT-Produkte werden immer komplexer und die IoT-Hardware immer leistungsfähiger. Steigende Komplexität beim Embedded Software Design führt aber aber zwangsweise auch zu einer höheren Fehleranfälligkeit.

Gerade bei Smart Products ist aber die Robustheit des Embedded Software Designs ein ganz entscheidendes Kriterium. Denn die IoT-Devices müssen häufig über sehr lange Zeiträume laufen, haben aber kein User Interface, um das Gerät neu zu starten, wenn es mal hängt.

Mit klassischen Software-Entwicklungs-Methoden lässt sich aber die Komplexität bei der Entwicklung eines robusten Embedded Software Designs kaum mehr beherrschen. Zahlreiche von uns durchgeführte Code-Review-Projekte zeigen das immer wieder schmerzlich aufs Neue.

Doch wie erreicht man nun einen anderen Level bei der Embedded Software Entwicklung für Smart Products mit einem Real Time OS wie z.B. RTOS oder ThreadX?

 

Quality by Design: Das Standard Finite State Machine Framework

Das Zauberwort heißt hier: Event Driven Architecture. Durch den Einsatz eines Standard Finite State Machine Framework (http://www.state-machine.com/) erreicht man einen neuen Level an Stabilität und Robustheit im Embedded Software Design. Dabei geht die Architektur weg von klassischen Thread-Syncronisations-Methoden hin zu Event gesteuerten Programmabläufen.

Dieses Schaubild verdeutlich diesen Paradigmenwechsel sehr gut:

Embedded Software Design Paradigm Shift

http://embedded-computing.com/eletter-products/asynchronous-event-driven-architecture-for-high-reliability-systems/

Doch warum ist nun eine Event Driven Architecture so viel besser als „klassische“ Embedded Software Entwicklungs-Methoden?

Dafür gibt es zwei Gründe:

 1. Threads

Threads sind eine große Hilfe bei der Entwicklung komplexer Embedded Software. Allerdings gestaltet sich die Synchronisation und Kommunikation schwierig und erfordert vom Entwickler ein sehr hohes Maß and Disziplin, Erfahrung und Überblick über den Code. Mit wachsender Komplexität der Anwendung wird das Thread Handling aber immer anfälliger für Fehler. Die üblichen damit einhergehenden Probleme sind Race Conditions, Deadlocks, Performance Probleme, usw. Fehler in diesem Bereich sind in der Regel auch am schwersten zu finden und zu reproduzieren.

Um diese Probleme beim Embedded Software Design zu adressieren, hat man entsprechende Regeln für die Software Entwickler erdacht.

Siehe: https://herbsutter.com/2010/07/12/effective-concurrency-prefer-using-active-objects-instead-of-naked-threads/


  1. Don’t block inside your code. Instead communicate among threads asynchronously via event objects → This makes threads run truly independently, without blocking on each other
  2. Don’t share any data or resources among threads. Keep data and resources encapsulated inside threads (“share-nothing” principle) and instead use events to share information
  3. Organize your threads as “message pumps” (event queue + event loop)

Wenn man es schafft, diese Regeln konsequent umzusetzen, erhält man entsprechend robusten Embedded Software Code. Die Erfahrung zeigt aber, dass Menschen immer wieder Fehler machen bzw. sich aufgrund von Komplexität Fehler einschleichen.

Die Lösung:
Durch den Einsatz des Standard Finite State Machine Framework erzwinge ich die Einhaltung der oben genannten Regeln einfach durch eine Umkehr der Kontrolle. Das Framework sorgt mit dem Design dafür, dass die Spielregeln bei der Embedded Software Entwicklung eingehalten werden und ich kann als Entwickler keine solchen Fehler mehr einbauen.

 2. Spaghetti Code

In der Regel fängt alles immer ganz harmlos an und der Entwickler schreibt eine Methode, um Events zu verarbeiten. Mit der Zeit kommen jedoch immer mehr neue Events und immer komplexere Bedingungen hinzu. Die if-then-else Statements werden mehr und mehr und immer verschachtelter – bis zu dem Punkt, dass ein Außenstehender nicht mehr versteht, was eigentlich passiert. Dieses Problem lässt sich dann durch entsprechendes Refactoring zwar wieder eindämmen – besser wäre es aber, wenn es erst gar nicht entstehen kann.

Die Lösung:
Auch dafür sorgt das Standard Finite State Machine Framework, weil hier gänzlich anders an die Problemstellung heran gegangen werden muss. Das führt nachweislich zu besseren Ergebnissen bei der Entwicklung eines robusten Embedded Software Designs. Eine sehr schöne Beschreibung (englisch) gibt es hier:
https://www.state-machine.com/doc/Modern_Programming_Slides.pdf


Wenn auch Sie Probleme mit unzuverlässigem Embedded Software Code haben, sprechen Sie uns an! Unsere Spezialisten prüfen gerne gemeinsam mit Ihnen, wie ein Re-Design Ihrer Lösung aussehen kann. Sie profitieren dabei von unserem speziellen Architektur- und Entwicklungs-Know-how für robustes Embedded Software Design und der langjährigen Erfahrung aus zahlreichen IoT- und Smart Products Projekten.

Auch für die Entwicklung neuer Smart Products und in neuen IoT-Projekten hat sich diese Vorgehensweise mit dem Standard Finite State Machine Framework als sehr erfolgversprechend gezeigt.


Vielleicht auch interessant:

Das MQTT Protokoll – Hintergründe (Teil 1)

Das MQTT Protokoll – Praxis (Teil 2)

IoT Protokolle – MQTT vs. AMQP

MQTT Protokoll – Anwendungsbeispiele

Modbus über MQTT – wie geht das?

 

Rate this post
0 Kommentare

Hinterlasse einen Kommentar

An der Diskussion beteiligen?
Hinterlasse uns deinen Kommentar!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert