mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik UART, Testprogramm aus Buch läuft nicht


Autor: tester (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin,

ich wollte nachfolgendes Testprogramm aus einem Buch mal testen. Dabei 
spuckt der Compiler einige Fehlermeldungen aus:

Programm:
/**************************************************************
*                                                              *
*                         UART.c                                *
*                                                              *
***************************************************************/

/* Include-Dateien   
   -----------------*/
#include <io8515.h>    // Register Definition fuer AT90S8515
#include <ina90.h>     // Intrinsic Funktionen fuer ICCA90 

 
/* UCR - UART Control Register: Bit Definitionen 
   -----------------------------------------------------------*/
#define     RXCIE    0x80    // Bit 7 
#define     TXCIE    0x40    // Bit 6 
#define     UDRIE    0x20    // Bit 5 
#define     RXEN     0x10    // Bit 4 
#define     TXEN     0x08    // Bit 3 
#define     CHR9     0x04    // Bit 2 
#define     RXB8     0x02    // Bit 1 
#define     TXB8     0x01    // Bit 0 

/* USR - UART Status Register: Bit Definitionen 
    ---------------------------------------------------------*/
#define     RXC     0x80    // Bit 7 
#define     TXC     0x40    // Bit 6 
#define     UDRE    0x20    // Bit 5 
#define     FE      0x10    // Bit 4 
#define     OVR     0x08    // Bit 3 

/* UBRR - UART Baudrate Register: Baud Definitionen fuer 4MHz
    ---------------------------------------------------------*/
#define     BAUD_1200     208
#define     BAUD_2400     103
#define     BAUD_9600     25
#define     BAUD_19200    12

/* UART Daten-Puffer Definitionen 
    ------------------------------*/
#define BUFFER_SIZE     8     // Modulo 2 Groesse: nur 2,4,8,16,32 Bytes 
#define BUFFER_MASK     (BUFFER_SIZE-1)

/* Allgemeine typ-Definitionen 
    -----------------------------------------------------------*/
typedef enum{ FALSE=0, TRUE=1} Boolean_t ;
 
typedef struct{ unsigned char UartData[ BUFFER_SIZE ];
                unsigned char NumberOfBytes;
                unsigned char UartStatus; } Uart_t; 

/* Static Variables 
   -------------------*/
static unsigned char                RxBuf[ BUFFER_SIZE ];
static volatile unsigned char       RxProducer;  // Empfang: Int-Service ist der Producer
static volatile unsigned char       RxConsumer;  // Empfang: Hauptprogramm ist Consumer
static unsigned char                TxBuf[ BUFFER_SIZE ];
static volatile unsigned char       TxProducer;  // Senden: Hauptprogramm ist der Producer
static volatile unsigned char       TxConsumer;  // Senden: Int-Service ist Consumer

/* Funktion-Prototypen
   ----------------------------*/
void InitUart( unsigned char baudrate );
Boolean_t ReceiveData( Uart_t * Data );
Boolean_t TransmitData( Uart_t * Data );
void Delay( void ); 
 
/* Input Pins, Port B:               sfrb PINB    = 0x16; 
   Data Direction Register, Port B:  sfrb DDRB    = 0x17; 
   Data Register, Port B:            sfrb PORTB   = 0x18; */
void Delay( void )
{
  unsigned int i= 0x7FFF;
  while(--i);
}


/* Main - ein einfaches Anwendungsbeispiel fuer UART und Timer 
   -------------------------------------------------------------*/
void C_task main( void )
{
    Uart_t UartData;
    
    DDRB  = 0xFF ; // Konfiguriert Port B als Ausgang
    PORTB = 0xAA;
      
    InitUart( BAUD_9600 );     // Baudrate = 9600 Baud bei 4MHz Quarz
    _SEI();                      // Freigabe aller Interrupts => Enable UART Interrupts 
    
    for( ;; )                  // Endlos-Schleife 
    {
        if( ReceiveData( & UartData ) )
        {  
          TransmitData( & UartData );     // Echo der empfangenen Bytes
         }

        PORTB++; // led switch
        Delay();
    }
}

/* Initialisierung der UART 
    ------------------------------*/
void InitUart( unsigned char baudrate )
{
    UBRR = baudrate;               // Baudrate setzen 

                                  // Freigabe der UART Interrupts
    UCR =  TXEN | RXEN | RXCIE;   // ==> Senden/Empfangen/Empf.INT

    RxConsumer     = 0;            // Ruecksetzen der Puffer-Index 
    RxProducer     = 0;
    TxConsumer     = 0;
    TxProducer     = 0;
}

/*  Empfangs-Interrupt Handler
    --------------------------- */
interrupt [UART_RX_vect] void UartRxIntHandler( void )
{
    unsigned char data;
    
    data = UDR;                 // Lesen der Empfangsdaten 
    RxBuf[RxProducer] = data;   // Empfangenes Byte in Puffer ablegen  
    RxProducer++;               // Bufferindex setzen
    RxProducer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang
     
    if (RxProducer == RxConsumer )
    {
        // Fehler! Ueberlauf Empfangspuffer 
    }
}

/*  Sende-Interrupt Handler
    --------------------------- */
interrupt [UART_UDRE_vect] void UART_TX_interrupt( void )
{
    // Test ob noch nicht fertig mit Senden  
    if ( TxConsumer != TxProducer )
    {
        ++TxConsumer;               // Pufferindex aktualisieren 
        TxConsumer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang
        UDR = TxBuf[TxConsumer];    // Uebergabe eines Bytes 
      }
    else
    {
        UCR &= ~UDRIE; // Disable UDRE interrupt
    }
} 

 
/* UART Empfangsfunktion 
   --------------------- */
Boolean_t ReceiveData( Uart_t * Data )
{
    unsigned char i=0;

    // Schleife zur Uebergabe der empfangenen Daten
    while (( RxConsumer != RxProducer ) && ( i < BUFFER_SIZE ) ) 
    {
       Data->UartData[i++] = RxBuf[RxConsumer++];
       
       RxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen und evtl. auf Puffer-Anfang                          
    }

    Data->NumberOfBytes = i ;

    if( i ) return TRUE ;
     else return FALSE ;
}

/* Sendefunktion 
   --------------------- */
Boolean_t TransmitData( Uart_t * Data )
{
    unsigned char i=0;

    while (( i < Data->NumberOfBytes ) && ( i < BUFFER_SIZE ) )// Uebergabe Empfangsdaten 
    {
       TxBuf[TxProducer++] = Data->UartData[i++] ;

       TxProducer &=BUFFER_MASK;   // Producer-Index begrenzen und evtl. auf Puffer-Anfang                          
    }

    UDR = TxBuf[TxConsumer];        // Senden Anstossen
    ++TxConsumer; 
    TxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen
    
    UCR |=  UDRIE ;
    Data->NumberOfBytes = 0;
    return TRUE ;
}



Fehlermeldungen:
(ohne Warnings)

C:\Meine Programme\WinAVR-20071221\avr\include\avr/io8515.h:41:4: error: 
#error "Include <avr/io.h> instead of this file."
In file included from c:/meine 
programme/winavr-20071221/bin/../avr/include/avr/io.h:233,
                 from c:/meine 
programme/winavr-20071221/bin/../avr/include/avr/pgmspace.h:81,
                 from C:\Meine 
Programme\WinAVR-20071221\avr\include\compat/ina90.h:64,
                 from ../UART_Ringpuffer_Interruptgesteuert.c:10:


c:/meine 
programme/winavr-20071221/bin/../avr/include/avr/iom8515.h:47:4: error: 
#error "Attempt to include more than one <avr/ioXXX.h> file."


../UART_Ringpuffer_Interruptgesteuert.c:80: error: expected '=', ',', 
';', 'asm' or '__attribute__' before 'main'

../UART_Ringpuffer_Interruptgesteuert.c:119: error: '__vector_9' 
undeclared here (not in a function)

../UART_Ringpuffer_Interruptgesteuert.c:119: error: expected '=', ',', 
';', 'asm' or '__attribute__' before 'void'

../UART_Ringpuffer_Interruptgesteuert.c:136: error: '__vector_10' 
undeclared here (not in a function)

../UART_Ringpuffer_Interruptgesteuert.c:136: error: expected '=', ',', 
';', 'asm' or '__attribute__' before 'void'


Eigentlich wollte ich es mit einem ATm8515 testen, aber nachdem das 
Compilieren so schon nicht funktioniert.....

Ich verwende die neueste WinAVR Version mit neuestem AVR-Studio

Danke

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ tester (Gast)

>ich wollte nachfolgendes Testprogramm aus einem Buch mal testen. Dabei
>spuckt der Compiler einige Fehlermeldungen aus:

Aus welchem Buch? Ist das für den AVR und den WinAVR geschrieben?
Nein, den ICCA90.

>#include <io8515.h>    // Register Definition fuer AT90S8515

Heisst beim WinAVR

#include <avr/io.h>    // Register Definition fuer AT90S8515


>#include <ina90.h>     // Intrinsic Funktionen fuer ICCA90

Gibts beim WinAVR nicht.


>void C_task main( void )

Ist auch nicht standardkonform.


>interrupt [UART_RX_vect] void UartRxIntHandler( void )

Interrupts werden beim WInAVR anders geschrieben.

>Ich verwende die neueste WinAVR Version mit neuestem AVR-Studio

Welche sind das? Zahlen? Ist aber egal, der Qulltext ist für einen 
anderen Compiler. Beispiele für den WinAVR gibts hier

AVR-GCC-Tutorial
Interrupt

MfG
Falk

Autor: tester (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das Buch heißt: "C für Mikrocontroller" von Burkhard Mann

Wer lesen kann ist klar im Vorteil, hat zwar mit AVR's zutun aber eben 
nicht mit WinAVR. Hab einfach nur durchgeblättert und wollt gleich 
loslegen ;-)

Was kannst du für ein Buch empfehlen? Speziell für WinAVR + AVR-Studio.
So gut wie keine Grundkenntnisse vorhanden.


thx

Autor: STK500-Besitzer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ STK500-Besitzer (Gast)

>http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
>http://www.mikrocontroller.net/articles/AVR

>Buch muß nicht unbedingt sein...

DOCH! Für die Grundlagen von C. Die werden hier nämlich nicht erklärt.

@ tester (Gast)

>Was kannst du für ein Buch empfehlen? Speziell für WinAVR + AVR-Studio.

Gibts keins, aber das Tutorial hier ist sehr gut und zu 99% ausreichend. 
Das restlich 1% klärt das Forum.

>So gut wie keine Grundkenntnisse vorhanden.

Dann besorg dir auf JEDEN Fall ein Grundlagenbuch zu C. "Programmieren 
lernen mit C", oder der klassische Kernigham & Ritchie.


MfG
Falk

Autor: STK500-Besitzer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>DOCH! Für die Grundlagen von C. Die werden hier nämlich nicht erklärt.

"Es muß kein spezielles AVR-Buch sein." (war der Sinn hinter der 
Aussage)

Autor: tester (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, danke erstmal

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.