I live close to the DCF77 radio transmitter, so my signal was always pretty strong and clear. This is of course not the case for everybody :-) Gwen Roelants did run into problems. He writes:

Although your code works (thanks for that!) it looked like it was very sensitive to how the antenna was positioned.
I found that I did receive a signal every second, but that for the longer signals, I sometimes got a short flash interrupting it, causing the library to add 2 seconds instead of one. Since I got such a flash in almost every minute it could take a very long time before a proper sync was found, and because 2 seconds were counted the time would also drift during the time no new signal could be decoded.
I found a rather simple fix for your code that greatly improved the reliability and time to find a correct signal.

I don’t have an Arduino around so I did not test it, but the proposed changes seem to be reasonable. You can find the changes in the Arduino forums. Thanks, Gwen!

The photo was CCed on flickr by Nathan Gibbs.

Thanks to Lasse Lambrecht, I can release a new version of the DCF77 code – now you can run it on the ATMega168-based Arduinos.

During the upgrade of my Arduino, I used the mySmartUSB programmer – initially on my Windows box, but since it’s USB and it mimics the AVR910 protocol, you can use it with avrdude on your Mac. Here’s how.

Note: This currently only works for PowerPC-based Macs. Silicon Laboratories is not able to get a Intel Mac driver out – see http://www.surveyor.com/cgi-bin/yabb2/YaBB.pl?num=1161916754/4

First of all, you need to install the USB driver for the chipset used in the programmer – it’s a CP2102 from Silicon Laboratories. You can download a driver from chip45. So go ahead and download it. Once it is installed, plug in the programmer. A file

/dev/cu.SLAB_USBtoUART

shows up – this is the USB-to-UART device that you can use with avrdude.I installed the latter using Macports, if you install it from another source, please make sure it is at least v5.3 – older versions do AFAIK not support the ATMega168.

By default, the avrdude.conf does not contain the right device code for the AVR910 protocol. Open /opt/local/etc/avrdude.conf and make sure the following line is in the ATMega168 definition:

avr910_devcode = 0x06;

When everything is set, you can use the command

avrdude -p m168 -P /dev/cu.SLAB_USBtoUART -c avr910 -t -u

to get to avrdude’s terminal mode – you can use e.g. ‘sig’ to print the signature of your ATMega chip.

You can buy the mySmartUSB programmer from myAVR – currently, it costs EUR 28,-.

I just upgraded by little Arduino to the ATMega168 – and basically doubled the memory. But, be warned: This is not a hassle-free procedure if you have not some experience with microcontrollers.

I bought a cheap serial programmer – only to figure out that the firmware is outdated and the ATMega168 is not supported. You can update the firmware – but you need another programmer for this *grmp*. So I bought a not-so-cheap mySmartUSB which runs over USB (so there is a chance it will work on the mac, I already found a driver for the USB chipset – stay tuned.)

Today, most programmers come with a 10-pin header (aka Kanda connector), but the Arduino uses the old 6-pin ICSP header. I soldered a converter to solve this. Once I succeeded with the electrical connection, I failed in using avrdude – programming went fine, but I wasn’t able to set the fuse bits. Finally, I have found AvrOspII which worked perfectly on my Windows box. Please read Wolf Paulus’ description to save yourself a lot of time (and broken ATMegas) – he has written a great article about the fuse settings.

If you’re interested in a pre-flashed Arduino, send me an email.

PS: picture CC’ed by opk on flickr.

The sketch for decoding the time radio signal DCF77 is greatly improved: I use interrupts for handling the signal and a backup timer has been added.

Note that there is no interface at the moment, the time is simply put to the serial line. But it should be easy to add a display to show the time. The sketch eats roughly 6000 bytes of memory – if you want to add a user interface, you should consider buying a 16 kb Arduino ;-)

Of course, you also need the DCF77 receiver module and a pullup-resistor, as described in my old post.

You can download the code here:

• arduino-dcf77-clock-0.2.0.tar.bz

BTW: The picture above shows a Nixie tube clock. I ripped the picture shamelessly from flickr, there’s a photostream showing the creation of the clock. Cool project.

This is the code:

#include < avr / interrupt.h >
#include < avr / io.h >

#define INIT_TIMER_COUNT 0
#define RESET_TIMER2 TCNT2 = INIT_TIMER_COUNT

int ledPin = 13;
int int_counter = 0;
volatile int second = 0;
int oldSecond = 0;

// Aruino runs at 16 Mhz, so we have 61 Overflows per second...
// 1/ ((16000000 / 1024) / 256) = 1 / 61
ISR(TIMER2_OVF_vect) {
  int_counter += 1;
  if (int_counter == 61) {
    second+=1;
    int_counter = 0;
  }
};

void setup() {
  Serial.begin(9600);
  Serial.println("Initializing timerinterrupt");
  //Timer2 Settings:  Timer Prescaler /1024
  TCCR2 |= ((1 < < CS22) | (1 << CS21) | (1 << CS20));
  //Timer2 Overflow Interrupt Enable
  TIMSK |= (1 << TOIE2);
  RESET_TIMER2;
  sei();
}

void loop() {
  if (oldSecond != second) {
    Serial.print(second);
    Serial.println(".");
    oldSecond = second;
  }
}

Unfortunately, the counter is not increased every second but every three seconds. I need to investigate this. Anyway, it seems to be more reasonable to use the CTC mode (clear-timer-on-compare-match). I need to read the datasheet ;-)

For my DCF77 clock project, I need an understanding of handling interrupts with the ATMega8 chip – here’s my sketch.

The ATMega8 provides two pins (2 and 3) which can trigger software interrupts when the attached digital signal changes. You can use this to be “notified” when the external signal changes. Therefore, you do not need to poll the pin periodically – the interrupt routine will be invoked automatically when the specified signal change happens.

In my case, I want to be notified when the DCF77 signal changes, so I need a simple way to exchange the current value of the pin. Here is the sketch:

// Definition of interrupt names
#include < avr/io.h >
// ISR interrupt service routine
#include < avr/interrupt.h >


// LED connected to digital pin 13
int ledPin = 13;
// This is the INT0 Pin of the ATMega8
int sensePin = 2;
// We need to declare the data exchange
// variable to be volatile - the value is
// read from memory.
volatile int value = 0;

// Install the interrupt routine.
ISR(INT0_vect) {
  // check the value again - since it takes some time to
  // activate the interrupt routine, we get a clear signal.
  value = digitalRead(sensePin);
}


void setup() {
  Serial.begin(9600);
  Serial.println("Initializing ihandler");
  // sets the digital pin as output
  pinMode(ledPin, OUTPUT);
  // read from the sense pin
  pinMode(sensePin, INPUT);
  Serial.println("Processing initialization");
  // Global Enable INT0 interrupt
  GICR |= ( 1 < < INT0);
  // Signal change triggers interrupt
  MCUCR |= ( 1 << ISC00);
  MCUCR |= ( 0 << ISC01);
  Serial.println("Finished initialization");
}

void loop() {
  if (value) {
    Serial.println("Value high!");
    digitalWrite(ledPin, HIGH);
  } else {
    Serial.println("Value low!");
    digitalWrite(ledPin, LOW);
  }
  delay(100);
}

In the main loop, the value gets interpreted, but not read. This happens in the interrupt handler routine. The routine is installed with the avrgcc preprocessor macro “ISR” – this way, we do not need to fiddle with the interrupt vector directly. During the setup function, be careful to initialize the ATMega8 correctly – in this case, we need to enable the INT0 interrupt. With the MCUCR register, we can change the way the interrupt gets triggered – here, we receive an interrupt when the signal changes in both directions (HIGH -> LOW and LOW -> HIGH).

The wiring for the testing is rather simple: Use a breadboard and power it from the Arduino. Connect a pull-up resistor to positive and the other end to pin 2 of your Arduino. Connect an additional cable from the “other end” of the resistor to negative. If you pull the latter cable from negative, the current on pin 2 will go to HIGH, if you reconnect it to negative, it will go to LOW. You could also use a switch, of course ;-)

If you speak german, I highly recommend the “AVR-GCC Tutorial” of mikrocontroller.net.

As a first sketch, I developed a little DCF77 library for the arduino. The DCF77 sender broadcasts the exact time in Germany. It uses a binary format which needs to be decoded – which is exactly what the library does.

There are others around who wrote a DCF77 decoder: I would like to thank Captain for his DCF77 code. You need to have an Arduino and a DCF77 receiver in order to use this sketch.

I use the “DCF-Empfänger BN 641138″ of Conrad. You need a pull-up resistor as displayed here:

When everything is connected, the exact time is printed on the serial line. Note that this is a very early release of the software – there is a lot of functionality missing. From the README:

The current todo list is:
 * Use interrupt routines for detecting signal changes
 * Use interrupt routines to add seconds automatically
   (currently, the 59th second is shown properly)
 * Implement parity checks to prevent faulty time
   signals to be evaluated

The sketch eats up 6400 of the 7168 bytes in the Arduino. I am currently considering to upgrade my board to the ATMega 168 processor in order to have 16kb of memory…

You can download the code here:

• dcf77-arduino-0.1.tar.gz

The code is released under terms of the CC-GNU GPL.