Difference between revisions of "Uart.c"

Latest revision as of 16:03, 27 October 2016

Dieses Beispiel zeigt die Nutzung der seriellen Schnittstelle. Bei dieses Diesem Beispiel werden Fließkommeberechnungen vorgenommen. Deswgen muss nutlibcrtf gelinkt werden.

<source lang="c">

1. include <cfg/crt.h> /* Floating point configuration. */

1. include <string.h>
2. include <stdio.h>
3. include <io.h>

1. include <dev/board.h>
2. include <sys/timer.h>

static char *banner = "\nNut/OS UART Sample\n"; static prog_char presskey_P[] = "Press any key..."; static prog_char pgm_ptr[] = "\nHello stranger!\n";

static char inbuf[128];

/*

* UART sample.
*
* Some functions do not work with ICCAVR.
*/

int main(void) {

   int got;
   int i;
   char *cp;
   u_long baud = 115200;
   FILE *uart;

1. ifdef STDIO_FLOATING_POINT

   float dval = 0.0;

1. endif

   /*
    * Each device must be registered. We do this by referencing the 
    * device structure of the driver. The advantage is, that only 
    * those device drivers are included in our flash code, which we 
    * really need.
    *
    * The uart0 device is the first one on the ATmega chip. So it 
    * has no configurable base address or interrupt and we set both 
    * parameters to zero.
    */
   NutRegisterDevice(&DEV_UART, 0, 0);

   /*
    * Now, as the device is registered, we can open it. The fopen()
    * function returns a pointer to a FILE structure, which we use 
    * for subsequent reading and writing.
    */
   uart = fopen(DEV_UART_NAME, "r+");

   /*
    * Before doing the first read or write, we set the baudrate.
    * This low level function doesn't know about FILE structures
    * and we use _fileno() to get the low level file descriptor
    * of the stream.
    *
    * The short sleep allows the UART to settle after the baudrate
    * change.
    */
   _ioctl(_fileno(uart), UART_SETSPEED, &baud);

   /*
    * Stream devices can use low level read and write functions. 
    * Writing program space data is supported too.
    */
   _write(_fileno(uart), banner, strlen(banner));
   {
       _write_P(_fileno(uart), presskey_P, sizeof(presskey_P));
   }

   /*
    * Stream devices do buffered I/O. That means, nothing will be 
    * passed to the hardware device until either the output buffer 
    * is full or we do a flush. With stream I/O we typically use
    * fflush(), but low level writing a null pointer will also flush 
    * the output buffer.
    */
   _write(_fileno(uart), 0, 0);

   /*
    * The low level function read() will grab all available bytes 
    * from the input buffer. If the buffer is empty, the call will
    * block until something is available for reading.
    */
   got = _read(_fileno(uart), inbuf, sizeof(inbuf));
   _write(_fileno(uart), inbuf, got);

   /*
    * Nut/OS never expects a thread to return. So we enter an 
    * endless loop here.
    */
   for (i = 0;; i++) {
       /*
        * A bit more advanced input routine is able to read a string 
        * up to and including the first newline character or until a
        * specified maximum number of characters, whichever comes first.
        */
       fputs("\nEnter your name: ", uart);
       fflush(uart);
       fgets(inbuf, sizeof(inbuf), uart);

       /*
        * Chop off trailing linefeed.
        */
       cp = strchr(inbuf, '\n');
       if (cp)
           *cp = 0;

       /*
        * Streams support formatted output as well as printing strings 
        * from program space.
        */
       if (inbuf[0])
           fprintf(uart, "\nHello %s!\n", inbuf);
       else {
           fputs_P(pgm_ptr, uart);
       }

       /*
        * Just to demonstrate formatted floating point output.
        * In order to use this, we need to link the application
        * with nutcrtf instead of nutcrt for pure integer.
        */

1. ifdef STDIO_FLOATING_POINT

       dval += 1.0125;
       fprintf(uart, "FP %f\n", dval);

1. endif

   }

} </source> uart.c Copyright by egnite Software GmbH