Added 01_m1284p_bb00_minimum project

01_m1284p_bb00_minimum/main.c

@@ -0,0 +1,336 @@
+/*
+ * main.c
+ *
+ *  Created on: 22 нояб. 2018 г.
+ *      Author: maxx
+ */
+#include <avr/io.h>
+#include <util/delay.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <compat/deprecated.h>  //sbi, cbi etc..
+#include "avr/wdt.h" // WatchDog
+#include <stdio.h>  // printf etc..
+#include "uart_extd.h"
+
+//#include <stdlib.h> // itoa etc..
+
+#define PRINTF_EN 1
+#if PRINTF_EN
+#define PRINTF(FORMAT,args...) printf_P(PSTR(FORMAT),##args)
+#else
+#define PRINTF(...)
+#endif
+
+/*
+ * m1284p minimum template, with one button & one led
+ */
+
+//M644P/M1284p Users LEDS:
+//LED1/PORTC.4- m644p/m1284p maxxir
+#define led1_conf()      DDRC |= (1<<DDC4)
+#define led1_high()      PORTC |= (1<<PORTC4)
+#define led1_low()       PORTC &= ~(1<<PORTC4)
+#define led1_tgl()     PORTC ^= (1<<PORTC4)
+#define led1_read()     (PORTC & (1<<PORTC4))
+
+#define sw1_conf()      {DDRC &= ~(1<<DDC5); PORTC |= (1<<PORTC5);}
+#define sw1_read()     (PINC & (1<<PINC5))
+
+//*********Global vars
+#define TICK_PER_SEC 1000UL
+volatile unsigned long _millis; // for millis tick !! Overflow every ~49.7 days
+
+//*********Program metrics
+const char compile_date[] PROGMEM    = __DATE__;     // Mmm dd yyyy - Дата компиляции
+const char compile_time[] PROGMEM    = __TIME__;     // hh:mm:ss - Время компиляции
+const char str_prog_name[] PROGMEM   = "\r\nAtMega1284p v1.2 Base Template 22/11/2018\r\n"; // Program name
+
+#if defined(__AVR_ATmega128__)
+const char PROGMEM str_mcu[] = "ATmega128"; //CPU is m128
+#elif defined (__AVR_ATmega2560__)
+const char PROGMEM str_mcu[] = "ATmega2560"; //CPU is m2560
+#elif defined (__AVR_ATmega2561__)
+const char PROGMEM str_mcu[] = "ATmega2561"; //CPU is m2561
+#elif defined (__AVR_ATmega328P__)
+const char PROGMEM str_mcu[] = "ATmega328P"; //CPU is m328p
+#elif defined (__AVR_ATmega32U4__)
+const char PROGMEM str_mcu[] = "ATmega32u4"; //CPU is m32u4
+#elif defined (__AVR_ATmega644P__)
+const char PROGMEM str_mcu[] = "ATmega644p"; //CPU is m644p
+#elif defined (__AVR_ATmega1284P__)
+const char PROGMEM str_mcu[] = "ATmega1284p"; //CPU is m1284p
+#else
+const char PROGMEM str_mcu[] = "Unknown CPU"; //CPU is unknown
+#endif
+
+
+//FUNC headers
+static void avr_init(void);
+void timer0_init(void);
+static inline unsigned long millis(void);
+
+// RAM Memory usage test
+static int freeRam (void)
+{
+	extern int __heap_start, *__brkval;
+	int v;
+	int _res = (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
+	return _res;
+}
+
+
+//******************* MILLIS ENGINE: BEGIN
+//ISR (TIMER0_COMP_vect )
+ISR (TIMER0_COMPA_vect)
+{
+	// Compare match Timer0
+	// Here every 1ms
+	_millis++; // INC millis tick
+	// Тест мигаем при в ходе в прерывание
+	// 500Hz FREQ OUT
+	// LED_TGL;
+}
+
+static inline unsigned long millis(void)
+{
+	unsigned long i;
+	cli();
+	// Atomic tick reading
+	i = _millis;
+	sei();
+	return i;
+}
+//******************* MILLIS ENGINE: END
+
+//***************** UART0: BEGIN
+// Assign I/O stream to UART
+/* define CPU frequency in Mhz here if not defined in Makefile */
+//#ifndef F_CPU
+//#define F_CPU 16000000UL
+//#endif
+
+/* 19200 baud */
+#define UART_BAUD_RATE      19200
+//#define UART_BAUD_RATE      38400
+
+static int uart0_putchar(char ch,FILE *stream);
+static void uart0_rx_flash(void);
+
+static FILE uart0_stdout = FDEV_SETUP_STREAM(uart0_putchar, NULL, _FDEV_SETUP_WRITE);
+//PS. stdin не переназначаю, т.к. удобнее с ним работать через uart.h - api:
+
+/*
+ * Т.е. например так
+        c = uart1_getc();
+        if (( c & UART_NO_DATA ) == 0)
+        {
+           uart1_putc( (unsigned char)c );
+        }
+ При этом чекаем что буфер приема не пуст и опрос идет неблокирующий (+ работаем через UART RX RINGBUFFER),
+ а если работаем в стиле stdin->getchar() там опрос блокируется пока символ не будет принят (поллинг)
+ через UART1_RX, т.е. неудобно.
+*/
+
+// STDOUT UART0 TX handler
+static int uart0_putchar(char ch,FILE *stream)
+{
+	uart_putc(ch);
+	return 0;
+}
+
+// Очищаем буфер приема UART1 RX (иногда нужно)
+static void uart0_rx_flash(void)
+{
+	// Считываем все из ring-buffer UART1 RX
+	unsigned int c;
+	do
+	{
+		c = uart_getc();
+	} while (( c & UART_NO_DATA ) == 0); // Check RX1 none-empty
+
+}
+//***************** UART0: END
+
+//***************** ADC: BEGIN
+
+#ifndef ADC_DIV
+//12.5MHz or over use this ADC reference clock
+#define ADC_DIV (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0) //:128 ADC Prescaler
+#endif
+
+#ifndef ADC_REF
+// vcc voltage ref default
+#define ADC_REF (1<<REFS0)
+#endif
+
+void adc_init(void)
+{
+	ADCSRA = 0;
+	ADCSRA |= (ADC_DIV);    // ADC reference clock
+	ADMUX |= (ADC_REF);     // Voltage reference
+	ADCSRA |= (1<<ADEN);    // Turn on ADC
+	ADCSRA |= (1<<ADSC);    // Do an initial conversion because this one is the
+	                        // slowest and to ensure that everything is up
+							// and running
+}
+
+uint16_t adc_read(uint8_t channel)
+{
+	ADMUX &= 0b11100000;                    //Clear the older channel that was read
+	ADMUX |= channel;                //Defines the new ADC channel to be read
+	ADCSRA |= (1<<ADSC);                //Starts a new conversion
+	while(ADCSRA & (1<<ADSC));            //Wait until the conversion is done
+
+	return ADCW;                    //Returns the ADC value of the chosen channel
+}
+//***************** ADC: END
+
+int main()
+{
+	uint8_t prev_sw1 = 1; // VAR for sw1 pressing detect
+
+	// INIT MCU
+	avr_init();
+
+	// Print program metrics
+	PRINTF("%S", str_prog_name);// Название программы
+	PRINTF("Compiled at: %S %S\r\n", compile_time, compile_date);// Время Дата компиляции
+	PRINTF(">> MCU is: %S; CLK is: %luHz\r\n", str_mcu, F_CPU);// MCU Name && FREQ
+	PRINTF(">> Free RAM is: %d bytes\r\n", freeRam());
+
+	//Short Blink LED 3 times on startup
+	unsigned char i = 3;
+	while(i--)
+	{
+		led1_high();
+		_delay_ms(100);
+		led1_low();
+		_delay_ms(400);
+		wdt_reset();
+	}
+
+    unsigned long prev_millis = 0;
+    unsigned long rx_millis = 0;
+	unsigned long uptime = 0;
+   	uint16_t CharIn;
+	while(1)
+	{
+		//Here at least every 1sec
+		wdt_reset(); // WDT reset at least every sec
+		if((millis()-prev_millis)>TICK_PER_SEC)
+		{
+			//Here every 1sec
+			wdt_reset(); // WDT reset at least every sec
+			prev_millis = millis();
+			led1_tgl();
+			PRINTF("Uptime %lu sec\r\n", uptime++);
+			//PRINTF("ADC5: %d\r\n", adc_read(5));
+
+
+			//!! SW1 pressing action
+			if(!sw1_read())// Check for SW1 pressed every second
+			{
+				// SW1 is pressed
+				//led1_high(); //LED1 ON
+				if(prev_sw1)
+				{
+					//!! Здесь по факту нажатия кнопки (1->0 SW1)
+					//!! Debug only
+					PRINTF("SW1 is pressed\r\nADC0/PA0 is: %u\r\n", adc_read(0));
+					//PRINTF("SW1 is pressed\r\n");
+				}//if(prev_sw1)
+				prev_sw1 = 0; // Store SW1 state for next iteration
+			}//if(!sw1_read())
+			else
+			{
+				// SW1 is unpressed
+				//led1_low(); // LED1 OFF
+				prev_sw1 = 1;// Store SW1 state for next iteration
+			}//if(!sw1_read())else..
+		}//if((millis()-prev_millis)>TICK_PER_SEC)
+
+		if((millis()-rx_millis)>0)
+		{
+			// Here every 1 msec, to check UART RX
+			rx_millis = millis();
+
+			// GET UART RX Symbol
+		    CharIn = uart_getc();
+
+			// Check if char exist
+			// Read until data in RX buffer present
+			while (( CharIn & UART_NO_DATA ) == 0)
+			{
+				wdt_reset(); // WDT reset at least every sec
+				//!! Debug only
+				//Read data from UART0 RX ring buffer & send back echo
+				uart_putc(CharIn+1);
+				// GET UART RX Symbol
+			    CharIn = uart_getc();
+			}
+		}//if((millis()-rx_millis)>0)
+	}
+	return 0;
+}
+
+// Timer0
+// 1ms IRQ
+// Used for millis() timing
+void timer0_init(void)
+{
+	/*
+	 *
+	 * For M128
+	TCCR0 = (1<<CS02)|(1<<WGM01); //TIMER0 SET-UP: CTC MODE & PS 1:64
+	OCR0 = 249; // 1ms reach for clear (16mz:64=>250kHz:250-=>1kHz)
+	TIMSK |= 1<<OCIE0;	 //IRQ on TIMER0 output compare
+	*/
+	//For M664p
+	TCCR0A = (1<<WGM01); //TIMER0 SET-UP: CTC MODE
+	TCCR0B = (1<<CS01)|(1<<CS00); // PS 1:64
+	OCR0A = 249; // 1ms reach for clear (16mz:64=>250kHz:250-=>1kHz)
+	TIMSK0 |= 1<<OCIE0A;	 //IRQ on TIMER0 output compareA
+}
+
+static void avr_init(void)
+{
+    // Initialize device here.
+	// WatchDog INIT
+	wdt_enable(WDTO_2S);  // set up wdt reset interval 2 second
+	wdt_reset(); // wdt reset ~ every <2000ms
+
+	timer0_init();// Timer0 millis engine init
+
+	// Initial UART Peripheral
+    /*
+     *  Initialize uart11 library, pass baudrate and AVR cpu clock
+     *  with the macro
+     *  uart1_BAUD_SELECT() (normal speed mode )
+     *  or
+     *  uart1_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode)
+     */
+	// Define Output/Input Stream
+#if	(UART_BAUD_RATE == 115200)
+	uart_init( UART_BAUD_SELECT_DOUBLE_SPEED(UART_BAUD_RATE,F_CPU) ); // To works without error on 115200 bps/F_CPU=16Mhz
+#else
+	uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
+#endif
+    stdout = &uart0_stdout;
+
+	//ADC init
+	adc_init();
+	adc_read(0); //Dummy read
+
+
+	led1_conf();
+	led1_low();// LED1 is OFF
+
+
+	sw1_conf();//SW1 internal pull-up
+
+	sei(); //re-enable global interrupts
+
+    return;
+}
+

01_m1284p_bb00_minimum/uart_extd.c

@@ -0,0 +1,706 @@
+/*
+ * Modified  for different BUFFER_SIZE for UART0 && UART1
+ * see below: UART0_RX_BUFFER_SIZE/UART1_RX_BUFFER_SIZE && UART0_TX_BUFFER_SIZE/UART1_TX_BUFFER_SIZE
+ * Ibragimov M. 7/03/2015
+*/
+/*************************************************************************
+Title:    Interrupt UART library with receive/transmit circular buffers
+Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
+File:     $Id: uart.c,v 1.12 2014/01/08 21:58:12 peter Exp $
+Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
+Hardware: any AVR with built-in UART, 
+License:  GNU General Public License 
+          
+DESCRIPTION:
+    An interrupt is generated when the UART has finished transmitting or
+    receiving a byte. The interrupt handling routines use circular buffers
+    for buffering received and transmitted data.
+    
+    The UART0[1]_RX_BUFFER_SIZE and UART0[1]_TX_BUFFER_SIZE variables define
+    the buffer size in bytes. Note that these variables must be a 
+    power of 2.
+    
+USAGE:
+    Refere to the header file uart.h for a description of the routines. 
+    See also example test_uart.c.
+
+NOTES:
+    Based on Atmel Application Note AVR306
+                    
+LICENSE:
+    Copyright (C) 2006 Peter Fleury
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    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 General Public License for more details.
+                        
+*************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include "uart_extd.h"
+
+
+/*
+ *  constants and macros
+ */
+
+/* size of RX0/TX0 buffers */
+#define UART0_RX_BUFFER_MASK ( UART0_RX_BUFFER_SIZE - 1)
+#define UART0_TX_BUFFER_MASK ( UART0_TX_BUFFER_SIZE - 1)
+
+#if ( UART0_RX_BUFFER_SIZE & UART0_RX_BUFFER_MASK )
+#error RX0 buffer size is not a power of 2
+#endif
+#if ( UART0_TX_BUFFER_SIZE & UART0_TX_BUFFER_MASK )
+#error TX0 buffer size is not a power of 2
+#endif
+
+/* size of RX1/TX1 buffers */
+#define UART1_RX_BUFFER_MASK ( UART1_RX_BUFFER_SIZE - 1)
+#define UART1_TX_BUFFER_MASK ( UART1_TX_BUFFER_SIZE - 1)
+
+#if ( UART1_RX_BUFFER_SIZE & UART1_RX_BUFFER_MASK )
+#error RX1 buffer size is not a power of 2
+#endif
+#if ( UART1_TX_BUFFER_SIZE & UART1_TX_BUFFER_MASK )
+#error TX1 buffer size is not a power of 2
+#endif
+
+
+#if defined(__AVR_AT90S2313__) \
+ || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \
+ || defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__) \
+ || defined(__AVR_ATmega103__)
+ /* old AVR classic or ATmega103 with one UART */
+ #define AT90_UART
+ #define UART0_RECEIVE_INTERRUPT   UART_RX_vect 
+ #define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+ #define UART0_STATUS   USR
+ #define UART0_CONTROL  UCR
+ #define UART0_DATA     UDR  
+ #define UART0_UDRIE    UDRIE
+#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
+ /* old AVR classic with one UART */
+ #define AT90_UART
+ #define UART0_RECEIVE_INTERRUPT   UART_RX_vect 
+ #define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR 
+ #define UART0_UDRIE    UDRIE
+#elif  defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \
+  || defined(__AVR_ATmega323__)
+  /* ATmega with one USART */
+ #define ATMEGA_USART
+ #define UART0_RECEIVE_INTERRUPT   USART_RXC_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR
+ #define UART0_UDRIE    UDRIE
+#elif defined (__AVR_ATmega8515__) || defined(__AVR_ATmega8535__)
+ #define ATMEGA_USART
+ #define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR
+ #define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega163__)
+  /* ATmega163 with one UART */
+ #define ATMEGA_UART
+ #define UART0_RECEIVE_INTERRUPT   UART_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR
+ #define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega162__) 
+ /* ATmega with two USART */
+ #define ATMEGA_USART0
+ #define ATMEGA_USART1
+ #define UART0_RECEIVE_INTERRUPT   USART0_RXC_vect
+ #define UART1_RECEIVE_INTERRUPT   USART1_RXC_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+ #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+ #define UART0_STATUS   UCSR0A
+ #define UART0_CONTROL  UCSR0B
+ #define UART0_DATA     UDR0
+ #define UART0_UDRIE    UDRIE0
+ #define UART1_STATUS   UCSR1A
+ #define UART1_CONTROL  UCSR1B
+ #define UART1_DATA     UDR1
+ #define UART1_UDRIE    UDRIE1
+#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) 
+ /* ATmega with two USART */
+ #define ATMEGA_USART0
+ #define ATMEGA_USART1
+ #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+ #define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+ #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+ #define UART0_STATUS   UCSR0A
+ #define UART0_CONTROL  UCSR0B
+ #define UART0_DATA     UDR0
+ #define UART0_UDRIE    UDRIE0
+ #define UART1_STATUS   UCSR1A
+ #define UART1_CONTROL  UCSR1B
+ #define UART1_DATA     UDR1
+ #define UART1_UDRIE    UDRIE1
+#elif defined(__AVR_ATmega161__)
+ /* ATmega with UART */
+ #error "AVR ATmega161 currently not supported by this libaray !"
+#elif defined(__AVR_ATmega169__) 
+ /* ATmega with one USART */
+ #define ATMEGA_USART
+ #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR
+ #define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__) \
+ || defined(__AVR_ATmega3250__) || defined(__AVR_ATmega3290__) ||defined(__AVR_ATmega6450__) || defined(__AVR_ATmega6490__)
+ /* ATmega with one USART */
+ #define ATMEGA_USART0
+ #define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+ #define UART0_STATUS   UCSR0A
+ #define UART0_CONTROL  UCSR0B
+ #define UART0_DATA     UDR0
+ #define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATtiny2313__) 
+ #define ATMEGA_USART
+ #define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+ #define UART0_STATUS   UCSRA
+ #define UART0_CONTROL  UCSRB
+ #define UART0_DATA     UDR
+ #define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega329__) || \
+      defined(__AVR_ATmega649__) || \
+      defined(__AVR_ATmega325__) || \
+      defined(__AVR_ATmega645__) 
+  /* ATmega with one USART */
+  #define ATMEGA_USART0
+  #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+  #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+  #define UART0_STATUS   UCSR0A
+  #define UART0_CONTROL  UCSR0B
+  #define UART0_DATA     UDR0
+  #define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1280__)  || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega640__)
+/* ATmega with two USART */
+  #define ATMEGA_USART0
+  #define ATMEGA_USART1
+  #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+  #define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+  #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+  #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+  #define UART0_STATUS   UCSR0A
+  #define UART0_CONTROL  UCSR0B
+  #define UART0_DATA     UDR0
+  #define UART0_UDRIE    UDRIE0
+  #define UART1_STATUS   UCSR1A
+  #define UART1_CONTROL  UCSR1B
+  #define UART1_DATA     UDR1
+  #define UART1_UDRIE    UDRIE1  
+#elif defined(__AVR_ATmega644__)
+ /* ATmega with one USART */
+ #define ATMEGA_USART0
+ #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+ #define UART0_STATUS   UCSR0A
+ #define UART0_CONTROL  UCSR0B
+ #define UART0_DATA     UDR0
+ #define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
+ /* ATmega with two USART */
+ #define ATMEGA_USART0
+ #define ATMEGA_USART1
+ #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+ #define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+ #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+ #define UART0_STATUS   UCSR0A
+ #define UART0_CONTROL  UCSR0B
+ #define UART0_DATA     UDR0
+ #define UART0_UDRIE    UDRIE0
+ #define UART1_STATUS   UCSR1A
+ #define UART1_CONTROL  UCSR1B
+ #define UART1_DATA     UDR1
+ #define UART1_UDRIE    UDRIE1
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1287__)
+ /* AT90USBxx with one USART */
+ #define AT90USB_USART
+ #define UART0_RECEIVE_INTERRUPT   USART1_RX_vect
+ #define UART0_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+ #define UART0_STATUS   UCSR1A
+ #define UART0_CONTROL  UCSR1B
+ #define UART0_DATA     UDR1
+ #define UART0_UDRIE    UDRIE1
+#else
+ #error "no UART definition for MCU available"
+#endif
+
+
+/*
+ *  module global variables
+ */
+static volatile unsigned char UART_TxBuf[UART0_TX_BUFFER_SIZE];
+static volatile unsigned char UART_RxBuf[UART0_RX_BUFFER_SIZE];
+static volatile unsigned char UART_TxHead;
+static volatile unsigned char UART_TxTail;
+static volatile unsigned char UART_RxHead;
+static volatile unsigned char UART_RxTail;
+static volatile unsigned char UART_LastRxError;
+
+#if defined( ATMEGA_USART1 )
+static volatile unsigned char UART1_TxBuf[UART1_TX_BUFFER_SIZE];
+static volatile unsigned char UART1_RxBuf[UART1_RX_BUFFER_SIZE];
+static volatile unsigned char UART1_TxHead;
+static volatile unsigned char UART1_TxTail;
+static volatile unsigned char UART1_RxHead;
+static volatile unsigned char UART1_RxTail;
+static volatile unsigned char UART1_LastRxError;
+#endif
+
+
+
+ISR (UART0_RECEIVE_INTERRUPT)	
+/*************************************************************************
+Function: UART Receive Complete interrupt
+Purpose:  called when the UART has received a character
+**************************************************************************/
+{
+    unsigned char tmphead;
+    unsigned char data;
+    unsigned char usr;
+    unsigned char lastRxError;
+ 
+ 
+    /* read UART status register and UART data register */ 
+    usr  = UART0_STATUS;
+    data = UART0_DATA;
+    
+    /* */
+#if defined( AT90_UART )
+    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
+#elif defined( ATMEGA_USART )
+    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
+#elif defined( ATMEGA_USART0 )
+    lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) );
+#elif defined ( ATMEGA_UART )
+    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
+#elif defined( AT90USB_USART )
+    lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
+#endif
+        
+    /* calculate buffer index */ 
+    tmphead = ( UART_RxHead + 1) & UART0_RX_BUFFER_MASK;
+    
+    if ( tmphead == UART_RxTail ) {
+        /* error: receive buffer overflow */
+        lastRxError = UART_BUFFER_OVERFLOW >> 8;
+    }else{
+        /* store new index */
+        UART_RxHead = tmphead;
+        /* store received data in buffer */
+        UART_RxBuf[tmphead] = data;
+    }
+    UART_LastRxError |= lastRxError;   
+}
+
+
+ISR (UART0_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART Data Register Empty interrupt
+Purpose:  called when the UART is ready to transmit the next byte
+**************************************************************************/
+{
+    unsigned char tmptail;
+
+    
+    if ( UART_TxHead != UART_TxTail) {
+        /* calculate and store new buffer index */
+        tmptail = (UART_TxTail + 1) & UART0_TX_BUFFER_MASK;
+        UART_TxTail = tmptail;
+        /* get one byte from buffer and write it to UART */
+        UART0_DATA = UART_TxBuf[tmptail];  /* start transmission */
+    }else{
+        /* tx buffer empty, disable UDRE interrupt */
+        UART0_CONTROL &= ~_BV(UART0_UDRIE);
+    }
+}
+
+
+/*************************************************************************
+Function: uart_init()
+Purpose:  initialize UART and set baudrate
+Input:    baudrate using macro UART_BAUD_SELECT()
+Returns:  none
+**************************************************************************/
+void uart_init(unsigned int baudrate)
+{
+    UART_TxHead = 0;
+    UART_TxTail = 0;
+    UART_RxHead = 0;
+    UART_RxTail = 0;
+    
+#if defined( AT90_UART )
+    /* set baud rate */
+    UBRR = (unsigned char)baudrate; 
+
+    /* enable UART receiver and transmmitter and receive complete interrupt */
+    UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);
+
+#elif defined (ATMEGA_USART)
+    /* Set baud rate */
+    if ( baudrate & 0x8000 )
+    {
+    	 UART0_STATUS = (1<<U2X);  //Enable 2x speed 
+    	 baudrate &= ~0x8000;
+    }
+    UBRRH = (unsigned char)(baudrate>>8);
+    UBRRL = (unsigned char) baudrate;
+   
+    /* Enable USART receiver and transmitter and receive complete interrupt */
+    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
+    
+    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
+    #ifdef URSEL
+    UCSRC = (1<<URSEL)|(3<<UCSZ0);
+    #else
+    UCSRC = (3<<UCSZ0);
+    #endif 
+    
+#elif defined (ATMEGA_USART0 )
+    /* Set baud rate */
+    if ( baudrate & 0x8000 ) 
+    {
+   		UART0_STATUS = (1<<U2X0);  //Enable 2x speed 
+   		baudrate &= ~0x8000;
+   	}
+    UBRR0H = (unsigned char)(baudrate>>8);
+    UBRR0L = (unsigned char) baudrate;
+
+    /* Enable USART receiver and transmitter and receive complete interrupt */
+    UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
+    
+    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
+    #ifdef URSEL0
+    UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
+    #else
+    UCSR0C = (3<<UCSZ00);
+    #endif 
+
+#elif defined ( ATMEGA_UART )
+    /* set baud rate */
+    if ( baudrate & 0x8000 ) 
+    {
+    	UART0_STATUS = (1<<U2X);  //Enable 2x speed 
+    	baudrate &= ~0x8000;
+    }
+    UBRRHI = (unsigned char)(baudrate>>8);
+    UBRR   = (unsigned char) baudrate;
+
+    /* Enable UART receiver and transmitter and receive complete interrupt */
+    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
+
+#elif defined ( AT90USB_USART )
+   /* set baud rate */
+    if ( baudrate & 0x8000 ) 
+    {
+    	UART0_STATUS = (1<<U2X1 );  //Enable 2x speed 
+    	baudrate &= ~0x8000;
+    }
+    UBRR1H = (unsigned char)(baudrate>>8);
+    UBRR1L = (unsigned char) baudrate;
+
+    /* Enable UART receiver and transmitter and receive complete interrupt */
+    UART0_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
+    
+    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
+    UCSR1C = (1<<UCSZ11)|(1<<UCSZ10);
+#endif
+
+}/* uart_init */
+
+
+/*************************************************************************
+Function: uart_getc()
+Purpose:  return byte from ringbuffer  
+Returns:  lower byte:  received byte from ringbuffer
+          higher byte: last receive error
+**************************************************************************/
+unsigned int uart_getc(void)
+{    
+    unsigned char tmptail;
+    unsigned char data;
+
+
+    if ( UART_RxHead == UART_RxTail ) {
+        return UART_NO_DATA;   /* no data available */
+    }
+    
+    /* calculate /store buffer index */
+    tmptail = (UART_RxTail + 1) & UART0_RX_BUFFER_MASK;
+    UART_RxTail = tmptail; 
+    
+    /* get data from receive buffer */
+    data = UART_RxBuf[tmptail];
+    
+    data = (UART_LastRxError << 8) + data;
+    UART_LastRxError = 0;
+    return data;
+
+}/* uart_getc */
+
+
+/*************************************************************************
+Function: uart_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none          
+**************************************************************************/
+void uart_putc(unsigned char data)
+{
+    unsigned char tmphead;
+
+    
+    tmphead  = (UART_TxHead + 1) & UART0_TX_BUFFER_MASK;
+    
+    while ( tmphead == UART_TxTail ){
+        ;/* wait for free space in buffer */
+    }
+    
+    UART_TxBuf[tmphead] = data;
+    UART_TxHead = tmphead;
+
+    /* enable UDRE interrupt */
+    UART0_CONTROL    |= _BV(UART0_UDRIE);
+
+}/* uart_putc */
+
+
+/*************************************************************************
+Function: uart_puts()
+Purpose:  transmit string to UART
+Input:    string to be transmitted
+Returns:  none          
+**************************************************************************/
+void uart_puts(const char *s )
+{
+    while (*s) 
+      uart_putc(*s++);
+
+}/* uart_puts */
+
+
+/*************************************************************************
+Function: uart_puts_p()
+Purpose:  transmit string from program memory to UART
+Input:    program memory string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart_puts_p(const char *progmem_s )
+{
+    register char c;
+    
+    while ( (c = pgm_read_byte(progmem_s++)) ) 
+      uart_putc(c);
+
+}/* uart_puts_p */
+
+
+/*
+ * these functions are only for ATmegas with two USART
+ */
+#if defined( ATMEGA_USART1 )
+
+ISR(UART1_RECEIVE_INTERRUPT)
+/*************************************************************************
+Function: UART1 Receive Complete interrupt
+Purpose:  called when the UART1 has received a character
+**************************************************************************/
+{
+    unsigned char tmphead;
+    unsigned char data;
+    unsigned char usr;
+    unsigned char lastRxError;
+ 
+ 
+    /* read UART status register and UART data register */ 
+    usr  = UART1_STATUS;
+    data = UART1_DATA;
+    
+    /* */
+    lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
+        
+    /* calculate buffer index */ 
+    tmphead = ( UART1_RxHead + 1) & UART1_RX_BUFFER_MASK;
+    
+    if ( tmphead == UART1_RxTail ) {
+        /* error: receive buffer overflow */
+        lastRxError = UART_BUFFER_OVERFLOW >> 8;
+    }else{
+        /* store new index */
+        UART1_RxHead = tmphead;
+        /* store received data in buffer */
+        UART1_RxBuf[tmphead] = data;
+    }
+    UART1_LastRxError |= lastRxError;   
+}
+
+
+ISR(UART1_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART1 Data Register Empty interrupt
+Purpose:  called when the UART1 is ready to transmit the next byte
+**************************************************************************/
+{
+    unsigned char tmptail;
+
+    
+    if ( UART1_TxHead != UART1_TxTail) {
+        /* calculate and store new buffer index */
+        tmptail = (UART1_TxTail + 1) & UART1_TX_BUFFER_MASK;
+        UART1_TxTail = tmptail;
+        /* get one byte from buffer and write it to UART */
+        UART1_DATA = UART1_TxBuf[tmptail];  /* start transmission */
+    }else{
+        /* tx buffer empty, disable UDRE interrupt */
+        UART1_CONTROL &= ~_BV(UART1_UDRIE);
+    }
+}
+
+
+/*************************************************************************
+Function: uart1_init()
+Purpose:  initialize UART1 and set baudrate
+Input:    baudrate using macro UART_BAUD_SELECT()
+Returns:  none
+**************************************************************************/
+void uart1_init(unsigned int baudrate)
+{
+    UART1_TxHead = 0;
+    UART1_TxTail = 0;
+    UART1_RxHead = 0;
+    UART1_RxTail = 0;
+    
+
+    /* Set baud rate */
+    if ( baudrate & 0x8000 ) 
+    {
+    	UART1_STATUS = (1<<U2X1);  //Enable 2x speed 
+      baudrate &= ~0x8000;
+    }
+    UBRR1H = (unsigned char)(baudrate>>8);
+    UBRR1L = (unsigned char) baudrate;
+
+    /* Enable USART receiver and transmitter and receive complete interrupt */
+    UART1_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
+    
+    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */   
+    #ifdef URSEL1
+    UCSR1C = (1<<URSEL1)|(3<<UCSZ10);
+    #else
+    UCSR1C = (3<<UCSZ10);
+    #endif 
+}/* uart_init */
+
+
+/*************************************************************************
+Function: uart1_getc()
+Purpose:  return byte from ringbuffer  
+Returns:  lower byte:  received byte from ringbuffer
+          higher byte: last receive error
+**************************************************************************/
+unsigned int uart1_getc(void)
+{    
+    unsigned char tmptail;
+    unsigned char data;
+
+
+    if ( UART1_RxHead == UART1_RxTail ) {
+        return UART_NO_DATA;   /* no data available */
+    }
+    
+    /* calculate /store buffer index */
+    tmptail = (UART1_RxTail + 1) & UART1_RX_BUFFER_MASK;
+    UART1_RxTail = tmptail; 
+    
+    /* get data from receive buffer */
+    data = UART1_RxBuf[tmptail];
+    
+    data = (UART1_LastRxError << 8) + data;
+    UART1_LastRxError = 0;
+    return data;
+
+}/* uart1_getc */
+
+
+/*************************************************************************
+Function: uart1_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none          
+**************************************************************************/
+void uart1_putc(unsigned char data)
+{
+    unsigned char tmphead;
+
+    
+    tmphead  = (UART1_TxHead + 1) & UART1_TX_BUFFER_MASK;
+    
+    while ( tmphead == UART1_TxTail ){
+        ;/* wait for free space in buffer */
+    }
+    
+    UART1_TxBuf[tmphead] = data;
+    UART1_TxHead = tmphead;
+
+    /* enable UDRE interrupt */
+    UART1_CONTROL    |= _BV(UART1_UDRIE);
+
+}/* uart1_putc */
+
+
+/*************************************************************************
+Function: uart1_puts()
+Purpose:  transmit string to UART1
+Input:    string to be transmitted
+Returns:  none          
+**************************************************************************/
+void uart1_puts(const char *s )
+{
+    while (*s) 
+      uart1_putc(*s++);
+
+}/* uart1_puts */
+
+
+/*************************************************************************
+Function: uart1_puts_p()
+Purpose:  transmit string from program memory to UART1
+Input:    program memory string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart1_puts_p(const char *progmem_s )
+{
+    register char c;
+    
+    while ( (c = pgm_read_byte(progmem_s++)) ) 
+      uart1_putc(c);
+
+}/* uart1_puts_p */
+
+
+#endif

01_m1284p_bb00_minimum/uart_extd.h

@@ -0,0 +1,209 @@
+#ifndef UART_H
+#define UART_H
+/*
+ * Modified  for different BUFFER_SIZE for UART0 && UART1
+ * see below: UART0_RX_BUFFER_SIZE/UART1_RX_BUFFER_SIZE && UART0_TX_BUFFER_SIZE/UART1_TX_BUFFER_SIZE
+ * Ibragimov M. 7/03/2015
+*/
+/************************************************************************
+Title:    Interrupt UART library with receive/transmit circular buffers
+Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
+File:     $Id: uart.h,v 1.12 2012/11/19 19:52:27 peter Exp $
+Software: AVR-GCC 4.1, AVR Libc 1.4
+Hardware: any AVR with built-in UART, tested on AT90S8515 & ATmega8 at 4 Mhz
+License:  GNU General Public License 
+Usage:    see Doxygen manual
+
+LICENSE:
+    Copyright (C) 2006 Peter Fleury
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    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 General Public License for more details.
+    
+************************************************************************/
+
+/** 
+ *  @defgroup pfleury_uart UART Library
+ *  @code #include <uart.h> @endcode
+ * 
+ *  @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers. 
+ *
+ *  This library can be used to transmit and receive data through the built in UART. 
+ *
+ *  An interrupt is generated when the UART has finished transmitting or
+ *  receiving a byte. The interrupt handling routines use circular buffers
+ *  for buffering received and transmitted data.
+ *
+ *  The UART0[1]_RX_BUFFER_SIZE and UART0[1]_TX_BUFFER_SIZE constants define
+ *  the size of the circular buffers in bytes. Note that these constants must be a power of 2.
+ *  You may need to adapt this constants to your target and your application by adding 
+ *  CDEFS += -DUART0[1]_RX_BUFFER_SIZE=nn -DUART0[1]_RX_BUFFER_SIZE=nn to your Makefile.
+ *
+ *  @note Based on Atmel Application Note AVR306
+ *  @author Peter Fleury pfleury@gmx.ch  http://jump.to/fleury
+ */
+ 
+/**@{*/
+
+
+#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
+#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"
+#endif
+
+
+/*
+** constants and macros
+*/
+
+/** @brief  UART Baudrate Expression
+ *  @param  xtalcpu  system clock in Mhz, e.g. 4000000UL for 4Mhz          
+ *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
+ */
+#define UART_BAUD_SELECT(baudRate,xtalCpu)  (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) -1UL)
+
+/** @brief  UART Baudrate Expression for ATmega double speed mode
+ *  @param  xtalcpu  system clock in Mhz, e.g. 4000000UL for 4Mhz           
+ *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
+ */
+#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) ( ((((xtalCpu) + 4UL * (baudRate)) / (8UL * (baudRate)) -1UL)) | 0x8000)
+
+
+/** Size of the circular receive buffer UART0, must be power of 2 */
+#ifndef UART0_RX_BUFFER_SIZE
+#define UART0_RX_BUFFER_SIZE 32
+#endif
+/** Size of the circular transmit buffer UART0, must be power of 2 */
+#ifndef UART0_TX_BUFFER_SIZE
+#define UART0_TX_BUFFER_SIZE 32
+#endif
+
+/** Size of the circular receive buffer UART1, must be power of 2 */
+#ifndef UART1_RX_BUFFER_SIZE
+#define UART1_RX_BUFFER_SIZE 128
+#endif
+/** Size of the circular transmit buffer UART1, must be power of 2 */
+#ifndef UART1_TX_BUFFER_SIZE
+#define UART1_TX_BUFFER_SIZE 128
+#endif
+
+/* test if the size of the circular buffers fits into SRAM */
+#if ( (UART0_RX_BUFFER_SIZE+UART0_TX_BUFFER_SIZE+UART1_RX_BUFFER_SIZE+UART1_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )
+#error "size of UART0[1]_RX_BUFFER_SIZE + UART0[1]_TX_BUFFER_SIZE larger than size of SRAM"
+#endif
+
+/* 
+** high byte error return code of uart_getc()
+*/
+#define UART_FRAME_ERROR      0x1000              /* Framing Error by UART       */
+#define UART_OVERRUN_ERROR    0x0800              /* Overrun condition by UART   */
+#define UART_PARITY_ERROR     0x0400              /* Parity Error by UART        */ 
+#define UART_BUFFER_OVERFLOW  0x0200              /* receive ringbuffer overflow */
+#define UART_NO_DATA          0x0100              /* no receive data available   */
+
+
+/*
+** function prototypes
+*/
+
+/**
+   @brief   Initialize UART and set baudrate 
+   @param   baudrate Specify baudrate using macro UART_BAUD_SELECT()
+   @return  none
+*/
+extern void uart_init(unsigned int baudrate);
+
+
+/**
+ *  @brief   Get received byte from ringbuffer
+ *
+ * Returns in the lower byte the received character and in the 
+ * higher byte the last receive error.
+ * UART_NO_DATA is returned when no data is available.
+ *
+ *  @param   void
+ *  @return  lower byte:  received byte from ringbuffer
+ *  @return  higher byte: last receive status
+ *           - \b 0 successfully received data from UART
+ *           - \b UART_NO_DATA           
+ *             <br>no receive data available
+ *           - \b UART_BUFFER_OVERFLOW   
+ *             <br>Receive ringbuffer overflow.
+ *             We are not reading the receive buffer fast enough, 
+ *             one or more received character have been dropped 
+ *           - \b UART_OVERRUN_ERROR     
+ *             <br>Overrun condition by UART.
+ *             A character already present in the UART UDR register was 
+ *             not read by the interrupt handler before the next character arrived,
+ *             one or more received characters have been dropped.
+ *           - \b UART_FRAME_ERROR       
+ *             <br>Framing Error by UART
+ */
+extern unsigned int uart_getc(void);
+
+
+/**
+ *  @brief   Put byte to ringbuffer for transmitting via UART
+ *  @param   data byte to be transmitted
+ *  @return  none
+ */
+extern void uart_putc(unsigned char data);
+
+
+/**
+ *  @brief   Put string to ringbuffer for transmitting via UART
+ *
+ *  The string is buffered by the uart library in a circular buffer
+ *  and one character at a time is transmitted to the UART using interrupts.
+ *  Blocks if it can not write the whole string into the circular buffer.
+ * 
+ *  @param   s string to be transmitted
+ *  @return  none
+ */
+extern void uart_puts(const char *s );
+
+
+/**
+ * @brief    Put string from program memory to ringbuffer for transmitting via UART.
+ *
+ * The string is buffered by the uart library in a circular buffer
+ * and one character at a time is transmitted to the UART using interrupts.
+ * Blocks if it can not write the whole string into the circular buffer.
+ *
+ * @param    s program memory string to be transmitted
+ * @return   none
+ * @see      uart_puts_P
+ */
+extern void uart_puts_p(const char *s );
+
+/**
+ * @brief    Macro to automatically put a string constant into program memory
+ */
+#define uart_puts_P(__s)       uart_puts_p(PSTR(__s))
+
+
+
+/** @brief  Initialize USART1 (only available on selected ATmegas) @see uart_init */
+extern void uart1_init(unsigned int baudrate);
+/** @brief  Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
+extern unsigned int uart1_getc(void);
+/** @brief  Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
+extern void uart1_putc(unsigned char data);
+/** @brief  Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
+extern void uart1_puts(const char *s );
+/** @brief  Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */
+extern void uart1_puts_p(const char *s );
+/** @brief  Macro to automatically put a string constant into program memory */
+#define uart1_puts_P(__s)       uart1_puts_p(PSTR(__s))
+
+/**@}*/
+
+
+#endif // UART_H 
+