Globale Variable aus ISR verändern

[Robert T. (Firma: Thormann) (robertthormann)]

Hallo!
Bin ganz neu im Forum, und hoffe es kann mir jemand bei meinem Problem 
weiterhelfen.

Ich versuche eine globale variabel in einer ISR zu setzen um sie dann in 
meiner main() weiter zu verwenden.
Leider bleibt sie immer 0, wenn ich sie testhalber in der ISR deklariere 
funzt die zuweisung, jedoch logischerweise nur bis zum ende der ISR.

THX in vorraus!

CODE:



//----------------------------------------------------------------------
#define    F_CPU 3686400   // Taktfrequenz des myAVR-Boards
#include   <avr/io.h>    // AVR Register und Konstantendefinitionen
#include   <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdint.h>


volatile int8_t globvar1;

ISR(TIM1_COMPB_vect)
{

globvar1 = 55;


}

main ()                  // Hauptprogramm, startet bei Power ON und 
Reset
{


   DDRA=0b11111000;
   DDRB=0b00000000;
   DDRC &= ~ ((1<<PC0) | (1<<PC1) | (1<<PC2));
   PCMSK1 |= ((1<<PCINT8)|(1<<PCINT9)|(1<<PCINT10)|(1<<PCINT11)); //Pins 
B0-B3 für Pin change interrupt in Maske 1 setzen
   GIMSK |= (1<<PCIE1);
  //****************TIMER***************
// Timer 0 konfigurieren
TCCR1A = 0b00001011;
//TCCR0B = 0b00000011;
TIMSK =  0b00010000; //OCIE0A = 1 => Timer output compare A enable
OCR1A =  0b00001010;  // auf 10 laden
  sei();

   while (1)
   {
      globvar1++;

  }
}


PS:

Dass das Programm ziemlich sinnfrei ist weiß ich selber, ist ja nur zum 
üben.

[unregistered (Gast)]

Läuft dein Timer überhaupt? Wie testest du das Programm?

[Stefan E. (sternst)]

ISR(TIM1_COMPB_vect)
       ^
TIMSK =  0b00010000; //OCIE0A = 1 => Timer output compare A enable
                           ^

Des weiteren:
>   GIMSK |= (1<<PCIE1);
Wo ist die ISR dafür?

[unregistered (Gast)]

noch vergessen: Ich empfehle dir die bits in den Konfigurationsregistern 
per Schiebeoperation und Namensersetzung zu setzen. Das ist viel 
übersichtlicher.

Also z.B. statt TCCR1A = 0b00001011; TCCR1A = 
(1<<COM1B0)|(1<<WGM11)|(1<<WGM10);

Willst du COM1B0 setzen?

[Robert T. (Firma: Thormann) (robertthormann)]

THX für die schnellen Antworten


Das ist nicht der ganze code da der andere teil ja funzt (die PCINT 
ISR's), .. und ja der Timer läuft und im suimulator sehe ich auch das er 
in die ISR springt.

Testen tu ich das ganze mit dem AVR simulator.

[Karl H. (kbuchegg)]

Robert Thormann schrieb:
> THX für die schnellen Antworten
>
>
> Das ist nicht der ganze code da der andere teil ja funzt (die PCINT
> ISR's), .. und ja der Timer läuft und im suimulator sehe ich auch das er
> in die ISR springt.

Aber nicht mit dem von dir geposteten Programm.

Tip: Es ist immer gut, wenn man ein Programm abspeckt, das man es vor 
dem posten mal testet, ob sich das Problem dort überhaupt zeigt, bzw. ob 
man nicht beim Abspecken selber einen Fehler gemacht hat.

[Robert T. (Firma: Thormann) (robertthormann)]

OKY, dann der ganze code mit allem Mist den ich sonst ncoh so 
ausprobiert hab ;)

/*
 * UwTasterbox_2.c
 *
 * Created: 26.06.2012 11:33:17
 *  Author: robert.thormann
 */ 

/*
 * AVRGCC8.c
 *
 * Created: 26.06.2012 09:29:00
 *  Author: robert.thormann
 */ 

//----------------------------------------------------------------------
#define    F_CPU 3686400   // Taktfrequenz des myAVR-Boards
#include   <avr/io.h>    // AVR Register und Konstantendefinitionen
#include   <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdint.h>


static volatile int8_t globvar1;

/*
volatile int8_t Merker1;
volatile int8_t Merker2;
volatile unsigned int i=0;
volatile unsigned int j=0;
//Variablen für die Zeit
volatile int millisekunden;
int sekunde;
int minute;
int stunde;
*/
//----------------------------------------------------------------------
//**********************************************Delay CODE*********************************************************************************************

void warte_ms(unsigned int wartezeit)
{
  volatile unsigned int i;    // Schlaufenzähler für Millisekunden-Loop
  while(wartezeit != 0)       // Schlaufe für jede Millisekunde
  {
    i = F_CPU/17000;          // Berechne Startwert für Millisekunden-Loop

    while(i != 0)             // Schlaufe, solange i nicht gleich null ist

    {
      i = i-1;                // i minus eins
    }                         // Schlaufen-Ende wenn i gleich null ist
    wartezeit = wartezeit-1;  // minus eine Millisekunde
  }                           // Schlaufen-Ende wenn wartezeit gleich 0 ist

}                             // Funktionsende  => return


//************************************************ADC BEHANDLUNG********************************************************************************
uint16_t readADC(uint8_t channel)
{
   // Funktion 1 zum Auslesen der Spannung

   uint8_t i;                   // Variablen definieren (Zählervariable i + Resultat)
   uint16_t result = 0;

   ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1); //ADEN = ADC Enable
   // wenn adps1+2 on sind und adps0 off, dann ist der Teilungsfaktor 64 (Tabelle Datasheet)

   ADMUX = channel; //Kanal wählen; REFs0+1 -> interne Referenz 2,56V verwenden, REFS1 gibt es bei Attiny13 nicht
   //externen Kondensator mit 100nF (Aufdruck 104) an AREF auf Masse

   //Dummy-Readout (unten), misst 1* Ergebnis, wird nicht gespeichert
   ADCSRA = ADCSRA | (1<<ADSC); // Schaltet bei ADCSRA das ADSC-Bit ein, d.h. Messung starten
   while(ADCSRA & (1<<ADSC)); //Warte bis Messvorgang vorbei ist

   // Nun 3* Spannung auslesen, Durchschnittswert ausrechnen
   for (i=0; i<3; i++)
   {
      // Schleife, startet 3*
      ADCSRA = ADCSRA |(1<<ADSC); // Einmal messen
      while(ADCSRA & (1<<ADSC));  //Warte bis Messung vorbei

      result = result + ADCW; // Resultate zusammenzählen (R1+R2+R3) -> später alles /3
   }

   ADCSRA = ADCSRA & (~(1<<ADEN)); //ADC wieder deaktivieren

   result=result/3;    // Durchschnittswert

   return result;
}



//************************************Taster abfragen*************************************************************************************************

 
void Taster(void)
{
   uint8_t tmp_sreg;  // temporaerer Speicher fuer das Statusregister
 
   tmp_sreg = SREG;   // Statusregister (also auch das I-Flag darin) sichern
   cli();             // Interrupts global deaktivieren
 
   /* hier "unterbrechnungsfreier" Code */
 
  
  
   SREG = tmp_sreg;     // Status-Register wieder herstellen 
                      // somit auch das I-Flag auf gesicherten Zustand setzen
}

ISR(PCINT1_vect) //ISR Kommt wenn irgendein Taster gedrückt ist
  
  {
  cli();  
  if (!(PINB & (1<<PINB0)))      //wegen ACTIVE LO von Eingang ==> Taste 1 gedrückt
  {
    blink(1);
    OUT1();
  }  
  
  
  if (!(PINB & (1<<PINB1)))      //wegen ACTIVE LO von Eingang  ==> Taste 2 gedrückt
  {
    blink(2);
    OUT2();
  }  
  
  sei();
  }  
  
  
  
  void  OUT1(void)
  {
        uint16_t result1 = readADC(0); // ruft die ADC Funktion auf an Pin0 =ADC0
        PORTA |= (1<<PA4);          //1 ein
        warte_ms(result1);
        PORTA &= ~(1<<PA4);          //1 ein 
        
  }
   void  OUT2(void)
  {
        uint16_t result2 = readADC(1); // ruft die ADC Funktion auf an Pin0 =ADC0
        PORTA |= (1<<PA3);          //1 ein  
        warte_ms(result2);
        PORTA &= ~(1<<PA3);          //1 ein 
           
      
  }
  
  void blink(uint8_t channel)
  {
    if (channel == 1)
    {
        PORTA |= (1<<PA6);          //Taster LED Bedienen
        warte_ms(50);
        PORTA &= ~(1<<PA6);
        warte_ms(50);
        PORTA |= (1<<PA6);          //Taster LED Bedienen
        warte_ms(50);
        PORTA &= ~(1<<PA6);  
    }
    
    else if (channel == 2)
    {
        PORTA |= (1<<PA7);          //Taster LED Bedienen
        warte_ms(50);
        PORTA &= ~(1<<PA7);
        warte_ms(50);
        PORTA |= (1<<PA7);          //Taster LED Bedienen
        warte_ms(50);
        PORTA &= ~(1<<PA7);  
    }
    
    else
    {
      return;
    }
  }      


ISR(TIM1_COMPB_vect)
{

globvar1 = 55;

  /*if(millisekunden == 1000)
  {
    sekunde = sekunde + 1;
    millisekunden = 0;
    if(sekunde == 60)
    {
    minute++;
    sekunde = 0;
    }
    if(minute == 60)
    {
    stunde++;
    minute = 0;
    }
    if(stunde == 24)
    {
    stunde = 0;
    }
  }*/

}



main ()                  // Hauptprogramm, startet bei Power ON und Reset
{


   DDRA=0b11111000;
   DDRB=0b00000000;
   DDRC &= ~ ((1<<PC0) | (1<<PC1) | (1<<PC2));
   PCMSK1 |= ((1<<PCINT8)|(1<<PCINT9)|(1<<PCINT10)|(1<<PCINT11)); //Pins B0-B3 für Pin change interrupt in Maske 1 setzen
   GIMSK |= (1<<PCIE1);
  //****************TIMER***************
// Timer 0 konfigurieren
TCCR1A = 0b00001011;
//TCCR0B = 0b00000011;
TIMSK =  0b00010000; //OCIE0A = 1 => Timer output compare A enable
OCR1A =  0b00001010;  // auf 10 laden
  sei();

   while (1)
   {
           
    globvar1 ++;           
  }   
}

[Stefan E. (sternst)]

Robert Thormann schrieb:
> OKY, dann der ganze code mit allem Mist den ich sonst ncoh so
> ausprobiert hab ;)

Auch hier ist der erste Teil meines obigen Posts gültig. Die ISR wird 
also nie ausgeführt. Wenn du im Simulator was anderes siehst, dann ist 
der irgendwie durcheinander gekommen (oder im Simulator ist der falsche 
Controller ausgewählt).

[Robert T. (Firma: Thormann) (robertthormann)]

Hmm versteh ich nicht.

die IST

ISR(TIM1_COMPB_vect)
{

globvar1 = 55;

  /*if(millisekunden == 1000)
  {
    sekunde = sekunde + 1;
    millisekunden = 0;
    if(sekunde == 60)
    {
    minute++;
    sekunde = 0;
    }
    if(minute == 60)
    {
    stunde++;
    minute = 0;
    }
    if(stunde == 24)
    {
    stunde = 0;
    }
  }*/

}


wird ausgeführt sobald mein timer 1 den wert 0A erreicht



OCR1A =  0b00001010;  // auf 10 laden

[Stefan E. (sternst)]

Robert Thormann schrieb:
> wird ausgeführt sobald mein timer 1 den wert 0A erreicht

Aber nicht bei dem gezeigten Code, weil dort der passende Interrupt gar 
nicht enabled wird (sondern ein ganz anderer).

PS: Zur Sicherheit solltest du aber vielleicht mal sagen, welchen 
Controller du überhaupt benutzt (kann aber eigentlich nur ATtiny25/45/85 
sein).

[Robert T. (Firma: Thormann) (robertthormann)]

ist ein TINY40

TIMSK =  0b00010000;

und ich denke das hier der interrupt aktiviert wird,

[Robert T. (Firma: Thormann) (robertthormann)]

BZW. wenn ich das ganze in meine Hardware lade und einen Ausgang in der 
ISR setze und in der while(1) lösche flunkert der in der eingestellten 
Zeit (nur mit oszi zu sehen gg)

[Stefan E. (sternst)]

Robert Thormann schrieb:
> ist ein TINY40
>
> TIMSK =  0b00010000;
>
> und ich denke das hier der interrupt aktiviert wird,

Bei einem Tiny40 tatsächlich. Dann stimmt aber der Kommentar dahinter 
nicht.


Gutes Beispiel, warum man den Controller immer gleich von Anfang an mit 
nennen sollte. Denn so war ich auf Raten angewiesen und habe auf 
Tiny25/45/85 getippt, denn nur dort passt der Name der ISR 
(TIM1_COMPB_vect), des Registers (TIMSK) und der Kommentar in der Zeile 
zusammen.

[Robert T. (Firma: Thormann) (robertthormann)]

.. und abgesehen von den ganzen vermeindlichen ISR Problemen funzt ja 
der teil


while (1)
   {
      globvar1++;

  }

schon garnicht weil globvar1 steht immer auf 0 und lässt sich nicht 
hochzählen.

lg Robert

[Robert T. (Firma: Thormann) (robertthormann)]

SRY ic hhab vergessen das am anfang zu erwähnen dass es ein tiny40 ist, 
wie gesagt bin neu in diesem Forum :)

[unregistered (Gast)]

TCCR0B auskommentiert, sollte aber dafür sorgen, daß der Timer nicht 
läuft. Ich kenne das Datenblatt des benutzten Prozessors zwar nicht, 
aber falls das einigermaßen symmetrisch läuft, muss der Timer auch 
gestartet werden.
Das meinte ich mit meiner Suggestivfrage und ich glaub Herr Buchegger 
ebenfalls.

[unregistered (Gast)]

Zum debuggen: Mach doch mal ein neues Projekt und initialisier nur den 
ocr des Timers und lass in der isr eine Led Blinken.
Das muss ohne irgendwelchen Ballast ja erst mal sicher klappen - und das 
ist am einfachsten ja in der Insellösung, da suchen alle auch leichter 
nach dem Problem wenn der Code klein ist.

[Stefan E. (sternst)]

unregistered schrieb:
> TCCR0B auskommentiert, sollte aber dafür sorgen, daß der Timer nicht
> läuft.

Bei einem Tiny40 passt das schon, da gibt es gar kein TCCR0B (und die 
CS-Bits sind in TCCR0A).

[unregistered (Gast)]

Ok kann man nicht von a auf b schließen. Vielleicht doch besser 
informieren ,-)

Den Timer samt isr ans laufen zu bringen, d.h. ein ganz eigenes Projekt 
nur damit, würde ich umso mehr als notwendiges Ziel sehen

[Stefan E. (sternst)]

Ähm, ein TCCR0B gibt es doch.
Aber es ging ja auch eigentlich um Timer 1, und ein TCCR1B gibt es 
nicht. ;-)

[Karl H. (kbuchegg)]

Ähm

while (1)
   {
      globvar1++;

  }

schon mal was von atomaren Zugriff gehört?



while (1)
   {
      cli();
      globvar1++;
      sei();
  }


Und aus den ISR nimmst du die sei() und cli() alle raus. Die will ich 
nicht gesehen haben.

[Robert T. (Firma: Thormann) (robertthormann)]

Guten Morgen!

Das mit dem atomaren zugriff stimmt schon, jedoch ändert das nichts an 
meinem Problem! es ligt ja eigentlcih nicht an der ISR wie ich 
herausgefunden habe, ich kann eine "global" definierte Variabel nicht 
beschreiben, ev. mache ich was bei der Deklaration falsch?

#define    F_CPU 3686400   // Taktfrequenz des myAVR-Boards
#include   <avr/io.h>    // AVR Register und Konstantendefinitionen
#include   <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdint.h>


volatile int8_t globvar1;

LG Robert

[unregistered (Gast)]

Es gibt doch auch zumindest die Möglichkeit, daß der Simulator da einen 
Bug hat?
Haste schon mal ein entkerntes Programm versucht?

[Karl H. (kbuchegg)]

Robert Thormann schrieb:
> Guten Morgen!
>
> Das mit dem atomaren zugriff stimmt schon, jedoch ändert das nichts an
> meinem Problem!

Doch tut es.
Denn der µC kann
   globavr1++
nicht in EINEM Schritt ausführen.

Was muss er machen

   globvar lesen

   globvar um 1 erhöhen

   globvar zurückschreiben


JEDER Interrupt, der irgendwo dazwischen ausgeführt wird, beschreibt 
zwar deine Variable, aber: in der Hauptschleife wird der Effekt sofort 
wieder zunichte gemacht, da in der Hauptschleife der Wert 
zurückgeschrieben wird, der vorher gelesen wurde (und um 1 erhöht). Und 
da in deiner Hauptschleife sonst nichts weiter passiert, ist die 
Wahrscheinlichkeit sehr gross, dass dein Interrupt genau immer wieder 
dann erfolgt wenn die Hauptschleife die globvar schon ausgelesen hat.

[Robert Thormann (Gast)]

Ich habe um zu beweisen das es nicht am atomaren zugriff liegt das I 
flag abgeschalter und in der main nur die Variable auf einen wert 
gesetzt! ist aba noch immer 0

[Karl H. (kbuchegg)]

Jetzt muss ich auch nachfragen.

Wie testest du?
Simulator? reale Hardware?

Was zählt ist immer nur die reale Hardware.
Und wenn es da ein Problem mit globalen Variablen gäbe, dann hätten ca. 
130 tausend 5 hundert 8 und 9 zig Programmierer, die deinen Compiler 
benutzen, bereits laut aufgeheult.

[Stefan E. (sternst)]

Karl Heinz Buchegger schrieb:
> Was zählt ist immer nur die reale Hardware.
> Und wenn es da ein Problem mit globalen Variablen gäbe, dann hätten ca.
> 130 tausend 5 hundert 8 und 9 zig Programmierer, die deinen Compiler
> benutzen, bereits laut aufgeheult.

Nun ja, der Tiny40 ist einer der Brain-Dead-Tiny, da sind solche 
grundlegenden Probleme nicht ganz so unwahrscheinlich. Wenn ich den Code 
z.B. dem Studio5.0 zum Fraß vorwerfe, dann entsteht folgendes für das 
Inkrementieren von globavr1:

 1d6:  80 91 40 00   lds   r24, 0x0040
 1da:  8f 5f         subi  r24, 0xFF  ; 255
 1dc:  80 93 40 00   sts   0x0040, r24

Und das ist definitiv falsch, denn bei den Brain-Dead sind lds und sts 
nur ein Word groß. Keine Ahnung wie es bei 5.1 oder 6.0 aussieht.

[Robert Thormann (Gast)]

Hier sollte die Ursache des problems und eine möglich Lösung stehen : 
http://www.wutj.info/attiny10-binutils-patch
Danke an Sternst für den Tipp!

@ Buchegger! Das Aufheulen der 130598 Programmierer war warscheinlich. 
icht laut genug! Aber ab jetzt sind es ja 130599 ;)

Ich werde den lösungsvorschlag testen und das Ergebnis natürlich posten.

lg

[Karl H. (kbuchegg)]

Robert Thormann schrieb:

> @ Buchegger! Das Aufheulen der 130598 Programmierer war warscheinlich.
> icht laut genug! Aber ab jetzt sind es ja 130599 ;)

Tatsächlich.
Hätt ich nicht gedacht.
(und ich hab mich schon gefragt, was wohl mit "brain dead" gemeint sein 
könnte)