binär uhr mit einer bit structur

[lufthackn (Gast)]

hallo,

ich möchte eine Binäruhr grafisch mittels Kreise auf einem LCD 
darstellen, also nicht wie übvlich über LEDs an einem Port.

die Zeit kommt von Ulrich Radig AVR77 DCF Treiber;

volatile unsigned char ss   = 0; // Globale Variable für die Sekunden
volatile unsigned char mm   = 0; // Globale Variable für die Minuten
volatile unsigned char hh   = 0; // Globale Variable für die Stunden

gefüllt==1 für EIN
gefüllt==0 für AUS

Circle(x,y,radius,farbe,gefüllt)

nun möchte ich für die Kreise ein struct anlegen:

struct
     { int8_t hh_1_ziffer :1, // 
              hh_2_ziffer :1, // 
        mm_1_ziffer :1, // 
        mm_2_ziffer :1, //
              ss_1_ziffer :1, //
              ss_2_ziffer :1; //
     } BinClock;

wie kann ich nun am besten die kreise füllen?
mit if und else is irgendwie zu doof vermute ich...

thx für euren input, sofern was kommt.

gruß Lufthackn

[André A. (nummer5)]

Deine struct erschließt sich mir nicht ganz. Jeder Eintrag ist ein 
Bitfeld der Länge 1, welche Daten willst du darin speichern?

Wenn ich es richtig verstehe willst du doch die Bits der drei Variablen 
ss, mm, hh als gefüllten oder nicht gefüllten Kreis darstellen?

Dann nimm doch einfach eine Schleife:

x = 0;
y = 0;
for (uint8_t bit = 0x01; bit != 0; bit >>= 1) {
  Circle(x,y,radius,farbe, (ss & bit) != 0);
  x += radius;
}

Dann solltest du acht Kreise nebeneinander angezeigt bekommen.
Für die anderen Variablen ebenso.
Die Bitschieberei benutz ich weil ein AVR nur effizient um ein Bit 
schieben kann, also (1 << i) oder so ist nicht sehr effizient, wenn i 
variable ist.
Es kann sein, dass die Reihenfolge der Bits verkehrt herum ist, aber 
kann man ja leicht anpassen.

[lufthackn (Gast)]

ich steh auf struct^^


deine schleife sieht sehr gut aus nur erschließt sie sich mir auf 
denersten blick noch nicht logisch. Notlösung war bisher ne riesn 
struct;

void sek_update();
  { // Funktion die jede Sekunde einmal ausgeführt wird ... 
    hh_foo =hh; mm_foo =mm; ss_foo =ss;
    bin_clock(hh_foo / 10, 32, 113, gr_clr, color); // 1.Ziffer Stunde
    bin_clock(hh_foo % 10, 57, 113, gr_clr, color); // 2.Ziffer Stunde
    bin_clock(mm_foo / 10,107, 113, gr_clr, color); // 1.Ziffer Minute
    bin_clock(mm_foo % 10,132, 113, gr_clr, color); // 2.Ziffer Minute
    bin_clock(ss_foo / 10,182, 113, gr_clr, color); // 1.Ziffer Sekunde
    bin_clock(ss_foo % 10,207, 113, gr_clr, color); // 2.Ziffer Sekunde
  }


void bin_clock(uint8_t ziffer, uint8_t x_foo, uint16_t y_foo, uint16_t clr, uint16_t clr2)
  {
    switch(ziffer)
          {          // circle( x,y,radius,stärke,farbe,fill)
          case 0: Circle( x_foo,y_foo   ,3,1,clr2,1); // bit 0 (1)
              Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 1: Circle( x_foo,y_foo   ,3,1,clr ,1); // bit 0 (1)
                        Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
          case 2: Circle( x_foo,y_foo   ,3,1,clr2,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr ,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 3: Circle( x_foo,y_foo   ,3,1,clr ,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr ,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 4: Circle( x_foo,y_foo   ,3,1,clr2,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr ,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break; 
      case 5: Circle( x_foo,y_foo   ,3,1,clr ,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr ,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 6: Circle( x_foo,y_foo   ,3,1,clr2,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr ,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr ,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 7: Circle( x_foo,y_foo   ,3,1,clr ,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr ,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr ,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr2,1); // bit 3 (8)
                break;
    case 8: Circle( x_foo,y_foo   ,3,1,clr2,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr ,1); // bit 3 (8)
                break;
    case 9: Circle( x_foo,y_foo   ,3,1,clr ,1); // bit 0 (1)
            Circle( x_foo,y_foo- 9,3,1,clr2,1); // bit 1 (2)
                        Circle( x_foo,y_foo-18,3,1,clr2,1); // bit 2 (4)
                        Circle( x_foo,y_foo-27,3,1,clr ,1); // bit 3 (8)
                break;
         }
  }

ich ahnte das es auch einfacher geht -.-
thx

[Rrolf Magnus (Gast)]

lufthackn schrieb:
> ich steh auf struct^^

Naja, aber struct-Elemente kannst du halt nicht per Index, sondern nur 
per Name ansprechen, und das führt zu so großen Codeblöcken wie bei dir, 
mit massig Fallunterscheidungen. struct ist zwar was tolles, aber eben 
nicht für jeden Anwendungsfall geeignet.

[PittyJ (Gast)]

Oha, was für ein Anfänger....
Also vielleicht mal ein gutes C-Buch lesen. Und auch verstehen was bei
int8_t hh_1_ziffer :1
die Doppelpunkt 1 wirklich bedeutet.

Der Switch ist ja nur eine Bitabfrage. Das könnte man auch einfacher 
machen, ganz ohne switch:

Circle( x_foo,y_foo   ,3,1,(ziffer&1)?clr:clr2,1); // bit 0 (1)
Circle( x_foo,y_foo- 9,3,1,ziffer&2)?clr:clr2,1); // bit 1 (2)
Circle( x_foo,y_foo-18,3,1,ziffer&4)?clr:clr2,1); // bit 2 (4)
Circle( x_foo,y_foo-27,3,1,ziffer&8)?clr:clr2 ,1); // bit 3 (8)

Also einfach in dem Buch mal schauen, wie ein binäre Zahlendarstellung 
geht, und wie die Bitoperatoren gehen.