Propleme beim Zeitgesteuerten Dimmen einer LED

[Johannes (Gast)]

Hallo an alle,

vorweg möchte ich sagen dass ich was den Arduino angeht ein absoluter 
Anfänger bin smiley Nachdem ich erst ein wenig mit meinem UNO 
rumexperimentiert habe, wollte ich nun mein erstes Programm schreiben.

Das Programm sollte z.B. Um 8.00 Uhr eine LED Lampe langsam hochdimmen 
(so über ne halbe stunde) und um 18Uhr wieder langsam runter. Nachdem 
ich durch jede Menge googeln den Arduino dazu bekommen habe die Uhrzeit 
(DS1307) auf meinem LCD anzuzeigen, stellt sich jetzt das Problem, dass 
ich nicht weiß wie ich beim Dimmen die delay Funktion umgehe weil dann 
ja sonst meine Uhr während des Dimmens stehen bleibt.

Das zweite ist dass ich nicht weiß wie ich den dann hochgedimmten 
ausgang dann angeschalten lasse obwohl er ja jede sekunde den loop 
wiederholt und die Zeit abruft.

Wenn mir jemand helfen kann, freue ich mich smiley

Grüße Bruzzzler





#include "LCD4Bit_mod.h"
#include "Wire.h"

int ledPin = 3;                                          // LED Pin 
setzen

#define DS1307_I2C_ADDRESS 0x68                          // I2C Adresse

char buffer[20] = "";                                    // 
Speicherbereich für Datenkonvertierung

LCD4Bit_mod lcd = LCD4Bit_mod(2);                        // LCD-Display

/*********************************************************************** 
*****************************
 * Konvertierung BCD-kodierter Dezimalzahl
 */
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

/*********************************************************************** 
*****************************
 * Zeit und Datum aus DS1307 auslesen und konvertieren
 */
void getDateDs1307(int date[])
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);         // 
I2C-Kommunikation im Schreibmodus starten
  Wire.write(0x00);                                   // Registerzeiger 
auf 0 setzen
  Wire.endTransmission();                             // 
I2C-Kommunikation beenden
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);            // 
I2C-Kommunikation im Lesemodus starten

  date[ 0 ] = bcdToDec(Wire.read() & 0x7f);        // Sekunden
  date[ 1 ] = bcdToDec(Wire.read());               // Minuten
  date[ 2 ] = bcdToDec(Wire.read() & 0x3f);        // Stunden
  date[ 3 ] = bcdToDec(Wire.read());               // Wochentag
  date[ 4 ] = bcdToDec(Wire.read());               // Tag
  date[ 5 ] = bcdToDec(Wire.read());               // Monat
  date[ 6 ] = bcdToDec(Wire.read());               // Jahr
}

/*********************************************************************** 
*****************************
 */
void setup() {
  Wire.begin();                                      // I2C-Bus 
einrichten

    lcd.init();                                      // LCD-Anzeige 
initialisieren
  lcd.clear();
  lcd.printIn( "DS1307 - Uhr" );


}

/*********************************************************************** 
*****************************
 */
void loop() {

  int datum[ 7 ];

  getDateDs1307( datum );                            // Datum und 
Uhrzeit aus DS1307 holen

  lcd.cursorTo(2, 0);                                // Datum und 
Uhrzeit in 2. Zeile schreiben

  if( datum[ 4 ] < 10 )
    lcd.printIn( "0" );
  lcd.printIn( itoa( datum[ 4 ], buffer, 10 ) );
  lcd.printIn( "." );
  if( datum[ 5 ] < 10 )
    lcd.printIn( "0" );
  lcd.printIn( itoa( datum[ 5 ], buffer, 10 ) );
  lcd.printIn( "." );
  /*
if( datum[ 6 ] < 10 )
   lcd.printIn( "0" );
   lcd.printIn( itoa( datum[ 6 ], buffer, 10 ) );
   */
  lcd.printIn( "  " );

  if( datum[ 2 ] < 10 )
    lcd.printIn( "0" );
  lcd.printIn( itoa( datum[ 2 ], buffer, 10 ) );
  lcd.printIn( ":" );
  if( datum[ 1 ] < 10 )
    lcd.printIn( "0" );
  lcd.printIn( itoa( datum[ 1 ], buffer, 10 ) );
  lcd.printIn( ":" );
  if( datum[ 0 ] < 10 )
    lcd.printIn( "0" );
  lcd.printIn( itoa( datum[ 0 ], buffer, 10 ) );
  lcd.printIn( "  " );

/*********************************************************************** 
*****************************
 Tageslichtsteuerung
*/

//Morgens

  if ( datum[ 2 ]  >= 10 )   // Stunde
  if ( datum[ 1 ] >= 2 )   // Minute
  if ( ledPin <1){
    for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
    analogWrite(3, fadeValue);
    delay(30);
  }
  }
{
  delay(1000);                                    // grobes 
Sekundenraster für Anzeige
}
}

[Karl H. (kbuchegg)]

Johannes schrieb:

> (DS1307) auf meinem LCD anzuzeigen, stellt sich jetzt das Problem, dass
> ich nicht weiß wie ich beim Dimmen die delay Funktion umgehe weil dann
> ja sonst meine Uhr während des Dimmens stehen bleibt.

Das hast du völlig richtig erkannt, dass dein delay das Problem ist.

Aber. Im Grunde ist das ja kein Problem. Du musst von deiner 
for-Schleife weg!

Denn:
Du weisst, dass du um 7:00 einen Dimmgrad von 0 haben sollst.
Liegt die Uhrzeit zwischen 7:00 und 7:01 dann brauchst du einen Dimmgrad 
von 1%.
Liegt die Uhrzeit zwischen 7:01 und 7:02, dann brauchst du einen 
Dimmgrad von 2%
etc. etc.

D.h. anstelle dass du in einer for-schleife durchdimmst, machst du
(Programmskizze)

void loop()
{

  if( Uhrzeit < 7 Uhr früh )
    Dimmgrad = 0

  else if( Urzeit < 7:01 früh )
    Dimmgrad = 1

  else if( Uhrzeit < 7:02 früh
    Dimmgard = 2

  ...
}

d.h. du siehst dir einfach bei jedem Aufruf von loop die aktuelle 
Uhrzeit an und leitest daraus her, wie der Dimmgrad zu dieser Uhrzeit 
sein muss. Da loop immer wieder erneut aufgerufen wird, verändert sich 
auch die dann jeweils festgestellte aktuelle Uhrzeit.

Hinweis: Du wirst natürlich nicht da jetzt 100 if-Abfragen machen, 
sondern dir überlegen, wie du aus der Uhrzeit den Dimmgrad ERRECHNEN 
kannst. Aber das Prinzip ist dasselbe: Die momentan aktuelle Uhrzeit 
verrät dir, wie die LED genau zu diesem Zeitpunkt gedimmt sein muss. Du 
musst dir nur überlegen, wie du das rechnen musst. Also: Papier und 
Bleistift raus und mal ein wenig rumgerechnet. Wenn du die Vorgabe hast, 
dass du einen Zahlenwert innerhalb von 30 Minuten von 0 auf 100 bringen 
sollst und ich frage dich, welcher Wert 11 Minuten und 43 Sekunden nach 
Beginn der ganzen Aktion dann vorliegt, wie berechnest du das?

> Das zweite ist dass ich nicht weiß wie ich den dann hochgedimmten
> ausgang dann angeschalten lasse obwohl er ja jede sekunde den loop
> wiederholt und die Zeit abruft.

Das Problem erledigt sich dann ganz von alleine :-)


(und ps: die delays schmeisst du alle raus. Versprochen?)

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:

> Hinweis: Du wirst natürlich nicht da jetzt 100 if-Abfragen machen,
> sondern dir überlegen, wie du aus der Uhrzeit den Dimmgrad ERRECHNEN
> kannst. Aber das Prinzip ist dasselbe: Die momentan aktuelle Uhrzeit
> verrät dir, wie die LED genau zu diesem Zeitpunkt gedimmt sein muss. Du
> musst dir nur überlegen, wie du das rechnen musst. Also: Papier und
> Bleistift raus und mal ein wenig rumgerechnet. Wenn du die Vorgabe hast,
> dass du einen Zahlenwert innerhalb von 30 Minuten von 0 auf 100 bringen
> sollst und ich frage dich, welcher Wert 11 Minuten und 43 Sekunden nach
> Beginn der ganzen Aktion dann vorliegt, wie berechnest du das?

Und noch ein Hinweis:
Die ganze Rechnung vereinfacht sich extrem, wenn du nicht mit einem 
bunten Mix aus Minuten und Sekunden an die Sache rangehst, sondern 
zuerst mal alles auf einen kleinsten gemeinsammen Nenner bringst. zb 
Sekunden.
30 Minuten sind 1800 Sekunden und 11 Minuten 43 sind 703 Sekunden.

Wenn also nach 1800 Sekunden ein bei 0 beginnender Wert 1800 erreicht 
haben soll, welchen Wert hast du dann nach 703 Sekunden?

-> Dreisatz.

[Johannes (Gast)]

OK super tipp. 100Stufen*703sek/1800sek = 39 Stufen

aber wie bekomm ich das ins programm weil das ja nur immer als uhrzeit 
10sekunden ausgiebt dann wieder von vorne anfängt?

[Karl H. (kbuchegg)]

Johannes schrieb:
> OK super tipp. 100Stufen*703sek/1800sek = 39 Stufen
>
> aber wie bekomm ich das ins programm weil das ja nur immer als uhrzeit
> 10sekunden ausgiebt dann wieder von vorne anfängt?

Ja, macht ja nichts.
Du hast eine andere Uhrzeit. Dann macht eben der µC mit dieser neuen 
Uhrzeit wieder dieselbe Berechnung, nur mit anderen Zahlenwerten. Dazu 
hat man ja Variablen, in denen diese Zahlenwerte stehen. Damit man

   a = b * 300 / c;

schreiben kann und je nachdem, welche WErte konkret in b bzw. c stehen, 
kommt dann ein anderes Ergebnis raus.

void loop() {

  int datum[ 7 ];

  getDateDs1307( datum );                            // Datum und Uhrzeit aus DS1307 holen


   .... jetzt hast du die aktuelle Uhrzeit.
   .... Mach was damit.
   .... Zb ausrechnen wie die LED genau jetzt, zu diesem Zeitpunkt
   .... gedimmt sein muss

   ....

[Karl H. (kbuchegg)]

Hier

  date[ 0 ] = bcdToDec(Wire.read() & 0x7f);        // Sekunden
  date[ 1 ] = bcdToDec(Wire.read());               // Minuten
  date[ 2 ] = bcdToDec(Wire.read() & 0x3f);        // Stunden

hast du dir die für den aktuellen Zeitpunkt relevanten Werte geholt.

Ergo

void loop()
{
  int datum[ 7 ];
  int licht;
  char str[30];

  getDateDs1307( datum );                            // Datum und Uhrzeit aus DS1307 holen

  // von Mitternacht bis 8 Uhr (7:59:59)
  // ist das Licht aus
  if( data[2] < 8 ) {
    licht = 0;
  }

  // von 8 Uhr, bis 8 Uhr 30 berechnet sich eine Dimmstufe
  // hochdimmen!
  else if( data[2] == 8 && data[1] < 30 ) {
    ....
    licht = ...... deine Formel
  }

  // von 8:30 bis 17:59:59 ist das Licht an
  else if( data[2] < 18 )
    Licht = 255;

  // von 6 bis halb 7 wird wieder eine Dimmstufe berechnet
  // aber diesmal runterdimmen!
  else if( data[2] == 18 && data[1] < 30 ) {
    ....
    licht = ....... deine Formel
  }

  // und für den Rest des Tages (kann dann nur noch nach halb 7 sein)
  // wird das Licht abgedreht
  else
    licht = 0;

  // jetzt noch schnell die Lampe tatsächlich anhand der
  // vorher bestimmten Werte einstellen
  analogWrite( 3, licht );

  // ... und der Benutzer will auch sehen wie spät es ist
  sprintf( str, "%02d-%02d-%02d  %02d:%02d:%02d,
                     data[4], data[5], data[6],
                     data[2], data[1], data[0] );
  lcd.cursorTo( 1, 0 );
  lcd.printIn( str );

  // ... bzw. er will auch sehen, wie hell es gerade sein sollte
  sprintf( str, "Lichtstufe: %3d", licht );
  lcd.cursorTo( 2, 0 );
  lcd.printIn( str );

  // und das wars für diesen Durchgang
  // in bälde wird loop() das nächste mal aufgerufen und dann
  // beginnt das ganze Spielchen wieder von vorne.
  // allerdings mit einer etwas anderen Uhrzeit :-)
}

[Johannes (Gast)]

Danke sehr für die geniale hilfe komm mir gerade vor wie ein depp aber 
bei mir kommen nur Fehlermeldungen :(

[Johannes (Gast)]

aber ich bastel einfach mal weiter ^^

[Karl H. (kbuchegg)]

Johannes schrieb:
> Danke sehr für die geniale hilfe komm mir gerade vor wie ein depp aber
> bei mir kommen nur Fehlermeldungen :(

Dann lies die Fehlermeldungen und behebe die Ursachen. Ein Fehler nach 
dem anderen. Fang bei der ersten Fehlermeldung an.

Ich tippe hier die Programme direkt ein. D.h. das kann schon sein, dass 
ich den einen oder anderen Tippfehler (und sei es nur eine 
Gross/Kleinschreibung) drinnen habe.
Das Ziel ist ja auch nicht, dass ich dir ein fertiges Programm liefere, 
dass du nur auf deinen µC brennen musst. Das Ziel ist, dass du verstehst 
wie und warum ich bestimmte Dinge tue und da das Prinzip verstehen und 
anwenden kannst. Und manchmal ist es nun mal einfacher, dieses Prinzip 
mit Code zu verdeutlichen anstelle das ich mir da den Mund fusselig 
rede.

(und deine Ausgabe war ja wirklich nicht sauber programmiert. Da gibt es 
einfachere Methoden, auch wenn die ein wenig Resourcen verbrauchen. Aber 
wer seinen µC 1 Sekunde lang Däumchen drehen lässt, kann es sich auch 
leisten den Komfort von sprintf in Anspruch zu nehmen)

[Karl H. (kbuchegg)]

Und noch was.

Hier

  else if( data[2] == 8 && data[1] < 30 ) {
    ....
    licht = ...... deine Formel
  }

wartet noch Arbeit auf dich. Das Erstellen der Berechnung nehm ich dir 
nämlich nicht ab. Etwas musst du schon auch dazutun.

[Johannes (Gast)]

ja schon klar aber trotzdem danke für deine Hilfe. ja sauber 
programmieren ist so ne sache :) Steh ja noch ganz am Anfang hab davor 
noch nie einen Controller programmiert

[Johannes (Gast)]

So hab jetzt alles fast am laufen und auch die Formel. Allerdings 
berechnet er die Lichtstufe falsch aber warum? Ich vermute das liegt 
daran dass ich nur minuten berechne und da auch nachkommastellen 
vorkommen

#include "LCD4Bit_mod.h" 
#include "Wire.h"

int ledPin = 3;                                          // LED Pin setzen

#define DS1307_I2C_ADDRESS 0x68                          // I2C Adresse

char buffer[20] = "";                                    // Speicherbereich für Datenkonvertierung 

LCD4Bit_mod lcd = LCD4Bit_mod(2);                        // LCD-Display

/****************************************************************************************************
 * Konvertierung BCD-kodierter Dezimalzahl
 */
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

/****************************************************************************************************
 * Zeit und Datum aus DS1307 auslesen und konvertieren
 */
void getDateDs1307(int date[])
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);         // I2C-Kommunikation im Schreibmodus starten
  Wire.write(0x00);                                   // Registerzeiger auf 0 setzen
  Wire.endTransmission();                             // I2C-Kommunikation beenden 
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);            // I2C-Kommunikation im Lesemodus starten

  date[ 0 ] = bcdToDec(Wire.read() & 0x7f);        // Sekunden
  date[ 1 ] = bcdToDec(Wire.read());               // Minuten
  date[ 2 ] = bcdToDec(Wire.read() & 0x3f);        // Stunden
  date[ 3 ] = bcdToDec(Wire.read());               // Wochentag
  date[ 4 ] = bcdToDec(Wire.read());               // Tag
  date[ 5 ] = bcdToDec(Wire.read());               // Monat
  date[ 6 ] = bcdToDec(Wire.read());               // Jahr
}

/****************************************************************************************************
 */
void setup() {
  Wire.begin();                                      // I2C-Bus einrichten

    lcd.init();                                      // LCD-Anzeige initialisieren
  lcd.clear();
  lcd.printIn( "DS1307 - Uhr" ); 
 
  
}

/****************************************************************************************************
 */
void loop() {

  int datum[ 7 ];  
  int licht;
  char str[30];
  
  
getDateDs1307( datum );                            // Datum und Uhrzeit aus DS1307 holen

int a = 255;
int b = datum[1]*60;
int c = 1800;


  // von Mitternacht bis 8 Uhr (7:59:59)
  // ist das Licht aus
  if( datum[2] < 8 ) {
    licht = 0;
  }

  // von 8 Uhr, bis 8 Uhr 30 berechnet sich eine Dimmstufe
  // hochdimmen!
  else if( datum[2] == 8 && datum[1] < 30 ) {
    licht = a * b / c;
  }

  // von 8:30 bis 17:59:59 ist das Licht an
  else if( datum[2] < 18 ){
    licht = 255;
  }
  // von 6 bis halb 7 wird wieder eine Dimmstufe berechnet
  // aber diesmal runterdimmen!
  else if( datum[2] == 18 && datum[1] < 30 ) {
    licht = a * b / c;
  }

  // und für den Rest des Tages (kann dann nur noch nach halb 7 sein)
  // wird das Licht abgedreht
  else
    licht = 0;

  // jetzt noch schnell die Lampe tatsächlich anhand der
  // vorher bestimmten Werte einstellen
  analogWrite( 3, licht );

   // ... und der Benutzer will auch sehen wie spät es ist
  sprintf( str, "%02d-%02d-%02d%02d:%02d:%02d",
                     datum[4], datum[5], datum[6],
                     datum[2], datum[1], datum[0] );
  lcd.cursorTo( 1, 0 );
  lcd.printIn( str );
  
  // ... bzw. er will auch sehen, wie hell es gerade sein sollte
  sprintf( str, "Lichtstufe: %3d", licht );
  lcd.cursorTo( 2, 0 );
  lcd.printIn( str );
}

[Johannes (Gast)]

Also ich meine jetzt beim hochdimmen beim Runterdimmen bin ich grad noch 
an der Formel

[Karl H. (kbuchegg)]

Johannes schrieb:
> So hab jetzt alles fast am laufen und auch die Formel. Allerdings
> berechnet er die Lichtstufe falsch aber warum? Ich vermute

vermute nicht. Du hast ein LCD. Auf dem kann man sich Werte ausgeben 
lassen, bzw. die Werte aus denen sie entstehen, wenn einem nicht klar 
ist, wie ein Wert zustande kommt.

Was bedeutet 'falsch'? Kommt 384 raus oder -38. Oder was?


> das liegt
> daran dass ich nur minuten berechne und da auch nachkommastellen
> vorkommen

Nichts und niemand hindert dich daran, dass du hier

  b = data[1] * 60;

auch noch die aktuellen Sekunden mit dazurechnest.

PS: Es ist immer gut, wenn man Variablen einen Namen gibt, der ihrer 
Funktion entspricht, denn nur durch betrachten von

    licht = a * b / c;

kann man nicht nachvollziehen, was du da eigentlich rechnest. Steht da 
aber


    licht = maximalLicht * DimmSekunde / GesamtDimmSekunden;

dann kann man das schon besser nachvollziehen. Und da im restlichen 
Programm momenan sowieso die maximale Helligkeit mit 255 vorgegeben ist 
und die Dauer der Dimmzeit mit 30 Minuten festgelegt ist, kannst du 
gerne auch hier

    licht = 255 * DimmSekunde / ( 60 * 30 );

schreiben, was das Lesen der Formel (momentan) vereinfacht.


PS:
Du wirst wohl hier

  else if( datum[2] == 8 && datum[1] < 30 ) {
    licht = a * b / c;
  }

und hier

  // von 6 bis halb 7 wird wieder eine Dimmstufe berechnet
  // aber diesmal runterdimmen!
  else if( datum[2] == 18 && datum[1] < 30 ) {
    licht = a * b / c;
  }

andere Formeln brauchen. Denn das eine mal wird das Licht ja heller 
(dimmt also von dunkel nach hell), während es am Abend genau in die 
andere Richtung dimmt: von hell nach dunkel. Das ist aber der genau 
gegensätzliche Vorgang, daher kann das nicht dieselbe Formel sein.

[Johannes (Gast)]

mit fehler meine ich dass zum beispiel bei 8:15  als Lichstufe -18 
rauskommt

[Johannes (Gast)]

Hab die Sekunden jetzt noch dazu genommen in meiner Rechnung allerdings 
keine änderung. Nach Lichtstufe 7 kommt 15 dann -5 und so weiter

[Karl H. (kbuchegg)]

Im übrigen ist es manchmal sehr erhellend, wenn man sich mal die
Berechnung rausgreift, Werte einsetzt und nachsieht, was da passiert

int b = datum[1]*60;


    licht = 255 * b / 1800;

Sagen wir mal b sei ganz am Anfang. Die Minuten seien also noch 0.
0 mal 60 macht 0      255*0/1800  macht   0/1800    macht 0

Ein WErt in der Mitte. Sagen wir 15 MInuten
15 mal 60 macht 900    255*900/1800  macht 229500/1800

                                             ^
                                             |
                                        möööp, möööp, mööp
                                        Overflow

Da ist ein Zwischenergebnis, welches den Bereich -32768 bis 32767
überschreitet.

Wenn du int rechnest, müssen auch alle Zwischenergebnisse im int Bereich
sein!

Ein long (32 Bit Ganzzahl) geht bis 2147483648. Da würden die 229500
nach reinpassen.
Was ist mit dem Extremwert von 30 Minuten?

30 mal 60 macht 1800. Das mal 255 macht 495000. Geht sich also auch noch
aus.

Also: macht man die Sekunden seit Beginn der Dimmung zu einem long
anstelle eines int, dann geht sich das aus

  long SekundenSeitDimmstart = data[1] * 60 + data[0];


...



   licht = 255 * SekundenSeitDimmstart / 1800;

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:

>    licht = 255 * SekundenSeitDimmstart / 1800;


Dadurch dass SekundenSeitDimmstart ein long ist, erzwinge ich, dass die 
Multiplikation mit 255 ebenfalls im Zahlenraum long gerechnet wird (also 
als 32 Bit Multiplikation), und damit kann dann auch das Ergebnis keinen 
Overflow mehr produzieren.

[Johannes (Gast)]

ja jetzt scheint es zu gehen :) Vielen Vielen Dank

Mach mich jetzt noch ans runter dimmen. Danke für die Hilfe und das 
dazugelernte wissen

[Karl H. (kbuchegg)]

Johannes schrieb:
> ja jetzt scheint es zu gehen :) Vielen Vielen Dank
>
> Mach mich jetzt noch ans runter dimmen.


Pst.
Runterdimmen ist im Prinzip der genau gleiche Vorgang gegengleich.
D.h. anstelle von 0 muss in deiner 'Formel' 255 rauskommen.
Anstelle von 1 muss 254 rauskommen
Anstelle von 2 muss 253 rauskommen
             3      252
             4      251
...

Merkst du was?   Die erste und die zweite Zahl ergeben addiert wieder 
die 255.

Wenn du also die Berechnung genau gleich wie im ersten Fall machst und 
dieses Ergebnis dann von 255 abziehst, dann .....

[Karl H. (kbuchegg)]

und schönen Gruß an deine Fische :-)
Das wird doch ein Aquariendimmer, oder nicht?

[Johannes (Gast)]

Ja solls Aquarium dimmen :) Super haut jetzt alles hin. Danke

[andi (Gast)]

Hallo habe auch ein problem mit meiner steuerung könnt ihr mir vll 
helfen?
ich weis nicht wie ich meinem board den befehl geb das wenn es zb 
8:00uhr ist das meine led auf pin 9 hochdimmt.
wäre voll nett wenn ihr mir helfen könnt.
MFG Andi

// 
######################################################################## 
#####
// #
// # Scriptname : DS1307_Test.pde
// # Author     : Peter Schmelzer, Oliver Kraus
// # Date       : 2011-04-08

// # Editor     : Lauren from DFRobot
// # Date       : 30.12.2011

// # Description:
// # Test file for the DS1307new library. Assumes that you have a DS1307
// # connected to the I2C-Bus of your Arduino and that it has a battery 
backup.
// # Update the library and sketch to compatible with IDE V1.0 and 
earlier

// # Version    : 1.0
// 
######################################################################## 
#####
// *********************************************
// INCLUDE
// *********************************************




#include <Wire.h>                       // For some strange reasons, 
Wire.h must be included here
#include <DS1307new.h>

// *********************************************
// DEFINE
// *********************************************

// *********************************************
// VARIABLES
// *********************************************
uint16_t startAddr = 0x0000;            // Start address to store in the 
NV-RAM
uint16_t lastAddr;                      // new address for storing in 
NV-RAM
uint16_t TimeIsSet = 0xaa55;            // Helper that time must not set 
again

// *********************************************
// SETUP
// *********************************************
void setup()
{
  pinMode(2, INPUT);                    // Test of the SQW pin, D2 = 
INPUT
  digitalWrite(2, HIGH);                // Test of the SQW pin, D2 = 
Pullup on

 int ledPin = 9; 
//INT------------------------------------------------------------------- 
--------
pinMode(ledPin, OUTPUT); 
//mode------------------------------------------------------------------ 
------


  Serial.begin(9600);

/*
   PLEASE NOTICE: WE HAVE MADE AN ADDRESS SHIFT FOR THE NV-RAM!!!
                  NV-RAM ADDRESS 0x08 HAS TO ADDRESSED WITH ADDRESS 
0x00=0
                  TO AVOID OVERWRITING THE CLOCK REGISTERS IN CASE OF
                  ERRORS IN YOUR CODE. SO THE LAST ADDRESS IS 0x38=56!
*/
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t));// Store 
startAddr in NV-RAM address 0x08

/*
   Uncomment the next 2 lines if you want to SET the clock
   Comment them out if the clock is set.
   DON'T ASK ME WHY: YOU MUST UPLOAD THE CODE TWICE TO LET HIM WORK
   AFTER SETTING THE CLOCK ONCE.
*/
//  TimeIsSet = 0xffff;
//  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));

/*
  Control the clock.
  Clock will only be set if NV-RAM Address does not contain 0xaa.
  DS1307 should have a battery backup.
*/
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));      // 54 
auf 55 stellen und datum + Zeiteinstellen
  if (TimeIsSet != 0xaa55)
  {
    RTC.stopClock();

    RTC.fillByYMD(2011,4,8);
    RTC.fillByHMS(22,7,0);

    RTC.setTime();
    TimeIsSet = 0xaa55;
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
    RTC.startClock();
  }
  else
  {
    RTC.getTime();
  }

/*
   Control Register for SQW pin which can be used as an interrupt.
*/
  RTC.ctrl = 0x00;                      // 0x00=disable SQW pin, 
0x10=1Hz,
                                        // 0x11=4096Hz, 0x12=8192Hz, 
0x13=32768Hz
  RTC.setCTRL();

  Serial.println("DS1307 Testsketch");
  Serial.println("Format is \"hh:mm:ss dd-mm-yyyy DDD\"");

  uint8_t MESZ;

  MESZ = RTC.isMEZSummerTime();
  Serial.print("MEZ=0, MESZ=1 : ");
  Serial.println(MESZ, DEC);
  Serial.println();
}

// *********************************************
// MAIN (LOOP)
// *********************************************
void loop()
{
  int ledPin = 9;      // hier ist mein 
Problem--------------------------------------------
pinMode(ledPin, OUTPUT);


RTC.getTime();

  if (time)
  {
    digitalWrite(ledPin, HIGH);
}

if ( 20 > DN_H )



  if (RTC.minute < 34)
{digitalWrite(ledPin, HIGH);
}

if (RTC.hour < 20)
{digitalWrite(ledPin, LOW);

}













            //mode bis hier 
------------------------------------------------------------------------



  RTC.getTime();
  if (RTC.hour < 10)                    // correct hour if necessary
  {
    Serial.print("0");
    Serial.print(RTC.hour, DEC);
  }
  else
  {
    Serial.print(RTC.hour, DEC);
  }
  Serial.print(":");
  if (RTC.minute < 10)                  // correct minute if necessary
  {
    Serial.print("0");
    Serial.print(RTC.minute, DEC);
  }
  else
  {
    Serial.print(RTC.minute, DEC);
  }
  Serial.print(":");
  if (RTC.second < 10)                  // correct second if necessary
  {
    Serial.print("0");
    Serial.print(RTC.second, DEC);
  }
  else
  {
    Serial.print(RTC.second, DEC);
  }
  Serial.print(" ");
  if (RTC.day < 10)                    // correct date if necessary
  {
    Serial.print("0");
    Serial.print(RTC.day, DEC);
  }
  else
  {
    Serial.print(RTC.day, DEC);
  }
  Serial.print("-");
  if (RTC.month < 10)                   // correct month if necessary
  {
    Serial.print("0");
    Serial.print(RTC.month, DEC);
  }
  else
  {
    Serial.print(RTC.month, DEC);
  }
  Serial.print("-");
  Serial.print(RTC.year, DEC);          // Year need not to be changed
  Serial.print(" ");
  switch (RTC.dow)                      // Friendly printout the weekday
  {
    case 1:
      Serial.print("MON");
      break;
    case 2:
      Serial.print("TUE");
      break;
    case 3:
      Serial.print("WED");
      break;
    case 4:
      Serial.print("THU");
      break;
    case 5:
      Serial.print("FRI");
      break;
    case 6:
      Serial.print("SAT");
      break;
    case 7:
      Serial.print("SUN");
      break;
  }
  Serial.print(" seconds since 1.1.2000:");
  Serial.print(RTC.time2000, DEC);
  uint8_t MESZ = RTC.isMEZSummerTime();
  Serial.print(" MEZ=0, MESZ=1 : ");
  Serial.print(MESZ, DEC);

  Serial.print(" - Address in NV-RAM is: ");
  RTC.getRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  Serial.print(lastAddr, HEX);
  lastAddr = lastAddr + 1;              // we want to use it as 
addresscounter for example
  RTC.setRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet == 0xaa55)              // check if the clock was set or 
not
  {
    Serial.println(" - Clock was set!");
  }
  else
  {
    Serial.println(" - Clock was NOT set!");
  }
  delay(1000);                          // wait a second
}