Telexforum.de

Hallo Fred,
das ist ja prima.
2 Wemos D1 Module hatte ich vor 14 Tagen bei https://de.aliexpress.com/item/1PCS-D1- ... 0.0.KSkwf2 bestellt. Konverter habe ich noch 2 rumliegen, da muß ich gucken ob es step-up oder step-down Konverter sind.

Hier gibt es übrigens auch noch ein Uhrenmodul, falls irgendwo mal kein WLAN verfügbar ist. https://de.aliexpress.com/item/RTC-DS13 ... 0.0.KSkwf2

Hallo zusammen,
bin auch an dem Thema dran.

• 12V Akku

• Step Up Converter

• WeMo R1

• H-Bridge

• Steckbrettchen zum Ausprobieren.

Bin gerade an der Sekundenzeigeransteuerung : umpolender 40V Impuls von 500ms Länge alle 1s.

Habe gelesen, die Uhr braucht einen Minutenimpuls von 2 Sekunden Länge.
Meine Überlegung ist , das Programm als „State Maschine“ zu programmieren.
Ich weiß nicht wie Fred das gemacht hat. Den Kot von mir poste ich dann hier.

Ich verwende stinknormalen C++ Code. Ich habe eine Klasse angelegt für die "Hauptuhr" (mit Ntp-Synchronisation alle paar Stunden, Sommerzeit-Umschaltung, usw), eine Klasse für die Ansteuerung der Nebenuhr (speichert, welche Uhrzeit gerade angezeigt wird, damit eine Art "Nachlaufsteuerung" möglich ist, sowie einige Standard-Bibliotheken (z.B. für die WLAN-Auswahl und Anmelde-Prozedur).
Allerdings habe ich mangels Bedarf auf eine Ansteuerung eines Sekundenzeigers verzichtet.

Hallo Fred,
der Interesse halber: wenn die Zeit um 1 Stunde zurückgestellt wird und da die mech. Uhr ziemlich langsam ist: stellst du 11 Stunden vor (+die Zeit vergangen ist um die Uhr vorzustellen) oder läßt du die Uhr 1 Stunde warten?
Rückwärtslauf ist ja nicht.
Grüße
Patrick

Ich stelle sie 11 Stunden vor.

tic-tac Test für den Sekundenzeiger.
Am Minuteneingang klappt es genauso... also reichen für den Minutenpuls in meinem Fall auch Impulse von 500ms Länge.

/************************************************************************************************
 * Programmname : h-bridge-clock.ino
 * Autor : Frank Ulbrich
 * Datum : 21.02.2018
 * **********************************************************************************************
 * Dieses Programm bezieht die Zeit via WIFI aus dem Internet von einem NTP Server 
 * Im Sekundentakt wird der Sekundenimpuls umgepolt.
 * Im Minutentakt wird der Minutentakt umgepolt.
 * Eine Status LED zeigt den Systemzustand an.
 * Daten werden via serielles Interface übertragen.
 * Eine statuspage soll via http abrufbar.
 * **********************************************************************************************
 * Variablen
 * **********************************************************************************************
 * Hardware : WeMos D1 R2
 *            L298N Modul
 *            
 *  Arduino DC Motor Control - PWM | H-Bridge | L298N  -  Example 01

    by Dejan Nedelkovski, www.HowToMechatronics.com
    http://howtomechatronics.com/tutorials/ ... -h-bridge/
*/

#define in1 D3                   // Schaltimpuls fuer Ausgang OUT2 links Sekunden
#define in2 D4                   // Schaltimpuls fuer Ausgang OUT2 links Sekunden
#define in3 D6                   // Schaltimpuls fuer Ausgang OUT3 rechts Minuten
#define in4 D7                   // Schaltimpuls fuer Ausgang OUT3 rechts Minuten
//#define button D5                // Taster
#define led1 D0                  // Status LED 

int rotDirection = 0;
int pressed = false;
int sekunden = 0;                 // Variable fuer Sekunde
int minuten  = 0;                 // Variable fuer Minuten
int stunden  = 0;                 // Variable fuer Sttunden
int t     = 1;                    // Zustand tick/tack

int ledState = LOW;  
unsigned long previousMillis = 0;
const long interval = 1000;

/********************************************************
 * Initialisierung des Sytems
 */
void setup() {
  // Hardwareausgaenge, -eingaenge setzen
  pinMode(in1, OUTPUT);          // Ausgabepin fuer OUT2 Sekundenpuls
  pinMode(in2, OUTPUT);          // Ausgabepin fuer OUT2 Sekundenpuls
  pinMode(in3, OUTPUT);          // Ausgabepin fuer OUT3 Minutenpuls
  pinMode(in4, OUTPUT);          // Ausgabepin fuer OUT3 Minutenpuls
//  pinMode(button, INPUT);        // Eingabepin fuer Taster
  pinMode(led1, OUTPUT);         // Ausgabepin fuer LED
  
  // Grundzustand der Ausgabepins
  digitalWrite(in1, LOW);        // Resultat kein Strom auf OUT2
  digitalWrite(in2, LOW);        // Resultat kein Strom auf OUT2
  digitalWrite(in3, LOW);        // Resultat kein Strom auf OUT3
  digitalWrite(in4, LOW);        // Resultat kein Strom auf OUT3
  digitalWrite(led1,LOW);        // Ausgabepin fuer LED

  //Serial.begin(115200);

}

void loop() 
{
  unsigned long currentMillis = millis();//Timer abfragen
  
  if(currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;   
    if (ledState == LOW){                 //TICK
      ledState = HIGH;  // Note that this switches the LED *on*
      digitalWrite(in1, HIGH);
      digitalWrite(in2, LOW);
      delay(500);
      digitalWrite(in1, LOW);
      digitalWrite(in2, LOW); 
      //Serial.println(ledState);
    }
    else {                                 //TACK
      ledState = LOW;   // Note that this switches the LED *off*
      digitalWrite(in1, LOW);
      digitalWrite(in2, HIGH);
      delay(500);
      digitalWrite(in1, LOW);
      digitalWrite(in2, LOW);
      //Serial.println(ledState);
    }
    sekunden = sekunden +1;           // Sekundenzaehler hochzaehlen  
    digitalWrite(led1, ledState);     // LED schalten
    //Serial.println(sekunden);
  } // Ende der Zeitschleife
} // Ende loop

Andere Ansteuerpins

/************************************************************************************************
 * Programmname : WeMo_Tochter_Uhr.ino
 * Autor : initial Bernhard Lueck, Frank Ulbrich
 * Datum : 24.02.2018
 * **********************************************************************************************
 * Zeile : 
 * Dieses Programm bezieht die Zeit via WIFI aus dem Internet von einem NTP Server 
 * Im Sekundentakt wird der Sekundenimpuls mit umgepolt . Impulslaenge : 500ms
 * Im Minutentakt wird der Minutentakt umgepolt. Impulslaenge : 500ms
 * Eine Status LED sollt den Systemzustand anzeigen.
 * Daten werden via serielles Interface übertragen.
 * Eine statuspage soll via http abrufbarverden
 * Ausgabe auf serielle Schnittstelle mit 115200 Baud
 * **********************************************************************************************
 * Variablen
 * **********************************************************************************************
 * Hardware : WeMos D1 R2
 *            L298N Modul
 *            
 *  Arduino DC Motor Control - PWM | H-Bridge | L298N  -  Example 01

    by Dejan Nedelkovski, www.HowToMechatronics.com
    http://howtomechatronics.com/tutorials/ ... -h-bridge/

    ####################### Portmanipulation ############################
    http://www.esp8266.com/viewtopic.php?p=63612#p63612
*/

//define port letter and pin number
#define SEC_IN1 D1            // Schaltimpuls fuer Ausgang OUT2 links Sekunden
#define SEC_IN2 D2            // Schaltimpuls fuer Ausgang OUT2 links Sekunden
#define MIN_IN1 D6            // Schaltimpuls fuer Ausgang OUT3 rechts Minuten
#define MIN_IN2 D7            // Schaltimpuls fuer Ausgang OUT3 rechts Minuten

#define SEC_MASK ((1 << SEC_IN1) | (1 << SEC_IN2))    // PINs fuer Sekundentakt
#define MIN_MASK ((1 << MIN_IN1) | (1 << MIN_IN2))    // PINs fuer Minutentakt
#define SEC_MIN_MASK (SEC_MASK | MIN_MASK)

typedef struct {
  unsigned long wait_tme;     // Wartezeit fuer naechste Aktion
  unsigned long prv_state;    // Voherige Status
  unsigned char state;        // Status
} clk_pin;

clk_pin v_sec, v_min;
unsigned long ms_timer;        // ms des internen Zeitgebers (timer)
unsigned char sec_counter;     // Sekundenzaehler
unsigned int  min_counter;     // Minutenzaehler

void show_bins(unsigned char sec, unsigned long pt) {
  Serial.print("(");
  Serial.print(millis());      // Systemtimer ausgeben
  Serial.print(") : ");
  for (int i=31; i>=0; i--) {
    Serial.write((pt & (1 << i) ? '1' : '0'));
  }
  Serial.println("");
}

void setup() {
   // put your setup code here, to run once:
   Serial.begin(115200);

   // preset IO pins to Low
   GPO  &=  ~SEC_MIN_MASK;
   // set port pins to output
   GPF(SEC_IN1) = GPFFS(GPFFS_GPIO(SEC_IN1));
   GPC(SEC_IN1) = (GPC(SEC_IN1) & (0xf << GPCI));
   GPF(SEC_IN2) = GPFFS(GPFFS_GPIO(SEC_IN2));
   GPC(SEC_IN2) = (GPC(SEC_IN2) & (0xf << GPCI));
   GPF(MIN_IN1) = GPFFS(GPFFS_GPIO(MIN_IN1));
   GPC(MIN_IN1) = (GPC(MIN_IN1) & (0xf << GPCI));
   GPF(MIN_IN2) = GPFFS(GPFFS_GPIO(MIN_IN2));
   GPC(MIN_IN2) = (GPC(MIN_IN2) & (0xf << GPCI));
   GPE  |=  SEC_MIN_MASK;

   //PORTB &= ~SEC_MIN_MASK;    // geht beim ARDUINO, nicht beim WeMo
   //DDRB  |=  SEC_MIN_MASK;

   v_sec.prv_state = (1 << SEC_IN1);
   v_min.prv_state = (1 << MIN_IN1);
   v_min.state = 0;                   // Status : Minute noch nicht um
   v_sec.state = 0;                   // Status : Sekunde nich nicht um
}

void loop() {
  // put your main code here, to run repeatedly:
 
  // SEKUNDE TICK / TACK
  if (v_sec.state == 1) {
    v_sec.state = 2;
    v_sec.prv_state ^= SEC_MASK;
//    PORTB &= ~SEC_MASK;
//    PORTB |= v_sec.prv_state;
    GPO &= ~SEC_MASK;                   // Pinout Zustand inverieren
    GPO |= v_sec.prv_state;
    v_sec.wait_tme = millis() + 500L;   // Wartezeit zur Abschaltung auf LOW/LOW auf 500ms setzen
//  show_bins(sec_counter, PORTB);
    show_bins(sec_counter, GPO);        // Varibale mit Zustand fuer debug Anzeige
  }

  //SEKUNDE IMPULS AUS
  if ((v_sec.state == 2) && (millis() > v_sec.wait_tme)) {
    v_sec.state = 0;
    //PORTB &= ~SEC_MASK;
    GPO &= ~SEC_MASK;                   // Pinout Zustand : Impuls abschalten
//  show_bins(sec_counter, PORTB);
    show_bins(sec_counter, GPO);
  }
  
  //MINUTE TICK / TACK
  if (v_min.state == 1) {
    v_min.state = 2;
    v_min.prv_state ^= MIN_MASK;
  //PORTB &= ~MIN_MASK;
  //PORTB |= v_min.prv_state;
    GPO &= ~MIN_MASK;
    GPO |= v_min.prv_state;

    
    v_min.wait_tme = millis() + 500L; // Wartezeit zur Abschaltung auf LOW/LOW auf 500ms setzen
//  v_min.wait_tme = millis() + 2000L;
//  show_bins(sec_counter, PORTB);
    show_bins(sec_counter, GPO);
  }

  //MINUTE IMPULS AUS
  if ((v_min.state == 2) && (millis() > v_min.wait_tme)) {
    v_min.state = 0;     // Auf status zurueckstellen: Minute noch nicht um 
  //PORTB &= ~MIN_MASK;
    GPO &= ~MIN_MASK;
//  show_bins(sec_counter, PORTB);
    show_bins(sec_counter, GPO);

  }

  if (millis() > ms_timer) {
    ms_timer += 1000L;
    sec_counter++;
    v_sec.state = 1;      // Sekunde wurde hochgezaehlt
    if (sec_counter == 60) {
      min_counter++;      
      v_min.state = 1;    // Minute wurde hochgezaehlt
      sec_counter = 0;
      if (min_counter == 12) {
        min_counter = 0;  // Stunde ist um. 
      }
    }
  }
}