www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Variablenwert geht nach verlassen der ISR verloren


Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ersteinmal vorweg. Ich programmiere einen MPSF2619.
In diesem Programm wird eine ISR nach Timerüberlauf aufgerufen. In diese 
wird der AD Wandler gestartet und der aktuelle AD Wert in ein Array 
geschrieben. Dies darf allerdings nicht öfters wie 60-mal geschehen. 
Danach soll das "komplette" Programm beendet werden.
Soweit klappt auch alles, bis auf das sich der Zählwert der Variable 
jedesmal auf Null setzt wenn ich die ISR aufrufe. Habe die Zählvariable 
schon global als static definiert.
Das seltsame an der Sache ist, das es im Simulator funktioniert aber auf 
dem Prozesseor nicht.

Hoffe die Angaben sind ausreichend um mich bei meinem Problem zu 
unterstützen.

Autor: Johannes M. (johnny-m)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ist die Variable auch volatile deklariert?

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke ersteinmal für die schnelle Antwort.

Zwischendurch war sie es kurzzeitig. Die Kombination aus static und 
volatile habe ich allerdings noch nicht getestet.

Autor: Bereits Fort (Firma: D.ade) (bereitsfort)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
entweder in der funktion static definieren wenn nur diese funktion die 
variable benutzt,

oder in main global definieren, dann können alle funktionen darauf 
zugreifen.

global & static weis nicht ob es da nicht  einen nesty gibt und die 
Variable automatisch zurückgesetzt wird?

am besten testroutine und testmain um die routine isoliert zu testen

dann in zielprogramm einbinden

wie wäre es du zeigtest mal so ein testmain mit testroutine. dann könnte 
jemand dein vorgehen auf schlüssigkeit oder fehler prüfen.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok hier ist mein eher schlecht als recht geschriebens Testprog.


#include "msp430x26x.h"
#include "main.h"

void zaehl ( )
{
  anz++;
 // while(1);

}

void main ()
{
  WDTCTL = WDTPW + WDTHOLD;
  P1DIR |=0x01;
  BCSCTL1 |= XTS;
  BCSCTL3 |= LFXT1S_3;
  BCSCTL3 &= ~XCAP0;
   //TimerA_Init
  TACCTL0 = CCIE;                        //Capture/compate Int enable
  TACCR0 =50000;                          //11kHz
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous 
mode, Int enable

  TACTL |= MC1;                          //Timer starten

  //ADC12_Init
  ADC12CTL0 = ADC12ON;                  //AD Wandler wird eingeschaltet
  ADC12CTL1 = SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_2 + CONSEQ_0; 
//sampling Time, Clock divider=1, single conversion
  ADC12MCTL0 = SREF_0 + INCH_2;    //Channel 2

  //ADC12CTL0 |= ADC12SC + ENC;     //Wandlung starten
  _BIS_SR(GIE);
  while(1);
}

#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{
    volatile  static int i;


  //pti=&i;
    i++;
    ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
    //TACTL |= MC1;  //Timer starten
    P1OUT ^= 0x01;
    CCR0 +=50000;
    array[i] = ADC12MEM0;


    if(i ==60)
    { zaehl();}
    //zaehl();



}

Autor: Johannes M. (johnny-m)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du hast doch erzählt, die Variable sei global! In Deinem Programm ist 
sie es aber gar nicht (Dein Programm enthält keine einzige globale 
Variable)! volatile macht auch nur bei globalen Variablen überhaupt 
Sinn.

Vielleicht solltest Du Dich mal über die Unterschiede von globalen und 
funktionslokalen Variablen erkundigen...

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was soll das Programm tun?

'i' wird nie zurückgesetzt, und zusammen mit 'array[i] = ADC12MEM0' gibt 
das dann einen amoklaufenden Pointer.

Zudem wird 'anz' nur einmal hochgezählt (und nirgends deklariert).

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Johannes M.:
Also der Unterschied zwischen Global und lokal ist mir bekannt. Hatte 
das kurz vorm posten nochmal geändert.Sorry für die Verwirrung.

@Lothar Miller:
Der Sinn und Zweck sei erst einmal dahingestellt. Mir geht es 
Hauptsächlich darum i nach verlassen der ISR zu erhalten. Und im 
Simulator tut es ja auch. Nur wenn ich den FET Debugger nutzesetzt er i 
immer auf Null sobald er die ISR betritt.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
jetzt müsste alles draussen sein, das für Verwirrung sorgen könnte.
in der Header wird lediglich das Array deklariert und eventuell spätere 
Variablen.


#include "msp430x26x.h"
#include "main.h"

volatile int i;

/*void zaehl ( )
{
  anz++;
 // while(1);

}*/

void main ()
{
  WDTCTL = WDTPW + WDTHOLD;
  P1DIR |=0x01;
  BCSCTL1 |= XTS;
  BCSCTL3 |= LFXT1S_3;
  BCSCTL3 &= ~XCAP0;
   //TimerA_Init
  TACCTL0 = CCIE;                        //Capture/compate Int enable
  TACCR0 =0xF400;                          //11kHz
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous 
mode, Int enable

  TACTL |= MC1;                          //Timer starten

  //ADC12_Init
  ADC12CTL0 = ADC12ON;                  //AD Wandler wird eingeschaltet
  ADC12CTL1 = SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_2 + CONSEQ_0; 
//sampling Time, Clock divider=1, single conversion
  ADC12MCTL0 = SREF_0 + INCH_2;    //Channel 2

  //ADC12CTL0 |= ADC12SC + ENC;     //Wandlung starten
  _BIS_SR(GIE);
  while(1);
}



#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{


  //pti=&i;
    i++;
    ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
    //TACTL |= MC1;  //Timer starten
    P1OUT ^= 0x01;
    CCR0 +=0xF400;
    array[i] = ADC12MEM0;


    if(i ==60)
    { i=0;
      }
    //zaehl();



}

Autor: Bereits Fort (Firma: D.ade) (bereitsfort)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>>>
....
#include "main.h"

volatile int i;

/*void zaehl ( )
.....
>>>


so bleibt i  aus main für deine ISR unsichtbar und wird lokal neu 
deklariert (automatisch)

 enweder:

>>>
....
#include "main.h"

global int i;

/*void zaehl ( )
.....
>>>


oder:

>>>
....

#include "msp430x26x.h"
#include "main.h"

void main ()
.....


....

 #pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{

static int i;
  pti=&i;
    i++;
    ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
    //TACTL |= MC1;  //Timer starten
    P1OUT ^= 0x01;
    CCR0 +=0xF400;
    array[i] = ADC12MEM0;


    if(i ==60)
    { i=0;
      }
  zaehl();

}
>>>

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ich habe mich für die zweite variante entschieden und noch den 
Zeiger entfernt, da dieser keinerlei Funktion hat.

 #pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{

static int i;
    i++;
    ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
    //TACTL |= MC1;  //Timer starten
    P1OUT ^= 0x01;
    CCR0 +=0xF400;
    array[i] = ADC12MEM0;


    if(i ==60)
    { i=0;
      }
  zaehl();

}
Ausser in der ISR kommt mein i jetzt nirgens mehr vor aber es will 
dennoch nicht.

Autor: Bereits Fort (Firma: D.ade) (bereitsfort)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
weil die Routine nicht wieder gestartet wird ,

du hast den timerstart noch auskommentiert, so wird

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
OK habs hinbekommen jetzt tut es was es soll, wobei mir die lösung nicht 
ganz klar ist. hab eig nur die Abfrage auf 60 in den main teil genommen.

static int i;

void main (void)  {

  if(i==0){

 P1DIR |=0x01;
      //TimerA_Init
  TACCTL0 = CCIE;                        //Capture/compate Int enable
  TACCR0 =0x3FFF;                          //11kHz
  //*************Achtung, nur zu Testzwecken TASSEL_2*************
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous 
mode, Int enable
  TACTL |= MC1;                          //Timer starten

  //ADC12_Init
  ADC12CTL0 = ADC12ON;                  //AD Wandler wird eingeschaltet
  ADC12CTL1 = SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_2 + CONSEQ_0; 
//sampling Time, Clock divider=1, single conversion
  ADC12MCTL0 = SREF_0 + INCH_2;  }  //Channel 2

  //ADC12CTL0 |= ADC12SC + ENC;     //Wandlung starten
  _BIS_SR(GIE);
  while(1);
}

#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{

  ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
  //TACTL |= MC1;  //Timer starten
  P1OUT ^= 0x01;
  CCR0 += 0x3FFF;
  i++;
  main();
}

wenn mir jetzt noch jemand erklären kann was da jetzt genau der 
Unterschied ist, ist mein Tag gerettet.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
naja das mit der Abfrage auf 60 fehlt noch :D

Autor: Stefan B. (stefan) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wuddy wrote:

> wenn mir jetzt noch jemand erklären kann was da jetzt genau der
> Unterschied ist, ist mein Tag gerettet.

Dein letzter Code ist von hinten durchs Knie in die Brust geschossen. Es 
mag eine Zeit lang funktionieren, aber 99% der Programmierer schütteln 
sich.

main() wieder innerhalb der ISR aufrufen ist IMHO ein No-Go. Du erzeugst 
damit eine Rekursion, die nie aufgelöst wird und die dir wahrscheinlich 
mit einem Stacküberlauf als Programmfehler endet.

Auch wird erste Interrupt formal gesehen nie verlassen, da die ISR nicht 
verlassen wird. Der Programmzeiger kommt nicht zum } hinter dem dortigen 
main(). (Ich habe hierbei nicht geprüft, ob _BIS_SR(GIE); den aktuellen 
Interrupt löscht)

Ein "normaler" Programmierer würde in main() den Timer initialisieren 
und starten und dann in eine endlose Hauptarbeitsschleife anstossen.

In der ISR würde ggf. eine Aktion ausgeführt (z.B. Hochzählen einer 
globalen, volatilen Variable) und ggf. der Timer neu initialisiert.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hm..ja ok, das ist wirklich ziemlich konfus gemacht. Aber wie sieht es 
aus wenn das ganz selber als Unterprogramm zu realisieren ist und nach 
erreichen der 60 Werte ins eigentliche Hauptprogramm gesprungen werden 
soll?

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann es sein das der Fehler wo anders liegt. Folgendes Szenario:

Ich debugge das ganze im Stepbetrieb. Komme bis zur while() und warte 
dann dort bis der Timer die gewünschte Zahl erreicht hat.Von Hand stelle 
ich dann das TAR-Reg auf den gewünschten Wert. Infolgedessen wird 
Interrupt ausgelöst und Sprung in die ISR. Soweit, sogut. Weiter im 
Stepbetrieb bis zur letzten Klammer der ISR }. Nach Ausführen der 
Klammer springt der Debugger in RUN und es kommt kein INT mehr. Erst 
wenn ich ihn stoppe und von Hand erneut einen INT auslöse.
Da ist das nicht ganz nachvollziehen kann habe ich diese ganze "main" - 
Springerrei eingebau.

Autor: Bereits Fort (Firma: D.ade) (bereitsfort)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
main() // das Hauptprogramm

Ist üblicherweise mit warten und auf Ereignisse und Aufrufen von 
Unterprogrammen (Funktionen und Routinen) beschäftigt, welche ihrerseits 
nach abarbeiten ihres jobs ihren status an main zurückmelden.
ISR sind ereignisbasierte Routinen, welche dazu dienen ein zeitlich 
nicht vorhersehbares Ereignis zu erfassen oder eben bei timer IRQ 
regelmäsig das laufende Programm zu unterbrechen um notwendige 
Aktualisierungen anzustoßen. Üblicher weise setzen sie ein Flag damit 
das Hauptpprgram eine passende Subroutine aufrufen kann. Diese erledigt 
dann den eigentlichen Job und kehrt anschließend nach main zurück.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wäre es möglich das der TimerA falsch initialisiert ist und so die 
Interrupts nicht richtig auslösen?
TimerA soll im Compare Mode und Continuous mode laufen. Grundsätzlich 
ist mir µC Programmieren bekannt da ich schon mit PIC und ARM gearbeitet 
hab. Mit MSP habe ich allerdings erst seit 3 Wochen zu tun.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So jetzt nochmal mein Ursprungsprogramm das ich gestern geschrieben 
hatte und dachte das ist am logischsten:

#include "msp430x26x.h"
#include "main.h"



static  int i;

void main (void)  {

  //if(i==0){
 WDTCTL = WDTPW + WDTHOLD;
 P1DIR |=0x01;
      //TimerA_Init
  TACCTL0 = CCIE;                        //Capture/compate Int enable
  TACCR0 =50000;                          //11kHz
  //*************Achtung, nur zu Testzwecken TASSEL_2*************
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous 
mode, Int enable
  TACTL |= MC1;                          //Timer starten

  //ADC12_Init
  ADC12CTL0 = ADC12ON;                  //AD Wandler wird eingeschaltet
  ADC12CTL1 = SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_2 + CONSEQ_0; 
//sampling Time, Clock divider=1, single conversion
  ADC12MCTL0 = SREF_0 + INCH_2;  //}  //Channel 2

  //ADC12CTL0 |= ADC12SC + ENC;     //Wandlung starten
  _BIS_SR(GIE);
  while(1);
}

#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)

{

  ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
  //TACTL |= MC1;  //Timer starten
  P1OUT ^= 0x01;
  CCR0 += 50000;
  i++;
}

nach dem tausendsten Debuggversuch und einiger Breakpoints stimmt alles. 
Oder gibt es noch was dran auszusetzen?

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> static  int i;
volatile int i;
Sonst kann es sein, dass der Compiler in anderen Routinen nicht erkennt, 
dass i ausserhalb geändert wird.

Denn das:
  while(1);
wird vermutlich auch noch anders?


BTW:
mit [/c] und [c] kann man C-Code schön darstellen.
Siehe Formatierung in der grauen Box um das Eingabefeld.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja das
while()
 wird auch noch anders. Die eigentliche Arbeit kommt jetzt erst noch :/ 
Das eben war nur Vorgeplänkel. Na toll und das hat so Kopfzerbrechen 
bereitet.
Danke nochmal für die schnelle und ausführliche Hilfe!

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe das Programm am Freitag noch einmal auf Herz und Nieren 
getestet und debugged und das Problem besteht nachwievor. Mir ist aber 
beim debuggen aufgefallen, dass er nach der ISR nicht in die while geht 
und wartet sondern die main komplett neu durchgeht.
void main (void)  {
  
  //if(i==0){ 
  WDTCTL = WDTPW + WDTHOLD; 
  P1DIR |=0x01;
      //TimerA_Init
  TACCTL0 = CCIE;                        //Capture/compate Int enable
  TACCR0 =50000;                          //11kHz
  //*************Achtung, nur zu Testzwecken TASSEL_2*************
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous mode, Int enable
  //TACTL |= MC1;                          //Timer starten
  
  //ADC12_Init
  ADC12CTL0 = ADC12ON;                  //AD Wandler wird eingeschaltet
  ADC12CTL1 = SHS_0 + SHP + ADC12DIV_0 + ADC12SSEL_2 + CONSEQ_0;    //sampling Time, Clock divider=1, single conversion
  ADC12MCTL0 = SREF_0 + INCH_2;  //}  //Channel 2 

  //ADC12CTL0 |= ADC12SC + ENC;     //Wandlung starten
  _BIS_SR(GIE);
  while(1);

}

#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
 
{
  static int a;
  ADC12CTL0 |= ENC + ADC12SC;   //Wandlung starten
  TACTL |= MC1;  //Timer starten
  P1OUT ^= 0x01;
  CCR0 += 50000;
  a++;
}

Mir ist jetzt allerdings nicht mehr so ganz klar wie und wo ich die 
zählvariable definieren soll, damit beide Funktionen drauf zugreifen 
können und sie auch ändern können.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann es sein das der Timer falsch initiallisiert ist? Denn wenn ich mir 
das TAR im Debugger anschaue macht das komische Dinge.

Autor: Rufus Τ. Firefly (rufus) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Mir ist jetzt allerdings nicht mehr so ganz klar wie und wo ich die
> zählvariable definieren soll, damit beide Funktionen drauf zugreifen
> können und sie auch ändern können.

Die Zählvariable scheint Dein 'a' zu sein. Anstelle es in der ISR als 
static zu deklarieren, musst Du es nur außerhalb der ISR und außerhalb 
von main als volatile deklarieren.

> Mir ist aber beim debuggen aufgefallen, dass er nach der ISR
> nicht in die while geht und wartet sondern die main komplett
> neu durchgeht.

Dann geht da wohl irgendwas schief.

>   TACTL |= MC1;  //Timer starten

Bist Du Dir sicher, daß diese Zeile in die Timer-ISR gehört?

>   CCR0 += 50000;

Willst Du das? Nicht TACCR0?

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Beim dem
TACTL |= MC1;
  war ich mir nicht sicher.

Ach und ich dachte TACCR0 und CCR0 seien das gleiche Register da in der 
Header ja steht
#define CCR0                TACCR0

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Habe jetzt festgestellt das der Interrupt auslöst sobalt der Wert im 
Compare Reg erreicht ist, was ja auch gewünscht. Aber sobald das TAR von 
0xFFFF nach 0x0000 wechseln sollte Schwachsinn passiert und nach 
unbestimmter Zeit wieder die main von vorn aufgerufen wird.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
OK jetzt weiß ich wo der Fehler ist. Sobald ein Überluaf von FFFF->0000 
stattfindet wird ein zweiter, "nicht definierter" Interrupt ausgelöst, 
der den Programmzeiger ins Nirvana zeigen lässt. Anschließend wird die 
main "neugestartet" Allerdings ist mir nicht so ganz klar warum der 
Inhalt der Variablen dann verloren geht. Bestimmt wird einfach alles neu 
initiallisiert, was dann auch die Register zurücksetzt.

Meine Frage wäre jetzt wie ich den zweiten, nicht erwünschten, Interrupt 
abschalte.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Lothar Miller:
Was genau meinst du mit Watchdog?

Autor: Guru (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Indem du ihn gar nicht erst einschaltest!

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Meine Frage wäre jetzt wie ich den zweiten,
> nicht erwünschten, Interrupt abschalte.
Du darfst den nicht einschalten, ich würde auf diese Zeile tippen:
  TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE;    //ACLK, divided 1, Continuous mode, Int enable

Probiers doch mal so:
  TACTL = TASSEL_2 + MC_2 + ID_0;    //ACLK, divided 1, Continuous mode

> Was genau meinst du mit Watchdog?
Passt schon, du schaltest den korrekt ab.
  WDTCTL = WDTPW + WDTHOLD;

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hm...ja...OK...auf dem falschen Fuss erwischt. Leider ist mir die 
Funktion des Watchdog nicht ganz geläufig. Weiß nur das das auch eine 
Art Timer ist.
Hab WDTCTL = WDTPW + WDTHOLD jetzt mal auskommentiert aber TAIFG wird 
dennoch gesetzt.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
OK auf den ersten Blick sieht es gut aus, jetzt wird nur ein INT 
ausgelöst.
Will mal versuchen den Fehler zu rekonstruieren.
Durch
TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE; 
 habe ich alle Interrups freigegeben, also auch den Overflow.

Autor: Christian R. (supachris)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
TAIE gibt nur den Overflow-Interrupt frei, die CCR-Interrupts sind in 
den passenden TACCTLx Registern zu finden (Bit CCIE). TAIFG wird bei 
Überlauf immer gesetzt, egal, ob der Interrupt freigegeben ist oder 
nicht, TAIE schaltet nur den IRQ zum Interrupt-Controller durch.

Watchdog auskommentieren ist auch schlecht, dann startet dein Programm 
in regelmäßigen Abständen neu. Alle Variablen usw. sind dann natürlich 
weg, weil quasi ein Kaltstart vorgenommen wird. Lass die Zeile mit 
WDTHOLD mal schön drin.

Außerdem nimmst du den falschen Interrupt-Vektor. TIMER_A0 ist nur für 
den Overflow. Die CCR-Interrupts teilen sich den TIMER_A1 Vektor, da 
musst du dann auch das TAIV auswerten, um festzustellen, welcher CCR-Int 
jetzt kam.

Du solltest dich erst mal eingehend mit dem User Guide beschäftigen, da 
steht alles wichtige drin.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So der Watchdog ist jetzt wieder drin und der Overflow ist "deaktivier". 
Sieht bis jetzt auch gut aus. Das Ding läuft durch und erhöht ständig 
den Wert, so wie es auch soll.

Bedanke mich recht herzlich für die ausführliche und schnelle Hilfe.

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Den Rat mit dem User Guide werd ich mir zur Brust nehmen. Hab es auf die 
gute, alte "learnig by doing" Variante versucht und bin, wie man dem 
Thread entnehmen kann, kläglich gescheitert :D

Autor: Sebastian B. (mircobolle)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wuddy wrote:
> OK auf den ersten Blick sieht es gut aus, jetzt wird nur ein INT
> ausgelöst.
> Will mal versuchen den Fehler zu rekonstruieren.
> Durch
TACTL = TASSEL_2 + MC_2 + ID_0 +TAIE; 
 habe ich alle
> Interrups freigegeben, also auch den Overflow.

Wie wäre es mit einer Interrupt Vektor Tabelle?

Du definierst für jeden aktivierten Interrupt eine ISR.

Aber das sicherste ist, nur die Interrupts zu aktivieren, die man 
wirklich verwenden möchte. Dazu nützt es das Handbuch (Manual) des 
Controllers beim Programmieren zur Hand zu haben. Das erspart viel Ärger 
;-)

Was mir an deinem Code auch noch aufgefallen ist, du verlässt dich beim 
Initialisieren deiner Variablen immer auf den Compiler. Zur Sicherheit 
würde ich aber immer ein
 = 0 
 schreiben, damit man sicher ist, dass die Variable einen definierten 
Wert hat.

MFG

Autor: wuddy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja ok den Wink mit dem Handbuch habe ich verstanden :)
Das mit dem initialisiren ist schon klar. Das ganze diente nur zu 
Testzwecken. Das eigentliche Programm ist dann ausführlicher und besser 
durchdacht, natürlich auch mit entsprechenden Vorabdefinitionen. Aber 
danke für den Hinweiß, hätte es später dann bestimmt vergessen.

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.