www.mikrocontroller.net

Forum: Compiler & IDEs Interrupt +ATMEGA32


Autor: Gizmo (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo

Ich arbeite gerade mit einem ATMEGA 32 und versuche über INT2 einen 
Hardware Interrupt auszulösen. Irgendwie wird aber nicht in die 
Interrupt Routine gesprungen. Sprich der Hardware Interrupt wird nicht 
ausgelöst. Hier mal mein Code.

#include <avr/io.h>

#include <compat/twi.h>

#include <util/delay.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>
#include <stdlib.h>
#include <avr/interrupt.h>


#include "USART.h"
#include "USART.c"

#include "i2cdevices.h"
#include "i2cdevices.c"

#include "i2cmaster.h"
#include "twimaster.c"

#include "BiT.h"
#include "BiT.c"

#include "Timer.h"
#include "Timer.c"

#include "PORT80.h"
#include "PORT80.c"

#include "Temperatur.h"
#include "Temperatur.c"



#define LED_RT_ON 0
#define LED_GN_ON 1
#define LED_RT_BLINK 2
#define LED_GN_BLINK 3

/* in PORT80.c definiert
unsigned char port_80_[100];
unsigned char port_80_read_pointer_ = 0;
unsigned char port_80_write_pointer_ = 0;
*/

//void pb_reset(void);


int main(void)
{
/******************************************************* I/O 
***********************************************************/
//LED BIT - HEAT Output

PORTC |= (1<<PORTC7) | (1<<PORTC6) | (1<<PORTC5) | (PORTC4);
  DDRC = 0x00;


//---------------------
//HEAT-FAN Output
PORTD |= (1<<DDD7) | (1<<DDD6);
DDRD |= (1<<PORTD7) | (1<<PORTD6);
//---------------------
//RESET-OUT

//---------------------------------------------------------------------- 
-------------------------------------------------


/*************************************************** Variabeln 
*********************************************************/
  unsigned char port_80_temp = 0;    //In diese Variable werden die 
Werte aus dem Array geschrieben
//  unsigned char led_merker_sc = ( 1<<LED_RT_BLINK); //4    // Bit 0 
rt, Bit 1 gn, Bit 2 rt-blink, , Bit 3 gn-blink
//  unsigned char led_merker_sp = 0x04;
//---------------------------------------------------------------------- 
-------------------------------------------------


//************************************************** Initialisierungs 
Routinen ******************************************
//DDRC |= 0x80;
//PORTC &= ~0x81;


  port80Init();
  initInterrupt2();    // PORT80
  initTimer1();
  SREG |= 0x80;
  i2c_init();        // I2C Bus initialisieren

  time_counter_[0] = 1;        // Timer benutzt LM92
  time_counter_[1] = 2;        // Timer benutzt für LED blinken
  time_counter_[2] = 301;        // Timer für PORT80 Time Out
  time_counter_[3] = 10;        // Timer für SC Reset beim Start für 
Delay
  time_counter_[5] = 8;
  time_counter_[6] = 21;        // Clr für NMEA EVT

  while(time_counter_[3] > 1){;}
  time_counter_[3] = 0;        // Timer für SC Reset
//---------------------------------------------------------------------- 
-----------------------------------------------------------------
//port_80_temp = 0xE7;
while(1)
{


// if port 80 dann rt-blink aus ELSE rt-blink on
    if(port_80_read_pointer_ != port_80_write_pointer_)
    {
      port_80_temp = port_80_[port_80_read_pointer_];
      port_80_read_pointer_++;
      if(port_80_read_pointer_ >= sizeof(port_80_)) 
port_80_read_pointer_ = 0;
      if (port_80_temp == 0xE7) //normal 0xC0
      {
        //PORTC &= ~(1<<PORTC7);
      }

    }
    if(port_80_temp == 0x80) time_counter_[2] = 301;
    if(time_counter_[2] <= 1)        // PORT 80 Test
    {
      if(port_80_temp != 0xC0)
      {
      //  led_merker_sc = (1<<LED_RT_ON);  // Rote LED vom sc teil 
schalten wenn wenn 0xc0 nicht kommt
      //  nmea_port_status_ = 0;


      }
      else
      {
      //  nmea_port_status_ = 1;
      }
    }
//      notloeschen();
    if(time_counter_[5] <= 1)
    {
      //sendNmea(NMEA_STA,NMEA_DUMMY,NMEA_DUMMY);
      time_counter_[5] = 100;
    }
//pb_reset();




}  //Endlosschleife

}  //Programmende

/*
void pb_reset(void)
{

  if(bit_is_clear(PIND, PIND3) )
  {

    PORTC &= ~(1<<PORTC6) ;


    PORTD |= (1<<PORTD1) ;
    PORTD &= ~(1<<PORTD1) ;
  }
  else{
      PORTC |= (1<<PORTC6) ;
      PORTD |= (1<<PORTD1);
    }
}//ende pb_reset */




SIGNAL  (INT2_vect)
{
  PORTC &= ~(1<<PORTC7) | (1<<PORTC6) | (1<<PORTC5) | (PORTC4);
  DDRC = 0xF0;
  PORTC &= ~(1<<PORTC7);



  PORTC &= ~(1<<PORTC7);
  port_80_temp_ = PINA;
  port_80_[port_80_write_pointer_] = port_80_temp_;
  port_80_write_pointer_++;
  if(port_80_write_pointer_ >= sizeof(port_80_)) port_80_write_pointer_ 
= 0;
  if(port_80_write_pointer_ == port_80_read_pointer_)
  {
    port_80_write_pointer_--;
    if(port_80_write_pointer_ >= 255) port_80_write_pointer_ = 
sizeof(port_80_)-1;
  }

}


meine Initialisierung Routine sieht so aus:

//Interrupt Routine for PORT80



unsigned char port_80_[100];
unsigned char port_80_read_pointer_ = 0;
unsigned char port_80_write_pointer_ = 0;


void port80Init(void)
{
    // Eingänge für PORT80
//  DDRA = 0x00;     /*Daten Richtungs Register für PORTA setzen*/
//  PORTA |= (1<<PORTA0) | (1<<PORTA1) | (1<<PORTA2) | (1<<PORTA3)
//  | (1<<PORTA4) | (1<<PORTA5) | (1<<PORTA6) | (1<<PORTA7);    /*Leds 
ausschalten*/
}



void initInterrupt2(void)    //Interrupt für PORT80 INT2 am ATMEGA32
{
  // port_80_write_pointer_ auf 0 setzen
  port_80_write_pointer_ = 0;

  // port_80_read_pointer_ auf 0 setzten
  port_80_read_pointer_ = 0;

  // MCUCSR muss nicht eingestellt werden da Bit6 (ISC2) schon auf 0 
steht. 0 fallende Flanke löst Interrupt aus.
  MCUCSR |= (1<<ISC10) | (1<<ISC11);

//  Externen Interrupt 2 aktivieren
  GICR |= (1<<INT2);


  MCUCSR |= (1 << ISC2);
   GICR  |= (1 << INT2);  //INT2 enable
}
Ich würde mich freuen wenn mir irgend jemand helfen könnte da ich 
absolut nicht weiter komme. Habe auch schon versucht, durch anlegen von 
5V auf der Interrupt leitung einen Interrupt auszölösen aber das bringt 
auch nichts.

Griß Gizmo

Autor: STK500-Besitzer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>SREG |= 0x80;

Soll das ein SEI(); ersetzen? Oder hast du die globale 
Interrupt-Freigabe vergessen?

>//  Externen Interrupt 2 aktivieren
>  GICR |= (1<<INT2);


>  MCUCSR |= (1 << ISC2);
>   GICR  |= (1 << INT2);  //INT2 enable

Wie oft willst du den Interrupt noch freigeben?

Nur so am Rand: Dein Code sieht erstens gruselig aus, und zweitens 
gehört sowas in den Anhang.

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Gizmo (Gast)

>Ich arbeite gerade mit einem ATMEGA 32 und versuche über INT2 einen
>Hardware Interrupt auszulösen. Irgendwie wird aber nicht in die

Siehe Interrupt, dort ist ein Beispiel drin.

Und lies mal was über Netiquette!!!
Lange Quelltexte als Anhang!

MFG
Falk

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.