uart in .c und .h File auslagern

[Hain (Gast)]

Hallo,

ich habe ein Problem mit der "Vordefenition" von

static int8_t uart_getchar(FILE *STREAM)
{
  while (!(UCSR0A & (1 << RXC0)));
  return (UDR0);
}

So geht es leider nicht.

//Empfaengt 1 Byte vom UART
static int8_t uart_getchar(FILE);

Fehlermeldung:
Warning  3  'uart_getchar' defined but not used [-Wunused-function]
Error  1  conflicting types for 'uart_getchar'
Message  2  previous declaration of 'uart_getchar' was here

/* main.c */
//#include <string.h>
//#include <stdlib.h>
//#include <stdio.h>
//#include <ctype.h>
#include <avr/io.h>

//Initialisierung und die Funktionen uart_putchar und art_getchar
#include "uart.h"

//Eintrag von uart_putchar und uart_getchar als 
//Standard IO
FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);
  
int main(void)
{ 
  //Initialisierung (aus serial2.h) aufrufen 
  uart_init(F_CPU, BAUD);        
  
  //Elementare IO Funktionen als Standard IO eintragen
  stdout = stdin = &mystdout;  
  
  printf("\r\nHello World!");
  while (1)
  {
  // ...
  }
}

/* uart.h */

#define F_CPU 16000000UL
#define BAUD  11000

//#include <string.h>
//#include <stdlib.h>
#include <stdio.h>  // FILE
//#include <ctype.h>
#include <avr/io.h>

//Initialisiert UART gegebener Oszillatorfrequenz und Baudrate
void uart_init(uint32_t, uint32_t);

//Sendet 1 Byte an UART
int8_t uart_putchar(char, FILE*);

//Empfaengt 1 Byte vom UART
static int8_t uart_getchar(FILE);

/* uart.c */

#include "uart.h"

void uart_init(uint32_t Oszi, uint32_t Baud)
{
  if ((Oszi / 16L / Baud - 1) > 30)
  {
    UBRR0L = (unsigned char)(Oszi /16L / Baud - 1);
    UBRR0H = (unsigned char)((Oszi / 16L / Baud - 1) >> 8);
    UCSR0A = 0;
  }
  else
  {
    //Falls Teilerwert zu klein => Rundungsfehler
    //Daher doppelte Rate waehlen
    UBRR0L = (unsigned char)(Oszi / 8L / Baud - 1);
    UBRR0H = (unsigned char)((Oszi / 8L / Baud - 1) >> 8);
    UCSR0A = (1 << U2X0);
  }
  
  UCSR0B = UCSR0B | (1 << TXEN0) | (1 << RXEN0);
  UCSR0C = UCSR0C | (1 << UMSEL01) | (1 << UCSZ01) |
  (1 << UCSZ00);
}

//Sendet 1 Byte an UART
int8_t uart_putchar(char data, FILE* stream)
{
  while (!(UCSR0A & (1 << UDRE0)));
  UDR0 = (char)data;
  return 0;
}

//Empfaengt 1 Byte vom UART
static int8_t uart_getchar(FILE *STREAM)
{
  while (!(UCSR0A & (1 << RXC0)));
  return (UDR0);
}

[Stefan R. (srand)]

Dann lies mal etwas aufmerksamer!

FILE und FILE* sind nunmal unterschiedliche Typen.

[Peter II (Gast)]

Hain schrieb:
> So geht es leider nicht.//Empfaengt 1 Byte vom UART
> static int8_t uart_getchar(FILE);

http://de.wikibooks.org/wiki/C-Programmierung:_static_%26_Co.
[...]
Auch vor Funktionen sowie Variablen außerhalb von Funktionen kann das 
Schlüsselwort static stehen. Das bedeutet, dass auf die 
Funktion/Variable nur in der Datei, in der sie steht, zugegriffen werden 
kann.
[...]

static ist das was du nicht brauchst.

[Hain (Gast)]

//Empfaengt 1 Byte vom UART
int8_t uart_getchar(FILE *);

//Empfaengt 1 Byte vom UART
int8_t uart_getchar(FILE *STREAM)
{
  while (!(UCSR0A & (1 << RXC0)));
  return (UDR0);
}

Geht nun!

[Karl H. (kbuchegg)]

Hain schrieb:
> //Empfaengt 1 Byte vom UART
> int8_t uart_getchar(FILE *);

tu dir selbst einen Gefallen und schreib beim Protoypen auch den Namen 
der Argumentvariable dazu. C erlaubt dir das extra und ausdrücklich.

OK, in diesem konkreten Fall ist das vielleicht nicht so wichtig, weil 
aus dem Zusammenhang klar ist, was wohl dieses FILE* Argument sein wird. 
Aber das ist nicht immer so.
In

double calcBruttoPreis( double, double );

ist da jetzt das erste Argument der Nettopreis und das zweite Argument 
der Steuersatz oder ist es genau umgekehrt? Ist da überhaupt ein 
Steuersatz involviert? Und wenn ja, wie wird er angegeben?
Wohingegen bei

double calcBruttoPreis( double NettoPreis, double SteuerProzent );

alles klar ist.

Es ist unklug, seine Möglichkeiten nicht auszuschöpfen! Gerade das 
Erstellen eines Protoypen geht recht einfach:
Man nimmt aus dem C File den Funktionsheader in den Copy&Paste Speicher, 
wechselt ins Header File, setzt dort die Zeile ein, löscht einen 
eventuellen { der je nach Schreibweise in derselben Zeile sitzen könnte 
und hängt einen ; an. Fertig. Das dauert keine 10 Sekunden. Es gibt 
keinen Grund da noch lange an der Argumentliste rumzueditieren.