Outsourcen von Programmcode = Programmtod

[Stephan R. (Gast)]

Moin!

Mein Problem: nachdem ich nun verschiedene Interrupts auf dem Atmega8535 
hinbekommen habe, möchte ich die ISRs in eine eigene Interrupts.c Datei 
verlagern.
Doch der Compiler meckert, klagt über fehlende Deklarationen, egal, wo 
ich die Variablendeklarationen hinschiebe, ausser, sie stehen direkt 
"über" der main-loop als globale Variable.

Wie sieht eine vernünftige Lösung hierfür aus?

[Marco (Gast)]

http://www.cplusplus.com/doc/tutorial/functions2/ - Declaring functions.

Die Prototypen für Interrupts.c gehören in die Interrupts.h und müssen 
dann in deiner main-Datei über #include "Interrupts.h" eingebunden 
werden.

[Jörg W. (dl8dtl) (Moderator)]

Stephan R. schrieb:
> Wie sieht eine vernünftige Lösung hierfür aus?

. Trennung von Deklaration und Definition
. Deklaration gehört in eine Headerdatei

[Stephan R. (Gast)]

Deklarationen, die ich in -gleich welche- Header-Datei schreibe sind 
doch autoatisch global- oda?

[Marco (Gast)]

Nur wenn du diese Headerdatei überall einbindest.

[Stephan R. (Gast)]

Es will nicht klappen!!
Wenn nicht ISR und Variablendekaration direkt nebeneinanderstehen, 
behauptet er, die Variable wäre nicht deklariert!

Nebenbei: muss ich für eine ausgelagerte ISR einen Prototypen im 
Headerfile anlegen? Und ohne Auslagerung?
Sähe der Prototyp für ISR(TIMER0_COMP_vect) dann so 
ISR(TIMER2_COMP_vect);
aus?
Fragen über Fragen. Zeit fürs erste Flens..

[Jörg W. (dl8dtl) (Moderator)]

Stephan R. schrieb:

> Wenn nicht ISR und Variablendekaration direkt nebeneinanderstehen,
> behauptet er, die Variable wäre nicht deklariert!

Dann mach Nägel mit Köpfen und poste (minimalen!) Code, der das
Problem aufzeigt.

> Nebenbei: muss ich für eine ausgelagerte ISR einen Prototypen im
> Headerfile anlegen?

Nein.  Eine ISR ist komplett eigenständig und wird nur durch ihren
Vektornamen eindeutig zugeordnet (das macht erst der Linker).

[Stefan B. (stefan)]

Stephan R. schrieb:

> Es will nicht klappen!!
> Wenn nicht ISR und Variablendekaration direkt nebeneinanderstehen,
> behauptet er, die Variable wäre nicht deklariert!

Code zeigen wäre hilfreich.

my_int.c:

#include "my_int.h"

// Globale Variable für den Datenaustausch 
// zwischen ISR und main()
volatile char foo; 

ISR(TIMER2_COMP_vect)
{
  foo = 1;
}

my_main.c:

#include "my_int.h"

int main(void)
{
  // TIMER2_COMP aufsetzen...
  while (1)
  {
    if (foo != 0)
    {
      // auf TIMER2_COMP reagieren...
      // Gemeinsame Variable zurücksetzen
      foo = 0;
    }
  }
}

my_int.h:

#include <avr/io.h>
#include <avr/interrupt.h>
extern volatile char foo;

> Nebenbei: muss ich für eine ausgelagerte ISR einen Prototypen im
> Headerfile anlegen? Und ohne Auslagerung?
> Sähe der Prototyp für ISR(TIMER0_COMP_vect) dann so
> ISR(TIMER2_COMP_vect);
> aus?
> Fragen über Fragen. Zeit fürs erste Flens..

Nein für die ISR brauchst du keinen Prototypen anzulegen.

Die avr/interrupt.h hast du includiert, damit ISR und TIMER2_COMP_vect 
beim Kompilieren bekannt sind?

[Stephan R. (Gast)]

Super. Mein liebevoll zusammengeschnipelter Code ist wieder weg.
Aber nach einpaar Experimenten mit "extern" wurden sie Fehler immer 
weniger und sind schließlich ale weg, muss mir noch bissel was über 
extern und volatile anlesen, dnek ich.
Vielen Dank!

[Kaila (Gast)]

Moin,

also ich pflege immer folgendes:
- die main-Funktion und der ISR in ein Main-Modul.
- da kommen dann auch die globalen Attribute hin.
- in der ISR kannst Du dann eine Funktion aus einem
  anderen Modul aufrufen und Parameter uebergeben oder
  Attribute importieren.
ungefaehr so:

main.c
-------------------------------
#include "my_int.h"

char foo;

ISR(...){
 ...
 what_ever(foo);
 ...
}

int main(void){
 ...
 foo='c';
 ..
}
-------------------------------

my_int.c
-------------------------------
// extern char foo;

int what_ever(int param){
 ...
 // Zugriff auf importiertes foo oder param
 ...
}
-------------------------------