Codevision Printf auf UART2 legen

[Mark (Gast)]

Hallo Forum,

ich suche nun schon seit einiger Zeit eine Lösung wie ich bei Codevision 
den Uart für Printf umlegen kann.. (Atmega128)

Kann mir da jemand weiterhelfen ?


Danke!
lg

[Hei (Gast)]

Irgendwann sollte man sich von solchen eierfressenden Wollmilchsaeuen 
loesen. Ueberleg dir was du uebertragen haben willst und uebertrag genau 
das und keine formatierten Strings.

[Seano L. (Gast)]

Muss es unbedingt printf sein? Je nach Implementierung ist das viel zu 
speicherhungrig und langsam, ich würde das nur verwenden wenn eigene 
komplexe Formatierungsroutinen zu aufwendig wären, im Normalfall macht 
man das 'von Hand' und kommt ohne printf aus.
Was machst du denn mit printf genau?

[Mark (Gast)]

Hallo,

ich möchte mehrere Float und Int ausgeben. Speicher ist egal da der MCU 
eh viel zu viel hat..


lg

[Karl H. (kbuchegg)]

Mark schrieb:
> Hallo,
>
> ich möchte mehrere Float und Int ausgeben. Speicher ist egal da der MCU
> eh viel zu viel hat..

Ja.
Und was hindert dich jetzt daran?

Letzten Endes musst du die UART Anbindung ja sowieso selber machen.
D.h. du hast eine Funktion, die einen String auf der UART 2 ausgeben 
kann.

Ob du die jetzt an printf hängst, oder ob du die Ausgabe mittels itoa 
oder ftoa zusammensetzt, ist Jacke wie Hose. Einziger Unterschied: du 
sparst dir den ganzen Unterbau, den printf benötigt bzw. das darunter 
liegende I/O system (ok, das ist auf einem AVR nicht die Welt).

Aber wenns unbedingt sein muss, kann man ja auch spritnf benutzen

   char buffer[40];

   sprintf( buffer, ".....", argumente );
   uart_writeString( buffer );

sprintf funktioniert wie printf. Also mit Format String und allem drum 
und drann. Nur dass es auf keinem Gerät ausgibt, sondern das Endprodukt 
als String in einen char Buffer schiebt. Mit diesem String kannst du 
dann machen was du willst. Zb auf einer UART ausgeben. Oder auf einem 
LCD. Oder per Infrarot LED zum Jupiter morsen. Oder ...

printf bzw. sprintf sind sehr mächtige Funktionen. Wenn du also nicht 
spezielle Formatierwünsche hast, dann lohnt sich das kaum. Dann fährt 
man mit itoa, ltoa, ftoa und Zusammensetzen der Einzelteile besser. Da 
schreibt man sich dann eben einmalig eine Funktion, die aus den 
interessierenden Werten die Ausgabe zusammensetzt und an die UART 
ausgibt, und gut ists.


Edit:
Mein Bauchgefühl sagt mir allerdings, dass es an den UART Funktionen 
krankt und du hoffst, dass man da eine Funktion aufruft oder so, und 
irgendwie funktioniert das dann so, dass printf auf der UART ausgibt.
Tja. Wenn das so ist, dann hast du mit Zitronen gehandelt. Ich hab zwar 
keine Ahnung, ob Codevision sowas wie fertige-UART Funktionen seinem 
Compiler beilegt, besser ist es aber wenn man versteht was man da tut. 
Denn spätestens bei der Fehlersuche (und die wird kommen) rächt sich 
Nichtwissen.

[Ste N. (steno)]

Nach kurzer Suche in der Doku gefunden, versuch es mal damit:


For the ATxmega chips the getchar and putchar functions use by default 
the USARTC0.
If you wish to use another USART, you must define the ATXMEGA_USART 
preprocessor macro prior to #include the stdio.h header file, like in 
the example below:

/* use the ATxmega128A1 USARTD0 for getchar and putchar functions */
#define _ATXMEGA_USART_ USARTD0

/* use the Standard C I/O functions */
#include <stdio.h>

The ATXMEGA_USART macro needs to be defined only once in the whole 
program, as the compiler will treat it like it is globally defined.


Eventuell gibt es sowas auch für

_ATMEGA_USART_

Ansonsten wieder laut Doku:

If you intend to use other peripherals for Input/Output, you must modify 
accordingly the getchar and putchar functions like in the example below:

#include <stdio.h>


/* inform the compiler that an alternate version
   of the getchar function will be used */
#define _ALTERNATE_GETCHAR_


/* now define the new getchar function */
char getchar(void) {
/* write your code here */


}


/* inform the compiler that an alternate version
   of the putchar function will be used */
#define _ALTERNATE_PUTCHAR_


/* now define the new putchar function */
void putchar(char c) {
/* write your code here */


}

Mann kann davon ausgehen, das printf() zur Zeichenausgabe putchar() 
aufruft. Dann müßte es etwa so gehen.

#define _ALTERNATE_PUTCHAR_

/* now define the new putchar function */
void putchar(char c)
{
  // putchar1 (c);  // Ausgabe auf UART1 umleiten
  putchar2 (c);  // Ausgabe auf UART2 umleiten
}