INFO: Dieses Forum nutzt Cookies...

iselein · 04.01.2014, 19:17

nAbendddddddddddd,

also mal Zeilen angepasst und getestet.
Keine Reaktion. Weder seriell noch im Browser.
Mach ich was falsch?

iselein

Fried22 · 04.01.2014, 23:44

Hallo iselein,

hier mal mein Sketch. Du brauchst nur die xxx mit deinen Werten aktualisieren.
Danach Browser öffnen und xxx.xxx.xxx.xxx eingeben.

/*Atmos und Internet:

Hier werden 10 Sensoren ausgelesen und via LAN als WebServer ausgegeben. Server-Adresse ist
in diesem Fall: xxx.xxx.xxx.xxx - im Browser einzugeben

*/
#include <SPI.h>
#include <Ethernet.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 8
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

// MAC address from Ethernet shield sticker under board
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(xxx, xxx, xxx, xxx); // IP address, may need to change depending on network
EthernetServer server(80); // create a server at port 80

void setup()
{
Ethernet.begin(mac, ip); // initialize Ethernet device
server.begin(); // start to listen for clients
sensors.begin();

}

void loop()
{
sensors.requestTemperatures();
EthernetClient client = server.available(); // try to get client

if (client) { // got client?
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) { // client data available to read
char c = client.read(); // read 1 byte (character) from client
// last line of client request is blank and ends with \n
// respond to client only after last line received
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();
// send web page
client.println("<!DOCTYPE html>");
client.println("<html>");
client.println("<head>");
client.println("<title>Arduino Web Page</title>");
client.println("</head>");
client.println("<body>");
client.println("<h1>Temperaturen vom Atmos mit Arduino Uno!</h1>");

client.println(sensors.getTempCByIndex(0));
client.println("<body>");
client.println(sensors.getTempCByIndex(1));

client.println(sensors.getTempCByIndex(2));
client.println("<body>");
client.println(sensors.getTempCByIndex(3));

client.println(sensors.getTempCByIndex(4));
client.println("<body>");
client.println(sensors.getTempCByIndex(5));

client.println(sensors.getTempCByIndex(6));
client.println("<body>");
client.println(sensors.getTempCByIndex(7));

client.println(sensors.getTempCByIndex(8));
client.println("<body>");
client.println(sensors.getTempCByIndex(9));

client.println("Mein Arduino Uno Server");
client.println("</body>");
client.println("Puffer links oben:");
client.println(sensors.getTempCByIndex(0),1),
client.println("</body>");
client.println(" Celsius");
client.println("Puffer links Mitte:");
client.println(sensors.getTempCByIndex(1),1);
client.println("Puffer links Unten:");
client.println(sensors.getTempCByIndex(2),1);
client.println("Puffer rechts Oben:");
client.println(sensors.getTempCByIndex(3),1);
client.println("Puffer rechts Mitte:");
client.println(sensors.getTempCByIndex(4),1);
client.println("Puffer rechts Unten:");
client.println(sensors.getTempCByIndex(5),1);
client.println("Heizung Vorlauf:");
client.println(sensors.getTempCByIndex(6),1);
client.println("Heizung Ruecklauf:");
client.println(sensors.getTempCByIndex(7),1);
client.println("Aussentemperatur:");
client.println(sensors.getTempCByIndex(8),1);
client.println("Temperatur Abgas:");
client.println(sensors.getTempCByIndex(9),1);
client.println("<body>");
client.println("</html>");
break;
}
// every line of text received from the client ends with \r\n
if (c == '\n') {
// last character on line of received text
// starting new line with next character read
currentLineIsBlank = true;
}
else if (c != '\r') {
// a text character was received from client
currentLineIsBlank = false;
}
} // end if (client.available())
} // end while (client.connected())
delay(1); // give the web browser time to receive the data
client.stop(); // close the connection
} // end if (client)

}

Das ganze sieht nicht schön aus, jedoch wollte ich nur testen, wie meine Angaben ausgegeben werden. Blush

MfG
Michael

iselein · 05.01.2014, 08:42

Guten Morgen zusammen,

der Sketch funktioniert. Hab vielen Dank großer Meister.
Das beste ist mit den Beschriftungen.
Ich habe auch einen Holzkessel im Keller mit 2 Puffer.
Genau so wollte ich es haben. Puffer oben, mitte, usw.
DANKE nochmal.

iselein

**Bitklopfer** · 05.01.2014, 15:22

@iselein,
Danke dir für deinen Beitrag mit den Dallas Fühlern die mich auch interessieren
weil die bei mir auch schon in der Bastelkiste liegen.
Und um das Forum zu bereichern hier ist der Sketch von meinem Datenlogger der aber wohl aufgrund seiner Größe mit 31,7KByte nur auf dem Mega2560 Exclamation

und Ethernet/SD Shield läuft.

Hier mal die integrierten Funktionen Idea

:
Beim Start wird von einem NTP Server die UNIX-Zeit abgefragt und dann aber
nur noch intern weitergezählt - läuft dann auch leicht weg mit der Zeit.
Jede Sekunde werden 3 Temperaturen erfasst ( 2x LM335, 1x PT1000), sowie
der Wert in mV einer Fotozelle.(im Zweifelsfall gilt der Code Smile

)
Die Werte werden auf einem LCD Shield das ich auf die noch freien Pin's
angepasst habe angezeigt bzw. können auf Tastendruck abgefragt werden.
Die aktuellen Messwerte sind über Ethernet abrufbar und werden zudem jede
Sekunde auf die SD-Karte gespeichert. Da die Tabellenkalkulation von Star-Office
(Excel wohl auch) keine Dateien mit mehr als 65.000 Datensätze aus einer Text-Datei
importieren kann wird alle 50.000 Datensätze ein neuer Logfile generiert.
Die Logfiles werden automatisch im Bereich der Nummern 10.000 bis 65.000
generiert was ein langes Loggerleben ermöglicht.
Über die Tasten kann man die verborgenen Messwerte abfragen,
einen neuen Datenfile erzwingen,
die Dateigröße reduzieren,
und die SD-Karte abmelden das keine Datensätze mehr geschrieben werden,
zum wiederanmelden der SD wird das System zurückgesetzt und somit
eine neue NTP Zeit geholt.
Das wärs mal im Groben....bei Fragen...
Aber nun mach ich erst mal an meinem RPi Projekt weiter...
Gruß
bk

manche würden sagen Spaghetticode...aber gerne nehme ich ne Einladung
zu Carbonara Tongue

an....falls es keinen stört das ich die 50 Big Grin

auch schon deutlich
überschritten habe...

Code:

//   Hier gehts los

//  History:

//  V6 Webdatenlogger mit Filegenerierung nach 50000 Datensaetzen

//     die Dateinummer wird in der Datei NUMMER.TXT gespeichert

//     die Datendatei hat beginnt bei WD_10000.TXT um keine Stellenschieberei

//     aufkommen zu lassen

//     

//  V7 kleinere Aenderungen wie Tastenbelegung

//  V8 Versuch SD Karte waehrend des Betriebes neu einzulegen

//

//  V9 SD Neustart geht nicht. wird stillgelegt. 

//     dafuer Versuch die Unix Zeit in lesbares Datum und Zeit zu wandeln

//######

//

//Mega Logger V1   Logger Mega Version

//

//  V2  KTY ersetzt durch LM135, LM335, PT1000, Photozelle uralt

//  

//

//######################################################################

//  initialize the library with the numbers of the interface pins

// LiquidCrystal lcd(8, 9, 3, 5, 6, 7);

// fuer Ethernet und SD Card

// Circuit:

// MOSI: pin 11

// MISO: pin 12

// SCK: pin 13

// 

#include <SPI.h>

#include <Ethernet.h>

#include <SD.h>

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

 LiquidCrystal lcd(8, 9, 3, 5, 6, 7);

//  Cipselect Pin's   LOW aktiv

const int SDselect = 4;    // CSelect fuer SD Card  LOW aktiv  neu definiert

const int ETHselect = 10;   // CSelect fuer Ethernet LOW aktiv neu definiert

// set up variables using the SD utility library functions:

Sd2Card card;

SdVolume volume;

SdFile root;

File dataFile; 

char numFile[14] = "NUMMER.TXT";   // Filenummerverwaltung

char WDLfile[16] = "             ";   // kreierter Filename fuer Datenloggerdaten

char numbuffer[10]; // R/W Buffer für Filenamen

unsigned int i = 0;     // der uebliche Verdaechtige

unsigned int dtNummer = 10000;   // fortlaufende Filenummer in NUMMER.TXT gespeichert 

// assign a MAC address for the ethernet controller.

byte mac[] = {0x11, 0xA2, 0xDA, 0x11, 0x11, 0x11};  // MAC Adresse wo auf dem Board steht

// assign an IP address for the controller:

unsigned int localPort = 8888;      // local port to listen for UDP packets NTP Code

IPAddress ip(192,168,15,250);

IPAddress gateway(192,168,15,1);    

IPAddress subnet(255, 255, 255, 0);

IPAddress timeServer(132, 163, 4, 101); // time-a.timefreq.bldrdoc.gov NTP server

// IPAddress timeServer(132, 163, 4, 102); // time-b.timefreq.bldrdoc.gov NTP server

// IPAddress timeServer(132, 163, 4, 103); // time-c.timefreq.bldrdoc.gov NTP server

// IPAddress timeServer(1.pool.ntp.org); // GEHT NICHT time-c.timefreq.bldrdoc.gov NTP server

const int NTP_PACKET_SIZE= 48; // NTP time stamp is in the first 48 bytes of the message

//byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets ORIGINAL

byte packetBuffer[50]; //buffer to hold incoming and outgoing packets geaendert !!!

// int Tzone = 7200; // Korrekturwert fuer MESZ 

// A UDP instance to let us send and receive packets over UDP

EthernetUDP Udp;

// Initialize the Ethernet server library

// with the IP address and port you want to use 

// (port 80 is default for HTTP):

EthernetServer server(80);

// Variablen Messwerte / Eingaben

float VCC = 4990.0;    // Rechenwert fuer Full Scale

unsigned int Twert;  // Tastaturwert

float adcbuff;         // ADC Einlesebuffer

float KTY1;

float KTY2;

float KTY3;

float PHOTO;

// Konstanten zur Temperaturberechnung

const float temp0 = 500; // KTY angenommener Nullpunkt in 

//const float temp0 = 0; // KTY angenommener Nullpunkt in 

// Alle Ausgabestrings

//char ktlin[12];  // KTY Wert als String

char sdausgstr[60] = "";  // ausgabestring fuer SD File   waren mal 80

char lcdausg1[18]; // stringbuffer

char lcdausg2[18]; // stringbuffer

char kty1str[5];   // KTY Wert als String

char kty2str[5];   // KTY Wert als String

char kty3str[5];   // KTY Wert als String

char photostr[5];   // PHOTO Wert als String

char tstr[5];       // Twert Tastenwert als String

char sdwrcountstr[7];  // Recordcounter als String

//##########Variablen Allgmein / meine Spielereien

unsigned long int lastReadingTime = 0;  // Intervall fuer Datenerfassung  ##

//unsigned long int lz = 0;   // Schleifenzaehler zum ausgeben

unsigned long int nextsek = 0; // naechste Sekunde wo was passiert

unsigned long int sekunden = 0; // Sekunden fuer Zeitmarke

unsigned int messintervall = 10; // Intervall fuer SD Erfassung  ## war mal long

unsigned int buffer = 0;

unsigned char SDpresent;   // 1 = SD Card vorhanden , 0 = SD Card fehlt

char sdon = 219;

char sdoff = 253;   // anstatt 173

char sdwrite = 165;

unsigned char sdtoggle = 0; // Zeichenwechsel beim SD Schreiben

unsigned int sdwrcount = 0; // Anzahl der Datensaetz wo in der Datei sind

unsigned int sdmaxcount = 50000; // Maximale Datensätze pro File

// Variablen fuer NTP und Global

unsigned long int secsSince1900;

unsigned long int Unixtime;

unsigned long int epoch;

//###########  SETUP ############

void setup(){

  Serial.begin(9600);

  lcd.begin(16,2);

  //### Port pinModes einstellen

  pinMode(SDselect, OUTPUT);

  pinMode(ETHselect, OUTPUT);

  pinMode(2, OUTPUT);    // Ausgang fuer Backlight

  digitalWrite(2,1);  // Backlight schalten  0 = AUS, 1 0 EIN

  // start the SPI library:

  selETH();   // Select  Ethernet - intialisiert auch den SD-CS

  SPI.begin();

  // start the Ethernet connection and the server:

  Ethernet.begin(mac, ip);

  server.begin();

  Udp.begin(localPort);    // NTP Code

  selSD();     //  ging komischerweise auch ohne diesen CS Aufruf.....########

  startSD();

  if(SDpresent == 1)newFilename();   // Filenamen holen bei Programmstart

   // Analog In Configuration

   analogReference(DEFAULT);

  //  ADCSRA = 0x87; // ADC Prescaler auf 128 setzen und ADC einschalten...

  // give the sensor and Ethernet shield time to set up:

  lcd.clear();  // LCD loeschen

  delay(200);

  //########  NTP Abfrage neu #######  

  CallNTP();

  Unixtime = epoch;

  //### lokaler Sekundenzaehler auf Unixzeit stellen

  sekunden = Unixtime;

  //### nextsek auf 0 am Ende einstellen

  nextsek = Unixtime / 10;  // letzte Stelle auf 0 setzen

  nextsek = nextsek * 10;  // letzte Stelle auf 0 setzen

  nextsek = nextsek + 10;  // SD Start nach +20 Sekunden 

}

// ######################### MAIN LOOP ########################################

void loop() { 

  //  Messzyklus alle Sekunde

  if (millis() - lastReadingTime > 1000){

    lastReadingTime = millis();  // Zeitstempel updaten

    sekunden ++;  // Sekundenzaehler inkrement

  // #### Messwerte erfassen und in Strings wandeln

    getData();   // Messwerte  erfassen, alle 1000mSec

  //  Messwerte gleich in String wandeln

    LM335lin(KTY1, kty1str);

    LM335lin(KTY2, kty2str);

    PT1000lin(KTY3, kty3str);

    buffer = PHOTO; //  Nachkomma abschneiden

    sprintf(photostr,"%4d", buffer);

    sprintf(tstr,"%4d", Twert);

    sprintf(sdwrcountstr,"%5u",sdwrcount);

  // LCD Ausgabe im Sekundentakt  

  sprintf(lcdausg1,"%14lu",sekunden);  // stringwandlung

  lcd.setCursor(0, 0);

  lcd.print(lcdausg1);

  lcd.setCursor(0, 1);

  String lcdausg2 = "";

  lcdausg2 += "K1 ";

  lcdausg2 += kty1str;

  lcdausg2 += "  K3 ";

  lcdausg2 += kty3str; 

  lcd.print(lcdausg2);

//#####################  Tastaturabfragen   

  if(Twert <= 1000){

      lcd.setCursor(0, 0);

      lcd.print("Tw ");

      lcd.print(tstr);

      lcd.print(" ");

      lcd.print(sdmaxcount);

      lcd.print(" ");

      if(Twert >= 750){       // SD Card ein / ausschalten

                      if(SDpresent == 1){

                      SDpresent = 0;

                        lcd.setCursor(0,0 );

                        lcd.print("Datenerfassung  ");

                        lcd.setCursor(0,1 );

                        lcd.print("abgeschaltet    ");

                        delay(5000);

                        }

                        else {

                        lcd.setCursor(0,0 );

                        lcd.print("SYSTEM RESET    ");

                        lcd.setCursor(0,1 );

                        lcd.print("wird vorbereitet");

                        delay(5000);

                        asm("JMP 0");  // Und Sprung nach RESET

                              }

                      }

   if(Twert <= 412 & Twert >= 400){   // neuer Photo

      lcd.setCursor(0,1 );

      lcd.print("Ph ");

      lcd.print(photostr);

              }

    if(Twert <= 260 & Twert >= 250){   // neue Filenamenanzeige

      lcd.setCursor(0,1 );

      lcd.print("  ");

      lcd.print(WDLfile);

      lcd.print("  ");

              }

    if(Twert <= 646 & Twert >= 633){   // Filegröße reduzieren

      sdmaxcount = 360 * 4;     //   360 Messungen pro Stunde * 4 Std.

                                   }

    //  erzeuge neuen Dateinamen

    if(Twert <= 10){                // neuer Wert fuer neue Datei

      newFilename();

      lcd.setCursor(0,1 );

      lcd.print("  ");

      lcd.print(WDLfile);

      lcd.print("  ");

                   }

    // Anzeige des Recordcounters

    if(Twert <= 105 & Twert >= 92){   // Anzeige Recordcounter

      lcd.setCursor(0,1 );

      lcd.print("  ");

      lcd.print(sdwrcountstr);

      lcd.print("  ");

              }

      }  // Ende Abfrage ob Taste gedrueckt

  }  // Ende im sekundentakt 

//######## Laufvariable / alive count

 if (sekunden >= nextsek){           // Wenn lz Intervall erreicht dann ausgeben     

nextsek = nextsek + messintervall;  // die Schrittweite berechnen fuer naechste Aktion

//##### Ausgabestring fuer Serial und SD zusammensetzen

  String sdausgstr = "";

  sdausgstr = sdausgstr + lcdausg1 + "," + kty1str + "," + kty2str + "," + kty3str + "," + photostr + "," + tstr;

//###############  auf SD schreiben  #####################

//  Serial.println(sdausgstr);   

 if(SDpresent ==1){  

   if(sdtoggle == 0){

   lcd.setCursor(15, 0);

   lcd.print(sdon);

   sdtoggle = 1;}

     else {

   lcd.setCursor(15, 0);

   lcd.print(sdwrite);

   sdtoggle = 0;

     }       

 // ######  Der Datenfile "WD_10001.TXT"

 // Serial.println(WDLfile);

  selSD();            // CS auf SD Card setzen

  dataFile = SD.open(WDLfile, FILE_WRITE);

  // if the file is available, write to it:

  if (dataFile) {

    dataFile.println(sdausgstr);

    dataFile.flush();

    dataFile.close();

    sdwrcount ++;

    if(sdwrcount >= sdmaxcount) {     //#########  hier die Maximale Recordgroesse angeben

      newFilename();

      CallNTP();

      Unixtime = epoch;

                       }

                }            

 }

 else {

   lcd.setCursor(15, 0);

   lcd.print(sdoff);

 }

 }

  // warten auf Ethernetanfragen 

  selETH();

  listenForEthernetClients();

}

//############################# ENDE HP #########################################

//############################# ENDE HP #########################################

//############################# ENDE HP #########################################

//############## getdata #############################

void getData() {

  //Serial.println("Daten erfassen");

  // ADC 's einlesen 

  KTY1 = analogRead(1);  // Temp einlesen

  KTY2 = analogRead(2);  // Temp einlesen

  KTY3 = analogRead(3);  // Temp einlesen

  adcbuff = analogRead(4);  // Temp einlesen

  PHOTO = ((adcbuff * VCC) / 1023);

  Twert = analogRead(0);  // Temp einlesen

}

//############################### Ethernet ########################

void listenForEthernetClients() {

  selETH();

  // listen for incoming clients

  EthernetClient client = server.available();

  if (client) {

    // Serial.println("Got a client");

    // an http request ends with a blank line

    boolean currentLineIsBlank = true;

    while (client.connected()) {

      if (client.available()) {

        char c = client.read();

        // if you've gotten to the end of the line (received a newline

        // character) and the line is blank, the http request has ended,

        // so you can send a reply

        if (c == '\n' && currentLineIsBlank) {

          // send a standard http response header

          client.println("HTTP/1.1 200 OK");

          client.println("Content-Type: text/html");

          client.println();

          // ############################  WEB AUSGABE   -  print the current readings, in HTML format:

          client.print("ARDUINO-Ethernet Web Testlauf 2013");

          client.println("<br />");

          client.print("Unix Zeit, Sekunden seit dem 1.1.1970: " + String(sekunden));

          client.println("<br />");

//          client.print("Unix Zeit: " + String(Unixtime));

//          client.println("<br />");

          client.println("<br />");

          client.print("Temperatur K1 Sofa   ");

          client.print(kty1str);

          client.println("<br />"); 

          client.print("Temperatur K2   ");

          client.print(kty2str);

          client.println("<br />"); 

          //client.print("Temperatur PT1000  ");

          //client.print(kty3str);

          //client.println("<br />"); 

          client.print("Photo   ");

          client.print(photostr);

          client.println("<br />"); 

          client.print("Datenfile    ");

          client.print(WDLfile);

          client.println("<br />"); 

          client.print("geschriebene Datensaetze    ");

          client.print(sdwrcount);

          client.println("<br />"); 

          break;

        }

        if (c == '\n') {

          // you're starting a new line

          currentLineIsBlank = true;

        } 

        else if (c != '\r') {

          // you've gotten a character on the current line

          currentLineIsBlank = false;

        }

      }

    }

    // give the web browser time to receive the data

    delay(10);   // mal mit 10 anstatt 1 testen

    // close the connection:

    client.stop();

  }

} 

//Send a write command to SCP1000

void writeRegister(byte registerName, byte registerValue) {

  selETH();

  // SCP1000 expects the register name in the upper 6 bits

  // of the byte:

  registerName <<= 2;

  // command (read or write) goes in the lower two bits:

  registerName |= 0b00000010; //Write command

  // take the chip select low to select the device:

  digitalWrite(ETHselect, LOW); 

  SPI.transfer(registerName); //Send register location

  SPI.transfer(registerValue); //Send value to record into register

  // take the chip select high to de-select:

  digitalWrite(ETHselect, HIGH); 

}

//Read register from the SCP1000:

unsigned int readRegister(byte registerName, int numBytes) {

  byte inByte = 0;           // incoming from  the SPI read

  unsigned int result = 0;   // result to return 

  // SCP1000 expects the register name in the upper 6 bits

  // of the byte:

  registerName <<=  2;

  // command (read or write) goes in the lower two bits:

  registerName &= 0b11111100; //Read command

  // take the chip select low to select the device:

  digitalWrite(ETHselect, LOW); 

  // send the device the register you want to read:

  int command = SPI.transfer(registerName); 

  // send a value of 0 to read the first byte returned:

  inByte = SPI.transfer(0x00); 

  result = inByte;

  // if there's more than one byte returned, 

  // shift the first byte then get the second byte:

  if (numBytes > 1){

    result = inByte << 8;

    inByte = SPI.transfer(0x00); 

    result = result |inByte;

  }

  // take the chip select high to de-select:

  digitalWrite(ETHselect, HIGH); 

  // return the result:

  return(result);

}

//######## meine eigene neue Routinen ###########################################

//################# Chip-Select ansteuern ###################################

void selETH() {     // waehlt den Ethernetcontroller aus

digitalWrite(SDselect, HIGH);

digitalWrite(ETHselect, LOW);

}

//####################################

void selSD() {      // waehlt die SD-Karte aus

digitalWrite(ETHselect, HIGH);

digitalWrite(SDselect, LOW);

}

//#################################

void selCLK() {      // waehlt die RTC aus bzw. sperrt Ethernet und SD-Karte

digitalWrite(SDselect, HIGH);

digitalWrite(ETHselect, HIGH);

}

//################### improvisierte KTY Umrechnung ##########

void ktylin(float wert,char retstring[]){     // KTY Linearisieren und als String wandeln

  wert = ((wert * VCC) / 1023); // Umrechnung in Spannung

  wert = wert - 2355;   //  Null Grad Spannung abziehen

  wert = (wert / 10) * 1.3;     // Differenz ist in Grad

  int whigh = wert;

  int wlow = (wert - whigh) * 10;  // wir wollen nur eine Nachkommastelle

  sprintf(retstring,"%2d.%1d", whigh, wlow);

}

//################### LM335 Umrechnung ##########

void LM335lin(float wert,char retstring[]){     // KTY Linearisieren und als String wandeln

//  Serial.println(wert);

 // wert = ((wert * 5000) / 1023); // Umrechnung in Spannung

  wert = wert * (VCC / 1023.0); // Umrechnung in Spannung

  //Serial.println(wert);

  wert = wert - (2730+30);   //  Null Grad Spannung abziehen

  wert = wert / 10;     // Differenz ist in Grad

  //Serial.println(wert);

  int whigh = wert;

  int wlow = (wert - whigh) * 10;  // wir wollen nur eine Nachkommastelle

  sprintf(retstring,"%2d.%1d", whigh, wlow);

}

//################### PT1000 Umrechnung ##########

void PT1000lin(float wert,char retstring[]){     // KTY Linearisieren und als String wandeln

 // Serial.println(wert);

 // wert = ((wert * 5000) / 1023); // Umrechnung in Spannung

  wert = wert * (VCC / 1023.0); // Umrechnung in Spannung

  float wert2 = VCC - wert;

  //Serial.println(wert2);

  float ptr = wert / (wert2 / 1000.0);

  ptr = ptr - 1000.0; // Null grad abziehen

  //Serial.println(ptr);

 // wert = ptr / 3.85;  // 3,85 Ohm pro Grad 

  wert = ptr / 3.87316;

  //Serial.println(wert);

 //wert = wert - (2500);   //  Null Grad Spannung abziehen

  //wert = wert / 10;     // Differenz ist in Grad

  //Serial.println(wert);

  int whigh = wert;

  int wlow = (wert - whigh) * 10;  // wir wollen nur eine Nachkommastelle

  sprintf(retstring,"%2d.%1d", whigh, wlow);

}

// send an NTP request to the time server at the given address 

unsigned long sendNTPpacket(IPAddress& address)

{

  selETH();

  // set all bytes in the buffer to 0

  memset(packetBuffer, 0, NTP_PACKET_SIZE); 

  // Initialize values needed to form NTP request

  // (see URL above for details on the packets)

  packetBuffer[0] = 0b11100011;   // LI, Version, Mode

  packetBuffer[1] = 0;     // Stratum, or type of clock

  packetBuffer[2] = 6;     // Polling Interval

  packetBuffer[3] = 0xEC;  // Peer Clock Precision

  // 8 bytes of zero for Root Delay & Root Dispersion

  packetBuffer[12]  = 49; 

  packetBuffer[13]  = 0x4E;

  packetBuffer[14]  = 49;

  packetBuffer[15]  = 52;

  // all NTP fields have been given values, now

  // you can send a packet requesting a timestamp:            

  Udp.beginPacket(address, 123); //NTP requests are to port 123

  Udp.write(packetBuffer,NTP_PACKET_SIZE);

  Udp.endPacket(); 

}

//############### CallNTP ###########################

unsigned long int CallNTP()

{

selETH();   //  Ethernet selektieren

  sendNTPpacket(timeServer); // send an NTP packet to a time server

    // wait to see if a reply is available

  delay(1000);  

  if ( Udp.parsePacket() ) {  

    // We've received a packet, read the data from it

    Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

    //the timestamp starts at byte 40 of the received packet and is four bytes,

    // or two words, long. First, esxtract the two words:

    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);

    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  

    // combine the four bytes (two words) into a long integer

    // this is NTP time (seconds since Jan 1 1900):

    secsSince1900 = highWord << 16 | lowWord;  

    secsSince1900 = secsSince1900 + 7200; // MESZ Korrektur

//    // now convert NTP time into everyday time:

//    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:

    const unsigned long seventyYears = 2208988800UL;     

//    // subtract seventy years:

      epoch = secsSince1900 - seventyYears;  

//    // print Unix time:

//    Serial.print("Unix time = ");

//    Serial.println(epoch);                               

    // print the hour, minute and second:

//    Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)

//    Serial.print((epoch  % 86400L) / 3600); // print the hour (86400 equals secs per day)

//    Serial.print(':');  

//    if ( ((epoch % 3600) / 60) < 10 ) {

//      // In the first 10 minutes of each hour, we'll want a leading '0'

//      Serial.print('0');

//    }

//    Serial.print((epoch  % 3600) / 60); // print the minute (3600 equals secs per minute)

//    Serial.print(':'); 

//    if ( (epoch % 60) < 10 ) {

//      // In the first 10 seconds of each minute, we'll want a leading '0'

//      Serial.print('0');

//    }

//    Serial.println(epoch %60); // print the second

  }

return epoch;  

}

//########################### ab hier Filenamengenerierung ######

  // open the file. note that only one file can be open at a time,

  // so you have to close this one before opening another.

void newFilename() {

  selSD();

  dataFile = SD.open(numFile,FILE_READ);

  // if the file is available, Lesen...

  if (dataFile) {

              dataFile.seek(0);

              for(i=0; i <= 4; i++ ) numbuffer[i] = dataFile.read();  // nur die ersten 5 Ziffern einlesen

                   Serial.println(numbuffer);

              //dataFile.flush();

              dataFile.close();

                }  

     dtNummer =  atoi(numbuffer);  // Dateinummer in Integer wandeln

     Serial.println(numbuffer);

     Serial.println(dtNummer);

//###### Filenummer neu generieren und speichern

    if(dtNummer <= 10000) dtNummer += 10000;  // Sicherstellen das Filenummer 5 stellig ist.

    dtNummer ++;                        // Increment 

   selSD();

   dataFile = SD.open(numFile, FILE_WRITE);

  // if the file is available, write to it:

  if (dataFile) {

    dataFile.seek(0);

    dataFile.println(dtNummer);

    //dataFile.flush();

    dataFile.close();

                }            

//###### WDL  Filename generieren

  sprintf(numbuffer,"%5d",dtNummer);

  strcpy(WDLfile,"WD_");

  strcat(WDLfile, numbuffer);

  strcat(WDLfile, ".TXT");

  sdwrcount = 0;   // Counter ruecksetzen

  Serial.println(WDLfile);

}   //### End of newFilename 

//############################# Start SD

void startSD() {

  // Start SD Card interface

  selSD();

  lcd.print("Initializing SD");  

  delay(800);

   if (!SD.begin(SDselect)) {

       lcd.setCursor(0, 1);    

       lcd.print("Card failed");

       SDpresent = 0;    //   Merker ob SD verfuegbar

                            }

   else {

       lcd.setCursor(0, 1);    

       lcd.println("card initialized.");

       SDpresent = 1;         //   Merker ob SD verfuegbar

         }

       delay(2000);   //  2 Sec warten um Anzeige abzulesen

}

//######################  END of Source ####################################

rkuehle · 05.01.2014, 15:40

Hallo Bitklopfer,

Zitat:manche würden sagen Spaghetticode...

Nix da, der Code ist gut kommentiert und sauber strukturiert.
Was will man mehr?

Grüße Ricardo

PS: Nicht das sich das Forum zu einer "Altherrenriege" entwickelt Smile

**Bitklopfer** · 05.01.2014, 15:57

(05.01.2014 15:40)rkuehle schrieb: Hallo Bitklopfer,

Zitat:manche würden sagen Spaghetticode...
Nix da, der Code ist gut kommentiert und sauber strukturiert.
Was will man mehr?

Grüße Ricardo

PS: Nicht das sich das Forum zu einer "Altherrenriege" entwickelt

Hallo Ricardo,
Danke für die Blumen...weissu Kommentare sind gut gegen Alzi... Big Grin

vor knapp 30 Jahren habe ich Kommentare gehaßt... Angry

..und vielleicht sollte ich mal bei den Azubi's und Schülerpraktikanten
wo bei mir im Betrieb durchlaufen und seit kurzem auch nen Arduino
Craschkurs bekommen mal auf das Forum hier hinweisen....
immerhin bastel ich für die gerade an einem abgewandelten UNO Board
wo gleich einige LED's und Sensoranschlüße drauf sind bzw. 1..2 Leistungsrelais
damit ich die Platine universell einsetzen kann....also auch für Betriebliche
Aufgaben.
lg
bk

Möglicherweise verwandte Themen...
Thema:		Verfasser	Antworten:	Ansichten:	Letzter Beitrag
	Serieller string zwischenspeichern und wieder ausgeben.	Matt	15	779	03.03.2018 20:23 Letzter Beitrag: Tommy56
	DS18s20 Temperatur Sensor	georg01	9	523	25.02.2018 16:03 Letzter Beitrag: georg01
	Temperatur mit Taster um +1 erhöhen	T100	7	448	09.02.2018 04:58 Letzter Beitrag: T100
	Datei von SD Karte auf Display ausgeben	dahans	30	967	06.02.2018 21:24 Letzter Beitrag: dahans
	ASCII Zeichen Seriell ausgeben	huber5093	3	703	07.10.2017 20:35 Letzter Beitrag: Tommy56
	Char Werte ausgeben	Scotch	5	1.167	31.03.2017 15:37 Letzter Beitrag: Scotch
	Zählerstand nur einmal ausgeben	Fliega	11	1.859	21.02.2017 11:21 Letzter Beitrag: SkobyMobil
	Blinkcode in Klartext ausgeben	Borderwalker310	20	1.928	09.02.2017 22:14 Letzter Beitrag: Tommy56
	Temperatur via SMS senden	Obermuda	6	1.561	07.02.2017 12:27 Letzter Beitrag: Tommy56
	DHT22 min max Temperatur 7-Segmentanzeige	bastelbert	50	4.870	14.01.2017 11:46 Letzter Beitrag: Tommy56


Baumstrukturmodus \| Linearer Modus Temperatur auf Lan ausgeben