Display Sekundenzähler

[Alex (Gast)]

Schönen guten Tag,

nach und nach möchte ich versuchen, mir eine Uhr auf mein 4-stelliges 
7-Segment-Display zu basteln.

Allerings versuche ich erst einmal, um die Grundlagen etwas 
reinzubekommen, einen Zähler auf den letzten beiden Stellen 
programmieren. Nun eine kurze Erläuterung zum Programm:
Jede Sekunde wird ein Interrupt ausgelöst, bei dem die Variable counter 
(bzw. im main dan "sec" für die Sekunden) inkrementiert wird.

Um eine LED am Display zur Erleuchtung zu bringen müssen die Pins der 
Anode (PORTA 0-7) und der Kathode (PORTF 0-3) auf 1 gesetzt sein, da 
beide durch einen Transistor durchgeschaltet werden (ich weiß ist 
unsinnig, aber zum Zeitpunnkt des Lötens hab ich mich noch auf mein Buch 
verlassen).

Ist es denn richtig, dass man die Einerstellen mit Hilfe des Modulo und 
die Zehnerstellen mit einer Division durch 10 anzeigen kann?

Wie kann ich das Programm kürzen, um nicht 2x die 10 Cases hinschreiben 
zu müssen?


Ich bitte um Verständnis für Fehler, da dies mein erstes wirklich 
komplexeres Projekt ist.

Ich bedanke mich schon einmal für die Hilfe!

Grüße,
Alex

[Rebi (Gast)]

Ich begreife dann sinn deines Programm nicht doch dein void 
number_output_ONES(uint8_t number) könntest du so kürzen:

PORTF |= (1<<PF0);  //Kathode für Einerstellen aktivieren -->Transistor schalten

if(number < 10)
{
number = array[number];
}

In dem Array sind deine ergebnisse gespeichert.

[Eric B. (beric)]

2 Tipps

1)

char digits[] = { ZERO, ONE, TWO ... NINE };

2)

int main()
{
  char sec1  = 0;
  char sec10 = 0;
  char min1  = 0;
  char min10 = 0;

  for(;;)
  {
    output(digits[min10], digits[min1], 
           digits[sec10], digits[sec1]);

    sec1++;
    if(sec1 == 10)
    {
      sec1 = 0;
      sec10 ++;
    }
    if(sec10 == 6)
    {
      sec10 = 0;
      min1 ++;
    }
    if(min1 == 10)
    {
      min1 = 0;
      min10 ++;
    }
    if(min10 == 6)
    {
      min10 = 0;
    }
  }
}

[Karl H. (kbuchegg)]

Alex schrieb:

Und

> Ist es denn richtig, dass man die Einerstellen mit Hilfe des Modulo und
> die Zehnerstellen mit einer Division durch 10 anzeigen kann?

ja, das ist richtig.

Hast du in der Grundschule schon gemacht. Modulo ist (bei positiven 
Zahlen) nichts anders als der Rest, der bei einer Division bleibt.

eine Mutter hat 36 Torten und 10 Kinder. Wenn jedes Kind gleich viele 
Torten kriegt, wieviele Torten kriegt dann jedes Kind und wieveler 
bleiben der Mutter übrig.

36 / 10 = 3
36 % 10 = 6

Jedes Kind kriegt 3 Torten und 6 Torten  bleiben übrig. Denn 3 * 10 + 6 
ergibt wieder die 36

[Karl H. (kbuchegg)]

Du solltest auch noch mal in dein C Buch schauen und nachlesen, wie das 
mit den Makros des Präprozessors wirklich ist.

#define ZERO   PORTA|= 0b00111111
...

  switch(number)
  {
  case 0:
  number= ZERO;

ein #define vereinbart im wesentlichen eine Textersetzung. D.h. wenn ich 
die mal durchführe, dann wird aus

  number= ZERO;

das hier

  number= PORTA|= 0b00111111;

mal abgeshen davon, dass du hier kein |= haben willst, weil du damit die 
Ausgangspins des Ports nur auf 1 setzen kannst, aber nicht auf 0 zwingen 
kannst, ist das ziemlich sicher nicht das, was du willst. WOzu willst du 
das Ergebnis des Veroderns des Musters mit dem PORTA in number 
speichern? Macht keinen Sinn.

(Der wirkliche Hinweis ist hier wohl untergegangen. Du willst hier kein 
|= haben. Denn mit |= kannst du nur Pins auf 1 setzen. Du kriegst sie 
aber nicht wieder zurück auf 0. In deinem Programm bedeutet das, dass 
kurz über lang alles BIts des PORTA auf 1 sein werden, weil du sie 
nirgendwo zurücksetzt. Wenn am PORTA sowieso nur die Spaltentreiber 
hängen, dann kannst du das Muster ganz einfach zuweisen.)

[Karl H. (kbuchegg)]

Alex schrieb:

> Wie kann ich das Programm kürzen, um nicht 2x die 10 Cases hinschreiben
> zu müssen?

Es wurde dir ja schon gezeigt, dass das mit einem Array viel einfacher 
zu machen ist.
Aber hier gehts jetzt ums Prinzip.

Wenn du das hier

void out_num( uint8_t num )
{
  PORTF ....

  switch( num )
  {
    ....
  }

  PORTF ...
}

void out_num_zehn( uint8_t num )
{
  PORTF ....

  switch( num )
  {
    ....
  }

  PORTF ...
}

vereinfachen willst, dann machst du die Beobachtung, dass der COde im 
switch...case in beiden Funtkionen identisch sind. Deine FUnktion 
bestehen also aus einem 'einleitenden Teil', dem identischen 
switc...case und einem 'ausleitenden Teil'. Das zu verinfachen, ist aber 
nicht schwer. Zieh den gemeinsamen Teil in eine eigene Funktion heraus 
und ruf sie von den beiden Funktionen auf

void out_digit( uint8_t num )
{
  switch( num )
  {
    ....
  }
}

void out_num( uint8_t num )
{
  PORTF ....
  out_digit( num );
  PORTF ...
}

void out_num_zehn( uint8_t num )
{
  PORTF ....
  out_digit( num );
  PORTF ...
}

und voila. Du hast den beide male identischen Teil nur ein einziges mal 
geschrieben.

[Alex (Gast)]

Hallo nochmal,

ich hatte eure Antworten bzgl. des Arrays erst später gesehen und habe 
dann selber noch weiter rumgebastelt. Aufgenommen habe ich jetzt erstmal 
nur den Vorschlag für das Zusammenführen der Cases.

Beim folgenden Programm sollen nun Einzer- und Zehnerstelle ausgegeben 
werden. Um die Anzeige zweier unterschiedlicher Ziffern zu ermöglichen, 
habe ich einfach schnell einen zweiten Timer Interrupt eingefügt. 
Allerdings scheint es mir so, dass der Wert PORTA bzw. "number" nur 
einen Wert annehmen kann, denn auf beiden Stellen wird die selbe Ziffer 
angezeigt; und zwar die, die als erstes im Programm auftritt.
Ich gehe mal ganz stark davon aus, dass es, wie Karl-Heinz schon gesagt 
hat daran liegt, dass die Bitmanipulation im Fall von PORTA daran Schuld 
ist.
Aber mit &,|,^ komm ich irgendwie nie auf die Lösung, dass die Bits für 
die nächste Ziffer richtig gesetzt werden.

Ich möchte erst einmal dieses "Anfangsprogramm" zu Ende führen und widme 
mich denn der Sache mit den Arrays!

Gruß,
Alex

[Karl H. (kbuchegg)]

Na ja.
Wie sage ich es.

Der ganze Ansatz, wie du das aufziehst ist quatsch. So macht man kein 
Multiplexing.

Du musst dich von der Vorstellung lösen, dass du beide Stellen 
gleichzeitig aufleuchten lassen willst. Statt dessen, lässt du sie 
hintereinander aufleuchten. Eine zeit lang lässt du die Einerstelle 
leuchten, dann eine Zeit lang die Zehner Stelle. Danach wieder die 
Einerstelle usw. usw.
Ja, tatsächlich blinken solche Anzeigen ständig. Nur Blinken die so 
schnell, dass du als Mensch das nicht mehr als Blinken siehst, weil es 
viel zu schnell blinkt.

Von daher ist auch dieser ganze Ansatz mit den Funktionen für die Zehner 
und die Einer an und für sich unsinng. Wenn du schon bei Interrupts 
angelangt bist, dann macht man das so, dass man sich global 2 uint8_t 
Variablen anlegt (sinnigerweise als Array) und in einer einzigen ISR 
jeweils eine von beiden ausgibt, mit dem jeweils zugehörigen SChalten am 
F-Port. Beim nächsten Timer-ISR AUfruf kommt dann die andere Variable 
drann.
In diesen beiden Variablen legst du dir bereits das komplette 
auszugebende Muster für diese Stelle ab. Das hat 2 Gründe. Zum einen 
willst du da in der ISR nicht mehr grossartig 200 mal in der Sekunde aus 
der Ziffer das auszugebende Bitmuster bestimmen. Denn das ändert sich 
aus Sicht der ISR ja nur alle heiligen Zeiten mal.
Zum anderen soll die ISR auch deswegen einfach nur das fertig 
hinterlegte Muster ausgeben, damit du da jedes beliebige Muster auf die 
anzeige zaubern kannst und nicht nur ein paar Ziffern. D.h. was die 
jeweilige Stelle anzeigen kann, bestimmt nicht die ISR (welche die 
eigentliche physikalische Ausgabe macht), sondern derjenige, der das 
Musterr bereit stellt.

Gib mir ein paar Minuten, dann such ich mir aus deinem Programm mal die 
Details raus und zeig dir, wie man sowas richtig macht.

[Route_66 H. (route_66)]

Alex schrieb:
> Um die Anzeige zweier unterschiedlicher Ziffern zu ermöglichen,
> habe ich einfach schnell einen zweiten Timer Interrupt eingefügt.

Wie kommst du auf so eine sinnfreie Idee?
Brauchst Du dann für alle Stellen von Stunden bis Sekunden 6 Timer???

In einem Interrupt werden nacheinander die Stellen angezeigt. Das 
geht natürlich nicht, wenn der INT nur einmal in der Sekunde auftritt. 
Du willst ja keine "blinkende" Uhr.

EDIT: zu spät.

[Karl H. (kbuchegg)]

Hier deer (ungetestete) Code

#include <avr/io.h>
#include "avr/interrupt.h"

#define F_CPU 16000000UL
#include "util/delay.h"

uint8_t DigitPattern[] = { 0b00111111,   // 0
                           0b00000110,   // 1
                           0b01011011,   // 2
                           0b01001111,   // 3
                           0b01100110,   // 4
                           0b01101101,   // 5
                           0b01111101,   // 6
                           0b00000111,   // 7
                           0b01111111,   // 8
                           0b01101111,   // 9
                         };

#define NR_DIGITS 2
volatile uint8_t digit[NR_DIGITS];
uint8_t digitToShow;

ISR(TIMER0_OVF_vect)
{
  // egal welche Stelle gerade eingeschaltet war,
  // jetzt auf jeden Fall ausschalten
  PORTF &= ~(( 1 << PF0 ) | ( 1 << PF2 ) );

  // welches ist die nächste anzuzeigende Stelle?
  digitToShow++;
  if( digitToShow == NR_DIGITS )
    digitToShow = 0;

  // das für diese Stelle auszugebende Muster auf die Segmente legen
  PORTA = digit[digitToShow];

  // und die jeweilige Stelle aktivieren
  if( digitToShow == 0 )
    PORTF |= ( 1 << PF0 );
  else
    PORTF |= ( 1 << PF2 );

  // ... diese Stelle leuchtet jetzt so lange, bis die ISR das nächste mal
  // vom Timer aufgerufen wird. Dann wird sie wieder abgeschaltet und die
  // nächste Stelle eingestellt und aktiviert.
}

// das auszugebende Muster für eine 2 stellige Zahl bestimmen
// und in den Variablen für die ISR ablegen
uint8_t outputNumber( uint8_t value )
{
  if( value > 99 )
    value = 99;

  digit[1] = value / 10;
  digit[0] = value % 10;
}

// Alles für die 'Uhr'
volatile uint8_t second;

ISR(TIMER1_COMPA_vect)
{   
  second++;
  if( second == 60 )
  {
    second = 0;
  }

  outputNumber( second );
}

int main()
{
  uint8_t cnt = 0;

  DDRA = 0xFF;
  DDRF = ( 1 << PF0 ) | ( 1 << PF2 );

  // Multiplex-Timer
  TCCR0A = (1<<CS00);
  TIMSK0 = (1<<TOIE0);

  // Sekunden Timer
  TCCR1B = (1<<CS10)|(1<<CS12)| (1<<WGM12);  //16-bit Timer 1 --> Prescaler 1024, CTC-Mode
  TCCR1C = 0;
  OCR1A = 15624;  //Zähler um auf 1s Intervall zu gelangen
  TIMSK1 = (1<<OCIE1A); //Compare Modus aktivieren

  sei();

  while( 1 )
  {
  }
}

Im Code sind möglicherweise noch Tippfehler.
Aber vom Prinzip her ist der Code ok. So betreibt man eine gemultiplexte 
Anzeige mit mehreren Stellen.

Du kannst auch gerne den Timer 0 etwas langsamer laufen lassen. Ein 
Vorteiler von 1 ist jetzt übertrieben. So schnell muss das Multiplexen 
nicht laufen. Ein Vorteiler von 8 oder 64 würde es auch tun, so dass 
noch nichts flackert.

[Karl H. (kbuchegg)]

Alex schrieb:

> Ich möchte erst einmal dieses "Anfangsprogramm" zu Ende führen

Da kannst du nichts zu Ende führen. Du steckst mit deinem Code in einer 
Sackgasse. Es gibt nur einen Ausweg: wegwerfen und richtig neu 
schreiben.

[Alex (Gast)]

Ich bedanke mich vielmals! Werde das jetzt mal akribisch durcharbeiten 
und mich ggf. melden.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

Und schon der erste Fehler.

hier, bei der Zerlegung der Zahl, muss es natürlich

// das auszugebende Muster für eine 2 stellige Zahl bestimmen
// und in den Variablen für die ISR ablegen
uint8_t outputNumber( uint8_t value )
{
  if( value > 99 )
    value = 99;

  digit[1] = DigitPattern[ value / 10 ];
  digit[0] = DigitPattern[ value % 10 ];
}

heissen. Denn irgendwann muss ja auch mal die 'Umsetzung' einer 
numerischen Ziffer in das auszugebende Segment-Muster erfolgen.

[Route_66 H. (route_66)]

Karl Heinz schrieb:
> So betreibt man eine gemultiplexte
> Anzeige mit mehreren Stellen.

Und für eine Uhr benötigt man nicht einen zweiten Timer. Das kann im 
Multiplexinterrupt gleich auch noch erledigt werden. Zumindest der 
Sekundenzähler.

[Marc V. (Firma: Vescomp) (logarithmus)]

Karl Heinz schrieb:
> eine Mutter hat 36 Torten und 10 Kinder. Wenn jedes Kind gleich viele
> Torten kriegt, wieviele Torten kriegt dann jedes Kind und wieveler
> bleiben der Mutter übrig.

 Ich fand deine andere Erklärung mit Wirtshaus und 7 Halben viel
 verständlicher.
 Also:
 eine Mutter hat 36 halbe Bier und 10 Kinder. Wenn jedes Kind...
 und wievele halbe Bier bleiben der Mutter übrig ?

[Alex (Gast)]

Und dann kommt schon die erste Frage:

Ich möchte das ganze jetzt auf 3 Stellen erweitern. Alle nötigen 
Parameter(sprich NR_digit, DDRF, die if-Schleife für digitToShow etc.) 
wurden auf die neue Anzahl eingestellt.

ISR(TIMER1_COMPA_vect)
{
  second++;
  if( second == 60 )
  {
    second = 0; minute++;
  }

  outputNumber(minute*100 +second);
}

Nach 60 Sekunden werden die Minuten hochgezählt und der Wert für "value" 
wurde angepasst.

uint8_t outputNumber( uint8_t value )
{
  if( value > 999 )
  value = 999;

  digit[2] = DigitPattern[ value / 100];
  digit[1] = DigitPattern[ (value / 10) % 10 ];
  digit[0] = DigitPattern[ value % 10 ];
}

Um nun die Zehnerstelle der Sekunden zu generieren, muss man ja zuerst 
durch 10 teilen und dann wieder den Modulo mit 10 nehmen.

Ergbnis ist, dass Zehner- und Einerstelle funktionieren, die 
Minutenanzeige zwar die richtige Minute anzeigt, die Einerziffer der 
Sekunden allerdings mitläuft und sich darüber schreibt.....

[Karl H. (kbuchegg)]

Alex schrieb:

> Ergbnis ist, dass Zehner- und Einerstelle funktionieren, die
> Minutenanzeige zwar die richtige Minute anzeigt, die Einerziffer der
> Sekunden allerdings mitläuft und sich darüber schreibt.....

Tja. Dann hast du wohl in der ISR einen Fehler gemacht.

Übrigens kannst du die Zerlegung auch so machen

  for( i = 0; i < 3; i++ )
  {
    digit[i]  = value % 10;
    value /= 10;
  }

Und bei einem uint8_t wirds natürlich etwas Essig mit Zahlen größer als 
255.

Ich hätte im Falle einer Uhr das auch nicht so gelöst, dass ich zuerst 
dem µC die Arbeit aufbürde, die Minuten mit 100 zu multiplizeren, nur um 
dann durch entsprechende Divisionen alles wieder auseinander klamüsern 
zu müssen.

Im speziellen Beispiel einer Uhr spricht ja nichts dagegen, sich eine 
Ausgabe für Sekunden zu machen, die die digits 0 und 1 beschreibt und 
eine Ausgabe für Minuten, die die digits 2 und 3 beschreibt. Dann kann 
man zb in der 'Uhr'-ISR dann auch gezielt nur die Stellen updaten, die 
es notwendig haben

void outputSecond( uint8_t sec )
{
  digit[0] = DigitPattern[ sec % 10 ];
  digit[1] = DigitPattern[ sec / 10 ];
}

void outputMinute( uint8_t min )
{
  digit[2] = DigitPattern[ min % 10 ];
  digit[3] = DigitPattern[ min / 10 ];
}

ISR(TIMER1_COMPA_vect)
{
  second++;
  if( second == 60 )
  {
    second = 0;
    minute++;

    outputMinute( minute );
  }

  outputSekunde( second );
}

man muss ja nicht mit Gewalt dem µC Mehrarbeit aufzwingen.

[Marc V. (Firma: Vescomp) (logarithmus)]

Alex schrieb:
> Ergbnis ist, dass Zehner- und Einerstelle funktionieren, die
> Minutenanzeige zwar die richtige Minute anzeigt, die Einerziffer der
> Sekunden allerdings mitläuft und sich darüber schreibt.....

 Zeig alles, hier ist dein Fehler bestimmt nicht.
 Fehler liegt zu 99% beim multiplexen.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Tja. Dann hast du wohl in der ISR einen Fehler gemacht.

Gemeint ist die Multiplex-ISR

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Im speziellen Beispiel einer Uhr spricht ja nichts dagegen, sich eine
> Ausgabe für Sekunden zu machen, die die digits 0 und 1 beschreibt und
> eine Ausgabe für Minuten, die die digits 2 und 3 beschreibt.

Wobei auch nichts dagegen spricht, sich für beide Aufgaben eine einzige 
Funktion zu schreiben, der man dann ganz einfach mitgibt, an welcher 
Digitposition die jeweilige Einerstelle sein soll

void outputNumber( uint8_t value, uint8_t firstDigit )
{
  digit[firstDigit + 0] = DigitPattern[ value % 10 ];
  digit[firstDigit + 1] = DigitPattern[ value / 10 ];
}

ISR(TIMER1_COMPA_vect)
{
  second++;
  if( second == 60 )
  {
    second = 0;
    minute++;

    outputNumber( minute, 2 );
  }
 
  outputNumber( second, 0 );
}

Die ursprüngliche outputNumber war mehr eine allgemeine Funktion. In 
konkreten speziellen Fällen kann man da durchaus auch davon abweichen 
und sich die Funktionen auch so zurecht legen, dass man
a) gut mit ihnen arbeiten kann
b) man dem µC ein wenig Arbeit abnimmt

Spezielle Funktionalität kann oft einfacher gestrickt sein, als wie wenn 
man eine allgemein verwendbare Funktion benötigt. Das ist alles nicht in 
Stein gemeisselt.

[John Wayne sein Garagennachbar (Gast)]

Karl Heinz schrieb:
> Jedes Kind kriegt 3 Torten und 6 Torten  bleiben übrig. Denn 3 * 10 + 6
> ergibt wieder die 36

...und dann wundern sich alle über die übergewichtige Jugend...
;-)

[Marc V. (Firma: Vescomp) (logarithmus)]

John Wayne sein Garagennachbar schrieb:
>> Jedes Kind kriegt 3 Torten und 6 Torten  bleiben übrig. Denn 3 * 10 + 6
>> ergibt wieder die 36
>
> ...und dann wundern sich alle über die übergewichtige Jugend...
> ;-)

 Sei still, sonst kommt demnächst der Beispiel mit Vater, 7 Söhnen und
 3 Nutten im Puff.

[Jörg E. (jackfritt)]

Wie gross kann ein uint8 werden?
999??