USART Interrupt Variablenwert zuweisen

[Pat K. (c63)]

Hallo zusammen,

habe ein Problem mit folgendem Quellcode:

#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

extern void uart_init(void);



static inline int
uart_putc (const uint8_t c)
{
  // Warten, bis UDR bereit ist für einen neuen Wert
  while (!(UCSRA & (1 << UDRE)))
  ;

  // UDR Schreiben startet die Übertragung
  UDR = c;

  return 1;
}

static inline uint8_t
uart_getc_wait(void)
{
  // Warten, bis etwas empfangen wird
  while (!(UCSRA & (1 << RXC)))
  ;

  // Das empfangene Zeichen zurückliefern
  return UDR;
}

static inline int
uart_getc_nowait(void)
{
  // Liefer das empfangene Zeichen, falls etwas empfangen wurde; -1 sonst
  return (UCSRA & (1 << RXC)) ? (int) UDR : -1;
}

#endif /* _UART_H_  */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include <stdio.h>





#define BAUDRATE 2400UL 



int Auslesen;
volatile unsigned char a = 0x00;


void uart_init()
{
  uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);
  
  UBRRH = (uint8_t) (ubrr>>8);
  UBRRL = (uint8_t) (ubrr);
  
  // UART Receiver und Transmitter anschalten
  // Data mode 8N1, asynchron
  UCSRA = (1 << RXC);
  UCSRB = (1 << RXEN) | (1<<RXCIE);
  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

  // Receive-Buffer leeren (entfernen evtl. vorhandener ungültiger Werte)
  do
  {
    UDR;
  }
  while (UCSRA & (1 << RXC));

  DDRD |= (1<<PD6);    // PortD als Ausgang deklarieren
  //DDRD |= (1<<PD5);
  //PORTD = 0x00;   // Ports auf LOW schalten

}


// Interupt wartet, bis Empfangsbit gesetzt wird und führt dann Routine aus

ISR(USART_RXC_vect) 
{
  a = UDR;
  
  if (a == '1') 
  {
    //PORTD |= (1<<PD6);
    Auslesen = 15;
  }
  else
  {
    if (a == '0')
    {
      PORTD &=~(1<<PD6);
    }
    
  }

}

ISR (TIMER1_COMPA_vect)
{
  static uint16_t swTeiler = 0;
  swTeiler++;
  //if (swTeiler == 120 )
  if (swTeiler == Auslesen )
  {
    swTeiler = 0;
    PORTD |= (1<<PD6);
    TCCR1B |= (1<<WGM12) | (1<<CS12);
    TIMSK |= (1<<OCIE1B);
    OCR1B = 3094;
    sei();
  }
}

ISR (TIMER1_COMPB_vect)
{
  static uint8_t vTeiler = 0;
  vTeiler++;
  if (vTeiler == 10)
  {
    vTeiler = 0;
    PORTD &=~ (1<<PD6);
  }
}





ISR (INT0_vect)
{
  PORTD |= (1<<PD6);
}

ISR (INT1_vect)
{
  PORTD &=~ (1<<PD6);
}





int main(void)
{
  
  DDRD &=~ (1<<PD2) | (1<<PD3);
  MCUCR |= (1<<ISC01) | (1<<ISC00) | (1<<ISC11) | (1<<ISC10);
  GICR |= (1<<INT0) | (1<<INT1);

TCCR1B |= (1<<WGM12)|(1<<CS12);
TIMSK |= (1<<OCIE1A);

OCR1A = 3906;


  uart_init();
  sei();
  
  int i = 0;
  
  while (i<2)
  {
    i++;
    PORTD |= (1<<PD6);
    _delay_ms(3000);
    PORTD &=~(1<<PD6);
    _delay_ms(3000);
  }
  
  while(1)
  {
    
  }
}

Ursprünglich wollte ich über die Serielle Schnittstelle einen ASCII 
string empfangen, mit #include <sstream> in eine Zahl umwandeln und 
diese Zahl an meine Variable "Auslesen" weitergeben, welche für den 
Interrupt des Timers zuständig ist.
Naja, weit entfernt von einem Resultat.
Konnte jetzt für mich persönlich den Fehler soweit begrenzen, dass der 
Variable "Auslesen" der Wert "15" wohl nicht übergeben wird, bzw die 
Variable von der einen Interrupt-Routine in die andere nicht übertragen 
wird?
Wo genau liegt mein Verständnisproblem?

Für eure Hilfe bedanke ich mich schon mal im Voraus.
mfg
c63

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Problem Ungelöst schrieb:
> int Auslesen;

Mach die mal 'volatile'. Generell sollte Variablen in ISR immer volatile 
sein, weil der Kompiler sie sonst wegrationalisieren möchte. ISR werden 
ja im Programm nicht aufgerufen und der Kompiler probiert eine 
Optimierung. Apropos Optimierung, wie steht die bei dir?

[Peter II (Gast)]

Matthias Sch. schrieb:
> Mach die mal 'volatile'. Generell sollte Variablen in ISR immer volatile
> sein, weil der Kompiler sie sonst wegrationalisieren möchte. ISR werden
> ja im Programm nicht aufgerufen und der Kompiler probiert eine
> Optimierung. Apropos Optimierung, wie steht die bei dir?

nein ist hier nicht notwendig, weil er sie nur ein 2 ISR verwendet. Sie 
wird nicht in Main verwendet!

Und die Aussage "Generell sollte Variablen in ISR immer volatile sein" 
ist Unsinn.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Peter II schrieb:
> weil er sie nur ein 2 ISR verwendet

Öhh, was willst du uns sagen? Die Variable steht auch nicht in der 
ISR, sondern ist global deklariert.

[Pat K. (c63)]

Danke euch beiden für die Hilfe,

lag am fehlenden volatile :-)

@Matthias Sch.: Bin totaler newbie, was c programmieren betrifft, 
deshalb bin ich mir nicht ganz sicher was du mit "Apropos Optimierung, 
wie steht die bei dir?" meinst.
Hab mir mal im AVR Studio den Compiler Output durchgelesen, allerdings 
nicht wirklich etwas in Richtung Optimierung seitens Compiler gefunden.

[Peter II (Gast)]

Matthias Sch. schrieb:
> Öhh, was willst du uns sagen? Die Variable steht auch nicht in der
> ISR, sondern ist global deklariert.

sie wird in zwei verschieden ISR verwendet, darum muss sich auch global 
sein.

das volatile bringt hier überhaupt nichts, das ist nur notwendig wenn 
eine Variable in einer ISR geändert wird und in der main( oder daraus 
aufgerufenen Funktionen) abgefragt wird.

[Pat K. (c63)]

Ok lag doch nicht am volatile, sonder daran, dass der Timer zum 
Zeitpunkt des Sendens via Schnittstelle schon über dem zugewiesenen 
Variablenwert lag und somit der Interrupt erst nach weiteren 65536 
Sekunden ausgelöst wird.

[ISR (Gast)]

Peter II schrieb:
> das volatile bringt hier überhaupt nichts, das ist nur notwendig wenn
> eine Variable in einer ISR geändert wird und in der main( oder daraus
> aufgerufenen Funktionen) abgefragt wird.

auch wenn die Variable in der einen ISR geändert wurde und dann in der 
anderen verwendet wird (oder auch dort wieder geändert), ist volatile 
genauso sinnvoll. Es muß nicht die main mit beteiligt sein. Einfach nur 
zwei Programmstellen, die keine direkte sichtbare verbindung miteinander 
haben, so daß der compiler sie nicht erkennen kann.

[Peter II (Gast)]

ISR schrieb:
> auch wenn die Variable in der einen ISR geändert wurde und dann in der
> anderen verwendet wird (oder auch dort wieder geändert), ist volatile
> genauso sinnvoll. Es muß nicht die main mit beteiligt sein. Einfach nur
> zwei Programmstellen, die keine direkte sichtbare verbindung miteinander
> haben, so daß der compiler sie nicht erkennen kann.

nein. Du hast scheinbar das Problem nicht wirklich verstanden.

Am ende einer ISR muss der Compiler die Variable immer in den Ram 
zurückschreiben und kann sie nicht im Register behalten. Damit kann 
überhaupt kein Problem mit wegen Optimierung entstehen. Nur wenn Main 
beteiligt ist, kann er sie im Register blassen, weil main nicht 
verlassen wird.

[Stefan E. (sternst)]

Peter II schrieb:
> das volatile bringt hier überhaupt nichts, das ist nur notwendig wenn
> eine Variable in einer ISR geändert wird und in der main( oder daraus
> aufgerufenen Funktionen) abgefragt wird.

Ist aber auch nicht ganz korrekt. Der "umgekehrte" Fall (in Main 
geändert und in ISR nur gelesen) erfordert ebenso das volatile.