/* this file must exist, but can be empty */

template.ino

diagram.json

/*
1_06_pushbuttonBlink.ino
Task:
Two pushbuttons control one blinking LED.

Version 1.0:

Summary:
One LED is attached to pin PB6, and two pushbuttons to pins
PD2 and PD3. The LED is contantly blinking. How quickly the
LED flashes depends on which buttons are pressed:
	• If no button is pressed, the LED should alternate between
  on and off for 100ms, each.
	• When one of the two buttons is pressed, the LED should be
  alternately on for 500ms and off for 100ms.
	• If both buttons are pressed, the LED should alternate
  between on and off for 500ms, each.

Algorithm requirements:
	• use non-blocking time control
	• use boolean variables like "button1pressed" and
  "button2pressed", that carry the information whether a
  button is pressed (true or false), to control the
  corresponding time intervals "unsigned long intervalOn" and
  "unsigned long intervalOff".
	• use symbolic constants like "SHORT_INTERVAL" and
  "LONG_INTERVAL" to assign to the corresponding time
  intervals.
	• Use the latest commands from unit 3 of "GPIO manipulation"
  for setting, deleting and testing of pins.

  Version 1.1

Algorithm requirements:
	• Values 0, 1 or 2 assigned to a control variable "blinkMode" indicate whether no pushbutton, only one pushbutton, or both pushbuttons are pressed.
	• Control variable "ledOn" carrying the values 0 or 1 indicates whether the LED is switched on or off, respectively.
	• Twodimensional array "interval[3][2]" contains all the LED on- and off-time intervals for all three blinker modes. Use indices "blinkMode" and "ledOn" to obtain the respective time intervals.

*/
#define SHORT_INTERVAL 200 // in ms
#define  LONG_INTERVAL 600 // in ms

#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);

  // time variables
  uint32_t currentMillis, previousMillis = 0;
  uint32_t interval[3][2] = {
    {SHORT_INTERVAL, SHORT_INTERVAL},
    {SHORT_INTERVAL,  LONG_INTERVAL},
    { LONG_INTERVAL,  LONG_INTERVAL}
  };

  // control variables
  uint8_t mode;
  bool ledOn;
  bool btn1pressed, btn2pressed;

  // set PB6 as output ...
  DDRB |= (0x01 << 6);

  // ... and switch led on
  PORTB |= (0x01 << 6);
  ledOn = true;
  
  // set PD2 and PD3 as inputs ...
  DDRD &= ~((0x01 << 2) | (0x01 << 3));

  // ... and activate internal pullup resistors
  PORTD |= ((0x01 << 2) | (0x01 << 3));

  while (1)
  {
    // get button states
    btn1pressed = ((PIND >> 2) & 0x01) == 0x00;
    btn2pressed = ((PIND >> 3) & 0x01) == 0x00;

    // set blinker mode according to button states
    if (!btn1pressed && !btn2pressed)
    {
      mode = 0;
    }
    else if (btn1pressed && btn2pressed)
    {
      mode = 2;
    }
    else
    {
      mode = 1;
    }
    
    // get current time in ms
    currentMillis = millis();

    // print to serial monitor
    printf("%d\n", ledOn);

    // when respective time has passed ...
    if (currentMillis >= previousMillis + interval[mode][ledOn])
    {
      // toggle led and control variable
      if (ledOn)
      {
        PORTB &= ~(0x01 << 6);
        ledOn = false;
      }
      else
      {
        PORTB |= (0x01 << 6);
        ledOn = true;
      }
    
      // remember current millis
      previousMillis = currentMillis;
    }
  }
}

main.cpp

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries


libraries.txt

/*
    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
/**@}*/
