From e22453c44e0b88f47cd16f6dd1a769bd4ff90203 Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Sat, 20 May 2017 19:08:44 +0200
Subject: First prototype version: Just shift register usage.

---
 Makefile |   6 +++
 main.c   | 164 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 170 insertions(+)
 create mode 100644 Makefile
 create mode 100644 main.c

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..e8d2720
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,6 @@
+all:
+	avr-gcc -Wall  -mmcu=attiny85 -O3 -o main.elf main.c
+	avr-objcopy -j .text -j .data -O ihex main.elf main.hex
+
+program: all
+	avrdude -B100 -p t85 -c avrisp2 -P usb -U flash:w:main.hex
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..7906126
--- /dev/null
+++ b/main.c
@@ -0,0 +1,164 @@
+#include <avr/io.h>          // (1)
+#include <avr/interrupt.h>
+
+#ifndef F_CPU
+#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
+// #define F_CPU 3686400UL     /* Quarz mit 3.6864 Mhz */
+#define F_CPU 1000000UL     /* Quarz mit 3.6864 Mhz */
+#endif
+
+#include <util/delay.h>
+#include <stdint.h>
+
+
+// set bit
+static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
+static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
+  *target |= (1<<bit);
+};
+
+// set clear
+static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
+static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
+  *target &= ~(1<<bit);
+};
+
+///* -----------------------------------------------------------------------------------------------------------*/
+///*! Eine schnelle MEM->SPI Blocksende Routine mit optimierungen auf Speed.
+// * \param  buffer    Zeiger auf den Puffer der gesendet werden soll.
+// * \param  Datalenght  Anzahl der Bytes die gesedet werden soll.
+// */
+///* -----------------------------------------------------------------------------------------------------------*/
+//void SPI_FastMem2Write( unsigned char * buffer, unsigned int Datalenght )
+//{
+//  unsigned int Counter = 0;
+//  unsigned char data;
+//
+//  // erten Wert senden
+//  SPDR = buffer[ Counter++ ];
+//  while( Counter < Datalenght )
+//  {
+//    // Wert schon mal in Register holen, schneller da der Wert jetzt in einem Register steht und nicht mehr aus dem RAM geholt werden muss
+//    // nachdem das senden des vorherigen Wertes fertig ist,
+//    data = buffer[ Counter ];
+//    // warten auf fertig
+//    while(!(SPSR & (1<<SPIF)));
+//    // Wert aus Register senden
+//    SPDR = data;
+//    Counter++;
+//  }
+//  while(!(SPSR & (1<<SPIF)));
+//  return;
+//}
+uint8_t spi_transfer(uint8_t data) {
+  USIDR = data;
+  USISR = _BV(USIOIF); // clear flag
+
+  while ( (USISR & _BV(USIOIF)) == 0 ) {
+    USICR = (1<<USIWM0)|(1<<USICS1)|(1<<USICLK)|(1<<USITC);
+  }
+  return USIDR;
+}
+
+void pulse_sck()
+{
+  PORTB |= ( 1 << PB2 );
+  _delay_ms(10);        // Eine Sekunde +/-1/10000 Sekunde warten...
+  PORTB ^= ( 1 << PB2 );
+}
+
+void print_data(uint16_t data)
+{
+  BIT_CLEAR(&PORTB, PB4);
+  _delay_ms(100);
+  BIT_SET(&PORTB, PB4);
+
+  for(int i=0; i<16; i++)
+  {
+    if(data<<i & 0b1000000000000000)
+      BIT_SET(&PORTB, PB4);
+    pulse_sck();
+    BIT_CLEAR(&PORTB, PB4);
+    //PORTB &= (1 << PB4);
+  }
+  //pulse_sck();
+
+
+  BIT_CLEAR(&PORTB, PB3);
+  _delay_ms(50);
+  BIT_SET(&PORTB, PB3);
+}
+
+
+int main (void) {
+
+  //DDRB |= _BV(PB4); // as output (latch)
+  //DDRB |= _BV(PB6); // as output (DO) - data out
+  //DDRB |= _BV(PB7); // as output (USISCK) - clock
+  _delay_ms(1000);
+  // DDRB   = (1<<PB0) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);  // PB0 an PORTB als Ausgang setzen
+  DDRB   = 0xFF;
+
+
+  BIT_CLEAR(&PORTB, PB5);
+  _delay_ms(500);
+  BIT_SET(&PORTB, PB5);
+  BIT_CLEAR(&PORTB, PB5);
+  _delay_ms(500);
+  BIT_SET(&PORTB, PB5);
+  //DDRB  &= ~_BV(PB5);     // as input (DI) - data in
+  //PORTB |= _BV(PB5);      // pullup on (DI)
+
+  while( 1 )
+  {                // Endlosschleife
+
+    _delay_ms(1000);        // Eine Sekunde +/-1/10000 Sekunde warten...
+
+
+    // char data = 0b10101010;
+    // char data = 0b11001101;
+    // char data = 0b10101100;
+    //
+    //
+    //
+    //
+    //
+    //
+    //
+    //
+
+    print_data(0x0001);
+    print_data(0x0002);
+    print_data(0x0004);
+    print_data(0x0008);
+    print_data(0x000F);
+    print_data(0xFF00);
+    print_data(0x00FF);
+    print_data(0xFF00);
+    print_data(0x00FF);
+    print_data(0xFF00);
+
+    uint16_t data;
+    for(int i=0; i<16; i++)
+      print_data(1<<i);
+    for(int i=0; i<16; i++)
+      print_data(0X8000>>i);
+
+    /*
+
+    char data = 1;
+    for(; data<128; data++)
+    {
+      // clear register (reset)
+      print_data(data);
+      _delay_ms(1000);
+    }
+
+    */
+
+    // spi_transfer(0x10101010b);
+
+
+  }
+  return 0;
+}
-- 
cgit v1.2.3


From ff7774def5479996e2acb77ddd942c036134453d Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Sat, 20 May 2017 20:59:52 +0200
Subject: Fix number format, coding style and improved test program

---
 Makefile |   4 +-
 main.c   | 146 ++++++++++++---------------------------------------------------
 2 files changed, 29 insertions(+), 121 deletions(-)

diff --git a/Makefile b/Makefile
index e8d2720..e63d2c0 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,7 @@
+FLAGS=-Wall -I/usr/lib/gcc/avr/6.3.0/plugin/include/ -I/usr/avr/include -mmcu=attiny13 -O3 -DF_CPU=1200000 
+
 all:
-	avr-gcc -Wall  -mmcu=attiny85 -O3 -o main.elf main.c
+	avr-gcc $(FLAGS) -o main.elf main.c
 	avr-objcopy -j .text -j .data -O ihex main.elf main.hex
 
 program: all
diff --git a/main.c b/main.c
index 7906126..2b5753d 100644
--- a/main.c
+++ b/main.c
@@ -1,164 +1,70 @@
-#include <avr/io.h>          // (1)
+// vim:set et sw=2 ts=2 tw=120:
+#define __AVR_ATtiny85__
 #include <avr/interrupt.h>
+#include <avr/io.h> // (1)
 
 #ifndef F_CPU
 #warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
-// #define F_CPU 3686400UL     /* Quarz mit 3.6864 Mhz */
-#define F_CPU 1000000UL     /* Quarz mit 3.6864 Mhz */
+#define F_CPU 1000000UL
 #endif
 
-#include <util/delay.h>
 #include <stdint.h>
-
+#include <util/delay.h>
 
 // set bit
-static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
-static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
-  *target |= (1<<bit);
-};
+static inline void BIT_SET(volatile uint8_t* target, uint8_t bit) __attribute__((always_inline));
+static inline void BIT_SET(volatile uint8_t* target, uint8_t bit) { *target |= (1 << bit); };
 
 // set clear
-static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
-static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
-  *target &= ~(1<<bit);
-};
-
-///* -----------------------------------------------------------------------------------------------------------*/
-///*! Eine schnelle MEM->SPI Blocksende Routine mit optimierungen auf Speed.
-// * \param  buffer    Zeiger auf den Puffer der gesendet werden soll.
-// * \param  Datalenght  Anzahl der Bytes die gesedet werden soll.
-// */
-///* -----------------------------------------------------------------------------------------------------------*/
-//void SPI_FastMem2Write( unsigned char * buffer, unsigned int Datalenght )
-//{
-//  unsigned int Counter = 0;
-//  unsigned char data;
-//
-//  // erten Wert senden
-//  SPDR = buffer[ Counter++ ];
-//  while( Counter < Datalenght )
-//  {
-//    // Wert schon mal in Register holen, schneller da der Wert jetzt in einem Register steht und nicht mehr aus dem RAM geholt werden muss
-//    // nachdem das senden des vorherigen Wertes fertig ist,
-//    data = buffer[ Counter ];
-//    // warten auf fertig
-//    while(!(SPSR & (1<<SPIF)));
-//    // Wert aus Register senden
-//    SPDR = data;
-//    Counter++;
-//  }
-//  while(!(SPSR & (1<<SPIF)));
-//  return;
-//}
-uint8_t spi_transfer(uint8_t data) {
-  USIDR = data;
-  USISR = _BV(USIOIF); // clear flag
-
-  while ( (USISR & _BV(USIOIF)) == 0 ) {
-    USICR = (1<<USIWM0)|(1<<USICS1)|(1<<USICLK)|(1<<USITC);
-  }
-  return USIDR;
-}
+static inline void BIT_CLEAR(volatile uint8_t* target, uint8_t bit) __attribute__((always_inline));
+static inline void BIT_CLEAR(volatile uint8_t* target, uint8_t bit) { *target &= ~(1 << bit); };
 
 void pulse_sck()
 {
-  PORTB |= ( 1 << PB2 );
-  _delay_ms(10);        // Eine Sekunde +/-1/10000 Sekunde warten...
-  PORTB ^= ( 1 << PB2 );
+  PORTB |= (1 << PB2);
+  _delay_ms(10); // Eine Sekunde +/-1/10000 Sekunde warten...
+  PORTB ^= (1 << PB2);
 }
 
 void print_data(uint16_t data)
 {
   BIT_CLEAR(&PORTB, PB4);
-  _delay_ms(100);
+  _delay_ms(50);
   BIT_SET(&PORTB, PB4);
 
-  for(int i=0; i<16; i++)
+  for (uint16_t i = 0; i < 16; i++)
   {
-    if(data<<i & 0b1000000000000000)
-      BIT_SET(&PORTB, PB4);
+    data & 0x1 << i ? BIT_SET(&PORTB, PB4) : BIT_CLEAR(&PORTB, PB4);
     pulse_sck();
-    BIT_CLEAR(&PORTB, PB4);
-    //PORTB &= (1 << PB4);
   }
-  //pulse_sck();
-
 
   BIT_CLEAR(&PORTB, PB3);
   _delay_ms(50);
   BIT_SET(&PORTB, PB3);
 }
 
-
-int main (void) {
-
-  //DDRB |= _BV(PB4); // as output (latch)
-  //DDRB |= _BV(PB6); // as output (DO) - data out
-  //DDRB |= _BV(PB7); // as output (USISCK) - clock
-  _delay_ms(1000);
-  // DDRB   = (1<<PB0) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);  // PB0 an PORTB als Ausgang setzen
-  DDRB   = 0xFF;
-
+int main(void)
+{
+  DDRB = 0xFF;
 
   BIT_CLEAR(&PORTB, PB5);
-  _delay_ms(500);
+  _delay_ms(200);
   BIT_SET(&PORTB, PB5);
   BIT_CLEAR(&PORTB, PB5);
-  _delay_ms(500);
+  _delay_ms(200);
   BIT_SET(&PORTB, PB5);
-  //DDRB  &= ~_BV(PB5);     // as input (DI) - data in
-  //PORTB |= _BV(PB5);      // pullup on (DI)
-
-  while( 1 )
-  {                // Endlosschleife
-
-    _delay_ms(1000);        // Eine Sekunde +/-1/10000 Sekunde warten...
-
-
-    // char data = 0b10101010;
-    // char data = 0b11001101;
-    // char data = 0b10101100;
-    //
-    //
-    //
-    //
-    //
-    //
-    //
-    //
 
-    print_data(0x0001);
-    print_data(0x0002);
-    print_data(0x0004);
-    print_data(0x0008);
-    print_data(0x000F);
-    print_data(0xFF00);
-    print_data(0x00FF);
-    print_data(0xFF00);
-    print_data(0x00FF);
-    print_data(0xFF00);
+  while (1)
+  { // Endlosschleife
 
-    uint16_t data;
-    for(int i=0; i<16; i++)
-      print_data(1<<i);
-    for(int i=0; i<16; i++)
-      print_data(0X8000>>i);
-
-    /*
-
-    char data = 1;
-    for(; data<128; data++)
+    uint16_t data = 1;
+    for (; data < UINT16_MAX; data++)
     {
       // clear register (reset)
-      print_data(data);
-      _delay_ms(1000);
+      print_data(data | data << 6);
     }
 
-    */
-
-    // spi_transfer(0x10101010b);
-
-
+    _delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
   }
   return 0;
 }
-- 
cgit v1.2.3


From e8c784a9502bbaa8d3c47b2fc60884311632d968 Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Thu, 25 May 2017 02:40:18 +0200
Subject: Simple counter (in seconds)

---
 .clang-format      |   5 +++
 .ycm_extra_conf.py |  26 ++++++++++++
 Makefile           |  17 ++++++--
 main.c             | 118 +++++++++++++++++++++++++++++++++++++++++------------
 4 files changed, 136 insertions(+), 30 deletions(-)
 create mode 100644 .clang-format
 create mode 100644 .ycm_extra_conf.py

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..b8ecd2e
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,5 @@
+BasedOnStyle: Webkit
+IndentWidth: 2
+BreakBeforeBraces: Allman
+AllowShortIfStatementsOnASingleLine: false
+ColumnLimit: 120
diff --git a/.ycm_extra_conf.py b/.ycm_extra_conf.py
new file mode 100644
index 0000000..42834fb
--- /dev/null
+++ b/.ycm_extra_conf.py
@@ -0,0 +1,26 @@
+import os
+import ycm_core
+
+def FlagsForFile( filename, **kwargs ):
+  return {
+    'flags': [
+      '-Wall',
+      '-Wextra',
+      '-Werror',
+      '-Wno-long-long',
+      '-Wno-variadic-macros',
+      '-fexceptions',
+      '-ferror-limit=10000',
+      '-DNDEBUG',
+      '-std=c99',
+      '-x', 'c',
+      '-D_GNU_SOURCE',
+      '-D__AVR_ATtiny85__',
+      '-D__AVR__',
+      '-I.',
+      '-I', '/usr/avr/include/'
+    ],
+    'do_cache': True,
+  }
+
+# vim:set et sw=2 ts=2 tw=120:
diff --git a/Makefile b/Makefile
index e63d2c0..e81f5a1 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,17 @@
-FLAGS=-Wall -I/usr/lib/gcc/avr/6.3.0/plugin/include/ -I/usr/avr/include -mmcu=attiny13 -O3 -DF_CPU=1200000 
+FLAGS=-Wall -O5 -Werror
+FLAGS+=-mmcu=attiny85
+FLAGS+=-D__AVR_ATtiny85__=1
+# FLAGS+=-DF_CPU=120000UL
+# FLAGS+=-DF_CPU=960000UL
+FLAGS+=-DF_CPU=800000UL
+FLAGS+=-I inc/int/
+FLAGS+=-I/usr/lib/gcc/avr/6.3.0/plugin/include/
+FLAGS+=-I/usr/avr/include
+
+program: all
+	avrdude -V -B100 -p t85 -c avrisp2 -P usb -U flash:w:main.hex
 
 all:
-	avr-gcc $(FLAGS) -o main.elf main.c
+	avr-gcc $(FLAGS) -o main.elf main.c inc/int/dcf77.c
 	avr-objcopy -j .text -j .data -O ihex main.elf main.hex
 
-program: all
-	avrdude -B100 -p t85 -c avrisp2 -P usb -U flash:w:main.hex
diff --git a/main.c b/main.c
index 2b5753d..2dd8058 100644
--- a/main.c
+++ b/main.c
@@ -1,15 +1,12 @@
 // vim:set et sw=2 ts=2 tw=120:
-#define __AVR_ATtiny85__
+#include <stdint.h>
+#include <avr/io.h>
 #include <avr/interrupt.h>
-#include <avr/io.h> // (1)
+#include <util/delay.h>
 
-#ifndef F_CPU
-#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
-#define F_CPU 1000000UL
-#endif
+#include "inc/int/dcf77.h"
 
-#include <stdint.h>
-#include <util/delay.h>
+#define CTC_MATCH_OVERFLOW ((F_CPU / 1000) / 8)
 
 // set bit
 static inline void BIT_SET(volatile uint8_t* target, uint8_t bit) __attribute__((always_inline));
@@ -19,52 +16,121 @@ static inline void BIT_SET(volatile uint8_t* target, uint8_t bit) { *target |= (
 static inline void BIT_CLEAR(volatile uint8_t* target, uint8_t bit) __attribute__((always_inline));
 static inline void BIT_CLEAR(volatile uint8_t* target, uint8_t bit) { *target &= ~(1 << bit); };
 
+
+/*
+ * 
+ * PB2        : connected to ShiftClock on Port 11
+ * PB3        : connected to MemoryClock on Port 12 (shows content of memory)
+ * PB4 (PIN3) : connected to SERIAL_IN on pin 14
+ *
+ */
+
 void pulse_sck()
 {
   PORTB |= (1 << PB2);
-  _delay_ms(10); // Eine Sekunde +/-1/10000 Sekunde warten...
   PORTB ^= (1 << PB2);
+
 }
 
 void print_data(uint16_t data)
 {
-  BIT_CLEAR(&PORTB, PB4);
-  _delay_ms(50);
-  BIT_SET(&PORTB, PB4);
+  //BIT_CLEAR(&PORTB, PB4);
+  //BIT_SET(&PORTB, PB4);
 
   for (uint16_t i = 0; i < 16; i++)
   {
-    data & 0x1 << i ? BIT_SET(&PORTB, PB4) : BIT_CLEAR(&PORTB, PB4);
+    data & 0x1 << i
+      ? BIT_SET(&PORTB, PB4)
+      : BIT_CLEAR(&PORTB, PB4);
     pulse_sck();
   }
-
+  //BIT_CLEAR(&PORTB, PB4);
+  // pulse_sck();
   BIT_CLEAR(&PORTB, PB3);
-  _delay_ms(50);
   BIT_SET(&PORTB, PB3);
+
 }
 
 int main(void)
 {
-  DDRB = 0xFF;
 
   BIT_CLEAR(&PORTB, PB5);
-  _delay_ms(200);
+  _delay_ms(20);
   BIT_SET(&PORTB, PB5);
   BIT_CLEAR(&PORTB, PB5);
-  _delay_ms(200);
+  _delay_ms(20);
   BIT_SET(&PORTB, PB5);
 
+
+
+  // make all pins output pins...
+  DDRB  = 0xFF;
+  DDRB &= ~(1 << PB0); // makes PB0 an input pin (INT0)
+  PORTB |= (1 << PB0); // activate input resistor
+
+  // activate dcf77-receiver...
+  PORTB &=  (1 << PB1); // sets PB1 to low
+  _delay_ms(20);
+  PORTB &= ~(1 << PB1); // sets PB1 to low
+
+
+  cli();
+
+  /*
+  GIMSK |= (1<<INT0); // External Interrupt Request 0 Enable
+  GIMSK |= (1<<PCIE); // Pin Change Interrupt Enable
+
+  // MCU Control Register (controls CPU-behaviours like interrupts & sleepmode)
+  MCUCR |= ~(1<<ISC01) | (1<<ISC00); // any logical change generates interrupt
+  PCMSK |= (1<<PCINT0);
+  // INT0_CONTROL = INT0_RISING_EDGE; // going to toggle int0-behaviour
+  */
+
+  TCCR0A |= (1 << WGM01);              // CTC mode
+  // TCCR0B |= (1 << CS00);
+  TCCR0B |= (1 << CS01);               // Prescaler 8
+  // TCCR0B |= (1 << CS02);               // Prescaler 256
+  // OCR0A  |= (1 << WGM01);              // CTC mode
+
+  // OCR0A   = 149;
+  OCR0A   = 124;
+  // OCR0A   = CTC_MATCH_OVERFLOW;
+  TIMSK  |= (1 << OCIE0A);             // if you want interrupt
+
+  sei();
+
   while (1)
-  { // Endlosschleife
+  {
+    // uint16_t t = 1;
+    // for (uint16_t i=0; i<16; i++)
+    // {
+      print_data(t_current.s);
+      // t = t<<1;
+    // }
+    // print_data(t_current.s);
 
-    uint16_t data = 1;
-    for (; data < UINT16_MAX; data++)
-    {
-      // clear register (reset)
-      print_data(data | data << 6);
-    }
 
-    _delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
+    /*
+      print_data(0xFFFF);
+      _delay_ms(1000);
+      print_data(0x0000);
+      _delay_ms(1000);
+    */
   }
   return 0;
 }
+
+
+/*
+for(uint16_t hour=0; hour<24; hour++)
+  for(uint16_t minute=0; minute<60; minute++)
+    for (uint16_t second = 1; second < 60; second++)
+    {
+      // clear register (reset)
+      // print_data(hour<< 12 | minute << 6 | second);
+      // print_data((int64_t) dcf77);
+      // dcf77[dcf77_bit].bit == 1
+      //   ? print_data(0xFFFF)
+      //   : print_data(0x0000);
+    }A
+*/
-- 
cgit v1.2.3


From 25d1f4326cce046b245cd224f3e6335c1a6f76b0 Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Thu, 25 May 2017 19:45:15 +0200
Subject: DCF signal recognized and shown

---
 inc/int/dcf77.c | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 inc/int/dcf77.h |  69 ++++++++++++++++++++++++++++
 main.c          |  49 ++++++++++----------
 3 files changed, 231 insertions(+), 26 deletions(-)
 create mode 100755 inc/int/dcf77.c
 create mode 100755 inc/int/dcf77.h

diff --git a/inc/int/dcf77.c b/inc/int/dcf77.c
new file mode 100755
index 0000000..13af50d
--- /dev/null
+++ b/inc/int/dcf77.c
@@ -0,0 +1,139 @@
+// vim:set et sw=2 ts=2 tw=120:
+#include "dcf77.h"
+
+// returns -1 on error
+unsigned char getBits(const DCF start, const char len)
+{
+  static const unsigned char mult[]  = {1, 2, 4, 8, 10, 20 ,40 ,80};
+  /// unsigned char p = 1; //parity
+  unsigned char r = 0; // retval
+  unsigned char i;
+  for(i=0; i<len; i++)
+    r += dcf77[start+i].bit * mult[i];
+    /// if(dcf77[start+i].bit)
+      /// p ^= 1;
+  return r;
+}
+
+void set_dcf_value()
+{
+  t_current.m = (getBits(DCF_MIN,      7)) - 1;
+  t_current.h = (getBits(DCF_HOUR,     6));
+  t_current.dd = (getBits(DCF_DAY,     6));
+  t_current.wd = (getBits(DCF_WEEKDAY, 3));
+  t_current.mm = (getBits(DCF_MONTH,   5));
+  t_current.yy = (getBits(DCF_YEAR,    8));
+}
+
+// 7372800/a=10000
+// 115200 / a * x = 10000
+// 7372800/8/150
+
+// interrupt service routine (ISR) for timer 0 A compare match
+/*
+ISR(TIMER0A_COMP_vect) // called 10000 times per second (12000000/8/150)
+{
+
+}
+*/
+ISR(TIMER0_COMPB_vect)
+{
+
+}
+
+ISR(TIMER0_COMPA_vect)
+{
+  interval++;
+  if (++t_current.ms >= 1000) // one second
+  {
+    t_current.ms = 0; // restart
+    if (++t_current.s > 59) // one minute
+    {
+      t_current.s = 0; // restart
+      if (++t_current.m > 59) // one hour
+      {
+        t_current.m = 0; // restart
+        if (++t_current.h > 23) // one day
+        {
+          t_current.h = 0; // restart
+          t_current.dd++;
+        }
+      }
+    }
+  }
+}
+
+ISR(INT0_vect)
+{
+}
+
+ISR(PCINT0_vect)
+{
+  interval = 1;
+  /// stdout_put_int(interval, uart_putc);
+  /// stdout_put_string("INT0 call\n", uart_putc);
+  // cli();
+
+  // if(INT0_CONTROL == INT0_RISING_EDGE)
+  // if(MCUCR & (1<<ISC00))
+  // {
+  if (interval > 1000 && interval < 2000) // 59th second - no rising edge at the beginning
+  {
+    /// if(dcf77_bit == 59) // check if every bit has been transfered
+    // set_dcf_value();  // completely received- apply new time data
+
+    // 59th second: synchronize with receiver...
+    TCNT0 = 0;
+    dcf77_bit = 0;
+    t_current.s = 0;
+    t_current.ms = 0;
+    // t_current.us = 0;
+    // falling edge causes interrupt...
+    // MCUCR &= ~(1 << ISC00);
+    // MCUCR |=  (1 << ISC01);
+    // INT0_CONTROL = INT0_FALLING_EDGE;
+  }
+  else // INT0_FALLING_EDGE
+  {
+    dcf77[dcf77_bit++].bit = interval >= 200 ? 1 : 0;
+
+    // rising edge causes interrupt...
+    // MCUCR |= (1 << ISC00);
+    // MCUCR |= (1 << ISC01);
+    // INT0_CONTROL = INT0_RISING_EDGE;
+    // interval = 0; // reset interval to count next interval
+  }
+
+  interval = 0;
+  // sei();
+}
+
+/*
+void timer_init()
+{
+  // 7372800/8
+  // >>>>>> DDRD &= ~((1<<PD2) | (1<<PD3)); // make INT0 and INT1 input-pins
+
+  // Prescaler...
+  // output compare...
+
+  //OCR0   = 152 - 1;
+  //TCCR0 |= (0<<WGM01) | (1<<WGM01);
+
+  // ICNC1 (Input Capture Noise Canceler (4 CKs) Timer/Counter 1
+  // ICES1 (Input Capture Edge Select Timer/Counter 1) - 1:increasing 0:falling
+  // CSx: set prescaler (010 means 8)
+  /// TCCR1B = (1<<ICNC1) | (1<<ICES1) | (0<<CS12) | (1<<CS11) | (0<<CS10);
+  // OCIE0: Output Compare Match Interrupt Enable
+  // TICIE: Timer/Counter Input Capture Interrupt Enable
+
+  // interrupts_init...
+  // General Interrupt Mask Register (enables interrupts)
+  GIMSK |= (1<<INT0);
+  // GICR |= (1<<INT0);
+  // MCU Control Register (controls CPU-behaviours like interrupts & sleepmode)
+  MCUCR |= (1<<ISC01) | (1<<ISC00); // any logical change generates interrupt
+  INT0_CONTROL = INT0_RISING_EDGE; // going to toggle int0-behaviour
+  /// loworhigh.bit = 0;
+}
+*/
diff --git a/inc/int/dcf77.h b/inc/int/dcf77.h
new file mode 100755
index 0000000..e47ca4e
--- /dev/null
+++ b/inc/int/dcf77.h
@@ -0,0 +1,69 @@
+#ifndef CLOCK_H
+#define CLOCK_H
+  /* this dcf77-module relies on a accuarate clock (crystal) for receiving
+   * the dcf-signal. therefor the clock is going to work as expected,
+   * even with no dcf77-signal available.
+   * receivement is automatically turned on, if the avr is connected to the
+   * signal via INT0. if there is no signal the clock will not be set (K.I.S.S.)
+   *
+   */
+  #include <avr/io.h>
+  #include <avr/interrupt.h>
+
+  #include <stdint.h>
+
+  #define INT0_CONTROL       MCUCR
+  // #define INT0_FALLING_EDGE  0x02
+  // #define INT0_RISING_EDGE   0x03
+  #define INT0_FALLING_EDGE  (1<<ISC01)
+  #define INT0_RISING_EDGE   (1<<ISC01 | 1<<ISC00)
+  #define INT0_EDGE_ANY      (1<<ISC00)
+
+  typedef struct
+  {
+    volatile unsigned char bit : 1;
+  } Bit;
+
+  typedef struct
+  {
+    uint16_t h ;  // hour
+    uint16_t m ;  // minute
+    uint16_t s ;  // second
+    uint16_t ms;  // milli second
+    uint8_t yy;  // year
+    uint8_t mm;  // month
+    uint8_t dd;  // day
+    uint8_t wd;  // weekday
+  } Time;
+
+  typedef enum
+  {
+    DCF_FIRST   = 0,  // start of a new minute (note: always 0)
+    DCF_WEATHER = 14, // proprietary :-(
+    DCF_ANTENNA = 15, // 0: normal, 1: replacement
+    DCF_DST     = 16, // daylight saving time: this hour new time...
+    DCF_MEZ     = 17, // 'summer-time'
+    DCF_MESZ    = 18, // 'winter-time'
+    DCF_DBLSEC  = 19, // one extra second gonna be inserted
+    DCF_START   = 20, // begin of time-info (note: always 1)
+    DCF_MIN     = 21, // 7 bit
+    DCF_MINP    = 28, // parity bit for minutes
+    DCF_HOUR    = 29, // 6 bit
+    DCF_HOURP   = 35, // parity bit for hours
+    DCF_DAY     = 36, // 6 bit
+    DCF_WEEKDAY = 42, // 3 bit
+    DCF_MONTH   = 45, // 5 bit
+    DCF_YEAR    = 50, // 8 bit
+    DCF_DATEP   = 58  // parity bit for date
+  } DCF;
+
+  volatile Bit dcf77[60];
+  volatile uint8_t dcf77_bit;
+  volatile Time t_current;
+  volatile uint16_t interval;
+
+  /// void getBits(volatile unsigned char* target, const DCF start, const char len, const DCF parity);
+  /// void set_dcf_value();
+  /// void interrupts_init();
+
+#endif
diff --git a/main.c b/main.c
index 2dd8058..5c8d616 100644
--- a/main.c
+++ b/main.c
@@ -25,30 +25,19 @@ static inline void BIT_CLEAR(volatile uint8_t* target, uint8_t bit) { *target &=
  *
  */
 
-void pulse_sck()
-{
-  PORTB |= (1 << PB2);
-  PORTB ^= (1 << PB2);
-
-}
-
 void print_data(uint16_t data)
 {
-  //BIT_CLEAR(&PORTB, PB4);
-  //BIT_SET(&PORTB, PB4);
-
-  for (uint16_t i = 0; i < 16; i++)
+  BIT_CLEAR(&PORTB, PB3);
+  for (char i = 0; i < 16; i++)
   {
     data & 0x1 << i
       ? BIT_SET(&PORTB, PB4)
       : BIT_CLEAR(&PORTB, PB4);
-    pulse_sck();
+    // pulse sck...
+    BIT_SET(&PORTB, PB2);
+    BIT_CLEAR(&PORTB, PB2);
   }
-  //BIT_CLEAR(&PORTB, PB4);
-  // pulse_sck();
-  BIT_CLEAR(&PORTB, PB3);
   BIT_SET(&PORTB, PB3);
-
 }
 
 int main(void)
@@ -64,27 +53,29 @@ int main(void)
 
 
   // make all pins output pins...
-  DDRB  = 0xFF;
-  DDRB &= ~(1 << PB0); // makes PB0 an input pin (INT0)
-  PORTB |= (1 << PB0); // activate input resistor
+  // DDRB  = 0xFF;
+  DDRB   = 0b11111110;
+  PORTB |= 1<<PB0; // activate pullup
+  PORTB |= 1<<PB1; // activate receiver
+
+  // DDRB &= ~(1 << PB0); // makes PB0 an input pin (INT0)
+  // PORTB |= (1 << PB0); // activate input resistor
 
   // activate dcf77-receiver...
-  PORTB &=  (1 << PB1); // sets PB1 to low
-  _delay_ms(20);
-  PORTB &= ~(1 << PB1); // sets PB1 to low
+  // PORTB &=  (1 << PB1); // sets PB1 to low
+  // _delay_ms(20);
+  // PORTB &= ~(1 << PB1); // sets PB1 to low
 
 
   cli();
 
-  /*
   GIMSK |= (1<<INT0); // External Interrupt Request 0 Enable
   GIMSK |= (1<<PCIE); // Pin Change Interrupt Enable
 
   // MCU Control Register (controls CPU-behaviours like interrupts & sleepmode)
-  MCUCR |= ~(1<<ISC01) | (1<<ISC00); // any logical change generates interrupt
+  // MCUCR |= ~(1<<ISC01) | (1<<ISC00); // any logical change generates interrupt
   PCMSK |= (1<<PCINT0);
   // INT0_CONTROL = INT0_RISING_EDGE; // going to toggle int0-behaviour
-  */
 
   TCCR0A |= (1 << WGM01);              // CTC mode
   // TCCR0B |= (1 << CS00);
@@ -104,7 +95,13 @@ int main(void)
     // uint16_t t = 1;
     // for (uint16_t i=0; i<16; i++)
     // {
-      print_data(t_current.s);
+      // print_data(t_current.s);
+      // uint16_t p = 0;
+      // for(int i=0; i<sizeof(t_current.s)*__CHAR_BIT__; i++)
+      //   p |= t_current.s & (1<<i);
+
+        print_data(t_current.s);
+      // print_data(t_current.s<<10 | interval | ((PINB & PB0) == 1 ? 2 : 0));
       // t = t<<1;
     // }
     // print_data(t_current.s);
-- 
cgit v1.2.3


From 9cbb0d04bba30988d6e814726800444fa020e845 Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Fri, 26 May 2017 00:02:32 +0200
Subject: Time decoding works.

---
 inc/int/dcf77.c | 58 +++++++++++++++++++++------------------------------------
 inc/int/dcf77.h | 15 +++++++--------
 main.c          | 42 ++++++++++++++++++++---------------------
 3 files changed, 48 insertions(+), 67 deletions(-)

diff --git a/inc/int/dcf77.c b/inc/int/dcf77.c
index 13af50d..31f1663 100755
--- a/inc/int/dcf77.c
+++ b/inc/int/dcf77.c
@@ -1,10 +1,14 @@
 // vim:set et sw=2 ts=2 tw=120:
 #include "dcf77.h"
 
+// 7372800/a=10000
+// 115200 / a * x = 10000
+// 7372800/8/150
+
 // returns -1 on error
 unsigned char getBits(const DCF start, const char len)
 {
-  static const unsigned char mult[]  = {1, 2, 4, 8, 10, 20 ,40 ,80};
+  static const unsigned char mult[]  = {1, 2, 4, 8, 10, 20, 40, 80};
   /// unsigned char p = 1; //parity
   unsigned char r = 0; // retval
   unsigned char i;
@@ -15,32 +19,13 @@ unsigned char getBits(const DCF start, const char len)
   return r;
 }
 
-void set_dcf_value()
-{
-  t_current.m = (getBits(DCF_MIN,      7)) - 1;
-  t_current.h = (getBits(DCF_HOUR,     6));
-  t_current.dd = (getBits(DCF_DAY,     6));
-  t_current.wd = (getBits(DCF_WEEKDAY, 3));
-  t_current.mm = (getBits(DCF_MONTH,   5));
-  t_current.yy = (getBits(DCF_YEAR,    8));
-}
-
-// 7372800/a=10000
-// 115200 / a * x = 10000
-// 7372800/8/150
-
 // interrupt service routine (ISR) for timer 0 A compare match
-/*
-ISR(TIMER0A_COMP_vect) // called 10000 times per second (12000000/8/150)
-{
-
-}
-*/
 ISR(TIMER0_COMPB_vect)
 {
 
 }
 
+// ISR(TIMER0A_COMP_vect)
 ISR(TIMER0_COMPA_vect)
 {
   interval++;
@@ -69,43 +54,42 @@ ISR(INT0_vect)
 
 ISR(PCINT0_vect)
 {
-  interval = 1;
-  /// stdout_put_int(interval, uart_putc);
-  /// stdout_put_string("INT0 call\n", uart_putc);
-  // cli();
-
   // if(INT0_CONTROL == INT0_RISING_EDGE)
   // if(MCUCR & (1<<ISC00))
   // {
   if (interval > 1000 && interval < 2000) // 59th second - no rising edge at the beginning
   {
-    /// if(dcf77_bit == 59) // check if every bit has been transfered
-    // set_dcf_value();  // completely received- apply new time data
+    if(dcf77_bit == 59) // check if every bit has been transfered
+    {
+      t_current.m  = getBits(DCF_MIN,     7);
+      t_current.h  = getBits(DCF_HOUR,    6);
+      t_current.dd = getBits(DCF_DAY,     6);
+      t_current.wd = getBits(DCF_WEEKDAY, 3);
+      t_current.mm = getBits(DCF_MONTH,   5);
+      t_current.yy = getBits(DCF_YEAR,    8);
+    }
 
     // 59th second: synchronize with receiver...
-    TCNT0 = 0;
     dcf77_bit = 0;
     t_current.s = 0;
     t_current.ms = 0;
-    // t_current.us = 0;
+
     // falling edge causes interrupt...
-    // MCUCR &= ~(1 << ISC00);
-    // MCUCR |=  (1 << ISC01);
     // INT0_CONTROL = INT0_FALLING_EDGE;
   }
   else // INT0_FALLING_EDGE
   {
-    dcf77[dcf77_bit++].bit = interval >= 200 ? 1 : 0;
+    if(interval > 50 && interval < 150)
+      dcf77[dcf77_bit++].bit = 0;
+    else if(interval > 150 && interval < 250)
+      dcf77[dcf77_bit++].bit = 1;
 
     // rising edge causes interrupt...
-    // MCUCR |= (1 << ISC00);
-    // MCUCR |= (1 << ISC01);
     // INT0_CONTROL = INT0_RISING_EDGE;
-    // interval = 0; // reset interval to count next interval
   }
 
+  TCNT0 = 0;
   interval = 0;
-  // sei();
 }
 
 /*
diff --git a/inc/int/dcf77.h b/inc/int/dcf77.h
index e47ca4e..2d79cdd 100755
--- a/inc/int/dcf77.h
+++ b/inc/int/dcf77.h
@@ -9,7 +9,6 @@
    */
   #include <avr/io.h>
   #include <avr/interrupt.h>
-
   #include <stdint.h>
 
   #define INT0_CONTROL       MCUCR
@@ -26,14 +25,14 @@
 
   typedef struct
   {
-    uint16_t h ;  // hour
-    uint16_t m ;  // minute
-    uint16_t s ;  // second
+    uint16_t  h;  // hour
+    uint16_t  m;  // minute
+    uint16_t  s;  // second
     uint16_t ms;  // milli second
-    uint8_t yy;  // year
-    uint8_t mm;  // month
-    uint8_t dd;  // day
-    uint8_t wd;  // weekday
+    uint8_t  yy;  // year
+    uint8_t  mm;  // month
+    uint8_t  dd;  // day
+    uint8_t  wd;  // weekday
   } Time;
 
   typedef enum
diff --git a/main.c b/main.c
index 5c8d616..6e86c36 100644
--- a/main.c
+++ b/main.c
@@ -84,7 +84,7 @@ int main(void)
   // OCR0A  |= (1 << WGM01);              // CTC mode
 
   // OCR0A   = 149;
-  OCR0A   = 124;
+  OCR0A   = 125;
   // OCR0A   = CTC_MATCH_OVERFLOW;
   TIMSK  |= (1 << OCIE0A);             // if you want interrupt
 
@@ -92,27 +92,25 @@ int main(void)
 
   while (1)
   {
-    // uint16_t t = 1;
-    // for (uint16_t i=0; i<16; i++)
-    // {
-      // print_data(t_current.s);
-      // uint16_t p = 0;
-      // for(int i=0; i<sizeof(t_current.s)*__CHAR_BIT__; i++)
-      //   p |= t_current.s & (1<<i);
-
-        print_data(t_current.s);
-      // print_data(t_current.s<<10 | interval | ((PINB & PB0) == 1 ? 2 : 0));
-      // t = t<<1;
-    // }
-    // print_data(t_current.s);
-
-
-    /*
-      print_data(0xFFFF);
-      _delay_ms(1000);
-      print_data(0x0000);
-      _delay_ms(1000);
-    */
+    //print_data(lastinterval<<1 | (PINB & PB0));
+     // uint16_t data = 0;
+     // for(int i=0; i<16; i++)
+     // {
+     //   if(i<4)
+     //     data |= (t_current.s & (1<<i));
+     //   else if(i <= 10)
+     //     data |= t_current.m & (1<<(i-4));
+     //   else
+     //     data |= t_current.h & (1<<(i-11));
+     // }
+     // print_data(data);
+
+      print_data(
+          (uint64_t) 0
+          | t_current.h<<8
+          | t_current.m);
+      //print_data(interval | ((PINB & PB0) == 1 ? 2 : 0));
+      // print_data(PINB);
   }
   return 0;
 }
-- 
cgit v1.2.3


From e2b37ffacd2b3e76fd849fc046466568d5ac0779 Mon Sep 17 00:00:00 2001
From: Max Christian Pohle
Date: Thu, 1 Jun 2017 23:58:37 +0200
Subject: Fixed PON pin to be LOW by default

---
 main.c | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/main.c b/main.c
index 6e86c36..9e2cb5d 100644
--- a/main.c
+++ b/main.c
@@ -57,6 +57,7 @@ int main(void)
   DDRB   = 0b11111110;
   PORTB |= 1<<PB0; // activate pullup
   PORTB |= 1<<PB1; // activate receiver
+  PORTB &= ~(1<<PB1);
 
   // DDRB &= ~(1 << PB0); // makes PB0 an input pin (INT0)
   // PORTB |= (1 << PB0); // activate input resistor
@@ -90,27 +91,24 @@ int main(void)
 
   sei();
 
+  for(uint8_t i=0; i<16; i++)
+  {
+    print_data(3<<i);
+    _delay_ms(5);
+  }
+
   while (1)
   {
     //print_data(lastinterval<<1 | (PINB & PB0));
-     // uint16_t data = 0;
-     // for(int i=0; i<16; i++)
-     // {
-     //   if(i<4)
-     //     data |= (t_current.s & (1<<i));
-     //   else if(i <= 10)
-     //     data |= t_current.m & (1<<(i-4));
-     //   else
-     //     data |= t_current.h & (1<<(i-11));
-     // }
-     // print_data(data);
-
-      print_data(
-          (uint64_t) 0
-          | t_current.h<<8
-          | t_current.m);
-      //print_data(interval | ((PINB & PB0) == 1 ? 2 : 0));
-      // print_data(PINB);
+
+    print_data(
+        (uint16_t) 0
+        | ((uint16_t) (PINB & 0x0001))<<15
+        | t_current.h<<8
+        | t_current.m
+        );
+    // print_data(interval | ((PINB & PB0) == 1 ? 2 : 0));
+    //print_data(PINB);
   }
   return 0;
 }
-- 
cgit v1.2.3