www.mikrocontroller.net

Forum: Digitale Signalverarbeitung / DSP Variablenübergabe bei einem Interrupt


Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Forum,
ich hoffe ihr könnt mir weiterhelfen...
Folgendes Problem, ich arbeite an einem vorhandenen Programm für einen 
TMS320F2812 weiter. Das Programm besteht aus mehreren Dateien.
Da ich in meiner Interruptroutine eine Switch-case Anweisung hab, muss 
ich dieser Funktion eine Variable übergeben, man kann aber einer 
Interruptroutine keine Variable übergeben, zumindest nicht im CCS.
Mein erster Versuch war mit einer globalen Variable, mit "extern" 
deklariert, aber die Variable wurde nicht richtig von Funktion zu 
Funktion übermittelt. Und außerdem ist es ja keine saubere Lösung mit 
globalen Variablen zu arbeiten. Kann mir jemand einen Tip geben, wie ich 
eine Variable an meine Interruptroutine übergebe, oder was es da sonst 
noch für Möglichkeiten gibt.
Vielen Dank schon mal im voraus...

Stefanie

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich kenne nur die "Übergabe" per globaler Variable.
Aber als volatile deklarieren!

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
danke, das probier ich gleich mal...
nur volatile oder dann volatile extern?

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
kann mir noch bitte jemand sagen wie und wo ich das genau deklariere...

Autor: Norgan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> nur volatile oder dann volatile extern?

Bei der Deklaration (üblicherweise in einem Header) mit extern. Bei 
der Definition (üblicherweise in einer C-Datei) kann man es lassen.

Autor: Norgan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> kann mir noch bitte jemand sagen wie und wo ich das genau deklariere...

Wird Zeit für

http://www.amazon.de/Programmieren-ANSI-Mit-C-Refe...

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das ist mir momentan keine große Hilfe, ich habe 2 C-Bücher, deren 
Beispiele leider nicht aufschlussreich sind!

Ich hab das ganze mit volatile extern in der main.h deklariert und die 
main.h per include da eingebunden wo ich die Variable nutzen möchte.
Beim kompilieren treten keine Fehler auf, aber wenn ich das build 
erstelle meckert er rum, das da ein undefieniertes Symbol ist...
über einen tip wäre ich sehr dankbar...

Autor: PS (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Ich hab das ganze mit volatile extern in der main.h deklariert und die
> main.h per include da eingebunden wo ich die Variable nutzen möchte.
> Beim kompilieren treten keine Fehler auf, aber wenn ich das build
> erstelle meckert er rum, das da ein undefieniertes Symbol ist...

Das ist auch kein Wunder, denn mit der Speicherklasse "extern" wird
zum Ausdruck gebracht, dass die Variable in irgend einer anderen
Quelltextdatei deklariert wurde.

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn hier jeder bloß einen Brocken der Lösung hinschreibt und man sich 
alles selber zusammenbasteln muss ist das ja kein Wunder das nix bei 
raus kommt...

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe das ganze jetzt in der main.h so
volatile extern unsigned char flag;
deklariert
und in der main.c
volatile unsigned char flag; 
 so
außerdem benutze ich die Variable "flag" noch in der interrupt.c, aus 
diesem Grund habe ich die main.h per include in die interrutp.c 
eingebunden...

kann mir bitte jemand sagen was da nun noch falsch ist,
in meinem Hauptprogramm setze ich die Variable flag, aber das hat keine 
Auswirkungen auf die switch-case Anweisung in der Interrupt-Routine...

bin für jede Hilfe dankbar...

Autor: Norgan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wenn hier jeder bloß einen Brocken der Lösung hinschreibt und man sich
> alles selber zusammenbasteln muss ist das ja kein Wunder das nix bei
> raus kommt...

Hier wird erwartet, dass man selber denkt und selber an seiner 
Hausarbeit oder gar dem beruflichen Projekt arbeitet und nicht mit dem 
Silberlöffel gefüttert werden möchte.

Solltest du zuverlässige, jederzeit für dich auf dem Sprung stehende 
Beratungsleistung benötigen, dann bezahle einen Berater. Den kannst du 
dann  rumkommandieren wie du willst und der muss dir helfen. Hier muss 
niemand seine Zeit mit deinem Problem verschwenden.

Autor: J. T. (smarty)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Huhu,

also ich arbeite auch auf nem TMSF2812 unter CCS 3.1. Ich hab auch ne 
Menge globaler Variablen in dem vorgegebenen Code und die sind auch dem 
Interrupt zugänglich. Es soll eine Möglichkeit wie man einer ISR 
Variablen oder Zeiger übergeben kann, aber diese kenne ich leider auch 
nicht. In meinem Programm ist das so organisiert...

BSP:

in main.c

#include ...

int GLOBAL=0;

void main(void)
{
  GLOBAL=25;
}

in T1CINT_ISR.c

#include ...

extern int GLOBAL;

interrupt void T1CINT_ISR(void)
{
  GLOBAL=5;
}


Natürlich muss die ISR erst noch in einer Initialisierungsroutine 
zugewiesen werden, also quasi die Adresse der Funktion in die 
Vektortabelle eintragen.

dies geht z.B. für den T1CINT so:

EALLOW;

/*Interruptadresse für Timer1-Compare-Interrupt angeben (Interrupt 
Adresse in PIE-vector tabelle eintragen)*/

*(volatile long*)0x00000D58 = (long)&T1CINT_ISR;

EDIS;

oder falls man die neuen DSP-Header-Files benutzt auch komfortabler:

void init_interrupt(void)
{
  EALLOW;    /*erlaubt Zugriff auf Register*/

  //Interrupt Adresse in PIE-Vector Tabelle eintragen
  PieVectTable.T1CINT = &T1CINT_ISR;

  EDIS;    /*verbietet den Zugriff auf Register wieder*/

// NICHT VERGESSEN - Gewünschte Interrupts auch freischalten !!!

/*********************************************************************** 
***************
/ Freigabe der Pie Interrupts
************************************************************************ 
**************/

  PieCtrlRegs.PIECRTL.bit.ENPIE=1;
  PieCtrlRegs.PIEACK.bit.ACK2=1;
  PieCtrlRegs.PIEIER2.bit.INTx5=1;

  EvaRegs.EVAIMRA.bit.T1CINT=1;

  IER|=2;
  EINT;

}

Hoffe das hilft dir weiter!

PS: Im Simulator-Betrieb lassen sich Interrupts nicht testen, da die 
Timer nicht simuliert werden. Wenn du z.B. ein eZdsp-board hast kannst 
du das ohne Probleme dort im Step-, oder Run-Betrieb testen. Nicht 
vergessen einen Breakpoint im Interrupt zu setzen, sonst bekommt man 
nicht mit das er dort hineinspringt!

Autor: Stefanie (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@J. T.
Vielen Dank, das probier ich gleich mal aus...

Autor: Jan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So sollte es gehen:

main.h:
extern unsigned char volatile flag;

main.c:
unsigned char volatile flag; 

Ansonsten wäre könnte die Fehlermeldung von CCS weiterhelfen.


> Mein erster Versuch war mit einer globalen Variable, mit "extern"
> deklariert, aber die Variable wurde nicht richtig von Funktion zu
> Funktion übermittelt. Und außerdem ist es ja keine saubere Lösung mit
> globalen Variablen zu arbeiten.

Wieso soll das keine saubere Lösung sein?

Gruss, Jan

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.