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
Uhrzeit einer Variable zuweisen?
17.02.2015, 12:13
Beitrag #1
Question Uhrzeit einer Variable zuweisen?
Hallo,

Ich beschäftige mich erst seid kurzem mit dem Arduino und finde die Möglichkeiten echt spannend. Leider gestaltet sich der Einstieg für mich aufgrund mangelnder Vorkenntnisse etwas schwierig und hoffe das ich mit meiner Frage hier richtig bin.

Also ich möchte einer Variable eine Uhrzeit zuweisen. Wenn ich dies aber mache, erhalte ich unteranderem folgenden Komplilierungsfehler.


Zitat:myEconLuxDimm.ino.ino:4:27: error: expected ',' or ';' before ':' token

Was mache ich falsch?

Weiterhin würde ich gerne wissen wie ich wenn ich die Uhrzeit der Variable zugewiesen habe diese erhöhen kann (z.B. 2 Sekunden oder so Ähnlich)

Code:
//##################### Bitte in diesem Bereich die gewünschten Zeiten eingeben. #####################\\
// Bitte darauf achten das sich die Start-/Dimm-/Stopzeiten nicht überschneiden!

int StartMorgens      =  8:0:0;                                  // Bitte die Startzeit für morgens eingeben.
int StartMorgensDimm  =  120;                                    // Anzahl der Minuten die für den kompletten Dimmvorgang genutzt werden soll.
int StopMittag        =  12:0:0;                                 // Bitte die Stoppzeit für die Mittagspause eingeben. Sollte diese Pause nicht gewünscht sein bitte leer lassen.
int StopMittagDimm    =  10;                                     // Anzahl der Minuten die für den kompletten Dimmvorgang genutzt werden soll.Sollte diese Pause nicht gewünscht sein bitte leer lassen.
int StartNachmittag   =  14:0:0;                                 // Bitte die Startzeit nach der Mittagspause eingeben. Sollte diese Pause nicht gewünscht sein bitte leer lassen.
int StartNachmDimm    =  10;                                     // Anzahl der Minuten die für den kompletten Dimmvorgang genutzt werden soll.
int StopAbend         =  20:0:0;                                 // Bitte die Stoppzeit für den Abend eingeben.
int StopAbendDimm     =  120;                                    // Anzahl der Minuten die für den kompletten Dimmvorgang genutzt werden soll.

//############################  Keine Änderungen nach dieser Zeile nötig. ############################\\

#include <DS1307RTC.h>                                          // Importiert die benannte Bibliothek
#include <Wire.h>                                               // Importiert die benannte Bibliothek
#include <Time.h>                                               // Importiert die benannte Bibliothek

void setup(){                                                   // Ausführung bei Initialisierung (Start) des Arduino
  tmElements_t tm;                                              // Dient als Variable
  Serial.begin(9600);                                           // Startet Serielle Schnittstelle mit 9600 Baud
  while (!Serial) ;                                             // Wartet auf Serielle Schnittstelle
  delay(200);                                                   // 200 Millisekunen verzögerung
  setSyncProvider(RTC.get);                                     // Bezieht die aktuelle Uhrzeit vom RTC Modul
  pinMode(11, OUTPUT);                                          // Defniert den dimmbaren Ausgang
  digitalWrite(11,LOW);
  int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second;   // Definiert die Variable "Now" mit Stunde : Minute : Sekunde
  if ((Now >= 8:0:10 ) && (Now <= 11:59:0)){                   // Wenn die Uhrzeit größer **:**:** UND kleiner als **:**:**
    analogWrite(11,0);                                         // Dann schreibe 0, (bedeutet 100% Beleuchtung) auf den definierten Ausgang.
    Serial.println("Beleuchtung nach Ausfall auf 100%");       // Hinterlasse angegebenen Kommantar im Seriellen Monitor
  } else if ((Now >= 12:0:10 ) && (Now <= 13:59:0)){           // Wenn die Uhrzeit größer **:**:** UND kleiner als **:**:**
    analogWrite(11,256);                                       // Schreibt auf 256, bedeutet 0% Beleuchtung auf den Ausgang
    Serial.println("Beleuchtung nach Ausfall auf 0%");         // Hinterlasse angegebenen Kommantar im Seriellen Monitor
  } else if ((Now >= 14:0:10 ) && (Now <= 19:59:0)){           // Wenn die Uhrzeit größer **:**:** UND kleiner als **:**:**
    analogWrite(11,0);                                         // Schreibt auf 0, bedeutet 100% Beleuchtung auf den Ausgang
    Serial.println("Beleuchtung nach Ausfall auf 0%");         // Hinterlasse angegebenen Kommantar im Seriellen Monitor  
  } else if ((Now >= 20:0:10 ) && (Now <= 7:59:0)){            // Wenn die Uhrzeit größer **:**:** UND kleiner als **:**:**
    analogWrite(11,256);                                       // Schreibt auf 256, bedeutet 0% Beleuchtung auf den Ausgang
    Serial.println("Beleuchtung nach Ausfall auf 0%";)         // Hinterlasse angegebenen Kommantar im Seriellen Monitor    
  }    
}

void loop(){
tmElements_t tm;                                              // Dient als Variable
  if(RTC.read(tm)){                                           // Wenn die aktuelle Uhrzeit ausgelesen werden kann
    delay(200);                                               // Dann *** Millisekunden warten
    int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second; // Definiert die Variable "Now" mit Stunde : Minute : Sekunde    
    Serial.println(Now);                                      // Ausgabe der ausgelesenen Uhrzeit an den Seriellen Monitor
        
    if(Now == 8:0:0){                                         // Wenn es die angegebene Uhrzeit ist,
      dimmHochMorgens();                                      // Gehe in den benannten Bereich
    }                                                         // Schliesst die IF Abfrage.
    if(Now == 12:0:0){                                        // Wenn es die angegebene Uhrzeit ist,
      dimmRunterMittags();                                    // Gehe in den benannten Bereich
    }                                                         // Schliesst die IF Abfrage.
    if(Now == 14:0:0){                                        // Wenn es die angegebene Uhrzeit ist,
      dimmHochMittags();                                      // Gehe in den benannten Bereich
    }                                                         // Schliesst die IF Abfrage.
    if(Now == 20:0:0){                                        // Wenn es die angegebene Uhrzeit ist,
      dimmRunterAbends();                                     // Gehe in den benannten Bereich
    }                                                         // Schliesst die IF Abfrage.
  }                                                           // Schliesst die IF Abfrage.
  void dimmHochMorgens(){                                     // Dieser Bereich (Scope) dimmt morgens zur definierten Uhrzeit das Licht an
    tmElements_t tm;                                          // Dient als Variable
    for(int i=256;i>=0;i--){                                  // Dazu wird der Variable "i" der Wert 256 zugewiesen und solange reduziert bis dieser <0 ist.
      analogWrite(11,i);                                      // Schreibt den aktuellen Wert der Variable auf den definierten Ausgang
      if(RTC.read(tm)){                                       // Liest immer die aktuelle Zeit aus
          delay(200);                                         // Nun *** Millisekunden warten
          int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second; // Definiert die Variable "Now" mit Stunde : Minute : Sekunde  
          Serial.println(Now && " - Dimme hoch. Dimmung von 256 (aus) bis 0 (an) - " && i);  // Hinterlasse angegebenen Kommantar im Seriellen Monitor
      }                                                       // Schliesst die IF Abfrage.
      int MyMilliSec = StartMorgensDimm  * 60 * 1000 / 256;   // Formel zum berechnen der benötigten Millisekunden per Dimmvorgang (Eingegebene Minuten multipiziert mal 60 (nun haben wir die Sekunen) multipiziert mal 1000 (nun haben wir die Millisekunen) geteilt durch 256 (Anzahl der Dimmsprünge)
      delay(MyMilliSec);                                      // Regelt die Schleifendauer, hierdurch bestimmt ihr wie lange es dauert bis fertig gedimmt ist. Die Zeit wird dabei in millisek angegeben. Dieser Dimmvorgang dauert somit 256*7 Sekunden. Hier könnt ihr eure eigene Wunschdauer reinschreiben, das könnt ihr bei allen delay(..) machen*/
     }                                                        // Schliesst die IF Abfrage.
  }                                                           // Schliesst die IF Abfrage.
  void dimmHochMittags(){    
    tmElements_t tm;                                           // Dient als Variable
    for(int i=256;i>=0;i--){                                   // Dazu wird der Variable "i" der Wert 256 zugewiesen und solange reduziert bis dieser <0 ist.
      analogWrite(11,i);                                       // Schreibt den aktuellen Wert der Variable auf den definierten Ausgang
      if(RTC.read(tm)){                                        // Liest immer die aktuelle Zeit aus
          delay(200);                                          // Nun *** Millisekunden warten
          int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second; // Definiert die Variable "Now" mit Stunde : Minute : Sekunde          
          Serial.println(Now && " - Dimme hoch. Dimmung von 256 (aus) bis 0 (an) - " && i);  // Hinterlasse angegebenen Kommantar im Seriellen Monitor
      }
      int MyMilliSec = StartNachmDimm * 60 * 1000 / 256;       // Formel zum berechnen der benötigten Millisekunden pr Dimmvorgang (Eingegebene Minuten multipiziert mal 60 (nun haben wir die Sekunen) multipiziert mal 1000 (nun haben wir die Millisekunen) geteilt durch 256 (Anzahl der Dimmsprünge)
      delay(MyMilliSec);                                       // Regelt die Schleifendauer, hierdurch bestimmt ihr wie lange es dauert bis fertig gedimmt ist. Die Zeit wird dabei in millisek angegeben. Dieser Dimmvorgang dauert somit 256*7 Sekunden. Hier könnt ihr eure eigene Wunschdauer reinschreiben, das könnt ihr bei allen delay(..) machen*/
     }
  }
  
  void dimmRunterMittags(){
    tmElements_t tm;                                            // Dient als Variable
    for(int i=0;i<=256;i++){                                    // Dazu wird der Variable "i" der Wert 0 zugewiesen und solange erhöht bis dieser 256 erreicht hat ist.
      analogWrite(11,i);                                        // Schreibt den aktuellen Wert der Variable auf den definierten Ausgang
        if(RTC.read(tm)){                                       // Liest immer die aktuelle Zeit aus
          delay(200);                                           // Nun *** Millisekunden warten
          int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second; // Definiert die Variable "Now" mit Stunde : Minute : Sekunde          
          Serial.println(Now && " - Dimme herunter. Dimmung von 0 (an) bis 256 (aus) - " && i);  // Hinterlasse angegebenen Kommantar im Seriellen Monitor
      }
      int MyMilliSec = StopMittagDimm * 60 * 1000 / 256;       // Formel zum berechnen der benötigten Millisekunden pr Dimmvorgang (Eingegebene Minuten multipiziert mal 60 (nun haben wir die Sekunen) multipiziert mal 1000 (nun haben wir die Millisekunen) geteilt durch 256 (Anzahl der Dimmsprünge)
      delay(MyMilliSec);                                       // Regelt die Schleifendauer, hierdurch bestimmt ihr wie lange es dauert bis fertig gedimmt ist. Die Zeit wird dabei in millisek angegeben. Dieser Dimmvorgang dauert somit 256*7 Sekunden. Hier könnt ihr eure eigene Wunschdauer reinschreiben, das könnt ihr bei allen delay(..) machen*/
     }
  }
  
  void dimmRunterAbends(){                                      // Diese Funktion dimmt Abends zur definierten Uhrzeit das Licht aus
    tmElements_t tm;                                            // Dient als Variable
    for(int i=0;i<=256;i++){                                    // Dazu wird der Variable "i" der Wert 0 zugewiesen und solange erhöht bis dieser 256 erreicht hat ist.
      analogWrite(11,i);                                        // Schreibt den aktuellen Wert der Variable auf den definierten Ausgang
        if(RTC.read(tm)){                                       // Liest immer die aktuelle Zeit aus
          delay(200);                                           // Nun *** Millisekunden warten
          int Now = tm.Hour && ":" && tm.Minute && ":" && tm.Second // Definiert die Variable "Now" mit Stunde : Minute : Sekunde          
          Serial.println(Now && " - Dimme herunter. Dimmung von 0 (an) bis 256 (aus) - " && i);  // Hinterlasse angegebenen Kommantar im Seriellen Monitor
      }
int MyMilliSec = StopAbendDimm * 60 * 1000 / 256 // Formel zum berechnen der benötigten Millisekunden pr Dimmvorgang (Eingegebene Minuten multipiziert mal 60 (nun haben wir die Sekunen) multipiziert mal 1000 (nun haben wir die Millisekunen) geteilt durch 256 (Anzahl der Dimmsprünge)
delay(MyMilliSec); // Regelt die Schleifendauer, hierdurch bestimmt ihr wie lange es dauert bis fertig gedimmt ist. Die Zeit wird dabei in millisek angegeben. Dieser Dimmvorgang dauert somit 256*7 Sekunden. Hier könnt ihr eure eigene Wunschdauer reinschreiben, das könnt ihr bei allen delay(..) machen*/
}
}
}
[/code]

Vielen Dank

Matze
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.02.2015, 16:22
Beitrag #2
RE: Uhrzeit einer Variable zuweisen?
Hallo Matze ,

int Variablen kann man Glanzzahlen von -32,768 bis 32,767 zuweisen.
Deswegen funktioniert das hier und andere ähnliche Zuweisungen in deinem Programm nicht:
Code:
int StartMorgens      =  8:0:0;                                  // Bitte die Startzeit für morgens eingeben.

Schau dir bitte die verwendbaren Datentypen an.
Es ist auch möglich daraus Strukturen zu bilden, welche dein Zeitformat aufnehmen können.

Für den Anfänger aber einfacher zu handhaben ist vermutlich die Verwendung je einer int-Variablen für Stunde, Minute und Sekunde.

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.02.2015, 17:00
Beitrag #3
RE: Uhrzeit einer Variable zuweisen?
Hallo Arne,

vielen Dank für deine Antwort.
wenn man korrekt liest ist das klar Confused Ich hatte die Hilfe so verstanden, dass das Int zum initialisieren der Variable ist. Das es sich aber um "Integer" also den Datentyp handelt war mir nicht bewusst.

Auch verstehe ich nicht gerade gar nicht die handhabe von Variablen bzw. wie ich diese nutzen kann.

In PS oder anderen Skriptsprachen kann ich Variablen definieren und einen bestimmten Wert zu weisen.

Wenn ich das jetzt richtig verstehe muss ich um mein Vorhaben umzusetzen String() nutzen korrekt?

Oder ich zerpflücke die Variablen so, was ich aber unschön finden würde.
Code:
//##################### Bitte in diesem Bereich die gewünschten Zeiten eingeben. #####################\\
// Bitte darauf achten das sich die Start-/Dimm-/Stopzeiten nicht überschneiden!
// Bitte die Startzeiten für morgens eingeben. 
int StartMorgensStd      =  8;                                  // Stunde
int StartMorgensMin      =  0;                                  // Minute
int StartMorgensSek      =  0;                                  // Sekunde
int StartMorgensDimm     =  120;                                // Anzahl der Minuten die für den kompletten Dimmvorgang genutzt werden soll.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.02.2015, 18:13
Beitrag #4
RE: Uhrzeit einer Variable zuweisen?
Hallo,

man kann auch für den Arduino Variablen definieren und einen bestimmten Wert zu weisen.

Code:
int StartMorgensStd;           // definiert eine int Variable mit dem Namen "StartMorgensStd"
int StartMorgensStd   =  8;    // definiert eine int Variable mit dem Namen "StartMorgensStd" und weist ihr den Wert 8 zu

Den Umweg über String() zu gehen würde ich nicht tun, das ergibt mehr umrechnerei zwischen den Formaten als dir lieb ist.

Eine Alternative wäre noch das Array.
Code:
int StartMorgens[3];               // definiert ein Array mit 3 int Variablen
int StartMorgens[3] = {8, 10, 15}; // definiert ein Array mit 3 int Variablen und weist 08:10:15 Uhr zu.

Um auf ein Element des Arrays zuzugreifen schreibt man:
StartMorgens[0]; für die Stundenvariable
StartMorgens[1]; für die Minutenvariable
StartMorgens[2]; für die Sekundenvariable

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Ausschaltverzögerung bei einer PV Heizung Hans_Maulwurf 27 736 29.11.2016 23:38
Letzter Beitrag: georg01
  Zahl von SD-Card Modul einlesen und Var. zuweisen Nafetz 13 298 28.10.2016 10:12
Letzter Beitrag: hotsystems
  Innenwiderstand einer Batterie (Rundzelle 1,5V) Einsteiger94 2 206 24.07.2016 11:42
Letzter Beitrag: SkobyMobil
  Gewichteten Durchschnitt berechnen, 20 Werte in fortlaufender Variable speichern TimeMen 10 475 03.07.2016 09:00
Letzter Beitrag: Binatone
  Brauche etwas Hilfe bei der Umsetzung einer Idee raspido 3 535 23.04.2016 10:26
Letzter Beitrag: rkuehle
  I2C Ansteuerung einer MSM3 (elv mp3 Box) Voreifel 2 315 09.04.2016 17:56
Letzter Beitrag: Voreifel
  Problem: SDFat - Das Ende einer Datei finden und Schleife beenden MartinK 4 490 01.04.2016 05:49
Letzter Beitrag: MartinK
  Problem: RFID code mit Inhalt einer Textdatei auf einer SD Karte vergleichen MartinK 6 514 29.03.2016 16:45
Letzter Beitrag: MartinK
  Inhalt einer Variable mit per Virtual Wire versenden toto1975 17 1.774 26.03.2016 18:57
Letzter Beitrag: hotsystems
  AKtuelle Uhrzeit bekommen, RTC oder DFC-Empfänger Cray-1 34 15.556 11.02.2016 23:49
Letzter Beitrag: hotsystems

Gehe zu:


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