Countdown ATMega8

[Franny (Gast)]

Hallöchen alle miteinander :)

Ich habe einen ATMega8 an vier 7-Segment-Displays angeschlossen und 
möchte dort nun im Loop von 9999 auf 0000 runterzählen lassen. Ansich 
klappt das auch recht gut, nur aus irgendwelchen Gründen fängt er 
zunächst an bei 147 runter zu zählen und springt erst dann auf die 9999.
Ich denke, ich bin gerade einfach "Code-blind" nenne ich es mal, und 
finde den Fehler darin einfach nicht...
Wäre super, wenn ihr mal nen Blick rüber werfen und mir die Augen öffnen 
könntet.

Vielen Dank im Voraus!
Franny

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

uint16_t damn [10] = {(0xC0), (0xF9), (0xA4), (0xB0), (0x99), (0x92), (0x82), (0xF8), (0x80), (0x90)};
uint8_t counts[4] = {0x90,0x90,0x90,0x90};

volatile uint16_t var = 0x90;
volatile uint16_t value = 0x90;
volatile uint16_t digit = 0x90;
volatile uint16_t c = 0x90;
volatile uint16_t btch = 0;

int main(void)
{
  uint16_t zahl = 0;
  
  DDRD |= (0x7F);
  DDRC |= (0x1E);

  TCCR0 |= (1<<CS00) | (1<<CS01);
  TIMSK |= (1<<TOIE0);
  
  TCCR1B |= (1<<CS10) | (1<<CS11);
  TIMSK |= (1 << TOIE1);
  
  sei();
  
  PORTD |= ~0x3F;    //Löschen der Zahl
  PORTC |= 0x1C;
  
  while(1)
  {
  }
}

ISR(TIMER1_OVF_vect)
{
  btch++;
  if (btch == 1)
  {
    btch = 0;
    c--;
    
    if (c == 0)
    {
      c = 9999;
    }  
  }
  else
  {
    PORTD = damn[c];
  }
  
  value = c;
  
  counts [3] = 0;          //Alles wieder auf 0 setzen
  counts [2] = 0;
  counts [1] = 0;
  counts [0] = 0;
  
  while(value >= 1000)      //Wertzerlegung
  {
    counts[0]++;
    value = value - 1000;
  }
  
  while(value >= 100)
  {
    counts[1]++;
    value = value - 100;
  }
  
  while(value >= 10)
  {
    counts[2]++;
    value = value - 10;
  }
  
  counts[3] = value;  
}

ISR(TIMER0_OVF_vect)        //Weitergabe über die Transistoren
{
  var++;
  
  if (var > 1)
  {
    var = 0;
    digit++;
    
    if (digit > 4)
    {
      digit = 1;
    }
  }
  
  PORTC |= 0x1E;
  PORTC &= ~(1 << digit);
  PORTD = damn[counts[digit - 1]];
}

[Stephan (Gast)]

Zeile 10:
volatile uint16_t c = 0x90;

[Oliver S. (oliverso)]

Auf den ersten Blick hätte ich ja erwartet, daß der bei 144 anfängt, 
daher ist 147 wirklich seltsam.

Das alles ist aber so verquer und durcheinander, da solltest du mal 
drüber shclafen, dann alles löschen, und von vorne anfangen.

Oliver

[Peter D. (peda)]

Franny schrieb:
> nur aus irgendwelchen Gründen fängt er
> zunächst an bei 147 runter zu zählen

Schon merkwürdig, Du lädst ja 144 rein.

[Cyblord -. (cyblord)]

Also Softwaretechnisch baut man das erst mal so auf, dass du an einer 
Stelle (von mir aus in einer Funktion, besser in einem eigenen Modul*) 
eine int16 Variable auf den 7-Segmentanzeigen ausgeben kannst.

Der Rest des Programms muss sich dann nur noch darum kümmern, diese 
simple Variable zu setzen.

Die Ausgabefunktion kann man dann auch erst mal wunderbar mit 
verschiedenen werten testen.

Das eigentliche Countdown Programm wird danach extrem einfach.


* Erstelle eine eigene .c und .h Datei für die 7 Segmentanzeige. Mit 
EINER öffentlichen Funktion (z.B. showValue(uint16_t value)) im header.
In die .c Datei machst du allen Quatsch den du für die 7Segment 
benötigst. Pins, Segment-Array usw. usw.

[Falk B. (falk)]

Franny schrieb:
> Hallöchen alle miteinander :)

Und selbst?

> Ich habe einen ATMega8 an vier 7-Segment-Displays angeschlossen und
> möchte dort nun im Loop von 9999 auf 0000 runterzählen lassen. Ansich
> klappt das auch recht gut,

Naja, dein Programm ist etwas akademisch, scheint aber zu funktionieren.

> nur aus irgendwelchen Gründen fängt er
> zunächst an bei 147 runter zu zählen und springt erst dann auf die 9999.
> Ich denke, ich bin gerade einfach "Code-blind" nenne ich es mal, und
> finde den Fehler darin einfach nicht...

Ich hab ihn auf die Schnelle nicht gefunden, vermute aber, daß du eben 
nicht die 9999 zuerst anzeigst, sondern erstmal um eins runter zählst. 
Und das in einer ARG verkrampften Weise. Mein Gott! Übst du für den C 
obfuscation contest?

Das geht DEUTLICH einfacher und ÜBERSICHTLICHER!

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
uint16_t damn [10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90};
uint8_t data[4];
int16_t zahl = 9999;
uint8_t digit;

int main(void) {
  
  DDRD |= (0x7F);
  DDRC |= (0x1E);
  TCCR0 |= (1<<CS00) | (1<<CS01);
  TIMSK |= (1<<TOIE0);
  
  TCCR1B |= (1<<CS10) | (1<<CS11);
  TIMSK |= (1 << TOIE1);
  
  sei();
  
  PORTD |= ~0x3F;    //Löschen der Anzeige
  PORTC |= 0x1C;
  
  while(1) {
  }
}

// Count down

ISR(TIMER1_OVF_vect) {

  zahl--;
  if (zahl < 0) zahl = 9999;
  data[3] = zahl % 10; zahl /=10;
  data[2] = zahl % 10; zahl /=10;
  data[1] = zahl % 10; zahl /=10;
  data[0] = zahl % 10;
}

// Multiplexansteuerung der Anzeige

ISR(TIMER0_OVF_vect) {

  PORTC |= 0x1E;                // alles aus
  digit++;
  if (digit > 3) digit = 0;  
  PORTD = damn[data[digit]];    // Muster für neues Digit
  PORTC &= ~(1 << (digit+1));    // Digit einschalten
}

Außerdem, wenn man schon alles in die ISRs packt, braucht man auch kein 
volatile, denn es gibt NUR in den ISRs den Variablenzugriff, nicht im 
normalen Programm. Ich würde das aber nicht so machen, denn man braucht 
dafür keine 2 Timer mit 2 ISRs. Eine reicht locker.

[Franny (Gast)]

Stephan schrieb:
> Zeile 10:
> volatile uint16_t c = 0x90;

Super Danke! In all dem Wirrwarr hab ich das echt übersehen.

Oliver S. schrieb:
> Das alles ist aber so verquer und durcheinander, da solltest du mal
> drüber shclafen, dann alles löschen, und von vorne anfangen.

Vernünftig strukturieren steht noch auf dem Plan :)
Konnte es mir nur leider noch nicht angewöhnen von vornherein sauber zu 
arbeiten...

> Franny schrieb:
> Schon merkwürdig, Du lädst ja 144 rein.

Immer diese Tippfehler...Ich meinte 144 ^^'

Vielen Dank an euch!

[Peter D. (peda)]

Franny schrieb:
> PORTD = damn[counts[digit - 1]];

Das muß man auch nicht bei jedem Multiplextakt immer wieder neu machen, 
sondern kann es einmalig bei der Zahlenumwandlung mit machen.

[Franny (Gast)]

Falk B. schrieb:
> Das geht DEUTLICH einfacher und ÜBERSICHTLICHER!

Erstmal Danke für das ausführliche Drüberschauen!
Mir scheint aber beim Überfliegen, dass dein Programm nicht runter 
zählt, sondern nur zwischen 9999 und 0000 hin und her springt. Oder 
überseh ich da gerade etwas?

Peter D. schrieb:
> Das muß man auch nicht bei jedem Multiplextakt immer wieder neu machen,
> sondern kann es einmalig bei der Zahlenumwandlung mit machen.

Das wusste ich noch garnicht, danke :)

[Falk B. (falk)]

Franny schrieb:
> Falk B. schrieb:
>> Das geht DEUTLICH einfacher und ÜBERSICHTLICHER!
>
> Erstmal Danke für das ausführliche Drüberschauen!
> Mir scheint aber beim Überfliegen, dass dein Programm nicht runter
> zählt, sondern nur zwischen 9999 und 0000 hin und her springt. Oder
> überseh ich da gerade etwas?

Du übersiehst was.

  zahl--;
  if (zahl < 0) zahl = 9999;