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
Temperatur auf Lan ausgeben
04.01.2014, 19:17
Beitrag #9
RE: Temperatur auf Lan ausgeben
nAbendddddddddddd,

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

iselein
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.01.2014, 23:44
Beitrag #10
RE: Temperatur auf Lan ausgeben
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("<p>Mein Arduino Uno Server</p>");
client.println("</body>");
client.println("<p>Puffer links oben:<p>");
client.println(sensors.getTempCByIndex(0),1),
client.println("</body>");
client.println(" Celsius");
client.println("<p>Puffer links Mitte:<p>");
client.println(sensors.getTempCByIndex(1),1);
client.println("<p>Puffer links Unten:<p>");
client.println(sensors.getTempCByIndex(2),1);
client.println("<p>Puffer rechts Oben:<p>");
client.println(sensors.getTempCByIndex(3),1);
client.println("<p>Puffer rechts Mitte:<p>");
client.println(sensors.getTempCByIndex(4),1);
client.println("<p>Puffer rechts Unten:<p>");
client.println(sensors.getTempCByIndex(5),1);
client.println("<p>Heizung Vorlauf:<p>");
client.println(sensors.getTempCByIndex(6),1);
client.println("<p>Heizung Ruecklauf:<p>");
client.println(sensors.getTempCByIndex(7),1);
client.println("<p>Aussentemperatur:<p>");
client.println(sensors.getTempCByIndex(8),1);
client.println("<p>Temperatur Abgas:<p>");
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
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.01.2014, 08:42
Beitrag #11
RE: Temperatur auf Lan ausgeben
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
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.01.2014, 15:22
Beitrag #12
RE: Temperatur auf Lan ausgeben
@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 CarbonaraTongue 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 ####################################

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.01.2014, 15:40
Beitrag #13
RE: Temperatur auf Lan ausgeben
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

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.01.2014, 15:57
Beitrag #14
RE: Temperatur auf Lan ausgeben
(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 Smile

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

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Servo über Temperatur steuern querkopf71 3 84 07.12.2016 19:21
Letzter Beitrag: hotsystems
  Temperatur mit nrf24 übertragen jgrothe 17 691 09.09.2016 14:01
Letzter Beitrag: jgrothe
  Problem bei Temperatur/volt Ampere Abfrage LCD Flimmern nuernie66 9 647 04.03.2016 19:25
Letzter Beitrag: hotsystems
  Analogspannung ausgeben Rudi 6 640 24.02.2016 14:25
Letzter Beitrag: hotsystems
  Hexzahl immer mit 2 Zeichen ausgeben. arduinofan 11 795 12.01.2016 09:00
Letzter Beitrag: arduinofan
  mehrere Analoge eingänge seriell ausgeben rieders 5 811 28.11.2015 09:55
Letzter Beitrag: Bitklopfer
  Status einer if / else Verknüpfung per client.print ausgeben daruel 8 1.142 20.08.2015 10:11
Letzter Beitrag: daruel
  Temperatur auf 3,2 Zoll TFT Anzeigen jgrothe 12 1.901 04.07.2015 17:06
Letzter Beitrag: jgrothe
  RTC auf LCD ausgeben. Probleme mit der führenden Null Gelegenheitsbastler 6 1.975 15.03.2015 12:18
Letzter Beitrag: tito-t
  Wert auf UTFT Display ausgeben Kurt 11 5.670 15.12.2014 08:56
Letzter Beitrag: rkuehle

Gehe zu:


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