Interrupt Frage ATMEGA8535

[Robin F. (gehacktes)]

Nabend,

ich bin seit langem mal wieder am programmieren und will eine Uhr mit 
vier 7-Segmentanzeigen programmieren.
Das multiplexen funktioniert, muss aber die Zeit noch etwas anpassen da 
es leicht flackert.

Jetzt zum Problem.
Ich habe das Datenblatt vom Atmega 8535 versucht zu verstehen und bin 
eigentlich der Meinung das ich den Interrupt richtig programmiert habe?.

Da es aber nicht funktioniert und den Fehler einfach nicht finde und 
verstehe, bitte ich um eine kurze Kontrolle und hoffentlich um 
Hilfestellung was ich falsch mache.
Die Anzeigen bleiben dauerhaft auf 0 0 0 0 stehen.

#include <avr/io.h>
#ifndef   F_CPU                       //Vordefinieren für delay.h
#define   F_CPU 8000000UL            //Definition von F_CPU in Herz
#endif
#include <avr/interrupt.h>
#include <util/delay.h>

//0b PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0
//0b -1-  A   B   C   D   E   F   G
#define ZERO    0b10000001
#define ONE     0b11001111
#define TWO     0b10010010
#define THREE   0b10000110
#define FOUR    0b11001100
#define FIVE    0b10100100
#define SIX     0b10100000
#define SEVEN   0b10001111
#define EIGHT   0b10000000
#define NINE    0b10000100

const uint8_t zaehlen[10] = {ZERO, ONE, TWO,THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE};
//                Anzeige 4, Anzeige 3, Anzeige 2, ANzeige 1
//                  PC6    PC5      PC4      PC3
volatile uint8_t driver[4] = {0b10111111, 0b11011111, 0b11101111, 0b11110111};
volatile uint8_t sekunden, EinerM, ZehnerM, EinerS, ZehnerS =0;

ISR (TIMER1_COMPA_vect){
  sekunden++;
  if (sekunden == 60){
    EinerM++;
    sekunden = 0;
    if (EinerM == 9){
      ZehnerM++;
      EinerM = 0;
    }
    if (ZehnerM == 6){
      EinerS++;
      ZehnerM = 0;
    }
    if (ZehnerS && EinerS != 24){
      if (ZehnerS <= 2){
        if(EinerS == 9){
          ZehnerS++;
          EinerS = 0;
        }
      }
    }
    else{
      EinerM = 0;
      ZehnerM = 0;
      EinerS = 0;
      ZehnerS = 0;
    }
  }
}

int main(void)
{
    DDRD = 0xff;
    PORTD = 0x00;
    DDRC = (1<<PC3) | (1<<PC4) | (1<<PC5) | (1<<PC6);
    PORTC = 0x00;
  
  TCCR1A = (1<<WGM12);
  TCCR1B = (1<<CS12);
  
  OCR1A = 31249;
  TIMSK |= (1<<OCIE1A);
  
  sei();
  
    while (1) 
    {
    PORTD = zaehlen[EinerM];
    PORTC = driver[0];
    _delay_ms(1);
    PORTD = zaehlen[ZehnerM];
    PORTC = driver[1];
    _delay_ms(1);
    PORTD = zaehlen[EinerS];
    PORTC = driver[2];
    _delay_ms(1);
    PORTD = zaehlen[ZehnerS];
    PORTC = driver[3];
    _delay_ms(1);
    }
return 0;
}

Danke und liebe Grüße
Robin

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

Robin F. schrieb:
> Die Anzeigen bleiben dauerhaft auf 0 0 0 0 stehen.

    if (ZehnerM == 6)
    {
      ZehnerM = 0;
      EinerS++;
      ...               << Und hier kommt zuerst die Abfrage auf ZehnerS
        if(ZehnerS < 2)
        {
           ...              // EinerS geht bis 9
        }
        else
        {
           ...              // EinerS geht bis 3
        }
    }


    if (ZehnerS && EinerS != 24)  << ??? Was soll das sein ?
    {
      ...
    }
    else   <<<  Wird immer angesprungen = dauernd Null 
    {
      EinerM = 0;
      ZehnerM = 0;
      EinerS = 0;
      ZehnerS = 0;
    }

 P.S.
 Nur weil ein paar selbsternannte Experten hier im Forum die
 Klammern so schreiben, heisst es noch lange nicht, dass es so
 richtig ist.
 Aber wenn man die Klammern so schreibt, dass es übersichtlich und
 leichter zu debugen ist, wird man als blutiger Anfänger angesehen,
 oder ?

 Bei while(1) hast du es doch auch anders geschrieben, bleib dabei,
 nur bisschen einrücken.

[Noch nicht Rentner (Gast)]

Die Zaehlerei macht man nicht im Interrupt. Und im Hauptprogramm wird 
nicht gewartet. Delay gibt es nicht. Das macht ein Timer.

[Robin F. (gehacktes)]

Morgen,

danke für die schnellen Antworten. Ich habe vorhin "schnell" mal die 
erste Antwort ausprobiert, leider bislang noch ohne Erfolg. Ich glaube 
das der Interrupt nicht auslöst, da sonst ja wenigstens die Minuten 
hochgezählt und angezeigt werden müssten.

Ich werde das nach der Arbeit noch einmal versuchen zu realisieren.

Des weiteren werde ich mein Progrmam dann weiter anpassen und die 
Antwort zwei berücksichtigen. Hier weiß ich leider aber noch nicht wie 
ich dann den Sekundentakt ohne delay realisieren soll.
Dazu werde ich mich aber noch einmal belesen und ggf. hier nochmal 
nachfragen müssen.

Marc V. schrieb:
> P.S.
>  Nur weil ein paar selbsternannte Experten hier im Forum die
>  Klammern so schreiben, heisst es noch lange nicht, dass es so
>  richtig ist.
>  Aber wenn man die Klammern so schreibt, dass es übersichtlich und
>  leichter zu debugen ist, wird man als blutiger Anfänger angesehen,
>  oder ?

Danke für deine konstruktive Kritik.
Ich habe das damals so gelernt und von dort an immer so geschrieben, das 
es im main anders geschrieben war, war eigentlich eher ein versehen.

Ich werde aber in Zukunft versuchen deinen Ratschlag zu beherzigen und 
dies so schreiben.

In der zwischen Zeit (bis heute Nachmittag) werde ich mich noch einmal 
vermehrt über Interrupts schlau machen.
Sobald ich nachher das ganze erneut probiert habe, werde ich mich noch 
mal melden und meine Erkenntnisse mit euch teilen.

Beste Grüße

[Robin F. (gehacktes)]

Hallo,

ich habe jetzt das Datenblatt und weitere Internetseiten durchwühlt und 
mir ist ein Fehler bei dem Interrupt aufgefallen.

Ich habe bei TCCR1 das falsche Register verwendet.

Das TCCR1A ist nicht für den CTC Mode ausgelegt, ich muss dort das 
Register B nehmen.

Hoffentlich ist das der Fehler gewesen!

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

Robin F. schrieb:
> Ich habe bei TCCR1 das falsche Register verwendet.

 Ja, deswegen schreibt man normalerweise alle bits ab und setzt bei
 den unbenutzten bits Null ein.

  TCCR1B = (0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (1<<WGM12)
           (0<<CS12) | (0<<CS11) | (0<<CS10);

 So weiss man, dass keine bits vergessen sind.

[Thomas E. (thomase)]

Noch nicht Rentner schrieb:
> Die Zaehlerei macht man nicht im Interrupt.

Unsinn. Wo denn sonst?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Thomas E. schrieb:
>> Die Zaehlerei macht man nicht im Interrupt.
>
> Unsinn. Wo denn sonst?

'Türlich in der ISR. Das geht so schnell, das die ISR in Nullkomamnix 
durchläuft.
Hier mal ein Getriebe für eine 50Hz Uhr, ist bei mir etwas einfacher, 
weil ich die Stellen nicht getrennt brechnen muss:

// a simple clock gearbox
volatile uint8_t fifties = 0;
volatile uint8_t seconds = 0;
volatile uint8_t minutes = 0;
volatile uint8_t hours = 0;
volatile uint16_t days = 0;
// clock gearbox is called every 1/50 of a second
// Note that it is really the CTC interrupt but the 8515 uses the COMP vector
// 6 byte clock : fifties:seconds:minutes:hours:days
// this clock will wrap around after 65535 days ~= 179 years 

ISR(TIMER0_COMP_vect) {
     fifties++;
     if (fifties > 49) {
  fifties = 0;
  seconds++;
  if (seconds > 59) {
    seconds = 0; 
    minutes++;
    if (minutes > 59) {
      minutes = 0;
      hours++;
      if (hours > 23) {
        hours = 0; 
        days++;
        }
      }
    }
  }
}

Nur jede Sekunde wird die gesamte Routine durchlaufen, sonst nicht.

[Dietrich L. (dietrichl)]

Robin F. schrieb:
> Ich glaube
> das der Interrupt nicht auslöst, da sonst ja wenigstens die Minuten
> hochgezählt und angezeigt werden müssten.

Dann lass doch zuerst die Zählerei weg und toogle im Interrupt nur eine 
LED. So kannst Du Dich ganz auf die Funktion des Interrupts 
konzentrieren.
Solange die LED nicht blinkt brauchst Du gar nicht weitermachen.

[Robin F. (gehacktes)]

Dietrich L. schrieb:
> Solange die LED nicht blinkt brauchst Du gar nicht weitermachen.

Da hast du vollkommen Recht. Wenn das mit dem TCCR Register immer noch 
nicht die Lösung bringt, werde ich das heute nochmal so versuchen.

Kann ich ich eigentlich in einem Programm auch mehrere Timer verwenden?

Also um z.b. das Zählen in Timer 0 ablaufen zu lassen und um ggf. einen 
Taster oder die Anzeigen in einem weiteren Timer 1 unterbringen?

Wenn ja, muss man da irgendwas beachten oder eifnach beide 
initialisieren?

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

Robin F. schrieb:
> Kann ich ich eigentlich in einem Programm auch mehrere Timer verwenden?

 Natürlich, nur die jeweiligen Routinen so kurz wie möglich halten.
 Und nur eine davon darf (soll) die gemeinsamen Variablen ändern.

[Christian S. (roehrenvorheizer)]

Hallo,

ich habe meine Lösung nicht ausprobiert, sondern nur mal ins Datenblatt 
geschaut.

In TCCR1 gibt es kein WGM12. Ich würde Mode 0 vorschlagen, siehe 
Table48.

In TIMSK TOIE1 setzen, Timer1 Überlauf Interrupt. Hierzu den passenden 
overflow-irq heraus suchen. Table19 Timer1 OVF Vector9.

CS12 Takt/256 läßt den Timer laufen.

sei ()

Mit freundlichem Gruß

[Robin F. (gehacktes)]

Alles klar vielen Dank.

Ich habe das Datenblatt auch nochmal angeguckt und auf Seite 113 steht 
bei 16-Bit Timer bei Register B des TTCR1 das es ein WGM12 gibt.

Siehe Bild.

Ich werde deine Variante dennoch testen.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Robin F. schrieb:
> Kann ich ich eigentlich in einem Programm auch mehrere Timer verwenden?
>
> Also um z.b. das Zählen in Timer 0 ablaufen zu lassen und um ggf. einen
> Taster oder die Anzeigen in einem weiteren Timer 1 unterbringen?

Selbstverständlich geht das. Meine Uhr z.B. von oben läuft als Nebenjob 
in einem Frequenzgenerator, der eigentliche Frequenzgenerator läuft mit 
Timer 1 und kommt sich mit der Uhr nicht in die Quere. Ehrlich gesagt, 
benutze ich die Uhr zum Langzeitabgleich des Quarzes, um den 
Frequenzgenerator genauer zu machen.
Wenn die ISR einigermassen zügig fertig werden, gibts da keine Probleme.

[Robin F. (gehacktes)]

Aber das Multiplexen lassen ich jetz wie gehabt im main oder sollte ich 
das dann auch lieber auslagern?

Aber erstmal abwarten. Ich will erstmal die Anzeige vernünftig zum 
laufen bekommen.

Wenn das funktioniert will ich Taster mit implementieren um manuell 
Einstellungen vornehmen zu können und dann kommt die nächste Große 
Aufgabe und das wird dann ein DCF-77 Modul sein.

[Thomas E. (thomase)]

Robin F. schrieb:
> Aber das Multiplexen lassen ich jetz wie gehabt im main oder
> sollte ich
> das dann auch lieber auslagern?

Das kann da bleiben, wo es ist. Aber nicht mit Delays, sondern von einem 
Timer getriggert. Wobei es allerdings auch nichts ausmacht, die 
Mux-Ausgaben in einer ISR zu erledigen. Denn die gebetsmühlenartig 
vorgetragene So-kurz-wie-möglich-Regel ist zwar nicht kompletter Unsinn, 
sollte aber einem, bezogen auf das gesamte Programm, "So kurz wie nötig" 
weichen.

[Dietrich L. (dietrichl)]

Robin F. schrieb:
> Aber das Multiplexen lassen ich jetz wie gehabt im main oder sollte ich
> das dann auch lieber auslagern?

Wenn Du im main() sonst nichts zu tun hast, kannst Du es da lassen.
Falls aber zu erwarten ist, dass da noch Funktionen hinzu kommen (was Du 
ja planst), ist das Auslagern nicht schlecht. Dann läuft der Multiplexer 
wenigstens immer "rund" und ohne Flackern.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Robin F. schrieb:
> Aber das Multiplexen lassen ich jetz wie gehabt im main oder sollte ich
> das dann auch lieber auslagern?

Multiplex per Timer hat den Vorteil, das die Anzeige nicht flimmert, 
wenn main() gerade was anderes macht, sondern beinhart durchgezogen 
wird. Per Timerintervall kannst du dann bequem den Kompromiss zwischen 
Flimmern der Anzeige und Überlast des MC programmieren. Ausserdem kann 
der Multiplex Interrupt auch gleich die Tastenentprellroutine mit 
übernehmen.

Bewahre dir das also als Erweiterung für später auf und fummel dich 
erstmal durch den Uhren Interrupt durch.

[Robin F. (gehacktes)]

Vielen Dank!

So mach ich das.

[Christian S. (roehrenvorheizer)]

Ich hätte TCCR1A schreiben sollen.

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

Thomas E. schrieb:
> Denn die gebetsmühlenartig
> vorgetragene So-kurz-wie-möglich-Regel ist zwar nicht kompletter Unsinn,
> sollte aber einem, bezogen auf das gesamte Programm, "So kurz wie nötig"
> weichen.

 Hmmm.
 Für mich ist es dasselbe.
 Wenn irgendetwas nötig ist, dann ist es unmöglich ohne diesen
 auszukommen, also ist "So kurz wie nötig" gleichzusetzen mit
 "So kurz wie möglich".

[Peter D. (peda)]

Robin F. schrieb:
> Aber das Multiplexen lassen ich jetz wie gehabt im main oder sollte ich
> das dann auch lieber auslagern?

Das gehört in einen Timerinterrupt. Ansonsten wirst Du immer ein 
Flackern sehen, abhängig von allen anderen Tasks.

Benutzt Du noch andere Interrupts, ist es am besten, diese als
ISR(xxx_vect, ISR_NOBLOCK)
unterbrechbar zu machen. Damit erreichst Du das geringste Flackern.
Geht aber nicht immer, z.B. bei UART, SPI, I2C nicht.

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

Peter D. schrieb:
> Das gehört in einen Timerinterrupt. Ansonsten wirst Du immer ein
> Flackern sehen, abhängig von allen anderen Tasks.

 Kommt auf die Refreshrate an.
 Bei ausreichend schnellem Refresh ist eher ein Unterschied in der
 Helligkeit zu sehen.

[Robin F. (gehacktes)]

So ich habe das jetzt nochmal angepasst.
Jetzt funktioniert es. Eine Fragen habe ich jetzt noch.

Ich versteh noch nicht ganz wie ich den Vorteiler und den Vorladewert 
richtig berechne.
Ich habe versucht die Werte zu bestimmen aber mit keiner Rechnung komme 
ich auf das Ergebnis, welches in der Hardware funktioniert.
Ich habe jetzt den Vorladewert auf 15624 und den Vorteiler auf 64 
gestellt.
Mit diesen Werten komme ich auf einen Sekunden Takt aber wie berechne 
ich das richtig und nachvollziehbar?


Hier noch etwas Code zum lesen:

#include <avr/io.h>
#ifndef   F_CPU                       //Vordefinieren für delay.h
#define   F_CPU 16000000UL            //Definition von F_CPU in Herz
#endif
#include <avr/interrupt.h>
#include <util/delay.h>

//0b PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0
//0b -1-  A   B   C   D   E   F   G
#define ZERO    0b10000001
#define ONE     0b11001111
#define TWO     0b10010010
#define THREE   0b10000110
#define FOUR    0b11001100
#define FIVE    0b10100100
#define SIX     0b10100000
#define SEVEN   0b10001111
#define EIGHT   0b10000000
#define NINE    0b10000100

const uint8_t zaehlen[10] = {ZERO, ONE, TWO,THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE};
//                Anzeige 4, Anzeige 3, Anzeige 2, ANzeige 1
//                  PC6    PC5      PC4      PC3
volatile uint8_t driver[4] = {0b10111111, 0b11011111, 0b11101111, 0b11110111};
volatile uint8_t sekunden;
volatile uint8_t ZehnerS = 1;
volatile uint8_t EinerS = 6;
volatile uint8_t ZehnerM = 1;
volatile uint8_t EinerM = 5;

ISR (TIMER1_COMPA_vect){
  sekunden++;
  if (sekunden == 60){
    EinerM++;
    sekunden = 0;
    if (EinerM == 10){
      ZehnerM++;
      EinerM = 0;
    }
    if (ZehnerM == 6){
      EinerS++;
      ZehnerM = 0;
      
      if (EinerS == 10){
        ZehnerS++;
        EinerS = 0;
      }
      if (ZehnerS <2){
        if (EinerS == 10){
          ZehnerS++;
          EinerS = 0;
        }
      }
      else
      {
        if (EinerS == 4){
          ZehnerS = 0;
          EinerS = 0;
        }
      }
    }
  }
}

int main(void)
{
    DDRD = 0xff;
    PORTD = 0x00;
    DDRC = (1<<PC3) | (1<<PC4) | (1<<PC5) | (1<<PC6);
    PORTC = 0x00;
  //Erklärung Timer: https://www.mikrocontroller.net/articles/AVR-Tutorial:_Timer
  //https://sites.google.com/site/qeewiki/books/avr-guide/timer-on-the-atmega8
  // CTC Mode | Prescaler 64
  TCCR1B |= (1<<WGM12) | (1<<CS11) | (1<<CS10);
  //Vorladewert
  OCR1A = 15624;
  //
  TIMSK |= (1<<OCIE1A);
  
  sei();
  
    while (1) 
    {
    PORTD = zaehlen[EinerM];
    PORTC = driver[0];
    _delay_us(100);
    PORTD = zaehlen[ZehnerM];
    PORTC = driver[1];
    _delay_us(100);
    PORTD = zaehlen[EinerS];
    PORTC = driver[2];
    _delay_us(100);
    PORTD = zaehlen[ZehnerS];
    PORTC = driver[3];
    _delay_us(100);
    }
return 0;
}

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Robin F. schrieb:
> Ich habe jetzt den Vorladewert auf 15624 und den Vorteiler auf 64
> gestellt.

Nach meiner Rechnung (F_CPU/64/15625) kämest du damit auf genau 16 Hz 
Ticker, was mich zu der Annahme verleitet, das dein Mega mit dem 
internen Oszillator läuft und damit nicht mit dem externen 16MHz Quarz, 
sondern mit den 1MHz des Auslieferzustandes.
Um das zu ändern, setzt du die Fuses auf den externen High Frequency 
Crystal Modus (CKOPT = 0), den du aber tunlichst erst dann aktivierst, 
wenn da wirklich ein externer 16MHz Quarz mit den beiden kleinen 
Kondensatoren dran hängt.

[Robin F. (gehacktes)]

Okey also muss ich gucken das ich mit dem 1Mhz rechne und gucke ob dann 
eine annehmliche Zeit bei raus kommt?.

Nein ich werde keinen externen anhängen

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Robin F. schrieb:
> Okey also muss ich gucken das ich mit dem 1Mhz rechne und gucke ob dann
> eine annehmliche Zeit bei raus kommt?

Das hast du ja schon. Bei 1000000 Hertz geteilt durch 64 geteilt durch 
15625 kommt ja genau 1 Hz raus. Du solltest nur dein

#define F_CPU 16000000UL

auf 1000000UL umstellen, damit auch etwaige Aufrufe von _delay_ms() das 
richtige Ergebnis bringen.
Für eine gut gehende Uhr ist übrigens der interne RC Oszillator viel zu 
ungenau. Wenn es dir darauf aber nicht ankommt, geht der RC aber.

[Robin F. (gehacktes)]

Hab ich jetzt angepasst danke.
Dann funktioniert das jetzt alles soweit.

Jetzt baue ich die nächsten Funktionen ein:
- Sekundentakt blinken
- mit dem Taster manuell einstellen können
- DCF-77 (Zukunftsmusik)

Ich danke euch!!!

Wenn ich das Programm fertig habe, kann es gern noch einmal hier rein 
laden für weitere Verwendungen.

Beste Grüße

[Robin F. (gehacktes)]

Hallo zusammen,

ich möchte mal ein kleines Update zu meinem Projekt geben.
Ein paar Probleme gab es zu lösen da es nicht richtig funktioniert hatte 
die Zeit manuell runter zu zählen.
Aus diesem Grund habe ich Taster 1 für Stunden hochzählen und Taster 2 
für Minuten hochzählen verwendet.
Des weiteren habe ich das Zählen der Zeit noch einmal anderst gelöst.

Hier der Code:

#include <avr/io.h>
#ifndef F_CPU
#define F_CPU 1000000UL //1MHz Takt
#endif
#include <avr/interrupt.h>
#include <util/delay.h>

/*
  Port B = Ziffern der Anzeigen
  Port C = Anzeigen  
  Port D = Taster, Sekunden LED, DCF-77, Temperaturfühler
  
  DP = PD1
  A = PB6
  B = PB5
  C = PB4
  D = PB3
  E = PB2
  F = PB1
  G = PB0
  Seg1 = PC2
  Seg2 = PC3
  Seg3 = PC4
  Seg4 = PC5
  
  Taster PD2 Minuten & PD3 Stunden hochzählen
*/

//0b PB7 PB6 PB5 PB4 PB3 PB2 PB1 PB0
//0b -1-  A   B   C   D   E   F   G
#define ZERO    0b10000001
#define ONE     0b11001111
#define TWO     0b10010010
#define THREE   0b10000110
#define FOUR    0b11001100
#define FIVE    0b10100100
#define SIX     0b10100000
#define SEVEN   0b10001111
#define EIGHT   0b10000000
#define NINE    0b10000100

volatile uint8_t zaehlen[10] = {ZERO, ONE, TWO,THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE};

volatile uint8_t driver[4] = {0b11011111, 0b11101111, 0b11110111, 0b11111011};
volatile uint8_t sekunden, Stunden = 12, Minuten = 0;
uint8_t ZehnerS;
uint8_t EinerS;
uint8_t ZehnerM;
uint8_t EinerM;

ISR (TIMER1_COMPA_vect)
{
  sekunden++;
  PORTD ^= (1<<PD0); //Toggle LED sekunden Takt
  if (sekunden == 60)
  {
    sekunden = 0;
    Minuten++;
    if (Minuten > 59)
    {
      Stunden++;
      Minuten = 0;
    }
    if (Stunden > 23)
    {
      Stunden = 0;
    }
  }
}

ISR(INT0_vect)
{
  _delay_ms(5);
  sekunden = 0;
  Minuten++;
  if (Minuten == 60)
  {  
    Stunden++;
    Minuten = 0;
  }
  if (Stunden == 24)
    Stunden = 0;
}

ISR (INT1_vect)
{
  _delay_ms(5);
  sekunden = 0;
  Stunden++;
  if (Stunden == 24)
    Stunden = 0;
}

void Berechnen(void)
{
  EinerM = Minuten % 10;
  ZehnerM = Minuten / 10;
  EinerS = Stunden % 10;
  ZehnerS = Stunden / 10;
}

void Zeigen(void)
{
  PORTB = zaehlen[EinerM];
  PORTC = driver[0];
  _delay_ms(2);
  PORTB = zaehlen[ZehnerM];
  PORTC = driver[1];
  _delay_ms(2);
  PORTB = zaehlen[EinerS];
  PORTC = driver[2];
  _delay_ms(2);
  PORTB = zaehlen[ZehnerS];
  PORTC = driver[3];
  _delay_ms(2);
}

int main(void)
{
    DDRB = 0xff;  // Ziffern auf Anzeige
  PORTB = 0x00;
  DDRC = (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5);  //Azeigen
  PORTC = 0x00;
  DDRD = (1<<PD0);
  DDRD &= ~((1<<DDB2) | (1<<DDB3));  //Taster
  PORTD |= (1<<PORTD2) | (1<<PORTD3);
  
    //Erklärung Timer: https://www.mikrocontroller.net/articles/AVR-Tutorial:_Timer
    //https://sites.google.com/site/qeewiki/books/avr-guide/timer-on-the-atmega8
    //1MHz/64 = 15625
    //1Mhz/64/15625 = 1s
    // CTC Mode | Prescaler 64
    TCCR1B |= (1<<WGM12) | (1<<CS11) | (1<<CS10);
    OCR1A = 15624;  //Vorladewert
    TIMSK |= (1<<OCIE1A);
  //Interrupt für Taster Stunde und Minuten hochzählen
  MCUCR |= (1<<ISC00) | (1<<ISC01) | (1<<ISC10) | (1<<ISC11);
  GICR |= (1<<INT0) | (1<<INT1);
    sei();
    
    while (1)
    {
    Berechnen();
      Zeigen();
    }
return 0;
}

Meint Ihr, sind die Taster mit den externen Interrupts vernünftig gelöst 
oder sollte ich das liebe nicht mit Interrupts machen?

Gruß
Robin

[Oliver S. (oliverso)]

Nein und Ja.

Und Code bitte als Anhang, nicht im Beitrag.

Oliver

[Robin F. (gehacktes)]

So hier noch einmal ein Update des Programms.
Jetzt sind die Taster nicht mehr mit den Interrupts realisiert.

Die nächsten Schritte sind dann DCF-77 und Temperaturfühler DS1820 zu 
implementieren.