refactoring

src/clock.c

@@ -131,7 +131,7 @@ uint8_t clockNextStep() {
   }
 }
 
-uint8_t clockNextTack() {
+uint8_t clockNextBlink() {
   if (tack != 0) {
     tack = 0;
     return 1;

src/clock.h

@@ -29,7 +29,7 @@ void clockInit();
 opTime_t clockGetOpTime();
 
 uint8_t clockNextStep();
-uint8_t clockNextTack();
+uint8_t clockNextBlink();
 uint8_t clockNextSecond();
 uint8_t clockNextMinute();
 

src/dcf77.c

@@ -0,0 +1,401 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+#include "clock.h"
+#include "validLed.h"
+#include "stepper.h"
+#include "dcf77.h"
+
+
+
+
+void dcf77Init() {
+  // signal measurment
+  TCCR1A = 0;
+  TCCR1B = (1 << CS12) | (1 << CS10);
+
+  DDRD &= ~(1 << PD2);
+  DDRD &= ~(1 << PD3);
+  PORTD |= (1 << PD2) | (1 << PD3);
+  MCUCR |= (1 << ISC11) | (1 << ISC10) | (1 << ISC01);
+  GICR |= (1 << INT0) | (1 << INT1);
+
+  dcf77SetValid(0);
+
+}
+
+
+
+volatile uint8_t tick;
+volatile uint16_t captValue = 0;
+volatile uint16_t gapValue = 0;
+volatile uint8_t valid = 0;
+uint16_t validCnt = 0;
+uint16_t timeValidCnt = 0;
+
+
+
+
+
+ISR(INT0_vect) {
+  uint16_t tmpCnt = TCNT1;
+  gapValue = tmpCnt - captValue;
+  TCNT1 = 0;
+}
+
+ISR(INT1_vect) {
+  captValue = TCNT1;
+  tick = 1;
+}
+
+
+void dcf77SetValid(uint8_t x) {
+  valid = x;
+  validLedSetStatus(valid);
+  if (valid == 1) {
+    validCnt++;
+    clockSetUseLocalClock(1);
+  } else if (valid == 2) {
+    timeValidCnt++;
+    clockSetUseLocalClock(0);
+    stepperEnable();
+  } else {
+    clockSetUseLocalClock(1);
+  }
+}
+
+uint8_t getValid() {
+  return valid;
+}
+
+
+
+void dcf77Engine() {
+  static receivedData_t rd;
+  static uint8_t state = 0;
+  static uint8_t showState = 0;
+  uint8_t bit = 0;
+
+
+
+  if (tick != 0) {
+    tick = 0;
+
+    uint16_t pulse = (((uint32_t) captValue) * 1000) / 15625;
+    uint16_t gap = (((uint32_t) gapValue) * 1000) / 15625;
+
+    if (gap > START_GAP_MIN) {
+      if (valid == 0) {
+        dcf77SetValid(1);;
+      }
+      state = 0;
+      clockClearSecond();
+    }
+
+    if (pulse > ZERO_WIDTH_MIN && pulse < ZERO_WIDTH_MAX) {
+      bit = 0;
+    } else if (pulse > ONE_WIDTH_MIN && pulse < ONE_WIDTH_MAX) {
+      bit = 1;
+    } else {
+      bit = 2;
+      dcf77SetValid(0);;
+    }
+
+
+    if (valid > 0) {
+      switch (state) {
+      case 0:
+        if (bit != 0)
+          dcf77SetValid(0);
+        break;
+      case 1:
+        break;
+      case 2:
+        break;
+      case 3:
+        break;
+      case 4:
+        break;
+      case 5:
+        break;
+      case 6:
+        break;
+      case 7:
+        break;
+      case 8:
+        break;
+      case 9:
+        break;
+      case 10:
+        break;
+      case 11:
+        break;
+      case 12:
+        break;
+      case 13:
+        break;
+      case 14:
+        break;
+      case 15:
+        break;
+      case 16:
+        break;
+      case 17:
+        break;
+      case 18:
+        break;
+      case 19:
+        break;
+      case 20:
+        if (bit != 1)
+          dcf77SetValid(0);
+        break;
+      case 21:
+        rd.minuteOneCnt = 0;
+        rd.minuteDigit0 = 0;
+        rd.minuteDigit0 |= bit;
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 22:
+        rd.minuteDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 23:
+        rd.minuteDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 24:
+        rd.minuteDigit0 |= (bit << 3);
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 25:
+        rd.minuteDigit1 = 0;
+        rd.minuteDigit1 |= bit;
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 26:
+        rd.minuteDigit1 |= (bit << 1);
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 27:
+        rd.minuteDigit1 |= (bit << 2);
+        if (bit == 1)
+          rd.minuteOneCnt++;
+        break;
+      case 28:
+        rd.minuteOneCnt += bit;
+        if (rd.minuteOneCnt % 2 != 0) {
+          printf("MINUTE INVALID\n");
+          dcf77SetValid(0);
+        } else {
+          printf("MINUTE %u %u\n", rd.minuteDigit0, rd.minuteDigit1);
+        }
+        break;
+      case 29:
+        rd.hourOneCnt = 0;
+        rd.hourDigit0 = 0;
+        rd.hourDigit0 |= bit;
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 30:
+        rd.hourDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 31:
+        rd.hourDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 32:
+        rd.hourDigit0 |= (bit << 3);
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 33:
+        rd.hourDigit1 = 0;
+        rd.hourDigit1 |= bit;
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 34:
+        rd.hourDigit1 |= (bit << 1);
+        if (bit == 1)
+          rd.hourOneCnt++;
+        break;
+      case 35:
+        rd.hourOneCnt += bit;
+        if (rd.hourOneCnt % 2 != 0) {
+          printf("HOUR INVALID\n");
+          dcf77SetValid(0);
+        } else {
+          printf("HOUR %u %u\n", rd.hourDigit0, rd.hourDigit1);
+        }
+        break;
+      case 36:
+        rd.dateOneCnt = 0;
+        rd.dayDigit0 = 0;
+        rd.dayDigit0 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 37:
+        rd.dayDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 38:
+        rd.dayDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 39:
+        rd.dayDigit0 |= (bit << 3);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 40:
+        rd.dayDigit1 = 0;
+        rd.dayDigit1 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 41:
+        rd.dayDigit1 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 42:
+        rd.weekdayDigit0 = 0;
+        rd.weekdayDigit0 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 43:
+        rd.weekdayDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 44:
+        rd.weekdayDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 45:
+        rd.monthDigit0 = 0;
+        rd.monthDigit0 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 46:
+        rd.monthDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 47:
+        rd.monthDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 48:
+        rd.monthDigit0 |= (bit << 3);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 49:
+        rd.monthDigit1 = 0;
+        rd.monthDigit1 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 50:
+        rd.yearDigit0 = 0;
+        rd.yearDigit0 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 51:
+        rd.yearDigit0 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 52:
+        rd.yearDigit0 |= (bit << 2);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 53:
+        rd.yearDigit0 |= (bit << 3);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 54:
+        rd.yearDigit1 = 0;
+        rd.yearDigit1 |= bit;
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 55:
+        rd.yearDigit1 |= (bit << 1);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 56:
+        rd.yearDigit1 |= (bit << 2);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 57:
+        rd.yearDigit1 |= (bit << 3);
+        if (bit == 1)
+          rd.dateOneCnt++;
+        break;
+      case 58:
+        rd.dateOneCnt += bit;
+        if (rd.dateOneCnt % 2 != 0) {
+          printf("DATE INVALID\n");
+          dcf77SetValid(0);
+        } else {
+          printf("DAY %u %u\n", rd.dayDigit0, rd.dayDigit1);
+          printf("WEEKDAY %u\n", rd.weekdayDigit0);
+          printf("MONTH %u %u\n", rd.monthDigit0, rd.monthDigit1);
+          printf("YEAR %u %u\n", rd.yearDigit0, rd.yearDigit1);
+
+          clockSetClock(rd.yearDigit0 + rd.yearDigit1 * 10,
+                        rd.monthDigit0 + rd.monthDigit1 * 10,
+                        rd.dayDigit0 + rd.dayDigit1 * 10,
+                        rd.weekdayDigit0,
+                        rd.hourDigit0 + rd.hourDigit1 * 10,
+                        rd.minuteDigit0 + rd.minuteDigit1 * 10);
+
+          dcf77SetValid(2);
+        }
+        break;
+      case 59:
+        break;
+      default:
+        valid = 0;
+        break;
+      }
+
+      showState = state;
+      state++;
+    }
+
+    printf("DCF77: %d %02d %d %d %d %d %d\n",
+        valid, showState, bit, pulse, gap, validCnt, timeValidCnt);
+  }
+
+
+
+
+}

src/dcf77.h

@@ -1,14 +1,18 @@
-#ifndef MAIN_H_
+#ifndef DCF77_H_
-#define MAIN_H_
+#define DCF77_H_
+
 
 #include <stdint.h>
 
+
 #define START_GAP_MIN 1500
 #define ONE_WIDTH_MIN 170
 #define ONE_WIDTH_MAX 260
 #define ZERO_WIDTH_MIN 70
 #define ZERO_WIDTH_MAX 150
 
+
+
 typedef struct receivedData_s {
   uint8_t minuteDigit0;
   uint8_t minuteDigit1;
@@ -27,6 +31,9 @@ typedef struct receivedData_s {
 } receivedData_t;
 
 
+void dcf77Init();
+void dcf77Engine();
+void dcf77SetValid(uint8_t x);
 
 
-#endif /* MAIN_H_ */
+#endif /* DCF77_H_ */

src/main.c

@@ -1,429 +1,52 @@
 #include <stdint.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
-#include <util/delay.h>
 
-#include "main.h"
+#include "dcf77.h"
 #include "clock.h"
 #include "uartdrv.h"
 #include "stepper.h"
 #include "validLed.h"
 
 
-
-
-
-
-
-receivedData_t rd;
-
-extern volatile clock_t clock;
-
-volatile uint8_t tick;
-volatile uint16_t captValue = 0;
-volatile uint16_t gapValue = 0;
-volatile uint8_t valid = 0;
-uint16_t validCnt = 0;
-uint16_t timeValidCnt = 0;
-
-
-
-ISR(INT0_vect) {
-  uint16_t tmpCnt = TCNT1;
-  gapValue = tmpCnt - captValue;
-  TCNT1 = 0;
-}
-
-ISR(INT1_vect) {
-  captValue = TCNT1;
-  tick = 1;
-}
-
-
-void setValid(uint8_t x) {
-  valid = x;
-  if (valid == 1) {
-    validCnt++;
-    clockSetUseLocalClock(1);
-  } else if (valid == 2) {
-    timeValidCnt++;
-    clockSetUseLocalClock(0);
-    stepperEnable();
-  } else {
-    clockSetUseLocalClock(1);
-  }
-}
-
-uint8_t getValid() {
-  return valid;
-}
-
 int main() {
 
-  // signal measurment
-  TCCR1A = 0;
-  TCCR1B = (1 << CS12) | (1 << CS10);
-
-  DDRD &= ~(1 << PD2);
-  DDRD &= ~(1 << PD3);
-  PORTD |= (1 << PD2) | (1 << PD3);
-  MCUCR |= (1 << ISC11) | (1 << ISC10) | (1 << ISC01);
-  GICR |= (1 << INT0) | (1 << INT1);
-
   // esd prot
   DDRD |= (1 << PD5) | (1 << PD6);
 
 
   uartdrvInit();
   clockInit();
+  dcf77Init();
   stepperInit();
   validLedInit();
 
-  setValid(0);
+
 
   sei();
 
   printf("MyClock started\n");
 
 
-  uint8_t bit = 0;
-  uint8_t state = 0;
-
 
   while (1) {
-    if (tick != 0) {
+    dcf77Engine();
-      tick = 0;
 
-      uint16_t pulse = (((uint32_t) captValue) * 1000) / 15625;
+    stepperEngine();
-      uint16_t gap = (((uint32_t) gapValue) * 1000) / 15625;
 
-      if (gap > START_GAP_MIN) {
+    validLedEngine();
-        if (valid == 0) {
-          setValid(1);;
-        }
-        state = 0;
-        clockClearSecond();
-      }
-
-      if (pulse > ZERO_WIDTH_MIN && pulse < ZERO_WIDTH_MAX) {
-        bit = 0;
-      } else if (pulse > ONE_WIDTH_MIN && pulse < ONE_WIDTH_MAX) {
-        bit = 1;
-      } else {
-        bit = 2;
-        setValid(0);;
-      }
 
 
-      if (valid > 0) {
+    if (clockNextSecond()) {
-        switch (state) {
+      clock_t clock = clockGetClock();
-        case 0:
+      printf("Time: %02d:%02d:%02d %d %02d.%02d.%02d\n",
-          if (bit != 0)
+          clock.year, clock.month, clock.day, clock.weekday,
-            setValid(0);
+          clock.hour, clock.minute, clock.second);
-          break;
-        case 1:
-          break;
-        case 2:
-          break;
-        case 3:
-          break;
-        case 4:
-          break;
-        case 5:
-          break;
-        case 6:
-          break;
-        case 7:
-          break;
-        case 8:
-          break;
-        case 9:
-          break;
-        case 10:
-          break;
-        case 11:
-          break;
-        case 12:
-          break;
-        case 13:
-          break;
-        case 14:
-          break;
-        case 15:
-          break;
-        case 16:
-          break;
-        case 17:
-          break;
-        case 18:
-          break;
-        case 19:
-          break;
-        case 20:
-          if (bit != 1)
-            setValid(0);
-          break;
-        case 21:
-          rd.minuteOneCnt = 0;
-          rd.minuteDigit0 = 0;
-          rd.minuteDigit0 |= bit;
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 22:
-          rd.minuteDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 23:
-          rd.minuteDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 24:
-          rd.minuteDigit0 |= (bit << 3);
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 25:
-          rd.minuteDigit1 = 0;
-          rd.minuteDigit1 |= bit;
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 26:
-          rd.minuteDigit1 |= (bit << 1);
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 27:
-          rd.minuteDigit1 |= (bit << 2);
-          if (bit == 1)
-            rd.minuteOneCnt++;
-          break;
-        case 28:
-          rd.minuteOneCnt += bit;
-          if (rd.minuteOneCnt % 2 != 0) {
-            printf("MINUTE INVALID\n");
-            setValid(0);
-          } else {
-            printf("MINUTE %u %u\n", rd.minuteDigit0, rd.minuteDigit1);
-          }
-          break;
-        case 29:
-          rd.hourOneCnt = 0;
-          rd.hourDigit0 = 0;
-          rd.hourDigit0 |= bit;
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 30:
-          rd.hourDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 31:
-          rd.hourDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 32:
-          rd.hourDigit0 |= (bit << 3);
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 33:
-          rd.hourDigit1 = 0;
-          rd.hourDigit1 |= bit;
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 34:
-          rd.hourDigit1 |= (bit << 1);
-          if (bit == 1)
-            rd.hourOneCnt++;
-          break;
-        case 35:
-          rd.hourOneCnt += bit;
-          if (rd.hourOneCnt % 2 != 0) {
-            printf("HOUR INVALID\n");
-            setValid(0);
-          } else {
-            printf("HOUR %u %u\n", rd.hourDigit0, rd.hourDigit1);
-          }
-          break;
-        case 36:
-          rd.dateOneCnt = 0;
-          rd.dayDigit0 = 0;
-          rd.dayDigit0 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 37:
-          rd.dayDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 38:
-          rd.dayDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 39:
-          rd.dayDigit0 |= (bit << 3);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 40:
-          rd.dayDigit1 = 0;
-          rd.dayDigit1 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 41:
-          rd.dayDigit1 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 42:
-          rd.weekdayDigit0 = 0;
-          rd.weekdayDigit0 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 43:
-          rd.weekdayDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 44:
-          rd.weekdayDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 45:
-          rd.monthDigit0 = 0;
-          rd.monthDigit0 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 46:
-          rd.monthDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 47:
-          rd.monthDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 48:
-          rd.monthDigit0 |= (bit << 3);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 49:
-          rd.monthDigit1 = 0;
-          rd.monthDigit1 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 50:
-          rd.yearDigit0 = 0;
-          rd.yearDigit0 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 51:
-          rd.yearDigit0 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 52:
-          rd.yearDigit0 |= (bit << 2);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 53:
-          rd.yearDigit0 |= (bit << 3);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 54:
-          rd.yearDigit1 = 0;
-          rd.yearDigit1 |= bit;
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 55:
-          rd.yearDigit1 |= (bit << 1);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 56:
-          rd.yearDigit1 |= (bit << 2);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 57:
-          rd.yearDigit1 |= (bit << 3);
-          if (bit == 1)
-            rd.dateOneCnt++;
-          break;
-        case 58:
-          rd.dateOneCnt += bit;
-          if (rd.dateOneCnt % 2 != 0) {
-            printf("DATE INVALID\n");
-            setValid(0);
-          } else {
-            printf("DAY %u %u\n", rd.dayDigit0, rd.dayDigit1);
-            printf("WEEKDAY %u\n", rd.weekdayDigit0);
-            printf("MONTH %u %u\n", rd.monthDigit0, rd.monthDigit1);
-            printf("YEAR %u %u\n", rd.yearDigit0, rd.yearDigit1);
-
-            clockSetClock(rd.yearDigit0 + rd.yearDigit1 * 10,
-                          rd.monthDigit0 + rd.monthDigit1 * 10,
-                          rd.dayDigit0 + rd.dayDigit1 * 10,
-                          rd.weekdayDigit0,
-                          rd.hourDigit0 + rd.hourDigit1 * 10,
-                          rd.minuteDigit0 + rd.minuteDigit1 * 10);
-
-            setValid(2);
-          }
-          break;
-        case 59:
-          break;
-        default:
-          valid = 0;
-          break;
-        }
-
-        printf("%02d:%02d:%02d %02d.%02d.%02d %d   %d %02d %d %d %d %d %d\n",
-            clock.hour, clock.minute, clock.second,
-            clock.day, clock.month, clock.year, clock.weekday,
-            valid, state, bit, pulse, gap, validCnt, timeValidCnt);
-
-        state++;
-      } else {
-
-        printf("%02d:%02d:%02d %02d.%02d.%02d %d   %d %02d %d %d %d %d %d\n",
-            clock.hour, clock.minute, clock.second,
-            clock.day, clock.month, clock.year, clock.weekday,
-            valid, state, bit, pulse, gap, validCnt, timeValidCnt);
-      }
     }
 
     if (clockNextMinute()) {
       opTime_t opTime = clockGetOpTime();
-      printf("% 4d:%02d:%02d\n", opTime.hour, opTime.minute, opTime.second);
+      printf("OpTime: % 4d:%02d:%02d\n", opTime.hour, opTime.minute, opTime.second);
-    }
-
-    if (clockNextStep()) {
-      stepperEngine();
-    }
-
-    if (clockNextTack()) {
-      validLedEngine(valid);
     }
 
   }

src/stepper.c

@@ -4,7 +4,6 @@
 #include <util/delay.h>
 
 
-#include "main.h"
 #include "clock.h"
 #include "stepper.h"
 
@@ -138,6 +137,9 @@ void stepperEngine() {
   static uint8_t hourStepPosition = 0;
   static int8_t hourDirection = 0;
 
+
+  if (clockNextStep()) {
+
     clock_t clock = clockGetClock();
 
     switch (stepperState) {
@@ -262,6 +264,6 @@ void stepperEngine() {
       stepperState = 0;
       break;
     }
-
+  }
 }
 

src/stepper.h

@@ -2,7 +2,6 @@
 #define STEPPER_H_
 
 #include <stdint.h>
-#include "main.h"
 #include "clock.h"
 
 #define STEPS_PER_MINUTE 3

src/validLed.c

@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <avr/io.h>
 
-#include "main.h"
+#include "clock.h"
 
 
 #define VALID_LED_REG_DIR DDRB
@@ -16,6 +16,11 @@
 #define DARK_SWITCH PD7
 
 
+uint8_t validLedStatus = 0;
+
+void validLedSetStatus(uint8_t x) {
+  validLedStatus = x;
+}
 
 uint8_t isNotDark() {
   return DARK_SWITCH_IN_REG & (1 << DARK_SWITCH);
@@ -41,12 +46,14 @@ void validLedInit() {
 }
 
 
-void validLedEngine(uint8_t valid) {
+void validLedEngine() {
   static uint8_t ledToggle = 0;
 
+
+  if (clockNextBlink()) {
     uint8_t light = isNotDark();
 
-  switch (valid) {
+    switch (validLedStatus) {
     case 0:
       validLedDisable();
       break;
@@ -71,5 +78,5 @@ void validLedEngine(uint8_t valid) {
       }
       break;
     }
-
+  }
 }

src/validLed.h

@@ -4,7 +4,8 @@
 
 
 void validLedInit();
-void validLedEngine(uint8_t valid);
+void validLedEngine();
+void validLedSetStatus(uint8_t x);
 
 
 #endif /* VALIDLED_H_ */