String empfangen mit PIC18F und XC8

[Ingo S. (schicki)]

Hallo Zusammen,

ich versuche gerade einen String über den USART einzulesen. Das PC 
Programm tut was es soll.

Der PIC antwortet, wenn nur mit Schrott. Wenn ich einen Teststring 
manuell erstelle und versende funktioniert die Schnittstelle. Es muss 
also folglich was mit der Deklaration bzw. etwas mit dem Einlesevorgang 
zu tun haben.

Der String besteht aus 38 Zeichen (siehe Bild). Nach der Durchsicht 
meiner C-Unterlagen und des String Artikels hier habe ich n alle 
möglichen für mich vorstellbaren Varianten durchgespielt.Ich komme nicht 
auf den richtige Lösung. Kennt jemand die Lösung?

// C-Code Auszüge
aus dem USART Programm

void USART_Write_String(char *text)
{
  int i;
  for(i=0;text[i]!='\0';i++)
    USART_Write(text[i]);
}

void USART_Write(uint8_t txData)
{
    while(0 == PIR1bits.TX1IF)
    {
    }

    TXREG1 = txData;    // Write the data byte to the USART.
}

void USART_Read_String(char *Output, unsigned int length)
{

    unsigned int i;
    for(int i=0;i<length;i++)
    {    
        Output[i] = USART_Read();

        if ((Output[i] == '\r') || (Output[i] == '\r'))
        {
            Output[i] = '\0';
            break;
        }
    }
    //Output[i+1] = '\0';
}

uint8_t USART_Read(void)
{

    while(!PIR1bits.RC1IF)
    {
    }

    if(1 == RCSTA1bits.OERR)
    {
        // EUSART1 error - restart

        RCSTA1bits.CREN = 0; 
        RCSTA1bits.CREN = 1; 
    }

    return RCREG1;
}


aus Main.c

//Deklarationen
   char chr_Temp[40];
   static char *chr_Data_1[40];
   char *chr_Data_2[40];
   char *chr_Data_3[40];
 while(1)                    // Ganzes Programm ist Endlosschleife
 {     
    memset(chr_Data_1, 0x20, 40);
    USART_Read_String(chr_Data_1,37);
    USART_Write_String(chr_Data_1);
    LcdPrintf(4, 1, chr_Data_1);
    USART_Write_String("\r\n");
}

Viele Grüße
Ingo

[PittyJ (Gast)]

Du weisst, was das hier erzeugt?

static char *chr_Data_1[40];

[Ingo S. (schicki)]

Grundsätzlich ja. Durch das viele Testen von verschiedenen 
Möglichkeiten.

das ist klar aber auch wenn der nicht static ist, geht das nur einmal 
und dann die wieder wegen eigen Overflow...


erzeugen einer static-Variablen mit Anfangswert 0 */

[PittyJ (Gast)]

Also uch würde zum Empfangen eine Strings einen einfachen char Buffer 
nehmen. So etwas wie
char Buffer[40];

So wie ich C kenne bedeutet
char *chr_Data_1[40];
ein Feld von 40 Char-Pointern. Wozu braucht man einen Poiner auf jedes 
Zeichen? Das geht doch einfacher?
Oder bin ich jetzt falsch, weil ich neueste C-20 Features nicht kenne?


Auch werden die Pointer durch
memset(chr_Data_1, 0x20, 40);
mit ziemlichen Mist initialisiert.

Eigentlich müßte der Compiler doch auch einen Haufen Warnungen ausgeben?