LCD Routine (C) bringt fehler

Bei C ist die erste Fehlermeldung die entscheidende, weitere sind meist
Folgefehler.
Die Meldung bedeutet, dass er string-avr.h nicht includen kann, weil er
sie nicht dort findet, wo er sie sucht.

Das kann 2 Gründe haben:
- die Datei steht woanders
  -> Datei ins include-Verzeichnis verschieben   oder
  -> in der #include-Anweisung den Pfad angeben
  (beachte den Unterschied <string-avr.h> und "string-avr.h")
- die Datei steht nirgens

Suche den Rechner nach der Datei ab (mit WindowsTaste-F).

Ein gutes Programm würde sagen:
Laden der Datei string-avr.h von Verzeichnis c:\abc\xyz und
c:\def\include nicht möglich, richtiges Verzeichnis eingeben:

ein programm aus codeschnippsel.
datenanschluss portc 0-3 (4bit-modus)standartdisplay 2x16, 4=en, 5=rs,
rw auf masse.
kannste jederzeit ändern, brauchs nur die daten vom jeweiligen lcd
reinbringen. daten werden vom pc über die serielle schnittstelle
eingelesen (19200bps)und auf dem display ausgegeben.
schau dir das programm in aller ruhe durch.
typ: avr16 8mhz und 19200bps.


die lcd.c :

#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "uart.c"

#define delay_us_(us)  _delayFourCycles_( ( ( 1*(F_CPU/4000) )*us)/2005
)

void _delayFourCycles_(uint16_t z)
{
  uint16_t i;

      for (i=0; i<z; i++)
      asm volatile("nop");
}

void delay_ms_(uint16_t z)
{
  uint16_t i;
  for (i=0; i<z; i++)
      delay_us_(999);
}

void lcd_flash_e (void)
{
  PORTC|=(1<<DDC4);
  delay_us_(5);
  PORTC&=~(1<<DDC4);
  delay_us_(50);
}

void lcd_write (uint8_t data, uint8_t rs)
{
  uint8_t dataBits ;

    if (rs)
       dataBits=0x20;
    else
       dataBits=0;

    PORTC=dataBits |(data>>4);
  lcd_flash_e ();
    PORTC=dataBits | (data&0x0F);
  lcd_flash_e();
  delay_ms_(2);
}

void lcd_cls (void)
{
  lcd_write(0x02,0);
  delay_ms_(2);
  lcd_write(0x01,0);
  delay_ms_(2);
}

void lcd_writechar(char zeichen)
{
  lcd_write (zeichen,1);
}

void lcd_writetext(char *text)
{
  uint8_t i = 0;
  while (text[i]!=0)
  {
    lcd_writechar(text[i]);
    i++;
  }
}

void lcd_gotoline(uint8_t zeile)
{
  if (zeile == 1)lcd_write(0x80,0);
  if (zeile == 2)lcd_write(0xC0,0);
}

void lcd_gotopos (uint8_t zeile, uint8_t spalte)
{
  if (zeile == 1)lcd_write(0x80+spalte-1,0);
  if (zeile == 2)lcd_write(0xC0+spalte-1,0);
}

void lcd_ini (void)
{
  DDRC = 0x3F;
  PORTC=0x00;

  delay_ms_(5);

  lcd_write(0x2,0);

  lcd_flash_e ();

  delay_ms_(5);

  lcd_write(0x28,0);
  lcd_write(0x0C,0);
  lcd_write(0x06,0);

  lcd_cls();
}

int main(void)
{

  DDRC=0xff;
  PORTC=0;
  sei();
  usart_init( (READ + WRITE) , READ);

  delay_ms_(100);
  lcd_ini();

  while(1)
  {
    if(char_test==1)
    {
        lcd_cls();
      lcd_gotopos (1, 3);
      lcd_writetext(text_ausgabe);
      lcd_gotopos (2, 6);
      lcd_writetext(text_ausgabe);

    }
    char_test=0;
    delay_ms_(5);
  }

}


die uart.c :

#define READ  1
#define WRITE 2

#define USART_BAUD_RATE   19200
#define USART_BAUD_SELECT   (F_CPU/(USART_BAUD_RATE*16l)-1)

char uart_text[32];
char text_ausgabe[32];
char buchstabe;
uint8_t zaehler_char=0;
uint8_t char_test;
uint8_t zaehler_ausgabe;


SIGNAL(SIG_UART_RECV)
{
if(char_test==0)
{
  buchstabe=UDR;
  if ((buchstabe==13) || (zaehler_char==31))
  {
    uart_text[zaehler_char]='\0';
    strcpy(text_ausgabe, uart_text);
    zaehler_ausgabe=zaehler_char;
    zaehler_char=0;
    char_test=1;
    }
    else
    {
    uart_text[zaehler_char] = buchstabe;
      zaehler_char=zaehler_char+1;
  }
}
}

void usart_init(int Enable, int Interupts)
{
  if (Enable & READ)             UCSRB = (1<<RXEN);
  if (Enable & WRITE)            UCSRB |= (1<<TXEN);

    if (Interupts & READ)             UCSRB |= (1<<RXCIE);
  if (Interupts & WRITE)            UCSRB |= (1<<TXCIE);
    UBRRL = (unsigned char)       USART_BAUD_SELECT;
}

void usart_writeChar(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE))) {}
    UDR = c;
    while(!(UCSRA & (1<<TXC))) {}
}

void usart_writeString(unsigned char *string) {
    while (!(UCSRA & (1<<UDRE))) {}
  while ( *string)
    usart_writeChar(*string++);
}