UART Interrupts, Rückgabe der Variable

[Samuel (Gast)]

Hallo,

ich habe ein Problem neuerdings mit meinem UART.

Ich nutze zum Einlesen einen Interrupt. Die Werte kommen auch alle an, 
jedoch bekomme ich nicht die Rückmeldung das der String komplett 
eingelesen ist.


h-Datei

#ifndef UART0_H_
#define UART0_H_

#define UART0_BAUD        9600
#define UART0_BUFFER_MAX_LEN  4   // wichtig fuer diesen Fehler

#include <avr/io.h>
#include <avr/interrupt.h>

static volatile char uart0_buffer[UART0_BUFFER_MAX_LEN + 1] = "";
static volatile uint8_t uart0_buffer_complete = 0;   // Uebeltaeter

int8_t uart0_init(void);
int8_t uart0_putc(uint8_t c);
int8_t uart0_puts(char *s);
#endif /* UART0_H_ */

c-Datei

#include "uart0.h"

static volatile uint8_t uart0_buffer_count;

int8_t uart0_init(void)
{
  //cli();
  // Baudrate berechnen
  UBRR0 = 51;//UBRR_VAL;
  // Senden und Empfänger(+Interrupt) aktivieren
  UCSR0B = (1 << TXEN0) | (1 << RXCIE0) | (1 << RXEN0) ;
  
  // 8 Bit, Asynchron, 1 Stop-Bit
  UCSR0C = (1 <<UCSZ01) | (1 << UCSZ00);
  
  return 0;
}


ISR(USART0_RX_vect)
{
  unsigned char nextChar;
  
  // Daten aus Puffer lesen
  nextChar = UDR0;
  
  if( uart0_buffer_complete == 0 )
  {
    if(nextChar != '\n' &&  nextChar != '\r' &&  uart0_buffer_count < UART0_BUFFER_MAX_LEN)
    {
      uart0_buffer[uart0_buffer_count] = nextChar;
      uart0_buffer_count++;
      uart0_puts(uart0_buffer); uart0_puts("\r\n");  // DEBUG
    }
    else
    {

      uart0_buffer[uart0_buffer_count] = '\0';
      uart0_buffer_count = 0;
      uart0_buffer_complete = 1;
      uart0_puts("complete\r\n");            // DEBUG
    }
  }
}

// ...

main, stark gekürzt

#include "uart0.h"

int main(void)
{
/.... init
  while(1)
  {
    if(uart0_buffer_complete)
    {
      uart0_puts("done\r\n");
      uart0_buffer_complete = 0;
    }
  }
}

[Ingo (Gast)]

Und wie äußert sich der Fehler genau? Auf Anhieb sehe ich keine Fehler! 
Kommt der String "Complete" und "Done" bleibt aus?

[Samuel (Gast)]

"Complete" kommt auf der Konsole an. Jedoch bleibt "Done" aus. Somit 
wird uart0_buffer_complete nicht auf wahr in der main abgefragt

[Samuel (Gast)]

Problem ist, dass sobald ich bei
static volatile uint8_t uart0_buffer_count;
das static wegnehme, mecker er in der main.c, dass ich die Variablem 
mehrmals defeniert hab. Das stimmt so aber nicht. Dort werden die 
lediglich abgefragt.

Wenn ich versuche die Stelle zu finden über die Fehlerausgabe in AS6.2, 
dann leitet er mich in die uart.c Datei nach dem include der uart.h 
Datei.

Aber eigentlich sollte static und/oder extern aber richtig sein.

[Rufus Τ. F. (rufus)]

Du solltest davon Abstand nehmen, in Deinem Uart-Empfangsinterrupt die 
Funktion uart0_puts aufzurufen. Lass all diese Ausgaben mal weg, bzw. 
verlagere sie in die main().

[Samuel (Gast)]

Hallo Rufus. Mir ist bewusst, dass eine ISR so kurz wie möglich sein 
muss.
Das hab ich dort auch NUR reingeschrieben, da ich keinerlei Feedback 
bekommen habe, ob überhaupt Zeichen ankommen. Eine Led anschließen kann 
ich derzeit leider nicht.


Das Problem hängt scheinbar mit dem Geltungsbereich von Variablen 
zusammen.

initialized and declared 'extern' enabled by default

http://openbook.galileo-press.de/c_von_a_bis_z/009_c_funktionen_011.htm#mj19e69aaaa55d4a98fe6073fe2a99a2c6

Demnach sollten aber keine, extern oder static gehen.

[Ahab (Gast)]

mit "static" im Header-File kriegt jedes C-File, dass diesen Header 
#included, eine eigene, von allen anderen unabhängige Kopie der Variable 
verpasst.

Du willst was anderes: Nur eine Variable, alle C-Files greifen auf 
dieselbe zu.

Also: Im headerfile nur "extern", und in einem einzgen C-File die 
Variable instanziieren.

in keinem der beiden Files sollte die Variable dabei "static" sein.

[Samuel (Gast)]

Hallo,
so gehts noch nicht. Was meinst du genau mit instanzieren in diesen 
Fall?

main.h

#include "uart.h"

main.c

#include "main.h"

uart.h

extern volatile i;

uart.c

#include "uart.h"

[Walter (Gast)]

in irgendeinem C File musst Du i auch definieren
(du hast übrigens int char oder sonst was bei i vergessen)

[Samuel (Gast)]

Datentyp bei dem Wert vergessen. Denke aber es war zu sehen wie gemeint 
;)

Wenn ich i in uart.c defeniere mekert meine main.c immer noch, dass es 
bereits deklariert ist.

Error  3  'uart_str_complete' undeclared (first use in this function) 
C:\...\main.c

[Samuel (Gast)]

So, jetzt noch einmal zum vergleich, ob es so richtig gemacht wird. Es 
funktioniert auf jedenfalls schon einmal. Danke


uart.c

#include "uart.h"

// Diese Variable soll nur in uart.c vorhanden sein
volatile uint8_t uart_str_count = 0;
// Diese Variablen beziehen sich auf die extern deklarierten in uart.h
volatile uint8_t uart_str_complete;
volatile char uart_string[];

//...

uart.h

#ifndef UART_H_
#define UART_H_
//..

// Diese beiden Varialben sollen auch ausserhalb verfuegbar sein
extern volatile uint8_t uart_str_complete = 0;
extern volatile char uart_string[UART_MAXSTRLEN + 1] = "";

//..
#endif /* UART_H_ */

main.h

#ifndef MAIN_H_
#define MAIN_H_
//..

#include "uart.h"

//..
#endif /* MAIN_H_ */

main.c

#include "main.h"

// Diese Variable bezieht sich auf die extern deklarierten in uart.h
volatile uint8_t uart_str_complete; // 1)

1) In der main.c oder ggf. in der main.h besser aufgehoben??

Gruß

[Rufus Τ. F. (rufus)]

Samuel schrieb:

> uart.h

> extern volatile uint8_t uart_str_complete = 0;
> extern volatile char uart_string[UART_MAXSTRLEN + 1] = "";

Initialisierungen gehören nicht in die Headerdatei.

> uart.c

> volatile uint8_t uart_str_complete;
> volatile char uart_string[];

Da gehört die Initialisierung und vor allem die Größenangabe des Arrays 
hin.

> main.c

> // Diese Variable bezieht sich auf die extern deklarierten in uart.h
> volatile uint8_t uart_str_complete; // 1)

Das hat da gar nichts verloren, stattdessen gehört da ein

#include "uart.h"

hin.

[Ingo (Gast)]

Variablen werden nicht in header-files definiert sondern nur in 
Source-Files und das auch nur einmal. Der Rest wird über "extern" 
erledigt. Und es gibt kein extern static!



Ingo

[Ingo (Gast)]

Mich wundert das der Compiler da mitspielt. Mach mal Werror an. Dann 
geht sowas schonmal alles garnicht mehr.

[Samuel (Gast)]

Also hab es dann nun geändert.

In der uart.h
die Initialisierung herausgenommen.

Nur in der uart.c die Werte initialisiert.



Für alle anderen h-Files nur noch das einfügen
volatile uint8_t uart_str_complete;
volatile char uart_string[UART_MAXSTRLEN+1];


soweit dann richtig?

[Differentialknilch (Gast)]

Debuggen geht sicher nicht mit einem Strin aus einem Interrupt zu 
schreiben. Die Methode der Wahl ist einem Pin zu wackeln und mit dem 
Scope zu kontrollieren.

[Samuel (Gast)]

Doch, das "debuggen" mit dem String ging in der ISR wunderbar. Natürlich 
ist mir klar, dass dieser dort nichts zu suchen hatte. Aber mir blieb da 
keine andere Möglichkeit. Ist inzwischen raus da es funktioniert.