Meine neueste Uhr "Galois"

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.

Super Teil! Ist wirklick ne tolle Geschenksidee!

Könntest mal den Code posten?

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...

Code:

---

#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];
}

---

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

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

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

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

Zitat:

---

Zitat von Stromi

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.

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...

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.