Demo1 Teil 2: IoT-Demo "Sensordaten"

In Demo1 Teil 1 "Was ist IoT?" wurden die wichtigsten Konzepte, Anwendungen und Technologien des Internet of Things vorgestellt. Hier im zweiten Teil der Demo werden diese Konzepte an einem Mini-Beispiel veranschaulicht: Mehrere mit Sensoren ausgestattete Mikrocontroller werden zu einem Netzwerk zusammengefasst und führen Messungen durch. Die Messwerte werden über WLAN an einen Server übermittelt und in einer Datenbank gespeichert. Aus dieser Datenbank werden die aktuellsten Messwerte für die Darstellung in der Grafik und der Tabelle ausgelesen.

Versuchsaufbau

Live-Demo

Tabelle der Sensordaten

Die Tabelle zeigt jeweils die letzten 26 Messungen.

ID Gerät Sensor Messwert Uhrzeit
34Gerät 2Sensor218.722:17:00
33Gerät 1Sensor 118.722:17:00
32Gerät 1Sensor 119.422:16:00
31Gerät 2Sensor218.222:16:00
30Gerät 2Sensor217.622:15:00
29Gerät 1Sensor 119.822:15:00
28Gerät 1Sensor 118.422:14:00
27Gerät 2Sensor218.122:14:00
26Gerät 2Sensor218.422:13:00
25Gerät 1Sensor 118.522:13:00
24Gerät 1Sensor 118.622:12:00
23Gerät 2Sensor217.622:12:00
22Gerät 2Sensor218.122:11:00
21Gerät 1Sensor 118.322:11:00
20Gerät 1Sensor 118.222:10:00
19Gerät 2Sensor218.422:10:00
18Gerät 2Sensor217.622:09:00
17Gerät 1Sensor 118.522:09:00
16Gerät 1Sensor 118.822:08:00
15Gerät 2Sensor218.622:08:00
14Gerät 2Sensor218.422:07:00
13Gerät 1Sensor 119.222:07:00
12Gerät 1Sensor 119.622:06:00
11Gerät 2Sensor217.722:06:00
10Gerät 2Sensor21822:05:00
9Gerät 1Sensor 11822:05:00


Umsetzung

Der IoT-Demonstrator besteht aus einer Reihe verteilter IoT-Geräte die mit einem zentralen Server kommunizieren. Ein IoT-Gerät besteht aus verschiedenen Hardware-Komponenten: WLAN-fähige Mikrocontroller, Stromversorgung und Sensoren. Auf jedem IoT-Gerät läuft eine eingebettete Software, die die Messung und Datenübertragung der Sensordaten steuert.

1 Hardware-Komponenten

Entwicklerboard STK600

Für die schnelle Entwicklung von Prototypen setzen wir das Entwicklerboard ATMEL AVR STK600 ein, an welches die anderen benötigten Komponenten angeschlossen werden. Das Board bietet einen schnellen Einstieg in die Programmierung und Erstellung neuer Anwendungen sowie beim Prototyp-Testing von verschiedenen Typen der ATMEL-Mikrocontroller. Auf dem verwendeten Board ist ein Mikrocontroller vom Typ ATmega2560 enthalten, sowie verschiedene Anschlüsse/Schnittstellen, z.B. USB, und 8 LEDs. Die Stromversorgung des Boards erfolgt per USB über einen PC.

Entwicklerboard STK600

Mikrocontroller: ATmega2560

detailsDemo1_atmega Der ATmega 2560 ist ein leistungsfähiger 8-Bit Mikrocontroller der Firma Atmel, der auf dem STK600-Entwicklerboard defaultmäßig dabei ist.

Was ist ein Mikrocontroller?
Ein Mikrocontroller ist ein Chip, der aus drei Kernelementen besteht: Prozessor, Speicher (RAM, ROM) und Ein- und Ausgabesteuerungen, und üblicherweise in Geräte eingebaut wird, die er steuert.

IoT-Modul: ESP8266

Der ESP8266 ist ein 32-Bit-Mikrocontroller der chinesischen Firma espressif, der aktuell oft in IoT-Szenarien verwendet wird, da er Datenübertragung per WLAN an einen Webserver ermöglicht. Der ESP8266 kann für die Nutzung als Seriell-zu-WLAN-Schnittstelle mit Hilfe einfacher Befehle angesteuert werden:
AT+RST - startet das Modul
AT+CWMODE=1 - setzt den WLAN-Modus
AT+CWJAP=ssid,password - verbindet sich mit einem Router
AT+CIPSTART="TCP",ip,port - startet eine TCP-Verbindung
AT+CIPSEND=length, data - sendet Daten
AT+CIPCLOSE - schließt die TCP-Verbindung

Temperatursensor: LM335

Der Temperatursensor LM335 der Firma Texas Instruments misst Temperaturen als analoge Spannungswerte, wobei die Temperatur linear von der Spannung abhängt. Bei der LM135-Serie handelt es sich um präzise, ​​einfach zu kalibrierende integrierte Schaltkreis-Temperatursensoren mit einem Messbereich von -40 bis 100° Celsius.

2 Eingebettete Software

Das Kernstück des Demonstrators ist die eingebettete Software, die die periodische Messung der Sensordaten und ihre Übertragung an den Webserver steuert.

Für die Programmierung der eingebettete Software wird Microchip Studio (bis 2020 Atmel Studio) [1, 2] eingesetzt, eine Entwicklungsumgebung, die alle Aspekte der eingebetteten Softwareentwicklung für Mikrocontroller der Firma Microchip unterstützt, angefangen von der Projekterstellung, Programmierung, Simulation und Übertragung der Software auf den Mikrocontroller.

Was ist eine eingebettete Software?

Eine eingebettete Software ist ein Programm, das fester Bestandteil einer Hardware bzw. eines Geräts ist und für diese entwickelt wurde, um eine festgelegte Aufgabe zu erfüllen. Beispiele sind z.B. die Programme, die in Haushaltsgeräte eingebaut sind und diese steuern. Eingebettete Software unterscheidet sich von nicht-eingebetteter Software in verschiedenen Punkten: Ein eingebettetes Programm läuft in einer Endlosschleife, in der es auf Ereignisse aus der Umwelt wartet und darauf reagiert, oder in der es periodisch festgelegte Aufgaben durchführt. Die Anforderungen bezüglich Zeit-, Speicher-, und Energiebedarf sind streng. Eine eingebettete Software hat knappere Ressourcen (Zeit und Speicher) zur Verfügung und muss die vorgesehenen Aufgaben in Echtzeit, d.h. in einem genau festgelegten Zeitfenster, durchführen.

Die eingebettete Software wurde als C-Programm implementiert. Das C-Programm besteht aus den Quellcode-Dateien main.c (das Hauptprogramm), ADC.c (Hilfsfunktionen für die Initialisierung und Verwendung des Analog-Digitalwandlers (ADC)) und Usart.c (Hilfsfunktionen für die Initialisierung und Verwendung der USART-Datenübertragung).

2-1 Das Hauptprogramm main.c

main.c - das Hauptprogramm, enthält die main-Funktion. Hier werden die unterschiedlichen Hardware-Komponenten initialisiert: der Analog-Digitalwandler (ADC), die serielle Datenübertragung per UART und das IoT-Modul ESP8266. In einer Endlosschleife erfolgt dann alle 30 Sekunden eine Temperaturmessung und der gelesene Wert wird mit Hilfe des ESP an den Webserver gesendet. Die Formel val = adc_read()*100/204 liefert die Temperatur in Grad Kelvin: Der Wert 204 ist das gerundete Ergebnis der Berechnung (2^10 - 1) / 5 = 1023 / 5 = 204.

#define F_CPU 16000000UL
#include <avr/io.h>

int main(void){
  // (1) Deklariere Variablen
  uint16_t val = 0;
  uint8_t T_C = 0;
  // (2) Initialisiere ...
  adc_init(); // ADC
  uart_init();// UART
  esp_init(); // ESP8266
  // (3) Endlosschleife
  while (1) {	
    // Alle 30 Sekunden	
    _delay_ms(300000);	
    // Lese Sensordaten ...
    val = adc_read()*100/204; // val = Temperatur in Grad Kelvin
    T_C = val - 273; // T_C = Temperatur in Grad Celsius
    // sende sie an Webserver
    esp_send(T_C);	
  } 
} 

2-2 Der Analog-Digitalwandler (ADC)

ADC.c - enthält Hilfsfunktionen für die Initialisierung und Verwendung des Analog-Digitalwandlers (ADC),


Was ist ein Analog-Digitalwandler (ADC)?

Viele Sensoren liefern ihre Messwerte als analoge kontinuierliche Signale. Ein Analog-Digitalwandler (engl. Analog Digital Converter) ist ein Bauelement, das ein analoges Eingangssignal (Spannung, Temperatur, Helligkeit, ...) in ein digitales Ausgangssignal umwandelt. Mathematisch gesehen ist ein analoges Signal eine stetige Funktion, ein digitales Signal hingegen eine diskrete Zahlenfolge, und die Umwandlung kann als Stufenfunktion dargestellt werden. Ein ADC wird beschrieben durch die Anzahl der Bits, die für die Darstellung des Ausgangssignals verwendet wird (3-Bit ADC, 10-Bit ADC), und seine Referenzspannung (den Wertebereich des Eingangssignals), z.B. 4 Volt oder 5 Volt.

Der ADC misst das Eingangssignal als kontinuierliche Kurve mit einer gewissen Abtastrate und ordnet einem Abtastwert einen digitalen Wert zu. Der 3-Bit-ADC approximiert ein lineares Eingangssignal durch die Stufenfunktion mit Schrittweite h = 4 / 8 = 0.5: jedem Wert aus dem Wertebereich von 0 bis 0.5 wird der Wert 000 zugewiesen, jedem Wert aus dem Wertebereich von 0.5 bis 1.0 der Wert 010 etc.
3-Bit Analog-Digitalwandler (ADC)

In der vorliegenden Demo wird der eingebaute Analog-Digitalwandler des Mikrocontrollers ATmega2560 verwendet, um die gemessenen analogen Temperaturen bzw. Spannungen in digitale Werte zu wandeln. Insbesondere wandelt der ADC des ATmega 2560 eine analoge Eingangsspannung durch sukzessive Approximation in einen 10-Bit-Digitalwert um. Nachdem die Konvertierung abgeschlossen ist, kann das Konvertierungsergebnis in den ADC-Ergebnisregistern ADCL und ADCH gefunden werden. Wenn das Ergebnis links ausgerichtet ist und lediglich 8-Bit-Präzision benötigt wird, reicht es aus, ADCH zu lesen. Andernfalls muss ADCL zuerst gelesen werden, dann ADCH, um sicherzustellen, dass der Inhalt der Datenregister zu derselben Umwandlung gehört.

Der Analog-Digitalwandler muss einmal vor Beginn der Messungen initialisiert werden, dies geschieht mit Hilfe einer Funktion namens adc_init(), die alle Initialisierungsanweisungen gruppiert, und kann nachher für das periodische Einlesen der Sensordaten eingesetzt werden, die Anweisungen dafür sind in einer zweiten Funktion adc_read() gruppiert.

adc_init()

void adc_init(){
  ADCSRA |= (1<<ADEN);
  ADCSRA |= (1<<ADEN); 
  ADMUX |= (1<<REFS0);
  ADMUX |= (1<<ADLAR);
  ADMUX |= (1<<MUX0) | (1<<MUX2);
  DIDR0 |= (1<<ADC5D);
}

adc_read()

uint16_t adc_read(void){
  uint16_t y;
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC) ) {}
  y = ADC;
  y = y >> 6;
  return y;
}

Erläuterung der ADC-Initialisierung adc_init()

Erläuterung der ADC-Umwandlung adc_read()

Eine einzelne Umwandlung wird gestartet, indem eine logische Eins in das ADC-Startumwandlungsbit ADSC geschrieben wird. Dieses Bit bleibt hoch, solange die Umwandlung im Gange ist, und wird von der Hardware gelöscht, wenn die Umwandlung abgeschlossen ist. Wenn während einer laufenden Konvertierung ein anderer Datenkanal ausgewählt wird, beendet der ADC die aktuelle Konvertierung, bevor er den Kanalwechsel durchführt.

2-3 Die UART-Datenübertragung


USART.c - enthält Hilfsfunktionen für die Initialisierung und Verwendung der UART-Datenübertragung. Wir verwenden UART hier für zwei Datenübertragungen: (1) die Übertragung von Debugging-Informationen an den PC und (2) Übertragung der AT-Befehle vom Mikrocontroller an das WLAN-Modul ESP8266.

Was versteht man unter UART bzw. USART-Datenübertragung?

UART (engl. Universal Asynchronous Receiver / Transmitter) ist ein Protokoll, das zur asynchronen seriellen Datenübertragung zwischen zwei Geräten (Mikrocontroller und PC oder zwischen zwei Mikrocontrollern) genutzt wird. USART steht für Universal Synchronous/Asynchronous Receiver Transmitter und bietet zusätzlich die Möglichkeit einer synchronen Datenübertragung.

Für die UART-Datenübertragung werden zwei Datenleitungen benötigt (damit asynchron gleichzeitig gesendet werden kann): TX – Transmit zum Senden und RX – Receive zum Empfangen. Ein UART-8 Bit-Datenpaket besteht aus einen Start-Bit, 8 Daten-Bits, und einem Stop-Bit. Start- und Stop-Bit kennzeichnen Beginn und Ende einer Nachricht. Die sogenannte BAUD Rate legt fest, mit welcher Geschwindigkeit die Daten gesendet werden. Eine BAUD Rate von 9600 bedeutet, dass jedes Bit mit einem Abstand von 1/9600 μs gesendet wird.

Wie jedes andere elektronische Bauteil muss der UART zunächst initialisiert werden. Die Initialisierung des UART geschieht, indem man die passenden Bits in den UART-Registern des ATmega2560 auf 0 oder 1 setzt, wie im DataSheet des ATmega 2560 [3] oder im UART-Tutorial [6] beschrieben. Am einfachsten schreibt man eine Funktion uart_init(), die die gewünschte Konfiguration zusammenfasst. Danach kann der UART für die Datenübertragung verwendet werden, die dafür erforderlichen Anweisungen können ebenfalls in einer Funktion wie uart_puts() zusammengestellt werden.

uart_init()

Bei der Initialisierung wird (1) der Übertragungs­modus (Senden und Empfangen), (2) der Aufbau des Datenpakets und (3) die Geschwindigkeit der Datenübertragung festgelegt.

#define BAUD 9600 
#define BAUD_PRESCALER ((F_CPU)/(BAUD*16UL)-1)
void uart_init(void){
	// (1) Aktiviere Datenleitungen
	// Aktiviere Receive RX
	UCSR0B |= (1 << RXEN0);
	// Aktiviere Transmit TX
	UCSR0B |= (1 << TXEN0);
	// (2) Konfiguration des Datenpakets
	// 8 Datenbits, 1 Stop Bit, Kein Parity-Bit
	UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
	// (3) Geschwindigkeit
	UBRR0H = (BAUD_PRESCALER>>8);
	UBRR0L = BAUD_PRESCALER;
}

uart_puts()

Für die Datenübertragung werden zwei Funktionen definiert: uart_putc sendet einzelne Zeichen, uart_puts sendet eine Zeichenkette mit Hilfe der zuvor definierten Funktion uart_putc().

int uart_putc(unsigned char c){
  // Warte,  bis Senden möglich 
  while (!(UCSR0A & (1 << UDRE0))) {}
    // Sende Zeichen
    UDR0 = c;
    return 0;
}
void uart_puts (char *s){
  // Solange Zeichenkette nicht zu Ende
  while (*s){   
    uart_putc(*s); // Sende Zeichen
    s++;
  }
}

2-4 Datenübertragung der AT-Befehle

Die zuvor definierten UART-Funktionen können nun eingesetzt werden, um die AT-Befehle an den ESP8266 zu senden.

Initialisierung des ESP

void esp_init(void){
	uart_puts("AT+RST\r\n"); _delay_ms(8000);
	uart_puts("AT\r\n"); _delay_ms(2000);
	uart_puts("ATE\r\n"); _delay_ms(2000);
	uart_puts("AT+CWMODE_DEF=1\r\n"); _delay_ms(2000);
	uart_puts("AT+CWJAP=\"NET\",\"PW\"\r\n"); _delay_ms(8000);
	uart_puts("AT+CWMODE?\r\n");_delay_ms(3000);
	uart_puts("AT+CWMODE_DEF?\r\n");
}

3 Datenspeicherung in einer Datenbank

Für die Speicherung der aufgezeichneten Sensordaten wird eine MySQL-Datenbank eingesetzt. Wie im Datenbankdiagramm dargestellt, werden vier Datenbanktabellen benötigt:

Der Vorteil beim Einsatz einer Datenbank ist, dass wir die Daten persistent speichern und die Datenintegrität mit Hilfe von Integritätseinschränkungen sicherstellen können.



Was ist eine Datenbank?

Eine Datenbank ist eine strukturierte Sammlung zusammengehöriger Daten. Der wichtigste und aktuell am häufigsten eingesetzte Datenbanktyp ist die relationale Datenbank. Eine relationale Datenbank besteht aus mehreren Tabellen, die über Schlüssel miteinander in Beziehung stehen. Jede Tabelle besteht ihrerseits aus mehreren Datensätzen.

Webserver

Der Webserver hat in einer IoT-Anwendung zwei Aufgaben. Einerseits empfängt er die Sensordaten, die die IoT-Geräte senden, und andererseits liefert er die Webseiten, die diese Daten darstellen, an die anfragenden Clients aus.

Was ist ein Webserver?

Die Aufgabe eines Webservers besteht darin, auf http-Anfragen hin die angeforderten Webseiten an den Client zu senden. Der Anbieter von Webseiten benötigt einen Webserver, auf dem eine Kombination von Programmen läuft, mit deren Hilfe statische oder dynamische Webseiten und -anwendungen entwickelt und bereitgestellt werden können.

Wir verwenden das Programmpaket XAMPP als Entwicklungsumgebung, da es viele Softwarekomponenten und Programmiersprachen bündelt, die wir für die Entwicklung unserer Webanwendung benötigen.
Weiterhin verwenden wir JavaScript-Bibliotheken wie JQuery und Chart.js für die Erstellung einer ansprechenden und responsiven Benutzeroberfläche.



Autoren, Tools und Quellen

Autor
 Prof. Dr. Eva Maria Kiss
Mit Beiträgen von
 B. Eng. Th. Melcher, Dipl.-Ing. (FH) E. Tcha-Tokey, M.Sc. A. Welz

elab2go Links:

Quellen und weiterführende Links: