Posts mit dem Label Wemos werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Wemos werden angezeigt. Alle Posts anzeigen

Dienstag, 27. August 2019

Gästebuch mit Wemos


Als ich mit meiner Freundin zum Geocaching unterwegs war, fiel mir ein das ich ein Programm schreiben wollte, das die Funktion eines Gästebuch ausführt und das auf einem Mikrocontroller. Wer Geocaching kennt, der weis dass man nach einem gefundenen Geocach sich auf einem beiliegenden Zettel eintragen kann. Und genau das will ich als digitale Form abbilden.

Was brauche ich:
  • Wemos
  • SD Shield
  • SD Karte

Anforderung
Für ein Gästebuch, soll ein (Nick)Name und Datum hinterlegt werden. Datum wird Automatisch mit dem Eintrag gesetzt, so das nur der Nickname eingetragen wird. Hier sollte der Wemos als eigenständiger Access-Point funktionieren, so das man sich mit dem Smartphone verbinden kann. Auf der Webseite sollten zwei Textboxen für die Eingabe des Namens und Datum vorhanden sein. Das Speichern erfolgt dann über ein Button. Neben der Eintrage Möglichkeit, soll auch eine Tabelle mit bereits bestehenden Einträgen zusehen sein. Und natürlich sollte der Zugang per Smartphone funktionieren.

Webseite schreiben
Leider kann die Webseite nicht mit Bootstrap aufgebaut werden. Na ja, eigentlich schon, aber das wäre ein eigenes Thema. Diesmal wird die Seite wieder Klassisch und einfach aufgebaut nach Standard HTML Bordmitteln.
Die Webseite wird mit in dem Programmcode eingebettet, so das diese nicht von der SD Karte erst gelesen werden muss. Zudem sollte bei defekter SD Karte trotzdem etwas angezeigt werden, wie eine Fehlermeldung.
Da die Darstellung des Code mit HTML auf dem Blog sich schwierig gestaltet, kann der Programmcode für den Seitenaufbau auf dem Github Repository betrachtet werden [Link zu WebsiteContent].
Die Seite habe ich zuvor ganz normal in HTML geschrieben und das Ergebnis im Browser immer wieder betrachtet. Erst danach kam die Seite in den Programmcode, das jedoch optisch grausig aussieht. Daher habe ich den Teil in einen eigenen Tab bzw. Code-Datei verfrachtet. Am Ende kam fast das selbe Ergebnis wie in den Folgendem Bild zu sehen ist.



Das Aktuelle Datum wird durch ComboBoxen ermöglicht, in dem man das aktuelle Datum und Uhrzeit einrichten kann. Das testen auf dem Windows Phone erfolgt ohne Probleme. Auf dem Iphone jedoch nicht.








SD Karte prüfen
Mit dem Start soll zunähst geprüft werden, ob die SD Karte verfügbar ist. Zuerst wird jedoch geprüft, ob bereits die Datei mit den Gästeeinträgen vorhanden ist. Wenn nicht, dann wird diese angelegt.

 void InitSdCard() {  
  SD.begin(mChipSelect);  
  if(!SD.exists(mGuestList)){  
   Serial.println("Create file...");  
   File dataFile = SD.open(mGuestList, FILE_WRITE);  
   dataFile.close();  
   Serial.println("...finish");  
  }  
  else {  
   Serial.println("the guest list exist");  
  }  
  if(!mCard.init(SPI_HALF_SPEED, mChipSelect)) {     // initialize sd card and check insert sd card  
   Serial.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");  
   Serial.println("\t\tERROR: can not init sd card");  
   Serial.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");  
   return;  
  }  
  if(!mVolume.init(mCard)) {               // initialize sd card  
   Serial.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");  
   Serial.println("\t\tERROR: Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");  
   Serial.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");  
   return;  
  }  
  Serial.println("SD Card: Exist and partion was found");  
 } 

Wemos zum Access Point machen
Auf der Webseite von Wemos ist es eigentlich schon beschrieben, aber zur Vollständigkeit, nehme ich das hier denoch auf. Um den Wemos zum Access Point zu machen, bedarf dies nur weniger Code zeilen. In den Globalen Variablen muss dann nur die Instanz vom WiFiServer gehalten werden. Für den Zugang wird kein Passwort festgelegt.

 void StartWebserver() {  
  Serial.println("Start access point");  
  WiFi.mode(WIFI_AP);            
  byte setMode = 0;               // 0 = disable, 1 = enable router information  
  wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &setMode);  
  WiFi.softAP("VisitorsBook", "");  
  mServer.begin();                // Start the HTTP Server  
  Serial.print("Ip Address: ");  
  Serial.println(WiFi.softAPIP());// Send the IP address of the ESP8266 to the computer  
 } 

Aufruf der Seite
Mit dem Aufruf der Seite wird zunächst geprüft, ob der Benutzer einen Request sendet. Wenn nicht, wird die Methode zum Speichern umgangen. Den Request nach dem Inhalt zuprüfen, sieht hier etwas kryptisch aus, das jedoch nur schlimm aussieht. Beim auslesen des Datums wird ein Doppelpunkt mit '%3A' ausgefüllt, der sich jedoch einfach mit einem Replace wieder in einen Doppelpunkt gesetzt werden kann. Nach dem aufbereiten des Namens und Datum kann das Ergebnis gespeichert werden.

void printOnWebside() {  
  WiFiClient webclient = mServer.available();  
  if (!webclient) {  
   return;  
  }  
  String request = webclient.readStringUntil('\r');  
  webclient.flush();  
  int indexGuest = request.indexOf("guestname=");  
  if(indexGuest != -1) {  
   int indexEndGuestname = request.indexOf('&');  
   String guestName = request.substring(indexGuest + 10, indexEndGuestname);  
   int indexSetTime = request.indexOf("settime=");  
   int indexEndSettime = request.indexOf(" HTTP");  
   String settime = request.substring(indexSetTime + 8, indexEndSettime);  
   // Example: 2019-08-25T19%3A40  
   // filter technical colon  
   settime.replace("T", " ");  
   settime.replace("%3A", ":");  
   WriteGuest(guestName, settime);  
  }  
  BuildWebside(webclient);  
 } 

Datenspeichern
Das Speichern erfolgt Zeilenweise. Hier wird der Eintrag mit einem Zeilenumbruch in die Datei hinzugefügt. Zuerst hatte ich nur Name und Datum, aber das Parsen wäre relativ aufwendiger geworden. Daher wird die Zeile bereits mit dem Ziel HTML Format eingetragen. (Wegen HTML Inhalt ist der folgende Code nur ein Bild)



















Daten abrufen
Ist etwas lang die Methode. Aber auch nur, weil wieder etwas HTML mit eingeflossen ist, um die Anzahl der gespeicherten Einträge wieder zugeben. Anschließend werden die Gast Einträge aus der Datei Zeilenweise mit dem bereits HTML Anteil abgerufen und hinzugefügt.































Offene Punkte
Das Hübsch machen der Webseite habe ich weggelassen, sowie das Fehlerbehandlung. Denn ein Eintrag kann ohne Namen und Datum erfolgen und führt dazu, dass der Eintrag in der Liste wirklich leer sein kann. Zudem war auch ein RTC Timer angedacht, der jedoch für den ersten Schritt nicht benötigt wird. Im Main Branch habe ich diesen Teil stehen gelassen.
Und dann noch der Fehler, dass das Datum nicht geht, wenn versucht wird vom Iphone ein Request zu senden.


Datenschutz
Die Anmeldung erfolgt anonym, weil hier keine Personenbezogenen Daten erhoben werden. Um genau zu sein, dürfen hier keine Personendaten erhoben werden, wie Email (Macht in diesen Kontext auch kein Sinn), Namen und Geburtsdatum. Für den Eintrag reicht dann der Hinweis:

Mit meinem Eintrag ins Gästebuch erkläre ich mich einverstanden, dass dieser Beitrag mit Datum und Uhrzeit auf der Gästebuch-Seite hier Lokal öffentlich lesbar wird.

Weitere Informationen findet ihr auf der Seite zu "Datenschutz auf Webseiten"

Wie immer das ganze Beispiel auf meinem Github Repository


Sonntag, 21. Juli 2019

Daten in JSON speichern auf dem Wemos


Um seine Daten auf eine SD Karte zu speichern, muss am Anfang klar sein, in welches Format gespeichert werden soll. Das ist dann besonders entscheidend, wenn die Daten wieder weiter verarbeitet werden.
Wenn für den Moment nur ein Wert gespeichert wird, dann reicht Zeilenweise. Bei mehreren Werten müssen die durch ein Zeichen getrennt werden. Das kann dann über Leerzeichen, Semikolon oder Komma sein, bzw. CSV entsprechend. CSV kann prima in Excel betrachtet und weiter verarbeitet werden. Will man die Daten aber weiter verarbeiten, müssen am Ende viele Zeichenketten zu Werten umgewandelt werden. Grundsätzlich ist das nicht verkehrt, aber man muss sich selbst Standards festlegen, um Aufwände gering zu halten.

Was benötigt wird:
  • Arduino oder Wemos
  • SD Shield
  • SD Karte

Vorhaben
Für das Ziel Projekt werden einige Werte aus den Messungen gespeichert. Daher wird ein Daten Objekt benötigt, dass alle Werte enthält. Um dieses nicht im Arbeitsspeicher zu halten, muss der Inhalt persistiert werden und später auf Abruf wieder hergestellt werden.

Datenformat zum Speichern
Die Entscheidung war für mich schon ein eigenes Thema Wert. Neben CSV blicke ich seit langem wieder auf JSON und XML. Nachdem ich ein wenig gesucht habe, kam ich zu dem Entschluss JSON zu verwenden. Für das JSON Format existiert bereits eine fertige Bibliothek.



Was man beachten sollte
Nach einigen Tutorials und veralteten Beispielen, hatte ich die nötigen Informationen zusammen. Zum Schreiben und lesen der Daten können zwei verschiedene Klassen zum Verarbeiten von JSON verwendet werden.
  • StaticJsonDocument
  • DynamicJsonDocument

Für meinen Einsatz reicht der StaticJsonDocument aus. Dieser legt die Daten im Stack ab und verbraucht durch die Eingrenzung auch weniger Arbeitsspeicher. Das ist bedingt durch den Mikrocontroller, vorzugsweise zu verwenden.
Mit DynamicJsonDocument werden die Daten im Heap abgesetzt. Für mein Beispiel konnte ich evaluieren, das nur zwölf Datensätze zuverlässig verarbeitet werden, ohne dass das Programm anhält bzw. abstürzt.

Datenobjekt
Der Zeitpunkt der Aufnahme und zu speichernden Werte werden für den späteren verlauf verwendet. Sekunden habe ich hier nicht einbezogen, da solche Zeitlich genauen Messungen für die Darstellung keinen Nutzen hat. Die Stunden und Minuten werden wiederum verwendet, um später Durchschnittswerte zu berechnen. Der Tag, Monat und Jahr werden ebenfalls für die Durchschnittswerte verwendet.

 class MeasureData {  
  public:  
   int16_t Day;  
   int16_t Month;  
   int16_t Year;  
   int16_t Hour;  
   int16_t Minute;  
   float Temperature;  
   float Humidity;  
   float Pressure;  
 };  


Speichern (Serialisieren)
Bevor die Daten in das JsonObject geschrieben werden können, muss die Größe definiert werden. Im folgenden Programmcode in "JSON_ARRAY_SIZE" der Wert 1 eingetragen, weil hier nur einmal gespeichert wird. Im Github Repository zeige ich dieses mit mehreren Datensätzen.

 void SaveData() {  
  const size_t capacity = JSON_ARRAY_SIZE(1) * JSON_OBJECT_SIZE(8);        
  StaticJsonDocument jsonBuffer;     // set the content size  
  JsonArray data = jsonBuffer.to();   // setup array to write  
  JsonObject measure = data.createNestedObject();  // created to add a new object  
  measure["Day"] = 12;  
  measure["Month"] = 12;  
  measure["Year"] = 2019;  
  measure["Hour"] = 12;  
  measure["Minute"] = 12;  
  measure["Temperature"] = 21.4f;  
  measure["Humidity"] = 50.5f;  
  measure["Pressure"] = 12345.6f;  
  File file = SD.open(mFilename, FILE_WRITE);  
  serializeJson(jsonBuffer, file);       // write json document to file  
  file.close();   
 } 

Öffnen (Deserialisierung)
Genau wie beim Speichern, wird ebenfalls die Kapazität angegeben. Dann kann die eingelesene Datei aus dem JSON Inhalt eingelesen und als JsonObject abgerufen werden.

 void OpenData() {  
  File file = SD.open(mFilename);  
  String content = file.readString();  
  const size_t capacity = JSON_ARRAY_SIZE(1) * JSON_OBJECT_SIZE(8);        
  StaticJsonDocument doc;  
  deserializeJson(doc, content);  
  JsonObject measure = doc[0];  
  Serial.print(" Day:"); Serial.print((int16_t)measure["Day"], DEC);  
  Serial.print(" Month:"); Serial.print((int16_t)measure["Month"], DEC);  
  Serial.print(" Year:"); Serial.print((int16_t)measure["Year"], DEC);  
  Serial.print(" Hour:"); Serial.print((int16_t)measure["Hour"], DEC);  
  Serial.print(" Minute:"); Serial.print((int16_t)measure["Minute"], DEC);  
  Serial.print(" Temperatur:"); Serial.print((float)measure["Temperature"], DEC);  
  Serial.print(" Humidity:"); Serial.print((float)measure["Humidity"], DEC);  
  Serial.print(" Pressure:"); Serial.println((float)measure["Pressure"], DEC);  
 }  


Fazit
Das JSON Format kann ich jeden nahe legen, dieses zu verwenden. Sobald mehrere Daten erfasst und gespeichert werden, ist der Aufwand beim Einlesen nahezu gleich. Das mag anfangs etwas ungewohnt sein. Spätestens wenn ihr Daten aus einer CSV einlesen wollt, das innerhalb des Mikrocontroller Bereiches geschieht, spart ihr eine Menge Zeit für das Entwickeln einer Methode, dass die Daten einließt.

Wie immer ein Beispiel:

Samstag, 7. Juli 2018

Wetterstation und Daten Logger


Immer die Aktuellen Messdaten abzurufen ist schön, aber auf Dauer würde man doch gerne sich ansehen wie sich das Wetter über einen Zeitraum verändert hat. Man könnte natürlich immer zu jeder Stunde nach sehen und sich das in der Excel Tabelle Notieren. Besser wäre der Vorgang, ein Programm zu verwenden das im vordefinierten Intervall die Messdaten automatisch speichert.


Wemos Codebeispiele
Die kurz Beschreibung, wie die Daten auf die SD Karte geschrieben werden, ist auf dem Github zu Wemos zu finden.

Simple übernommen
Ich habe das Codebeispiel übernommen und entsprechende Anpassungen und Erweiterungen eingesetzt. Im wesentlich wird am Anfang das SD Shield initialisiert und geprüft, ob eine SD Karte eingesetzt ist. Über den Seriellen Monitor wird der Typ und die Kapazität der SD Karte abgezeigt. Wenn die Zieldatei noch nicht vorhanden ist beim Speichern, wird die Datei "weather.csv" angelegt und bekommt in die erste Zeile die Header Info zu den Spalten.

Abruf der gespeicherten Daten
Nach dem Initialisieren und der ersten Messungen, werden im Beispiel von mir, alle zehn Sekunden die aktuellen Daten auf die SD Karte gespeichert. Die Daten werden in einer CSV Datei angehängt. Hierbei wird die Datei geöffnet und der neue Datensatz in eine neue Zeile geschrieben. Um später die Datei zu entnehmen, muss die SD Karte aus dem Shield entnommen werden und am PC mit einem SD Karten Slot eingelesen werden.

Problem mit Excel
Öffnet man die Datei in Excel, so kann es sein das Werte als Datum Formatiert werden. Das liegt mitunter an der verwendeten Zeichen für Nachkommastelle. Technisch gesehen ist alles Richtig, nur Excel macht etwas zu viel des Guten.


Statt die Datei per Doppel klick zu öffnen, muss die Datei über Excel aufgerufen werden. Über den Reiter "Daten" und dann Daten abrufen -> Aus Datei -> Aus Text/CSV  kann die Datei importiert werden.


Nach dem Import öffnet sich ein neuer Dialog. In der dritten Combobox wählt ihr Dateitypen nicht ermitteln und anschließend kann dann auf den Button Laden geklickt werden.


Leider kann das hier nur zum Betrachten verwendet werden. Eine Darstellung in einem Diagramm geht hier ebenfalls nicht. Zugegeben empfand ich dies sehr nervig und schrieb hierzu ein einfachen Konverter, der mir die Werte in das Zielformat bringt. In dem vorigen Bild ist auch zu sehen, dass die Nachkommastelle komplett entfernt wurde.

Hat nur eine Aufgabe
Das Tool zum konvertieren der CSV Datei ist ebenfalls auf meinem Repository zu finden. Momentan kann das Tool nur eine Sache und zwar die Zahlen mit einem Punkt als Nachkommastelle umzustellen zu einem Komma. Wenn die Anforderungen steigt, dann werde ich sicherlich mehr daraus machen.


Im Diagramm betrachten
Kommen wir zum eigentlich Ziel. Die gemessenen Daten können in Excel im Einzelnen Betrachtet werden. Mit dem Anlegen einer Diagramm-kurve sieht man wie die Temperatur und Feuchtigkeit zu einander sich verändert haben. Der Luftdruck muss ein separates Diagramm haben, da die Werte im Hektopascal hinterlegt sind.


Immer noch nicht Rund
Das Automatische Aufzeichnen der Messdaten ist schon hilfreich. Aber an den gespeicherten Messungen ist keine Uhrzeit angegeben, so dass eine Zeitliche Orientierung nicht ermittelt werden kann. Und noch besser wäre, die Diagramme ebenfalls im Browser anzuzeigen. Aber dazu komme ich zu einem anderen Zeit.



Donnerstag, 31. Mai 2018

Wetterstation / Gewächshaus mit Webzugriff


Mit der Zeit kommen für das Beispiel Programm einer Wetterstation neue Funktionen hinzu. Somit lässt sich mit dem aktuellen Stand, den Wemos mit dem WLAN verbinden und über einem Browser können die Messdaten abgelesen werden.

Momentan wird das Programm mit dem Wemos in meinem Gewächshaus verwendet. Natürlich ist mir bewusst, dass die Elektronik durch die hohe Luftfeuchtigkeit beschädigt werden kann und ist auch nicht zu empfehlen. Ansonsten müsse die Elektronik mit Plastikspray oder ähnlichen eingesprüht werden.



Webzugriff
Die Implementierung einer Webseite war ein Muss. Für die Realisierung muss man nur wissen, wie man auf eingehende Anfragen reagiert und wie die Webseite zurück gegeben wird. Die Webseite erfüllt ihren Zweck und Zeigt die aktuellen Messdaten. Das Aktualisieren der Messdaten erfolgt durch den erneuten Aufruf des Wemos, bzw. die Seite neu laden.


WLAN
Damit sich der Wemos mit WLAN verbinden kann, muss die SSID (Euer WLAN Name) und das Passwort eingetragen werden. Von den Sicherheitsoptionen sollte mindestens WPA-PSK funktionieren. Die IP Adresse und Gateway müssen bei Bedarf ebenfalls angepasst werden.

Zuletzt
Auf dem Bild mit der Webseite ist ein Vierter Wert aufgeführt. Der Vierte Wert ist der Grund für meinen Test im Gewächshaus und Zeigt einen Messwert von einem Bodensensor an. Aber dazu komme ich dann zu meinem nächsten Blogpost.


Samstag, 25. November 2017

Konfigurierbarkeit des Feuchtigkeitssensor HTU21D


Wenn man im Internet sucht, finden sich viele Beispiele zur Programmierung einiger Sensoren, die ich ebenfalls selbst verwende. Die meisten Codeschnipsel funktionieren auch auf dem Wemos. Dennoch muss noch etwas herum probiert werden, um bestimmte Schwierigkeiten anzugehen, damit auch das erwartete Ergebnis kommt.

HTU21D, HTU21, SHT21
Wird ein Sensor gelesen bekommt man nach diesem Vorgang einen Rohwert, der dann in einen für uns bekannten und lesbaren Wert umgerechnet wird. Wir können dies ohne weiteres nach Datenblatt tun oder einen fertigen Beispiel Code verwenden.
Ich wollte meinen Programmcode mit anderen Beispielen Vergleichen, auf Grund einer Konfigurierbarkeit des Sensors. Leider war dazu auf Anhieb nichts zu finden, womit ein Grund bestand sich damit selbst auseinander zu setzten.
In diesem Fall ist es der Feuchtigkeit Sensor HTU21D und ist auch unter HTU21 oder SHT21 zu finden (Nicht ganz sicher, ob alle dieselben sind). Abgesehen Technischer Unterschiede, können alle drei mit dem gleichen Programmcode angesteuert werden. Vor ein paar Jahren hatte ich bereits ein Beispiel Code mit C# und .NET Micro Framework geschrieben, in dem ich damals keine Implementierung der Einstellmöglichkeiten vornahm.

Für den Sensor sind drei Register verfügbar, mit denen die Einstellungen abgefragt, festgelegt oder zurückgesetzt werden können.
  • Write user register 0xE6
  • Read user register 0xE7
  • Soft Reset 0xFE
Grundeinstellung
Wird der Sensor nur gestartet und gelesen, dann bestehen die Grundeinstellungen. Diese sollten im Normalfall reichen. Bei Speziellen Anwendungen könnten dieses Lesevorgänge zu lange dauern. Mit dem Kompromiss der Genauigkeit, kann der Lesevorgang für die Feuchtigkeit von 18ms auf 3ms gesengt werden. Anstatt der 12bit, werden jedoch nur 8bit verwendet.

Genauigkeit
Zeit
12bit
18ms
11bit
9ms
10bit
5ms
8bit
3ms

Abruf und Zuweisen der Einstellung
Im Grunde ist dies so simpel wie der Abruf der Sensor Daten. Für die Einstellwerte ist jedoch etwas umdenken erforderlich, da diese in einem Byte verpackt sind. Ein Byte besteht aus 8Bit und verfügt damit so acht Schalter für bestimmte Einstellungen. Zum Nachvollziehen habe ich aus dem Datenblatt die Tabelle mit den zugehörigen Bit Schaltern abgebildet.


Einstellen und Auswerten
Mit dem 'Read user register' 0xE7 kann die aktuelle Einstellung abgerufen werden. Das kann hilfreich sein, um die geschrieben Einstellungen gegen zu prüfen.

 void Htu21ReadUserRegister() {  
  Wire.beginTransmission(HTU21D_ADDRESS);  
  Wire.write(command);              
  Wire.endTransmission();  
  Wire.requestFrom(HTU21D_ADDRESS, 1);   
  while(Wire.available() < 1) { }  
  byte regCon = Wire.read();  
  Serial.print("\tRegister Result: ");   
  Serial.println(regCon, BIN);         
 }  

Das folgende Beispiel beschreibt die Einstellung 'RH 11Bit / Temp 11Bit', 'On-Chip Header' aus und 'Disable OTP Reload' aus.

 void Htu21WriteRegisterSetting() {  
  byte command = 0xC0;  // RH 11bit / 11Bit Temp  
  command |= 0x01;     // disable otp reload  
  Wire.beginTransmission(HTU21D_ADDRESS);  
  Wire.write(0xE6);       // command for write register command  
  Wire.write(command);  // write the finish command  
  Wire.endTransmission();  
 }  

War das Schreiben der Einstellung erfolgreich, sollte mit der Methode 'Htu21ReadUserRegister()' das Binäre Ergebnis '1100 0001' ausgegeben werden.

Beispiel Projekt Wetterstation
Auf dem Github Repository stelle ich diesmal das kleine Projekt zur Verfügung, in dem ich bereits den HTU21 und den BMP180 Sensor verwende. Dort sind einige Methoden etwas weiter ausgeführt und zum Teil Kommentiert. Soweit ich immer Zeit habe, erweitere ich das Projekt mit Möglichst überschaubaren Funktionen.

Sonntag, 5. November 2017

Unterdruck und Höllentemperatur bei falschen Valuetype (Wemos)


Wenn die Ergebnisse nicht den Erwartungen entsprechen, dann ist mit Sicherheit etwas falsch. Das geschah diesmal mit dem Wemos D1 Mini. Einen bereits fertiges Code Beispiel für das Auslesen eines BMP085 Sensors mit einem Arduino, verwendete ich diesmal auf dem Wemos. Nach dem hochladen zeigten sich die nicht erwartenden Ergebnisse. Zumindest war offensichtlich, dass in meiner Wohnung keine 119 Grad Celsius herrschten und bei einem Luftdruck von 4000 Pascal wäre ich sicherlich an Sauerstoffmangel oder kochendem Blut auseinander gegangen. Also musste was an der Berechnung nicht stimmen.


Behoben
Der Fehler ließ sich relativ schnell beheben. Die Verwendeten ValueTypes int und unsigned int wurden ersetzt durch int16_t und unt16_t.

Aber warum
Ein ValueType INT ist immer das gleiche, solange die Variable als INT definiert wird auf einem System. Das eine System ist die Arduino Plattform mit dem 8Bit Mikrocontroller. Der Wemos verwendet wiederum einen 32Bit Mikrocontroller. Das sollte als erstes Auffallen und schnell sollte klar sein, dass etwas mit den Typen etwas nicht stimmt und folglich nicht mit den richtigen Werten rechnet. Eigentlich ist das von Compiler abhängig, welcher Type aus einem INT angelegt wird.
Der Folgende Code macht die Größe eines INT sichtbar, sobald ihr das auf der Ziel Plattform ausführt.

 void setup() {  
  Serial.begin(9600);  
  Serial.print("int: ");   
  Serial.println(sizeof(int), DEC);  
  Serial.print("unsigned int: ");   
  Serial.println(sizeof(unsigned int), DEC);  
  Serial.print("int16_t: ");   
  Serial.println(sizeof(int16_t), DEC);  
  Serial.print("uint16_t: ");   
  Serial.println(sizeof(uint16_t), DEC);  
 }  

Wie man sieht, wird auf dem Wemos kein 16Bit INT, sondern 32Bit INTEGER angelegt

Arduino Nano
Wemos D1 Mini



Aber Moment mal. Damit wäre eine Berechnung auf dem Wemos genauer und der Rechenfehler dürfte erst gar nicht auftreten. Sieht man sich allerdings die Funktionsinhalte an, dann sind mehrere Stellen auffällig, wo die Werte durch Byteshifting hoch oder runter gerechnet werden. Das nur passt wiederum nur mit 16 Bit. Andernfalls muss die Funktion geändert werden.

Zur Vollständigkeit der Beispielcode mit den geänderten ValueTypes. In diesem Fall reichten die Änderungen für INT aus und kann nun für Arduino oder Wemos verwendet werden.

 #include <Wire.h>  
 #define BMP085_ADDRESS 0x77 // I2C address of BMP085  
 const unsigned char OSS = 0; // Oversampling Setting 
// Calibration values
int16_t ac1, ac2, ac3, b1, b2, mb, mc, md;
uint16_t ac4, ac5, ac6;
long b5;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  bmp085Calibration();
}

void loop() {
  uint16_t rawValueUt = bmp085ReadUT();  // MUST be called first
  float temperature = bmp085GetTemperature(rawValueUt);
  uint16_t rawValueUp = bmp085ReadUP();
  float pressure = bmp085GetPressure(rawValueUp);
  float atm = pressure / 101325; // "standard atmosphere"
  float altitude = calcAltitude(pressure); //Uncompensated caculation - in Meters 

  Serial.print("Temperature: "); Serial.print(temperature, 1); Serial.println(" deg C");
  Serial.print("Pressure: "); Serial.print(pressure, 0); Serial.println(" Pa");
  Serial.print("Standard Atmosphere: "); Serial.println(atm, 4);
  Serial.print("Altitude: "); Serial.print(altitude, 2); Serial.println(" M");
  Serial.println();
  delay(2000);
}

void bmp085Calibration(){
  ac1 = bmp085ReadInt(0xAA); Serial.print("ac1"); Serial.print(ac1, DEC);
  ac2 = bmp085ReadInt(0xAC); Serial.print(" ac2"); Serial.print(ac2, DEC);
  ac3 = bmp085ReadInt(0xAE); Serial.print(" ac3"); Serial.print(ac3, DEC);
  ac4 = bmp085ReadInt(0xB0); Serial.print(" ac4"); Serial.print(ac4, DEC);
  ac5 = bmp085ReadInt(0xB2); Serial.print(" ac5"); Serial.print(ac5, DEC);
  ac6 = bmp085ReadInt(0xB4); Serial.print(" ac6"); Serial.print(ac6, DEC);
  b1 = bmp085ReadInt(0xB6); Serial.print(" b1"); Serial.print(b1, DEC);
  b2 = bmp085ReadInt(0xB8); Serial.print(" b2"); Serial.print(b2, DEC);
  mb = bmp085ReadInt(0xBA); Serial.print(" mb"); Serial.print(mb, DEC);
  mc = bmp085ReadInt(0xBC); Serial.print(" mc"); Serial.print(mc, DEC);
  md = bmp085ReadInt(0xBE); Serial.print(" md"); Serial.print(md, DEC); 
  Serial.println();
}
// Calculate temperature in deg C
float bmp085GetTemperature(uint16_t ut){
  long x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
  long x2 = ((long)mc << 11)/(x1 + md);
  b5 = x1 + x2;

  return (float)((b5 + 8)>>4) / 10.0;
}
// calculate pressure from raw value
long bmp085GetPressure(unsigned long up){

  long b6 = b5 - 4000;
  // Calculate B3
  long x1 = (b2 * (b6 * b6)>>12)>>11;
  long x2 = (ac2 * b6)>>11;
  long x3 = x1 + x2;
  long b3 = (((((long)ac1)*4 + x3)<>2;

  // Calculate B4
  x1 = (ac3 * b6)>>13;
  x2 = (b1 * ((b6 * b6)>>12))>>16;
  x3 = ((x1 + x2) + 2)>>2;
  unsigned long b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
  
  unsigned long b7 = ((unsigned long)(up - b3) * (50000>>OSS));

  long p;
  if (b7 < 0x80000000)
    p = (b7<<1 b4="" else="" p="(b7" x1="(p">>8) * (p>>8);
  x1 = (x1 * 3038)>>16;
  x2 = (-7357 * p)>>16;
  p += (x1 + x2 + 3791)>>4;

  return p;
}
// Read 1 byte from the BMP085 at 'address'
char bmp085Read(unsigned char address){
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();
  Wire.requestFrom(BMP085_ADDRESS, 1);
  while(!Wire.available()) {}
  return Wire.read();
}
// read two byte 
int16_t bmp085ReadInt(unsigned char address){
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();

  Wire.requestFrom(BMP085_ADDRESS, 2);
  while(Wire.available()<2 0x34="" 0xf4="" 0xf6="" 0xf7="" 0xf8="" 16="" 4.5ms="" 8="" a="" and="" at="" bmp085readint="" bmp085readup="" bmp085readut="" char="" conversion="" delay="" dependent="" for="" int16_t="" into="" least="" long="" lsb="" msb="" on="" oss="" oversampling="" pressure="" raw="" read="" reading="" register="" request="" return="" setting="" temperature="" the="" time="" uint16_t="" uncompensated="" unsigned="" up="(((unsigned" value="" w="" wait="" wire.begintransmission="" wire.endtransmission="" wire.write="" write="" x2e="" x34="" xf4="" xf6="" xlsb="">> (8-OSS);
  Serial.print("Pressure Raw Value: "); Serial.print(up, DEC); Serial.println();
  return up;
}
// calculate altitude by pressure value
float calcAltitude(float pressure){
  float alti = pow((pressure/101325),(1/5.25588));
  return (1 - alti) /0.0000225577;
}


Donnerstag, 19. Oktober 2017

Bibliotheken installieren für den Wemos@Lolin


Kaum angeschaut, habe ich mir den Wemos mit OLED Display beim Chinesischen Händler bestellt. Dann ca. vier Wochen später lag nun das Wemos@Lolin auf meinem Tisch und versuchte gleich ein Beispiel Code darauf zu schreiben. Leider musste ich zunächst feststellen, dass die bereits bei mir installierte Bibliothek nicht dieses Board aufführte. Und damit fing die Abendliche Suche an.

Nach kurzer suche fand ich diesen Link zu espressif. Zugegeben wollte ich nicht noch ein Tool installieren, dass mir im Grunde nur die Dateien in das Ziel Verzeichnis kopiert, also klickte ich auf den Download Button von dieser Seite des Github Accounts. Anschließend kopierte ich die Sourcen in den selbst angelegten Ordner "esp32/esp32" im Unterverzeichnis der Arduino Anwendung "../Arduino/hardware/"


Nach dem Start der Arduino Anwendung konnte unter Werkzeuge => Bord => WEMOS LOLIN32 ausgewählt werden.


Dann noch den Port auswählen und die Verbindung konnte hergestellt werden. Weitere Einstellungen mussten nicht vorgenommen werden.


Zuletzt fehlt noch die Bibliothek für die OLED Display von squix78 Github Account.

Nach dem Zip Download kann der entpackte Inhalt unter "…/Dokumente/Arduino/libraries/.." hinein kopiert werden.


Jetzt kann endlich ein Programmcode auf den Wemos geschrieben werden, dass auch das integrierte OLED ansteuern kann. Zu der OLED Bibliothek liegen bereits ein paar Beispiele.


Damit diese auch funktionieren, muss die Pin Zuweisung geändert werden. Sonst erhält ihr die Meldung "'D3' was not decleared in this scope".


Hierzu ändert die Pin Zuweisung auf 5 und 4. Dann sollte sich er Programmcode kompilieren lassen.


Damit nun der Programmcode auch auf dem Wemos geschrieben werden kann, muss mit dem hochladen die ‚Boot‘ Taste gedrückt werden.


Erst dann lässt sich das Programm erfolgreich hoch laden und euer Ergebnis ansehen.


Hier nochmal die Links zusammengefasst:

Ameisen Simulation und andere Dinge

Wer lange sich schon mit C# beschäftig, hat sicherlich schon mal was von AntMe gelesen oder gehört. Diese Idee hatte ich aufgegriffen und mi...