Arduino - Textuhr von φ

Diese Textuhr läuft in Ihrem Browser und benötigt, dass «JavaScript» eingeschaltet ist.

Du suchst ein Arduino-Projekt oder Du wolltest schon lange Deine eigene Textuhr basteln? Dann bist Du hier bei dieser Projektvorstellung genau richtig. Auf dieser Seite, zeige ich Dir, wie Du die Elektronik für eine eigene Textuhr aufbauen kannst. Wie die Uhr ein ein Gehäuse verpackt werden könnte, zeige ich hier.

Motivation

Die Hauptmotivation für den Eigenbau einer Textuhr könnte ich nicht besser formulieren:

«Just for fun!» (Linus Torvalds: Erfinder von Linux)

Motiviert zum Projekt dieser Textuhr hat mich der Arduino und einige Exemplare von Textuhren in Schaufenstern. Die folgende Webseite hat mich dann aber vollends überzeugt, so etwas selbst zu basteln: ubetz.de/arduino/uhr/.
Vielen Dank, Ulli!
Das Programmieren übernehme normalerweise ich, wobei ich das Löten gerne meinen Kindern (8 und 11) überlasse. Diesmal habe ich das Gehäuse des Prototyps mit Legos^TM gebaut, sodass meine Kinder noch mehr mithelfen konnten als sonst.

Code

/**
 * Text Uhr
 * --------
 * @author   philipp gressly freimann (phi@gressly.eu)
 * @date     2016-02-23
 * @version  2016_02_23
 * @license  GPL (http://www.gnu.org/licenses/gpl-3.0.de.html)
 *
 * Variation of http://ubetz.de/arduino/uhr/
 *
 * Diese vorliegende Lösung bedient sich ebenfalls dreier
 * Shift-Register.des Typs 74HC595.
 * Die Möglichkeit nur einen AT-Mega zu verwenden und mit sechs
 * Ausgängen die 22 Dioden zu "chralieplexen" (nach Charlie Allen)
 * habe ich (noch) nicht ins Auge gefasst, wäre jedoch mit Abstand
 * die Lösung mit den wenigsten Kabeln.
 *
 * Modifikationen gegenüber ubetz.de/arduino/uhr:
 * + "Fünf" und "Zwölf" werden mit Umlauten geschrieben.
 *
 * + Anstelle der DCF-Library verwende ich eigenen Code, der im besten Fall
 *   nur gerade ca. 40 Sekunden benötigt, um die Stunde und die Minute zu
 *   erkennen und der auf dem AtTiny85 problemlos läuft.
 *
 * + Die Uhr schaltet 59 Sekunden vor dem nächsten Fünfminutenübergang auf die
 *   nächsten vollen fünf Minuten.
 *   So ist 12:04:01 bereits "fünf nach zwölf", während
 *          12:03:59 immer noch als "punkt zwölf" angezeigt wird.
 *   Siehe dazu die Subroutine "zeitNaheAn()"
 *
 * + Ein "zehn vor halb" würde zwar noch mal eine Diode sparen, doch
 *   "zwanzig nach" schien für mich doch verständlicher.
 *
 * + Der Text "ES IST" wird mit zwei verschiedenen farbigen Dioden hinterlegt
 *   gelb: Die Zeit kommt vom DCF77
 *   rot : Die Zeit ist entweder noch nicht gelesen oder schon sehr veraltet.
 *         Siehe Modul dcf77HMReader. Falls kein RealTimeClock-Chip (RTC)
 *         verwendet wird und die Uhrzeit mit millis() weitergelesen wird,
 *         kann nach einer gewissen Zeit nicht mehr von einer verläßlichen 
 *         Uhrzeit ausgegangen werden.
 *           * CKSUM_CORRECT_MILLIS -> erst nach 37 Sekunden fehlerlosem Lesen
 *                                     ist die Zahl ernst zu nehmen.
 *           * OUTDATED_MILLIS      -> 2 Stunden ohne Signal lässt die Uhrzeit
 *                                     als "veraltet" anzeigen.
 *                                     (Der Arduino Uno kann locker 24 Stunden
 *                                      ohne Signal bleiben, aber der AtTiny85
 *                                      geht alle 2 Stunden 5 Minuten ungenau.)
 *   Um noch einen Output am Shift-Register zu sparen, kann ERROR-Diode bleiben,
 *   jedoch die "ES IST" Diode als NOT (zwei Transistoren) vom "Error"
 *   abgezwackt werden. Entweder leuchtet "ES IST" rot oder grün.
 *   Somit brauche ich nur 21 Dioden und kann alle Ausgänge "südlich" der
 *   Shift-Register verwenden. Ein Kreuzen der Kabel entfällt.
 *   Dass die NOT-Schaltung mit Transistoren größer ist, als den Output auf
 *   einen eigenen Ausgang der Shift-Register zu legen steht außer Frage.
 *   Ich bin so jedoch flexibel entweder, das NOT direkt bei den Dioden zu
 *   verbauen, oder aber später dennoch einen weiteren Ausgang zu verwenden.
 *   Im Moment ist PIN 16 als LED_VALID vorgesehen (könnte aber auch als
 *   «free» taxiert werden).
 */

/**
 * Don't forget to download this libraries also and put
 * them into <Arduino>/libraries/MyDCF.
 */
#include "my_debug.h"
#include "myMath.h"
#include "dcf77HMReader.h" // needs library 'pinChanger' and 'accumulator'
#include "simpleShifter.h"


// DCF_PIN is the <inverted> inverted signal from Frankfurt:
// This is HIGH for 0.1 (or 0.2) secs and LOW the rest of the second.

// You can add an analog or a digital pin (see dcf77HMReader.h).
// Pin Nr work for AtTiny85 (don't use 0 and 1 for the arduino)

#define DCF_PIN                3 // Input from DCF77-Module
#define IS_DCF_PIN_ANALOG  false // false = read pin digitaly (HIGH/LOW)
                                 // (true on analog reading 0..1024)

// Pins for the shift registers:
// Data:
#define SHIFT_DATA_PIN         0   // (orange to 1. shift reg pin 14)
// Clock:
#define SHIFT_SRCLK_PIN        1   // (yellow to 1. shift reg pin 11)
// Latch:
#define SHIFT_RCLK_PIN         2   // (green  to 1. shift reg pin 12)

// How many shift registers are required:
#define NUM_SHIFT_REGISTERS    3

SimpleShifter  simpleShifter(NUM_SHIFT_REGISTERS,
                             SHIFT_DATA_PIN, SHIFT_SRCLK_PIN, SHIFT_RCLK_PIN);
DCF77HMReader  dcf77HMReader(DCF_PIN, IS_DCF_PIN_ANALOG);

/**
 * The "setup" is done in the constructors of "simpleShifter" and "dcf77HMReader".
 */
void setup() {
	#ifdef DEBUG_METHOD
		Serial.begin(19200);
	#endif
}


void loop() {

#ifdef DEBUG_METHOD
	dcf77HMReader.debugShowTime();     // show as text in the console
#endif

	shift_register_output(); // on/off LEDs
	dcf77HMReader.handlePinChanges();  // read next DCF signal second
}


// PIN Numbers starting with 0 on Shift-Register 1
// PINs 0, 8 and 16 are not used; I only use output
// PINs on the same side (I call it "south").

#define LED_VALID           0 // Time is valid (can be ignored, using a 'not'-gatter)
#define LED_INVALID         1 // Time is not valid.

#define LED_MINUTE_FUENF    2
#define LED_MINUTE_ZEHN     3
#define LED_MINUTE_VIERTEL  4
#define LED_MINUTE_ZWANZIG  5

#define LED_VOR             6
#define LED_NACH            7
// PIN 8 not used, hence it lays "north"
#define LED_HALB            9
#define LED_PUNKT          10


/**
 * The following are the numbers of the PINS for the hour LEDs.
 * Attention 1: For a simpler board-disign, the hours use
 *              decreasing numbers.
 * Attention 2: There is a pin-nr GAP between hour SIEBEN(7) and hour ACHT(8).
 * This is a board design reason, because I don't want to have
 * any output pin on the right (north) of the shift register.
 * So, all used 21 Bits are the ones south (on the same side of
 * the shift register (actually pin 0 and 8 are not used, pin 16
 * is used for LED_VALID.
 * 
 * Note: The following Constants (LED_...) are not used.
 *       They only mention which hour corresponds to which pin.
 *       The Method "hourPin()" solves the mapping.
 */
#define LED_EINS   11
#define LED_ZWEI   12
#define LED_DREI   13
#define LED_VIER   14
#define LED_FUENF  15
// !!!!!!!!!!!!!!!!!!! (16 not used, because it lays "north")
#define LED_SECHS  17
#define LED_SIEBEN 18
#define LED_ACHT   19
#define LED_NEUN   20
#define LED_ZEHN   21
#define LED_ELF    22
#define LED_ZWOELF 23


/**
 * Calculate PIN-Nr for given hour.
 * Because Pin 8 is not used, this 'mapping' is not
 * straight forward.
 */
int hourPin(int hour) {
	hour = ordMod(hour, 12); // ensure 1..12
	if(hour <= 5) {
		return hour + 10;
	}
	return hour + 11;
}


/**
 * There is no "offBit" method.
 * This method turns an LED on. To turn them off, use the
 * method clearData();
 * @pin is the above mentioned LED_ - Pin Number.
 */
void ledON(int pin) {
	simpleShifter.onBit(pin);
}


void shift_register_output() {
	simpleShifter.clearData();
	showInvalidLEDs();
	if(! dcf77HMReader.valueNotYetValid()) {
		showHoursAndMinutes();
	}
	simpleShifter.writeData();
}


void showInvalidLEDs() {
	if(dcf77HMReader.valueOutdatedOrNotYetValid() ) {
		ledON(LED_INVALID);
	} else {
		ledON(LED_VALID  );
	}
}


void showHoursAndMinutes() {
	int min  = dcf77HMReader.getMinute();
	int hour = dcf77HMReader.getHour  ();
	behandleStundenLEDs(hour, min);
	behandleMinutenLEDs(      min);
}


/**
 * Die folgenden Methoden sind deutsch, denn die Uhrzeit wird ja auch in deutsch
 * angezeigt.
 */
void behandleStundenLEDs(int stunde, int min) {
	// Nach "fünf vor halb" ist bereits die nächste Stunde
	// anzuzeigen.
	if(min > 23) {
		stunde = stunde + 1;
	}
	ledON(hourPin(stunde));
}


void behandleMinutenLEDs(int min) {
	if     (zeitNaheAn(min, + 5)) { ledON(LED_MINUTE_FUENF  ); ledON(LED_NACH);                 }
	else if(zeitNaheAn(min, +10)) { ledON(LED_MINUTE_ZEHN   ); ledON(LED_NACH);                 }
	else if(zeitNaheAn(min, +15)) { ledON(LED_MINUTE_VIERTEL); ledON(LED_NACH);                 }
	else if(zeitNaheAn(min, +20)) { ledON(LED_MINUTE_ZWANZIG); ledON(LED_NACH);                 }
	else if(zeitNaheAn(min, +25)) { ledON(LED_MINUTE_FUENF  ); ledON(LED_VOR ); ledON(LED_HALB);}
	else if(zeitNaheAn(min, +30)) {                                             ledON(LED_HALB);}
	else if(zeitNaheAn(min, +35)) { ledON(LED_MINUTE_FUENF  ); ledON(LED_NACH); ledON(LED_HALB);}
	else if(zeitNaheAn(min, +40)) { ledON(LED_MINUTE_ZWANZIG); ledON(LED_VOR );                 }
	else if(zeitNaheAn(min, +45)) { ledON(LED_MINUTE_VIERTEL); ledON(LED_VOR );                 }
	else if(zeitNaheAn(min, +50)) { ledON(LED_MINUTE_ZEHN   ); ledON(LED_VOR );                 }
	else if(zeitNaheAn(min, +55)) { ledON(LED_MINUTE_FUENF  ); ledON(LED_VOR );                 }
	else    /* >=59 && <= 3 */    { ledON(LED_PUNKT         );                                  }
}


/**
 * Bei 3 Minuten nach xy sage ich noch nicht es ist 'fünf nach'.
 * Bei 4 Minuten eigentlich auch noch nicht, aber bei 59 Sekunden
 * kann ich mich auf den Standpunkt stellen, dass die Zeit nun genug
 * nahe an den nächsten fünf Minuten ist. Daher wechsle ich
 * immer exakt bei 4, 9, 14, 19, ... Minuten auf den nächsten 'Fünfer'.
 *
 * Beispiel: Zeit Nahe an 45 -> true bei 44, 45, 46, 47, und 48
 *                              false bei allen anderen Zahlen.
 */
boolean zeitNaheAn(int min, int fuenfMinutenGenauigkeit) {
	return min >= fuenfMinutenGenauigkeit - 1 &&
	       min <= fuenfMinutenGenauigkeit + 3;
}

Arduino Hauptsketch download

Arduino Sketch incl. Libraries (als zip-Datei 17.97kByte)

HTML5 Javascript Code (für diese Webseite)

Diskussion zum Code

Der Code ist in «wiring», der Arduino-C-Variante geschrieben und sollte weitgehend selbsterklärend sein. Um meinen Arduino nicht für das Projekt zu opfern, habe ich den Sketch auf einem AtTiny85 untergebracht. Leider musste ich für die Benutzung des Sketches auf dem AtTiny einige Libraries neu schreiben; um untenstehenden Sketch kompilieren zu können, müssen diese Libraries (accumulator, dcf77HMReader, my_debug, myMath, pinChanger, simpleShifter) auch eingebunden werden. Alle Libraries müssen in einem Unterverzeichnis von /<Arduino>/libraries/ abgespeichert werden.

Bemerkung am Rande: Im Code habe ich gegen einen Grundsatz verstoßen, den ich meinen Lernenden immer und immer wieder einbläue! Der Grundsatz stammt von Martin Fowler aus seinem Buch «Refactoring» und lautet: Kein Codestück hat mehr als sieben Zeilen! Ich glaube jedoch, dass die Behandlung der Fünfminutenabschnitte (behandleMinutenLEDs()) nicht lesbarer oder wartbarer wird, wenn ich die Uhrzeit in «vor» und «nach» einteile. Hier ist es wahrscheinlich sogar sinnvoller, gegen einen der wichtigsten Grundsätze der Computerprogrammierung zu verstoßen — Der Lesbarkeit und Wartbarkeit halber bestätigt hier die Ausnahme unsere Faustregel.

Hardware

Arduino

Zunächst habe ich die Schaltung mit dem Arduino Uno erstellt. Dies hat zur Folge, dass ich Feedback sofort via Serial.print() erhalten kann. Die Tests laufen mit dem DCF77-Empfänger vom CONRAD.

Den Empfänger habe ich einmal digital und einmal analog implementiert. Bei der digitalen Variante wird einfach nach LOW bzw HIGH abgefragt. Bei der analogen Variante kann LOW_VOLTAGE_MAX bzw. HIGH_VOLTAGE_MIN angegeben werden. Dies kann in der Library «pinChanger» im Code pinChanger.h angepasst werden.

AtTiny85

Wie erwähnt habe ich das Projekt auf einen AtTiny85 portiert. Zunächst verwendete ich einen AtTiny45, doch der Sketch ist mittlerweile auf über 4096 Byte angewachsen, was keinen Platz mehr auf dem AtTiny45 hat. Leider funktionierte darauf die Standard DCF77-Library nicht (oder nicht so, wie ich es erwartet hätte) und somit habe ich eigene Libraries geschrieben, um das DCF-77-Signal zu lesen. Mein Sketch hat den Vorteil gegenüber der Standard Library, dass ich nicht eine ganze Minute lesen muss, um die Uhrzeit zu erhalten. Da ich mich lediglich für die Stunde und die Minute interessiere, reicht ein Lesen bis zu Bit 35 im DCF. Im besten Fall bin ich in weniger als 40 Sekunden bei der korrekten Uhrzeit.

Um den Sketch auf den AtTiny zu bringen, musste dieser zuerst vom Serial.print() befreit werden (dies kann einfach in der Library my_debug.h ausgeschaltet werden). Die Pins im Sketch (obiger Download) stimmen mit dem AtTiny überein, nicht aber mit dem Arduino und müssen zum Testen verändert werden.

Nachdem der Sketch mit dem Arduino getestet war, habe ich die Pin-Nummern geändert und den Sketch per ISP auf den AtTiny85 kopiert. Dazu sind die folgenden Schritte nötig:

1. Obiger Sketch auf den Arduino laden, um zu sehen, ob er fehlerfrei kompiliert. (Hast Du alle Libraries eingebunden? Hier bieten sich z. B. Pin-Nummern 10,11,12 und 13 an. Die Pin-Nummern 0 und 1 sind beim Arduino wohl für Serial.print vorgesehen und können im Sketch nur für den AtTiny verwendet werden.)
2. Die AtTiny85 Library ist in die Arduino-IDE zu laden. Da dies auf verschiedenen IDEs anders aussieht, lasse ich eine allgemeine Beschreibung aus und verweise an google. Ich bin in meiner Arduino 1.6.5 IDE wie folgt vorgegangen: Menu->File->Preferences wählen; darin bei «Additional Boards Manager URLs:» folgendes eingeben: https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
3. Der Arduino ist als ISP-Programmer umzufunktionieren (oder Du kaufst Dir einen fixfertigen Hardware-ISP-Programmer). Dazu ist der Sketch «Arduino as ISP-Progarmmer» zu installieren. Ich verwende den Sketch «ArduinoISP» V. 04m3 von Randall Bohn. Im Menu «Tools->Programmer:» ist «Arduino as ISP» einzustellen.
4. Die folgende Schaltung ist aufzubauen:
   
5. In der Arduino IDE ist der obige TextUhr-Sketch zu laden und als Board ist AtTiny85 auszuwählen.
6. Sketch «uploaden». Fertig! Nun hast Du einen AtTiny85 als Textuhr, den Du in die untenstehende Schaltung einbauen kannst.

Alternativ dazu kann ich Dir den bereits programmierten AtTiny85 auch per Post zukommen lassen. Dafür verrechne ich CHF 8.- (bzw. EUR 8.50) zuzüglich Versandkosten.

Schaltpläne

Zunächst das ganze Gebilde:

Das Signal von Frankfurt wird zunächst verstärkt und kann mittels Taster auf einer Diode sichtbar gemacht werden. Ebenso wird das verstärkte Signal in den AtTiny85 gespiesen. Beachte: Der AtTiny ist in dieser Schaltung um 180° gedreht, damit ich den Output gleich mit den Shift-Regsitern verbinden kann. Unter den Registern habe ich angegeben, welche Information die Pins angeben. Einzig der Output «Es ist» liegt im Norden der Shift-Register und wird zusätzlich (da für 4 Dioden) noch verstärkt.

Im Folgenden sind drei Teil-Schaltpläne abgebildet. Alle Pläne können von hier (zip 41kByte) heruntergeladen werden. Der erste Plan zeigt die Hauptschaltung. Diese benötigt als Eingabe das DCF-77 Signal aus Frankfurt und zwar derart «invertiert», dass die 0.1 bzw. 0.2 Sekundensignale auf 5V liegen und nicht als «Lücken» ankommen, wie das Signal effektiv gesendet wird. Alle Breadboards werden mit 5V gespiesen; dies habe ich in den Diagrammen nicht aufgeführt.

Im Hauptplan habe ich lediglich die «Ein Uhr»-Diode angegeben. Alle anderen zwanzig Dioden sind genauso zu verdrahten. Vor jede Diode schalte ich noch einen 150 Ω Widerstand, um die Register, wie auch die Dioden zu schützen. Einzig die Diode Nummer eins erhält noch eine Spezialbehandlung mit der Bedeutung LED_INVALID (s. dritter Schlatplan «NOT»).

Plan oben: Hauptplan
Plan unten: DCF77-Receiver mit Status-Diode

Der Receiver des DCF77-Signals kann auch einfach vom fertigen Bauteil genommen werden (z. B. CONRAD). Ich habe hier zusätzlich eine Diode eingebaut, welche das Signal sichtbar macht. In jeder Sekunde sollte die Diode einmal kurz aufblinken. Tut sie dies nicht, so ist das Signal schlecht. Ich habe im Plan auch einen Schalter eingebaut, der jedoch auch weggelassen werden kann: Alternativ kann die Diode hinter der Uhr «versteckt» werden oder aber sie wird — wie bereits erwähnt — ganz weggelassen.

Die dritte Schaltung spart einen PIN am Shift Register. LED_NOT_INVALID liegt als einzige Diode «im Norden» der Shift-Register und ist immer das Gegenteil von LED_INVALID. Wenn nämlich LED_INVALID eingeschaltet ist (rote Dioden), dann leuchten die gelben «ES IST»-Dioden in meiner Schaltung nicht. Hier habe ich eine einfache NOT-Schaltung mit Transistoren nachgebaut:

Wie bereits im Sketch erwähnt, wird die Schaltung durch die vielen Transistoren natürlich größer. Als Vorteil sehe ich die Möglichkeit, das NOT von der Schaltung ins Gehäuse zu verlegen und dadurch ein Kabel von der Schaltung ins Gehäuse zu sparen. Eine weitere Möglichkeit ist es, den Text «ES IST» permanent leuchten zu lassen. Damit kann die ganze NOT Schaltung gespart werden. Wer will kann ja immer noch einen PIN «opfern» (hier PIN 16 = LED_NOT_INVALID = LED_VALID) oder einen NOT-Chip kaufen.

Stromzufuhr

Die Stromzufuhr beträgt 5V. Die Schaltung verbraucht wohl etwa 500mA. Damit kann die Uhr mit handelsüblichen AA-Batterien gerade einmal etwa 1-2 Tage funktionieren. Ein altes Netzteil ist eine gute Alternative. Ich bin dabei zu überlegen, ob die Schaltung mit Akkus bedient wird (4x 1.2V) und tagsüber mit einer Solarzelle die Batterien wieder aufzuladen...

Stückliste

Melde Dich

Errata

Wie Du vielleicht bemerkt hast, bin ich kein Elektroniker, sondern ein klassischer Programmierer. Daher bin ich um jedwelchen Verbesserungsvorschlag wie auch für jedes Melden von Fehlern in obigen Schaltungen froh. Insbesondere bin ich mit den Transistorschaltungen so verblieben, dass sie zwar funktionieren, jedoch wohl nicht die optimalen Vorwiderstände aufweisen. Leider habe ich eher darauf geschaut, dass ich möglichst wenig verschiedene Bauteile benötige (10k, 1k, 150 Ohm), als darauf, dass überall der optimale Widerstand steht. Wer kann mir hier helfen?
Auf der anderen Seite sind wir Menschen nie von Irrungen und Flüchtigkeitsfehlern befreit: Also auch im Programmcode können sich Fehler oder Unschönheiten einschleichen; und für deren Meldung bin ich ebenfalls sehr dankbar: phi [@] gressly [.] eu.

Bestellung

Du willst weder ein Arduino-Projekt noch eine Textuhr selbst basteln? Dennoch hast Du brav bis hierhin weitergelesen? Dann bist Du vielleicht jemand, der einfach eine Textuhr haben will ohne diese selbst basteln zu wollen oder zu können.
Diese Textuhr ist leider (noch) nicht für den Massenmarkt vorgesehen. Eine Bestellung einer Einzelanfertigung ist jedoch möglich. Minimalpreise sind die Materialkosten (Elektronik ca. CHF 60.— inkl. Netzteil ca. CHF 8.—). Das Lego^TM-Gehäuse ist vergleichsweise teuer und ein Sperrholzkistchen kommt sicher billiger. Das teuerste sind jedoch die Arbeitskosten, welche je nach gewünschter Ausführung stark variieren können. Eine einfache Anfrage hingegen kostet gar nichts: phi [@] gressly [.] eu.