next topic »

[Reply #15 on:]

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

Code:

#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 :

Code:

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 
Please Help...

[Reply #16 on:]

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:

Code:

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.

[Reply #17 on:]

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

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

Hier der Sketch:

Code:

#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 ?

Code:

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

Und hier die Ausgabe:

Code:

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... 

[Reply #18 on:]

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

Code:

char* daten_laden() {

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

Code:

    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.

Code:

  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.

Code:

   //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  Und an drei Stellen sogar mit dem F() Macro um Speicher zu sparen. Sehr schön und ausbaufähig.

Code:

  // 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.

Code:

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

Code:

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:

Code:

  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() :

Code:

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.

[Reply #19 on:]

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



Hier der Sketch:

Code:

#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.

Code:

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

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

[Reply #20 on:]

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():

Code:

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() != '$');

  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.

[Reply #21 on:]

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

Code:

$ found

Aber bei "Antwort" kommt nur ein "<"


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

Hier der Sketch :

Code:

#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() != '$');

  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 

Gruß
Stefan

[Reply #22 on:]

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

Code:

 
  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.

[Reply #23 on:]

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

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

Code:

 
  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...
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.

Code:

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:

Code:

#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() != '$');

  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

[Reply #24 on:]

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

Code:

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 :

Code:

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

[Reply #25 on:]

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.

[Reply #26 on:]

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...   <peinlich>

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 !!!  
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 ?

[Reply #27 on:]

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.

Code:

/*
  #####################################################
  #          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() != '$');

  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 !

[Reply #28 on:]

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.

[Reply #29 on:]

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