String einlesen und bearbeiten

[Matthias Drexler (Gast)]

Hallo

Ich habe ein ATmega32 Prototype Board mit einem Siemens ME45 Handy 
verbunden.
Mit dem Board frage ich das Handy mit dem Befehl AT+CCLK? um die Uhrzeit 
und den Datum, um es dann später in einen DS1307 RTC-Baustein schreiben 
zu können.
Der string der da zum Board zurück gesendet wird der lautet:

+CCLK: "11/05/28,19:09:29"

OK

Und hier meine Frage.
Wie kann ich diese Daten einlesen, aufsplitten und in Variable 
reinschrieben so das ich es in denn RTC schreiben kann?
Und gibt es da einen Befehl wo man z.B. den Teil innerhalb der Klammer 
nehmen kann?

Danke im Voraus

mfg
Matthias Drexler

[gagast (Gast)]

>Wie kann ich diese Daten einlesen,
Datenblatt: UART

> aufsplitten und in Variable reinschrieben so das ich es in denn RTC
> schreiben kann?
In C? Frag mal Google nach C-Standard-Library, alles was mit str(n) 
anfängt ist potentiell hilfreich. Header ist string(s?).h

[Matthias Drexler (Gast)]

ich habe in meiner string.h datei keinen strtok befehl.
nur einen strtok_r befehl.
wie bekomme ich denn strtok da rein das es auch funktioniert, denn 
einfach reinschreiben klappt nicht.

[Karl H. (kbuchegg)]

Matthias Drexler schrieb:
> ich habe in meiner string.h datei keinen strtok befehl.
> nur einen strtok_r befehl.
> wie bekomme ich denn strtok da rein das es auch funktioniert, denn
> einfach reinschreiben klappt nicht.

Dann nimm eben strtok_r. Die Funktion ist sowieso besser als strtok.

[Matthias Drexler (Gast)]

was ist denn da der unterschied?
hier sind nämlich 3 char typen in der klammer.
der erste ist der string der zweite die trennzeichen und was ist der 
dritte char?

[tom (Gast)]

1. RTFM:

PARAMETERS

s1     Points to the string from which to extract tokens.
s2     Points to a null-terminated set of delimiter characters.
s3     Is a value-return parameter used by strtok_r() to record its 
progress through s1.


2. Da eine C-function nur einen return-wert hat (in diesem fall ein 
zeiger auf den extrahierten token oder einen NULL-pointer) behilft man 
sich, indem weitere return-values per Referenz (adresse) mit übergeben 
werden. Das genau wird mit dem s3 Parameter gemacht. Du solltest da also 
auf jeden Fall gültigen Speicherplatz (Variable, Zeiger - welcher Typ 
auch immer gefordert ist) übergeben, egal ob Du den Wert benutzen 
möchtest - sonst "übergibt" sich wahrscheinlich strtok_r().


gruss, Tom.

[tom (Gast)]

gurgeln + lesen :o) :

http://www.linuxhowtos.org/manpages/3p/strtok_r.htm

[M. K. (sylaina)]

Einen solchen String:

Matthias Drexler schrieb:
> "11/05/28,19:09:29"

von Hand zu zerlegen ist eigentlich etwas, das ganz dicht hinter den 
Grundlagen in C kommt. Die Funktionen in string.h sind eigentlich nur 
dazu da damit man das Rad nicht immer neu erfinden muss. Was würdest du 
denn machen, wenn du nur den Tag haben wolltest? ;)

[cskulkw (Gast)]

Hallo Mathias,

also für diesen String brauchst Du ein Array von 30 Zeichen.

Nimm 40 Zeichen. Dann hast Du Reserve.

Ich gehe davon aus, dass Du weißt, wie Du eine ISR benutzen mußt, um die 
empfangenen Daten aus der UART in ein charakter-Array zu kopieren. (Ich 
verstehe sonst das "einlesen" nicht...)

Vorschlag:

char string[40] = +CCLK: "11/05/28,19:09:29"
char help[5];

int_16 jahr,monat,tag,stunde,minute,sekunde;

Du kannst jetzt die strncmp-Funktion nehmen, um den Teilstring "+CCLK: " 
zu identifizieren.

z.B. so:

if(!strncmp(string,"+CCLK: ",7))
{
uint_8 i=9;

   // Zeitstring gelesen.
   help[0] = string[i++];
   help[1] = string[i++];
   help[2] = 0;
   // jetzt ist das Jahr im help zu fuss kopiert.
   jahr = atoi(help);

   i++; // Komma überspringen
   help[0] = string[i++];
   help[1] = string[i++];
   help[2] = 0;
   // jetzt ist der Monat im help zu fuss kopiert.
   monat = atoi(help);

   und so weiter...

}

Ich habe die Erfahrung gemacht, dass die Standard-Stringfunktionen 
doppelten RAM verbrauchen. Der Vergleichsstring wird irgendwie 2 mal im 
RAM abgelegt. Jedenfalls ist bei mir der RAM weggeschmolzen.

Ich bin dazu übergegeben, die Vergleichsstrings in der Flash abzulegen 
und mit den Funktion strcpy_P(...). Dann hatte ich wieder etwas mehr RAM 
zum Ahsen.

Außerdem habe ich die Erfahrung gemacht, dass diese Antwortstrings von 
den GSM-Geräten immer irgendwie gemischt sind. Deshalb würde diese 
strtok-Funktion ebenfalls mehrmals eingesetzt werden müssen. 
Übersichtlicher wird das Programm dadurch nicht.

Das zu Fuß kopieren ist primitiv aber effektiv und verständlich.

Nur wenn Dir irgendwann SMS senden und im Empfangen mit PDU-Format 
vorschwebt, wirst Du damit nicht mehr allzu weit kommen.

Ich hoffe, das hier was für Dich dabei ist.

Viel Erfolg

[M. K. (sylaina)]

cskulkw schrieb:
> Der Vergleichsstring wird irgendwie 2 mal im
> RAM abgelegt

Wenn sich der Vergleichsstring während der Laufzeit nicht ändert kann 
man ihn auch direkt aus dem Flash lesen und muss ihn nicht erst ins RAM 
umkopieren:

#include <avr/pgmspace.h>
.
.
.
char[] string_im_RAM = "Ich werde zur Laufzeit im RAM zu finden sein!";
char[] string_im_Flash PROGMEM= "Ich werde den Flashspeicher nicht verlassen!";
.
.
.

Sowas spart RAM ;)

Siehe hierzu auch:

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=38003

[Matthias Drexler (Gast)]

danke für die vielen und schnellen Antworten.

ich werde mir die vorschläge anschauen und sie ausprobieren.

mfg
Matthias Drexler

[Matthias Drexler (Gast)]

Ich hätte da mochmal ne frage:
Wie heist denn der Name der ISR der auslöst wenn über die com 
schnittstelle daten rein kommen?

mfg
Matthias

[M. K. (sylaina)]

der heißt

ISR(USART_RX_vect){}

;)

[Matthias Drexler (Gast)]

Bei diesem Befehl sagt er auch das dieser Befehl wahrscheinlich falsch 
geschrieben ist......
was könnte das sein?

[M. K. (sylaina)]

Matthias Drexler schrieb:
> Bei diesem Befehl sagt er auch das dieser Befehl wahrscheinlich falsch
> geschrieben ist......
> was könnte das sein?

Liegt wohl daran, dass ich ins falsche Datenblatt schaute. Hab aus 
irgend einem Grund ins Datenblatt zum Atmega88 geschaut statt ins 
Datenblatt vom Atmega32. Beim 32er heißt der Vector:

ISR(USART_RXC_vect){}

[Matthias Drexler (Gast)]

ich habe diesen befehl jetzt eingefügt aber dann sagt er mir folgendes:

gcc plug-in: Error: Object file not found on expected location 
K:\AVR\AVR-Programme\Wechselrichter 
Störmeldeprogramm\default\WvS-Sample.elf

und wenn ich eine WvS-Sample.elf datei einfüge löscht er sie mir wieder.

was kann das jetzt sein?

[... (Gast)]

Schau mal in den anderen Output-Tab im AVRStudio, dann siehst Du auch 
die richtige Fehlermeldung.

[M. K. (sylaina)]

Öhm, also ich vermeide "Sonderzeichen" auch in Order- und Dateinamen. 
Also keine Leerzeichen, keine ä,ö,ü oder ß. Hat mir alles schon Probleme 
gemacht beim Programmieren.
Der Dateipfad mit dem ö drin könnte hier auch eine Fehlerquelle sein.

[Matthias Drexler (Gast)]

Im anderen Tab steht folgendes:


uart.o: In function `__vector_13':
K:\AVR\AVR-Programme\WechselrichterStoermeldeprogramm\default/../uart.c: 
260:  multiple definition of `__vector_13'
WvS-Sample.o:K:\AVR\AVR-Programme\WechselrichterStoermeldeprogramm\defau 
lt/../WvS-Sample.c:673:  first defined here
make: *** [WvS-Sample.elf] Error 1

und den dateipfad habe ich auch geändert und ist immer noch der gleich 
fehler

[M. K. (sylaina)]

Wie schaut denn dein gesamter Code aus? Mich dünkt, da klemmts irgendwo 
bei dir. Und welchen Atmega verwendest du genau (und was soll dieser 
tun)? Sonst reden wir hier wohl nur um den heißen Brei.

[Uwe (Gast)]

tja herausfinden warum in uart.c zeile 260 "__vector_13" mehrfach 
definiert ist bzw. warum woanders nochmal definiert bzw. was überhaupt 
__vector_13 ist.
Ich tippe auf den RXC interupt. du hast warscheinlich irgendeine 
definition ausversehen nocheinmal benutzt die schon in den standard 
includes vorkommt.
Und ich würde mal an Zeile 673 in Date WvS-Sample.c reingucken ob das 
nur ein Fehler ist der durch den vorhergehende Fehler  entstand.

[M. K. (sylaina)]

Das vermute ich auch, Uwe.
Genauer: In uart.c, Zeile 260 wird eine Funktion definiert, die schon in 
WsV-Sample.c, Zeile 673 definiert worden ist.
Der eigentliche Fehler kann jetzt alles Mögliche sein, z.B. eine Klammer 
zuviel geschlossen in uart.c vor Zeile 260.

[Matthias Drexler (Gast)]

ich verwende einen ATMega32.

Hier code ab zeile 672:

ISR (USART_RXC_vect)//ISR (USART_RX_vect)//ISR (SIG_UART0_RECV) 
//RS232(UART)Interrupt
{
  if (schutz == 1)          //Schutz vor nicht benötigter 
Interruptauslösung
  {

  buffer = UDR;            //Daten aus dem buffer lesen .....

  while (!(UCSRA & (1<<UDRE)))    //.... warten bis der Sende´buffer 
leer ist ....

  UDR = buffer;            //.....und gleich wieder zurück schicken

    if (buffer != 26)        //bei einem Return beginnnt die Auswertung, 
solange kein Return kommt, werden die Zeichen einfach nur gesammelt
    {
    string[f] = buffer;
    buffer = 0;
    f++;

    rprintf("buffer");
    }

    else
    {
    schutz = 1;
    rs232_recieve();
    schutz = 0;
    }
  }
}

Und im uart.h ab zeile 258:

// UART Receive Complete Interrupt Handler
UART_INTERRUPT_HANDLER(SIG_UART_RECV)
{
  u08 c;

  // get received char
  c = inb(UDR);

  // if there's a user function to handle this receive event
  if(UartRxFunc)
  {
    // call it and pass the received data
    UartRxFunc(c);
  }
  else
  {
    // otherwise do default processing
    // put received char in buffer
    // check if there's space
    if( !bufferAddToEnd(&uartRxBuffer, c) )
    {
      // no space in buffer
      // count overflow
      uartRxOverflow++;
    }
  }
}

[Matthias Drexler (Gast)]

#include <avr/io.h>
#include "global.h"     // include our global settings
#include "i2cmaster.h"   // Auskommentieren, falls nicht benötigt...
#include "lcd.h"
#include "adc.h"  // include printf function library
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include "string.h"
#include "timer.h"
#include <stdlib.h>
//#include <avr/signal.h>
#include <stdio.h>
//#include "usart.h"
//#include "uart.h"


#define DS1307  0xd0  /* I2C Adresse unseres DS1307 Uhrenbausteins, write-Zugriff */
#define USE_LCD 1    // 1 Falls LCD verwendet wird

// type declarations - Hier werden neue Typen für Variablen definiert
typedef unsigned char uint8;         /*!< vorzeichenlose 8-Bit-Zahl          0..255      */

// Hier die Variablen definieren, die im Programm verwendet werden sollen

uint8 i;  // Eine Variable: Zahlenbereich 0..255

uint8 sec,minute,hour,wd,day,month,year; // Variablen für Zeit, Wochentag, Datum

const char zeichen[] = ",:/";

char string[30];
char *wert, empfang[20];


int schutz = 0, buffer = 0, (f), (t) = 0;

/*unsigned*/ char tempstr[20]; // temporärer String (Variable für eine Folge von Zeichen)

// Definitionen für Unterprogramme
void init(void);
void i2cGetdatetime(void);
void i2cSettime(void);
void i2cSetdate(void);
void rs232_recieve (void);  //Fernsteuerung über RS-232

  /* 
  UART-Init: 
  Berechnung des Wertes für das Baudratenregister 
  aus Taktrate und gewünschter Baudrate
  */
 
#ifndef F_CPU
  /* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
   F_CPU im Makefile definiert werden, eine nochmalige Definition
   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
   #ifndef/#endif 
 
   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 
   verwendet wird und dort eine andere, nicht zur Hardware passende 
   Taktrate eingestellt ist: Dann wird die folgende Definition 
   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 
   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
   noch nicht definiert: */
  #warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 14756000"
  #define F_CPU 14756000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
  #endif
 
  #define BAUD 9600UL      // Baudrate
 
  // Berechnungen
  #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
  #define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
  #define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
  #if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
  #endif 

// Unterprogramm init: Hier werden die Initialisierungen vorgenommen
void init(void)
{

  wdt_disable();    // Watchdog ausschalten 
  

  // Port B initialisieren
  DDRB= 0xFF;       // alle 8 pins sind als Ausgang geschaltet
           
  // Port A initialisieren
  DDRA= 0x00;       // alle 8 pins sind als Eingänge geschaltet


  PORTB= 0x00;    // Alle unteren Pins sind low (Ruhestellung)
    
  timer0Init();      /*   Mit diesem Befehl wird die include-Datei timer initialisiert,
            die uns u.a. den Befehl timerPause() zur Verfügung stellt.
            */ 
  i2c_init();       // Initialisierung des I2C-Busses

  sei();        // Interrupts zulassen (für timer.c wichtig)
  


#if USE_LCD  
  lcd_init(LCD_DISP_ON);
#endif  

  lcd_clrscr(); // LCD löschen



  UCSRB |= (1<<TXEN);                           // UART TX einschalten
  UCSRC |= (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1 

  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  

    
  uartInit();     // initialize the UART (serial port)
  uartSetBaudRate(9600); // serielle Schnittstelle auf 19200 Baud setzen
  rprintfInit(uartSendByte);



} // Ende init


uint8 bcd2hex(uint8 hexb) // Umwandlung von BCD nach Hex
              // der DS1307 tickt in BCD
{

 u08 tempb1, tempb2; //lokale Variablen
 
 tempb1 = hexb >> 4;
 tempb1 = tempb1 * 10;
 tempb2 = hexb & 0x0F;
 return (tempb1 + tempb2);
 
}

uint8 hex2bcd(uint8 hexb) // Umwandlung von Hex nach BCD
{
 uint8 tempb1, tempb2; //lokale Variablen
 
 tempb1 = hexb / 10;
 tempb2 = hexb % 10;
 tempb1 = tempb1 << 4;
 return (tempb1 | tempb2);
 
}


void i2cGetdatetime(void) // Holt Zeit,Datum von DS1307
{
    unsigned char ret,isec,imin,ihour,iwd,iday,imonth,iyear; // Lokale Variablen
  
      
      /* write 0x75 to eeprom address 0x05 (Byte Write) */
    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode
  if ( ret ) {
      rprintf("I2cnotready",ret,"<<>>");
        /* failed to issue start condition, possibly no device found */
        i2c_stop();
    }else {
        /* issuing start condition ok, device accessible */
        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode
        i2c_write(0x00);                      // write address = 0
        i2c_rep_start(DS1307+I2C_READ);       // set device address and read mode
        isec  = i2c_readAck();                // read one byte and go on
    imin  = i2c_readAck();                // read one byte and go on
    ihour = i2c_readAck();                // read one byte and go on
    iwd   = i2c_readAck();                // read one byte and go on
    iday  = i2c_readAck();                // read one byte and go on
    imonth = i2c_readAck();               // read one byte and go on
    iyear  = i2c_readNak();               // read one byte and finish
        i2c_stop(); // Stop i2c
    sec   = bcd2hex(isec);
    minute   = bcd2hex(imin);
    hour  = bcd2hex(ihour);
    wd = iwd;
    day   = bcd2hex(iday);
    month = bcd2hex(imonth);
    year  = bcd2hex(iyear);
        
    }
}


void i2cSettime(void) // setzt die Zeit im DS1307
{
    unsigned char ret;
  
  
      /* write 0x75 to eeprom address 0x05 (Byte Write) */
    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode
  if ( ret ) {
        /* failed to issue start condition, possibly no device found */
    rprintf("\r\nKeine I2C-Uhr gefunden in SetTime!\r\n");
        i2c_stop();
 
    }else {
        /* issuing start condition ok, device accessible */
        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode
        i2c_write(0x00);                      // write address 0
        i2c_write(hex2bcd(sec));    // Sekunden
    i2c_write(hex2bcd(minute)); // Minuten
    i2c_write(hex2bcd(hour));   // Stunden
    i2c_stop();

    }
}

void i2cSetdate(void) // setzt die Zeit im DS1307
{
    unsigned char ret;
  
  
      /* write 0x75 to eeprom address 0x05 (Byte Write) */
    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode
  if ( ret ) {
        /* failed to issue start condition, possibly no device found */
    rprintf("\r\nKeine I2C-Uhr gefunden in SetDate!\r\n");
        i2c_stop();
 
    }else {
        /* issuing start condition ok, device accessible */
        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode
        i2c_write(0x03);                      // write address 0
    i2c_write(wd);            // Wochentag 
    i2c_write(hex2bcd(day));   // Tag
    i2c_write(hex2bcd(month)); // Monat
    i2c_write(hex2bcd(year));  // Jahr
        i2c_stop();  
    }
}




void rs232_recieve (void)  //Fernsteuereung über RS-232
{

                          
//bei prgrammstart "rprintf("AT+CCLK?\r\n");"  dann kommt +CCLK: "02/08/15,00:09:29" 

string[f] = '\0';  //erst mal einen sauberen C-String daraus machen


wert = strtok(string, zeichen);// initialisieren und ersten Abschnitt erstellen


while(wert != NULL) 

{

empfang[t] = atoi(wert);

wert = strtok(NULL, zeichen);

t++;

}



  sec = empfang[5];
  minute = empfang[4];
  hour = empfang[3];
  day = empfang[2];
  month = empfang[1];
  year = empfang[0];
  i2cSettime(); // i2c Befehl zum Setzen der Zeit
  i2cSetdate(); // i2c Befehl zum Setzen des Datums

}  //ende rs232_recieve



int main (void) 
{ 

  
  init(); // Aufruf des Unterprogramms init

                  
    while (!(UCSRA & (1<<UDRE)))  // warten bis Senden moeglich                   
    {
    }
  
  rprintf("AT+CCLK?\r\n");
  timerPause(1000);


  

    while (1) // Endlosschleife
  { 
  
  lcd_clrscr();
  lcd_puts("Kontrolle l\xE1uft");
        i2cGetdatetime(); // Hier werden die Variablen für Zeit und Datum aktualisiert
    lcd_gotoxy(15,1);
    sprintf(tempstr,"%02d",hour);
    lcd_puts(tempstr);
    lcd_puts(":");           // : zwischen stunde und minute
    sprintf(tempstr,"%02d",minute);
    lcd_puts(tempstr);


  PORTB |= (1<<PB0);
  timerPause(300);
  PORTB &= ~(1<<PB0);
  
  PORTB |= (1<<PB1);
  timerPause(300);
  PORTB &= ~(1<<PB1);

  PORTB |= (1<<PB2);
  timerPause(300);
  PORTB &= ~(1<<PB2);


  PORTB |= (1<<PB3);
  timerPause(300);
  PORTB &= ~(1<<PB3);

  } // ende Endlosschleife


} // Ende main (Hauptprogramm)



ISR (USART_RXC_vect)  //SIGNAL (SIG_UART_RECV)  //ISR  (SIG_USART_RECV) //ISR (USART_RX_vect) //ISR (SIG_UART0_RECV)            //RS232 (UART) Interrupt
{
  if (schutz == 1)          //Schutz vor nicht benötigter Interruptauslösung  
  {  

  buffer = UDR;            //Daten aus dem buffer lesen .....

  while (!(UCSRA & (1<<UDRE)))    //.... warten bis der Sende´buffer leer ist ....
  
  UDR = buffer;            //.....und gleich wieder zurück schicken

    if (buffer != 26)        //bei einem Return beginnnt die Auswertung, solange kein Return kommt, werden die Zeichen einfach nur gesammelt
    {
    string[f] = buffer;
    buffer = 0;
    f++;

    //rprintf("buffer");
    }
  
    else
    {
    schutz = 1;
    rs232_recieve();
    schutz = 0;
    }
  }
}

[Matthias Drexler (Gast)]

und das ist meine kompletter quellcode incl. Fehler.

[Karl H. (kbuchegg)]

In deiner Fehlermeldung steht

uart.o: In function `__vector_13':
K:\AVR\AVR-Programme\WechselrichterStoermeldeprogramm\default/../uart.c:260:
multiple definition of `__vector_13'
WvS-Sample.o:K:\AVR\AVR-Programme\WechselrichterStoermeldeprogramm\default/../WvS-Sample.c:673:
first defined here

da ist von einer Datei "uart.o" die Rede, die aus "uart.c" compiliert 
wurde. WEnn man davon ausgehen kann, dass du vernünftige Dateinamen 
gewählt hast, dann wird es sich wohl hierbei um UART Routinen handeln, 
die zum Bliestift eine ISR für den RXC Interrupt mitbringen.

Und genau denselben Interrupt (und einen soweit ich sehen kann 
vollständigen Satz UART Routinen) hast du auch in deinem Hauptfile 
"WvS-Sample.o" welche aus "WvS-Sample.c" compiliert wurde.

Das mag jetzt nicht so gewollt sein, weil du in deinem Hauptfile alle 
Referenzen zu uart.h auskommentiert hast. Fakt ist aber, dass in deiner 
Projektbeschreibung, die du im AVR-Studio (? ansonsten eben im Makefile) 
in Form von dazugehörigen Source-Code Dateien hast, die uart.c noch 
immer mit drinnen hast und die daher compiliert und zum Projekt gelinkt 
wird. Und deswegen gibt es alles doppelt. Insbesondere gibt es die ISR 
doppelt.


Steht alles da. Nur lesen und seine Schlüsse aus dem Gelesenen muss man 
halt ziehen.

[Matthias Drexler (Gast)]

@Karl Heinz Buchegger:
Danke für die Erklärung.
Das diese Definition doppelt vorhanden ist hab ich schon raus gefunden.
Aber was heißt der letzte Absatz genau?
Sollte ich die uart.c löschen oder kann man die umändern oder ähnliches?

[M. K. (sylaina)]

Matthias Drexler schrieb:
> Sollte ich die uart.c löschen oder kann man die umändern oder ähnliches?

Das soll heißen, dass du nicht doppelt includieren sollst.

[Karl H. (kbuchegg)]

Matthias Drexler schrieb:
> @Karl Heinz Buchegger:
> Danke für die Erklärung.
> Das diese Definition doppelt vorhanden ist hab ich schon raus gefunden.
> Aber was heißt der letzte Absatz genau?
> Sollte ich die uart.c löschen oder kann man die umändern oder ähnliches?

WElcher Teil von

> Fakt ist aber, dass in deiner
> Projektbeschreibung, die du im AVR-Studio (? ansonsten eben
> im Makefile) in Form von dazugehörigen Source-Code Dateien hast,
> die uart.c noch immer mit drinnen hast und die daher compiliert
> und zum Projekt gelinkt wird.

ist da jetzt so, dass man mit ein bischen mitdenken nicht von selber auf 
die Lösung kommt, das man uart.c aus der Projektbeschreibung rausnehmen 
soll?

[Matthias Drexler (Gast)]

Hallo

Ich habe jetzt den befehl ab der angegebenen zeile im uart.c 
auskommentiert und da war der fehler weg.

der befehl sieht wie folgt aus:

/*
// UART Receive Complete Interrupt Handler
UART_INTERRUPT_HANDLER(SIG_UART_RECV)
{
  u08 c;

  // get received char
  c = inb(UDR);

  // if there's a user function to handle this receive event
  if(UartRxFunc)
  {
    // call it and pass the received data
    UartRxFunc(c);
  }
  else
  {
    // otherwise do default processing
    // put received char in buffer
    // check if there's space
    if( !bufferAddToEnd(&uartRxBuffer, c) )
    {
      // no space in buffer
      // count overflow
      uartRxOverflow++;
    }
  }
}
*/

Muss es aber noch in der Praxis ausprobieren ob der Interrupt noch 
funktioniert.
Danke für eure Tipps und Ratschläge.

mfg
Matthias Drexler