interrupt nutzen

[Jürgen V. (derunglaubliche)]

Hallo,

ich bin ziemlich neu in dem Thema und wollte eine 7 Segment anzeige dazu 
bringen, von 0 hochzuzählen mit einer Pause von jeweils 1000ms zwischen 
dem Wechsel.
Jedoch will ich keine Delay Funktion nutzen, sondern die Interrupts 
nutzen.
Ich habe jetzt einen Code geschrieben, jedoch funktioniert dieser nicht.

Die Bitmasken sind aufjedenfall richtig. Beim ausführen sehe ich 
garnichts, weshalb ich denke dass meine Interrupt Routine garnicht 
aufgerufen wird.

Edit: Es handelt sich um einen AtMega328PB

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



uint8_t PC_Bitmaske[10] = {0b00111,0b01111,0b00111,0b00111,0b01111,0b10111,0b10111,0b00111,0b00111,0b00111};
uint8_t PD_Bitmaske[10] = {0b11000011,0b11111011,0b10100111,0b10110011,0b10011011,0b10010011,0b10000011,0b11011011,0b10000011,0b10010011};

  
uint8_t timer_counter = 0;
uint8_t number = 0;


ISR(TIMER0_OVF_vect) 
  {
  
  number++;  
  
  while(timer_counter < 100){
    
    timer_counter++;
    
  }
    
  PORTC = PC_Bitmaske[number];    // 7 Segmentanzeige des Zählwerts (Ziffer) 
  PORTD = PD_Bitmaske[number];  
    
  if(number == 9){    // Rotierenden Ziffernwert für Anzeige 0..9 iterieren (inkrementiern, prüfen, bei Überlauf zurücksetzen)
  number = -1;
  }
    
  }


int main(void)
{
  // 7 Segment Anzeige initialisieren (Alle LEDs aus, restliche Bits passend für Input und Tristate)
  DDRC = 0x18;
  PORTC = 0xFF;
  DDRD = 0x7C;
  PORTD = 0x7C; 
  
  // Timer/Counter 0 initialisieren: CTC Modus, Prescaler 1/1024, Interrupt-Intervall 10 ms
  TCCR0A = (1<<WGM01); 
  TCCR0B =    (1<<CS02)|(1<<CS00) ; 
  OCR0A = 156;
  TIMSK0 = 0b00000010; 
  //Interrupts global freigeben
  sei();
  
  
    while (1) 
    {
  
    }

[Christoph db1uq K. (christoph_kessler)]

avr steht ja wenigstens da, ist das ein Arduino?

[Jürgen V. (derunglaubliche)]

Wie rufe ich denn genau eine ISR Funktion in C auf ? Ich dachte die 
Routine würde mit dem sei() aufgerufen werden.

[Jürgen V. (derunglaubliche)]

Christoph db1uq K. schrieb:
> avr steht ja wenigstens da, ist das ein Arduino?

nein das ist ein AtMega328PB

[Hannes (Gast)]

while(timer_counter < 100){
    
    timer_counter++;
    
  }

Was soll das? Das zählt im ersten Interrupt einmal bis 100 und verweilt 
dann da fröhlich. Wenn du die 10ms zählen willst um auf 1s zu kommen, 
solltest du das anders machen.

Und du benutzt einen Capturewert und rufst den Overflowvector auf.

[Hannes (Gast)]

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



uint8_t PC_Bitmaske[10] = {0b00111,0b01111,0b00111,0b00111,0b01111,0b10111,0b10111,0b00111,0b00111,0b00111};
uint8_t PD_Bitmaske[10] = {0b11000011,0b11111011,0b10100111,0b10110011,0b10011011,0b10010011,0b10000011,0b11011011,0b10000011,0b10010011};

  
volatile uint8_t timer_counter = 0;


ISR(TIMER0_COMPA_vect){
  uint8_t number;
  timer_counter += 10; //10ms vergangen
  if(timer_counter == 10000) //nach 10s
    timer_counter = 0;
    
  number = (timer_counter - timer_counter%1000)/1000;  
  PORTC = PC_Bitmaske[number];    // 7 Segmentanzeige des Zählwerts (Ziffer) 
  PORTD = PD_Bitmaske[number];  
  
 }


int main(){
  // 7 Segment Anzeige initialisieren (Alle LEDs aus, restliche Bits passend für Input und Tristate)
  DDRC = 0x18;
    PORTC = 0xFF;
   DDRD = 0x7C;
    PORTD = 0x7C; 
  
    // Timer/Counter 0 initialisieren: CTC Modus, Prescaler 1/1024, Interrupt-Intervall 10 ms
    TCCR0A = (1<<WGM01); 
    TCCR0B =    (1<<CS02)|(1<<CS00) ; 
    OCR0A = 156;
    TIMSK0 = 0b00000010; 
    //Interrupts global freigeben
    sei();
 
    while (1) 
    {
  
    }


}

probier mal das

[Falk B. (falk)]

Jürgen V. schrieb:
> Hallo,
>
> ich bin ziemlich neu in dem Thema und wollte eine 7 Segment anzeige dazu
> bringen, von 0 hochzuzählen mit einer Pause von jeweils 1000ms zwischen
> dem Wechsel.
> Jedoch will ich keine Delay Funktion nutzen, sondern die Interrupts
> nutzen.

Prnzipiell richtig.

> Ich habe jetzt einen Code geschrieben, jedoch funktioniert dieser nicht.

Das oft der Fall ;-)

> Die Bitmasken sind aufjedenfall richtig. Beim ausführen sehe ich
> garnichts, weshalb ich denke dass meine Interrupt Routine garnicht
> aufgerufen wird.

Du hast einige grundlegende Dinge beim Thema Interrupt noch nicht 
verstanden. Lies den Artikel Interrput.

 while(timer_counter < 100){
    
    timer_counter++;
    
  }

Sowas ist sinnlos und hat in einer ISR nix zu suchen.

Das Multiplexen bzw. die Anzeige der Zahl macht man sinnvollerweise in 
der ISR, den Rest außerhalb. Für das einfache Beispiel kann man aber 
auch alles in der ISR machen. Siehe Anhang.

Dein wesentlicher Fehler ist der falsche Interrupt. Im CTC-Modus wird 
der Overflow praktisch NIE ausgelöst. Bei CTC muss man den COMPA nutzen.

[Falk B. (falk)]

Hallo Admins, bitte mal die Diskussion ins richtige Unterforum 
verschieben. Danke.

[Hannes (Gast)]

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

volatile uint8_t timer_counter = 0;

ISR(TIMER0_COMPA_vect){
  timer_counter += 10; //10ms vergangen
  if(timer_counter == 10000) //nach 10s
    timer_counter = 0;
 }

int main(){

  uint8_t PC_Bitmaske[10] = 
{0b00111,0b01111,0b00111,0b00111,0b01111,0b10111,0b10111,0b00111,0b00111 
,0b00111};
  uint8_t PD_Bitmaske[10] = 
{0b11000011,0b11111011,0b10100111,0b10110011,0b10011011,0b10010011,0b100 
00011,0b11011011,0b10000011,0b10010011};
    // 7 Segment Anzeige initialisieren (Alle LEDs aus, restliche Bits 
passend für Input und Tristate)
    DDRC = 0x18;
  PORTC = 0xFF;
  DDRD = 0x7C;
  PORTD = 0x7C;

    // Timer/Counter 0 initialisieren: CTC Modus, Prescaler 1/1024, 
Interrupt-Intervall 10 ms
    TCCR0A = (1<<WGM01);
    TCCR0B =    (1<<CS02)|(1<<CS00) ;
    OCR0A = 156;
    TIMSK0 = 0b00000010;
    //Interrupts global freigeben
    sei();

    while (1)
    {
  uint8_t number;
  number = (timer_counter - timer_counter%1000)/1000;
    PORTC = PC_Bitmaske[number];    // 7 Segmentanzeige des Zählwerts 
(Ziffer)
    PORTD = PD_Bitmaske[number];
    }
}


So ist es noch n ticken schöner, sofern die Anzeige asynchron umschalten 
darf.

[Falk B. (falk)]

Hannes schrieb:
> So ist es noch n ticken schöner, sofern die Anzeige asynchron umschalten
> darf.

Sicher?

volatile uint8_t timer_counter = 0;
if(timer_counter == 10000) //nach 10s

[Jürgen V. (derunglaubliche)]

Ich habe mir das Thema noch einmal neu angeschaut mit dem Interrupt und 
gemerkt dass ich die Funktion nicht richtig verstanden habe.
Jetzt habe ich das Thema verstanden und meinen Code verbessert. Jetzt 
klappt es auch mit dem hochzählen!

ISR(TIMER0_COMPA_vect)
  {
        
    if(timer_counter<100)
      {
        timer_counter++;
      } 
    
    else
    {
      timer_counter = 0;
      
      number++;  
      
      if(number == 10)
      {    
        number = 0;
      }
    }
    
  PORTC = PC_Bitmaske[number];    // 7 Segmentanzeige des Zählwerts (Ziffer) 
  PORTD = PD_Bitmaske[number];  
    
  
  }

als nächstes versuche ich mal ein numpad zu benutzen. wünscht mir glück 
:D

[Jürgen V. (derunglaubliche)]

Ich will nun den PB2 Pin von meinem Knopf auslesen um eine Nummer 
anzeigen zu lassen. Wie lasse ich den Zustand von einem Pin abfragen. 
Ich habe einmal das unten und einmal mit PINB versucht aber beide male 
wird auch ohne den gedrückten Knopf die 1 angezeigt.


if(PORTB & (1<<3)){
        number = 1;
    }

[Purzel H. (hacky)]

Ja, ein PORT wird auch nicht als PORT ausgelesen, sondern als PIN,
PIN ist der input buffer,
PORT ist der output buffer.

if ((PINB & 0x02)==0x02) {.. mach ..}