template.ino

diagram.json

#include <avr/io.h>
#include "./SystemClock.h"
#include "./USART.h"
 
int main()
{
  // start timer and count ms
  initTimer0AsSystemClock(true);
 
  // start serial communication
  USARTInit(0,9600,1,0,1,0);
 
  // set data direction of port F
  // pins 1, 2 and 6 as outputs
  DDRF |= (0x01<<6 | 0x01<<2 | 0x01<<1);
 
  // print to serial monitor
  printf("hello world!\n");  
 
  while (1)
  {
    // get current time in ms
    currentMillis = millis();
 
 
  }
}

main.cpp

/*
    SystemClock.cpp - Functions to initialize and use a system clock
    on AVR chips that is compatible with Arduino.

    Copyright (c) 2018 Wolfgang Zukrigl. Just added cosmetic changes to
    the code from Igor Mikolic-Torreiras from the AVRTools library

    Copyright (c) 2014 Igor Mikolic-Torreira.  All right reserved.

    Functions delayMicroseconds() and delayMilliseconds() adapted from
    Arduino code that is
    Copyright (c) 2005-2006 David A. Mellis and licensed under LGPL.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



#include "SystemClock.h"


#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>



// The prescaler is set so that timer0 ticks every 64 clock cycles, and the
// the overflow handler is called every 256 ticks.
#define kMicrosecondsPerOverflowTIMER0  ( (unsigned long) ( clockCyclesToMicroseconds( 64 * 256 ) ) )

// The whole number of milliseconds per timer0 overflow
#define kMillisInc ( (unsigned long) ( kMicrosecondsPerOverflowTIMER0 / 1000 ) )

// The fractional number of milliseconds per timer0 overflow. Shift right
// by three to fit these numbers into a byte (for 8 MHz, 12 MHz, and 16 MHz this doesn't lose precision).
#define kFractInc  ( (uint8_t) ( ( kMicrosecondsPerOverflowTIMER0 % 1000 ) >> 3 ) )
#define kFractMax  ( (uint8_t)  ( 1000 >> 3 ) )

// Variables to keep track of time
volatile uint32_t      timer0_overflow_count;
volatile uint32_t      timer0_millis;
uint8_t                timer0_fract;  //doesn't need volatile




ISR( TIMER0_OVF_vect )
{
    // Copy these to local variables so they can be stored in registers
    // (volatile variables must be read from memory on every access)
    uint32_t m = timer0_millis;
    uint8_t f = timer0_fract;

    m += kMillisInc;
    f += kFractInc;
    if ( f >= kFractMax )
    {
        f -= kFractMax;
        ++m;
    }

    timer0_fract = f;
    timer0_millis = m;
    timer0_overflow_count++;
}



uint32_t millis()
{
    // Disable interrupts while we read timer0_millis or we might get an
    // inconsistent value (e.g. in the middle of a write to timer0_millis)
    uint32_t m;

    ATOMIC_BLOCK( ATOMIC_RESTORESTATE )
    {
        m = timer0_millis;
    }

    return m;
}




uint32_t micros()
{
    // Disable interrupts to avoid reading inconsistent values
    uint32_t m;
    uint8_t t;

    ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) //Here, interrupts are disabled
    {
        m = timer0_overflow_count;
        t = TCNT0;

        //TCNT0 is still counting. Therefore check, if TCNT0 just had an overflow. If so, increase the
        //copy of timer0_overflow_count, because the interrupt-service-routine had not been executed yet, and has
        //not yet increased timer0_overflow_count.
        if ( ( TIFR0 & _BV(TOV0) ) && ( t < 255 ) )
        {
            m++;
        }
    }

    return ( (m << 8) + t ) * ( 64 / clockCyclesPerMicrosecond() );
}




void delayMilliseconds( uint32_t ms )
{
    uint16_t start = (uint16_t) micros();

    while ( ms > 0 )
    {
        if ( ( ((uint16_t) micros()) - start ) >= 1000 )
        {
            ms--;
            start += 1000;
        }
    }
}




// Delay for the given number of microseconds.  Assumes an 8 MHz, 12 MHz, or 16 MHz clock.
void delayMicroseconds( uint16_t us )
{
    // Code adapted from wiring.c, Copyright (c) 2005-2006 David A. Mellis

    // Calling avrlib's delay_us() function with low values (e.g. 1 or
    // 2 microseconds) gives delays longer than desired.
    // delay_us( us);

#if F_CPU == 16000000L

    // For the 16 MHz clock on most Arduino boards.

    // 16 cycles = 1 us

    // The overhead of the function call is 14 cycles for
    // constant delay, 16 for variable delay, which is 1us

    // For a one-microsecond delay, simply return

    // Takes 3 cycles if false, 4 cycles if true
    if ( us <= 1 )
    {
        return;
    }

    // The timing loop takes 1/4 of a microsecond (4 cycles) per iteration
    // So execute it four times for each microsecond of delay requested.

    // Multiply by 4; takes 4 cycles
    us <<= 2;

    // Account for the time taken in the preceeding commands.  We just
    // burned 21 (23) cycles above, plus 2 cycles for the adjustment below.
    // Total 23 (25) cycles, so remove 6 iterations, (6*4=24)
    // us is at least 8 so we can substract 6

    // Takes 2 cycles
    us -= 6;

#elif F_CPU == 12000000L

    // For the 12 MHz clock of the Adafruit Trinket and others.

    // 12 cycles - 1 us

    // The overhead of the function call is 14 (16) cycles, which is 1.5us

    // For a 1 microsecond delay, simply return

    // Takes 3 cycles if false, 4 cycles if true
    if ( us <= 1 )
    {
        return;
    }

    // The timing loop takes 1/3 of a microsecond (4 cycles) per iteration
    // So execute it three times for each microsecond of delay requested.

    // Multiply by 3 (actually by 2 and add again); takes 5 cycles
    us = (us << 1) + us;

    // Account for the time taken in the preceeding commands.  We just
    // burned 22 (24) cycles above, plus 2 cycles for the adjustment below.
    // Total 24 (26) cycles, so remove 6 iterations, (6*4=24)
    // us is at least 6 so at most we can substract 5 (us ==0 breaks the loop)
    // Close enough....

    // Takes 2 cycles
    us -= 5;

#elif F_CPU == 8000000L

    // For the 8 MHz internal clock on the ATmega168

    // 8 cycles = 1 us

    // The overhead of the function call is 14 (16) cycles, which is 2us

    // For a 1 or 2 microsecond delay, simply return

    // Takes 3 cycles if false, 4 cycles if true
    if ( us <= 2 )
    {
        return;
    }

    // The timing loop takes 1/2 of a microsecond (4 cycles) per iteration
    // So execute it twice for each microsecond of delay requested.

    // Multiply by 2; takes 2 cycles
    us <<= 1;

    // Account for the time taken in the preceeding commands.  We just
    // burned 19 (21) cycles above, plus 2 cycles for the adjustment below.
    // Total 21 (23) cycles, so remove 5 iterations, (5*4=20)
    // us is at least 6 so at most we can substract 5
    // Close enough....

    // Takes 2 cycles
    us -= 5;

#else

#error "delayMicroseconds() is only implemented for CPU speeds of 8 MHz, 12 MHz, or 16 MHz."

#endif

    // Busy wait
    __asm__ __volatile__
    (
        "1: sbiw %0,1" "\n\t" // 2 cycles
        "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
    );
}




void initTimer0AsSystemClock(uint8_t enableInterrupts)
{
    ATOMIC_BLOCK( ATOMIC_RESTORESTATE )
    {
        // Use Timer0 for the system clock, but configure it so it also supports
        // fast hardware pwm (using phase-correct PWM would mean that Timer0
        // overflowed half as often)

        TCCR0A = 0;     // Clear all settings
        TCCR0B = 0;     // Clear all settings
        TIMSK0 = 0;     // Disable all interrupts
        TCNT0  = 0;     // initialize counter value to 0

        TCCR0A |= (1 << WGM01) | (1 << WGM00);

        // set timer 0 prescale factor to 64
        TCCR0B |= (1 << CS01) | (1 << CS00);

        // enable timer 0 overflow interrupt
        TIMSK0 |= (1 << TOIE0);

        // Reset counters
        timer0_overflow_count = 0;
        timer0_millis = 0;
        timer0_fract = 0;
    }

    if (enableInterrupts)
        sei();
}



SystemClock.c

/*
    SystemClock.h - Functions to initialize and use a system clock
    on AVR chips that is compatible with Arduino.

    Copyright (c) 2018 Wolfgang Zukrigl. Just added cosmetic changes to
    the code from Igor Mikolic-Torreiras from the AVRTools library

    Copyright (c) 2014 Igor Mikolic-Torreira.  All right reserved.

    Functions delayMicroseconds() and delayMilliseconds() adapted from
    Arduino code that is
    Copyright (c) 2005-2006 David A. Mellis and licensed under LGPL.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



/*!
 * \file
 *
 * \brief Include this file to use the functions that instantiate and access a system clock
 * that counts elapsed milliseconds.
 *
 * To use these functions, include SystemClock.h in your source code and link against SystemClock.c.
 *
 * \note Linking against SystemClock.c installs a interrupt function on timer0.  This interrupt
 * routine is installed regardless of whether the system clock is actually initialized or not.
 * If you have other uses for timer0, do not use SystemClock functions and do not link against SystemClock.c.
 */



#ifndef SystemClock_h
#define SystemClock_h

#include <stdint.h>

#ifndef F_CPU
    #error "F_CPU must be defined, to use the SystemClock-Module"
#endif

#define clockCyclesPerMicrosecond()         ( F_CPU / 1000000L )
#define clockCyclesToMicroseconds( a )      ( (a) / clockCyclesPerMicrosecond() )
#define microsecondsToClockCycles( a )      ( (a) * clockCyclesPerMicrosecond() )

#ifdef __cplusplus
extern "C"{
#endif

/*!
 * \brief This function initializes a system clock that tracks elapsed milliseconds.
 *
 * The system clock uses timer0, so you cannot use timer0 for other functions if you
 * use the system clock functionality.
 *
 * \note Linking against SystemClock.c installs a interrupt function on timer0.  This interrupt
 * routine is installed regardless of whether the system clock is actually initialized or not.
 * If you have other uses for timer0, do not use SystemClock functions and do not link against SystemClock.c.
 *
 * @param enableInterrupts If 0, interrupts will not be globally enabled and must be enabled later
 *        by calling sei(). If not-zero, interrupts are globally enabled.
 */
void initTimer0AsSystemClock(uint8_t enableInterrupts);


/*!
 * \brief Delay a certain number of microseconds.
 * This function works independently of Timer0 (It is not necessary to call `initTimer0AsSystemClock()` before using
 * `delayMicroseconds`.
 *
 * \arg \c us the number of microseconds to delay.
 *
 * \note This function only works for CPU clocks running at either 8 MHz, 12 MHz, or 16 MHz.
 */
void delayMicroseconds(uint16_t us );


/*!
 * \brief Delay a certain number of milliseconds.
 * Note: initTimer0AsSystemClock() must have been called, and interrupts must be globally enabled
 * before using this function.
 *
 * \arg \c ms the number of milliseconds to delay.
 */
void delayMilliseconds( uint32_t ms );


/*!
 * \brief Delay a certain number of milliseconds.
 *
 * This inline function is a synonym for delayMilliseconds(); it is provided for
 * compatibility with the standard Arduino library.
 * Note: initTimer0AsSystemClock() must have been called, and interrupts must be globally enabled
 * before using this function.
 *
 * \arg \c ms the number of milliseconds to delay.
 *
 */

inline void delay( uint32_t ms )
{ delayMilliseconds( ms ); }


/*!
 * \brief Return the number of elapsed microseconds since the system clock was turned on using
 * `initTimer0AsSystemClock()` and globally enabling interrupts.
 *
 * The microsecond count will overflow back to zero after 2^32 microseconds, which is
 * approximately 70 minutes.
 *
 * \returns the number of elapsed microseconds.
 *
 */
uint32_t micros();


/*!
 * \brief Return the number of elasped milliseconds since the system clock was turned on using
 * `initTimer0AsSystemClock` and globally enabling interrupts.
 * The millisecond count will overflow back to zero after 2^32 milliseconds, which is
 * approximately 49 days.
 *
 * \returns the number of elapsed milliseconds.
 *
 */
uint32_t millis();

#ifdef __cplusplus
} // extern "C"
#endif

#endif


SystemClock.h

/***************************************************************************//**
Implementation file for USART on ATMEL-Controller with one or more uarts

@author LiTec/PAMG
@date 17.10.2012
@version 1.2

@param compiler switches: none
@param linker switches: none

@b History:
- 1.3 LiTec/ZUKW fixed compiler-warnings for AVRs with only one USART
- 1.2 LiTec/PAMG 17.10.2012 Enhancement: routines for scanf and _getkey.
- 1.1 LiTec/PAMG 20.09.2012 Enhancement of baudrates for ATMEGA2560.
- 1.0 LiTec/PAMG 02.01.2012 initial version.
*******************************************************************************/
/** @addtogroup USART_api
@{*/
/** @file USART.c Main source file for USART-Module. */
#include "USART.h"

#if defined (SCANF_ECHO)
static FILE mystdinout = FDEV_SETUP_STREAM(USARTPutChar, USARTGetChar, _FDEV_SETUP_RW);
#else
static FILE mystdinout = FDEV_SETUP_STREAM (USARTPutChar, USARTGetCharNoEcho, _FDEV_SETUP_RW);
#endif
uint8_t usart_stdio = 0;                // use USART0 as STDIO

/***************************************************************************//**
Function to set USART for STDIO
@param uart select one of the controllers USART (0 .. n see datasheet)
@retval - none
*******************************************************************************/
void USARTInitSTDIO (uint8_t uart) {

  if ( uart < 4) {
    usart_stdio = uart;
  } else {
    usart_stdio = 0;
  }
}

/***************************************************************************//**
Function for USART initialization
@param uart select one of the controllers USART (0 .. n see datasheet)
@param baud defines the baud-rate (depends on the CPU-clk)
@param rx_enable enables the USARTx-receiver
@param rx_int_enable enables the USARTx-RX-interrupt
@param tx_enable enables the USARTx-transmitter
@param tx_int_enable enables the USARTx-TX-interrupt
@retval - none
*******************************************************************************/
void USARTInit (uint8_t uart, uint32_t baud,
                uint8_t rx_enable, uint8_t rx_int_enable,
                uint8_t tx_enable, uint8_t tx_int_enable ) {

#ifndef F_CPU
  #warning "F_CPU undefined --> used in module USART.C"
#endif
  uint8_t ubrrh = 0;
  uint8_t ubrrl = 0;
  uint8_t doubleTransSpeed = 0;

  stdout = stdin = &mystdinout;

  switch ( F_CPU ) {
   case 4000000L :
     switch ( baud ) {
      case 19200 :
        ubrrl =12;                      // 19200 at 0.2% error see datasheet
        break;
      case 2400 :
        ubrrl =103;                     // 2400 at 0.2% error see datasheet
        break;
      default: // 9600
        ubrrl =25;                      // 9600 at 0.2% error see datasheet
        break;
     }
     break;

   case 7372800L :
     switch ( baud ) {
      case 115200 :
        ubrrl = 3;                      // 115200 at 0.0% error see datasheet
        break;
      case 19200 :
        ubrrl =23;                      // 19200 at 0.0% error see datasheet
        break;
      default: // 9600
        ubrrl =47;                      // 9600 at 0.0% error see datasheet
        break;
     }
     break;

   case 8000000L :
     switch ( baud ) {
      case 19200 :
        ubrrl =25;                       // 19200 at 0.2% error see datasheet
        break;
      case 2400 :
        ubrrl =207;                      // 2400 at 0.2% error see datasheet
        break;
      default: // 9600
        ubrrl =51;                       // 9600 at 0.2% error see datasheet
        break;
     }
     break;

   case 16000000L :
     switch ( baud ) {
      case 115200 : // 115200bps at 2.1% error see datasheet
        doubleTransSpeed = 1; ubrrl = 16; break;
      case 57600 : // 57600bps at -0.8% error see datasheet UBRR = 34
        doubleTransSpeed = 1; ubrrl = 34; break;
      case 38400 : // 38400bps at 0.2% error see datasheet UBRR = 51
        doubleTransSpeed = 1; ubrrl = 51; break;
      case 19200 : // 19200bps at 0.2% error see datasheet
        ubrrl = 51; break;
      case 4800 : // 4800bps at -0.1% error see datasheet UBRR = 416
        doubleTransSpeed = 1; ubrrl = 160; ubrrh = 1; break;
      case 2400 : // 2400bps at 0.0% error see datasheet UBRR = 832
        doubleTransSpeed = 1; ubrrl = 64; ubrrh = 3; break;
      case 1200 : // 2400bps at 0.0% error see datasheet UBRR = 1666
        doubleTransSpeed = 1; ubrrl = 130;  ubrrh = 6; break;
      default: // 9600bps at 0.2% error see datasheet
        ubrrl = 103; break;
     }
     break;

   default:   // missing or unknown F_CPU
     return;
     break;
  }

#if defined (__AVR_ATtiny2313__) || defined (__AVR_ATtiny26__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  UCSRA = 0x00;                      // !double Transmission Speed
  UBRRH = ubrrh; UBRRL = ubrrl;
  /* enable receiver and transmitter */
  UCSRB = ((rx_enable & 0x01) << RXEN) | ((rx_int_enable & 0x01) << RXCIE) |
          ((tx_enable & 0x01) << TXEN) | ((tx_int_enable & 0x01) << TXCIE);
  /* set frame format: 8data, 1stop bit, no parity */
  UCSRC = (1<<UCSZ1) | (1<<UCSZ0);
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__) || defined (__AVR_ATmega16__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  UCSRA = 0x00;                      // !double Transmission Speed
  UBRRH = ubrrh; UBRRL = ubrrl;
  /* enable receiver and transmitter */
  UCSRB = ((rx_enable & 0x01) << RXEN) | ((rx_int_enable & 0x01) << RXCIE) |
          ((tx_enable & 0x01) << TXEN) | ((tx_int_enable & 0x01) << TXCIE);
  /* set frame format: 8data, 1stop bit, no parity */
  UCSRC = (1<<URSEL) /*| (1<<USBS)*/ |(1<<UCSZ1) | (1<<UCSZ0);
#elif defined (__AVR_ATmega328P__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  if ( doubleTransSpeed ) UCSR0A |= (1<<U2X0); // double Transmission Speed
  else                    UCSR0A = 0x00;
  UBRR0H = ubrrh; UBRR0L = ubrrl;
  UCSR0B = ((rx_enable & 0x01)<<RXEN0) | ((rx_int_enable & 0x01)<<RXCIE0) |
           ((tx_enable & 0x01)<<TXEN0) | ((tx_int_enable & 0x01)<<TXCIE0);
  UCSR0C=0x06;       // 8 Databit see datasheet    
#elif defined (__AVR_ATmega2560__)
  /* enable receiver and transmitter */
  /* set frame format: 8data, 1stop bit, no parity */
  switch ( uart ) {
    case 0 :
      if ( doubleTransSpeed ) UCSR0A |= (1<<U2X0); // double Transmission Speed
      else                    UCSR0A = 0x00;
      UBRR0H = ubrrh; UBRR0L = ubrrl;
      UCSR0B = ((rx_enable & 0x01)<<RXEN0) | ((rx_int_enable & 0x01)<<RXCIE0) |
               ((tx_enable & 0x01)<<TXEN0) | ((tx_int_enable & 0x01)<<TXCIE0);
      UCSR0C=0x06;       // 8 Databit see datasheet
      break;
    case 1 :
      if ( doubleTransSpeed ) UCSR1A |= (1<<U2X1); // double Transmission Speed
      else                    UCSR1A = 0x00;
      UBRR1H = ubrrh; UBRR1L = ubrrl;
      UCSR1B = ((rx_enable & 0x01)<<RXEN1) | ((rx_int_enable & 0x01)<<RXCIE1) |
               ((tx_enable & 0x01)<<TXEN1) | ((tx_int_enable & 0x01)<<TXCIE1);
      UCSR1C=0x06;       // 8 Databit see datasheet
      break;
    case 2 :
      if ( doubleTransSpeed ) UCSR2A |= (1<<U2X2); // double Transmission Speed
      else                    UCSR2A = 0x00;
      UBRR2H = ubrrh; UBRR2L = ubrrl;
      UCSR2B = ((rx_enable & 0x01)<<RXEN2) | ((rx_int_enable & 0x01)<<RXCIE2) |
               ((tx_enable & 0x01)<<TXEN2) | ((tx_int_enable & 0x01)<<TXCIE2);
      UCSR2C=0x06;       // 8 Databit see datasheet
      break;
    case 3 :
      if ( doubleTransSpeed ) UCSR3A |= (1<<U2X3); // double Transmission Speed
      else                    UCSR3A = 0x00;
      UBRR3H = ubrrh; UBRR3L = ubrrl;
      UCSR3B = ((rx_enable & 0x01)<<RXEN3) | ((rx_int_enable & 0x01)<<RXCIE3) |
               ((tx_enable & 0x01)<<TXEN3) | ((tx_int_enable & 0x01)<<TXCIE3);
      UCSR3C=0x06;       // 8 Databit see datasheet
      break;
    default: break;
  }
#else
  #error "MCU unknown"
#endif
} // USART_init

/***************************************************************************//**
Function for sending a character via USART
@param uart select one of the controllers USART (0 .. n see datasheet)
@param data data to be transmitted
@retval - none
*******************************************************************************/
void USARTTransmit (uint8_t uart, char data ) {
#if defined (__AVR_ATmega2560__)
  switch ( uart ) {
   case 0 : while ( !(UCSR0A & (1<<UDRE0))) { }  // wait for old data sended
            UDR0 = data;  break;
   case 1 : while ( !(UCSR1A & (1<<UDRE1))) { }  // wait for old data sended
            UDR1 = data;  break;
   case 2 : while ( !(UCSR2A & (1<<UDRE2))) { }  // wait for old data sended
            UDR2 = data; break;
   case 3 : while ( !(UCSR3A & (1<<UDRE3))) { }  // wait for old data sended
            UDR3 = data;  break;
   default: break;
  }
#elif defined (__AVR_ATmega328P__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  while ( !(UCSR0A & (1<<UDRE0))) { }  // wait for old data sended
  UDR0 = data;
#else // only one uart
  while ( !(UCSRA & (1<<UDRE))) { } // wait for old data sended
  UDR = data;
#endif
} // USARTTransmit

/***************************************************************************//**
Function for receiving a character via USART
@param uart select one of the controllers USART (0 .. n see datasheet)
@retval received_character
*******************************************************************************/
char USARTReceive (uint8_t uart ) {
#if defined (__AVR_ATmega2560__)
  switch ( uart ) {
   case 0 : while ( !(UCSR0A & (1<<RXC0))) { } // wait for data
            return UDR0;  break;
   case 1 : while ( !(UCSR1A & (1<<RXC1))) { } // wait for data
            return UDR1;  break;
   case 2 : while ( !(UCSR2A & (1<<RXC2))) { } // wait for data
            return UDR2;  break;
   case 3 : while ( !(UCSR3A & (1<<RXC3))) { } // wait for data
            return UDR3;  break;
   default: return 0; break;
  }
#elif defined (__AVR_ATmega328P__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  while ( !(UCSR0A & (1<<RXC0))) { } // wait for data
  return UDR0;
#else                                   // only one uart
  while ( !(UCSRA & (1<<RXC))) { }      // wait for data
  return UDR;
#endif
} // USARTReceive

/***************************************************************************//**
Function for testing if char received
@param uart select one of the controllers USART (0 .. n see datasheet)
@retval 1 .. char received, 0 .. no char received
*******************************************************************************/
char USARTCharReceived (uint8_t uart ) {
	#if defined (__AVR_ATmega2560__)
	switch ( uart ) {
	case 0 : return (UCSR0A & (1<<RXC0)); break;
	case 1 : return (UCSR1A & (1<<RXC1)); break;
	case 2 : return (UCSR2A & (1<<RXC2)); break;
	case 3 : return (UCSR3A & (1<<RXC3)); break;
    default: return 0; break;
  }
#elif defined (__AVR_ATmega328P__)
  (void) uart;  // this microcontroller only has one uart, avoid compiler-warnings
  return (UCSR0A & (1<<RXC0));
#else                                   // only one uart
  return (UCSRA & (1<<RXC));
#endif
} // USARTReceive

/***************************************************************************//**
Function for sending data via standard USART by printf
@param c character to be sent
@param *stream outputstream
@retval c (sended char), expected by printf
*******************************************************************************/
int16_t USARTPutChar(char c, FILE *stream) {
#if defined (__AVR_ATmega2560__)        // stdio sends by USART0
  switch ( usart_stdio) {
    case 3 :
      if (c == '\n') USARTPutChar('\r', stream);
      loop_until_bit_is_set(UCSR3A, UDRE3);
      UDR3 = c;
      break;
    case 2 :
      if (c == '\n') USARTPutChar('\r', stream);
      loop_until_bit_is_set(UCSR2A, UDRE2);
      UDR2 = c;
      break;
    case 1 :
      if (c == '\n') USARTPutChar('\r', stream);
      loop_until_bit_is_set(UCSR1A, UDRE1);
      UDR1 = c;
      break;
    default:
      if (c == '\n') USARTPutChar('\r', stream);
      loop_until_bit_is_set(UCSR0A, UDRE0);
      UDR0 = c;
      break;
  }
  return c;
#elif defined (__AVR_ATmega328P__)
  if (c == '\n') USARTPutChar('\r', stream);
  loop_until_bit_is_set(UCSR0A, UDRE0);
  UDR0 = c;
  return c;
#else
  if (c == '\n') USARTPutChar('\r', stream);
  loop_until_bit_is_set(UCSRA, UDRE);
  UDR = c;
  return c;
#endif
} // USARTPutChar

/***************************************************************************//**
Function for receiving data from standard USART by scanf with echo
@param *stream outputstream for echo
@retval received character
*******************************************************************************/
int16_t USARTGetChar(FILE *stream) {
#if defined (__AVR_ATmega2560__)        // stdio sends by USART0
  switch ( usart_stdio) {
    case 3 :
      while (!(UCSR3A & (1<<RXC3)));
      return (int16_t)(USARTPutChar(UDR3, stream)); // echo;
    break;
    case 2 :
      while (!(UCSR2A & (1<<RXC2)));
      return (int16_t)(USARTPutChar(UDR2, stream)); // echo;
    break;
    case 1 :
      while (!(UCSR1A & (1<<RXC1)));
      return (int16_t)(USARTPutChar(UDR1, stream)); // echo;
    break;
    default:
      while (!(UCSR0A & (1<<RXC0)));
      return (int16_t)(USARTPutChar(UDR0, stream)); // echo;
      break;
  }
#elif defined (__AVR_ATmega328P__)
  while (!(UCSR0A & (1<<RXC0)));
  return (int16_t)(USARTPutChar(UDR0, stream)); // echo;
#endif
} // USARTGetChar

/***************************************************************************//**
Function for receiving data from standard USART by scanf without echo
@retval received character
*******************************************************************************/
int16_t USARTGetCharNoEcho(  ) {
#if defined (__AVR_ATmega2560__)        // stdio sends by USART0
  switch ( usart_stdio) {
    case 3 :
      while (!(UCSR3A & (1<<RXC3)));
      return UDR3;
    break;
    case 2 :
      while (!(UCSR2A & (1<<RXC2)));
      return UDR2;
    break;
    case 1 :
      while (!(UCSR1A & (1<<RXC1)));
      return UDR1;
    break;
    default:
      while (!(UCSR0A & (1<<RXC0)));
      return UDR0;
      break;
  }
#elif defined (__AVR_ATmega328P__)
  while (!(UCSR0A & (1<<RXC0)));
  return UDR0;
#endif
} // USARTGetChar

/***************************************************************************//**
_getkey for compatibility KEIL
*******************************************************************************/
char _getkey ( void ) {
#if defined (__AVR_ATmega2560__)        // stdio sends by USART0
switch ( usart_stdio) {
	case 3 :
	  while (!(UCSR3A & (1<<RXC3)));
	  return UDR3;
	  break;
	case 2 :
	  while (!(UCSR2A & (1<<RXC2)));
	  return UDR2;
	  break;
	case 1 :
	  while (!(UCSR1A & (1<<RXC1)));
  	return UDR1;
	  break;
	default:
	  while (!(UCSR0A & (1<<RXC0)));
	  return UDR0;
	  break;
  }
#elif defined (__AVR_ATmega328P__)
  while (!(UCSR0A & (1<<RXC0))) { /*empty*/ }
	return UDR0;
#endif
}
/**@}*/


USART.c

/***************************************************************************//**
Interface file for USART on ATMEL-Controller with one or more uarts
*******************************************************************************/
/** @addtogroup USART_api
@{*/
/** @file USART.h Interface file for USART-Module. */
#ifndef  USART_H
#define  USART_H

#include <stdio.h>
#include <avr/io.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C"{
#endif

void    USARTInit (uint8_t uart, uint32_t baud,
                  uint8_t rx_enable, uint8_t rx_int_enable,
                  uint8_t tx_enable, uint8_t tx_int_enable);
void    USARTInitSTDIO (uint8_t uart);           // define STDIO (USART0 - 3)
void    USARTTransmit (uint8_t uart, char data); // simple USART-Transmit
char    USARTReceive  (uint8_t uart );           // simple USART-Receive
char    USARTCharReceived (uint8_t uart );       // test for char received
int16_t USARTPutChar  (char c, FILE *stream);    // put_char for printf
int16_t USARTGetChar (FILE *stream);             // get_char with echo for scanf
int16_t USARTGetCharNoEcho ( );             // get_char without echo
char    _getkey ( void );                        // get_char without echo

#ifdef __cplusplus
} // extern "C"
#endif

#endif // USART_H
/**@}*/
