Meine neueste Uhr "Galois"

[SprinterSB]

Hier ein Bild meiner neuesten Uhr (wobei...es ist nicht mehr meine, ich hab sie verschenkt).

http://www.gjlay.de/pub/galois/12Uhr34-1.jpg

...nicht leicht zu fotografieren das Ding...

In diesem Anzeigemodus wird sie von links nach rechts gelesen, jede Farbe entspricht einer Ziffer. Dabei zählen nur die Anzahl der LEDs einer Farbe, nicht ihre Position: Sie zeigt 12:34.

Frontplatte 16cm*4cm ist direkt auf die doppelseitig bestückte Platine montiert. Netzteil und DCF77-Empfänger sind separat in einer kleinem Box, um sie an einen Ort mit guten Empfangsvoraussetzungen unterzubringen.

Handbuch und Schaltplan (pdf, 420kB) (http://www.gjlay.de/pub/galois.pdf)

Haupt-Features:
Anzeige der Uhrzeit in verschiedenen Formaten: binär, BCD, dezimal. Im Dezimalmodus mit festem Muster oder in einstellbaren Zeitintervallen nach Zufallsprinzip wechselnd (wie oben).
Datumsanzeige
automatischer Zeitabgleich via DCF77 oder auf Quarz mit einstellbarer Uhrzeit
Minutenweise einstellbarer Countdown (Eier-/Teeuhr).
Wecker, der zur einegstellten Weckzeit piept. Wahlweise 7 Tage die Woche, nur wochentags (Mo-Fr) oder überhaupt nicht.
Helligkeit passt sich der Umgebungshelligkeit an oder ist wahlweilse fest einstellbar
Würfelfunktion zum Erzeugen von Zufallszahlen (Lottozahlen, Münzwurf, Würfel, ...)


Hardware + Software
µC: ATmega8, 16MHz, 5V
Basis-IRQ-Last: 20kHz
Sprache: GNU-C, Flashverbrauch: 93%
Schnittstellen: ISP, UART, DCF-77, RC5 via TSOP1736 (Anzeige von Systeminformationen wie RAM-Verbrauch, Anzahl ISR-Takte, DCF77-Status, etc.) LEDs als Helligkeitssensoren (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=160444)
LEDs: SuperFlux (120°) als 3*9 Matrix ohne Treiber direkt am AVR, Helligkeit via Soft-PWM
3 Taster (kurz/lang o. autorepeate) in LED-Matrix integriert, Menüsteuerung zur Konfigurierung/Zeitstellung bei fehlendem DCF77, Helligkeitsauswahl, etc
Piezo-Pieper an Hard-PWM zur Tonausgabe (Taster-Rückmeldung, Eieruhr, Song als Easteregg)


Die Blende
Via CorelScript (BASIC-Dialekt) hab ich ein Eagle-Script erzeugt, das die LEDs exakt auf der Platine positioniert. Aus dem selben Script heraus hab ich auch mit CorelDraw eine bemaßte Skizze für nen Schildermacher generiert. Dadurch war sichergestellt, daß die bestückte Platine und die Blende exakt zusammenpassen. Die LED-Bohrungen sind 3.2mm.

Video (AVI, 1.1MB) (http://people.freenet.de/gjl/pub/12Uhr28.avi)

http://www.gjlay.de/pub/galois/Galois.gcc.zip (64kB, C-Quellen, Makefile, HEX)
http://www.gjlay.de/pub/galois/Galois.eagle.zip (170 kB, eagle)

Build erfolgte mit avr-gcc 3.4.6 + binutils 2.16.1

Detail der Platine:
http://www.gjlay.de/pub/galois/pcb-bottom-top.jpg

Platine top
http://www.gjlay.de/pub/galois/pcb-top.jpg


Platine bottom
http://www.gjlay.de/pub/galois/pcb-bottom.jpg

Netzteil mit DCF-Empfänger
http://www.gjlay.de/pub/galois/netzteil.jpg

[vajk]

Gute Idee, klassse Design - gefällt mir !!!

> LEDs: SuperFlux (120°) als 3*9 Matrix ohne Treiber direkt
> am AVR, Helligkeit via Soft-PWM
gefährlich ... softwarefehler -> alle An = uC tot

[squelver]

Ja, find ich auch sehr beeindruckend, echt klasse, will auch haben \:D/

[Florian]

ich hab sie verschenktMensch, Du kannst Gedanken lesen, dass finde ich aber nett von Dir, dass Du sie mir geschenkt hast! *grins*
Schade, also ein Felckchen Wand hätte ich dafür sicherlich noch frei gehabt! ;p
Sehr schicke Uhr, man muss sich nur an das andere Ablesen gewöhnen! :o9

Viele Grüße
Florian

[squelver]

Ich wette, dass die bald in irgendwelcher Form auf den Markt kommen wird ;)

[SprinterSB]

> LEDs: SuperFlux (120°) als 3*9 Matrix ohne Treiber direkt
> am AVR, Helligkeit via Soft-PWM
gefährlich ... softwarefehler -> alle An = uC tot

Nein.

Selbst das geht locker. (Bei dem "direkt" sind Vorwiderstände inbegriffen ;-))

Von der Hardware her können nie mehr als 20mA gezogen werden. Die Blauen und Grünen sind schon bei ca. 1mA voll da (soll ja nicht blenden!) und die Gelben bei 4-5. Die 3 LEDs einer Spalte ziehen ja über den selben Vorwiderstand! Somit ist der Gesamtstrom die Summe der (unterschiedlich großen) Spaltenströme. Die Summe kann nicht über 20mA kommen. :-)

[squelver]

Gibts sowas schon in Worten? Etwa: "Zwölf Uhr Achtundzwanzig"

EDIT:
Könntest deine Version nicht auch für Blinde, quasi als Blindenschriftuhr entwickeln? Statt der LED'S sind kleine Pins, die statt leuchten, nach vorn kommen? :-k

[SprinterSB]

Ich wette, dass die bald in irgendwelcher Form auf den Markt kommen wird ;)

Nö, hab ich nur Hobbymässig gebaut.

Ich bin Bastler und mit Zeug wie Buchhaltung, Marketing, Konformitätsprüfungen, Steuerrecht und dem ganzen Schmodder kenn ich mich net aus. Ich bin halt kein Geschäftsmann...

Das einzige was es gibt ist ein kleines Handbuch, das Handhabung und Bedienung erläutert — ist wie gesagt ein Teil, mit dem sich jetzt mein Freund rumplagen muss... Aber er scheint gut damit zurechtzukommen und seine Kids (er ist Lehrer) finden das Teil cooool, freut mich natürlich auch. \:D/

...und bevor ich was neues anfange, mach ich erst mal meine Nixie-Uhr fertig *ächtz*.

[squelver]

Hi =)

Eigentlich meinte ich das so, dass hier vieleicht jemand mitliesst und das Teil auf den Markt bringt :D

Na dann halt durch, ich möcht deine Nixies-Uhr auch sehen, was immer man drauf sieht ;)

[ogni42]

Sehr, sehr schönes Projekt, Sprinter.

[m.artmann]

Hi copious,


Ich wette, dass die bald in irgendwelcher Form auf den Markt kommen wird

Tja leider schon zu spät, gibts schon seit 1-2 Jahren.

http://www.thinkgeek.com/homeoffice/lights/7437/

Aber ein selbst gebautes Geschenk kommt beim Beschenkten natürlich
immer viel besser an. Und der Erbauer hat dabei noch Spaß und was gelernt.

Gruß
m.artmann

[squelver]

Die Uhr hier, gefällt mir sogar mehr =)

[SprinterSB]

Tja leider schon zu spät, gibts schon seit 1-2 Jahren.
http://www.thinkgeek.com/homeoffice/lights/7437/

Da hatte ich die Idee her, und wollte die TIX nachbauen. Ums verrecken sind aber keine Flächen-LEDs zu bekommen (Blau oder Grün/530nm), schon garnicht für Privat. Ausserdem würde man dann Treiber brauchen, weil man sich dann der 4-fachen LED-Anzahl gegenübersieht. Flächen-LEDs selber bauen hab ich aufgegeben...

Ausserdem müssen die LEDs hell genug sein, sollen satte Farben haben (also kein popel-grün) und alle den gleichen, nicht zu kleinen Öffnungswinkel. Mit Treiber wird die Helligkeitsmessung ohne extra-Bauteile unmöglich, zumindest wenn man die Helligkeit unauffällig nach vorne messen will.

SMD-LEDs direkt auf der Platine war eine Option, aber da hat man wieder das Farben-Problem... Sähe aber recht technomässig aus, einfach ne bestüchte Platine an die Wand...oder hinter Blende je nach Gusto.

Oder 5mm LEDs sauber in eine Matrix verlöten und mit den paar Bauteilen und haarfeinem Cu-Lackdraht und SMD-Controller ne glitzernde Sauerkrautschaltung bauen und das ganze in wasserklares Gießharz tun, Taster als Reed-Kontakte. Die Öffnungswinkel werden durch das Vergiessen natürlich größer... das hab ich angefangen, wär aber nicht in dem Zeitrahmen hingekommen. Und ein winziger Fehler, und über 100 Euronen und unzählige Stunden landen rettungslos in der Tonne! Ausserdem hab ich noch keine Schwiegermutter gemeuchelt...

Möglichkeiten gibt's genug...

[squelver]

Und trotzdem gefällt mir deine Uhr um vieles mehr ;)

[OsramLED]

ja, das muss ich auch sagen. Ist einfach schicker, so im silber mit den kleinen LEDs.

[m.artmann]

War ja auch kein Vorwurf meinerseits, ich finde Deine Uhr auch schöner und sie hat viel mehr Möglichkeiten (DCF, Blinkmuster usw).

Mir kam sie nur gleich sehr bekannt vor ;-)

Gruß
m.artmann

[ManniMammut]

Sehr sehr schön geworden, das Ding!
Ich überleg' ja auch schon länger, so nen Teil mal zu basteln.
Naja, mal sehen, wo ich die Zeit dafür hernehme :-k

[squelver]

Ich hab noch n bischen Zeit liegen, für 5 Euro schick ich sie dir :mrgreen:

Spaß, geht mir doch genauso ;)

[SprinterSB]

Hab oben nochn Link zum Schaltplan dazugetan (im PDF).

[Stromi]

Prima, wo gibt es die LED's ?
Hast du vor das Teil gewerblich zu vermarkten, oder ist es ein Hobby-Projekt??

[SprinterSB]

Es ist ein Hobby-Projekt; eine Serie mit einer Auflage von wahnsinnigen 3 Exemplaren.

Die LEDs: Wichtig ist eigentlich nur, daß
-- alle den gleichen, möglichst großen Öffnungswinkel haben (hier 120°)
-- möglichst effizient sind
-- gleiche Bauform haben
-- satte Farben haben (grün 530nm!)

Ich hab sie vom Conrad, kannst gut 30€ rechnen. Beim Reichelt gibt's auch Super-Flux, aber unbegreiflicherweise nur rote... Interessant sind auch die PLCC-2 Teile.

[techboy]

Super Teil! Ist wirklick ne tolle Geschenksidee!

Könntest mal den Code posten?

[SprinterSB]

Also ich glaub nicht, daß irgendjemand den Code sehen will oder was damit anfangen kann. Ich musste mich schon etwas auf die Hinterbeine stellen, damit ich den Code schnell genug bekomme und alles eingebaut, was ich gaben wollte. Ausserdem war ich aufn ATmega8 festgelegt, und sooo groß ist der ja auch nicht...

Also hier mal eines von 17 Modulen. Es kümmert sich um die Aufbereitung der Daten für den Multiplex. Dokumentiert ist nicht wirklich viel...

#include <AVR.h>
#include "ports.h"
#include "pattern.h"
#include <div.h>
#include "timer2.h"
#include "hell.h"
#include "timer1-job.h"
#include <avr/delay.h>

#include "menu.h"

pattern_t pat;

// Feste Muster für Ziffer 0=2, 1, 3
typedef uint16_t muster_t[3][10];

const muster_t m_wurfel PROGMEM = {
/*1*/ { 0x0, 0x8, 0x0c, 0x26, 0x33, 0x3b, 0x3f },
/*2,0*/ { 0x0, 0x10, 0x101, 0x54, 0x145, 0x155, 0x16d, 0x1d7, 0x1ef, 0x1ff },
/*3*/ { 0x0, 0x2, 0x5, 0x7 }
};

const muster_t m_fill PROGMEM = {
/*1*/ { 0x0, 0x1, 0x5, 0x15, 0x17, 0x1f, 0x3f },
/*2,0*/ { 0x0, 0x1, 0x9, 0x49, 0x4b, 0x5b, 0xdb, 0xdf, 0xff, 0x1ff },
/*3*/ { 0x0, 0x1, 0x3, 0x7 }
};

void pattern_out (uint8_t num)
{
pattern_t *p = &pat;

RELOAD ("b", p);

uint8_t off = 0;
uint8_t tick = p->pwm.tick;
uint8_t duty = p->pwm.duty;
uint8_t max = p->pwm.max;

uint8_t tnum = num >> 2;

p->rownum = num = num & 3;

if (0 == num)
{
tick++;

if (tick >= max)
tick = 0;

p->pwm.tick = tick;
}

if (tick >= duty)
off = 1;

if (hell.state == HS_MESS)
{
if (!off)
hell.mess_count++;

return; // TIMSK &= ~TIMSK_T1;
}

if (hell.state == HS_PREPARE_MESS)
{
hell_mess_start();
return;
}
// alles aus
SET_KATHODES;

// Gap durch SOFT-PWM
if (hell.state == HS_AWAIT_PATTERN_GAP
// hook in Anfang einer längeren off-Sequenz
&& num == 0 && tick == duty
// nur, wenn duty < 100%, redundant!
&& duty < max)
{
// 1 extra Gap zum relax der LEDs
if (tick == duty)
{
hell.state = HS_PREPARE_MESS;

MAKE_IN_ANODES;
CLR_ANODES;
SET (PORT_ANO1); MAKE_OUT (PORT_ANO1);
SET (PORT_ANO0); MAKE_OUT (PORT_ANO0);
SET (PORT_ANO2); //MAKE_OUT (PORT_ANO2);
CLR_KATHODES;
_delay_loop_1 (1);
SET_KATHODES;

return;
}
}

CLR_ANODES;
MAKE_IN_ANODES;

if (num == 3 && tnum <= 3)
{
/*3*/
/*7*/
/*11*/
/*15*/
// Gap durch MUX
return;
}
if (off && num < 3)
return;

// PullUps für Spalte4 (rote Spalte als Trenner)
if (num == 3)
{
if (tnum > 3 && (PM_BCD == p->mode))
{
tnum %= 4;
if (tnum < 3)
{
if (0 == tnum) { MAKE_IN (PORT_ANO0); SET (PORT_ANO0); }
if (1 == tnum) { MAKE_IN (PORT_ANO1); SET (PORT_ANO1); }
if (2 == tnum) { MAKE_IN (PORT_ANO2); SET (PORT_ANO2); }
CLR (PORT_KAT4);
}
}

return;
}

uint16_t bits = pat.row[num];

uint8_t pow2 = POW2 (num);
{ // Blinken
if (pat.blink_count >= 50)
if (pow2 & pat.blink_row)
bits &= ~pat.blink_mask;
}

uint8_t portc = bits;
if (0 == num) SET (PORT_ANO0);
if (0 == num) MAKE_OUT (PORT_ANO0);
BARRIER;
if (1 == num) SET (PORT_ANO1);
if (1 == num) MAKE_OUT (PORT_ANO1);
BARRIER;
if (2 == num) SET (PORT_ANO2);
if (2 == num) MAKE_OUT (PORT_ANO2);
BARRIER;

PORTC = ~0x1f | ~portc;
if (bits & (1<<5)) CLR (PORT_KAT5);
if (bits & (1<<6)) CLR (PORT_KAT6);
if (bits & (1<<7)) CLR (PORT_KAT7);
if (bits & (1<<8)) CLR (PORT_KAT8);
}

uint16_t set_n_bits0 (uint8_t total, uint8_t n)
{
return set_n_bits (total, n, 0);
}

// setzt n bits von total (rechts)
// 0 <= n <= total
// verwendet rndval[]
uint16_t set_n_bits (uint8_t total, uint8_t n, uint32_t quot /*rndval*/)
{
uint16_t val;

if (n > total)
n = total;

val = 0;

while (n != 0)
{
uint8_t pos;

// Constraint "e" forces quot into y,z
// Otherwise z has to be marked as clobbered (by udiv32)

__asm__ __volatile (
"movw r22, %A0" CR_TAB
"movw r24, %C0" CR_TAB
"mov r18, %3" CR_TAB
"clr r19" CR_TAB
"clr r20" CR_TAB
"clr r21" CR_TAB
"rcall __udivmodsi4" CR_TAB
"movw %A0, r18" CR_TAB
"movw %C0, r20" CR_TAB
"mov %1, r22"
: "=e" (quot), "=r" (pos) /* rem */
: "0" (quot), "r" (total)
: "r18", "r19", "r20", "r21",
"r22", "r23", "r24", "r25",
"r26", "r27"
);

uint16_t mask = 1;

// pos-tes freies Bit suchen
while (1)
{
if (!(val & mask))
if (pos-- == 0)
break;

mask <<= 1;
}

val |= mask;

total--;
n--;
}

return val;
}

/*
Bildet pat.bits[] ab auf pat.row[]
pat.bits[4]: Bitpattern der einzelnen Ziffern
pat.row[3]: Die 3 geMUXten Zeilen

Durch diese Anordnung der Bits werden nur gleichfarbige
LEDs gegeneinander gemultiplext.

8 765 43 210 set bits: pat.row[?]
3 222 11 000 pat.data[?]

2 876 54 876 pat.row[2]
1 543 32 543 pat.row[1]
0 210 10 210 pat.row[0]

# @@@ ** QQQ row 2
# @@@ ** QQQ row 1
# @@@ ** QQQ row 0

*/

uint16_t bits_to_row (uint8_t row)
{
pattern_t *pp = &pat;
RELOAD ("z", pp);

uint8_t val0 = pp->bits[0];
uint8_t val1 = pp->bits[1];
uint8_t val2 = pp->bits[2];
uint8_t val3 = pp->bits[3];

if (0 == row)
{
val1 <<= 3;
val2 <<= 5;
}

if (1 == row)
{
val0 >>= 3;
val1 <<= 1;
val2 <<= 2;
val3 >>= 1;
}

if (2 == row)
{
val0 = pp->bits[0] >> 1; val0 >>= 5;
val1 >>= 1;
val2 = pp->bits[2] >> 1;
val3 >>= 2;
}

val0 &= 7; // 000000111
val1 &= 3<<3; // 000011000
val2 &= 7<<5; // 011100000

uint16_t res = val0 | val1 | val2;

if (val3 & 1) // 100000000
res |= 0x100;

return res;
}

void digit_to_bits (uint8_t n, uint8_t max)
{
uint16_t wert;
uint8_t mask = POW2 (n);
uint8_t dig = pat.digit[n+2];

if (dig > max)
dig = max;

if (PM_WURFEL == pat.mode || PM_FILL == pat.mode)
{
// 1-->0 0,2-->1 3-->2
uint8_t idx = n-1;
if (idx >= 0x80)
idx = 1;

const muster_t * muster = & m_wurfel;
if (PM_FILL == pat.mode)
muster = & m_fill;

wert = pgm_read_word (& (*muster)[idx][dig]);
}
else if (PM_COLORS == pat.mode)
{
wert = 0;

if (pat.data[0] & mask) wert = 0xffff;
}
else //(PM_RANDOM == p->mode)
{
wert = set_n_bits (max, dig, pat.rand[n]);
}

pat.bits[n] = wert;
}

static uint16_t pattern_data_to_row_2434 (uint8_t data)
{
udiv8_t qrem = { .quot = data};

uint8_t j, shift = 0;
uint16_t row = 0;

for (j=0; j<4; j++)
{
uint8_t leds = 3;
if (j == 3) leds >>= 1;
if (j == 1) leds--;

qrem = udiv8 (qrem.quot, leds+1);
row |= set_n_bits0 (leds, qrem.rem) << shift;
shift += leds;
}

return row;
}

static uint16_t pattern_data_to_row_bin (uint8_t data)
{
uint16_t row = data;
uint8_t data3 = pat.data3;

if (data3 & 1)
row |= 0x100;

pat.data3 = (data3 >> 1);

return row;
}

void pattern_data_to_rows()
{
pattern_t * pp = &pat;
RELOAD ("y", pp);

uint16_t (*func) (uint8_t);

if (PM_BIN == pp->mode)
{
pp->data3 = pp->data[3];
func = pattern_data_to_row_bin;
goto _call_func;
}

if (PM_2434 == pp->mode)// || PM_BIN == pp->mode)
{
func = pattern_data_to_row_2434;

_call_func:;
pp->row2[0] = func (pp->data[0]);
pp->row2[1] = func (pp->data[1]);
pp->row2[2] = func (pp->data[2]);

goto _eiuhr;
}

{
udiv8_t qrem;

qrem = udiv8 (pp->data[0], 10); pp->digit[0] = qrem.rem; pp->digit[1] = qrem.quot;
qrem = udiv8 (pp->data[1], 10); pp->digit[2] = qrem.rem; pp->digit[3] = qrem.quot;
qrem = udiv8 (pp->data[2], 10); pp->digit[4] = qrem.rem; pp->digit[5] = qrem.quot;
}

if (PM_BCD == pp->mode) // || PM_BCD5 == pp->mode)
{
uint8_t i, * pdig = pp->digit;
for (i=0; i<=2; i++)
{
uint8_t dig0 = *pdig++;
uint8_t dig1 = *pdig++;
dig1 = swap (dig1);

pp->row2[i] = (dig1 << 1) | dig0;
}
}
else
{
digit_to_bits (0, 9);
digit_to_bits (1, 6);
digit_to_bits (2, 9);
digit_to_bits (3, 3);

pp->row2[0] = bits_to_row (0);
pp->row2[1] = bits_to_row (1);
pp->row2[2] = bits_to_row (2);
}
_eiuhr:;

#define BLINK_DAUER 15
uint16_t row0 = pp->row2[0];
uint8_t blink;

blink = count.ms10.eiuhr_blink-(50-BLINK_DAUER/5);

if (MID_MAIN == menu.id
&& menu.eiuhr.runs
&& blink < BLINK_DAUER)
{
row0 ^= 1;
}
pp->row[0] = row0;
pp->row[1] = pp->row2[1];
pp->row[2] = pp->row2[2];
}

[Stromi]

Hallo Georg-Johann !
Wäre toll, wenn du den Code, Layout usw. frei gibst.
Kannst du die Super Flux (mit 120 Grad abstrahlwinkel) Bestellnummern noch rausfinden. Ich kann da nur 90 Grad finden.
MfG

[Spion]

Hallo
@Stromi
Den Schaltplann findest du aus Seite 1 ganz oben. Den Code solltest du selber finden :arrowu: :-s .
Die Led's finde ich auch gerade nicht.

mfg Luca

[Stromi]

@Spion
äh, was sollte denn die Bemerkung ?
Ich würde mich freuen, wenn ich das Layout nicht noch einmal routen müßte.
MfG

[Spion]

Hallo

@Stromi
Entschuldigung beim Layout, da habe ich dich Falsch verstanden.
Den Code solltest du ja gefunden haben oder?

mfg Luca

Ps: Wollte ja nur helfen #-o

[SprinterSB]

Wäre toll, wenn du den Code, Layout usw. frei gibst.
Kannst du die Super Flux (mit 120 Grad abstrahlwinkel) Bestellnummern noch rausfinden. Ich kann da nur 90 Grad finden.

Da hatte ich was falsch in Erinnerung. Die SFlux-LEDs haben wirklich nur 90°, aber das ist voll ok.

Weder Schaltplan noch Software sind momentan in einem Zustand, in dem es sinnvoll wäre sie zu veröffentlichen. Am Schaltplan hängen zB eigene Bibliotheken dran und er hat einige Bugs, so daß er eh neu geroutet werden muss, wenn man die zweilagige Platine neu auflegen möchte.

Hauptfehler sind fehlende Reihen-Dioden an den blauen und grünen LEDs. Diese Dioden leiten in Sperrrichtung!, was sie zur Verwendung in einer Matrix denkbar ungeeignet macht! Ich hab lediglich spaltenweise Shottky-Dioden (BAT41) eingebaut, es ist aber auf jeden Fall ratsam, jeder blauen/grünen LED ne eigene Shottky zu verpassen!

Momentan ist der Effekt, daß LEDs, die eigentlich aus sein sollten, je nach Muster leicht glimmen. Wegen der automatischen Helligkeitsanpassung fällt das nicht weiter auf, aber ich als Konstrukteur seh das natürlich und es wurmt mich... Per Software konnte ich den Effekt stark reduzieren, aber einfach war es beileibe nicht! Woher das Glimmen genau kommt, kann ich nicht nachvollziehen. Eine mögliche Erklärung ist, daß sich LED-Kapazitäten (ca. 20pF) ja nach Vorgeschichte des MUX über diese LEDs entladen, und aufgrund der sehr niedrigen Schwellenströme sieht man das.

[Physikus]

Hallo SprinterSB!
Deine beiden Uhren, die Du mit Bildern gepostet hast, finde ich très chic! Eine kleine Anmerkung zum "Nachrüsten" der Firmware: Anzeige der Sekunden (Minuteneiner und Sekunden) auf Knopfdruck...

[BiGF00T]

Lecker Uhr :) Sehr schick und macht sich bestimmt gut. Nur mit dem Ablesen hätte ich morgens nach dem Aufwachen so meine Problemchen...
Ich wollte mir auch mal ne Uhr bauen, weil meine das Zeitliche gesegnet hat... Mal sehen, wann ich mal dazu komm.

[SprinterSB]

Das Ablesen geht erstaunlich gut, wenn du nicht um 4 oder 5 Uhr aufstehen musst. Am einfachsten ist das Ablesen, wenn viele LEDs an oder aus sind, aber auch das lern man fix.

Etwas länger braucht man bei der
http://www.duesseldorf.de/thema/sights/rheinturm/uhr.shtml
weil da die Leuchten nicht so kompakt angeordnet sind.

Für so ein Designteil liegt die Priorität auch nicht in der Abledegeschwindigkeit. Wober Kinder die echt klasse finden, wenn sie noch keine Zahlen lesen können :-)

[BiGF00T]

Wie läuft das denn dann eigentlich so mit der Uhrzeit? Wird die allein vom µC berechnet? Und wenn ja, kann es dann mal sein, dass eine Programmverzögerung die Uhr langsam nachgehen lässt?

[SprinterSB]

Alle meine Uhren bekommen ein DCF-Modul spendiert, das 641138 von Conrad (10€).

Im Vergleich zum Reichel-Modul ist es preiswerter und mechanisch robuster. Es hat 2 Ausgänge anstatt einem (den 2ten braucht man eh net). Das Reichelt-Modul hat einen Enable-Eingang, den man am µC auch nie brauchen wird. (Falls man ein Enable will, kann man die VCC des Moduls direkt an einen µC-Port klemmen und gut ist).

Bei miesem Funksignal läuft es natürlich auf Quarz.

Nachteil DCF:
-- teurer
-- braucht Platz
-- zickt bei SMPS-Netzteilen, daher baue ich auch die Netzteile selbst
-- zickt in der Nähe von Monitoren, TFTs, PCs, ...

Vorteil:
-- Uhr muss nicht gestellt werden
-- Zeit ist immer aktuell, auch Sommer-/Winterzeit, Wochentag und Datum. Wochentag ist seeehr praktisch, wenn die Uhr nen Wecker hat (weckt nicht am Wochenende :-))

[vajk]

Tipp: DCF77-Modul mit abgeschirmtem Kabel (Mikrofonleitung) in separates Gehäuse abgesetzt betreiben ... dann findet man leichter ungestörten Empfang und die Antenne kann auch Richtung Frankfurt ausgerichtet werden :-)

[BiGF00T]

Hmmm... Den Luxus wollte ich meiner Uhr eigentlich nicht spendieren...
Ich hoffe, dass die Uhr bei mir dann nicht irgendwann mal ein paar Minuten falsch geht...
Habe hier eine relativ einfach aussehende Uhr gefunden:
http://www.dumdididum.de/blackstrom/avr/avr_uhr/index.shtml
Keine Ahnung, ob die was taugt oder nicht.
Gibts dazu Meinungen?

[SprinterSB]

Im Verlauf des Threads gab es ja einige von euch, die sich für diese Uhr interessiert hatten.

Inzwischen ist das Thema ausgekühlt, aber vielleicht findet der eine oder andere die Uhr immer noch ganz nett.

Demnächst werde ich Platinen dafür fertigen lassen, vielleicht mag sich ja jemand die Uhr (nach) bauen.

Es gibt folgende Änderungen/Fixes: Jede blaue/grüne LED hat ihre eigene Reihen-Diode
Die Lautstärke ist trimmbar
Die Tonhöhe ist einstellbar
Das Netzteil wird primärseitig durch eine Sicherung abgesichert
Aussagekräftigere Statusanzeige (Status-LEDs in Empfangsteil) erleichtert das Ausrichten des DCF77-Empfängers bei schlechten Empfangsbedingungen


Ein Überblick über die Uhr (Funktion, Schaltplan, Bauteile) findet ihr in meinem ersten Beitrag (https://www.roboternetz.de/phpBB2/viewtopic.php?p=207197#207197). Allerdings ist das pdf noch nicht aktuell und zeigt entspricht der alten Version der Uhr.

[SprinterSB]

So, jetzt gibt's auch das aktuelle Handbuch (pdf, 400kB) (http://www.gjlay.de/pub/galois.pdf).

[mrroboto]

Die Uhr gefällt mir.

Bin auch gerade dabei eine ausgefallene Uhr zu bauen.

Allerdings mit "mechanischer" Anzeige für die Minuten.

Eine Sanduhr die ziemlich genau 1h für einen Durchlauf braucht wird mittels eines Getriebemotors jede volle Stunde umgedreht. Kleine Ungenauigkeiten spielen keine Rolle, da man eine Sanduhr ja nicht genau ablesen kann.

Die Anzeige der Stunden wollte ich eigentlich per großem, hellen VF-Display lösen. Eine LED Anzeige wie hier ist aber auch keine schlechte Lösung.

Soll halt so ein bischen den Kontrast zwischen alt und modern widerspiegeln.

Mein größtes Problem ist derzeit die Kiste in die das ganze rein soll. Sollte ca. 20x40x10cm (BxHxT) groß sein und möglichst edel bzw. rustikal aussehen. Hatte bei e*ay noch kein Glück. Bei einem sehr schönen Teil war ich leider zu lahm.

Vielleicht hat einer von Euch ne Idee wo noch gucken kann. (Sollte bezahlbar sein <=25EUR. Also bitte keine Tips wie: Antiquitätenhändler deines Vertrauens.)

Alternativ kann ich mir noch einen Kasten aus Alu/Edelstahl Lochblechen vorstellen, durch die man Teile der Mechanik (RB35 mit Zahnriementrieb 1:3) arbeiten sieht.

Vielleicht von innen her noch dezent beleuchtet. Habe hier noch eine ganze Kiste voller Luxeon 1W/350mA LEDs in weiss, blau und orange liegen.

Achso, das ganze soll (falls es gut aussieht) Weihnachten verschenkt werden, also nicht mehr so viel Zeit. Aber die wesentliche Mechanik und die Software stehen ja schon.

[vajk]

Das mit der Sanduhr ist eine super Idee !!! Ich hoffe Du stellt ein paar Fotos davon rein ... wie groß sind die "Kolben", wo her ..
... hmmm .. das könnte man auch super als LED-Wand aufbauen, mit Lichtkranz drumrum für die Stunden ... und ohne Mechanik ...
.. so was gabs mal als Kurzzeittimer ... bei Pollin in groß und ein Bekannter hat sowas in max. 10 cm Höhe ...

[squelver]

Ich hab hier ne Schaltung einer simplen LED-Sanduhr \:D/

[mrroboto]

So ne kleine, simple Eieruhr mit LEDs habe ich auch schon mal gebaut. Mit sonem einfachen Kippsensor (C*onrad), der die Mensch-Maschine-Schnittstelle bildete. Sobald man das Ding umgedreht "tropfen" die LEDs runter. Wenn alle unten versammelt sind, dann Piezotröte. Witziges Geschenk für Leute, die schon alles haben.

http://cgi.ebay.de/Sanduhr-Stundenglas-aus-Edelstahl-NEU_W0QQitemZ230059811198QQihZ013QQcategoryZ8408QQ rdZ1QQcmdZViewItem

Das ist so eine Sanduhr, wie ich sie gekauft habe (als 2. Wahl, habe aber keine Mängel entdecken können).

Abmessungen und Gewicht sind dort abzulesen. Ist schon recht groß und schwer. Deshalb ein RB35 Motor mit 1:200 Getriebe und dann nochmal Zahnriemenuntersetzung 1:3.

Zahnräder wollte ich nicht, weil auch der Sound ansprechend sein sollte. Der Zahnriementrieb arbeitet schön leise. Die volle Umdrehung wird einfach mit einer Gabellichtschranke abgefragt. Motor An/Aus mit einem kleinen Relais.

Die Metallteile der Original-Sanduhr habe ich aus Gewichtsgründen abgeschraubt und durch eine Holzhalterung ersetzt. Aber ich glaube der Motor schafft es auch mit dem Metall, werde es vielleicht wieder umbauen. Schliesslich hat der Motor dann wieder fast eine ganze Stunde um sich wieder auszuruhen.

Sobald ich wieder mal ne Kamera habe, kommen auch ein paar Fotos. Dann aber ein eigener Thread, weil hier gehts ja um ne rein elektronische LED Uhr.

BTW: Hat einentlich schon mal jemand eine elektronisch gesteuerte Kuckucksuhr gebaut? - Kuckuck auf Servomotor, Microcontroller...?

[Der-Eumel]

Hm ... der Thread ist zwar schon ziemlich alt, aber ich würde diese Uhr sehr gerne nachbauen und habe dafür auch im Handbuch die Bauteilelisten, Layouts und den Bohrplan gefunden. Allerdings konnte ich nirgends den Code finden bis auf dieses kleinen Teil ... nur das hilft mir nicht wirklich weiter da ich mich mit Microkontrollern noch nicht soo gut auskenne. Ich wäre wirklich sehr dankbar für den kompletten Code!

Außerdem noch Respekt für diese wunderschöne Uhr!
Matze

[ehenkes]

Könntest deine Version nicht auch für Blinde, quasi als Blindenschriftuhr entwickeln?Blinde/Sehbehinderte bevorzugen sprechende Uhren. Heute gibt es für wenig Geld solche Uhren als Armbanduhren. Ich habe vor Jahren eine sprechende Uhr (SPUHR) für den PC programmiert. http://www.henkessoft.de/HenkesSoft3000/hs3000.htm

[SprinterSB]

Wegen Anfrage hier noch die C-Quellen der Uhr.

Dabei sind auch die HEX-Dateien.

Durch die Quellen durchzusteigen wird nicht sonderlich einfach...heute würd ich einiges anders machen, klar.


http://www.gjlay.de/pub/galois/Galois.gcc.zip (64kB)
http://www.gjlay.de/pub/galois/Galois.eagle.zip (170 kB)
http://www.gjlay.de/pub/galois.pdf (420 kByte)

Build erfolgte mit avr-gcc 3.4.6 + binutils 2.16.1

[jmetzkow]

Hallo
Alle Achtung.
Die Uhr hat mich umgehauen.
Das Design und die Uhr sind Patentreif.
Mir würde es nicht wundern wenn es die bald zu kaufen gibt.
Einfach genial.

Bye
jens

[SprinterSB]

Hi, freut mich \:D/

Ich hab ein paar Bildchen gemacht, und zum Nachbau ist alles da, was man braucht.

https://www.roboternetz.de/phpBB2/viewtopic.php?p=207197

ach ja... die Uhr hat inzwischen auf Wunsch noch einen Wecker bekommen. Der bimmelt zur eingestellten Zeit, und zwar jeden Tag die Woche, nur wochentags (Mo-Fr) oder gar nicht, je nach Einstellung.

Die Quellen hab ich etwas aufgeräumt (bis auf menu*).

[user529]

http://www.erro.de/06_ledlicht/tixuhr.html ????

hast dus verkauft oder hat jemand die "gleiche idee"

mfg clemens

[nietzsche]

Hi copious,


Ich wette, dass die bald in irgendwelcher Form auf den Markt kommen wird

Tja leider schon zu spät, gibts schon seit 1-2 Jahren.

http://www.thinkgeek.com/homeoffice/lights/7437/

Aber ein selbst gebautes Geschenk kommt beim Beschenkten natürlich
immer viel besser an. Und der Erbauer hat dabei noch Spaß und was gelernt.

Gruß
m.artmann

damit bist du nun ca. 3-4 jahre hinterher... ab und zu kann man mal das datum beachten ;)