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
AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
17.07.2014, 11:06
Beitrag #17
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
huhu Smile

habe auch das gleiche Problem Sad( Habe eine RTC DS1307 zum laufen gebracht und die ist über eine 3,6 V Knopfzelle gespeist. Nun mag ich aber auch die Sync über eine DCF77....

In einem anderen Beitrag schrieb ich dazu:

"... zum Thema RealTime Clock... ja,, da bin ich sehr Enttäuscht.... Ich habe vom ELV die DCF77 Platine gekauft,

http://www.elv.de/real-time-clock-dcf-mo...usatz.html

die als Schild eingesetzt werden kann, oder als Breadboard mit I2C Anbindung oder den DCF77 Empfänger zum direkt anschließen an den Digital Pin und 3,3 Volt. Ein von mir gekaufter Bidirektionaler Pegelwandler für den I2C Bus von 5 V auf 3,3 Volt tut hierbei super Dienste.... Der Empfänger alleine funkt gut, der Empfänger mit dem I2C Bus macht zicken beim Auslesen, und als Shield .... naja.. war er für mich unbrauchbar...

Alles hierbei scheiterte auch an den Millionen Programmierbeispielen, weil nix funktionierte und ich noch nicht beim direkten Ansprechen auf die Register den Plan habe... noch nicht...

Bin an dem Thema gerade dran. Werde mal versuchen, die Antenne 1-2 Meter auszulagern, ob dann der Empfang besser wird, und ggf. mal die Datenleitung mit einem Widerstand etwas zu "Belasten"...

Das muss doch gehen Smile)

LG

Frank
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.07.2014, 18:20
Beitrag #18
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
(17.07.2014 11:06)fp.blues2013 schrieb:  huhu Smile

habe auch das gleiche Problem Sad( Habe eine RTC DS1307 zum laufen gebracht und die ist über eine 3,6 V Knopfzelle gespeist. Nun mag ich aber auch die Sync über eine DCF77....

In einem anderen Beitrag schrieb ich dazu:

"... zum Thema RealTime Clock... ja,, da bin ich sehr Enttäuscht.... Ich habe vom ELV die DCF77 Platine gekauft,

http://www.elv.de/real-time-clock-dcf-mo...usatz.html

die als Schild eingesetzt werden kann, oder als Breadboard mit I2C Anbindung oder den DCF77 Empfänger zum direkt anschließen an den Digital Pin und 3,3 Volt. Ein von mir gekaufter Bidirektionaler Pegelwandler für den I2C Bus von 5 V auf 3,3 Volt tut hierbei super Dienste.... Der Empfänger alleine funkt gut, der Empfänger mit dem I2C Bus macht zicken beim Auslesen, und als Shield .... naja.. war er für mich unbrauchbar...

Alles hierbei scheiterte auch an den Millionen Programmierbeispielen, weil nix funktionierte und ich noch nicht beim direkten Ansprechen auf die Register den Plan habe... noch nicht...

Bin an dem Thema gerade dran. Werde mal versuchen, die Antenne 1-2 Meter auszulagern, ob dann der Empfang besser wird, und ggf. mal die Datenleitung mit einem Widerstand etwas zu "Belasten"...

Das muss doch gehen Smile)

LG

Frank

Hallo Frank,
jupp...ich glaube du meintest dieses elv Modul:
RTC-DCF Modul
Wenn ich mich nicht irre dann habe ich das Vorgängermodell davon das ich auch nicht zum laufen bekommen habe und es bislang zur Seite gelegt habe.
Allerdings habe ich es am laufen die Zeit über einen NTP Server zu ziehen und habe dazu eines der in der Arduino IDE mitgelieferten Beispiele für mich angepasst. Nur den Algorhytmus um dann auch die RTC dahin abzugleichen habe ich auch noch nicht programmiert.
Also das Thema lebt noch...
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
17.07.2014, 18:54 (Dieser Beitrag wurde zuletzt bearbeitet: 17.07.2014 18:55 von fp.blues2013.)
Beitrag #19
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
Ja Smile das Thema lebt wieder Smile) Ich brüte gerade über den Schaltplänen / den Datenblättern / Beschreibungen... Die bisherigen Sketsche, die ich ausprobiert habe, beinhalteten irgendwie Fehler / Unverträglichkeiten mit der IDE 1.xxx b.z.w. kann ich die Fehler noch nicht finden...
ABER... ich geb nicht auf Smile außerdem muss ich es ja auch lernen...

Ich habe das kleine DCF Modul mit der Ferrit Antenne wieder auf die Platine mit dem kleinen Prozessorchip gelötet, und werde das Ding nun mal step bei Step über I2C ansprechen. Anscheinend sind die beiden Platinen nur zusammen eine funktionierende DCF77 Uhr. Eins ist der reine Empfänger und das andere ist die Auswerteinheit ( MCU und die RTC ).

Ich fange nun mal mit der Initialisierung der I2C Schnittstelle an und sehe zu, das ich überhaupt irgendwas auslesen kann. Danach gibt's eine Sequenz, in der der man den DCF77 Zeitsignal Empfang aktivieren kann, der ja dann nach erfolgreichem Empfang ( 1-2 Minuten ) die Zeit in der RTC updatet.

Danach wird ich die neue Zeit auslesen und auf einem Display 20x4 darstellen.

Das mal zur Theorie Smile) Nun geht's an die Arbeit Smile werde mal laufend hier berichten... aber sicher wird ich auch eure Hilfe brauchen...


Liebe Grüße

Frank
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.07.2014, 19:34
Beitrag #20
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
Hallo Frank,
ich halte das Thema für sehr interessant. Du schreibst:
Zitat:Die bisherigen Sketsche, die ich ausprobiert habe, beinhalteten irgendwie Fehler / Unverträglichkeiten mit der IDE 1.xxx b.z.w. kann ich die Fehler noch nicht finden...
Bekommst du irgendwelche Fehlermeldungen? Immer her damit, am besten natürlich samt Code.

Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.07.2014, 20:48 (Dieser Beitrag wurde zuletzt bearbeitet: 17.07.2014 21:52 von fp.blues2013.)
Beitrag #21
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
huhu Smile

Mooaah Sad das ist soo verdammt kompliziert...

Habe nun das DCF77 Modul auf die MCU gelötet... die I2C Adresse auf 0X19 eingestellt.... Das Shield habe ich weggemacht.... ( hat den Ausbau des kleinen Cut-Outs ^^ nicht überlebt ^^ egal, waren eh nur Pegelanpassungen von 5 v auf 3,3 Volt.. und die entsprechenden Stiftleisten, um es als Shield auf den Arduino zu stecken...

Dann 3,3, Volt angeschlossen und den I2C Bus über einen Bidirektionalen Pegelwandler an den 5 Volt Bus angekoppelt...

Ein I2C Scanner hat das Modul gefunden an 0x19 und keine Fehler ausgeworfen.

Dann habe ich ein kleinen TestSketch gefunden, um die DCF77 RTC einzustellen und dann die Zeit auszulesen.

Musste dann noch eine Datei um konfigurieren, damit das Modul über die richtige I2C Adresse angesprochen wird.

Hier mal der Sketch, der nun läuft:

/******************************************************************************
Beispiel: setTime

Beschreibung: Dieses Beispiel zeigt das Schreiben und Lesen der Uhrzeit aus
dem RTC-DCF.

Hinweis: Zur Einstellung des Kommunikationswegs (UART, SPI oder I2C) zum
RTC-DCF enthält die Library die Datei RTC_DCF_config.h im
Unterordner \libraries\RTC_DCF\config\. Innerhalb dieser Datei
kann der Kommunikationsweg umgestellt werden.
******************************************************************************/
#include <stdio.h>
#include "DateTime.h"
#include "RealTimeClock_DCF.h"

/* leider setzt die Arduino-IDE voraus, dass alle in einem Projekt verwendeten
Klassen auch ins Sketch übernommen werden. Wird dieses nicht berücksichtigt,
kommt es zu Fehlern beim Linken des Programms. Daher muss an dieser Stelle
die Headerdatei zu der jeweils verwendeten Kommunikationsklasse eingefügt
werden. Die beiden jeweils nicht verwendeten Header müssen auskommentiert
werden. */

/* für die Kommunikation über UART die modSoftwareSerial.h verwenden */
// #include "modSoftwareSerial.h"

/* für die Kommunikation über SPI die SPI.h verwenden */
//#include "SPI.h"

/* für die Kommunikation über Wire die Wire.h verwenden */
#include "Wire.h"

/******************************************************************************
globale Variablen
******************************************************************************/
/* einzustellende Uhrzeit */
DateTime dateTime = DateTime(0, 1, 1, DateTime::SATURDAY, 0, 0, 0);

/******************************************************************************
Funktionen
******************************************************************************/
void setup()
{
/* der RTC-DCF benötigt ca. 1,5 Sekunden bis er Daten empfangen kann */
delay(1500);

/* RTC-DCF initialisieren */
RTC_DCF.begin();

/* Uhrzeit im RTC-DCF setzen */
RTC_DCF.setDateTime(&dateTime);

/* die serielle Ausgabe initialisieren */
Serial.begin(115200);
}

void loop()
{
/* ca. jede Sekunde wird die Uhrzeit ausgelesen und über die serielle Schnittstelle
ausgegeben. */
delay(1000);

RTC_DCF.getDateTime(&dateTime);

printClock();
}

void printClock(void)
{
char clockString[30];

sprintf(clockString, "Es ist %02u:%02u:%02u am %02u.%02u.%02u", dateTime.getHour(), dateTime.getMinute(), dateTime.getSecond(), dateTime.getDay(), dateTime.getMonth(), dateTime.getYear());

Serial.println(clockString);
}

Ok, nun weis ich aufgrund der Anzeigen im Monitor wenigstens,


Es ist 00:27:54 am 01.01.00
Es ist 00:27:55 am 01.01.00
Es ist 00:27:56 am 01.01.00
Es ist 00:27:57 am 01.01.00
Es ist 00:27:58 am 01.01.00
Es ist 00:27:59 am 01.01.00
Es ist 00:28:00 am 01.01.00
Es ist 00:28:01 am 01.01.00
Es ist 00:28:02 am 01.01.00
Es ist 00:28:03 am 01.01.00
Es ist 00:28:04 am 01.01.00
Es ist 00:28:05 am 01.01.00
Es ist 00:28:06 am 01.01.00
....

das die Zeit richtig ausgelesen wird, und das Modul meine ganzen Tests überlebt hat ^^

Ich schaue mir jetzt mal den Sketch an, um zu sehen, was da alles passiert...

Was noch nicht funktioniert, ist, das der DCF77 Empfänger aktiviert wird und eine Zeit empfängt, sowie diese dann in die RTC schreibt.

In der Bedienungsanleitung steht drin, wie man den Empfänger aktivieren kann... aber das ist noch fast zu hoch für mich... Sad((

DCF77 Empfang....

Mit Hilfe des Config Registers 0xD kann die DCF77 Funktionalität des RTC-DCF eingestellt werden. Dazu kann mit dem DCFE-Bit der DCF77 Empfang aktiviert werden.

In der Registertabelle ist dieses DCFE-Bit unter der Adresse Dh und dem Bit D0 zu finden.
...

Soll die DCF77 LED ( auf der kleinen Trägerplatine ) zusätzlich bei dem Empfang eines DCF77 Zeitsignals eingeschaltet werden... muss hierzu das DCFLED-Bit gesetzt werden.

In der Registertabelle ist dieses DCFLED-Bit unter der Adresse Dh und dem Bit D2 zu finden.

Da ich das mal selbst lernen möchte, denke ich nun mal, das ich das über den I2C Bus durch senden einer Sequenz erreichen kann.

start sowieso mit #include "Wire.h"
dann unter void Setup()
wire.begin();

Muss ja dann denke ich erstmal als "Sender" den Bus zu mir nehmen, und sagen.. Wire.beginTransmission(0X19); //"hey" ( Adresse 0X19 ) aufpassen... Dann mit
wire.write ( Registerposition Dh ) den pointer drauf setzen
und dann irgendwie das datenbit schicken.. also eine 1.. an Bit 0
dann die Transmission beenden...

hab ich das im groben richtig verstanden ?

blos...Sad wire.write(0); hatte ich schon ein anderes mal gemacht... also den pionter auf Position 0 ins Register setzen... Dann habe ich aber ausgelesen... nun muss ich senden, ( wire write.... ) und dann an die Position Dh und das Bit an die D0....

wie würde man so etwas formulieren ??

Muuhaha... wer lesen kann.... ( Nachtrag) anscheinend gibt's für diese Funktion einen direkten Befehl ^^^^

/* DCF77-Empfang aktivieren */
RTC_DCF.enableDCF77Reception();

das habe ich nur eingefügt unter Void Setup.... , habs compiliert und übertragen...

Dann im Serial Monitor beobachtet ^^ .... nach wenigen Sekunden dann das Ergebnis:
Es ist 00:01:17 am 01.01.00
Es ist 00:01:18 am 01.01.00
Es ist 00:01:19 am 01.01.00
Es ist 00:01:20 am 01.01.00
Es ist 22:24:00 am 17.07.14 <--- Jipiieeee Big Grin Big Grin *freu*
Es ist 22:24:01 am 17.07.14
Es ist 22:24:02 am 17.07.14

Hmm... funktioniert Smile nur leider war das ja nur zusammengebaut... Ich muss noch soo viel lernen Sad(

Jetzt schau ich mal, wie ich die RTC per Knopfzelle noch Puffern kann.... das die RTC auch ohne Strom weiterläuft

Ok.. obriges hat sich auch erledigt... das Datenblatt schreibt ca 12mA Stromverbrauch... ^^

Dann gehe ich jetzt mal dran... mit der DCF77 Zeit die kleine DS1307 RTC nach dem Start zu syncronisieren.... die ist ja schon von Hause aus mit einer Backup-Knopfzelle versehen. Die benötigte Zeit wird sowieso immer nur aus der DS1307 herausgelesen... und somit kann ja auch die DCF-RTC mit irgendeiner Vorgabe starten. Mittlerweise ist die DCF77 bereits nach 7 Sekunden aktualisiert Smile)
Jetzt füge ich noch eine Ausgabe von Zeit, Datum und Wochentag hinzu über mein 20x4 I2C Display Smile

Wie siehts eigentlich aus mit der anzeige einer Kalenderwoche ??
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.07.2014, 22:22
Beitrag #22
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
Hallo,
letztes Jahr hatte ich in der Richtung auch mal was angefangen und zwar mit einer per Gold-Cap C gepufferten RTC auch von elv mit ner Gangreserve von umme einer Woche. Das Ganze war dann noch mit Ethernetschnittstelle versehen um per NTP Server die Unix Zeit aus dem Netz zu ziehen weil mein DCF77 Empfänger viel einfacher aufgebaut war wie deiner jetzt, also das Zeitsignal das erst noch Decodiert werden mußte was aber nie gefunzt hat bislang. Ergo habe ich mich daruaf beschränkt die RTC per NTP Server zu initialisieren und habe dann noch die Möglichkeit eingebaut per Tastendruck am LCD Keypad Shield den Korrekturwert der RTC zu verändern.
Dann konnte die Uhrzeit am LCD, per Ethernet und Seriel ausgegeben werden. Was noch fehlt ist eine clevere Routine wo sagt welche Uhrzeit nun gerade gültig ist und diese dann als Update für die andere verwendet. Also hier mal der Code davon mit allen Versuchsecken die auch auskommentiert sind:

Code:
//#################### TIME SERVER #######################################
//  Allgemeines:
//  Linux Zeit wird im Programm zu NTP Zeit
//  History:
//  V1  NTP RTC DCF Server
//
//######################################################################


//  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 "Wire.h"
#include "TwoWireRTC.h"
#include "DateTime.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
unsigned int i = 0;     // der uebliche Verdaechtige


// assign a MAC address for the ethernet controller.
byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x94, 0xAB};  // MAC Adresse wo auf EGO's 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,0,154);
IPAddress gateway(192,168,0,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);


#define FIRSTYEAR       1970
#define FIRSTDAY        4                       // 0 = Sunday
const uint8_t DayOfMonth[] PROGMEM = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
#define getMonthLen(a)  pgm_read_byte(&(DayOfMonth[(a)]))


/******************************************************************************
globale Variablen  RTC
******************************************************************************/
// einzustellende Uhrzeit
DateTime time = DateTime(13, 7, 25, DateTime::THURSDAY, 16, 19, 0);

// Variablen System Zeit
unsigned int jahr;      
unsigned int mon;
unsigned int tag;
unsigned int wd;
unsigned int hr;
unsigned int mn;
unsigned int sc;

// Variablen RTC Zeit
unsigned int rtcjahr;  
unsigned int rtcmon;
unsigned int rtctag;
unsigned int rtcwd;
unsigned int rtchr;
unsigned int rtcmn;
unsigned int rtcsc;
unsigned long int rtclinux;    // die aus der RTC gezogene Linuxzeit
long int differenz;
unsigned int rtcmonh;          // Hilfsvariable fuer RTC Linux zeit berechnen
unsigned char rtcschalt;        // ist es ein Schaltjahr 0 = JA
char trimmwert;                 // Wert zum RTC Baustein abzugleic
char trimmold;                  // Zwischenspeicher das nicht andauernd geschrieben wird


// Variablen NTP Zeit
unsigned int ntpjahr;
unsigned int ntpmon;
unsigned int ntptag;
unsigned int ntpwd;
unsigned int ntphr;
unsigned int ntpmn;
unsigned int ntpsc;

// Konstante zur NTP Zeit
//const long int simNTP = 1374920000;   // irgendeine Zeit am 27.7.2013 nach 10Uhr
const long int simNTP = 1380000000;   // irgendeine Zeit am 27.7.2013 nach 10Uhr

// DCF77 Variablen
unsigned long dcfoldh;
unsigned long dcfoldl;
unsigned long dcfh;
unsigned long dcfl;
unsigned int dcfsig;


// 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 lcdausg1[18]; // stringbuffer
char lcdausg2[18]; // stringbuffer
char tstr[5];       // Twert Tastenwert als String
char lcdbuff[5];   // Buffer fuer NTP Proto Ausgabe



//##########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;
char sdon = 219;
char sdoff = 253;   // anstatt 173
char sdwrite = 165;
unsigned char dattoggle = 0; // Anzeigenwechels LCD Datum
unsigned int di;     // LCD Datum Change Zaehler
unsigned int ni;     // NTP Index


// 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
  
//  pinMode(A3, INPUT);   // Eingang fuer DCF77
//  digitalWrite(A3,1);   // Pullup 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
  
  Wire.begin();
  RTC.begin();
  
  di = 0;  

   // 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 #######  
  CallNTP();
  Unixtime = epoch;
  
  //### lokaler Sekundenzaehler auf Unixzeit stellen
  //sekunden = Unixtime;
  differenz = 0;
}


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

void loop() {
  
  // DCF einlesen
//do{
//  dcfsig = digitalRead(A3);
//}
//while (dcfsig == 1);
//dcfoldl = millis();
//do{
//  dcfsig = digitalRead(A3);
//}
//while (dcfsig == 0);
//dcfl = millis() - dcfoldl;
////dcfl = analogRead(A3);
//
// sprintf(lcdausg1,"%4lu  ",dcfl);  // stringwandlung
//  lcd.setCursor(0, 1);
//  lcd.print(lcdausg1);


  //  Messzyklus alle Sekunde
  if (millis() - lastReadingTime > 1000){    // eigentlich ja 1000, aber auch 999 ist zu schnell
    lastReadingTime = millis();  // Zeitstempel updaten
    //sekunden ++;  // Sekundenzaehler inkrement

    
  // LCD Ausgabe im Sekundentakt  
  sprintf(lcdausg1,"%10lu",millis());  // stringwandlung
  lcd.setCursor(0, 0);
  lcd.print(lcdausg1);

  
  
  readRTC();                 // lese RTC aus und speichere auf lokalen Variablen
  rtczulinux();              // wandle lokale RTC Variablen zu rtclinux um
  rtcSerial();               // RTC ausgeben
  rtcLCD();                  // RTC auf LCD ausgeben
  //epoch = sekunden;          // uebergabe
  //ntpaufreal(sekunden);              // NTP Zeit auf Real umsetzen
  ntpSerial();               // oehm mal nachkucken was da ausgegeben wird....

  readRTCtrimm();
  sprintf(lcdausg1,"%3d",trimmwert);  // stringwandlung
  lcd.setCursor(0, 1);
  lcd.print(lcdausg1);
  
//   if(sekunden >= rtclinux)differenz = sekunden - rtclinux;
//  if(sekunden <= rtclinux)differenz = rtclinux - sekunden;
//differenz = -2;
  sprintf(lcdausg1,"%4ld",differenz);  // stringwandlung
  lcd.setCursor(12, 0);
  lcd.print(lcdausg1);

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


  Twert = analogRead(0);  // Temp einlesen
  if(Twert <= 1000){
      lcd.setCursor(0, 0);
      sprintf(tstr,"%4u",Twert);
      lcd.print(tstr);

      if(Twert >= 750){       // SD Card ein / ausschalten
      
                       writeRTC();
                        
                      }
                      
   if(Twert <= 420 & Twert >= 400){   // NTP Server abfragen zum Uhrenvergleich
      CallNTP1();
      readRTC();
      rtczulinux();
      Unixtime = epoch;
      differenz = Unixtime - rtclinux;  // bei - ist die RTC zu langsam
//      if(Unixtime >= rtclinux)differenz = Unixtime - rtclinux;
//      if(Unixtime <= rtclinux)differenz = rtclinux - Unixtime;
//      sekunden = Unixtime;
      //delay(1000);
              }
              
    if(Twert <= 260 & Twert >= 250){   //
    trimmwert--;
    writeRTCtrimm();
    //delay(800);
              }


    if(Twert <= 646 & Twert >= 633){   // NTP Buffer ausgeben auf Seriell
   i = 0;
   do
   {
  
    ni = 0;
    sprintf(lcdbuff,"%3d  ",ni + i*8);
    Serial.print(lcdbuff);

    do
    {
    sprintf(lcdbuff,"%2x ",packetBuffer[ni+i*8]);
    if(lcdbuff[0] == ' ')lcdbuff[0] = '0';
    Serial.print(lcdbuff);
    ni++;  
    }
    while (ni <= 7);
    ni = ni - 8;
    Serial.print(" - ");
    
    do
    {
    sprintf(lcdbuff,"%1c ",packetBuffer[ni+i*8]);
    Serial.print(lcdbuff);
    ni++;  
    }
    while (ni <= 7);
    Serial.println(" ");
    i++;    
     }
    while (i <= 5);
    Serial.println(" ");
    Serial.println(" ");
    Serial.println(" ");


                                   }


    //  NTP Zeit holen
    if(Twert <= 10){                // NTP Zeit holen und sofort auf RTC schreiben
      CallNTP1();
      ntpaufreal(epoch);
      writeRTC();
      Unixtime = epoch;
      //sekunden = Unixtime;
      //delay(1000);


    }
                  
              
    // Anzeige des Recordcounters
    if(Twert <= 105 & Twert >= 92){   //
    trimmwert++;
    writeRTCtrimm();
    //delay(800);
              }




      }  // Ende Abfrage ob Taste gedrueckt



    //sekunden ++;  // Sekundenzaehler inkrement


  }  // Ende im sekundentakt
  
  
//########## Schleifenarbeit

//  readRTC();                 // lese RTC aus und speichere auf lokalen Variablen
//  rtczulinux();              // wandle lokale RTC Variablen zu rtclinux um
//  rtcSerial();               // RTC ausgeben
//  rtcLCD();                  // RTC auf LCD ausgeben
//  epoch = sekunden;          // uebergabe
//  ntpaufreal(epoch);              // NTP Zeit auf Real umsetzen
//  ntpSerial();               // oehm mal nachkucken was da ausgegeben wird....



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

// if (sekunden >= nextsek){           // Wenn lz Intervall erreicht dann ausgeben    
//
//nextsek = nextsek + messintervall;  // die Schrittweite berechnen fuer naechste Aktion
//
//
//}

  // warten auf Ethernetanfragen
  selETH();
  listenForEthernetClients();
  
}

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


//################################# RTC zu Linux ######
void rtczulinux()
{
//  readRTC();
//  rtctag = time.getDay();         //  Ausgabe der RTC auf LCD
//  rtcmon = time.getMonth();
//  rtcjahr = time.getYear();
//  rtcwd = time.getWeekday();   // das Gegenstueck ist setWeekday
//  rtchr = time.getHour();
//  rtcmn = time.getMinute();
//  rtcsc = time.getSecond();
  
// rtclinux =  rtcsc;     //   Sekunden addieren
//  rtclinux = rtclinux + (rtcjahr + 30) * 31536000l; //  Jahressekunden mal Jahre

  rtclinux = (rtcjahr + 30) * 31536000l;              //  Jahressekunden mal Jahre
  rtclinux = rtclinux + ((rtcjahr + 30) / 4) * 86400l;//  Schaltjahrtage addieren
  //rtcschalt = (rtcjahr + 30) / 4;                     // Schaltjahrflag setzen 0 = dies ist ein Schaltjahr
  //if(rtcschalt == 0)rtclinux = rtclinux - 86400l;     // wenn Schaltjahr aktuell dann einen Tag abziehen
// Serial.print("10 rtclinux ");
//  Serial.println(rtclinux);
  
  rtcmonh = rtcmon - 1;                               // aktuellen Monat nicht addieren
  if(rtcmonh >=  1)rtclinux = rtclinux + 2678400l;    // Januar addieren
  if(rtcmonh >=  2)rtclinux = rtclinux + 2419200l;    // Februar mit 28 Tagen addieren Schaltjahrtag fehlt noch
  //if(rtcschalt == 0)rtclinux = rtclinux + 86400l;     // Schaltjahrtag dazurechnen
  if(rtcmonh >=  3)rtclinux = rtclinux + 2678400l;    // Maerz addieren
  if(rtcmonh >=  4)rtclinux = rtclinux + 2592000l;    // April addieren
  if(rtcmonh >=  5)rtclinux = rtclinux + 2678400l;    // Mai addieren
  if(rtcmonh >=  6)rtclinux = rtclinux + 2592000l;    // Juni addieren
  if(rtcmonh >=  7)rtclinux = rtclinux + 2678400l;    // Juli addieren
  if(rtcmonh >=  8)rtclinux = rtclinux + 2678400l;    // August addieren
  if(rtcmonh >=  9)rtclinux = rtclinux + 2592000l;    // September addieren
  if(rtcmonh >=  10)rtclinux = rtclinux + 2678400l;   // Oktober addieren
  if(rtcmonh >=  11)rtclinux = rtclinux + 2592000l;   // November addieren
//  Serial.print("0 rtclinux ");
//  Serial.println(rtclinux);
    
  rtclinux = rtclinux + (rtctag * 86400);             //  Tage addieren
//  Serial.print("1 rtclinux ");
//  Serial.println(rtclinux);
  if(rtchr != 0)rtclinux = rtclinux + (rtchr * 3600l); //  Stunden addieren
//  Serial.print("2 rtclinux ");
//  Serial.println(rtclinux);
  if(rtcmn != 0)rtclinux = rtclinux + (rtcmn * 60);   //  Minuten addieren
//  Serial.print("3 rtclinux ");
//  Serial.println(rtclinux);
  rtclinux = rtclinux + rtcsc;                        //   Sekunden addieren
  //rtclinux = rtclinux + 7200;                       //   Sommerzeit ergaenzen, braucht man hier nicht.
//  Serial.print("4 rtclinux ");
//  Serial.println(rtclinux);
  
  

  
}




//############################### 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("Projekt ARDUINO-TIME SERVER, V1 2013");
          client.println("<br />");
          client.print("Lokale Unix Zeit, Sekunden seit dem 1.1.1970: " + String(rtclinux));
          client.println("<br />");

//   Ausgabe NTP
//          client.println("<br />");
//          client.print("NTP Date - Time   ");
//          sprintf(lcdausg2,"%2d.%d.20%2d - %1d - ", ntptag, ntpmon, ntpjahr, ntpwd);          
//          client.print(lcdausg2);
//          
//          sprintf(lcdausg2,"%2d:%2d:%2d", ntphr, ntpmn, ntpsc);
//          if(lcdausg2[3] == ' ')lcdausg2[3] = '0';
//          if(lcdausg2[6] == ' ')lcdausg2[6] = '0';
//          client.print(lcdausg2);
          
          
//  Ausgabe RTC
          client.println("<br />");
          client.print("RTC Date - Time   ");
          sprintf(lcdausg2,"%2d.%d.20%2d - %1d - ", rtctag, rtcmon, rtcjahr, rtcwd);          
          client.print(lcdausg2);
          
          sprintf(lcdausg2,"%2d:%2d:%2d", rtchr, rtcmn, rtcsc);
          if(lcdausg2[3] == ' ')lcdausg2[3] = '0';
          if(lcdausg2[6] == ' ')lcdausg2[6] = '0';
          client.print(lcdausg2);

          client.println("<br />");
          client.println("<br />");
//          client.print("NTP ");
//          client.println(sekunden);
//          client.println("<br />");
          client.print("RTC ");
          client.print(rtclinux);
          client.println("<br />");
          
//if(sekunden >= rtclinux)differenz = sekunden - rtclinux;
//if(sekunden <= rtclinux)differenz = rtclinux - sekunden;

          client.println("<br />");
          client.print("Differenz zu letztem NTP Abgleich, - = RTC zu langsam ");
          client.print(differenz);
          client.println("<br />");



////          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);

}




// 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]  = '1';   // Standart ist "1"  aber "X" ist Experimental
  packetBuffer[13]  = 'N';
  packetBuffer[14]  = '1';
  packetBuffer[15]  = '4';

  // 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()  // zur Simulation
{
  epoch = simNTP;
  return epoch;
}


unsigned long int CallNTP1()
{
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
    secsSince1900 = secsSince1900 + 3600; // MEZ 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;  
  }
return epoch;  
}

void ntpSerial()
{
// Ausgabe der Daten auf die Serielle Schnittstelle
   sprintf(lcdausg2,"NTP: %2d.%d.20%2d - %1d - ", ntptag, ntpmon, ntpjahr, ntpwd);          
   Serial.print(lcdausg2);    
   sprintf(lcdausg2,"%2d:%2d:%2d", ntphr, ntpmn, ntpsc);
   if(lcdausg2[3] == ' ')lcdausg2[3] = '0';
   if(lcdausg2[6] == ' ')lcdausg2[6] = '0';
   Serial.println(lcdausg2);

}

//###### Unix zeit auf Reale Variablem umsetzen
void ntpaufreal( uint32_t second)
{
    uint16_t day;
    uint8_t  year;
    uint16_t dayofyear;
    uint8_t  leap400;
    uint8_t  month;

    ntpsc = second % 60;
    second      /= 60;
    ntpmn = second % 60;
    second      /= 60;
    ntphr   = second % 24;
    day       = second / 24;
    ntpwd = (day + FIRSTDAY) % 7;             // weekday

    year = FIRSTYEAR % 100;                     // 0..99
    leap400 = 4 - ((FIRSTYEAR - 1) / 100 & 3);  // 4, 3, 2, 1

    for(;;)
    {
        dayofyear = 365;
        if( (year & 3) == 0 )
        {
            dayofyear = 366;                    // leap year
            if( year == 0 || year == 100 || year == 200 ) // 100 year exception
                if( --leap400 )                 // 400 year exception
                    dayofyear = 365;
        }
        if( day < dayofyear )
            break;
        day -= dayofyear;
        year++;                                 // 00..136 / 99..235
    }
    ntpjahr = year + (int)(FIRSTYEAR / 100) * 100;     // + century
    ntpjahr = ntpjahr - 2000;                   // korrektur da die RTC nur Zweistellig ist

    if( dayofyear & 1 && day > 58 )             // no leap year and after 28.2.
        day++;                                  // skip 29.2.

    for( month = 1; day >= getMonthLen(month-1); month++ )
        day -= getMonthLen(month-1);

    ntpmon = month;                           // 1..12
    ntptag   = day + 1;                         // 1..31
}


//###########################################  RTC #####################
void readRTC(){

RTC.getTime(&time);
  
  
// einlesen der Zeit und Datumswerte auf lokale Variablen
  rtctag = time.getDay();         //  Ausgabe der RTC auf LCD
  rtcmon = time.getMonth();
  rtcjahr = time.getYear();
  rtcwd = time.getWeekday();   // das Gegenstueck ist setWeekday
  rtchr = time.getHour();
  rtcmn = time.getMinute();
  rtcsc = time.getSecond();
}

//################# RTC Serielle Konsole ausgeben
void rtcSerial()
{
  
// Ausgabe der Daten auf die Serielle Schnittstelle
   sprintf(lcdausg2,"RTC: %2d.%d.20%2d - %1d - ", rtctag, rtcmon, rtcjahr, rtcwd);          
   Serial.print(lcdausg2);    
   sprintf(lcdausg2,"%2d:%2d:%2d", rtchr, rtcmn, rtcsc);
   if(lcdausg2[3] == ' ')lcdausg2[3] = '0';
   if(lcdausg2[6] == ' ')lcdausg2[6] = '0';
   Serial.println(lcdausg2);
}


  
  
//################# RTC auf LCD Zeile 2 ausgeben
void rtcLCD()
{
//  lcd.setCursor(0,1 );
//
//if(dattoggle == 0 & di >= 4){
// dattoggle = 1;
// di = 0;
// }
//if(dattoggle == 1 & di >= 2){
// dattoggle = 0;
// di = 0;
// }
//di++;
//
//   if(dattoggle == 0){
//   lcd.setCursor(0, 1);
//   sprintf(lcdausg2,"%2d.%d. ", rtctag, rtcmon);          
//   lcd.print(lcdausg2);    
//   }
//   else {
//   lcd.setCursor(0,1);
//  sprintf(lcdausg2,"20%2d    ", rtcjahr);          
//  lcd.print(lcdausg2);
//   }
  lcd.setCursor(8,1 );
  sprintf(lcdausg2,"%2d:%2d:%2d", rtchr, rtcmn, rtcsc);
  if(lcdausg2[3] == ' ')lcdausg2[3] = '0';
  if(lcdausg2[6] == ' ')lcdausg2[6] = '0';
  lcd.print(lcdausg2);


}  

  

//######## RTC setzen
// Uhrzeit im RTC-Chip setzen

void writeRTC()
{
//RTC.getTime(&time);  
//##### improvisiertes RTC setzen
//  ntptag = time.getDay();         //  Ausgabe der RTC auf LCD
//  ntpmon = time.getMonth();
//  ntpjahr = time.getYear();
//  ntpwd = time.getWeekday();   // das Gegenstueck ist setWeekday
//  rtchr = time.getHour();
//  rtcmn = time.getMinute();
//  rtcsc = time.getSecond();

//ntptag = 29;
time.setDay(ntptag);
time.setMonth(ntpmon);
time.setYear(ntpjahr);
time.setWeekday(ntpwd);
time.setHour(ntphr);
time.setMinute(ntpmn);
time.setSecond(ntpsc);


//DateTime time = DateTime(ntpjahr, ntpmon, ntptag, DateTime::Weekday, ntphr, ntpmn, ntpsc);
  
RTC.setTime(&time);
}


//###########################################  RTC Trimmung #####################
void readRTCtrimm(){

RTC.getTimeTrimming(&trimmwert);
}


void writeRTCtrimm(){
  
RTC.setTimeTrimming(trimmwert);
}

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

Theoretisch müßte der Code so laufen, also ich hatte da einen Arduino Ethernet und das RTC Modul von elv und ein LCD Keypad Shield gestappelt OHNE DCF77. Was ich gerade nicht mehr weiß wie die I2C Adresse von dem RTC Modul eingestell wurde....evtl. ist das in der Lib von elv eingestellt.
Vielleicht kannst da ja evtl. Teile daraus aufgreifen wo dir weiterhelfen.
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
18.07.2014, 06:55 (Dieser Beitrag wurde zuletzt bearbeitet: 18.07.2014 06:59 von fp.blues2013.)
Beitrag #23
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
Huhu Bitklopfer Smile

Danke für den Code und die Infos Smile) freu mich riesig Smile

Soooo Smile Hier mal das soweit fertige und funktionierende Script der DCF-RTC mit anschließender Syncronisierung durch die DCF77 Zeit + Ausgabe auf dem Seriellen 4x20 Display. Beide Komponenten werden über I2C angesprochen Smile) Vielleicht könnt Ihr das ja gebrauchen. Ist sicher nicht ganz perfekt, aber ich bin ja noch neu Smile

Die DCF-RTC ist vom ELV, und ich habe nur die kleine DCF77 Platine und die Auswertplatine miteinander verbunden. Das Shield außen rum habe ich weggelassen.

/******************************************************************************
Beispiel: setTime

Beschreibung: Dieses Beispiel zeigt das Schreiben und Lesen der Uhrzeit aus
dem RTC-DCF, mit aktualisierung durch das DCF77 Signal und Ausgabe
auf dem seriellen Monitor sowie auf einem 4x20 Zeichen LCD Display.

Hinweis: Zur Einstellung des Kommunikationswegs (UART, SPI oder I2C) zum
RTC-DCF enthält die Library die Datei RTC_DCF_config.h im
Unterordner \libraries\RTC_DCF\config\. Innerhalb dieser Datei
kann der Kommunikationsweg umgestellt werden.
******************************************************************************/
#include <stdio.h>
#include "DateTime.h"
#include "RealTimeClock_DCF.h"

/* leider setzt die Arduino-IDE voraus, dass alle in einem Projekt verwendeten
Klassen auch ins Sketch übernommen werden. Wird dieses nicht berücksichtigt,
kommt es zu Fehlern beim Linken des Programms. Daher muss an dieser Stelle
die Headerdatei zu der jeweils verwendeten Kommunikationsklasse eingefügt
werden. Die beiden jeweils nicht verwendeten Header müssen auskommentiert
werden. */

/* für die Kommunikation über UART die modSoftwareSerial.h verwenden */
// #include "modSoftwareSerial.h"

/* für die Kommunikation über SPI die SPI.h verwenden */
//#include "SPI.h"

/* für die Kommunikation über Wire die Wire.h verwenden */
#include "Wire.h"

#include <LiquidCrystal_I2C.h>

/******************************************************************************
globale Variablen
******************************************************************************/
/* einzustellende Uhrzeit */
DateTime dateTime = DateTime(14, 1, 1, DateTime::SUNDAY, 0, 0, 0);

/******************************************************************************
Funktionen
******************************************************************************/
// Setzen der LCD I2C Adresse auf 0x27 für das 4 x 20 Zeichen Display
// Setzen der Pins des I2C Bausteins ( Backpack auf dem LCD Display ) für die Verbindung zum Display:
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

/******************************************************************************
Einmalige Ausführung
******************************************************************************/

void setup()
{
/* der RTC-DCF benötigt ca. 1,5 Sekunden bis er Daten empfangen kann */
delay(1500);

/* RTC-DCF initialisieren */
RTC_DCF.begin();

/* Uhrzeit im RTC-DCF setzen */
RTC_DCF.setDateTime(&dateTime);

/* die serielle Ausgabe initialisieren */
Serial.begin(115200);
while (!Serial) ; // warten bis der Arduino Serial Monitor geeöffnet wird

/* DCF77-Empfang aktivieren */
RTC_DCF.enableDCF77Reception();
/* aktiviert, dass die LED bei einem DCF77-Empfangs-Interrupt
ein- bzw. nach ausschalten des Interrupts wieder ausgeschaltet wird. */
RTC_DCF.enableDCF77LED();

Wire.begin();

lcd.begin(20,4); // Initialisierung des LCD Displays auf 20 Zeichen und 4 Zeilen, Einschalten der Hintergrundbeleuchtung

// -------- Startmeldung auf dem LCD Display ------------------
// Anmerkung: Das Display startet in Zeile 0 ( die erste Zeile )

lcd.setCursor(0,0); //Start at character 4 on line 0
lcd.print("Datum und DCF77-Zeit");
delay(300);
lcd.setCursor(0,1);
lcd.print(" mit Atmega168 ");
delay(300);
lcd.setCursor(0,2);
lcd.print(" DonnerBlitz ");
lcd.setCursor(0,3);
delay(300);
lcd.print(" und Funkenflug ");
delay(8000);
lcd.clear();

}
/*--(Ende setup )---*/

/******************************************************************************
kontinuierliche Ausführung
******************************************************************************/
void loop()
{
/* ca. jede Sekunde wird die Uhrzeit ausgelesen und über die serielle Schnittstelle
ausgegeben. */
delay(1000);

RTC_DCF.getDateTime(&dateTime);

printClock();
}
void printClock(void)
{
char clockString[40];

sprintf(clockString, "Heute ist: %01u, der %02u:%02u:20%02u um %02u.%02u.%02u ", dateTime.getWeekday(), dateTime.getDay(), dateTime.getMonth(), dateTime.getYear(), dateTime.getHour(), dateTime.getMinute(), dateTime.getSecond());

Serial.println(clockString);

int weekDay = dateTime.getWeekday(); // Zuordnung int für die Ausgabe am LCD Display
int monthDay = dateTime.getDay();
int month = dateTime.getMonth();
int year = dateTime.getYear();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();

/* Ausdruck von Wochentag, Datum und Uhrzeit

Montag, der
27.01.2011
23:59:59

*/

lcd.setCursor(0,0); //Starte in Zeile 0, bei Zeichen 0

if (weekDay == 0) lcd.print("Montag"); // Wochentag Zuordnung
if (weekDay == 1) lcd.print("Dienstag");
if (weekDay == 2) lcd.print("Mittwoch");
if (weekDay == 3) lcd.print("Donnerstag");
if (weekDay == 4) lcd.print("Freitag");
if (weekDay == 5) lcd.print("Samstag");
if (weekDay == 6) lcd.print("Sonntag");

lcd.print(", der");
lcd.setCursor(0,1);
if (monthDay<10) lcd.print("0"); // Ergänzung der führenden Nullen bei Bedarf
lcd.print(monthDay);
lcd.print(".");
if (month<10) lcd.print("0");
lcd.print(month);
lcd.print(".");
if (year <99) lcd.print("20");
lcd.print(year);
lcd.setCursor(0,2);
if (hour<10) lcd.print("0");
lcd.print(hour);
lcd.print(":");
if (minute<10) lcd.print("0");
lcd.print(minute);
lcd.print(":");
if (second<10) lcd.print("0");
lcd.print(second);

}
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.04.2015, 16:03 (Dieser Beitrag wurde zuletzt bearbeitet: 21.04.2015 16:05 von stevie72.)
Beitrag #24
RE: AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger
Guten Tag zusammen!

Ich arbeite auf einem MAC Book Pro und bei mir funktionieren die Beispiele wie zb.
das setTime.ino Skript gar nicht. Compilerfehler an Compilerfehler ..

Ein Anruf bei der ELV brachte Klärung.
Dort sagte man mir das der Compiler Fehler an der IDE Version des arduino für den MAC liegt.

Sehr sehr schade.

Meine bitte an Euch: Wenn es möglich ist, bitte kompiliert doch mal die Sourcen
auf der PC Version hier ist der link von der elv dazu:

http://files.elv.de/Assets/Produkte/13/1...o_demo.zip

Hier ist das Board auf der ELV Seite

http://www.elv.de/real-time-clock-dcf-mo...usatz.html

Wenns klappt bitte mit Software Version der arduino Software posten.

Wenn das funktioiniert werde ich wohl umsteigen auf PC.

Vielen Dank vorab für die Hilfe.

Stefan
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  mit if aus do-while oder while Schleife aussteigen Nafetz 6 124 05.12.2016 21:41
Letzter Beitrag: Pit
  Welche IDE? Arduini.cc oder .org Bilbo 1 209 17.10.2016 21:03
Letzter Beitrag: ardu_arne
  Ardublock übertragt nicht an IDE oder UNO R3 tobi83 5 357 16.10.2016 14:07
Letzter Beitrag: Pit
  DCF77 Empfänger paq 19 913 23.07.2016 17:16
Letzter Beitrag: rkuehle
  Programmspeicher auf i2c_EEPROM oder SD_Card erweitern? avoid 11 349 11.07.2016 15:46
Letzter Beitrag: avoid
  Empfänger RF 433 peterfried 6 367 10.06.2016 23:01
Letzter Beitrag: hotsystems
  IDE von .org oder .cc besser geeignet? Bit of Byte 4 451 01.03.2016 21:57
Letzter Beitrag: arduinopeter
  Pretzelboard oder C.Control Warmbronner 1 534 22.02.2016 20:14
Letzter Beitrag: hotsystems
  digitalOutputpin mit Taster an- oder ausschalten Raptor 2 576 26.12.2015 20:59
Letzter Beitrag: torsten_156
  werte vom MPU6050 gy521 bekommen max1798 0 464 18.12.2015 21:11
Letzter Beitrag: max1798

Gehe zu:


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