Monthly archives: November, 2015

Raspberry Pi Wecker mit Webradio (Teil 4)

In der letzten Folge hatten wir uns ja die Innereien des Uhrenmoduls angesehen. Heute wollen wir einen kurzen Blick darauf werfen, wie die Uhrzeit vom Raspberry auf das Uhrenmodul kommt und wie die Auswertung der Zeit erfolgt, die ja über die serielle Schnittstelle übertragen wird.

Zunächst müssen wir dem ATMega beibringen, Daten von der seriellen Schnittstelle zu lesen. Ich verwende hierzu die UART-Bibliothek von Peter Fleury.  Um diese zu verwenden, müssen wir die Bibliothek mittels des Befehls:

uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );

initialisieren. Die UART_BAUD_RATE beträgt in meinem Falle 9600 Baud, es geht natürlich auch schneller. Die Geschwindigkeit ist aber für die Übertragung der Zeit völlig ausreichend. Nun müssen wir in der Hauptschleife des Programm zyklisch prüfen, ob Daten an der seriellen Schnittstelle anliegen, dafür basteln wir uns eine Funktion:

void getUart() {
    /*
     * Get received character from ringbuffer
     * uart_getc() returns in the lower byte the received character and
     * in the higher byte (bitmask) the last receive error
     * UART_NO_DATA is returned when no data is available.
     *
     */
    char c = uart_getc();

    if ( c & UART_NO_DATA )
    {
        /*
         * no data available from UART
         */
    }
    else
    {
        /*
         * new data available from UART
         * check for Frame or Overrun error
         */
        if ( c & UART_FRAME_ERROR )
        {
            /* Framing Error detected, i.e no stop bit detected */
            uart_puts_P("UART Frame Error: ");
        }
        if ( c & UART_OVERRUN_ERROR )
        {
            /*
             * Overrun, a character already present in the UART UDR register was
             * not read by the interrupt handler before the next character arrived,
             * one or more received characters have been dropped
             */
            uart_puts_P("UART Overrun Error: ");
        }
        if ( c & UART_BUFFER_OVERFLOW )
        {
            /*
             * We are not reading the receive buffer fast enough,
             * one or more received character have been dropped
             */
            uart_puts_P("Buffer overflow error: ");
        }

        if (charNum < 16) {

            if ((unsigned char)c == 'r') {

            	parseCommand(buffer,charNum);

            	uart_puts("rn");
            	uart_puts("Ok.rn");

            	charNum = 0;
            }
            else {
            	if (isalnum(c) || isblank(c)) {
					uart_putc(c);
					buffer[charNum] = (unsigned char)c;
					charNum++;
            	}
            }

        }

    }

}

Da wir jeweils immer nur ein Zeichen einlesen können, müssen wir eine maximale Länge (hier 16) definieren und uns merken, an welcher Position wir uns befinden. Am Ende des Kommandos erfolgt ein CR LF, damit der Controller weiss, daß wir einen kompletten Befehl empfangen haben. Jetzt fehlt nur noch das Auswerten des empfangenen Kommandos und das geht so:

void parseCommand(char* cmd, uint8_t len) {

	if (strncmp(cmd,"time",4) == 0) {

		char* t = &buffer[5];

		uint16_t time   = atoi(t);

		int hour = time / 100;
		int minute = time - ((time / 100) * 100);

		tmp_date.hour = hour;
		tmp_date.minute = minute;
		tmp_date.month = 1;
		tmp_date.year = 0;
		tmp_date.day = 1;

		if (isValidTime(tmp_date)) {
			current_date.hour = hour;
			current_date.minute = minute;
		}

	}
	else if(strncmp(cmd,"gettime",7) == 0) {
		sprintf(buffer,"rn%02d:%02d",current_date.hour,current_date.minute);
		uart_puts(buffer);
	}

}

Nun können wir über die serielle Schnittstelle die Zeit empfangen und die aktuelle Zeit ausgeben. Wie aber senden wir nun die Daten vom Raspberry?

Hierzu benötigen wir zunächst ein einfaches Python Script, was die Zeit als Kommandozeilenargument übergeben bekommt und diese dann an die serielle Schnittstelle sendet:

import serial
import sys
ser = serial.Serial("/dev/ttyAMA0",9600);
ser.write("time "+sys.argv[1]+"rn")
ser.close()

Und das Shellscript, welches wir später periodisch über einen Cronjob anstossen, um die Zeit zu synchronisieren:

#!/bin/bash ntpdate -s 0.de.pool.ntp.org date +"%H%M" | xargs python /home/pi/webradio/time.py

Damit haben wir nun alles zusammen und können einen Cronjob anlegen, der einmal in der Stunde die Zeit aktualisiert, hierzu verwenden wir den Befehl crontab -e und fügen folgende Zeile hinzu:

0 */1 * * * /home/pi/webradio/time.sh

Das Script muss sich natürlich am entsprechenden Ort befinden.

Das war's dann für heute. In der nächsten Folge schauen wir uns an, wie das eigentliche Webradio auf dem Raspberry funktioniert und wie wir selbiges mit externen Tastern steuern können.


Raspberry Pi Wecker mit Webradio (Teil 3)

Zeit ist relativ

Wir wollen jetzt hier keine Diskussion zur Relativitätstheorie anfangen. Ich hatte ja in der letzten Folge versprochen, daß wir uns das Webradio mal in der Praxis ansehen. In dieser Folge wollen wir uns die komplette Uhrenschaltung ansehen und auch darüber sprechen, wie denn nun die Firmware für den ATMega aussieht. Insbesondere die Implementierung der Uhr und das Multiplexing sollen uns hier interessieren. Wie versprochen hier also zunächst die gesamte Schaltung der Uhrenplatine:

Schaltung der Uhrenplatine

Schaltung der Uhrenplatine

Ich setzte an dieser Stelle voraus, daß sich der interessierte Leser bereits mit Mikrocontrollern, insbesondere denen aus der ATMega Familie auskennt. Wer hier noch keinen Überblick hat, sollte sich hier mal ansehen um was es geht. Vielleicht schreibe ich auch hierzu irgendwann mal einen Artikel. Interessant ist dieses Gebiet auf jeden Fall.

Die Beschaltung des Mikrocontrollers entspricht ziemlich genau dem, was notwendig ist, um den Baustein zu betreiben. So verwende ich ier einen normalen Quarz zur Taktung, ISP ist der EInfachheit halber nicht angeschlossen. Praktisch alles, was sich links vom Controller befindet, ist Standard um den Baustein zu betreiben. auf der rechten Seite kann man die Leitungen sehen, die die 7-Segmentanzeigen steuern. Der Übersicht halber habe ich das hier über einen Bus geführt. Mit den Pins PB2-PB5 steuere ich die Transistoren, die die jeweilige Anzeige aktivieren. Was hier nicht zu sehen ist, ist der UART, den ich direkt mit dem Raspberry verbunden habe, um die Uhrzeit vom Raspberry an den ATMega zu übertragen.  Es stellt sich nun die Frage, wie man den ATMega dazu bewegt, die Uhrzeit anzuzeigen. Und hier sind wir auch beim Kern der Sache.

Ich habe das ganz einfach über einen Timer gelöst, der im CTC-Modus läuft. Im Code sieht das dann so aus:

void timer1_start_ctc(uint16_t cmp) {
	OCR1A = cmp; // set value to output compare register
	TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10); // ctc, 256 prescale
	//Enable the Output Compare A interrupt
	TIMSK1 |= (1 << OCIE1A);
}

Hier wird das Register OCR1A mit einem Wert geladen, der bestimmt, wann die Timer ISR ausgelöst wird. Dies geschieht eben dann, wenn der Timer den Wert erreicht, der im OCR1A Register hinterlegt ist. Dann wird der Timer so eingestellt, daß er mit 1/256 der Taktfrequenz  läuft. Anschliessend  laden wir das OCR1A Register mit dem Wert 31250 und starten den Timer. Nun wird die ISR-Routine für den Timer genau einmal in der Sekunde ausgelöst. Aber wie komme ich denn nun genau auf 31250?

Ganz einfach, die Taktfrequenz beträgt in meinem Fall 8MHz. Also wird, wenn im OCR1A der Wert 0 steht, die Timer ISR mit einer Frequenz von 8MHz/256 ausgelöst, also 31250Hz. Somit müssen wir das Register genau mit diesem Wert vorladen, um eine Frequenz von 1Hz zu bekommen. Für andere Taktfrequenzen muss man das dann entsprechend umrechnen.

Jetzt ist es einfach, wir definieren uns eine Struktur:

typedef struct { uint8_t hour; uint8_t minute; uint8_t second; uint8_t day; uint8_t day_of_week; uint8_t month; uint8_t year; } date_t;

Dann definieren wir den entsprechenden Typ mit

volatile date_t current_date;

Und können die ISR implementieren:

ISR (TIMER1_COMPA_vect) {

	if (current_date.second < 59) {
		current_date.second++;
	}
	else {
		current_date.second = 0;

		if (current_date.minute < 59) {
			current_date.minute++;
		}
		else {
			current_date.minute = 0;

			if (current_date.hour < 23) {
				current_date.hour++;
			}
			else {
				current_date.hour = 0;
			}
		}
	}

}

In der Hauptschleife aktualisieren wir dann immer die aktuelle Zeit. Nun fehlt noch die Ausgabe an die 7-Segment anzeigen.

Es werden jetzt einige Definitionen für die Anzeigemodule benötigt. Da die Module über eine gemeinsame Anode verfügen, müssen die Segmente zur Anzeige auf LOW geschaltet werden.

#define setPin(PORT,PIN) PORT |= (1 << PIN)
#define clearPin(PORT,PIN) PORT &= ~(1 << PIN)

#define SEG_A clearPin(PORTB, 4)
#define SEG_B clearPin(PORTC, 5)
#define SEG_C clearPin(PORTC, 3)
#define SEG_D clearPin(PORTC, 2)
#define SEG_E clearPin(PORTB, 2)
#define SEG_F clearPin(PORTB, 3)
#define SEG_G clearPin(PORTC, 4)

Jetzt können wir die Methoden für die Zeitanzeige implementieren:

void displayNumber(uint8_t num, boolean withDot) {

	// turn all segments off
	setPin(PORTC, 5);
	setPin(PORTC, 4);
	setPin(PORTC, 3);
	setPin(PORTC, 2);
	setPin(PORTB, 4);
	setPin(PORTB, 3);
	setPin(PORTB, 2);
	setPin(PORTB, 1);

	if (withDot) {
		clearPin(PORTB, 1);
	}
	else {
		setPin(PORTB,1);
	}

	if (num == 0) {
		SEG_A;
		SEG_B;
		SEG_C;
		SEG_D;
		SEG_E;
		SEG_F;
	}
	else if (num == 1) {
		SEG_B;
		SEG_C;
	}
	else if (num == 2) {
		SEG_A;
		SEG_B;
		SEG_G;
		SEG_D;
		SEG_E;
	}
	else if (num == 3) {
		SEG_A;
		SEG_B;
		SEG_C;
		SEG_D;
		SEG_G;
	}
	else if (num == 4) {
		SEG_B;
		SEG_C;
		SEG_F;
		SEG_G;
	}
	else if (num == 5) {
		SEG_A;
		SEG_F;
		SEG_G;
		SEG_C;
		SEG_D;
	}
	else if (num == 6) {
		SEG_A;
		SEG_F;
		SEG_G;
		SEG_C;
		SEG_D;
		SEG_E;
	}
	else if (num == 7) {
		SEG_A;
		SEG_B;
		SEG_C;
	}
	else if (num == 8) {
		SEG_A;
		SEG_B;
		SEG_C;
		SEG_D;
		SEG_E;
		SEG_F;
		SEG_G;
	}
	else if (num == 9) {
		SEG_A;
		SEG_B;
		SEG_C;
		SEG_D;
		SEG_F;
		SEG_G;
	}

}

void displayTime(int hours, int minutes, int seconds, boolean dot) {

	int s_tenths = seconds / 10;
	int s_ones = seconds - s_tenths * 10;

	int m_tenths = minutes / 10;
	int m_ones = minutes - m_tenths * 10;

	int h_tenths = hours / 10;
	int h_ones = hours - h_tenths * 10;

	clearPin(PORTD,5);
	clearPin(PORTD,6);
	clearPin(PORTB,6);
	setPin(PORTB,7);
	displayNumber(m_ones,false);
	_delay_ms(SW_DELAY);

	clearPin(PORTD,5);
	clearPin(PORTD,6);
	setPin(PORTB,6);
	clearPin(PORTB,7);
	displayNumber(m_tenths,false);
	_delay_ms(SW_DELAY);

	clearPin(PORTB,6);
	clearPin(PORTB,7);
	clearPin(PORTD,5);
	setPin(PORTD,6);
	displayNumber(h_ones,dot);
	_delay_ms(SW_DELAY);

	clearPin(PORTB,6);
	clearPin(PORTB,7);
	setPin(PORTD,5);
	clearPin(PORTD,6);
	displayNumber(h_tenths,false);
	_delay_ms(SW_DELAY);
}

Hier kann man gut sehen, wie die einzelnen Anzeigeelemente umgeschaltet werden, indem der entprechende Pin geschaltet wird, bevor die jeweilge Ziffer angezeigt wird. Schauen wir uns das ganze mal auf dem Logic Analyzer an:

Multiplexing

Multiplexing

Hier sehen wir von oben nach unten die einzelnen Ausgänge des MIkrocontrollers für die Ansteuerung der Transistoren. Hier lassen sich noch zwei Messgrößen ablesen: Zum einen können wir sehen, daß jedes einzelne Segment mit einer Frequenz von knapp 118 Hz angesteuert wird und somit kein Flimmern mehr zu sehen ist, zum andern kann man sehen, daß jedes einzelne Segment für knapp 2ms aktiv ist, bevor zum nächsten umgeschaltet wird.

Im Grunde ist das die gesamte "Magie", die benötigt wird, um die Zeit anzuzeigen. In der nächsten Folge beschäftigen wir uns damit, wie wir über den UART die aktuelle Zeit vom Raspberry an das Uhrenmodul übertragen.

Der Code für das Projekt kann wie immer auf Github eingesehen und heruntergeladen werden. Hier ist auch die Schaltung im EAGLE Format enthalten.


Ruhig Blut

dummy

Soweit so gut, ich habe mich wieder ein wenig beruhigt nach der Linux-Orgie.

Ich habe noch ein wenig recherchiert und herausgefunden, daß mein Soundproblem offenbar ein bekannter Bug ist

https://bugzilla.kernel.org/show_bug.cgi?id=87771#c23

Das Problem betrifft wohl alle Mainboards mit dem Realtek ALC1150 Chipsatz, also in meinem Falle das MSI Z97 GAming 3 Board. Ich kann das komplett so nachvollziehen, die Mühe, das Kernel upzudaten spare ich mir mal, da ich meistens sowieso direkt Windows oder Linux starte und im laufenden Betrieb nicht neustarte.


Nichts dazugelernt?

Junge, junge! Ich war echt der Meinung, daß sich möglicherweise in den letzten 10 Jahren im Linux-Desktop Bereich etwas getan hat. Da habe ich leider falsch gelegen.

Nachdem ich im letzten Post berichtete, daß die Installation von Linux Mint auf meinem Notebook wie Butter erstaunlich gut von der Hand ging, dachte ich, daß es an der Zeit wäre, das ganze auch mal auf meinem Desktop zu installieren. Soweit so gut, ich besitze einen Standard PC von der Stange mit einer NVIDIA GTX970 und keinerlei exotischen Komponenten. Sollte also funktionieren oder? Also nicht lange gefackelt, die Windows Partition verkleinert und den bootfähigen USB-Stick vom letzten Mal eingesteckt.

Nachdem ich die ersten Probleme mit dem UEFI Boot umschifft habe, mit denen ich allerdings gerechnet hatte, lies sich Linux Mint dann parallel installieren und hat auch brav den Bootmanager installiert. Aber was soll ich euch sagen? Die NVIDIA Karte wurde nicht erkannt! Eine NVIDIA Karte! Hallo, geht's noch??? Da muss ich doch tatsächlich die Treiber manuell von der NVIDIA Seite herunterladen und ein Kernelmodul kompilieren. Ich kam mir vor wie in der Steinzeit, der gleiche Müll wie vor 10 Jahren! Abgesehen davon, daß sich der NVIDIA Installer darüber beschwerte, daß das Kernelmodul nicht geladen werden konnte, lief die ganze Geschichte dann nach einem Neustart, warum auch immer.

Als ich dann die Grafikkarte dann am Laufen hatte, gingen die Probleme natürlich weiter. Irgendwie konnte ich zwar Audio-Dateien abspielen, aber ich habe nichts gehört. Ich habe dann solange an den diversen Lautstärkereglern rumgespielt, bis ich irgendwann mal was gehört habe, leider alles viel zu leise. Eine umfangreiche Recherche in diversen Foren ergab dann, daß ich angeblich mittels des Alsamixers auf der Konsole (!!!!) den Sound lauterstellen sollte. Zahllose Versuche später, nachdem ich mich durch diverse Mixer und EInstellungtools gewühlt hatte, warf ich dann die Flinte ins Korn. Liebe Linux Entwickler, es kann echt nicht sein, daß es mindestens vier verschiedene Sound Systeme gibt, die irgendwie miteinander zusammenhängen: PulseAudio, Alsa, Jack, Mixer hier, Konsole da, Alsactl, blah blah blah. Was soll das? Wer soll das bedienen? Habt Ihr 'ne Meise?

Fuck you

Aber am Besten fand' ich die Tatsache, daß sich das ganze irgendwie von selbst repariert hat. *kopfkratz*

Ich höre immer das Geheule, daß sich Linux ja nicht auf dem Desktop durchsetzt, aber ich weiss jetzt wieder genau warum. Ich weiss, es kostet nichts und ich weiss auch, daß die meisten Entwickler in ihrer Freizeit an Linux arbeiten, aber irgendwas läuft hier gewaltig schief.


Linux Mint vom USB-Stick

WIe jedes Jahr um diese Zeit, wenn die Tage länger werden und ich gerade nichts besseres zu tun habe, beschäftige ich mich hin und wieder mit Linux. Ich finde es, obwohl ich zu 99% WIndows nutze, sehr wichtig, ab und zu einen Blick über den Tellerrand zu werfen. Vor einiger Zeit habe ich von Linux Mint gehört, einer Ubuntu basierten Distribution, die wohl besonders leicht zu installieren und zu bedienen ist.

Linux Mint

Linux Mint

Also nicht lang gefackelt und eine aktuelle Version von Linux Mint heruntergeladen und mit UNetbootin einen bootfähigen USB-Stick erstellt. Das geht ganz leicht. Man lädt sich ein Installationsimage herunter und erzeugt mit wenigen Mausklicks eine bootfähige Version der Linux Distribution. Dazu muss allerdings der Stick vorher unter Windows mit FAT32 formatiert werden, dann steht der Installation fast nichts mehr im Wege. Da ich noch ein Lenovo Thinkpad T420 besitze, was ich nur zum Surfen auf der Couch benutze, fiel auch die Wahl des Zielcomputers nicht schwer.

UNetbootin

UNetbootin

Nach zwei erfolglosen Installationen, die auf zwei (!) defekte USB-Sticks zurückzuführen waren, ist es mir dann tatsächlich mit einem Kingston 8GB Stick gelungen, Linux Mint auf dem T420 zu installieren. Und was soll man sagen, die Installation hat auf Anhieb geklappt und soweit ich sehen kann, funktioniert alles Out-Of-The-Box, inklusive Trackpad, Webcam, WLAN und Sound - Ganz großes Kino! Das einzige, was ich noch anpassen musste, war die Konfiguration des Trackpads, das Scrollen mit zwei Fingern war nicht standardmäßig aktiviert.

Ich werde in den nächsten Tagen meine Erfahrungen hier berichten. Mich interessiert besonders, wie gut sich Bilder unter Linux Mint verwalten lassen und ob man RAW Dateien von der Nikon irgendwie konvertiert bekommt. Vielleicht lässt sich ja auch irgendwie die Creative Suite von Adobe installieren, wer weiss?


Raspberry Pi Wecker mit Webradio (Teil 2)

Die sieben Segmente

Nein, das ist kein reisserischer Titel aus einem neuen Hollywood-Streifen. Wie ich in der letzten Folge ja kurz erwähnt habe, will ich die Anzeige der Uhrzeit des Weckers mit 7-Segment-Anzeigen realisieren. Jeder von uns, der nicht ganz blind durch die Gegend läuft, hat sicher schon einmal welche gesehen. Sei es in handelsüblichen Weckern, Küchenradios, Waagen oder ähnlichen, so hat sich diese Art von Luminiszenz-Anzeigen bis heute gehalten. Dies liegt nicht zuletzt an der optischen Attraktivität und der einfachen Handhabung. Die Geschichte dieser Anzeigen reicht bis ins Jahr 1908 zurück. Auf Wikipedia gibt es hierzu einen hervorragenden Artikel. Im untenstehenden Bild sieht man ein handelsübliches 7-Segment Anzeigeelement mit 27mm Bauhöhe in der Farbe rot.

Red

Red

In diesem Projekt soll diese Anzeige zur Darstellung der Uhrzeit verwendet werden. Um also beispielsweise die Uhrzeit ohne Sekunden anzuzeigen, benötigen wir derer vier. Sollen noch die Sekunden dargestellt werden sind es sechs. Aus Platzgründen verzichte ich auf die Sekunden, ich habe allerdings auch noch keinen klassischen Digitalwecker gesehen, der die Sekunden mit angezeigt hat.

Schon haben wir das erste Problem: Wollen wir 4 Elemente parallel ansteuern, so benötigen wir, wenn wir den Dezimalpunkt mitrechnen mindestens 8 Leitungen, Masse und Versorgungsspannungen nicht mitgerechnet. Somit wären also 32 Leitungen nötig, die von einem Mikrocontroller angesteuert werden wollen. Wenn man also noch eine serielle Schnittstelle und ein paar Buttons und Statusleuchten benötigt, ist man da schnell bei 40 Leitungen oder mehr. Hier muss also eine Lösung her, um den Leitungsaufwand zu reduzieren. Hier kommt das Multiplexing ins Spiel.

Multiplexing heisst im Grunde nichts anderes, als daß nicht alle Anzeigeelemente parallel angesteuert werden, sondern immer nur eins zu einem bestimmten Zeitpunkt. Der Mikrocontroller weiss, welches Segment gerade aktiv ist und schaltet die entsprechenden Leitungen für die jeweilige Ziffer. Dann wird auf das nächste Element weitergeschaltet und die nächste Ziffer dargestellt. Da 7-Segment-Anzeigen entweder über eine gemeinsame Katode oder eine gemeinsame Anode verfügen, schaltet man zyklisch die gewünschte Katode auf Low oder eben die Anode auf High. Die zyklische Umschaltung erfolgt dann eben schnell genug, so daß das menschliche Auge das nicht mehr mitbekommt. Im Idealfall schaltet man also mit mindestens 25 Hz die Segmente um, sonst ist ein Flimmern sichtbar.

7-Segment Multiplexing

7-Segment Multiplexing

In dem obigen Schaltungsauszug kann man das Prinzip gut erkennen: Die dicke blaue Leitung ist ein Bus, der zum Mikrocontroller führt und alle 8 Leitungen der Anzeige führt (a bis f plus Dezimalpunkt). Das von mir verwendete Modul verfügt über eine gemeinsame Anode und diese muss somit gegenüber dem jeweiligen Segment auf High geschaltet werden. Hierzu verendet man ainfach einen NPN Transistor mit entsprechendem Basisvorwiderstand, der vom Controller über die Basis geschaltet wird. Auf diese Weise reduziert sich der Leitungsaufwand auf 12 Leitungen für die ganze Anzeige, was auch mit kleineren Mikrocontrollern problemlos bewerkstelligt werden kann.

In der nächsten Folge wollen wir uns dann ansehen, wie das ganze in der Praxis und vor allem auf dem Mikrocontroller aussieht.


Raspberry Pi Wecker mit Webradio (Teil 1)

Nachdem meine elektronischen Experimente nun seit einigen Monaten ruhen, juckt es mich dann doch mal wieder, etwas zu bauen. Die Tage werden kürzer,die Nächte länger und das Wetter erlaubt es nicht immer, zum Fotografieren loszuziehen. Also habe ich kurzerhand mein "Labor" wieder in Betrieb genommen,

Da ich schon immer irgendwie auf Radios und Digitaluhren abgefahren bin, habe ich mir überlegt, einen neuen Versuch zu starten, einen Radiowecker zu bauen. Der letzte Versuch liegt schon eine Weile zurück und ist ehrlich gesagt ziemlich in die Hose gegangen. Also neuer Versuch neues Glück, bauen wir also einen Radiowecker mitsamt Webradio auf der Basis eines Raspberry Pi. Man muss sich das Leben ja nicht unnötig schwer machen. Das Display soll dieses Mal mit roten großen 7-Segment Anzeigen realisiert werden, damit ich die Uhrzeit nachts gut lesen kann, die Anzeige aber nicht so hell ist, daß sie mich beim Schlafen stört.

Weiterhin sollte das ganze in einem ansprechenden Gehäuse untergebracht werden und auch natürlich Stereo Lautsprecher enthalten, die wirklich gut klingen sollen. Womit wir dann auch beim dritten Element des Projekts angelangt sind, dem Audio-Verstärker. Um das ganze nicht unnötig zu verkomplizieren, werde ich auf ein Verstärker-IC zurückgreifen, was mit möglichst wenig externer Beschaltung auskommt,

Die Anzeigeeinheit möchte ich ziemlich universell konzipieren, so daß ich den Entwurf auch später mal für einen anderen Zweck gebrauchen kann. Ich habe mich dazu entschlossen die ganze Uhrenplatine mit einem ATMega 328 zu realisieren, der per UART von der Raspberry Platine angesprochen wird. So kann ich beispielsweise die Zeit auf dem Raspberry über das Internet beziehen und an die Uhrenplatine schicken. Das ganze läuft natürlich in beide Richtungen, also bidirektional. Grob sieht der Aufbau also so aus:

Webwecker

Webwecker

Nun kann man die ganze Sache also schön modular angehen und zunächst die Displayplatine entwerfen. Der zweite Teil beschäftigt sich dann mit der Software auf dem Raspberry sowie die Anbindung der Platine über UART und weitere externe Beschaltung wie z.B. Tasten um die Zeit manuell einzustellen oder das Radio ein- und auszuschalten. Anschliessend kümmern wir uns dann um den Verstärker, das Gehäuse und die Lautsprecher. Ach, ganz wichtig noch: die ganze Sache benötigt ja auch noch eine Stromversorgung. Hier möchte ich die Stromversorgung des Raspberries verwenden und ggf. einen Step-Up Wandler für den Verstärker nutzen. Aber dazu später mehr.

Da ich schon einige Abende experimentiert habe, verfüge ich bereits über einen prototypischen Aufbau des Uhrenteils, den ich euch natürlich nicht vorenthalten möchte:

Clockworks

Clockworks

Mit dem Aufbau dieses Moduls werde ich dann im nächsten Teil fortfahren.


(c) 2016 Matthias Pueski