MySQL DB Eintrag auslesen ? [gelöst]

Nur mal schnell erzählt, warum ich float benutze bzw. habe.
Der Zählerstand ist 9013,46m³ und wenn ich float beutzte wird er auch so in die DB eingetragen.
Aber wenn ich unsigned long verwende, wird die Zahl so 901346 eingetragen, sprich ohne Punkt/Komma.
Und da ich nicht weiß (und auch noch nicht geschaut habe) wie ich das ändern kann, benutze ich float.

Werde das aber auf jedenfall ändern, habe das schon verstanden, warum man nicht float nimmt. 8)

Und vielen Dank für deine Super Hilfe, werde mich heute abend ran machen, alles um zu setzen.
Bis später....

So, da bin ich wieder... =(
Ich verstehe nicht wie ich das umsetzten soll,ich habe jetzt folgenden Sketch:

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

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
IPAddress ip(192,168,178,140);
IPAddress server(192,168,178,111);
EthernetClient client;


char host[]    = "192.168.178.111";                      // Domain
char url[]     = "/Arduino/Gas/read.php"; // Pfad zur PHP-Datei

unsigned long GZStand=0;

void setup() 
{
Serial.begin(9600);
Serial.print("Setup LAN ... ");
// give the Ethernet shield a second to initialize:
delay(1000);
Ethernet.begin(mac, ip);
Serial.println("ok");
delay(1000);
Daten_senden();
}


void loop()
{
 char buffer[10] = "";
 int index = 0;
 
if (client.available()) 
{
  delay(100);
  while (client.available()) 
  {
    buffer[index++] = client.read();
}
}
buffer[index] = 0; // NULL-Terminierung
Serial.print("Antwort :  ");
Serial.println(buffer);
}


void Daten_senden(){

if (client.connect(server, 8000)) {
    Serial.println(F("Verbunden, Sende Daten..."));

    client.print("GET ");
    client.print(url);
    Serial.print("GET ");
    Serial.print(url);   
    client.println(" HTTP/1.1");
    Serial.println(F(" HTTP/1.1"));
    client.print("Host: ");
    client.print(host);
    Serial.print("Host: ");
    Serial.print(host);
    client.println();
    Serial.println();
    client.println("User-Agent: Arduino");
    Serial.println(F("User-Agent: Arduino"));
    client.println("Connection: close");
    Serial.println(F("Connection: close"));
    client.println();
    Serial.println();
  } else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
    Serial.println("disconnecting.");
  }  

}

bei dem DAS rauskommt :

Setup LAN ... ok
Verbunden, Sende Daten...
GET /Arduino/Gas/read.php HTTP/1.1
Host: 192.168.178.111
User-Agent: Arduino
Connection: close

Antwort :  
.6
Vary: Accept-Encoding
Content-Length: 7
Connection: close
Content-Type: text/html

9015.08HTTP/1.1 200 OK
Date: Thu, 10 Jan 2013 21:15:27 GMT
Server: Apache/2.2.21 (Unix) PHP/5.3.6
X-Powered-By: PHP/5.3.6
Vary: Accept-Encoding
Content-Length: 7
Connection: close
Content-Type: text/html

9015.08
Setup LAN ... ok
connection failed
disconnecting.
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort :  
Antwort : 
...

Ich verstehe nicht wie der Aufbau der Loop aussehen muss, damit da der DB Eintrag zu sehen ist :blush:
Please Help...

Hallo Cetax,

Du machst es Dir schon wieder viel zu kompliziert. Einfach mal einen Schritt zurück treten und überlegen was Du am Ende umsetzen willst und was Du bisher Du bisher schon hast (deinen eigentlichen Gaszähler-Sketch).

Du hast in Deinem eigentlichen Programm eine Funktion Daten_senden(), mit deren Hilfe Du über einen HTTP Request vom Arduino Daten an den Webserver schickst, damit dieser die übermittelten Daten in die Datenbank schreibt.
Was Du nun noch brauchst ist eine Funktion z.B. Daten_laden() mit deren Hilfe Du über einen HTTP Request Daten vom Webserver an den Arduino schickst, die der Websrveraus der Datenbank gelesen hat.
Fällt Dir die Ähnlichkeit der letzten beiden Sätze auf? Warum ist das so? Weil die Anforderungen an beide Funktionen sehr ähnlich sind. Du bist sogar schon selbst drauf gekommen, denn Du hast ja einen Teil der Daten_Senden() Funktion in den neuen Test-Sketch übernommen. Leider nicht ganz konsequent. Da Du einen Teil wieder in setup() und in die loop() ausgelagert hast.

Ich gebe mal die Struktur des Testprogramms vor und Du füllst es mit dem was Du quasi schon hast:

void setup() {
  // IP Konfiguration setzen
  // Serielle Konsole initialisieren

}

void loop() {
  // http-request senden und in variable speichern

  // 10 sekunden warten
}

//achtung wir liefern ein char* (c-String zurück)
char* daten_laden() {
    // puffer initialisieren mit leerem string
    // zaehlindex auf 0 setzen

   // connect to server

   // connected?

   //wenn connected, request senden

        // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen

        // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)

    // puffer per return zurückliefern    
}

Der Trick ist also, wie schon beim Daten_senden() die ganze Funktionalität in die daten_laden() funktion zu packen. Auch wenn es erstmal nur ein Testprogramm ist, denn wenn alles was Du braucht in der Funktion steckt, brauchst Du die am Ende nur noch in Deinen eigentlichen Sketch kopieren.

Sobald die Funktion läuft, kümmern wir uns dann um das Umwandeln in eine Zahl.

Mario.

Hallo Mario,
also ich habe versucht, das zuverstehen was du geschrieben hast und es versucht umzusetzen. :blush:

Der Sketch kompiliert ohne Fehler durch und ich sehe im Serial-Monitor auch was, aber nicht den Gasstand. :frowning:

Hier der Sketch:

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

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
IPAddress ip(192,168,178,140);
IPAddress server(192,168,178,111);
EthernetClient client;


char host[]    = "192.168.178.111";                      // Domain
char url[]     = "/Arduino/Gas/read.php"; // Pfad zur PHP-Datei

unsigned long GZStand=0;
char* returnvalue = 0;



void setup() {
  // IP Konfiguration setzen
  // Serielle Konsole initialisieren
  Serial.begin(9600);
  Serial.print("Setup LAN ... ");
  delay(1000);
  Ethernet.begin(mac, ip);
  Serial.println("ok");
}

void loop() {
  // http-request senden und in variable speichern
  daten_laden();
  
  // 10 sekunden warten
  delay(10000);
}

//achtung wir liefern ein char* (c-String zurück)
char* daten_laden() {
    char buffer[10] = ""; // puffer initialisieren mit leerem string
    int index = 0;        // zaehlindex auf 0 setzen
    
   client.connect(server, 8000);   // connect to server
        
   
   if (client.available()) // connected?
   {
    char c = client.read();
    Serial.print(c);
   }
       
   //wenn connected, request senden
    if (client.connected()) {
    Serial.println(F("Verbunden, Sende Daten..."));

    client.print("GET ");
    client.print(url);
    Serial.print("GET ");
    Serial.print(url);   
    client.println(" HTTP/1.1");
    Serial.println(F(" HTTP/1.1"));
    client.print("Host: ");
    client.print(host);
    Serial.print("Host: ");
    Serial.print(host);
    client.println();
    Serial.println();
    client.println("User-Agent: Arduino");
    Serial.println(F("User-Agent: Arduino"));
    client.println("Connection: close");
    Serial.println(F("Connection: close"));
    client.println();
    Serial.println();
  }

  // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
  buffer[index++] = client.read();
  
  // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  buffer[index] = 0; // NULL-Terminierung
  
  // puffer per return zurückliefern    
  returnvalue=buffer;
}

Ich weiß auch nicht wie ich das "unsigned long GZStand=0;" einbinden soll.
Eigentlich doch hier , oder ?

void loop() {
  // http-request senden und in variable speichern
  daten_laden();
  
  // 10 sekunden warten
  delay(10000);
}

Und hier die Ausgabe:

Setup LAN ... ok
Verbunden, Sende Daten...
GET /Arduino/Gas/read.php HTTP/1.1
Host: 192.168.178.111
User-Agent: Arduino
Connection: close

HVerbunden, Sende Daten...
GET /Arduino/Gas/read.php HTTP/1.1
Host: 192.168.178.111
User-Agent: Arduino
Connection: close

T/. 0 K
ae r,1 a 032:62

Ich habe irgendwo was falsches Eingegeben, aber ich sehe nicht wo... :~

Nehmen wir doch mal die daten_laden() Funktion auseinander und schauen was sie macht und was sie eigentlich machen sollte:

char* daten_laden() {

definiert eine Funktion die einen Zeiger auf einen C-String zurück liefert. Das ist schon mal ok.

    char buffer[10] = ""; // puffer initialisieren mit leerem string
    int index = 0;        // zaehlindex auf 0 setzen
    
   client.connect(server, 8000);   // connect to server

definiert ein Array für 10 Zeichen (bzw. 9 Zeichen, wenn wir einen C-String mit \0 Terminierung draus machen) und einen Zählindex.
Außerdem wird die Server-Verbnidung hergestellt. Alles richtig bisher.

Nun wird es aber zum ersten Mal seltsam.

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

Hier wird ein Zeichen aus der gerade aufgebauten Verbindung gelesen, wenn vorhanden. Aber warum? Wir haben noch keine Daten an den Server geschickt, wieso sollten wir hier also Daten bekommen?
Zumal das Zeichen nur gelesen und auf der Seriellen Konsole ausgegeben wird, es wird aber nicht verarbeitet. Diese Code-Schnippsel kann also komplett weg.

   //wenn connected, request senden
    if (client.connected()) {
    Serial.println(F("Verbunden, Sende Daten..."));

    client.print("GET ");
    client.print(url);
    Serial.print("GET ");
    Serial.print(url);   
    client.println(" HTTP/1.1");
    Serial.println(F(" HTTP/1.1"));
    client.print("Host: ");
    client.print(host);
    Serial.print("Host: ");
    Serial.print(host);
    client.println();
    Serial.println();
    client.println("User-Agent: Arduino");
    Serial.println(F("User-Agent: Arduino"));
    client.println("Connection: close");
    Serial.println(F("Connection: close"));
    client.println();
    Serial.println();
  }

Hier wird der Request an den Webserver geschickt. Sehr schön, weil ohne böse String-Klasse :slight_smile: Und an drei Stellen sogar mit dem F() Macro um Speicher zu sparen. Sehr schön und ausbaufähig.

  // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
  buffer[index++] = client.read();
 
  // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  buffer[index] = 0; // NULL-Terminierung

Hier wird dann ein und NUR EIN Zeichen aus der Verbindung gelesen und in den Puffer geschrieben. Dabei wird gleichzeitig der Wert von index um 1 erhöht (das macht das ++ hinter derm index).
Anschliessend wird unter dem neuen Index der Wert 0 gesetzt. Du hast damit einen C-String mit einem Zeichen gebaut, nämlich dem ersten Zeichen das der Webserver schickt. Es sollte also in Deinem Puffer dann die erste Ziffer der erwarteten Zahl stehen. Den Code um alle Zeichen einzulesen hatte ich aber schon gegeben und Du hast ihn in Deinem vorherigen Code sogar schon verwendet, nur das er da in der loop() steckte.

char[10] buffer = "";
int index = 0;
while (client.available()) {
    buffer[index++] = client.read();
} 
buffer[index] = 0 // NULL-Terminierung
Serial.print("Antwort :  ");
Serial.println(buffer);

Es fehlt also die WHILE-Schleife um das buffer[index++] = client.read();, dann sollten schon alle Zeichen gelesen werden.

Nun zur letzten Zeile

returnvalue=buffer;

Das funktioniert zwar, ist aber umständlich. Wir haben die Funktion daten_laden() ja als char* daten_laden() definiert. Das bedeutet, das diese Funktion einen Rückgabewert hat. Den sollten wir dann auch verwenden. Z.B. so:

  return buffer;

Damit sparen wir uns die Variable "returnvalue"

Ansonsten sehe ich in Deinem Code keinerlei Ausgabe bei der die empfangenen Zeichen auch ausgegeben werden. Ohne Ausgabe sieht man aber nix.

Die Ausgabe kommt dann in die loop() :

void loop() {
  // http-request senden und in variable speichern
  char* zaehlerstand = daten_laden();
  Serial.print("\n\nAntwort : ");
  Serial.println(zaehlerstand);
  // 10 sekunden warten
  delay(10000);  
}

Das "unsigned long GZStand=0;" ist zur Zeit noch unwichtig, da es ja zunächst darum geht, das wir den Zählerstand als String bekommen. Erst wenn das klappt, machen wir uns Gedanken wie wir daraus eine Zahl machen.
Aber das ist der nächste Schritt. Aktuelle kümmern wir uns nur um die Rückgabe des Webservers.

Nachdem ich den Code nun "zerpflückt" habe, versuch Du den mal mit den von mir geschriebenen Hinweisen wieder zusammen zu setzen. Ich denke dann bist Du schon wieder ein Ganzes Stück weiter.

Mario.

ahh, ok.
habe es jetzt so zusammen gesetzt, das da was "Rauskommt"...

Hier der Sketch:

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

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
IPAddress ip(192,168,178,140);
IPAddress server(192,168,178,111);
EthernetClient client;

char host[]    = "192.168.178.111";                      // Domain
char url[]     = "/Arduino/Gas/read.php"; // Pfad zur PHP-Datei

unsigned long GZStand=0;
char* returnvalue = 0;


void setup() {
  // IP Konfiguration setzen
  // Serielle Konsole initialisieren
  Serial.begin(9600);
  Serial.print("Setup LAN ... ");
  delay(1000);
  Ethernet.begin(mac, ip);
  Serial.println("ok");
}

void loop() {
  // http-request senden und in variable speichern
  char* zaehlerstand = daten_laden();
  Serial.print("\n\nAntwort : ");
  Serial.println(zaehlerstand);
  // 10 sekunden warten
  delay(10000);  
}


//achtung wir liefern ein char* (c-String zurück)
char* daten_laden() {
    char buffer[10] = ""; // puffer initialisieren mit leerem string
    int index = 0;        // zaehlindex auf 0 setzen
 
   client.connect(server, 8000);   // connect to server
    Serial.println(F("Verbinde ..."));    

   //wenn connected, request senden
   if (client.connected()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println("User-Agent: Arduino");
    client.println("Connection: close");
    client.println();
   }


while (client.available()) {
    buffer[index++] = client.read();   // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
}

buffer[index] = 0;    // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
return buffer;        // puffer per return zurückliefern

}

Ich habe mich mal an atoi versuch, aber da scheiterts mal wieder am verständnis, wo ich das eintragen muss.
Sofern atoi das richtige ist.

char buffer[10] = "123";
int index;

index = atoi(buffer);
Serial.println(index);

Sorry, mein Fehler. Der Webserver schickt ja nicht nur den Wert zurück, sondern auch noch einen HTTP-Response Header, den müssen wir vorher wegwerfen, ehe wir die Daten aus der Verbindung lesen können.
Das ist aber einfach. Hier mal meine Version von daten_laden():

daten_laden() {
  //buffer wird jetzt extern definiert.
  int index = 0;        // zaehlindex auf 0 setzen

  client.connect(server, 8000);   // connect to server
  Serial.println(F("Verbinde ..."));    

  //wenn connected, request senden
  if (client.connected()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(20);
  } 

  //Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '

Beim return hatte ich mich wohl auch geirrt. Ich hab zwar ein Testprogramm, wo das klappt, aber mit einem globalen Puffer ist es sicher übersichtlicher. Es braucht also da wo Du host und server definierst noch ein "char buffer[10];" oben im sketch.
Außerdem muss Dein PHP-Script ein "$" vor die ausgegebene Zahl schreiben. Das ist ein kleiner Trick, damit man solange Daten aus der Verbindung lesen kann, bis man das "$" findet. Alles danach sind dann die Nutzdaten.);

Serial.println("$ found");

//einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
  while (client.available() && index < 10) {
    buffer[index++] = client.read();  // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
  }

buffer[index] = 0;    // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)

}


Beim return hatte ich mich wohl auch geirrt. Ich hab zwar ein Testprogramm, wo das klappt, aber mit einem globalen Puffer ist es sicher übersichtlicher. Es braucht also da wo Du host und server definierst noch ein "char buffer[10];" oben im sketch.
Außerdem muss Dein PHP-Script ein "$" vor die ausgegebene Zahl schreiben. Das ist ein kleiner Trick, damit man solange Daten aus der Verbindung lesen kann, bis man das "$" findet. Alles danach sind dann die Nutzdaten.

Hi,
wow , ok, das hätte ich niemals allein soweit geschaft...
Also, ich habe das, was du geschrieben hast, jetzt eingefügt und es kommt auch ein

$ found

Aber bei "Antwort" kommt nur ein "<"

So ein < kommt aber in der read.php nicht vor.

Hier der Sketch :

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

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
IPAddress ip(192,168,178,140);
IPAddress server(192,168,178,111);
EthernetClient client;


char host[]    = "192.168.178.111";                      // Domain
char url[]     = "/Arduino/Gas/read.php"; // Pfad zur PHP-Datei

unsigned long GZStand=0;
char* returnvalue = 0;
char buffer[10];


void setup() {
  // IP Konfiguration setzen
  // Serielle Konsole initialisieren
  Serial.begin(9600);
  Serial.print("Setup LAN ... ");
  delay(1000);
  Ethernet.begin(mac, ip);
  Serial.println("ok");
}

void loop() {
  // http-request senden und in variable speichern
  char* zaehlerstand = daten_laden();
  Serial.print("\n\nAntwort : ");
  Serial.println(zaehlerstand);
  // 10 sekunden warten
  delay(10000);  
}



//achtung wir liefern ein char* (c-String zurück)
char* daten_laden() {
      
  //buffer wird jetzt extern definiert.
  int index = 0;        // zaehlindex auf 0 setzen

  client.connect(server, 8000);   // connect to server
  Serial.println(F("Verbinde ..."));    

  //wenn connected, request senden
  if (client.connected()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(20);
  } 

  //Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '

So langsam wird es immer schwieriger dir zu folgen :blush:

Gruß
Stefan);

Serial.println("$ found");

//einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
  while (client.available() && index < 10) {
    buffer[index++] = client.read();  // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
  }

buffer[index] = 0;    // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)

}


So langsam wird es immer schwieriger dir zu folgen :blush:

Gruß
Stefan

Der Wert steht in buffer drin, nicht in zaehlerstand. Da Du aber zaehlerstand ausgibst, bekommst Du das Ergebnis nicht. Verwende mal

  daten_laden();
  Serial.print("\n\nAntwort : ");
  Serial.println(buffer);

Dann sollte es gehen. Für Dein Problem mit dem float in der Datenbank habe ich mittlerweile auch eine Lösung, die ist zwar etwas hinterhältig und nicht sehr elegant, sollte aber reichen.

Aber eins nach dem anderen. Erstmal mußt Du sicher Deine Werte bekommen. Dazu fehlt wie mir gestern bei meinen Tests noch aufgefallen ist ein "Client.stop()" am Ende der daten_laden() Funktion.

Mario.

Arg... jepp wer lesen und verstehen kann ist klar im Vorteil....
Hätte ich vieleicht auch selber drauf kommen können. :blush:

mkl0815:
Der Wert steht in buffer drin, nicht in zaehlerstand. Da Du aber zaehlerstand ausgibst, bekommst Du das Ergebnis nicht. Verwende mal

  daten_laden();

Serial.print("\n\nAntwort : ");
  Serial.println(buffer);



Dann sollte es gehen.

Hat natürlich geklappt ! DANKE !!

Für Dein Problem mit dem float in der Datenbank habe ich mittlerweile auch eine Lösung, die ist zwar etwas hinterhältig und nicht sehr elegant, sollte aber reichen.

Ok, da bin ich gespannt... 8)
Wobei ich noch anmerken möchte, das ich bis jetzt alles in float gespeichert habe und wenn du sagt ich kann das einfach in unsigned long machen, mach ich das.
Ich denke die Ausgabe nachher, kann man bestimmt mit PHP formatieren, so das sie wieder mit Punkt zu sehen ist.

Aber eins nach dem anderen. Erstmal mußt Du sicher Deine Werte bekommen.
Dazu fehlt, wie mir gestern bei meinen Tests noch aufgefallen ist, ein "Client.stop()" am Ende der daten_laden() Funktion.

Wert ist zu sehen.

Setup LAN ... ok
Verbinde ...
$ found


Antwort : 9031.63

Ein client.stop(); habe ich eingefügt, ganz am Ende.
Hier jetzt der Read Sketch, so wie er funktioniert:

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

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
IPAddress ip(192,168,178,140);
IPAddress server(192,168,178,111);
EthernetClient client;


char host[]    = "192.168.178.111";                      // Domain
char url[]     = "/Arduino/Gas/read.php"; // Pfad zur PHP-Datei

unsigned long GZStand=0;
char* returnvalue = 0;
char buffer[10];


void setup() {
  // IP Konfiguration setzen
  // Serielle Konsole initialisieren
  Serial.begin(9600);
  Serial.print("Setup LAN ... ");
  delay(1000);
  Ethernet.begin(mac, ip);
  Serial.println("ok");
}

void loop() {
  // http-request senden und in variable speichern
  char* zaehlerstand = daten_laden();
  Serial.print("\n\nAntwort : ");
  Serial.println(buffer);
  // 10 sekunden warten
  delay(10000);  
}



//achtung wir liefern ein char* (c-String zurück)
char* daten_laden() {
      
  //buffer wird jetzt extern definiert.
  int index = 0;        // zaehlindex auf 0 setzen

  client.connect(server, 8000);   // connect to server
  Serial.println(F("Verbinde ..."));    

  //wenn connected, request senden
  if (client.connected()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(30);
  } 

  //Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '

stefan
);

Serial.println("$ found");

//einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
  while (client.available() && index < 10) {
    buffer[index++] = client.read();  // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen
  }

buffer[index] = 0;    // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}


stefan

So habe mich mal mit atol beschäftigt.
Wenn ich folgendes einfüge

GZStand_DB = atol(buffer);
  Serial.println(GZStand_DB);

Dann sehe ich im Serialmonitor den DB Eintrag.
Kann man das so machen ?
Kann ich jetzt "GZStand_DB" weiter verarbeiten ?
Ist dort die Zahl drin oder verstehe ich das falsch ?

Mit weiterverarbeiten, meine ich , ob ich das damit machen kann :

unsigned long ZStand = 890023;      // Gasstand bei Start
unsigned long ZStandNeu;            // Gasstand Neu
unsigned long ZStand_DB;            // Gasstand aus DB

if(ZStand_DB > ZStand)                               // DB eintrag größer als Gasstand bei start, dann
{
  ZStandNeu = ZStand_DB + buttonPresses;   // DB eintrag + Zählimpuls = Neuer Gasstand zum eintrgaen in DB
}

stefan

So kompliziert würde ich es gar nicht machen. Ich würde einfach in der setup() Funktion die Funktion daten_laden() aufrufen und prüfen ob da was sinnvolles zurück kommt. Wenn ja wird der Wert verwendet, ansonsten eben nicht.
Wenn Du Deine Datenbank nicht ändern willst, kannst Du auch mit "atof(buffer)" den Buffer in ein "float" umwandeln.

Meine Lösung war, das Du das PHP-Script das den Zählerstand lieferst und wo Du irgendwo ja ein echo "$"; echo $zaehlerstand; haben musst anpasst, das es den Zählerstand vorher mit 100 multiplizierst, dann liefert das Script einen ganzzahligen Wert, den Du mit atol() umwandeln kannst. Am Ende wird dieser Wert dann einfach durch 100 geteilt und wird so wieder zum float.

Mario.

mkl0815:
So kompliziert würde ich es gar nicht machen. Ich würde einfach in der setup() Funktion die Funktion daten_laden() aufrufen und prüfen ob da was sinnvolles zurück kommt. Wenn ja wird der Wert verwendet, ansonsten eben nicht.

Was verstehst du unter "... ob da was sinnvolles zurück kommt" ?
Ich muss doch die Werte vergleichen oder nicht ?
Wenn der Arduino Neu Startet, dann nimmt er ja den alten Start Wert und nicht den letzten Eintrag in der DB.
Arhh... Habe verstanden... Ok... :blush:

Wenn Du Deine Datenbank nicht ändern willst, kannst Du auch mit "atof(buffer)" den Buffer in ein "float" umwandeln.

Ok, danke für den Tip, ich denke, ich werde aber, da es ja für längerfristig geplant ist, auf unsigned long umsteigen.
Wie du ja schon weiter oben geschrieben hast, ist man damit ja auf der sicheren Seite.

Meine Lösung war, das Du das PHP-Script das den Zählerstand lieferst und wo Du irgendwo ja ein echo "$"; echo $zaehlerstand; haben musst anpasst, das es den Zählerstand vorher mit 100 multiplizierst, dann liefert das Script einen ganzzahligen Wert, den Du mit atol() umwandeln kannst. Am Ende wird dieser Wert dann einfach durch 100 geteilt und wird so wieder zum float.

Mario.

Ok, ich probiere mich mal durch...

Aber auf jedenfall VIELEN DANK für deine tolle Hilfe !!! :wink:
So als ahnungsloser hätte ich das niemals so weit geschaft...

DANKE

Gruß
Stefan

PS: Eine Frage noch, wäre es auch möglich, fehlende Werte, z.B. wegen einer fehlenden LAN-Verbindung, auf die SD-Card zu schreiben und wenn die LAN-Verbindung wieder da ist, die fehlenden Werte nachträglich in die DB zu schreiben ?

Hier der Sketch, mit dem ich einen Wert aus einer MySQL lese.
In diesem Sketch verwende ich noch float, was man aber lieber in unsigned long ändern sollte.

/*
  #####################################################
  #          Einen Wert aus einer MySQL DB lesen      #
  #####################################################
*/
#include <SPI.h>                                       // library für die Serielle Kommunikation
#include <Ethernet.h>                                  // library für Ethernet kommunikation

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };   // MAC-Adresse der Arduino
IPAddress ip(192,168,178,140);                         // IP-Adresse des Arduino
IPAddress server(192,168,178,111);                     // IP-Adresse des Servers
EthernetClient client;                                 // initialisiere Ethernet-Bibliothek 

char host[]    = "192.168.178.111";                    // Domain
char url[]     = "/Arduino/Gas/read.php";              // Pfad zur PHP-Datei

float GZStand;                                         // Wert aus DB als Variablentyp float
char* returnvalue = 0;                                 // Variable mit max 10 zeichen 
char buffer[10];


void setup() {
  Serial.begin(9600);                                  // Serielle Konsole initialisieren
  Serial.print(F("Setup LAN ... "));
  delay(1000);
  Ethernet.begin(mac, ip);                             // IP Konfiguration setzen
  Serial.println(F("ok"));
}

void loop() {
  delay(1000);
  char* zaehlerstand = daten_laden();                 // http-request senden und in variable speichern
  Serial.print(F("\n\nAntwort : "));
  Serial.println(buffer);
  GZStand = atof(buffer)/100;                         // durch 100 teilen, weil in der read.php multipliziert wird (*100)
  Serial.println(GZStand);
  delay(10000);                                       // 10 sekunden warten
}


char* daten_laden()                                   //achtung wir liefern ein char* (c-String zurück)
    {
    int index = 0;                                    // zaehlindex auf 0 setzen
    client.connect(server, 8000);                     // connect to server
    Serial.print(F("Verbinde ... "));    
    delay(1000);

    if (client.connected()) {
    Serial.println(F("ok"));
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(30);
  } else {
    Serial.println(F("Keine Verbindung..."));
    client.flush();
    client.stop();
    client.connect(server, 8000);                    // connect to server
    Serial.print(F("Neu Verbinden ... "));    
    delay(1000);
  }

  //Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '

An dieser stelle nochmal ein ganz großes Danke an mkl0815 !);

Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen   
  }

buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}


An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Cetax:
PS: Eine Frage noch, wäre es auch möglich, fehlende Werte, z.B. wegen einer fehlenden LAN-Verbindung, auf die SD-Card zu schreiben und wenn die LAN-Verbindung wieder da ist, die fehlenden Werte nachträglich in die DB zu schreiben ?

Brauchst Du doch nicht wirklich. Dein Script zählt ja trotzdem weiter, auch wenn daten_senden() nicht klappt. Spätestens beim nächsten Sendeversuch werden doch wieder alle angesammelten Daten übertragen, da Du ja in der Zwischenzeit weiterzählst.
Das einzige Risiko ist jetzt, das ein Stromausfall /Reset während der Zeit kommt, in der nicht in die DB geschrieben werden kann. Dann verlierst Du die gezählten Signale.

mkl0815:

Cetax:
PS: Eine Frage noch, wäre es auch möglich, fehlende Werte, z.B. wegen einer fehlenden LAN-Verbindung, auf die SD-Card zu schreiben und wenn die LAN-Verbindung wieder da ist, die fehlenden Werte nachträglich in die DB zu schreiben ?

Brauchst Du doch nicht wirklich. Dein Script zählt ja trotzdem weiter, auch wenn daten_senden() nicht klappt. Spätestens beim nächsten Sendeversuch werden doch wieder alle angesammelten Daten übertragen, da Du ja in der Zwischenzeit weiterzählst.
Das einzige Risiko ist jetzt, das ein Stromausfall /Reset während der Zeit kommt, in der nicht in die DB geschrieben werden kann. Dann verlierst Du die gezählten Signale.

Stimmt... Hatte ich nicht mehr auf dem Zettel.
Und mit dem Risiko kann ich leben, sind ja keine Lebensnotwendigen Zahlen :smiley:

Eben, außerdem kannst Du ja jederzeit den aktuellen Stand als "letzten" Stand von Hand in die Datenbank schreiben und dann dem Arduino kontrolliert einen RESET verpassen. Dann zieht er sich den korrekten Stand und zählt von da an wieder korrekt weiter.

Mal den alten kram ausgegraben.....

Cetax:
Hier der Sketch, mit dem ich einen Wert aus einer MySQL lese.
In diesem Sketch verwende ich noch float, was man aber lieber in unsigned long ändern sollte.

/*

#####################################################
  #          Einen Wert aus einer MySQL DB lesen      #
  #####################################################
*/
#include <SPI.h>                                       // library für die Serielle Kommunikation
#include <Ethernet.h>                                  // library für Ethernet kommunikation

byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };   // MAC-Adresse der Arduino
IPAddress ip(192,168,178,140);                         // IP-Adresse des Arduino
IPAddress server(192,168,178,111);                     // IP-Adresse des Servers
EthernetClient client;                                 // initialisiere Ethernet-Bibliothek

char host[]    = "192.168.178.111";                    // Domain
char url[]     = "/Arduino/Gas/read.php";              // Pfad zur PHP-Datei

float GZStand;                                         // Wert aus DB als Variablentyp float
char* returnvalue = 0;                                 // Variable mit max 10 zeichen
char buffer[10];

void setup() {
  Serial.begin(9600);                                  // Serielle Konsole initialisieren
  Serial.print(F("Setup LAN ... "));
  delay(1000);
  Ethernet.begin(mac, ip);                             // IP Konfiguration setzen
  Serial.println(F("ok"));
}

void loop() {
  delay(1000);
  char* zaehlerstand = daten_laden();                 // http-request senden und in variable speichern
  Serial.print(F("\n\nAntwort : "));
  Serial.println(buffer);
  GZStand = atof(buffer)/100;                         // durch 100 teilen, weil in der read.php multipliziert wird (*100)
  Serial.println(GZStand);
  delay(10000);                                       // 10 sekunden warten
}

char* daten_laden()                                   //achtung wir liefern ein char* (c-String zurück)
    {
    int index = 0;                                    // zaehlindex auf 0 setzen
    client.connect(server, 8000);                     // connect to server
    Serial.print(F("Verbinde ... "));   
    delay(1000);

if (client.connected()) {
    Serial.println(F("ok"));
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(30);
  } else {
    Serial.println(F("Keine Verbindung..."));
    client.flush();
    client.stop();
    client.connect(server, 8000);                    // connect to server
    Serial.print(F("Neu Verbinden ... "));   
    delay(1000);
  }

//Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '




An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Der Sketch funktioniert bei dir?

Also bei mir nicht. Ich sag auch warum:D

char* daten_laden()                                   //achtung wir liefern ein char* (c-String zurück)
    {
    int index = 0;                                    // zaehlindex auf 0 setzen
    client.connect(server, 80);                     // connect to server
    Serial.print(F("Verbinde ... "));    
    delay(1000);

    if (client.connected()) {
    Serial.println(F("ok"));
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.print(host);
    client.println();
    client.println();
    delay(30);
  } else {
    Serial.println(F("Keine Verbindung..."));
    client.flush();
    client.stop();
    client.connect(server, 80);                    // connect to server
    Serial.print(F("Neu Verbinden ... "));    
    delay(1000);
  }

  //Lese solange Bytes aus der Verbindung und wirf sie weg bis ein $ gefunden wird.
  while (client.available() && client.read() != '

Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz.
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :smiley:

client.read() != '

client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet

Antwort :
0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen   
  }

buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}




An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Der Sketch funktioniert bei dir?

Also bei mir nicht. Ich sag auch warum:D

§_DISCOURSE_HOISTED_CODE_1_§

Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz.
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :smiley:

§_DISCOURSE_HOISTED_CODE_2_§

client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet

Antwort :
0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen   
  }

buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}


Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz. 
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :D

§DISCOURSE_HOISTED_CODE_2§


client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet 

> Antwort : 
> 0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

  Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen    
  }

  buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}
> ```
> 
> 
> 
> An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Der Sketch funktioniert bei dir?

Also bei mir nicht. Ich sag auch warum:D

§DISCOURSE_HOISTED_CODE_1§


Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz. 
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :D

§DISCOURSE_HOISTED_CODE_2§


client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet 

> Antwort : 
> 0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet

Antwort :
0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen   
  }

buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}




An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Der Sketch funktioniert bei dir?

Also bei mir nicht. Ich sag auch warum:D

§_DISCOURSE_HOISTED_CODE_1_§

Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz.
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :smiley:

§_DISCOURSE_HOISTED_CODE_2_§

client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet

Antwort :
0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen   
  }

buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}


Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz. 
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :D

§DISCOURSE_HOISTED_CODE_2§


client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet 

> Antwort : 
> 0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

);

  Serial.println(F("$ found"));                        // in der read.php ein $ vor den auszugebenden Wert setzen
  while (client.available() && index < 10) {        //einlesen der Nutzdaten. Aufpassen, das wir die Arraygrenze nicht überschreiten
    buffer[index++] = client.read();                // solange zeichen vorhanden sind, das aktuelle zeichen in puffer schreiben und zaehlindex erhoehen    
  }

  buffer[index] = 0;                                // wenn keine zeichen mehr vorhanden, dann puffer am letzten (schon erhoehten) index auf \0 setzen (c-String ende)
  client.stop();
}
> ```
> 
> 
> 
> An dieser stelle nochmal ein ganz großes Danke an mkl0815 !

Der Sketch funktioniert bei dir?

Also bei mir nicht. Ich sag auch warum:D

§DISCOURSE_HOISTED_CODE_1§


Ich frag ab ob Verbunden wurde, fals ja dann den ganzen kram posten.
else
Keine Verbindung und deshalb neu Verbinden (zumindest posten dass neu Verbunden soll)
Nun kommt der Witz. 
Hab den host falsch eingegeben, bzw garnicht geändert und es wird gepostet $ found
Das beste kommt ja aber zum schluss :D

§DISCOURSE_HOISTED_CODE_2§


client.read() fals was anderes als '$');
dann posten $ found

Nun kommt aber der traurige Teil, nachdem ich den host richtig eingegeben hab, wird mir immer noch gepostet 

> Antwort : 
> 0

Dies steht in der Datenbank:
2014-01-18 22:06:32.000000 //datum
12.00 //temp1
13.00 //temp2

Hallo skorpi08,
also bei mir läuft das ganze seit einem Jahr.
Auch nach mehreren Stromausfällen. Löppt ohne Probleme.

Hier meine ganzer Sketch, der auf einem Arduino Ethernet läuft.

reed_14_SQL_LCD_request_MAIL.ino

Dass mit der mail funktion ist ja mal ne gute idee, mal gleich implementieren :slight_smile:

Teste mal obs nun läuft
PS: Deine website ist auch schick :smiley: