[gelöst] Temperatur Logger, mit DS18B20

Hallo,
erstmal ein großes Danke für deine Hilfe und Mühe !!
Ich habe aber noch eine Fage.
Wäre es einfacher, ich würde alles wegwerfen und neu anfangen (Theoretisch :grin:)
Folgende Vorstellung:

DS18B20 --> Arduino Ethernet -->LAN-Kabel --> WebServer (Synology DS111)

Soll heißen, der Arduino misst die Temperatur und mein Webserver ruft die Temperatur ab und speichert sie in einer Text-Datei (z.b. Log.txt)
Dann hätte ich doch nicht das Problem mit der SD-Karte und dem Ethernet Pin, oder ?
Und der Code wäre kleiner und der Arduino vielleicht nicht überlastet.

Oder geht das so nicht ? (Is ja nur so´ne Idee :roll_eyes:)

Ich pack den Sketch mal als Anhang...

Temp_Logger_1.ino (4.72 KB)

Dann mach doch aus dem Arduino einen Webclient, keinen Webserver.
Der Arduino misst die Temperatur und ruft auf Deinem Webserver eine URL (z.B. http:///senddata.php?temp1=10.3&temp2=23) auf. Der Synology-Webserver kann auch PHP, Du kannst dort also ohne Probleme die Daten verarbeiten und in eine Datei schreiben. Außerdem sparst Du Dir so den Cronjob auf dem NAS das alle X Minuten den Arduino abfragt. Meine Arduino-Wetterstation funktioniert auf diese Weise sehr stabil seit einem halben Jahr. Ich habe mir sogar die RTC gespart und frage einmal täglich über eine spezielle URL von Webserver die Zeit ab. Das spart den Code für eine NTP-Funktion, denn ein HTTP-Get musste ich ja eh bauen.
Ein weiterer Vorteil ist, das der Arduino den Zeitpunkt zum Senden der Daten bestimmen kann und nicht immer auf ankommende Requests warten muss.

dafür hast du den grossen Nachteil, dass

  • wenn das NAS nicht läuft
  • wenn das Netzwerkkabel nicht eingesteckt ist
    du keine Messwerte hast.

Dafür ist ja die SD-Karte da, dort werden die Daten lokal gespeichert. Der Zugriff selbst kann auch wieder indirekt erfolgen. z.B. durch aufrufen eine URL http:///service.php
Das kann der Arduino regelmäßig pollen und dort stehen z.B. Befehle wie
"send 2012-04-19.csv" drin. Damit kann der Arduino in einer "Messpause" die Datei von der SD-Karte per HTTP-Post an den Webserver hochladen.
Das kann man sicher auch alles anders lösen. Es gibt immer verschiedene Wege zum Ziel. Bei meiner Lösung war mir wichtig, das der Arduino Wetterdaten sammelt und nicht die meiste Zeit damit verbringt auf einen HTTP-Request zu warten, oder von einem Request im ungünsitgen Zeitraum erwischt wird.

Hallo mkl0815,
Das hört sich super an.
Nur wie das funktionieren soll mit dem übergeben der gemessenen Temperatur, versteh ich nicht.
Bin jetzt auf die Arbeit,werde mich heute Abend mal dran setzen.
Aber erstmal vielen Dank den Lösungsvorschlag.
Ich werde aber bestimmt für die Umsetzung deine Hilfe brauchen.

PS: Eine Wetterstation habe ich auch, WS2300.

Moin,
so habe mich mal an einen Anfang gewagt:

/*
  Web client
  This sketch connects to my Diskstation 192.168.178.111
  and send the Themperature from DS18B20 at DigiPin 6 to it
 
  created 20 April 2012 
*/

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {  0x90, 0xA2, 0xDA, 0x00, 0xEE, 0xF3 }; // Mac-Adresse Arduino Ethernet
byte ip[] = {192,168,178,230}; // IP-Adresse Arduino Ethernet
byte gateway[] = {192,168,178,1}; // Gateway (Fritzbox)
byte subnet[] = {255,255,255,0}; 
IPAddress server(192,168,178,111); // Diskstation DS111

// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

void setup() 
{
  Serial.begin(9600);                             // initialisiere serielle Verbindung mit 9600
  Ethernet.begin(mac, ip, gateway, subnet);       // starte Ethernet
  delay(1000);                                    // warten auf Ethernet
  Serial.println("verbinde...");                  // Ausgabe(n) auf serieller Konsole
 if (client.connect(server, 80))                  // wenn Verbindungsversuch erfolgreich ...
  { 
    Serial.println("verbunden");                  // Ausgabe(n) auf serieller Konsole
                                                  // schicke Temperatur zum Server
    client.println("GET http://192.168.178.111/senddata.php?temp1=10.3&temp2=23) HTTP/1.0"); // <-- Wie setzt sich die Adresse zusammen??
    client.println();                             // schicke Leerzeile (beende Anfrage)
  } 
 else                                             // sonst, wenn Verbindung fehlgeschlagen, ...
  {
     Serial.println("Verbindung fehlgeschlagen"); // Fehlermeldung auf Konsole
  }
}

void loop()
{
  //Keine Ahnung was hier rein soll... :-(
}

Jetzt bräuchte ich HIlfe, wwie setzt sich das zusammen:

client.println("GET http://192.168.178.111/senddata.php?temp1=10.3&temp2=23) HTTP/1.0");

senddata.php? <-- Was muss darein und muss die auf den Arduino? Auf die SD-Karte?
temp1=10.3 <-- Ok, temp1 soll wohl der erste DS18B20 sein, aber was ist die 10.3?
temp2=23 <-- Hier auch, was ist die 23 ?

Und was kommt in den Loop-Bereich, sowie was muss auf der Diskstation sein (PHP-File?)

Fragen über Fragen... :blush:
Ach ja, der DS18B20 muss ja auch noch rein... ups..

http://192.168.178.111/senddata.php?temp1=10.3&temp2=23

192.168.178.111
die ip deines NAS

senddata.php
das PHP Script auf dem NAS

temp1=10.3
der erste DS18B20, 10.3 ist der aktuelle Messwert (Temperatur)
10.3 ist nur ein Beispielwert, bei dir muss da der aktuelle Messwert von dem DS18B20 stehen

temp2=23
der zweite DS18B20

hi,
ok, ich habe was im Netz gefunden und versucht auf meine Bedürfnisse anzupassen,
aber es kommt beim Compilieren eine Fehlermeldung :

Temperatur_WebClient.cpp: In function 'void loop()':
Temperatur_WebClient:83: error: a function-definition is not allowed here before '{' token
Temperatur_WebClient:91: error: a function-definition is not allowed here before '{' token
Temperatur_WebClient:109: error: expected `}' at end of input

Hier mein Sketch:

/*
/*
  Web client
  This sketch connects to my Diskstation 192.168.178.111
  and send the Themperature from DS18B20 at DigiPin 6 to it
 
  created 20 April 2012 
*/

#include <SPI.h>
#include <Ethernet.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 6          // DS18B20 an Pin 6 angeschlossen

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress kessel_Thermometer =         { 0x28, 0x03, 0xF6, 0xC2, 0x03, 0x00, 0x00, 0xA7 };  //Adressen der Sensoren manuell eingeben


// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {  0x90, 0xA2, 0xDA, 0x00, 0xEE, 0xF3 }; // Mac-Adresse Arduino Ethernet
byte ip[] = {192,168,178,230}; // IP-Adresse Arduino Ethernet
byte gateway[] = {192,168,178,1}; // Gateway (Fritzbox)
byte subnet[] = {255,255,255,0}; 
IPAddress server(192,168,178,111); // Diskstation DS111

// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

char url[]  = "/senddata.php";	// Pfad zur PHP-Datei eingeben
char key[] = "Kennwort_eingeben";	// Kennwort aus PHP-Datei eingeben
char c;

int Sensor = 5;    		        // DS18B20 an DigitalPin 5
int PowerLED = 3;          		// Power LED DigitalPin3
float Temperatur = 0;      		// Variable für Temperatur ;-)
int temp = 0;            		

void setup() 
{
  Serial.begin(9600);  
  sensors.begin();
  sensors.setResolution(kessel_Thermometer, 9);  // initialisiere serielle Verbindung mit 9600
  
  digitalWrite(PowerLED, HIGH);
  Ethernet.begin(mac, ip, gateway, subnet);       // starte Ethernet
  delay(1000);                                    // warten auf Ethernet
  Serial.println("verbinde...");                  // Ausgabe(n) auf serieller Konsole
 if (client.connect(server, 80))                  // wenn Verbindungsversuch erfolgreich ...
  { 
    Serial.println("verbunden");                  // Ausgabe(n) auf serieller Konsole
                                                  // schicke Temperatur zum Server
    client.println("GET http://192.168.178.111/senddata.php?temp1=10.3&temp2=23) HTTP/1.0"); // <-- Wie setzt sich die Adresse zusammen??
    client.println();                             // schicke Leerzeile (beende Anfrage)
  } 
 else                                             // sonst, wenn Verbindung fehlgeschlagen, ...
  {
     Serial.println("Verbindung fehlgeschlagen"); // Fehlermeldung auf Konsole
  }
}

void loop()
{
  digitalWrite(PowerLED, LOW);
    Sensor_lesen();
    Daten_senden();
    delay(900);
    digitalWrite(PowerLED, HIGH);

  if (client.available()) 
  {
    char c = client.read();
    Serial.print(c);
  }
  delay(899000);
    client.stop();
    client.flush();

void Sensor_lesen()
{
  temp = analogRead(Sensor);                  // Analog-Wert auslesen
  Temperatur = (5.0 * temp * 100.0)/1024.0;   // Berechnung der Temperatur in °C
  Serial.print("Temperatur: ");
  Serial.println(Temperatur);
}

void Daten_senden()
{
  if (EthernetClient.connect())  // Verbindung zum Server aufbauen
  {
    Serial.print("Verbunden...sende Daten...");
    client.print("GET ");
    client.print(url);
    client.print("?TEMP=");
    client.print(Temperatur);
    client.print("&key=");
    client.print(key);
    client.println(" HTTP/1.1");
    client.println();
    Serial.println("fertig!");
  }
  else
  {
    Serial.println(" ***** VERBINDUNGSAUFBAU NICHT MÖGLICH *****");
  }    
}

Was noch fehlt :

sensors.requestTemperatures();
float tempKessel = sensors.getTempC(kessel_Thermometer);

Wo wird das rein geschrieben ? In welchen void ?

Ich hoffe das das so die Richtung ist, oder ist das total falsch?

client.println("GET http://192.168.178.111/senddata.php?temp1=10.3&temp2=23) HTTP/1.0");

stimmt schon fast.

client.print("GET /senddata.php?temp1=");
client.print(temp1);
client.print("&temp2=");
client.print(temp2);
client.print(" HTTP/1.0\n"); 
client.println("Host: 192.168.178.111\n");

Ist richtig. Du gibts hinter dem GET nur den relativen Pfad an. Solltest Du für den Webservice einen Domainnamen verwenden und nicht nur die IP, dann musst Du den Parameter "Host:" anpassen. Akutell sollte es aber erstmal so gehen.
Das obige Beispiel geht davon aus, das Du zwei Variablen temp1 und temp2 hast, welche die gemessene Temperatur as float enthalten.
Du brauchst dann auf dem NAS ein PHP-Script das unter http://192.168.178.111/senddata.php aufrufbar ist. In diesem Script hast Du dann zwei Werte im globalen Array $_GET[] für temp1 und temp2, die Du dann z.B. in eine Datei schreiben kannst. Idealerweise ergänzt um den aktuellen Timestamp.

Allerdings ist Dei Code noch durcheinander. Das Senden an den Server soll ja regelmäßig passieren, also muss das in die loop(). Dafür muss der Server-Kram aus der loop() raus, da Du den nicht mehr brauchst. Am einfachsten definierst Du Dir eine Funktion sendHTTP(float temp1, float temp2) die den HTTP-Request kapselt, dann wird Dein Programm übersichtlicher.

Ok, ich hab mir den Code gerade nochmal angesehen. Welcher Teil ist von Dir und was ist von dem Beispiel das Du gefunden hast? Denn es gibt bereits zwei Funktionen zum Sensor-Lesen und Daten-Senden. Allerdings verwenden die noch einen analogen Sensor und schicken einen Key mit im Request, vermutlich zur Authentifizierung beim PHP-Script.
Wie in einem anderen Thread schon geschrieben, finde ich es ungünstig, fremden Code 1:1 zu übernehmen und auf die eigenen Bedürfnisse anzupassen. Lieber eigenen Code schreiben und einzelne Teile oder Funktionen aus anderem Code übernehmen. Das ist strukturierter und übersichtlicher.
Wenn es nicht auf Anhieb klappt, dann zerlege die Aufgabe in einzelne Teilaufgaben, die Du unabhängig voneinander löst.

z.B.

  1. HTTP-Request an ein PHP-Script auf dem NAS schicken. Dazu einfach zwei fixe Werte in loop() einmal pro Minute an das Script schicken und dort auswerten.
  2. Wenn 1 funktioniert, dann Deinen Code zum Auslesen der Temperaturen (am besten als eigene Funktion) in den Code mit einbauen. Dann die bisher fixen Werte durch die gemessene Temperatur ersetzen und wieder mit dem PHP-Script verarbeiten
  3. Ergänzen weiterer Funktionen die Du noch haben willst.

Btw. ich habe keine zusätzliche Wetterstation, der Arduino IST die Wetterstation :slight_smile:
Mario.

Hallo,
ok ich bin dabei den Code zu zerpflücken und ihn für mich neu zusammen zu setzten...
Aber hier mal der Link zum Orginal, von dem ich das kopiert habe:
http://jleopold.de/wp-content/uploads/2011/03/ArduinoDatenLogger.txt

Ich versuche es mal so wie du gesagt hast... Gar nicht so einfach...
ich geh den mal wieder ins Kämmerlein.....

Danke dir !!

Keine Panik, das wird schon. Immer schön einen Schritt nach dem anderen.
Als erstes kannst Du ja das PHP Script auf dem NAS entwickeln. Das es macht was es soll, kannst Du ja erstmal mit einem Browser testen. Wenn das klappt, ist dann der Arduino dran mit senden.
Das zunächst nur mit festen Daten und wenn das dann klappt, kommen die gemessenen Werte dran.
Und wenn es Fragen gibt, dann sind wir hier ja auch noch da.

Hi,
ich habe es genau andersrum gemacht :blush:
Ich habe mich am Arduino versucht, also er liest die Temperatur und gibt sie Serial aus.
Hier der funktionierende Sketch bis jetzt:

/*
  Web client
  This sketch connects to my Diskstation 192.168.178.111
  and send the Themperature from DS18B20 at DigiPin 6 to it
 
  created 20 April 2012 
*/

#include <SPI.h>
#include <Ethernet.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 6          // DS18B20 an Pin 6 angeschlossen

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress Fuehler1 = { 0x28, 0x65, 0x35, 0xC3, 0x03, 0x00, 0x00, 0x35 };  //Adressen der Sensoren manuell eingeben

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {  0x90, 0xA2, 0xDA, 0x00, 0xEE, 0xF3 }; // Mac-Adresse Arduino Ethernet
byte ip[] = {192,168,178,230}; // IP-Adresse Arduino Ethernet
byte gateway[] = {192,168,178,1}; // Gateway (Fritzbox)
byte subnet[] = {255,255,255,0}; 
IPAddress server(192,168,178,111); // Diskstation DS111
char host[] = "192.168.178.111\n";

// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

char url[]  = "/senddata.php";	// Pfad zur PHP-Datei eingeben
char c;

int Sensor = 6;    		        // DS18B20 an DigitalPin 6
int ledPIN = 5;          		// Power LED DigitalPin5
float temp1 = 0;        		// Variable für Temperatur
           		

void setup() 
{
  Serial.begin(9600);  
  sensors.begin();
  sensors.setResolution(Fuehler1, 9); 
  
  pinMode(ledPIN, OUTPUT);
  Ethernet.begin(mac, ip, gateway, subnet);       // starte Ethernet
 // delay(1000);                                    // warten auf Ethernet
 // Serial.println("verbinde...");                  // Ausgabe(n) auf serieller Konsole
 // if (client.connect(server, 80))                  // wenn Verbindungsversuch erfolgreich ...
 // { 
 // Serial.println("verbunden");                  // Ausgabe(n) auf serieller Konsole
 // client.print("GET /senddata.php?Fuehler1=");     // schicke Temperatur zum Server
 // client.print(temp1);
 // client.print(" HTTP/1.0\n"); 
 //  client.println("Host: 192.168.178.111\n");
 //  client.println();                             // schicke Leerzeile (beende Anfrage)
 // } 
 // else                                             // sonst, wenn Verbindung fehlgeschlagen, ...
 // {
 //  Serial.println("Verbindung fehlgeschlagen"); // Fehlermeldung auf Konsole
 // }
 //  if (client.available()) 
 // {
 //   char c = client.read();
 //   Serial.print(c);
 // }
 // delay(899000);
 // client.stop();
 // client.flush();
}

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00) {
    Serial.print("Error getting temperature");
  } else {
    Serial.print("C: ");
    Serial.print(tempC);
  }
}

void loop()
{
  
    Sensor_lesen();
    //Daten_senden();
    delay(10000);
}

void Sensor_lesen()
{
  sensors.requestTemperatures();
  //float temp1 = sensors.getTempC(Fuehler1);
  Serial.print("Temperatur: ");
  printTemperature(Fuehler1);
  Serial.print("C");
  Serial.print("\n\r");
}

/*void Daten_senden()
{
    Serial.print("Verbunden...sende Daten...");
    client.print("GET ");
    client.print(url);
    client.print("?Fuehler1=");
    client.print(temp1);
    client.println(" HTTP/1.1");
    client.println();
    Serial.println("fertig!");
  }
  */

Alles andere habe ich erstmal auskommentiert, da ich nicht weiß, was ich in die PHP-Datei schreiben soll.
Ich habe zwar schon mal was mit PHP gemacht, aber noch nie irgendwas von einem anderen Rechner abgefragt oderso. Da hab ich null Ahnung (Aber davon ganz viel :grin:)

<?php
$_GET["Fuehler1"]; // Temperatur von Fuehler 1
$dateiname = "log.txt"; // Name der Log-Datei
// Datei öffnen, wenn nicht vorhanden dann wird die Datei erstellt.
$handler = fOpen($dateiname , "a+");
// Dateiinhalt in die Datei schreiben
fWrite($handler , $GET); // <-- Ist das richtig ?
fClose($handler); // Datei schließen
?>

Is ne Idee, keine Ahnung ob das richtig ist :frowning:
Wird die Temperatur denn so übergeben? GET sollte doch richtig sein, oder?

Der PHP Code ist schon mal ein Anfang. Zwei Dinge würde ich ändern:

<?php
$data = $_GET["Fuehler1"]; // Temperatur von Fuehler 1 nach $data; nicht zwingend notwendig, aber übersichtlicher.
$dateiname = "log.txt"; // Name der Log-Datei (ggf. "/volume1/.../log.txt
// Datei öffnen, wenn nicht vorhanden dann wird die Datei erstellt.
$handler = fopen($dateiname , "a+");
if($handler) {
    // Dateiinhalt in die Datei schreiben
    fputs($handler , time().";$data\n"); // Unix-Timestamp; $data + Zeilenumbruch schreiben
    fclose($handler); // Datei schließen
}
?>

Damit sollte es erstmal klappen. Beim Dateinamen musst Du evtl. noch einen passenden Pfadmit angeben. Kommt drauf an, wo der Webserver auf Deinem NAS schreiben darf.
Idealerweise schreibst Du die Daten in ein Verzeichnis, das vom NAS exportiert wird, dann kannst Du direkt auf die Datei von Deinem PC aus zugreifen.
Mario.

Hallo Mario,
erstmal VIELEN DANK für die tolle Hilfe!!! :smiley:
Es funktioniert !!! XD

Der Arduino sende die Temperatur an meine Diskstaion und die speichert die Temperatur mit dem Datum und Uhrzeit. Klasse. Jetzt mache ich noch ein bischen feintuning... :wink:

Ich werde den Sketch noch Kommentieren und dann hier Posten.
Bei bedarf kann ich den auch jetzt schon Posten...

Also, vielen Dank an Mario aka mkl0815 und thewknd.

Hallo,
so habe mal versucht den Sketch zu Kommentieren,
ich hoffe das ist OK so und verständlich. :slight_smile:

Die Idee war folgende:
DS18B20 --> Arduino Ethernet -->LAN-Kabel --> WebServer

Soll heißen, der Arduino misst die Temperatur und schickt sie zum Webserver,
der speichert die Temperatur mittels PHP-Script in einer Text-Datei (z.b. Log.txt) ab.
Und kann dann weiter verarbeitet werden, z.b. für Visuelle Dartsellungen usw.

Ich möchte an dieser stelle nochmal ein Dankeschön sagen, für die tolle Unterstützung hier im Forum !

Hier der Sketch:

Ich habe mir den fertigen Sketch mal angesehen und mir fallen dabei eingige Dinge auf.

  1. Du verwendest zwei Funktionden Sensor_lesen() und Daten_senden(), das finde ich gut, weil es das Programm übersichtlich macht. Aber warum liest Du im Daten_senden() den Sensor nochmal aus? Damit schickst Du an den Webserver ggf. eine andere Temperatur, als Du über Sensor_lesen() über die serielle Schnittstelle ausgegeben hast.

2). Daten_senden() verschickt die Daten an den Webserver. Im loop() gibt es aber nochmal Code der sich mit dem Webserver verbindet. Der allerdings nichts weiter macht als ein Zeichen aus der Verbindung zu lesen und dann 30 Sekunden bei offener Verbidung zu warten. Das ist nicht nur sinnlos, sondern auch "gemein" gegenüber dem Webserver, da Du eine offene Verbdindung blockierst. In Deinem Fall ist das wurscht, aber kein guter Stil. Stell Dir vor Du baust damit einen öffentlichen Webservice, wo alle Arduinouser dieser Welt Ihre Daten hinloggen dürfen. Und alle würden ihre Verbindung unnötigerweise 30 Sekunden offen halten, dann hast Du einen selbst gebauten Denial of Service Angriff.

  1. Auch die Funktion printTemperature() liest den Sensor nochmal aus. Damit ist das die dritte Stelle im Code, die das macht. Hier würde ich viel mehr aufräumen.
  • Eine Funktion die den Sensor ausliest und die globale Variable temp1 setzt. Gleichzeitig kannst Du eine globale Variable "boolean messenOK" einführen, die von Sensor_lesen() immer gesetzt wird. TRUE wenn das Messen erfolgreich war, und FALSE wenn nicht.

  • printTemperature() gibt den Wert der in temp1 steht nach Serial aus, aber ohne selbst zu messen. Ist "messenOK" gleich FALSE wird eine Fehlermeldung ausgegeben. Gleichzeitig kannst Du z.B. noch eine rote LED einschalten, die dann den Fehler signalisiert.

  • Daten_senden() schreibt die Daten an den Webserver, aber auch wieder ohne selbst zu messen. Auch hier kannst Du z.b. den Fehler mit an den Webserver melden.

Beim Schreiben auf den Webserver kannst Du Dir folgenden Code sparen:

  if (client.available()) 
 {
   char c = client.read();
   Serial.print(c);
 }

Außer Du willst tatsächlich etwas vom Webserver lesen.

In Daten_senden() würde ich auch noch ein client.close() einbauen, das ist besserer Stil (siehe oben - offene Verbindungen).

Ansonsten ist es doch eine runde Lösung geworden.
Mario.

Hallo Mario,
oh ok, werde ich mir mal alles anschauen.
Ich denke aber, das ich da vieleicht nochmal deine Hilfe in anspruch nehemen muss... :roll_eyes:

Hi, ich krame das mal aus, habt ihr auch ein Projekt gesehen, wo die Daten wirklich auf der SD gepuffert werden, bis der Webserver die Daten abgeholt hat? Da mein NAS nicht die ganze nacht durch läuft, oder auch um bei Updates etwas unabhänging zu sein von der Verfügbarkeit des NAS???

MQTT liest sich auch recht nett, aber habe auch noch nicht gesehen, ob der Broker die Daten puffert? Das wäre eine alternative.

Leichenschänder :slight_smile:
So ein Projekt hab ich zwar noch nicht gesehen, sollte aber doch mit wenig Aufwand zu realisieren sein. Die einzige Schwierigkeit dürfte sein, zu gewährleisten, dass keine Daten verschütt gehen. Anstatt vom Server abholen zu lassen, würde ich eher zum Pushen neigen. Dann bekomme ich eine Empfangsbestätigung und kann die Daten auf sd-Karte löschen.