Probleme mit fdevopen

[T.v.B. (Gast)]

Hallo,

ich versuche gerafe mit printf und scanf Zeichen über meinen Uart zu
senden und zu empfangen. Ich habe dazu folgenden Sourcecode wieder
ausgegraben.

#include <stdio.h>
#include <stdlib.h>
#include <avr/io.h>
#include <string.h>
#include <avr/interrupt.h>
#include <avr/signal.h>

static int  UART_SendByte(char Data_c);
static int  UART_ReceiveByte(void);
static void UART_Init(void);

#define UART_CPU               16000000     /* 16MHz */
#define UART_BAUD_RATE         19200       /* baud rate*/
#define UART_BAUD_SELECT       (UART_CPU/(UART_BAUD_RATE*16l)-1)

unsigned char   UART_Ready_uc;
unsigned char   UART_ReceivedChar_uc;
unsigned char   UART_RxChar_uc;


int main(void )
{
    char c;
    UART_Init();            
    c = UART_ReceiveByte(); /*funktioniert*/
    UART_SendByte(c);       /*funktioniert*/
    fdevopen(UART_SendByte,UART_ReceiveByte,0);
    printf("Hello, world!\n"); /*funktioniert nicht*/

    scanf("%c", &c); /*funktioniert nicht*/
    printf("%c",c);  /*funktioniert nicht*/
    while(1);

}

void UART_Init(void)
{
    UART_Ready_uc        = 1;
    UART_ReceivedChar_uc = 0;
    UCSR0B |= _BV(RXCIE)|_BV(TXCIE)|_BV(RXEN)|_BV(TXEN);
    UBRR0L |= UART_BAUD_SELECT;
    sei();
}

int UART_SendByte(char Data)
{
    while (!UART_Ready_uc || (PINE & _BV(PE2)));
    UART_Ready_uc = 0;
    UDR0 = Data;
    return 0;
}

int UART_ReceiveByte(void)
{
    while (!UART_ReceivedChar_uc);
    UART_ReceivedChar_uc = 0;
    return UART_RxChar_uc;
}


SIGNAL(SIG_UART0_RECV)
{
    UART_ReceivedChar_uc = 1;
    UART_RxChar_uc = UDR0;
}

SIGNAL(SIG_UART0_TRANS)
{
    UART_Ready_uc = 1;
}

Ich hatte vor einiger Zeit schon mal mit diesen Sourcen gearbeitet. Da
hatte es einwandfrei funktioniert .

Das Problem ist folgendes:

Die Funktionen zum senden und emfpangen funktionieren (UART_ReceiveByte
und UART_SendByte). Versuche ich aber mit fdevopen die printf oder die
scanf Funktion zu benutzen tut sich gar nichts auf dem UART.

Ich habe einen Atmega128 und einen JTAGICE + AVR Studio 4.12 zum
debuggen. Kompiliert habe ich das Ganze mit WinAVR-20040720.

Ich habe mal einen Haltepunkt in die UART_SendByte Funktion gesetzt und
dann versucht einen String mit printf auszugeben. Eigentlich hätte er
auf dem Haltepunkt landen sollen, tat er aber nicht.

Was mache ich falsch? So schwer kann das doch nicht sein!
Bin ziemlich ratlos und für jede Hilfe dankbar.

Vielen Dank schonmal
Gruß T.v.B.

[Wolfgang Horn (Gast)]

Hi, Leidgeplagter von Leidensgenossem,

würde ich Dein Listing hier durchlesen und finden, was wegen Änderung
an AVRGCC nicht mehr funktioniert, dann hättest Du bald die nächste
Frage und ich die nächste Arbeit.

Selbst ist der Mann.
Lies die stdio.h, aber Wort für Wort.
Und lies das libc_User Manual.

Ciao
Wolfgang Horn

[T.v.B. (Gast)]

Hi Wolfgang,

habe mir die stdio.h angesehen und wüsste nicht was ich da falsch
gemacht haben könnte. Ich habe das Ganze inzwischen mit der aktuellen
GCC-Version übersetzt. Da hat es genauso wenig funktioniert.

Und ja, da ist der Aufruf von fdevopen etwas anders:

fdevopen(UART_SendByte,UART_ReceiveByte)

Das ist doch richtig, oder? Zumindest entnehme ich das so dem Manual

Und eine kleine Bemerkung am Rande.
Das beantworten von Fragen in Foren ist freiwillig.
Zu sagen: "würde ich Dein Listing hier durchlesen und finden, was
wegen Änderung an AVRGCC nicht mehr funktioniert, dann hättest Du bald
die nächste Frage und ich die nächste Arbeit"
Naja, ich sag mal so, das hilft mir nicht weiter. Zumindest sollte man
sich das Listing durchlesen bevor man antwortet. (imo)

Ich habe irgendwo in meinem Programm einen Fehler gemacht, ich finde
ihn aber nicht. Ich habe das fm gelesen, ich finde den Fehler immer
noch nicht. Wer etwas weiß, bitte melden.

Nichts für ungut
T.v.B.

[Jörg W. (dl8dtl) (Moderator)]

> Und ja, da ist der Aufruf von fdevopen etwas anders:
> ...
> Das ist doch richtig, oder?

Im Prinzip ja.  Aber die Funktionen bekommen nun auch noch ihren FILE
* als zweites Argument durchgereicht, welches du zur Vermeidung von
Compilerwarnungen dann bei dir als Dummy mit aufnehmen solltest.

Ansonsten denke ich, dass dein Problem darin besteht, dass du die in
den ISRs gesetzten Flag-Variablen nicht als "volatile" deklariert
hast.  Damit wird der Compiler den Zugriff auf diese in Schleifen wie:

while (!UART_ReceivedChar_uc);

aus der Schleife heraus optimieren, da sich nach seiner Einschätzung
am Wert von UART_ReceivedChar_uc innerhalb der Schleife ja nichts mehr
ändern kann.  Das ist übrigens die FAQ #1 in der avr-libc-Doku...

Apropos ISR: die solltest du jetzt schreiben als:

ISR(USART0_TX_vect) ...
ISR(USART0_RX_vect) ...

Bei interruptgesteuertem Versenden bietet es sich übrigens an, statt
USART0_TX_vect besser USART0_UDRE_vect zu benutzen: damit wird der
Interrupt bereits ausgelöst, wenn wieder Platz in Datenpuffer-Register
ist, sodass ein Versenden der Zeichen ,,Rücken an Rücken'' möglich
wird.  Das Handling ist aber geringfügig komplizierter, da man dann
zwischen ,,es sind gar keine Zeichen mehr zu versenden'' (UDRE-
Interrupt muss ausgeschaltet werden) und dem Sendebetrieb
unterscheiden muss.

[T.v.B. (Gast)]

Hi Jörg,

das mit dem volatile ist mir im Nachhinein auch aufgefallen, aber auch
das war nicht das eigentliche Problem. Die Ursache liegt ja scheinbar
eine Ebene höher. Das Progamm sollte zumindest nach einem printf in der
UART_SendByte Funktion landen, egal was in dieser drin steht bzw. ob
diese richtig funktioniert. Laut Debugger ist das aber nicht der Fall.

Naja, ich werde das Problem erstmal ein bis zwei Nächte überschlafen um
mich diesem dann mit frischer Kraft und neuem Mut nochmal zu stellen.
;-)
(Man sollte meinen an der Stelle kann man nicht so viel falsch machen,
aber irgendwie habe ich es wohl trotzdem geschafft :-)

Trotdem vielen Dank für die Hilfe
Gruß T.v.B.

[Günter R. (galileo14)]

Hallo, T.v.B.,

versuch's doch mal so, wie ich's im Dateianhang üblicherweise mache
(kannst dann leicht an Deine Bedürfnisse anpassen).

printf würde ich nicht verwenden, sondern in Deinem Fall fprintf bzw.
die ganzen "f"-Funktionen, weil man da das Ausgabe-Device steuern
kann.

Viele Grüße
Günter

[T.v.B. (Gast)]

@Günter R.

Yep, funktioniert!
Besten Dank also!

Bleibt halt immer noch immer noch die Frage warum meine Version nicht
funktioniert hat.
Naja, für den Moment ist es mir egal, werde mir bei Gelegenheit das
Problem noch mal zur Brust nehmen.
Zunächst reicht mir dieser "Workaround" jedoch völlig aus!

Nochmal Vielen Dank
Gruß T.v.B.

[Bernt (Gast)]

Gleiches Problem:
Mit fdevopen bewirkt einen Reset,
aber mit fdev_setup_stream funktioniert es!

Hauptsache es gibt immer noch eine funktionierende
Methode ;-)

Bernt

[Jörg W. (dl8dtl) (Moderator)]

> Mit fdevopen bewirkt einen Reset,

Klingt nach einem Problem mit malloc() dann.  Möglicherweise bist
du bereits an der RAM-Auslastungsgrenze dran.

[Bernt (Gast)]

Tja,des Rätsels Lösung war Mega103-Kompatibilitäts-Fuse.

[Jörg W. (dl8dtl) (Moderator)]

Bernt wrote:

> Tja,des Rätsels Lösung war Mega103-Kompatibilitäts-Fuse.

Wenn du irgendwo mal die Stichworte ATmega64 oder ATmega128 hättest
fallen gelassen, wäre ich da vielleicht auch drauf gekommen.