INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Ausgelesene Daten in eine Datenbank schreiben
19.06.2015, 16:57
Beitrag #9
RE: Ausgelesene Daten in eine Datenbank schreiben
Danke, jetzt funktionierts =)

jetzt gibt es nur die nächste Frage...

Die Daten sollen in eine MySQL Datenbank geschrieben werden, ist das dafür überhaupt richtig?
Müssen wir jetzt nur noch am PHP Code arbeiten, um die Daten auslesen zu können?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
24.06.2015, 22:20
Beitrag #10
RE: Ausgelesene Daten in eine Datenbank schreiben
Code:
#include <math.h>         //loads the more advanced math functions
/********************************************************************************​*******************************************            
  PROJEKT: Temperaturlogger                                                                                                 *
  Beschreibung:  Temperaturwerte von 2 ds1820 Temperatursensoren werden an ein php-Script gesendet,                         *
  dass diese Daten in eine MySQL-Datenbank schreibt,                                                                        *
                                                                                                                            *
                                                                                                                            *
  Folgende Werte müssen angepasst werden                                                                                    *
  --------------------------------------------------------------------------------------------------------------------------*
  Intervall = Zeitraum in welchen Abständen die Temperaturdaten vom Arduino zur Datenbank übertragen werden sollen,         *
  mac[] = MAC-Adresse des Ethernet Shields                                                                                  *
  ip[] = IP-Adresse über die der Arduino erreichbar sein soll.                                                              *
  server[] = IP-Adresse des Servers auf den die Daten übertragen werden sollen. herauszufinden mit ping www.domain.de       *
  host[] = Name der Domain zu der die Verbindung aufgebaut werden soll                                                      *
  url[] = Pfad und Name der Datei die für den Upload der übergebenen Daten zur Datenbank zuständig ist.                     *
  key[] = Kennwort dass mit dem Kennwort in der php-Datei übereinstimmen muss (Sicherheitsaspekt)                           *
********************************************************************************​*********************************************/

#include <SPI.h>
#include <Ethernet.h>             // library for ethernet functions




//ETHERNET-SETTINGS
byte mac[]     = { 0x90, 0xA2, 0xDA, 0x0E, 0x0B, 0x76 };    // MAC-Adresse des Arduino
byte ip[]      = { 192, 168, 0, 2 };                     // IP-Adresse des Arduino
byte gateway[] = { 192, 168, 0, 1 };                    // Gateway
byte subnet[]  = { 255, 255, 255, 0 };                    // SubNet
byte server[]  = { 192, 168, 0, 16 };                     // IP-Adresse des Servers

EthernetClient client;
char host[]    = "192.168.0.16";                      // Domain
char url[]     = "/var/www/info5home.php";           // Pfad zur PHP-Datei

char c;                                                     // Variable für Rückgabe des Servers

long Interval  = 0.1;                                        // Upload-Interval in Minuten


int sensorValue = analogRead(A0);
double temp;

double Thermister(int RawADC)
{  //Function to perform the fancy math of the Steinhart-Hart equation
  double Temp;
  Temp = log(((10240000/RawADC) - 10000));
  Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
  Temp = Temp - 273.15;              // Convert Kelvin to Celsius

return Temp;
}

void setup()
{
  temp=Thermister(sensorValue);
  pinMode(0, INPUT);
  delay(1000);

  Serial.begin(9600);
  Serial.flush();
  delay(200);

  Serial.println("Arduino Temperatur");
  Serial.println("Ethernet initialisieren...");  

  Ethernet.begin(mac, ip);
  Interval = Interval * 1000 * 60;                            // Das in Minuten angegebene Interval in Millisekunden umrechnen
  delay(1000);                                                // warten, bis Ethernet gestartet

  //Sensoren abfragen
  // sensors.begin();
  Serial.println("Temperatur-Sensoren ermitteln...");

  }
void loop()  {
  
  analogRead(A0);  // Auslesen des Analogpins A0
  int val;                //Create an integer variable
  double temp;            //Variable to hold a temperature value
  val=analogRead(0);      //Read the analog port 0 and store the value in val
  temp=Thermister(val);   //Runs the fancy math on the raw analog value
  Serial.println(temp);   //Print the value to the serial port
  Serial.println(val);
  delay(1000);            //Wait one second before we do it again


  Serial.print("temp: ");
  Serial.println(temp);

   Serial.print("val: ");
   Serial.println(val);

   //Daten_senden(temp);                                 // Temperaturdaten an Server übertragen

  delay(700);

  byte maxReads = 10; //Seconds
  while ((maxReads-- > 0) && client.connected())              // Antwort des Servers lesen
  {
    delay(1000);
    while (client.available())
    {
      char response = client.read();
      Serial.print(response);
    }
  }
  client.stop();
  Serial.println("Done.");
  client.flush();

  delay(Interval);
}
void Daten_senden(float temp)
{
  if (client.connect(server, 80)) // Verbindung zum Server aufbauen
  {
    Serial.println("Verbunden, Sende Daten...");
    client.print("GET " + String(url));
    Serial.println("GET " + String(url));
    client.print("?temp=");
    Serial.print("?temp=");
    client.print(temp);
    Serial.println(temp);
    client.println(" HTTP/1.1");
    Serial.println(" HTTP/1.1");
    client.print("Host: " + String(host));
    Serial.print("Host: " + String(host));
    client.println();
    Serial.println();
    client.println("User-Agent: Arduino");
    Serial.println("User-Agent: Arduino");
    client.println("Connection: close");
    Serial.println("Connection: close");
    client.println();
    Serial.println();
  }
  else
  {
    Serial.println(" ***** VERBINDUNG KANN NICHT HERGESTELLT WERDEN *****");
  }}

Dieser Sketch wird nun so als fehlerfrei angesehen...

Nun ist die Frage, wie ich die Daten, in eine Datenbank gespeichert bekomme..

Weiß jemand, wie ich nun vorgehen muss?

Vielen Dank...
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
28.06.2015, 16:13
Beitrag #11
RE: Ausgelesene Daten in eine Datenbank schreiben
Ich habe jetzt einen neuen Ansatz gewagt und die Hilfe einer Seite
names GroveStreams genommen.

Jetzt gibt es nur ein Problem, die Seite hat einen vorgefertigten Sketch, jedoch mit einem anderen Sensor und ich glaube anderen Widerständen.

Code:
/*

Arduino GroveStreams Stream Feed via Ethernet

The GroveStreams client sketch is designed for the Arduino and Ethernet.
A full "how to" guide for this sketh can be found at https://www.grovestreams.com/developers/getting_started_arduino_temp.html
This sketch updates several stream feeds with an analog input reading,
from a temperature probe, via the GroveStreams API: https://www.grovestreams.com/developers/api.html
The Arduino uses DHCP and DNS for a simpler network setup.
The sketch also includes Internet Connection Reset logic to ensure the
Arduino stays connected and can regain connectivity after a network outage.
Use the Serial Monitor on the Arduino IDE to see verbose network feedback
and the GroveStreams connectivity status.

License:
  Copyright 2014 GroveStreams LLC.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

GroveStreams Setup:

* Sign Up for Free User Account - https://www.grovestreams.com
* Create a GroveStreams organization while selecting the Arduino blueprint
* Enter a unique MAC Address for this network in this sketch under "Local Network Settings"
*    (Newer shields have the mac address on a sticker on the shield. Use that.)
*    (A MAC address can also be generated within a GroveStreams organization: Tools toolbar button - Generate MAC Address)
*    (The MAC address is used to identify this device within GroveStreams. It must be unique within your GS organization)
* Enter your GroveStreams secret api key under "GroveStreams Settings" in this sketch  
*    (The api key can be retrieved from within a GroveStreams organization: click the Api Keys toolbar button,
*     select your Api Key, and click View Secret Key. Paste the Secret Key below)

Arduino Requirements:

* Arduino with Ethernet Shield or Arduino Ethernet
* Arduino 1.0 IDE

Network Requirements:

* Ethernet port on Router    
* DHCP enabled on Router
* Unique MAC Address for Arduino

Additional Credits:
Example sketches from Arduino team, Ethernet by David A. Mellis
Sketch review and advice from Arduino enthusiast and expert David Thompson, http://www.desert-home.com/
*/

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



// Local Network Settings
byte mac[] = {
  0x90, 0xA2, 0xDA, 0x0E, 0x0B, 0x76 };  // Change this!!! Must be unique on local network.
                                         // Look for a sticker on the back of your Ethernet shield.

// GroveStreams Settings
char gsApiKey[] = "fd4822da-b552-3db9-bf94-5e64e2a5d5b5";   //Change This!!!
char gsComponentName[] = "Temperature";        //Optionally change. Set this to give your component a name when it initially registers.

char gsDomain[] = "grovestreams.com";   //Don't change. The GroveStreams domain.
char gsComponentTemplateId[] = "temp";  //Don't change. Tells GS what template to use when the feed initially arrives and a new component needs to be created.
                                        // The blueprint is expecting "temp".

//GroveStreams Stream IDs. Stream IDs tell GroveStreams which component streams the values will be assigned to.
//Don't change these unless you edit your GroveStreams component definition and change the stream IDs to match these.
char gsStreamId1[] = "s1";   //Don't change. Temp C.
char gsStreamId2[] = "s2";   //Don't change. Temp F.

// Other Settings
const unsigned long updateFrequency = 10000UL;    // Update frequency in milliseconds (20000 = 20 seconds). Change this to change your sample frequency.

const int temperaturePin = 0;          // You might need to change depending on the Pin you are using. The Temperature pin number.    
char samples[35];                      // Change this buffer size only if you increase or decrease the size of samples being uploaded.

char myIPAddress[20];  //Don't Change. Set below from DHCP. Needed by GroveStreams to verify that a device is not uploading more than once every 10s.
char myMac[20];        //Don't Change. Set below from the above mac variable. The readable Mac is used by GS to determine which component the
                       // feeds are uploading into. It must match an existing GroveStreams component's ID

unsigned long lastSuccessfulUploadTime = 0; //Don't change. Used to determine if samples need to be uploaded.
int failedCounter = 0;                      //Don't change. Used for Internet Connection Reset logic

// Initialize Arduino Ethernet Client
EthernetClient client;


void setup()
{
  // Start Serial for debugging on the Serial Monitor
  Serial.begin(9600);

  // Start Ethernet on Arduino
  startEthernet();
}

void loop()
{

  // Update sensor data to GroveStreams
  if(millis() - lastSuccessfulUploadTime > updateFrequency)
  {
    updateGroveStreams();
  }

}

void updateGroveStreams()
{
  //Assemble the url that is used to pass the temperature readings to GroveStreams and call it
  unsigned long connectAttemptTime = millis();

  if (client.connect(gsDomain, 80))
  {        
  
    //You may need to increase the size of urlBuf if any other char array sizes have increased
    char urlBuf[175];

    sprintf(urlBuf, "PUT /api/feed?compTmplId=%s&compId=%s&compName=%s&api_key=%s%s HTTP/1.1",
           gsComponentTemplateId, myMac, gsComponentName, gsApiKey, getSamples());
      
    //Uncomment the next three lines for debugging purposes
    Serial.println(urlBuf);    
    //Serial.print(F("urlBuf length = "));
    //Serial.println(strlen(urlBuf));
    
    client.println(urlBuf);  //Send the url with temp readings in one println(..) to decrease the chance of dropped packets
    client.print(F("Host: "));
    client.println();
    client.println(F("Connection: close"));
    client.print(F("X-Forwarded-For: "));     //Include this line and the next line if you have more than one device uploading behind
    client.println(myIPAddress);              // your outward facing router (avoids the GS 10 second upload rule)
    client.println(F("Content-Type: application/json"));
  
    client.println();


    if (client.connected())
    {
          
      //Begin Report Response
      while(!client.available())
      {
        delay(1);
      }

      while(client.available())
      {
        char c = client.read();
        Serial.print(c);
      }
      //End Report Response
    
      //Client is now disconnected; stop it to cleannup.
      client.stop();
  
      lastSuccessfulUploadTime = connectAttemptTime;
      failedCounter = 0;
    }
    else
    {
      handleConnectionFailure();
    }

  }
  else
  {
     handleConnectionFailure();
  }

}

void handleConnectionFailure() {
  //Connection failed. Increase failed counter
  failedCounter++;

  Serial.print(F("Connection to GroveStreams Failed "));
  Serial.print(failedCounter);  
  Serial.println(F(" times"));
  delay(1000);
    
  // Check if Arduino Ethernet needs to be restarted
  if (failedCounter > 3 )
  {
    //Too many failures. Restart Ethernet.
    startEthernet();
  }

}

void startEthernet()
{
  //Start or restart the Ethernet connection.
  client.stop();

  Serial.println(F("Connecting Arduino to network..."));
  Serial.println();  

  //Wait for the connection to finish stopping
  delay(2000);

  //Connect to the network and obtain an IP address using DHCP
  if (Ethernet.begin(mac) == 0)
  {
    Serial.println(F("DHCP Failed, reset your Arduino and try again"));
    Serial.println();
  }
  else
  {
    Serial.println(F("Arduino connected to network using DHCP"));

    //Set the mac and ip variables so that they can be used during sensor uploads later
    Serial.print(F(" MAC: "));
    Serial.println(getMacReadable());
    Serial.print(F(" IP address: "));
    Serial.println(getIpReadable(Ethernet.localIP()));
    Serial.println();
  }

}

char* getMacReadable()
{
  //Convert the mac address to a readable string
  sprintf(myMac, "%02x:%02x:%02x:%02x:%02x:%02x\0", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

  return myMac;
}

char* getIpReadable(IPAddress ipAddress)
{
  //Convert the ip address to a readable string
  unsigned char octet[4]  = {0,0,0,0};
  for (int i=0; i<4; i++)
  {
    octet[i] = ( ipAddress >> (i*8) ) & 0xFF;
  }
  sprintf(myIPAddress, "%d.%d.%d.%d\0",octet[0],octet[1],octet[2],octet[3]);

  return myIPAddress;
}

char* getSamples()
{
  //Get the temperature analog reading and convert it to a string
  float voltage, degreesC, degreesF;

  voltage = (analogRead(temperaturePin) * 0.004882814);
  degreesC = (voltage - 0.5) * 100.0;
  degreesF = degreesC * (9.0/5.0) + 32.0;

  char tempC[15] = {0}; //Initialize buffer to nulls
  dtostrf(degreesC, 12, 3, tempC); //Convert float to string

  char tempF[15] = {0}; //Initialize buffer to nulls
  dtostrf(degreesF, 12, 3, tempF); //Convert float to string

  //Assemble the samples into URL parameters which are seperated with the "&" character
  //
  // Example: &s1=25.684&s2=78.231
  sprintf(samples, "&%s=%s&%s=%s", gsStreamId1, trim(tempC), gsStreamId2, trim(tempF));

  return samples;
}

char* trim(char* input)                                        
{
  //Trim leading and ending spaces
  int i,j;
  char *output=input;
  for (i = 0, j = 0; i<strlen(input); i++,j++)          
  {
    if (input[i]!=' ')                          
      output[j]=input[i];                    
    else
      j--;                                    
  }
  output[j]=0;

  return output;
}

Das ist der gesamte Code nur die Umrechnung der Temperatur müsste auf unsere Bauteile angepasst werden.

Also soll diese Umrechnung
Code:
#include <math.h>         //loads the more advanced math functions
/********************************************************************************​*******************************************            
  PROJEKT: Temperaturlogger                                                                                                 *
  Beschreibung:  Temperaturwerte von 2 ds1820 Temperatursensoren werden an ein php-Script gesendet,                         *
  dass diese Daten in eine MySQL-Datenbank schreibt,                                                                        *
                                                                                                                            *
                                                                                                                            *
  Folgende Werte müssen angepasst werden                                                                                    *
  --------------------------------------------------------------------------------------------------------------------------*
  Intervall = Zeitraum in welchen Abständen die Temperaturdaten vom Arduino zur Datenbank übertragen werden sollen,         *
  mac[] = MAC-Adresse des Ethernet Shields                                                                                  *
  ip[] = IP-Adresse über die der Arduino erreichbar sein soll.                                                              *
  server[] = IP-Adresse des Servers auf den die Daten übertragen werden sollen. herauszufinden mit ping www.domain.de       *
  host[] = Name der Domain zu der die Verbindung aufgebaut werden soll                                                      *
  url[] = Pfad und Name der Datei die für den Upload der übergebenen Daten zur Datenbank zuständig ist.                     *
  key[] = Kennwort dass mit dem Kennwort in der php-Datei übereinstimmen muss (Sicherheitsaspekt)                           *
********************************************************************************​*********************************************/

#include <SPI.h>
#include <Ethernet.h>             // library for ethernet functions




//ETHERNET-SETTINGS
byte mac[]     = { 0x90, 0xA2, 0xDA, 0x0E, 0x0B, 0x76 };    // MAC-Adresse des Arduino
byte ip[]      = { 192, 168, 0, 2 };                     // IP-Adresse des Arduino
byte gateway[] = { 192, 168, 0, 1 };                    // Gateway
byte subnet[]  = { 255, 255, 255, 0 };                    // SubNet
byte server[]  = { 192, 168, 0, 16 };                     // IP-Adresse des Servers

EthernetClient client;
char host[]    = "192.168.0.16";                      // Domain
char url[]     = "/var/www/info5home.php";           // Pfad zur PHP-Datei

char c;                                                     // Variable für Rückgabe des Servers

long Interval  = 0.1;                                        // Upload-Interval in Minuten


int sensorValue = analogRead(A0);
double temp;

double Thermister(int RawADC)
{  //Function to perform the fancy math of the Steinhart-Hart equation
  double Temp;
  Temp = log(((10240000/RawADC) - 10000));
  Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
  Temp = Temp - 273.15;              // Convert Kelvin to Celsius

return Temp;
}

void setup()
{
  temp=Thermister(sensorValue);
  pinMode(0, INPUT);
  delay(1000);

  Serial.begin(9600);
  Serial.flush();
  delay(200);

  Serial.println("Arduino Temperatur");
  Serial.println("Ethernet initialisieren...");  

  Ethernet.begin(mac, ip);
  Interval = Interval * 1000 * 60;                            // Das in Minuten angegebene Interval in Millisekunden umrechnen
  delay(1000);                                                // warten, bis Ethernet gestartet

  //Sensoren abfragen
  // sensors.begin();
  Serial.println("Temperatur-Sensoren ermitteln...");

  }
void loop()  {
  
  analogRead(A0);  // Auslesen des Analogpins A0
  int val;                //Create an integer variable
  double temp;            //Variable to hold a temperature value
  val=analogRead(0);      //Read the analog port 0 and store the value in val
  temp=Thermister(val);   //Runs the fancy math on the raw analog value
  Serial.println(temp);   //Print the value to the serial port
  Serial.println(val);
  delay(1000);            //Wait one second before we do it again


  Serial.print("temp: ");
  Serial.println(temp);

   Serial.print("val: ");
   Serial.println(val);

   //Daten_senden(temp);                                 // Temperaturdaten an Server übertragen

  delay(700);

  byte maxReads = 10; //Seconds
  while ((maxReads-- > 0) && client.connected())              // Antwort des Servers lesen
  {
    delay(1000);
    while (client.available())
    {
      char response = client.read();
      Serial.print(response);
    }
  }
  client.stop();
  Serial.println("Done.");
  client.flush();

  delay(Interval);
}
void Daten_senden(float temp)
{
  if (client.connect(server, 80)) // Verbindung zum Server aufbauen
  {
    Serial.println("Verbunden, Sende Daten...");
    client.print("GET " + String(url));
    Serial.println("GET " + String(url));
    client.print("?temp=");
    Serial.print("?temp=");
    client.print(temp);
    Serial.println(temp);
    client.println(" HTTP/1.1");
    Serial.println(" HTTP/1.1");
    client.print("Host: " + String(host));
    Serial.print("Host: " + String(host));
    client.println();
    Serial.println();
    client.println("User-Agent: Arduino");
    Serial.println("User-Agent: Arduino");
    client.println("Connection: close");
    Serial.println("Connection: close");
    client.println();
    Serial.println();
  }
  else
  {
    Serial.println(" ***** VERBINDUNG KANN NICHT HERGESTELLT WERDEN *****");
  }}

die Umrechnung des vorherigen Sketches ersetzen...

Ich habe schonmal probiert einfach mit Copy-Paste das zu ändern, leider aber ohne Erfolg..

Also müsste

Code:
float voltage, degreesC, degreesF;

  voltage = (analogRead(temperaturePin) * 0.004882814);
  degreesC = (voltage - 0.5) * 100.0;
  degreesF = degreesC * (9.0/5.0) + 32.0;

  char tempC[15] = {0}; //Initialize buffer to nulls
  dtostrf(degreesC, 12, 3, tempC); //Convert float to string

  char tempF[15] = {0}; //Initialize buffer to nulls
mit dem hier vertauscht werden

Code:
int sensorValue = analogRead(A0);
double temp;

double Thermister(int RawADC)
{  //Function to perform the fancy math of the Steinhart-Hart equation
  double Temp;
  Temp = log(((10240000/RawADC) - 10000));
  Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
  Temp = Temp - 273.15;              // Convert Kelvin to Celsius

return Temp;
}

void setup()
{
  temp=Thermister(sensorValue);
  pinMode(0, INPUT);
  delay(1000);

  Serial.begin(9600);
  Serial.flush();
  delay(200);

  Serial.println("Arduino Temperatur");
  Serial.println("Ethernet initialisieren...");  

  Ethernet.begin(mac, ip);
  Interval = Interval * 1000 * 60;                            // Das in Minuten angegebene Interval in Millisekunden umrechnen
  delay(1000);                                                // warten, bis Ethernet gestartet

  //Sensoren abfragen
  // sensors.begin();
  Serial.println("Temperatur-Sensoren ermitteln...");

  }
void loop()  {
  
  analogRead(A0);  // Auslesen des Analogpins A0
  int val;                //Create an integer variable
  double temp;            //Variable to hold a temperature value
  val=analogRead(0);      //Read the analog port 0 and store the value in val
  temp=Thermister(val);   //Runs the fancy math on the raw analog value
  Serial.println(temp);   //Print the value to the serial port
  Serial.println(val);
  delay(1000);            //Wait one second before we do it again

Kann mir da jemand helfen?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
28.06.2015, 16:44
Beitrag #12
Kleiner Tip !
Hi,

wahrscheinlich werde ich Dir hier nicht weiterhelfen können. Aber ich
kann Dir erzählen, wie ich mich am Anfang "durchgequält" habe.

Von Elektronik hatte ich keine Ahnung (jetzt vielleicht ein kleines bischen mehr).

Ich war es gewohnt beim Programmieren an einigen Stellen gleichzeitg zu arbeiten. Ging auch, denn ich hatte eine komfortable IDE und vom programmieren verstehe ich schon ein bischen mehr.

Versuche nicht zuviel auf einmal. Es sind die kleinen Schritte des Verstehens. Ich wollte am Anfang zuviel und bin nicht vorangekommen. Manchmal helfen schon kleine Code-Schnipsel wie (PseudoCode) :

Funktion SchreibeWertInDatenbank(Parameter1,Parameter2)

Print("Öffne Datenbankverbindung) ;
Print("Jetzt wird der Wert " + Parameter1 + " in die Datenbank geschrieben !")
Print("Schließe Datenbanlverbindung")

Ende Funktion

Dann weißt Du zumindest, daß der Wert an dieser Stelle schon mal richtig ankommt. Bau Dir kleine Hilfen ein. Das Debugging ist schon ein guter Anfang.
Schreib Dir dafür eine Kleine Funktion, die nur das Debugging übernimmt und
steuere über eine Variable das Ein bzw. Abschalten vom Debugging !

Copy and Paste ist eine tolle Sache, aber was ist wenn Du es nicht verstanden hast ? Dann hängst Du wieder beim nächsten Schritt , weil Du den ersten Schritt nicht verstanden hast !

Versioniere die Sketche, wenn Du es nicht schon machst !

Auch solltest Du schon konkretere Fragen stellen, sonst kann man
sich nicht so richtig in das Problem hereinversetzten, daß der andere gerade hat.

Versuch erstmal die Programmlogik zu erstellen bzw. zu strukturieren, sonst machst Du Dir zu viele Baustellen gleichzeitig auf.

Du wirst sehen, auf einmal macht es KLICK und das Licht geht an.

Denke immer dran : Der Weg ist das Ziel ...
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
28.06.2015, 18:00
Beitrag #13
RE: Ausgelesene Daten in eine Datenbank schreiben
Full ACK @ Home38.
Dazu noch: Etwas Beharrungsvermögen (Sturheit) ist manchmal auch nicht schlecht. Wenn man an Probleme stößt, dann ist es besser, diese erst einmal innerhalb des momentanen Konzepts zu lösen und nicht gleich alles umzuwerfen. Das gilt insbesondere dann, wenn man nicht versteht, warum etwas nicht funktioniert.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Daten Visualisieren MeisterQ 12 576 01.12.2016 19:36
Letzter Beitrag: MeisterQ
  Data Logger Daten auf SD Card schreiben Crichton 12 312 22.11.2016 18:32
Letzter Beitrag: Crichton
  I2C Daten übertragen Gandalf 3 217 04.11.2016 13:20
Letzter Beitrag: hotsystems
  Daten über USB verarbeiten Felix91 10 330 12.10.2016 13:00
Letzter Beitrag: Tommy56
  Can-Bus Shield ok, aber keine Daten Clubsport 38 1.544 01.09.2016 14:17
Letzter Beitrag: Clubsport
  Serial Monitor ASCII 1 schreiben BennIY 11 581 01.08.2016 16:42
Letzter Beitrag: Mathias
  Daten an mysql diode1990 24 1.309 31.07.2016 10:29
Letzter Beitrag: Gandalf
  NRF24L01,Empfangene Daten auswerten Marc2014 9 526 30.07.2016 19:34
Letzter Beitrag: rkuehle
  Fehlermeldung das eine reimundko 3 309 08.06.2016 08:56
Letzter Beitrag: hotsystems
  Serielle Schnittstelle - Daten empfangen Datatom 8 779 22.05.2016 18:10
Letzter Beitrag: avoid

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste