uController-USART-String

[daselmo (Gast)]

Hallo,

wir haben bei unserem kleinen Tester folgendes Problem:
Der Funktion WriteUARTStringPC ()kann kein String übergeben werden.
Bitte um Hilfe.

Es wird auf einem ATMEGA128 mit einem 7372000 Quarz programmiert.
Quellcode

 
#include <avr/io.h>
#include <avr/interrupt.h>
//#include <util/delay.h>
#include <inttypes.h>
#include <string.h>

#define FOSC 7372000      //clock speed
#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1

//typeset unsigned char uchar;
  //set baud rate 



void USART0Init(unsigned int ubrr0)
{  //set Bausdrate
  UBRR0H = (ubrr0>>8);
  UBRR0L = (ubrr0);

  //transmit enable / 1 stopbit, 8 databits
  UCSR0B = 0x18;   //?!?!?!?!?!?!?!?!?
  UCSR0C = 0x06;
}


char ReadPcUART()
{
  while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
        ;
  return UDR0;                  
}

void ReadStringPCUART( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = ReadPcUART();         // Warte auf und empfange das n‰chste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen + 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = ReadPcUART();
  }
 
                                  // Noch ein '\0' anh‰ngen um einen Standard
                                  // C-String daraus zu machen
  //*Buffer = '\0';
}


void WriteCharPC (unsigned char cData)
{
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR0 = cData;                      /* sende Zeichen */
    return 0;
}

void WriteUARTStringPC (char* sText)
{
  unsigned char cByte;
   unsigned char cOffset;

   for (cOffset=0;sText[cOffset]!='\0';cOffset++)
    {
       // byte aus flash lesen
       cByte=sText[cOffset];  

       // fertig
       if (cByte=='\0') break;

       // und zum PC schicken
       WriteCharPC (cByte);
    }
}

int main ()
{
  
  char Line[20];      // String mit maximal 20 zeichen

  Line[0] = 101;
  Line[1] = 54;
  Line[2] = 72;  

  USART0Init(MYUBRR);
  
  for(;;)
  {  
    //ReadStringPCUART(Line);
    //WriteUARTStringPC('1');
        /*
        WriteCharPC ('A');
    WriteCharPC ('0');
    WriteCharPC ('0');
    WriteCharPC ('0');
    WriteCharPC ('1');
    WriteCharPC ('\n');
         */
    WriteUARTStringPC(Line[0]);          //<-- 
    //WriteUARTStringPC("\n\r");
    //uart_gets( Line,40);
    //data=ReadPcUSART();
    //WritePCUSART(data);
  }
  
  return 0;  
}

Bitte um Hilfe.

[Noname (Gast)]

>Der Funktion WriteUARTStringPC ()kann kein String übergeben werden.
Was heisst das genau? Fängt der uC an zu quitschen oder was? :-)

[Noname (Gast)]

Das hier:

    WriteUARTStringPC(Line[0]);          //<--

wird jedenfalls eine Fehlermeldung geben.
Dir ist doch klar, das Du das ein Zeichen (char) übergibst anstelle des 
von der Funktion geforderten char *, oder vielleicht doch nicht?

[Stefan E. (sternst)]

daselmo schrieb:
> Der Funktion WriteUARTStringPC ()kann kein String übergeben werden.

Kann schon, du tust es nur nicht.

    WriteUARTStringPC(Line[0]);          //<--

Line[0] ist kein String, sondern nur das erste Zeichen in einem Array. 
Aber auch wenn du das korrigierst, wirst du vielleicht unerwartete 
Ergebnisse bekommen, denn in dem Array steht gar kein String, sondern 
eine unterminierte Abfolge von Zeichen.

[Typ (Gast)]

char Line[20] ="WTF?";
WriteUARTStringPC(Line); //entspricht -> WriteUARTStringPC(&Line[0]);

[daselmo (Gast)]

Gut nun bessere ich folgende Zeilen aus:

char Line[20] ="WTF?";
WriteUARTStringPC(Line); //entspricht -> WriteUARTStringPC(&Line[0]);

und debugge es mit dem JTAG mkII und AVR Studio.
Jetzt gibt der uController eine unendliche Folge von 'hochgestellten 3' 
aus.

Es funktioniert aber wenn man es direkt hineinschreibt.

 WriteUARTStringPC("WTF?");

Hat jemand eine Idee was es sein könnte?

[Peter II (Gast)]

Ich würde es dem µC und compiler nicht so schwer machen.

So sollte das ganze ein wenig optimierter sein:

[c]
void WriteUARTStringPC (char* sText)
{
   // oder die langform  while( *sText != 0 ) {
   while( *sText ) {
       WriteCharPC ( *sText );
       sText++;
   }
}
[\c]

du hattest 2 hilfsvariablen und jedes mal in der schleife hast du den 
index zugriff verwendet.

[daselmo (Gast)]

void WriteUARTStringPC (char* sText)
{
   // oder die langform  while( *sText != 0 ) {
   while( *sText ) {
       WriteCharPC ( *sText );
       sText++;
   }
}

Ist ja eine super Idee, haben wir auch hier im µC Forum des Öfteren 
gesehen und ausprobiert, behebt aber leider unser Problem nicht.

Das Problem ist die Übergabe des Strings an die Funktion. Wo liegt da 
unser Fehler?

[Karl H. (kbuchegg)]

daselmo schrieb:
> Gut nun bessere ich folgende Zeilen aus:
>
char Line[20] ="WTF?";
> WriteUARTStringPC(Line); //entspricht -> WriteUARTStringPC(&Line[0]);
>
> und debugge es mit dem JTAG mkII und AVR Studio.
> Jetzt gibt der uController eine unendliche Folge von 'hochgestellten 3'
> aus.

und was war sonst noch so im Programm?
Gab es Code zwischen den beiden Programmzeilen, die Line manipuliert
haben? Immer wenn ich sowas in einem Programm sehe

 Line[0] = 101;

läuft es mir kalt den Rücken runter und ich traue dem Programmierer
nicht weiter, als ich einen Kernighan&Ritchie werfen kann. Und der 
fliegt nicht besonders gut.

[daselmo (Gast)]

Aktueller Code, erfolgreich einen weiteren Weg gefunden der nicht 
funktioniert.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <string.h>

#define FOSC 7372000      //clock speed
#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1


//typeset unsigned char uchar;
//set baud rate 



void USART0Init(unsigned int ubrr0)
{  //set baud
  UBRR0H = (ubrr0>>8);
  UBRR0L = (ubrr0);

  //transmit enable / 1 stopbit, 8 databits
  UCSR0B = 0x18;   
  UCSR0C = 0x06;
}

void WriteCharPC (unsigned char cData)
{
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
  {
  }                             
 
  UDR0 = cData;                      /* sende Zeichen */
  return 0;
}

void WriteUARTStringPC (char* sText)
{
  while( *sText ) 
  {
     WriteCharPC ( *sText );
     sText++;
  }
}

int main ()
{
  char Line[20] = "WTF";      // String mit maximal 20 zeichen

  USART0Init(MYUBRR);
  
  for(;;)
  {  

    WriteUARTStringPC(Line);          //<-- 

  }
  
  return 0;  
}

Also wenn jemand weiter weiss bitte um Hilfe!

[Peter II (Gast)]

kannst du denn einzele zeichen senden?

WriteCharPC('#');

stimmt wirklich der Takt vom µC? Bitte mit ein LED die im sekunden Takt 
blinkt prüfen!

Richtige Baudrate am PC angestellt? Stimmt der verkabelung?

[daselmo (Gast)]

>kannst du denn einzele zeichen senden?

über die WriteCharPC() sind einzelne Zeichen möglich.

Es funktioniert auch, wenn wir z.b. "Hello World" in die 
WriteUSARTStringPC() schreiben, also:

 WriteUSARTStringPC("Hello World");

>stimmt wirklich der Takt vom µC? Bitte mit ein LED die im sekunden Takt
>blinkt prüfen!

Takt stimmt, hatten am Anfang das Problem mit den Fuses und dem externen 
Takt. Diesen Fehler haben wir aber schon behoben.

>Richtige Baudrate am PC angestellt? Stimmt der verkabelung?

Die Baudrate am Terminal stimmt auch und die Verkabelung wurde schon 
mehrmals kontrolliert.

[Karl H. (kbuchegg)]

Welche Compilerversion?
Dein letzter Code sieht soweit in Ordnung aus. Müsste eigentlich 
funktionieren.

[daselmo (Gast)]

>Welche Compilerversion?

Verwenden AVR Studio 4 Version 4.18 mit original ATMEL JTAG mkII.

[Peter II (Gast)]

kommt denn beim compilieren keine Warnung oder ein Fehler?

> void WriteCharPC (unsigned char cData)
> ...
> return 0

sollte eigenlich nicht zulässig sein.

[daselmo (Gast)]

>kommt denn beim compilieren keine Warnung oder ein Fehler?

>> void WriteCharPC (unsigned char cData)
>> ...
>> return 0

>sollte eigenlich nicht zulässig sein.

Warning schon. Wurde behoben. Problem bleibt.

[Peter II (Gast)]

dann nutzt doch mal den debuger wenn du schon einen hast, werden denn 
die buchstaben einzeln in WriteCharPC übergeben?

[daselmo (Gast)]

Wird das Line folgendermaßen deklariert:

 char Line[20] = "WTF";

steht im Line beim Debuggen nichts drinnen.

Also liegt das Problem schon bei der Deklaration?!

[Peter II (Gast)]

daselmo schrieb:
> Also liegt das Problem schon bei der Deklaration?!

nein, kann durch den optimierer anderes gemacht werden. Gehe direkt in 
die funktion WriteUARTStringPC dort sollte dann der string schon zu 
sehen sein.

[daselmo (Gast)]

Das Problem ist, dass das sText in der Watchliste "Location not valid" 
meldet.
Was tun?

[Peter II (Gast)]

daselmo schrieb:
> Was tun?

optimierung mal ausschalten

[daselmo (Gast)]

>optimierung mal ausschalten

wenn wir die Optimierung ausschalten, hängt sich das Programm nach der 
Init auf.
Langsam sind wir verzweifelt.

[Peter II (Gast)]

daselmo schrieb:
> wenn wir die Optimierung ausschalten, hängt sich das Programm nach der
> Init auf.
> Langsam sind wir verzweifelt.

hat du auch den richtigen controller type ausgewählt?

[Karl H. (kbuchegg)]

Hast du den richtigen Prozessor in den Optionen eingestellt?
Such mal deine Projekt-Optionen durch.

Wenn du nichts findest, würd ich auch mal Folgendes probieren:

Neues Projekt anfangen.
Wichtig: Sehr genau darauf auchten, was da eingestellt wird.

Den Code mittels Cut&Paste in das vom Wizard erzeugte Source File 
einsetzen.

Build machen.

[Karl H. (kbuchegg)]

Mega128 bringt mich auf noch eine Idee:
Die M103 Fuse ist abgeschaltet?

Dieses Symptom
> wenn wir die Optimierung ausschalten, hängt sich das Programm
> nach der Init auf.
würde da ganz stark dafür sprechen, dass die M103 aktiv ist.

[daselmo (Gast)]

>Mega128 bringt mich auf noch eine Idee:
>Die M103 Fuse ist abgeschaltet?

ES FUNKTIONIERT!!!!!!!

Code wie vom Post: Datum: 25.04.2012 08:43. M103 in den Fuses 
deaktiviert.

Vielen Dank!

Schulden dir ein Bier/Kaffee o.Ä ;)

[Stefan P. (form)]

daselmo schrieb:
>

> #define FOSC 7372000      //clock speed
>

Nicht wirklich dramatisch, aber es wird sich vermutlich um einen 7,3728 
MHz Quarz handeln. Also lieber auch die "8" noch hinschreiben.