Ich habe jetzt zusätzlich eine Überprüfung eingebaut, die testet, ob der DCF77-Empfang länger als 10 Minuten läuft und diesen dann abschaltet. Wenn nach 10 Minuten keine 2 brauchbaren Signale empfangen wurden, wird das in nächster Zeit wohl auch nix mehr. Nach 3 Stunden wird dann wieder versucht das Signal sauber zu empfangen – mit etwas Glück klappt es ja dann

Demnächst werde ich die Uhr in ihr Gehäuse einbauen. Dafür möchte ich aber erst eine Folie entwerfen, die ich dann auf die Front aufkleben kann, so dass die verschiedenen Knöpfe und Anzeigen (Alarm 1/2, DCF77-Empfang) auch beschriftet sind. Ich bin noch auf der Suche nach einer selbstklebenden, bedruckbaren Transparenzfolie. Mal sehen, ob es sowas gibt…

Als Lautsprecher benutze ich im Moment einen alten PC-Speaker. Diesen möchte ich aber noch gegen etwas kleineres tauschen, da das Ganze so nicht in das Gehäuse passen wird. Um den Lautsprecher möglichst einfach tauschen zu können, habe ich ihn nicht fest auf die Platine gelötet. Stattdessen habe ich eine kleine zweipolige Stiftleiste benutzt, an die der Lautsprecher dann angesteckt wird. Um die Lautstärke zu begrenzen, benutze ich einen 470 Ohm Widerstand. Die resultierende Lautstärke dürfte morgens eigentlich ganz in Ordnung sein.

Sobald die Uhrzeit die voreingestellte Weckzeit erreicht (und der Alarm natürlich aktiviert ist), wechselt die Uhr in einen neuen Modus (bisher gab es “Zeit anzeigen”, “Alarm 1 einstellen”, “Alarm 2 einstellen” und “Uhrzeit einstellen”), den man normalerweise nicht erreichen kann. Hier wird ganz normal die Uhrzeit angezeigt. Zusätzlich wird aber auch auf einem Ausgang ein Soundsignal erzeugt. Wird eine (beliebige) Taste gedrückt, ist der Alarm vorbei und die Uhr wechselt zurück in den “Zeit anzeigen” Modus. Der Wecker bleibt gestellt.

Um die eingestellten Weckzeiten auch über einen Stromausfall (egal welcher Art) hinweg zu behalten, werden diese nun im EEPROM des µC gespeichert. Um den EEPROM nicht unnötig zu belasten (er ist nur für etwa 100.000 Schreibvorgänge pro Speicherzelle ausgelegt), wird die Weckzeit nur gespeichert, falls sie auch wirklich geändert wurde. Sobald der µC sein Programm startet, lädt er die gespeicherten Weckzeiten aus dem EEPROM.

Das Problem, dass die Uhr plötzlich (ohne Tastendruck) den Modus wechselt, habe ich mittlerweile zusammen mit ein paar anderen lösen können: Ich habe den Anschluss für das Netzteil ausgetauscht und nochmal sauber (und stabil) verlötet. Jetzt wackelt nix mehr und die Spannungsversorgung scheint wirklich stabil zu sein. Jedenfalls springt der µC (bisher) nicht mehr durch die verschiedenen Modi und auch der DCF77-Empfang funktioniert viel besser.

Als letztes neues Feature habe ich nun noch eingebaut, dass sich die Binäruhr nach einem erfolgreichen DCF-Empfang erstmal nicht neu synchronisieren will, sondern dies nur alle 3 Stunden tut. Das sollte für eine genaue Zeitanzeige auf jeden Fall genug sein und evtl. noch ein paar Ressourcen des µC für zukünftige Features frei halten.

Ok, als letztes gibt es jetzt noch den Sourcecode und den aktualisierten Schaltplan. Achtung: Der Schaltplan ist doch etwas unübersichtlich geworden – ich hoffe, man kann noch alles erkennen. Evtl. werde ich demnächst noch eine etwas aufgeräumtere Version online stellen.

[Klick für größere Version]

Ich habe jetzt damit begonnen, ein paar Weckerfunktionen zu implementieren. Dafür habe ich der Uhr einen Taster zum Wechsel zwischen den verschiedenen Modi und noch zwei zusätzliche (rote) LEDs spendiert, die den Alarmstatus (ja, genau: zwei LEDs = zwei Weckzeiten) anzeigen: Leuchtet die erste rote LED, ist Alarm 1 aktiviert. Blinkt diese, stellt man gerade die erste Weckzeit ein. Wenn sie langsamer blinkt, ist der Alarm aktiv. Genauso funktioniert die zweite LED. Blinken beide LEDs, kann man die Uhrzeit ändern. Dafür habe ich einen eigenen Modus gewählt, damit im “normalen” Modus die Zeit nicht verstellt wird und die beiden anderen Taster zum Aktivieren der beiden Alarme genutzt werden können.

Momentan verhält sich die Uhr etwas merkwürdig: Sie springt ab und zu unmotiviert von einem Modus in den nächsten ohne dass eine Taste gedrückt worden wäre. Merkwürdig… ich muss wohl nochmal auf die Suche nach einem Kurzschluss oder Wackelkontakt gehen.

Außerdem habe ich einen 12 Ohm Serienwiderstand, der den Strom für alle LEDs begrenzt hat, gegen einen Transistor getauscht. Dieser wird über einen Fotowiderstand gesteuert, um die LEDs bei Dunkelheit etwas zu dimmen, damit bei Nacht nicht das ganze Zimmer beleuchtet wird

Den aktualisierten Schaltplan dazu gibt es demnächst, wenn alles so klappt, wie es soll…

Ich habe auch mal mit der Sounderzeugung mit Hilfe des AVR experimentiert: Wieder über einen Transistor habe ich einen Lautsprecher angeschlossen. Der Transistor wird diesmal von einem Port des AVR gesteuert, der mit einer bestimmten Frequenz ein- und ausgeschaltet wird. Im Moment benutze ich eine Überlagerung von 1000 und 440Hz. Dadurch entsteht ein Geräusch, das einen bestimmt wach kriegt, aber auch nicht zu fies klingt.

Ich habe den Lautsprecher noch nicht an die Binäruhr angeschlossen, da ich erst einmal das Problem der springenden Modi lösen möchte, bevor ich die nächste Baustelle anfange. Außerdem weiß ich auch noch nicht genau, wie ich die Sounderzeugung sinnvoll in den Code der Uhr einfüge, aber das wird sich schon noch lösen lassen… auf jeden Fall gibt es deswegen aber auch keinen neuen Code für euch.
Ach ja: Ich kann nur empfehlen, das DCF-Modul mit der Antenne auf einen starren Streifen Pappe zu kleben. Seitdem ich das gemacht habe, habe ich viel weniger Probleme damit.

Aber bis es soweit war, gab es noch einige Probleme:

• Die Spannung war für das Funkmodul nicht stabil genug und musste stabilisiert werden.
• Das dürftige “Handbuch” des Funkmoduls musste verstanden werden
• und zu guter Letzt ist natürlich auch noch die Antenne des Modules abgerissen, so dass ich sie auch erstmal wieder anlöten musste

In dem Handbuch zum Funkmodul wird – in Worten – erklärt, wie das Modul zu beschalten ist. Leider ist ein nicht ganz unwichtiger Punkt aber etwas schwammig formuliert: Das Modul lässt sich anscheinend in eine Art Schlafmodus versetzen. Dazu muss einer der vier Anschlüsse auf hohes Potential gelegt werden. Zum Einschalten soll er auf GND liegen. Soweit die Theorie. In der Praxis hat sich jetzt gezeigt, dass dieser Anschluss wohl intern bereits auf GND liegt und eine externe Beschaltung Probleme bereitet. Jedenfalls habe ich diesen Anschluss jetzt unbeschaltet gelassen und so scheint es zu funktionieren. Die anderen Anschlüsse sind +5V, GND und DCF. An DCF liegt das (invertierte) Signal an, das das Modul empfängt.

Normalerweise besteht das DCF77-Signal aus einem High-Pegel, der zu Beginn jeder Sekunde auf 25% der Leistung abgesenkt wird. 100ms für eine logische 0 und 200ms für eine logische 1. (Weitere Details gibt es hier.) Die Inversion bewirkt jetzt, dass das Signal an DCF grundsätzlich auf niedrigem Potential liegt und zu Beginn jeder Sekunde für 100 bzw. 200ms auf +5V gezogen wird.

Für einen “sauberen” Betrieb des Funkmoduls wird eine Spannung zwischen 1,2 und 5V benötigt, die im Betrieb allerdings um weniger als 0,1V schwanken darf. Bisher konnte ich meine Schaltungen einfach mit einem 5V Netzteil betreiben ohne Probleme zu kriegen. Aber für das Modul schien das nicht mehr zu reichen, so dass ich einen 7805-Baustein zusammen mit 3 Kondensatoren (2x100nF KerKo, 1×10µF ELKO) einbauen musste. Dieser erzeugt nun aus 7V Eingangsspannung eine stabilisierte Spannung von 5V, die auch dem mäkeligen Funkmodul genügt.

Bei dem nun folgenden häufigen Programmieren und damit verbundenem Bewegen der Schaltung, habe ich wohl die Antenne etwas zu viel und falsch bewegt, so dass sie sich schließlich vom Funkmodul gelöst hat. Mit etwas Arbeit ließ sie sich aber wieder anlöten, was sich aber schon recht schwierig gestaltet hat, da die dünnen Anschlusskabel die Wärme des Lötzinns nicht richtig ableiten konnten und so der Zinn nicht abkühlen konnte um zu erstarren… naja, schließlich und endlich hat es aber geklappt.

Den Code für die Auswertung des DCF-Signals habe ich von dieser Seite teilweise übernommen und angepasst. Meinen Code gibt’s dann auch hier. Die Funktionalität wurde nur um die DCF77-Routinen erweitert.

Auch das neue Schaltbild gibt es natürlich:

Hier sind auch alle Neuerungen eingetragen. Ich musste die Anschlüsse für die Stundenanzeige verändern, da ich den Pin für den externen Interrupt vorher belegt hatte.

Für die Zukunft steht jetzt noch ein Summer/Lautsprecher an, mit dem dann eine Weckfunktionalität hinzukommen kann. Ich werde mal ein wenig experimentieren, was sich da so machen lässt. Ein Gehäuse habe ich mittlerweile auch, allerdings werde ich die Uhr vorerst da noch nicht einbauen.

Im Moment scheint der Anschluss des DCF-Moduls einen Wackelkontakt zu haben, denn ab und zu empfängt die Uhr die aktuelle Zeit nicht Eventuell befestige ich das Modul und die Antenne noch auf einem starren Stückchen Pappe oder so um zusätzliche Bewegung und somit Belastung für die eh schon schlechte Verbindung zu vermeiden…

Eine Sekunde ist definitionsgemäß das 9.192.631.770-fache der Periode einer Mikrowelle, die mit einem ausgewählten Niveauübergang im Caesiumatom in Resonanz ist. Anders gesagt: das 9.192.631.770-fache der Periodendauer der dem Übergang zwischen den beiden Hyperfeinstrukturniveaus des Grundzustandes von Atomen des Nuklids ¹³³Cs entsprechenden Strahlung.
http://de.wikipedia.org/wiki/Sekunde

Von all dem weiß der AVR aber nichts. Gemäß seinem internen Takt von 1MHz besteht eine Sekunde aus einer Millionen Takte. Da der interne Takt aber recht ungenau ist, ist auch eine Sekunde für den AVR nicht so genau definiert. Möchte man den AVR aber z.B. als Uhr benutzen, ist das sehr unpraktisch. Abhilfe muss also her.

Deswegen wollte ich – schon bevor ich die falschen Fuse-Bits gesetzt habe – einen externen Quarz-Kristall mit dem AVR verbinden, um ein stabiles Taktsignal zu haben. Da ich in dem Datenblatt etwas über einen externen 32.768kHz Kristall gelesen hatte, für den der AVR ausgelegt sei, hatte ich diesen zuerst versehentlich für einen Ersatz zum internen Taktgeber gehalten. Daher auch der Artikel “Fuse-Bits sind böse…“.

Nachdem ich diesen Fehler wieder hingebogen habe, habe ich den externen Kristall mit den korrekten Eingängen TOSC1 und TOSC2 verbunden. Nachdem ich dann noch den zweiten Timer so eingestellt habe, dass er den externen Resonator auch verwendet, hatte ich plötzlich ein recht stabiles Signal von 32.768kHz zur Verfügung.

Auch wenn diese Zahl auf den ersten Blick recht unhandlich aussieht, fällt auf, dass sie sich prima durch z.B. 1024 teilen lässt – eine Zahl, die der AVR auch mag Also benutze ich einen Vorteiler von 1024 und löse alle 32768/1024 = 32 Takte einen Interrupt aus – also genau 1 Mal pro Sekunde.

Dieser Takt ist bedeutend genauer als der Takt des AVR. Mit diesem hatte ich innerhalb von 24 Stunden einen Fehler von mehr als 5 Minuten. Mit dem Uhrenquarz hatte ich in 12 Stunden einen Fehler kleiner als eine Sekunde. Wenn das mal kein Unterschied ist

Hier noch einige ausgewählte Code-Schnipsel, die das eben gesagte verdeutlichen sollen:

void main(){
//…
ASSR |= 1< TCCR2 = (1<<<
TIMSK |= 1<
//...
}
SIGNAL (SIG_OVERFLOW2){
TCNT0 = -32; // 1s: Prescaler 1024, resonator freq. 32.768kHz
// ...
}

Der Rest des Codes sollte eigentlich recht unverändert geblieben sein. Ich stelle ihn trotzdem mal zum Download, damit ihr einen Gesamteindruck kriegt

Mein nächster Plan ist jetzt, den AVR noch mit einem Funkmodul auszustatten, über das er sich die aktuelle Atomzeit besorgen kann, um auch den kleinen Gangunterschied des Quarzes zu korrigieren…

Die LEDs leuchten bei mir so hell, dass man die Zeit nicht richtig ablesen kann, weil man geblendet wird. Außerdem könnte man die Uhr nachts sogar als Lampe benutzen Das macht also keinen Sinn. Ich habe mir erstmal so geholfen, dass ich einen zusätzlichen 12 Ohm Widerstand in den gemeinsamen Masseanschluss aller LEDs gelötet habe. Die Anzeige ist dadurch schon etwas angenehmer geworden. Aber wahrscheinlich werde ich den Widerstandswert noch etwas erhöhen.

Außerdem habe ich gemerkt, dass es sehr unpraktisch ist, wenn ich jedes Mal den µC ausbauen muss, wenn ich ihn umprogrammieren will. Daher habe ich einen Anschluss für das Programmierinterface auf die Platine gelötet und passend verdrahtet. Bisher hatte ich den AVR immer auf meinem Breadboard programmiert. Der Programmieradapter besteht aus einem Anschluss für den Parallelport des PC, einem Kabel, zwei Widerständen und einer fünfpoligen Stiftleiste (gemäß dieser Anleitung). Ich habe also einfach noch eine fünfpolige Stiftleiste auf die Platine gelötet und mit dem µC verbunden. Jetzt kann ich den AVR also auch direkt in der Uhr programmieren – ein netter Nebeneffekt des Ganzen ist, dass beim Programmieren einige LEDs aufleuchten, da sie an demselben Port wie das Programmierinterface hängen

Mir ist auch aufgefallen, dass meine erste Idee, nämlich die LEDs als Matrix zu verkabeln – was die Anzahl der nötigen I/O-Pins und den Verdahtungsaufwand drastisch reduziert hätte – auch möglich gewesen wäre. Ich hatte diese Möglichkeit aber anfangs ausgeschlossen, da ich dachte, dass ich dann nicht jede beliebige Kombination an LEDs zum Leuchten bringen könnte. Aber das ist ja auch gar nicht nötig: Die LEDs müssen nicht ständig leuchten, d.h. ich hätte einen Zeitmultiplex anwenden können… naja, die jetzige Variante hat den Vorteil, dass die Programmierung recht einfach ist. Also: Wer fit mit dem Lötkolben ist und ausreichend I/O-Ports hat, kann meine Verkabelung nutzen – wer das nicht ist/kann/will, benutzt eine Matrixverdrahtung und muss den Code dann nur noch etwas anpassen.

Im Moment spiele ich mit dem Gedanken, ein DCF77-Modul (z.B. von Reichelt oder Conrad) in die Schaltung zu integrieren. Das hätte einige Vorteile:

• Da der interne Oszillator des AVR nicht sehr genau ist, treten nach einiger Zeit schon Gangunterschiede auf – ok, das ließe sich in Software noch ein wenig ausbessern, aber eben nur bis zu einem bestimmten Punkt.
• Man spart sich das lästige Einstellen der Uhrzeit
• und zu guter Letzt ist es doch einfach ziemlich cool, oder?

Als zusätzliche Feature habe ich mir überlegt, noch einen Summer und einen zusätzlichen Taster einzubauen, um eine Weckerfunktionalität zu erzeugen. Die zusätzliche Taste wäre nötig, um den Modus zu wechseln: Entweder Taste nicht gedrückt, dann stellt man mit den anderen beiden Tasten die normale Uhrzeit ein oder Taste gedrückt, dann stellt man die Alarmzeit ein. Außerdem wäre dann noch eine LED nützlich, die den aktuellen Alarmzustand (ein/aus) anzeigt, damit man nicht aus Versehen geweckt wird
In Kombination mit dem Funkmodul ließe sich der zusätzliche Taster einsparen, da man die Uhrzeit wahrscheinlich nicht mehr verstellen möchte. Den gesparten Taster könnte man gegen noch eine LED austauschen, die zusätzliche Alarmmodi anzeigt: Ich denke da z.B. an einen Alarmmodus, der nur in der Woche klingelt – oder mehrere Weckzeiten – auch wenn das dann doch noch zusätzliche Taster erfordern würde… die Möglichkeiten sind doch recht umfangreich.

Falls ich das DCF77-Funkmodul nicht dazubaue, werde ich auf jeden Fall einen externen Quarzoszilliator hinzufügen, um einen genaueren Takt zu erhalten. Bis ich den habe, werde ich mal sehen, was sich an der Software noch optimieren lässt…

Ihr benötigt folgende Komponenten:

• 20 blaue LEDs
• 20 12 Ohm Widerstände
• 2 10k Ohm Widerstände
• 1 Streifenrasterplatine (10cmx10cm)
• 8adriges Flachbandkabel
• 2 Kurzhubtaster
• Anschlussklemme für DC-Netzteil
• 40-Pin Sockel für Microcontroller
• Microcontroller (z.B. ATMega32)

Ich habe einen Schaltplan erstellt nach dem ihr die Schaltung aufbauen könnt.

Als erstes habe ich alle Bauteile auf die Platine gesetzt, um zu sehen, wo ich die Leiterbahnen der Streifenrasterplatine durchtrennen muss, um die nötigen “Isolationen” zwischen den Bauteilen zu erzeugen. Wichtig ist hierbei besonders, die einzelnen Pins des Sockels für den Microcontroller voneinander zu isolieren. Auch die Anoden der LEDs müssen voneinander getrennt sein, damit es möglich ist, sie einzeln anzusteuern. Die Kathoden habe ich zeilenweise auf gleiches Potential gelegt. Auch die Schalter müssen voneinander isoliert sein, um einen eindeutigen Schaltvorgang zu erhalten.

Dann habe ich die 20 12 Ohm Widerstände auf die Platine gesteckt und angelötet. Im Anschluss habe ich die 2 Schalter, die 10k Ohm Widerstände und den Sockel an ihre vorgesehenen Positionen gelötet. Das Ganze sah dann in etwa so aus:

Nun geht es daran, die LEDs auf der Platine zu befestigen. Hierbei ist es wichtig, die Polarität der Dioden zu beachten. Ich habe die Kathoden auf die gemeinsame Leiterbahn gesetzt, so dass nur ein Masseanschluss pro Zeile nötig ist.

Jetzt kommt nochmal ein etwas schwierigerer Teil: Da unsere Platine nur einseitig bedruckt ist, muss die restliche Verdrahtung zwischen Microcontroller und den LEDs “fliegend” erfolgen. Dazu habe ich das achtadrige Flachbandkabel verwendet und in je 2 vieradrige Teile geteilt, so dass immer eine Zeile verkabelt wird. Wenn man die Verkabelung hier sinnvoll macht, spart man sich hinterher eine Menge Arbeit beim Programmieren des Microcontrollers Tipp: Es ist sinnvoll die LEDs entsprechend ihrer Wertigkeit mit den Ausgängen des Microcontrollers zu verbinden.

Außerdem muss natürlich auch für die Spannungsversorung des AVR gesorgt sein, die Schalter müssen angeschlossen werden und die Masseanschlüsse der LEDs müssen verbunden sein… so sieht’s bei mir aus:

Als Letztes fehlt noch die Anschlussklemme für die Spannungsversorgung, die auf die dafür vorgesehenen Leiterbahnen gelötet wird. Bei mir gab es ein kleines Problem mit der Spannungsversorgung (Wackelkontakt), so dass ich noch eine Kontroll-LED mit Vorwiderstand (12k Ohm) eingebaut habe, um zu sehen, ob die Schaltung mit Strom versorgt wird. Und auch hiervon gibt es wieder ein nettes Bildchen:

Auf dem Bild fehlt noch der Microcontroller und das hat auch seinen Sinn, denn bisher fehlt ja noch die nötige Software für unsere Uhr:

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

typedef unsigned char u8;
typedef signed short s16;

#define XTAL 1e6 // 1MHz = 1 * 10^6

#define KEY_PIN PINC
#define HOURS PORTD
#define MINS PORTB
#define SECS PORTA
#define BUT_PORT PORTC
#define BUT_HOUR PINC0
#define BUT_MIN PINC1

#define REPEAT_MASK (1<<BUT_HOUR^1<<BUT_MIN)
#define REPEAT_START 50 // after 500ms
#define REPEAT_NEXT 20 // every 200ms

u8 key_state; // debounced and inverted key state:
// bit = 1: key pressed
u8 key_press; // key press detect

u8 key_rpt; // key long press and repeat

static unsigned int count = 0;

static u8 hours_1st = 0, hours_2nd = 0;
static u8 minutes_1st = 0, minutes_2nd = 0;
static u8 seconds_1st = 0, seconds_2nd = 0;

SIGNAL (SIG_OVERFLOW0) // every 10ms
{
static u8 ct0, ct1, rpt/*, hours, minutes, seconds */;
/* static unsigned int count; */
u8 i;

TCNT0 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5); // preload for 10ms

i = key_state ^ ~KEY_PIN; // key changed ?
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
i &= ct0 & ct1; // count until roll over ?
key_state ^= i; // then toggle debounced state
key_press |= key_state & i; // 0->1: key press detect

if( (key_state & REPEAT_MASK) == 0 ) // check repeat function

rpt = REPEAT_START; // start delay
if( –rpt == 0 ){
rpt = REPEAT_NEXT; // repeat delay
key_rpt |= key_state & REPEAT_MASK;
}

count++;
if (count >= 100){
seconds_2nd++;
count = 0;
if (seconds_2nd >= 10){
seconds_1st++;
seconds_2nd = 0;
if (seconds_1st >= 6){
minutes_2nd++;
seconds_1st = 0;
if (minutes_2nd >= 10){
minutes_1st++;
minutes_2nd = 0;
if (minutes_1st >= 6){
hours_2nd++;
minutes_1st = 0;
if (hours_2nd >= 10){
hours_1st++;
hours_2nd = 0;
if (hours_1st >= 2 && hours_2nd >= 4){
hours_1st = 0;
hours_2nd = 0;
}
}
}
}
}
}
}
}

u8 get_key_press( u8 key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_press; // read key(s)
key_press ^= key_mask; // clear key(s)
sei();
return key_mask;
}

u8 get_key_short( u8 key_mask )
{
cli(); // read key state and key press atomic !
return get_key_press( ~key_state & key_mask );
}

u8 get_key_long( u8 key_mask )
{
return get_key_press( get_key_rpt( key_mask ));
}

int main( void )
{
u8 x;

unsigned int flicker = 0;

DDRA = 0xff;
DDRB = 0xff;
DDRC = 0×00;
DDRD = 0xff;

PORTA = 0×00;
PORTB = 0×00;
PORTD = 0×00;

for (x=0; x<7; x++){
SECS = (1< _delay_ms(500);
}
SECS = 0x00;

for (x=0; x<7; x++){
MINS = (1<
_delay_ms(500);
}
MINS = 0x00;

for (x=0; x<6; x++){
HOURS = (1<
_delay_ms(500);
}
HOURS = 0x00;

TCCR0 = 1<<
TIMSK = 1<

sei();

for(;;){ // main loop

flicker++;
if (flicker < 50){
HOURS = (hours_1st<<4)|(hours_2nd);
MINS = (minutes_1st<<4)|(minutes_2nd);
SECS = (seconds_1st<<4)|(seconds_2nd);
} else if (flicker > 50 && flicker < 100){
HOURS = 0x00;
MINS = 0x00;
SECS = 0x00;
flicker = 0;
}

// short press
if( get_key_short( 1<
hours_2nd++;
seconds_1st = 0;
seconds_2nd = 0;
if (hours_2nd >= 10){
hours_1st++;
hours_2nd = 0;
if (hours_1st >= 2 && hours_2nd >= 4){
hours_1st = 0;
hours_2nd = 0;
}
}
}

// long press
if( get_key_long( 1< hours_2nd += 2;
seconds_1st = 0;
seconds_2nd = 0;
if (hours_2nd >= 10){
hours_1st++;
hours_2nd = 0;
if (hours_1st >= 2 && hours_2nd >= 4){
hours_1st = 0;
hours_2nd = 0;
}
}
}

// short press
if( get_key_short( 1< minutes_2nd++;
seconds_1st = 0;
seconds_2nd = 0;
if (minutes_2nd >= 10){
minutes_1st++;
minutes_2nd = 0;
if (minutes_1st >= 6){
hours_2nd++;
minutes_1st = 0;
if (hours_2nd >= 10){
hours_1st++;
hours_2nd = 0;
if (hours_1st >= 2 && hours_2nd >= 4){
hours_1st = 0;
hours_2nd = 0;
}
}
}
}
}

// long press
if( get_key_long( 1< minutes_2nd+=5;
seconds_1st = 0;
seconds_2nd = 0;
if (minutes_2nd >= 10){
minutes_1st++;
minutes_2nd = 0;
if (minutes_1st >= 6){
hours_2nd++;
minutes_1st = 0;
if (hours_2nd >= 10){
hours_1st++;
hours_2nd = 0;
if (hours_1st >= 2 && hours_2nd >= 4){
hours_1st = 0;
hours_2nd = 0;
}
}
}
}
}
}
}

Den Code für die Binäruhr gibt es auch hier nochmal etwas ordentlicher formatiert zum Download.

Die Software funktioniert soweit vollständig. Bei mir zeigt sie allerdings zu Beginn ein merkwürdiges Verhalten: Nachdem die Anzeige drei Sekunden anzeigt, springt die Zeit plötzlich auf 2 Stunden und 5 Minuten vor… da ist also noch irgendwo ein Bug

Schön finde ich das Feature, bei einem längeren Tastendruck einen “schnellen Vorlauf” zu haben. Das spart etwas Zeit, wenn man eine etwas spätere Stunde (oder besonders Minute) einstellen will. Allerdings wäre es hier noch sinnvoll, die Zeit für “lang” auf ein paar Sekunden zu erhöhen, da sonst nur sehr selten ein kurzer Druck erkannt wird. Der Code hierfür stammt größtenteils von hier.
Interessant ist vielleicht auch noch, dass die LEDs eigentlich nur die Hälfte der Zeit überhaupt an sind. Das spart eine Menge Strom und besonder Abwärme Und für das Auge ist aufgrund der hohen Frequenz nicht mal ein Flackern wahrnehmbar.

Als nächstes möchte ich evtl. noch ein passendes Gehäuse für die Uhr finden – dann sieht das ganze gleich nach viel mehr aus Außerdem stört dann die Verkabelung hinten nicht mehr so sehr.

]]> http://blog.elvizz.net/2006/04/27/binaeruhr/feed/ 0