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

[ePyx]

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.

[ra.graf1988]

Ist das schon mal besser?

 
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...

[ePyx]

 
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.

[ra.graf1988]

hm ich hab das jetzt mal so probiert, aber es kommt nichts zurück.

[ePyx]

Aber du hast die Interrupts aktiviert und die Übertragung via Interrupt funktioniert auch?

[ra.graf1988]

Ja sollte alles funktionieren. Das ist mein Code:

/*### Includes ###*/#include <avr/io.h>
#include <stdlib.h>
#include <string.h>
#include "BTControlled_v1.0.h"
#include "uart.h"

/*############### ISR ###########################*/

// Empfangene Zeichen werden in die Eingangs-FIFO gespeichert und warten dort
ISR (USART_RXC_vect)
{
    _inline_fifo_put (&infifo, UDR);
}

// Ein Zeichen aus der Ausgabe-FIFO lesen und ausgeben
// Ist das Zeichen fertig ausgegeben, wird ein neuer SIG_UART_DATA-IRQ getriggert
// Ist die FIFO leer, deaktiviert die ISR ihren eigenen IRQ.
ISR (USART_UDRE_vect)
{
    if (outfifo.count > 0)
       UDR = _inline_fifo_get (&outfifo);
    else
        UCSRB &= ~(1 << UDRIE);
}


/*############## Main ############################*/

int main(void)
{
    /*##########Initialisierungsphase############*/

    //Pins bzw. Ports als Ein-/Ausgänge konfigurieren
    DDRA |= 0x00;    //00000000 -> alle Analogports als Eingänge
    DDRB |= 0x03;    //00000011 -> PORTB.0 und PORTB.1 sind Kanäle des rechten Motors
    DDRC |= 0xFF;    //11111111 -> PORTC.6 und PORTC.7 sind Kanäle des linken Motors, Rest sind LEDs für Lauflicht
    DDRD |= 0xB0;    //10110000 -> PORTD.4 ist PWM-Kanal des linken Motors, PORTD.5 des rechten

    setportcon(0); setportcon(1); setportcon(2); setportcon(3); setportcon(4); setportcon(5); //LEDs ausschalten
    setportdoff(7);    //Speaker aus
    init_timer1();    //Initialisierung Timer für PWM


    uart_init();    //UART initialisieren
    sei();

    char text[] = "Hallo Welt.";
    char text2[40] = "23";

    uart_puts (text);

     /*##############Hauptschleife###########*/
    while(1)
    {


        if(infifo.count == 6)
        {
            char ch;
            while(infifo.count > 0);
            {
                ch = fifo_get_wait(&infifo);
                uart_putc(ch);
            }
        }
    }




    return 0;
}

Nach dem Reset wird auch vom µC auf den PC übertragen:

Hallo Welt.\0x00

dann sende ich an den µC vom PC aus z.B. 1234567
aber es kommt nichts zurück

[ePyx]

Initialisierst du das FIFO nicht ?

fifo_init (&fifo, buffer, BUF_SIZE);