Pages: [1]   Go Down
Author Topic: Interval Wartezeit ohne Delay  (Read 562 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 2
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo Liebe Freunde,

mal kurz etwas zu meinem Projekt.
In dem Projekt werden 5 Stück Ds18B20 Temperatursensoren ausgelesen und die Messwerte über Internet in einer Datenbank gespeichert, das ganze passiert im Moment alle 30 min. und funktioniert auch wunderbar.
Im gleichen zuge werden die aktuellen Messwerte auch noch auf einem LCD Display angezeigt. Die Anzeige aktualiesiert sich aber auch nur alle 30 min. weil der Loop im Sketch durch das Delay(Interval) angehalten wird und somit auch die Messung der Sensoren nicht permanent durchgeführt wird.
Ich möchte gerne erreichen das die LCD anzeige immer den aktuellen Wert anzeigt aber nur alle 30 min. der Upload der Messwerte erfolgt.
Hat jemand eine Idee das der Loop immer durchläuft aber die Messwerte nur alle 30 min. zur Datenbank gesendet werden?
Ich habe schon etwas über die "MILLIS" Funktion gelesen , weiß aber nicht wie ich die in den Sketch einbauen kann.   

Code:

#include <SPI.h>
#include <Ethernet.h>             // library for ethernet functions
#include <DallasTemperature.h>    // library for temperature sensors
#include <OneWire.h>              // library for the onewire bus
#include <LiquidCrystal.h>


LiquidCrystal lcd(9, 8, 6, 5, 3, 2);
OneWire  ds(7);                         // pin für Temperatursensoren
 
//DeviceAdressen der einzelnen ds1820 Temperatursensoren.
DeviceAddress sensor1 = { 0x28, 0x90, 0x14, 0x81, 0x4, 0x0, 0x0, 0x4 };
DeviceAddress sensor2 = { 0x28, 0x5C, 0x11, 0x81, 0x4, 0x0, 0x0, 0x34 };
DeviceAddress sensor3 = { 0x28, 0x75, 0xB7, 0x80, 0x4, 0x0, 0x0, 0x34 };
DeviceAddress sensor4 = { 0x28, 0x33, 0x76, 0x62, 0x4, 0x0, 0x0, 0x52 };
DeviceAddress sensor5 = { 0x28, 0x17, 0x8F, 0x81, 0x4, 0x0, 0x0, 0xAC };
 
//ETHERNET-SETTINGS
byte mac[]     = { 0x5D, 0xA2, 0xFA, 0x2D, 0x76, 0x7C };    // MAC-Adresse des Arduino
byte ip[]      = { 192, 168, 137, 2 };                     // IP-Adresse des Arduino
byte gateway[] = { 192, 168, 1, 1 };                    // Gateway
byte subnet[]  = { 255, 255, 255, 0 };                    // SubNet
byte server[]  = { 213, 202, 225, 31 };                     // IP-Adresse des Servers
 
EthernetClient client;
char host[]    = "+++++++++++++++";                      // Domain
char url[]     = "/SaveTempToMySQL.php"; // Pfad zur PHP-Datei
char key[]     = "++++++++++++++";                     // Kennwort aus PHP-Datei
char c;                                                     // Variable für Rückgabe des Servers
 
long Interval  = 30;                                        // Upload-Interval in Minuten
DallasTemperature sensors(&ds);                               
int numSensors;                                             // Variable zum speichern der Anzahl der Temperatur-Sensoren
 
void setup()
{
  delay(1000);
  lcd.begin(20,4); // columns, rows. use 16,2 for a 16x2 LCD, etc.
  lcd.setCursor(0,0);
  lcd.print("Heizungsueberwachung");
  lcd.setCursor(3,1);
  lcd.print("ueber Internet");
  lcd.setCursor(6,2);
  lcd.print("ver.1.01");
  lcd.setCursor(3,3);
  lcd.print("++++++++++++");
  delay(8000);
  lcd.clear(); // start with a blank screen
  Serial.begin(9600);
  Serial.flush();
  delay(200);
 
  Serial.println("Arduino TemperaturLogger");
  lcd.setCursor(2,1);
  lcd.print("TemperaturLogger");
  lcd.setCursor(3,2);
  lcd.print("wird gestartet");
  lcd.setCursor(3,3);
  lcd.print("bitte warten..");
  delay(6000);
  lcd.clear(); // start with a blank screen
  Serial.println("Ethernet initialisieren...");
  lcd.setCursor(6,1);
  lcd.print("Ethernet");
  lcd.setCursor(2,2);
  lcd.print("initialisieren..");
  delay(3000);
  lcd.clear(); // start with a blank screen
  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...");
  lcd.setCursor(1,1);
  lcd.print("Temperatur-Sensoren");
  lcd.setCursor(3,2);
  lcd.print("ermitteln...");
  delay(3000);
  lcd.clear(); // start with a blank screen
  numSensors = sensors.getDeviceCount();                      // Anzahl der angeschlossenen Sensoren in numSensors speichern
 
  if(numSensors > 0)                                          // Es wurde mindestens 1 Sensor gefunden                                       
  {
    Serial.print(numSensors);
    Serial.println( " Temperatur-Sensoren gefunden.");
   lcd.setCursor(10,0);
   lcd.print(numSensors);
   lcd.setCursor(1,1);
    lcd.print("Temperatur-Sensoren");
    lcd.setCursor(4,2);
    lcd.print("gefunden.");
  delay(3000);
  lcd.clear(); // start with a blank screen
  }         
  else                                                        // Es wurde kein Sensor gefunden
  {
    Serial.println("Keine Temperatur-Sensoren gefunden.");
  }
}

void loop()

  float temp1 = getTemperature(sensor1);                      // Temperatur von Sensor 1 ermitteln
  float temp2 = getTemperature(sensor2);                      // Temperatur von Sensor 2 ermitteln
  float temp3 = getTemperature(sensor3);
  float temp4 = getTemperature(sensor4);
  float temp5 = getTemperature(sensor5);
 
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("DA: ");
  lcd.print(temp1);
  lcd.setCursor(0,1);
  lcd.print("PO: ");
  lcd.print(temp2);
  lcd.setCursor(0,2);
  lcd.print("PM: ");
  lcd.print(temp3);
  lcd.setCursor(0,3);
  lcd.print("PU: ");
  lcd.print(temp4);
  lcd.setCursor(10,0);
  lcd.print("KE: ");
  lcd.print(temp5);
  lcd.setCursor(10,1);
  lcd.print("HV: ");
  lcd.print("N.a");
  lcd.setCursor(10,2);
  lcd.print("HR: ");
  lcd.print("N.a");
  lcd.setCursor(10,3);
  lcd.print("AT: ");
  lcd.print("N.a");
 
 
 
  Serial.print("Temp1: ");
  Serial.println(temp1);
  Serial.print("Temp2: ");
  Serial.println(temp2);
  Serial.print("Temp3: ");
  Serial.println(temp3);
  Serial.print("Temp4: ");
  Serial.println(temp4);
  Serial.print("Temp5: ");
  Serial.println(temp5);
 
  Daten_senden(temp1, temp2, temp3, temp4, temp5);                                 // 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);
}
 
/******************************
                              *
  Daten an Server schickenn   *
                              *
*******************************/
void Daten_senden(float T1, float T2, float T3, float T4, float T5)
{
  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("?T1=");
    Serial.print("?T1=");
    client.print(T1);
    Serial.println(T1);
    client.print("&T2=");
    Serial.print("&T2=");
    client.print(T2);
    Serial.println(T2);
    client.print("&T3=");
    Serial.print("&T3=");
    client.print(T3);
    Serial.println(T3);
    client.print("&T4=");
    Serial.print("&T4=");
    client.print(T4);
    Serial.println(T4);
    client.print("&T5=");
    Serial.print("&T5=");
    client.print(T5);
    Serial.println(T5);
    client.print("&key=" + String(key));
    Serial.print("&key=" + String(key));
    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 *****");
  }
}
 
/*************************************
                                     *
  Temperatur der Sensoren auslesen   *
                                     *
*************************************/
void startConversion_DS18B20(byte* address)
{
  ds.reset();
  ds.select(address);
  ds.write(0x44,0);
  delay(1000);
}
 
void readTemperature_DS18B20(byte* address, byte* data)
{
  ds.reset();
  ds.select(address);
  ds.write(0xBE);
  for (byte i=0;i<9;i++)
  {
    data[i] = ds.read();
  }
}
 
float getTemperature(byte* address)
{
  byte i;
 // int tr;
  byte data[12];
  float Temp;
  startConversion_DS18B20(address);
 
  readTemperature_DS18B20(address,data);

   // Calculate temperature: data[1] High Byte, data[0] Low Byte.
  Temp =  ((data[1] << 8) + data[0] ) * 0.0625;  // 12Bit = 0,0625 C per Bit
  return Temp;
}
Logged

Austria
Offline Offline
Full Member
***
Karma: 2
Posts: 107
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo,
du hast es schon richtig erkannt du brauchst die Funktion millis(). Schau dir einmal das Beispiel "BlinkWithoutDelay" an, dann wirst du verstehen wie du millis() verwenden musst.
http://arduino.cc/en/Tutorial/BlinkWithoutDelay

Grüße,
J3RE
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 2
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Danke für deine Hilfe,
diese Beschreibung habe ich bestimmt schon 30 mal studiert aber ich werde da einfach nicht schlau draus an genau welcher Stelle der Code einzufügen ist. Ich muß dazu sagen das ich auch nicht der geborene Programmierer bin sonder erst Anfänger.
Logged

Germany
Offline Offline
Faraday Member
**
Karma: 56
Posts: 3001
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Dann machs doch umgekehrt:

Lass BlinkWithoutDelay laufen, ergänze es um eine zweite LED:  eine blinkt kurz alle 30 Minuten ( Na gut, 30 sekunden, damit es nicht so langweilig ist) , die andere jede Sekunde.


Dann ersetze die LED Ausgabe durch deine LCD Ansteuerung und das DatenSenden()
Logged

Pages: [1]   Go Up
Jump to: