Hallo..
bei den rs485 tests hat sich ein problem ergeben..
ich glaube ich stehe einfach vor einer wand um die ein sehr einfacher weg herumführt..

ich habe meine zentrale c-datei namens motor-treiber.c.
ich habe versucht die funktionen zur kommunikation allgemein zu implementieren... in einer header datei..
und wenn mich meine c/c++ erfahrungen nicht täuschen, sollte man diese auslagerung mit dem befehl #include "rs485.h" einbinden können..
in die header datei schreibe ich die prototypen und in die "rs485.c" die definitionen ..
wenn ich nun die rs485.h datei einbinde, müssten die in rs485.c ausführlich definierten funktionen verfügbar sein oder hab ich was falsch in errinnerung ?
das problem ist, dass die beispiele zum UART mit AVR/GCC hier für mich etwas schwer zu durchblicken sind was die dateizuordnung angeht..
ist der mit c-datei überschriebene teil die eigentliche programm-quellcode-datei oder die zur header datei gehörige c-datei.. ?
desweiteren stellt sich mir die frage, ob die c-datei denselben namen tragen muss wie die header datei damit die funktionen sauber implementiert werden.. weil ja nur die header datei eingebunden wird.. (und damit dann auch die zugehörige c-datei ??)
für einen kleinen hinweis wär ich sehr dankbar..

MfG
ngb

P.S.: hier die dateien und die fehlermeldung von PN:

Code:
// Sollte schon im Makefile definiert sein.
// In dem Fall hier einfach löschen.
#define F_CPU       16000000UL

#include <avr/io.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "rs485.h"
#include "fifo.h"

void warte (uint16_t loop) //loop: wartezeit in ms
{
	uint16_t i;
	for(i=0;i<loop;i++) _delay_ms(1); //Hier sind als Werte für _delay_ms Takt-abhängige Werte maximal
										//erlaubt.. Durch die Schleife werden beliebige Werte möglich
}

int main(void)
{
    // USART initialisieren
    rs485_init();
	
	warte(5000);
	
	rs485_puts("Hallo Welt !");
	
	sei();
	
	while(1);
}
Code:
#ifndef _RS485_H_
#define _RS485_H_

void rs485_init();
uint8_t rs485_getc_wait();
int rs485_getc_nowait();
void rs485_putc(unsigned char buffer);
void rs485_puts(const char *s);

static inline void rs485_flush()
{
	while (UCSRB & (1 << UDRIE));
}

#endif /* _RS485_H_ */
Code:
#define BAUDRATE 19200

// FIFO-Objekte und Puffer für die Ein- und Ausgabe 

#define BUFSIZE_IN  0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;

// Empfangene Zeichen werden in die Eingabgs-FIFO gespeichert und warten dort 
SIGNAL (SIG_UART_RECV)
{
    _inline_fifo_put (&infifo, UDR);
}

void rs485_init()
{
    uint8_t sreg = SREG;
    uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);

    UBRRH = (uint8_t) (ubrr>>8);
    UBRRL = (uint8_t) (ubrr);

    // Interrupts kurz deaktivieren 
    cli();

    // UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren 
    // Data mode 8N1, asynchron 
    UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
    UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

    // Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) 
    do
    {
        // UDR auslesen (Wert wird nicht verwendet) 
        UDR;
    }
    while (UCSRA & (1 << RXC));

    // Rücksetzen von Receive und Transmit Complete-Flags 
    UCSRA = (1 << RXC) | (1 << TXC);

    // Global Interrupt-Flag wieder herstellen 
    SREG = sreg;

    // FIFOs für Ein- und Ausgabe initialisieren 
    fifo_init (&infifo,   inbuf, BUFSIZE_IN);
	
	//Output DDD2 setzen für Send/Receive- Wechsel
	DDRD = (1<<DDD2);
}

// Ein Zeichen lesen (Wenn keine Zeichen da, Rückmeldung)
int rs485_getc_nowait ()
{
    return fifo_get_nowait (&infifo);
}

// Ein Zeichen lesen (so lange warten, bis ein Zeichen da ist)
uint8_t rs485_getc_wait ()
{
    return fifo_get_wait (&infifo);
}

// Um das Problem bei RS485 zu umgehen, dass nicht gleichzeitig gesendet und empfangen werden kann (2 Adern),
// nur "direktes" Senden möglich

//Einzelnes Zeichen senden
void rs485_putc (unsigned char buffer)
{
	while (!(UCSRA & (1 << UDRE)));
	PORTD |= (1 << 2);
	UDR = buffer;
	PORTD &= ~(1 << 2);
}

//String senden
void rs485_puts (const char *s)
{
	PORTD |= (1 << 2);
	do 
    {
		// Warten bis der Sendepuffer frei ist
		while ( !( UCSRA & (1<<UDRE)) );
		UDR = *s;
    }
    while (*s++);	
	PORTD &= ~(1 << 2);
}
Fehlermeldung:
in Main:
Undefined Reference to rs485_puts