diff --git a/.hgignore b/.hgignore
new file mode 100644
index 0000000..b16f296
--- /dev/null
+++ b/.hgignore
@@ -0,0 +1,3 @@
+
+syntax: regexp
+^Release$
\ No newline at end of file
diff --git a/src/main.c b/src/main.c
index 2b8bd96..2477e21 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,11 +6,38 @@
 #include "uartdrv.h"
 
 
+#define START_GAP_MIN 1500
+#define ONE_WIDTH_MIN 170
+#define ONE_WIDTH_MAX 240
+#define ZERO_WIDTH_MIN 70
+#define ZERO_WIDTH_MAX 140
+
+
+typedef struct receivedData_s {
+  uint8_t minuteDigit0;
+  uint8_t minuteDigit1;
+  uint8_t minuteOneCnt;
+  uint8_t hourDigit0;
+  uint8_t hourDigit1;
+  uint8_t hourOneCnt;
+  uint8_t dayDigit0;
+  uint8_t dayDigit1;
+  uint8_t weekdayDigit0;
+  uint8_t monthDigit0;
+  uint8_t monthDigit1;
+  uint8_t yearDigit0;
+  uint8_t yearDigit1;
+  uint8_t dateOneCnt;
+} receivedData_t;
 
 typedef struct clock_s {
   uint8_t hour;
   uint8_t minute;
   uint8_t second;
+  uint8_t day;
+  uint8_t weekday;
+  uint8_t month;
+  uint8_t year;
 } clock_t;
 
 volatile clock_t clock;
@@ -75,8 +102,11 @@ int main() {
   printf("Hello world!\n");
 
 
-  uint8_t start = 0;
+  uint8_t valid = 0;
   uint8_t bit = 0;
+  uint8_t state = 0;
+
+  receivedData_t rd;
 
   while (1) {
     if (tick != 0) {
@@ -85,25 +115,314 @@ int main() {
       uint16_t pulse = (((uint32_t) captValue) * 1000) / 15625;
       uint16_t gap = (((uint32_t) gapValue) * 1000) / 15625;
 
-      if (gap > 1500) {
-        start = 1;
+      if (gap > START_GAP_MIN) {
+        valid = 1;
+        state = 0;
         clock.second = 0;
       }
 
-      if (pulse > 70 && pulse < 130) {
+      if (pulse > ZERO_WIDTH_MIN && pulse < ZERO_WIDTH_MAX) {
         bit = 0;
-      } else if (pulse > 170 && pulse < 230) {
+      } else if (pulse > ONE_WIDTH_MIN && pulse < ONE_WIDTH_MAX) {
         bit = 1;
       } else {
-        bit = 2;
+        valid = 0;
       }
 
-      printf("%02d %02d %02d   %u %u %u %u \n", clock.hour, clock.minute, clock.second, start, bit, pulse, gap);
 
+      if (valid > 0) {
+        switch (state) {
+        case 0:
+          if (bit != 0)
+            valid = 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)
+            valid = 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");
+            valid = 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");
+            valid = 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");
+            valid = 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);
 
+            clock.minute = rd.minuteDigit0 + rd.minuteDigit1 * 10;
+            clock.hour = rd.hourDigit0 + rd.hourDigit1 * 10;
+            clock.day = rd.dayDigit0 + rd.dayDigit1 * 10;
+            clock.weekday = rd.weekdayDigit0;
+            clock.month = rd.monthDigit0 + rd.monthDigit1 * 10;
+            clock.year = rd.yearDigit0 + rd.yearDigit1 * 10;
 
-      start = 0;
-      //printf("tick\n");
+            valid = 2;
+          }
+          break;
+        case 59:
+          break;
+        default:
+          valid = 0;
+          break;
+        }
+
+        printf("VALID   %02d:%02d:%02d %02u.%02u.%02u %u   %u %u %u %u %u \n",
+            clock.hour, clock.minute, clock.second,
+            clock.day, clock.month, clock.year, clock.weekday,
+            valid, state, bit, pulse, gap);
+
+        state++;
+      } else {
+
+        printf("INVALID %u %u %u \n", bit, pulse, gap);
+      }
     }
   }
 }
diff --git a/src/uartdrv.c b/src/uartdrv.c
index 0bf09b7..678dc99 100644
--- a/src/uartdrv.c
+++ b/src/uartdrv.c
@@ -3,10 +3,6 @@
 #include <avr/interrupt.h>
 
 #include "uartdrv.h"
-#include "debug.h"
-
-
-volatile uartdrvCmdBuf_t uartdrvCmdBuf;
 
 
 
@@ -18,24 +14,17 @@ void uartdrvInit() {
   DDRD |= (1 << PD1);
 
   //        transmitter enable
-  UCSRB = (1 << TXEN) | (1 << RXEN) | (1 << RXCIE);
+  UCSRB = (1 << TXEN);
   //        8 data bit, no parity, 1 stop bit
   UCSRC = (1 << UCSZ1) | (1 << UCSZ0);
-  //        19200 Baud @ 16MHz
-  UBRRL = 51;
+  //        115200 Baud @ 16MHz
+  UBRRL = 8;
   UBRRH = 0;
   FILE *mystdout = fdevopen(uartdrvPutchar, NULL);
   stdout = mystdout;
-
-  uartdrvCmdBuf.idx = 0;
-  uartdrvCmdBuf.cmd = 0;
-  uartdrvCmdBuf.cmdStart = 0;
-  uartdrvCmdBuf.cmdDelay = 0;
-  uartdrvCmdBuf.cmdReady = 0;
 }
 
 void uartdrvWrite(uint8_t o) {
-  loop_until_bit_is_clear(PIND, PD2);
   loop_until_bit_is_set(UCSRA, UDRE);
   UDR = o;
 }
@@ -48,46 +37,5 @@ int uartdrvPutchar(char c, FILE *stream) {
   return 0;
 }
 
-void uartdrvCmdCycle() {
-  if (uartdrvCmdBuf.cmdStart == 1) {
-    uartdrvCmdBuf.cmdDelay++;
-    if (uartdrvCmdBuf.cmdDelay > UART_CMD_CYCLES) {
-      uartdrvCmdBuf.idx = 0;
-      uartdrvCmdBuf.cmdStart = 0;
-      uartdrvCmdBuf.cmdDelay= 0;
-      // myPrintf("clear invalid cmd\n");
-    }
-  }
-}
-
-void uartdrvCmdReceived() {
-  uartdrvWrite(0x7f);
-  uartdrvWrite(uartdrvCmdBuf.cmd);
-  uartdrvWrite(0);
-  uartdrvWrite(0);
-  uartdrvWrite(0);
-}
-
-ISR(USART_RXC_vect) {
-  uint8_t c = UDR;
-  if (uartdrvCmdBuf.cmdReady != 1) {
-    if (uartdrvCmdBuf.idx == 0) {
-      uartdrvCmdBuf.cmdStart = 1;
-      uartdrvCmdBuf.cmd = c;
-      uartdrvCmdBuf.idx++;
-    } else if (uartdrvCmdBuf.idx >= 1 && uartdrvCmdBuf.idx <= UART_CMD_BUF_SIZE) {
-      uartdrvCmdBuf.buf[uartdrvCmdBuf.idx - 1] = c;
-      uartdrvCmdBuf.idx++;
-    }
-
-    if (uartdrvCmdBuf.idx == (UART_CMD_BUF_SIZE + 1)) {
-
-      uartdrvCmdBuf.idx = 0;
-      uartdrvCmdBuf.cmdStart = 0;
-      uartdrvCmdBuf.cmdDelay = 0;
-      uartdrvCmdBuf.cmdReady = 1;
-    }
-  }
-}