-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 16

Thema: UART avr-gcc, \0x00 zu viel am Ende

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    29.08.2010
    Beiträge
    33

    UART avr-gcc, \0x00 zu viel am Ende

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    Hallo zusammen!
    Ich habe ein Problem mit dem UART meines RNControl1.4 oder besser gesagt mit der Programmierung.

    Mit diesem Wiki Artikel bin ich schon sehr weit gekommen.
    http://www.rn-wissen.de/index.php?ti...cc&redirect=no
    Die Kommunikation ohne Interrupts funktioniert einwandfrei.

    Jetzt habe ich das ganze mit Interrupts probiert, und habe folgendes Problem.
    Ich will wie unter:
    http://www.rn-wissen.de/index.php?ti..._String_senden
    einen String vom µC zum PC senden. Der kommt auch an, leider kommt noch ein \0x00 hinten nach also:

    Hallo Welt.
    \0x00

    Habt ihr eine Vorahnung, an was das liegen könnte, oder muss ich meinen gesamten Code posten?

    Gruß

    Rainer

  2. #2
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Ich denke an der do while schleife. Denn der Vergleich mit 0x00 wird erst zum Schluß durchgeführt.

    Code:
    while ( *str ) 
    {
        uart_send_char ( *str );
        str++;
    }
    Macht das Gleiche nur, dass der Vergleich im Schleifenkopf stattfindet und damit vor der Übertragung. Des Weiteren werden Strings immer mit einem 0x00 terminiert.
    Grüße,
    Daniel

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    29.08.2010
    Beiträge
    33
    Ok verstanden. Das ist also gewollt, dass die 0x00 am Ende kommt.
    Könnte mir noch jemand einen Tipp geben, wie ich ein einfaches Echo für einen String mit den Funktionen aus dem oben genannten Artikel erstelle?
    Die Funktion uart_getc_wait() und uart_getc_nowait() geben ja nur einen Integer Wert aus... Wie komme ich jetzt da auf einen String?

  4. #4
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Zitat Zitat von ra.graf1988 Beitrag anzeigen
    Die Funktion uart_getc_wait() und uart_getc_nowait() geben ja nur einen Integer Wert aus...
    Warum sollte das so sein? uint8_t ist das bis auf das Vorzeichen (und damit auch dem Wertebereich) das Gleiche wie ein char. Im Grunde wird so oder so immer nur ein Byte, also ein Zeichen zwischen 0x00 und 0xFF übertragen. Ein Zeichen wird durch die Interpretation daraus (http://www.torsten-horn.de/techdocs/ascii.htm). Bis auf die ersten 30 und die Zeichen größer 127 funzt das ohne Probleme als Echo.
    Grüße,
    Daniel

  5. #5
    Benutzer Stammmitglied
    Registriert seit
    29.08.2010
    Beiträge
    33
    ach ja, ok
    Wenn ich jetzt

    Code:
    uart_putc(uart_getc_wait());
    in meiner Hauptschleife ausführe bekomme ich mein Echo durch einzelne Character.
    Aber jetzt wird ja jeder Charakter, wenn er ankommt gleich wieder zurück geschickt.

    Wie kann ich denn jetzt die einzelnen Charakter, die ankommen zusammensetzen?
    Das mit den Strings in C leuchtet mir noch nicht so ganz ein.

    Code:
    char text2[40] = "";        
    char x;
    
    do
            {
                x= uart_getc_wait();
                strcat(text2,x);
            }
    while(x!=-1);
    
    uart_puts(text2);
    Das funktioniert auch nicht so ganz...
    Geändert von ra.graf1988 (24.07.2012 um 16:22 Uhr)

  6. #6
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Naja du musst die Zeichen natürlich puffern. Entweder in einem Array oder in einem FIFO (ist eigentlich auch nichts anderes, halt ein Array mit Features). Im Beispiel im Wiki werden ja auch FIFOs benutzt.

    Einfach ausgedrückt :
    1. Array anlegen
    2. Ein empfangenes Zeichen in das Array kopieren
    3. Die Position im Array hochzählen

    Allerdings würde ich das Ganze dann in der ISR der USART machen und nicht irgendwo in einem Programm.
    Grüße,
    Daniel

  7. #7
    Benutzer Stammmitglied
    Registriert seit
    29.08.2010
    Beiträge
    33
    ok, wenn ich die fifo schon dabei hab, dann nutze ich es doch aus:
    Code:
    ISR (USART_RXC_vect){
        _inline_fifo_put (&infifo, UDR);
    
    
    }
    Code:
    char text[] = "Hallo Welt.";    char text2[40] = "";
        uint8_t x =0;
    
    
        uart_puts (text);
    
    
         /*##############Hauptschleife###########*/
        while(1)
        {
             x =0;
            do
            {
                text2[x]= uart_getc_wait();
                x++;
            }
            while(x==5);
    
    
            uart_puts(text2);
        }
    
    
    
    
        return 0;
    }
    Ich hab mir gedacht ich sende jetzt einfach mal 6 Zeichen. "123456"
    Aber nun bekomme ich zurück:
    1\0x002\0x003\0x004\0x005\0x006\0x00
    \0x00
    reiht meine do-while-schleife nicht alle Zeichen aneinander?

    außerdem kann ich auch nur 1 Zeichen schicken: "1"
    dann kommt zurück:
    1\0x00
    aber er sollte doch warten bis 6 Zeichen kommen....

  8. #8
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Zitat Zitat von ra.graf1988 Beitrag anzeigen
    Ich hab mir gedacht ich sende jetzt einfach mal 6 Zeichen. "123456"
    Auch wenn das etwas drastisch klingt, sehr weit hast du dabei nicht gedacht.

    Ich würde die Zeichen aus dem FIFO ausgeben und nicht das aktuelle Zeichen was gerade ankommt. Des Weiteren, schmeißt du jedes Zeichen direkt wieder auf den UART, wenn du die Ausgabe abhängig von der Anzahl der Bytes im FIFO machst, wird wohl eher ein Schuh draus.
    Grüße,
    Daniel

  9. #9
    Benutzer Stammmitglied
    Registriert seit
    29.08.2010
    Beiträge
    33
    Ist das schon mal besser?
    Code:
     
    ISR (USART_RXC_vect)
    {
        _inline_fifo_put (&infifo, UDR);
    
    
    }
    
    
    
    char text2[40] = "23";
    uint8_t x =0;
    
    
         /*##############Hauptschleife###########*/
        while(1)
        {
            if(infifo.count > 0)
            {
                x =0;
                while(infifo.count > 0);
                {
                    text2[x]= _inline_fifo_get(&infifo);
                    x++;
                }
                uart_puts(text2);
            }
        }
    
    
    
    
        return 0;
    }
    Ich frage ab, ob was in der infifo ist, wenn nein, soll er einen neuen Hauptschleifendurchlauf machen.
    Wenn ja, so lange bis die infifo leer ist, die charakter in den String text2 packen
    Wenn die infifo nun leer ist, dann wird vom µC an den PC gesendet....

    Das sind meine Überlegungen, leider tut sich nichts.

    Danke schon mal für deine Geduld...

  10. #10
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Code:
     
    ISR (USART_RXC_vect)
    {
        _inline_fifo_put (&infifo, UDR);
     }
    
    
    
    char text2[40] = "23";
    uint8_t x =0;
    
    
         /*##############Hauptschleife###########*/
        while(1)
        {
            // Nach 6  Zeichen wird der Inhalt des FIFOs zurückgeschickt.
            if(infifo.count == 6)
            {
                char ch;
                while(infifo.count > 0);
                {
                     ch = fifo_get_wait (&infifo);
    uart_putc(ch);  
                 }
            }
        }
    
    
    
    
        return 0;
    }
    Probiere es mal so.
    Grüße,
    Daniel

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. l6208+schrittmotor zieht viel zu viel Strom
    Von michiE im Forum Elektronik
    Antworten: 6
    Letzter Beitrag: 22.09.2011, 20:09
  2. AVR Studio 4.17 - WARNING: FLASH byte address 0x0000 is 0x00
    Von Jeypee im Forum C - Programmierung (GCC u.a.)
    Antworten: 2
    Letzter Beitrag: 30.09.2009, 00:00
  3. Grad zu doof für ATMega32 UART (Sendet nur 0x00)
    Von Jaecko im Forum C - Programmierung (GCC u.a.)
    Antworten: 3
    Letzter Beitrag: 01.03.2009, 18:44
  4. Ende des Strings beim UART ?
    Von guenter1604 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 19
    Letzter Beitrag: 02.08.2007, 11:41
  5. UArt "verschluckt" beim Senden den Wert 0x00 ( AT9
    Von LotharM im Forum Assembler-Programmierung
    Antworten: 1
    Letzter Beitrag: 02.12.2006, 12:24

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •