Really changed name to lowercase

2016-05-20 15:37:33 +02:00
parent 3a8ec7f2c3
commit b1bd03eeb6
11 changed files with 0 additions and 0 deletions
--- a/usart/Clock.h
+++ b/usart/Clock.h
@@ -0,0 +1,14 @@
+/*
+* Copyright (c) by BlackMark 2015
+* Date 24/11/2015
+* Version 1.1
+*/
+
+#ifndef CLOCK_H
+#define CLOCK_H
+
+#define F_CPU 8000000
+
+#include <util/delay.h>
+
+#endif
--- a/usart/cppalloc.cpp
+++ b/usart/cppalloc.cpp
@@ -0,0 +1,25 @@
+#include "cppalloc.h"
+
+//////////////////////////////////////////////////////////////////////////
+void* operator new( size_t sizeSize )
+{
+	return malloc( sizeSize );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void operator delete( void* pAddress )
+{
+	free( pAddress );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void* operator new[]( size_t sizeSize )
+{
+	return malloc( sizeSize );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void operator delete[]( void* pAddress )
+{
+	free( pAddress );
+}
--- a/usart/cppalloc.h
+++ b/usart/cppalloc.h
@@ -0,0 +1,18 @@
+/*
+* Copyright (c) by BlackMark 2015
+* Date 24/11/2015
+* Version 1.3
+*/
+
+#ifndef CPPALLOC_H
+#define CPPALLOC_H
+
+#include <stdlib.h>
+
+void* operator new( size_t sizeSize );
+void operator delete( void* pAddress );
+
+void* operator new[]( size_t sizeSize );
+void operator delete[]( void* pAddress );
+
+#endif
--- a/usart/main.cpp
+++ b/usart/main.cpp
@@ -0,0 +1,61 @@
+/*
+* Copyright (c) by BlackMark 2015-2016
+* Date 05/01/2016
+* Version 1.4
+*/
+
+#include <stdio.h>
+#include "Clock.h"
+#include "usart.h"
+
+int main()
+{
+	USART0 cUSART;
+	cUSART.init();
+
+	uint32_t ui32Counter = 0;
+
+	cUSART << "\r\nSizes: \r\n";
+	cUSART << "sizeof( char ) = " << sizeof( char ) << "\r\n";
+	cUSART << "sizeof( unsigned char ) = " << sizeof( unsigned char ) << "\r\n";
+	cUSART << "sizeof( short int ) = " << sizeof( short int ) << "\r\n";
+	cUSART << "sizeof( unsigned short int ) = " << sizeof( unsigned short int ) << "\r\n";
+	cUSART << "sizeof( int ) = " << sizeof( int ) << "\r\n";
+	cUSART << "sizeof( unsigned int ) = " << sizeof( unsigned int ) << "\r\n";
+	cUSART << "sizeof( long int ) = " << sizeof( long int ) << "\r\n";
+	cUSART << "sizeof( unsigned long int ) = " << sizeof( unsigned long int ) << "\r\n";
+	cUSART << "sizeof( long long int ) = " << sizeof( long long int ) << "\r\n";
+	cUSART << "sizeof( unsigned long long int ) = " << sizeof( unsigned long long int ) << "\r\n";
+	cUSART << "sizeof( float ) = " << sizeof( float ) << "\r\n";
+	cUSART << "sizeof( double ) = " << sizeof( double ) << "\r\n";
+	cUSART << "sizeof( long double ) = " << sizeof( long double ) << "\r\n\r\n";
+	cUSART << "sizeof( void* ) = " << sizeof( void* ) << "\r\n";
+	cUSART << "sizeof( unsigned char* ) = " << sizeof( unsigned char* ) << "\r\n";
+	cUSART << "sizeof( unsigned int* ) = " << sizeof( unsigned int* ) << "\r\n\r\n";
+	
+	while( true )
+	{
+		cUSART << "This has been running for \"" << ui32Counter++ << "\" seconds!\r\n\r\n";
+
+		cUSART << "Please enter a number: ";
+
+		int iNumber;
+		cUSART >> iNumber;
+		
+		cUSART << "\r\nYou entered: " << iNumber << "\r\n\r\n";
+
+		cUSART << "Please enter a decimal number: ";
+
+		double dNumber;
+		cUSART >> dNumber;
+
+		cUSART << "\r\nYou entered: " << dNumber << "\r\n\r\n";
+
+		unsigned char uchByte;
+		cUSART.receiveByte( uchByte, 1000 );
+		
+		_delay_ms( 1000 );
+	}
+	
+	return 0;
+}
--- a/usart/string.cpp
+++ b/usart/string.cpp
@@ -0,0 +1,448 @@
+#include "string.h"
+
+//////////////////////////////////////////////////////////////////////////
+string::string() :
+m_sizeLength( 0 ), m_sizeCapacity( 1 ), m_szString( nullptr )
+{
+	m_szString = new char[m_sizeCapacity];
+
+	if( !m_szString )
+	{
+		return;
+	}
+	
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+string::string( const string &strString ) :
+m_sizeLength( strString.m_sizeLength ), m_sizeCapacity( strString.m_sizeCapacity ), m_szString( nullptr )
+{
+	m_szString = new char[m_sizeCapacity];
+	
+	if( !m_szString )
+	{
+		return;
+	}
+	
+	memcpy( m_szString, strString.m_szString, m_sizeCapacity * sizeof( char ) );
+}
+
+//////////////////////////////////////////////////////////////////////////
+string::string( const char* szString ) :
+m_sizeLength( strlen( szString ) ), m_sizeCapacity( strlen( szString ) + 1 ), m_szString( nullptr )
+{
+	m_szString = new char[m_sizeCapacity];
+	
+	if( !m_szString )
+	{
+		return;
+	}
+	
+	memcpy( m_szString, szString, m_sizeLength * sizeof( char ) );
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+string::string( char chCharacter ) :
+m_sizeLength( 1 ), m_sizeCapacity( 2 ), m_szString( nullptr )
+{
+	m_szString = new char[m_sizeCapacity];
+	
+	if( !m_szString )
+	{
+		return;
+	}
+	
+	m_szString[0] = chCharacter;
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+string::string( size_t sizeLength, char chCharacter ) :
+m_sizeLength( sizeLength ), m_sizeCapacity( sizeLength + 1 ), m_szString( nullptr )
+{
+	m_szString = new char[m_sizeCapacity];
+	
+	if( !m_szString )
+	{
+		return;
+	}
+	
+	for( size_t i = 0; i < sizeLength; ++i )
+	{
+		m_szString[i] = chCharacter;
+	}
+	
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+string::~string()
+{
+	delete [] m_szString;
+}
+
+//////////////////////////////////////////////////////////////////////////
+string &string::append( const string& strString )
+{
+	if( m_sizeLength + strString.m_sizeLength >= m_sizeCapacity )
+	{
+		char* szCopyString = new char[m_sizeLength + strString.m_sizeLength + 1];
+		
+		if( !szCopyString )
+		{
+			return *this;
+		}
+		
+		memcpy( szCopyString, m_szString, m_sizeLength * sizeof( char ) );
+		delete [] m_szString;
+		
+		m_sizeCapacity = m_sizeLength + strString.m_sizeLength + 1;
+		m_szString = szCopyString;
+	}
+	
+	memcpy( m_szString + m_sizeLength, strString.m_szString, strString.m_sizeLength * sizeof( char ) );
+	m_sizeLength = m_sizeLength + strString.m_sizeLength;
+	m_szString[m_sizeLength] = '\0';
+	
+	return *this;
+}
+
+//////////////////////////////////////////////////////////////////////////
+char& string::at( size_t sizeIndex )
+{
+	if( sizeIndex >= m_sizeLength )
+	{
+		return m_szString[m_sizeLength - 1];
+	}
+	
+	return m_szString[sizeIndex];
+}
+
+//////////////////////////////////////////////////////////////////////////
+const char& string::at( size_t sizeIndex ) const
+{
+	if( sizeIndex >= m_sizeLength )
+	{
+		return m_szString[m_sizeLength - 1];
+	}
+	
+	return m_szString[sizeIndex];
+}
+
+//////////////////////////////////////////////////////////////////////////
+size_t string::capacity() const
+{
+	return m_sizeCapacity;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void string::clear()
+{
+	m_sizeLength = 0;
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+const char* string::c_str() const
+{
+	return m_szString;
+}
+
+//////////////////////////////////////////////////////////////////////////
+const char* string::data() const
+{
+	return m_szString;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool string::empty() const
+{
+	if( m_sizeLength == 0 )
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////
+size_t string::find( const string &strString, size_t sizePos /* = 0 */ ) const
+{
+	if( strString.empty() || sizePos >= m_sizeLength )
+	{
+		return npos;
+	}
+	
+	for( size_t i = sizePos; i < m_sizeLength; ++i )
+	{
+		if( i + strString.length() > m_sizeLength )
+		{
+			return npos;
+		}
+		
+		if( m_szString[i] == strString[0] )
+		{
+			size_t sizeFound;
+			
+			for( sizeFound = 1; sizeFound < strString.size(); ++sizeFound )
+			{
+				if( m_szString[i + sizeFound] != strString[sizeFound] )
+				{
+					break;
+				}
+			}
+			
+			if( sizeFound == strString.size() )
+			{
+				return i;
+			}
+		}
+	}
+
+	return npos;
+}
+
+//////////////////////////////////////////////////////////////////////////
+size_t string::length() const
+{
+	return m_sizeLength;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void string::push_back( char chCharacter )
+{
+	if( m_sizeLength + 1 >= m_sizeCapacity )
+	{
+		char* szCopyString = new char[m_sizeLength + 2];
+		
+		if( !szCopyString )
+		{
+			return;
+		}
+		
+		memcpy( szCopyString, m_szString, m_sizeLength * sizeof( char ) );
+		delete [] m_szString;
+		
+		m_sizeCapacity = m_sizeLength + 2;
+		m_szString = szCopyString;
+	}
+	
+	m_szString[m_sizeLength++] = chCharacter;
+	m_szString[m_sizeLength] = '\0';
+}
+
+//////////////////////////////////////////////////////////////////////////
+void string::reserve( size_t sizeCapacity /* = 0 */ )
+{
+	if( sizeCapacity > m_sizeCapacity )
+	{
+		char* szCopyString = new char[sizeCapacity];
+		
+		if( !szCopyString )
+		{
+			return;
+		}
+		
+		memcpy( szCopyString, m_szString, m_sizeLength * sizeof( char ) );
+		delete [] m_szString;
+		
+		szCopyString[m_sizeLength] = '\0';
+		
+		m_sizeCapacity = sizeCapacity;
+		m_szString = szCopyString;
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+void string::resize( size_t sizeLength, char chCharacter )
+{
+	if( sizeLength < m_sizeLength )
+	{
+		m_sizeLength = sizeLength;
+		m_szString[m_sizeLength] = '\0';
+	}
+	else if( sizeLength > m_sizeLength )
+	{
+		if( sizeLength + 1 > m_sizeCapacity )
+		{
+			char* szCopyString = new char[sizeLength + 1];
+			
+			if( !szCopyString )
+			{
+				return;
+			}
+			
+			memcpy( szCopyString, m_szString, m_sizeLength * sizeof( char ) );
+			delete [] m_szString;
+			
+			for( size_t i = m_sizeLength; i < sizeLength; ++i )
+			{
+				szCopyString[i] = chCharacter;
+			}
+			szCopyString[sizeLength] = '\0';
+			
+			m_sizeLength = sizeLength;
+			m_sizeCapacity = m_sizeLength + 1;
+			m_szString = szCopyString;
+		}
+		else
+		{
+			for( size_t i = m_sizeLength; i < sizeLength; ++i )
+			{
+				m_szString[i] = chCharacter;
+			}
+			m_szString[sizeLength] = '\0';
+			
+			m_sizeLength = sizeLength;
+		}
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+size_t string::rfind( const string &strString, size_t sizePos /* = npos */ ) const
+{
+	if( sizePos == npos )
+	{
+		sizePos = m_sizeLength - 1;
+	}
+
+	if( strString.empty() || sizePos >= m_sizeLength )
+	{
+		return npos;
+	}
+
+	for( size_t i = sizePos + 1; i-- > 0; )
+	{
+		if( i - ( strString.length() - 1 ) > m_sizeLength )
+		{
+			return npos;
+		}
+
+		if( m_szString[i] == strString[strString.length() - 1] )
+		{
+			size_t sizeFound;
+
+			for( sizeFound = strString.length() - 1; sizeFound-- > 0; )
+			{
+				if( m_szString[i - ( strString.length() - ( sizeFound + 1 ) )] != strString[sizeFound] )
+				{
+					break;
+				}
+			}
+
+			if( sizeFound == npos )
+			{
+				return i - ( strString.length() - 1 );
+			}
+		}
+	}
+
+	return npos;
+}
+
+//////////////////////////////////////////////////////////////////////////
+size_t string::size() const
+{
+	return m_sizeLength;
+}
+
+//////////////////////////////////////////////////////////////////////////
+string string::substr( size_t sizePos /* = 0 */, size_t sizeLength /* = npos */ ) const
+{
+	if( sizePos >= m_sizeLength )
+	{
+		return string();
+	}
+
+	string strSubString;
+
+	for( size_t i = sizePos; i < sizePos + sizeLength; ++i )
+	{
+		if( i >= m_sizeLength )
+		{
+			break;
+		}
+
+		strSubString += m_szString[i];
+	}
+
+	return strSubString;
+}
+
+//////////////////////////////////////////////////////////////////////////
+string& string::operator=( const string &strRHS )
+{
+	char* szCopyString = new char[strRHS.m_sizeCapacity];
+	
+	if( !szCopyString )
+	{
+		return *this;
+	}
+	
+	m_sizeLength = strRHS.m_sizeLength;
+	m_sizeCapacity = strRHS.m_sizeCapacity;
+	
+	memcpy( szCopyString, strRHS.m_szString, m_sizeCapacity * sizeof( char ) );
+	delete [] m_szString;
+	
+	m_szString = szCopyString;
+	
+	return *this;
+}
+
+//////////////////////////////////////////////////////////////////////////
+char &string::operator[]( size_t sizeIndex )
+{
+	return m_szString[sizeIndex];
+}
+
+//////////////////////////////////////////////////////////////////////////
+const char &string::operator[]( size_t sizeIndex ) const
+{
+	return m_szString[sizeIndex];
+}
+
+//////////////////////////////////////////////////////////////////////////
+string string::operator+( const string &strRHS ) const
+{
+	string strReturn = *this;
+		
+	strReturn.append( strRHS );
+		
+	return strReturn;
+}
+
+//////////////////////////////////////////////////////////////////////////
+string &string::operator+=( const string &strRHS )
+{
+	append( strRHS );
+	
+	return *this;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool string::operator==( const string &strRHS ) const
+{
+	if( size() != strRHS.size() )
+	{
+		return false;
+	}
+	
+	for( size_t i = 0; i < size(); ++i )
+	{
+		if( m_szString[i] != strRHS.m_szString[i] )
+		{
+			return false;
+		}
+	}
+	
+	return true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool string::operator!=( const string &strRHS ) const
+{
+	return !( *this == strRHS );
+}
--- a/usart/string.h
+++ b/usart/string.h
@@ -0,0 +1,55 @@
+/*
+* Copyright (c) by BlackMark 2015
+* Date 26/11/2015
+* Version 1.4
+*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <string.h>
+
+class string
+{
+private:
+	size_t m_sizeLength;
+	size_t m_sizeCapacity;
+	char* m_szString;
+	
+public:
+	static const size_t npos = -1;
+
+	string();
+	string( const string &strString );
+	string( const char* szString );
+	string( char chCharacter );
+	string( size_t sizeLength, char chCharacter );
+	~string();
+	
+	string& append( const string &strString );
+	char& at( size_t sizeIndex );
+	const char& at( size_t sizeIndex ) const;
+	size_t capacity() const;
+	void clear();
+	const char* c_str() const;
+	const char* data() const;
+	bool empty() const;
+	size_t find( const string &strString, size_t sizePos = 0 ) const;
+	size_t length() const;
+	void push_back( char chCharacter );
+	void reserve( size_t sizeCapacity = 0 );
+	void resize( size_t sizeLength, char chCharacter = '\0' );
+	size_t rfind( const string &strString, size_t sizePos = npos ) const;
+	size_t size() const;
+	string substr( size_t sizePos = 0, size_t sizeLength = npos ) const;
+	
+	string& operator=( const string &strRHS );
+	char& operator[]( size_t sizeIndex );
+	const char& operator[]( size_t sizeIndex ) const;
+	string operator+( const string &strRHS ) const;
+	string& operator+=( const string &strRHS );
+	bool operator==( const string &strRHS ) const;
+	bool operator!=( const string &strRHS ) const;
+};
+
+#endif
--- a/usart/usart.cpp
+++ b/usart/usart.cpp
@@ -0,0 +1,520 @@
+#include "usart.h"
+
+//////////////////////////////////////////////////////////////////////////
+uint8_t USART0::readUCSRC()
+{
+	uint8_t ui8UCSRC;
+	
+#ifdef USART_SHAREDIO
+	ui8UCSRC = UBRRH;
+	ui8UCSRC = UCSRC;
+#else
+	ui8UCSRC = *m_vui8pUCSRC;
+#endif
+
+	return ui8UCSRC;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setUCSRC( uint8_t ui8UCSRC )
+{
+#ifdef USART_SHAREDIO
+	*m_vui8pUCSRC = ( 1 << URSEL ) | ui8UCSRC;
+#else
+	*m_vui8pUCSRC = ui8UCSRC;
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setRXState( bool bEnable )
+{
+	if( bEnable )
+	{
+		*m_vui8pUCSRB |= ( 1 << RXEN_D );
+	}
+	else
+	{
+		*m_vui8pUCSRB &= ~( 1 << RXEN_D );
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setTXState( bool bEnable )
+{
+	if( bEnable )
+	{
+		*m_vui8pUCSRB |= ( 1 << TXEN_D );
+	}
+	else
+	{
+		*m_vui8pUCSRB &= ~( 1 << TXEN_D );
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setBaudRate( uint32_t ui32BaudRate )
+{
+	uint16_t ui16UBRR = ( ( F_CPU / ( 16 * ui32BaudRate ) ) - 1 );
+	*m_vui8pUBRRH = static_cast<uint8_t>( ui16UBRR >> 8 );
+	*m_vui8pUBRRL = static_cast<uint8_t>( ui16UBRR );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setDataBits( uint8_t ui8DataBits )
+{
+	uint8_t ui8UCSRC = readUCSRC();
+	
+	if( ui8DataBits < 5 )
+	{
+		ui8DataBits = 5;
+	}
+	else if( ui8DataBits > 9 )
+	{
+		ui8DataBits = 9;
+	}
+	
+	if( ui8DataBits <= 8 )
+	{
+		bool bZeroBit = ( ui8DataBits - 5 ) & 1;
+		bool bOneBit = ( ( ui8DataBits - 5 ) >> 1 ) & 1;
+		
+		if( bZeroBit )
+		{
+			ui8UCSRC |= ( 1 << UCSZ0_D );
+		}
+		else
+		{
+			ui8UCSRC &= ~( 1 << UCSZ0_D );
+		}
+		
+		if( bOneBit )
+		{
+			ui8UCSRC |= ( 1 << UCSZ1_D );
+		}
+		else
+		{
+			ui8UCSRC &= ~( 1 << UCSZ1_D );
+		}
+		
+		*m_vui8pUCSRB &= ~( 1 << UCSZ2_D );
+	}
+	else
+	{
+		ui8UCSRC |= ( 1 << UCSZ1_D ) | ( 1 << UCSZ0_D );
+		*m_vui8pUCSRB |= ( 1 << UCSZ2_D );
+	}
+	
+	setUCSRC( ui8UCSRC );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setParity( Parity enmParity )
+{
+	uint8_t ui8UCSRC = readUCSRC();
+	
+	if( enmParity == Parity::DISABLED )
+	{
+		ui8UCSRC &= ~( ( 1 << UPM1_D ) | ( 1 << UPM0_D ) );
+	}
+	else if( enmParity == Parity::ODD )
+	{
+		ui8UCSRC |= ( ( 1 << UPM1_D ) | ( 1 << UPM0_D ) );
+	}
+	else if( enmParity == Parity::EVEN )
+	{
+		ui8UCSRC &= ~( ( 1 << UPM0_D ) );
+		ui8UCSRC |= ( ( 1 << UPM1_D ) );
+	}
+	
+	setUCSRC( ui8UCSRC );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setStopBits( StopBit enmStopBits )
+{
+	uint8_t ui8UCSRC = readUCSRC();
+	
+	if( enmStopBits == StopBit::ONE )
+	{
+		ui8UCSRC &= ~( 1 << USBS_D );
+	}
+	else if( enmStopBits == StopBit::TWO )
+	{
+		ui8UCSRC |= ( 1 << USBS_D );
+	}
+	
+	setUCSRC( ui8UCSRC );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::setMode( Mode enmMode )
+{
+	uint8_t ui8UCSRC = readUCSRC();
+
+#ifdef USART_SPI
+	if( enmMode == Mode::ASYNCHRONOUS )
+	{
+		ui8UCSRC &= ~( ( 1 << UMSEL1_D ) | ( 1 << UMSEL0_D ) );
+	}
+	else if( enmMode == Mode::SYNCHRONOUS )
+	{
+		ui8UCSRC &= ~( 1 << UMSEL1_D );
+		ui8UCSRC |= ( 1 << UMSEL0_D );
+	}
+	else if( enmMode == Mode::MASTERSPI )
+	{
+		ui8UCSRC |= ( ( 1 << UMSEL1_D ) | ( 1 << UMSEL0_D ) );
+	}
+#else
+	if( enmMode == Mode::ASYNCHRONOUS )
+	{
+		ui8UCSRC &= ~( 1 << UMSEL_D );
+	}
+	else if( enmMode == Mode::SYNCHRONOUS )
+	{
+		ui8UCSRC |= ( 1 << UMSEL_D );
+	}
+#endif
+
+	setUCSRC( ui8UCSRC );
+}
+
+//////////////////////////////////////////////////////////////////////////
+USART0::USART0()
+{
+#ifdef USART_SHAREDIO
+	m_vui8pUCSRA = &UCSRA;
+	m_vui8pUCSRB = &UCSRB;
+	m_vui8pUCSRC = &UCSRC;
+	m_vui8pUBRRH = &UBRRH;
+	m_vui8pUBRRL = &UBRRL;
+	m_vui8pUDR = &UDR;
+#endif
+
+#ifndef USART_SHAREDIO
+	m_vui8pUCSRA = &UCSR0A;
+	m_vui8pUCSRB = &UCSR0B;
+	m_vui8pUCSRC = &UCSR0C;
+	m_vui8pUBRRH = &UBRR0H;
+	m_vui8pUBRRL = &UBRR0L;
+	m_vui8pUDR = &UDR0;
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////
+USART0::~USART0()
+{}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::init( uint32_t ui32BaudRate /* = 9600 */, uint8_t ui8DataBits /* = 8 */, Parity enmParity /* = Parity::DISABLED */, StopBit enmStopBits /* = StopBit::ONE */, Mode enmMode /* = Mode::ASYNCHRONOUS */ )
+{
+	setBaudRate( ui32BaudRate );
+	setDataBits( ui8DataBits );
+	setParity( enmParity );
+	setStopBits( enmStopBits );
+	setMode( enmMode );
+
+	setRXState( true );
+	setTXState( true );
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool USART0::receiveByte( unsigned char &chData, uint32_t ui32DelayMS )
+{
+	const uint8_t ui8ClockCyclesPerIteration = 6;
+	double dDelayS = ui32DelayMS / 1000.0;
+	
+	uint32_t ui32Iterations = static_cast<uint32_t>( ( dDelayS * F_CPU ) / ui8ClockCyclesPerIteration );
+
+	do
+	{
+		if( ( *m_vui8pUCSRA & ( 1 << RXC_D ) ) )
+		{
+			chData = *m_vui8pUDR;
+			return true;
+		}
+	} while( --ui32Iterations > 0 );
+	
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////
+unsigned char USART0::receiveByte()
+{
+	while( !( *m_vui8pUCSRA & ( 1 << RXC_D ) ) );
+	
+	return *m_vui8pUDR;
+}
+
+//////////////////////////////////////////////////////////////////////////
+string USART0::receiveLine( string strLineTerminator /* = "\r\n" */, size_t sizeMaxSize /* = 1024 */ )
+{
+	string strReceived;
+	
+	while( strReceived.length() < sizeMaxSize )
+	{
+		strReceived += receiveByte();
+		
+		size_t sizeLineTerminator = strReceived.rfind( strLineTerminator );
+		
+		if( sizeLineTerminator != string::npos )
+		{
+			strReceived = strReceived.substr( 0, sizeLineTerminator );
+			break;
+		}
+	}
+	
+	return strReceived;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( char &chReceived )
+{
+	chReceived = receiveByte();
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( unsigned char &uchReceived )
+{
+	uchReceived = receiveByte();
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( short int &shiReceived )
+{
+	long int liInput;
+	receive( liInput );
+
+	shiReceived = static_cast<short int>( liInput );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( unsigned short int &ushiReceived )
+{
+	unsigned long int uliInput;
+	receive( uliInput );
+
+	ushiReceived = static_cast<unsigned short int>( uliInput );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( int &iReceived )
+{
+	long int liInput;
+	receive( liInput );
+
+	iReceived = static_cast<int>( liInput );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( unsigned int &uiReceived )
+{
+	unsigned long int uliInput;
+	receive( uliInput );
+
+	uiReceived = static_cast<unsigned int>( uliInput );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( long int &liReceived )
+{
+	string strInput;
+	unsigned char uchRead;
+
+	while( !isspace( uchRead = receiveByte() ) )
+	{
+		strInput += uchRead;
+	}
+
+	liReceived = strtol( strInput.c_str(), nullptr, 10 );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( unsigned long int &uliReceived )
+{
+	string strInput;
+	unsigned char uchRead;
+
+	while( !isspace( uchRead = receiveByte() ) )
+	{
+		strInput += uchRead;
+	}
+
+	uliReceived = strtoul( strInput.c_str(), nullptr, 10 );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( long long int &lliReceived )
+{
+	long int liInput;
+	receive( liInput );
+
+	lliReceived = liInput;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( unsigned long long int &ulliReceived )
+{
+	unsigned long int uliInput;
+	receive( uliInput );
+
+	ulliReceived = uliInput;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( float &fReceived )
+{
+	double dInput;
+	receive( dInput );
+
+	fReceived = dInput;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( double &dReceived )
+{
+	string strInput;
+	unsigned char uchRead;
+
+	while( !isspace( uchRead = receiveByte() ) )
+	{
+		strInput += uchRead;
+	}
+
+	dReceived = strtod( strInput.c_str(), nullptr );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::receive( long double &ldReceived )
+{
+	double dInput;
+	receive( dInput );
+
+	ldReceived = dInput;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmitByte( unsigned char byteData )
+{
+	while( !( *m_vui8pUCSRA & ( 1 << UDRE_D ) ) );
+	
+	*m_vui8pUDR = byteData;
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( string strData )
+{
+	for( size_t i = 0; i < strData.length(); ++i )
+	{
+		transmitByte( strData[i] );
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( char chData )
+{
+	transmitByte( chData );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( unsigned char uchData )
+{
+	sprintf( m_szConvertBuffer, "%hhu", uchData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( short int shiData )
+{
+	sprintf( m_szConvertBuffer, "%hd", shiData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( unsigned short int ushiData )
+{
+	sprintf( m_szConvertBuffer, "%hu", ushiData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( int iData )
+{
+	sprintf( m_szConvertBuffer, "%d", iData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( unsigned int uiData )
+{
+	sprintf( m_szConvertBuffer, "%u", uiData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( long int liData )
+{
+	sprintf( m_szConvertBuffer, "%ld", liData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( unsigned long int uliData )
+{
+	sprintf( m_szConvertBuffer, "%lu", uliData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( long long int lliData )
+{
+	sprintf( m_szConvertBuffer, "%lld", lliData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( unsigned long long int ulliData )
+{
+	sprintf( m_szConvertBuffer, "%llu", ulliData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( float fData )
+{
+	sprintf( m_szConvertBuffer, "%f", static_cast<double>( fData ) );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( double dData )
+{
+	sprintf( m_szConvertBuffer, "%f", dData );
+	transmit( m_szConvertBuffer );
+}
+
+//////////////////////////////////////////////////////////////////////////
+void USART0::transmit( long double ldData )
+{
+	sprintf( m_szConvertBuffer, "%f", static_cast<double>( ldData ) );
+	transmit( m_szConvertBuffer );
+}
+
+#ifdef SECOND_USART
+
+//////////////////////////////////////////////////////////////////////////
+USART1::USART1()
+{
+	m_vui8pUCSRA = &UCSR1A;
+	m_vui8pUCSRB = &UCSR1B;
+	m_vui8pUCSRC = &UCSR1C;
+	m_vui8pUBRRH = &UBRR1H;
+	m_vui8pUBRRL = &UBRR1L;
+	m_vui8pUDR = &UDR1;
+}
+
+//////////////////////////////////////////////////////////////////////////
+USART1::~USART1()
+{}
+
+#endif
--- a/usart/usart.cppproj
+++ b/usart/usart.cppproj
@@ -0,0 +1,174 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectVersion>7.0</ProjectVersion>
+    <ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
+    <ProjectGuid>dce6c7e3-ee26-4d79-826b-08594b9ad897</ProjectGuid>
+    <avrdevice>ATmega328P</avrdevice>
+    <avrdeviceseries>none</avrdeviceseries>
+    <OutputType>Executable</OutputType>
+    <Language>CPP</Language>
+    <OutputFileName>$(MSBuildProjectName)</OutputFileName>
+    <OutputFileExtension>.elf</OutputFileExtension>
+    <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
+    <AssemblyName>usart</AssemblyName>
+    <Name>usart</Name>
+    <RootNamespace>usart</RootNamespace>
+    <ToolchainFlavour>Native</ToolchainFlavour>
+    <KeepTimersRunning>true</KeepTimersRunning>
+    <OverrideVtor>false</OverrideVtor>
+    <CacheFlash>true</CacheFlash>
+    <ProgFlashFromRam>true</ProgFlashFromRam>
+    <RamSnippetAddress>0x20000000</RamSnippetAddress>
+    <UncachedRange />
+    <preserveEEPROM>true</preserveEEPROM>
+    <OverrideVtorValue>exception_table</OverrideVtorValue>
+    <BootSegment>2</BootSegment>
+    <eraseonlaunchrule>0</eraseonlaunchrule>
+    <AsfFrameworkConfig>
+      <framework-data xmlns="">
+        <options />
+        <configurations />
+        <files />
+        <documentation help="" />
+        <offline-documentation help="" />
+        <dependencies>
+          <content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.31.0" />
+        </dependencies>
+      </framework-data>
+    </AsfFrameworkConfig>
+    <avrtool>com.atmel.avrdbg.tool.stk500</avrtool>
+    <avrtoolserialnumber />
+    <avrdeviceexpectedsignature>0x1E950F</avrdeviceexpectedsignature>
+    <com_atmel_avrdbg_tool_stk500>
+      <ToolOptions>
+        <InterfaceProperties>
+          <IspClock>1843200</IspClock>
+        </InterfaceProperties>
+        <InterfaceName>ISP</InterfaceName>
+      </ToolOptions>
+      <ToolType>com.atmel.avrdbg.tool.stk500</ToolType>
+      <ToolNumber>
+      </ToolNumber>
+      <ToolName>STK500</ToolName>
+    </com_atmel_avrdbg_tool_stk500>
+    <avrtoolinterface>ISP</avrtoolinterface>
+    <avrtoolinterfaceclock>1843200</avrtoolinterfaceclock>
+    <com_atmel_avrdbg_tool_simulator>
+      <ToolOptions xmlns="">
+        <InterfaceProperties>
+        </InterfaceProperties>
+        <InterfaceName>
+        </InterfaceName>
+      </ToolOptions>
+      <ToolType xmlns="">com.atmel.avrdbg.tool.simulator</ToolType>
+      <ToolNumber xmlns="">
+      </ToolNumber>
+      <ToolName xmlns="">Simulator</ToolName>
+    </com_atmel_avrdbg_tool_simulator>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <ToolchainSettings>
+      <AvrGccCpp>
+  <avrgcc.common.Device>-mmcu=atmega328p -B "%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\gcc\dev\atmega328p"</avrgcc.common.Device>
+  <avrgcc.common.optimization.RelaxBranches>True</avrgcc.common.optimization.RelaxBranches>
+  <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+  <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+  <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+  <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
+  <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
+  <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+  <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+  <avrgcc.compiler.directories.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcc.compiler.directories.IncludePaths>
+  <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+  <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+  <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+  <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
+  <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
+  <avrgcccpp.compiler.directories.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcccpp.compiler.directories.IncludePaths>
+  <avrgcccpp.compiler.optimization.PackStructureMembers>True</avrgcccpp.compiler.optimization.PackStructureMembers>
+  <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
+  <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
+  <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
+  <avrgcccpp.compiler.miscellaneous.OtherFlags>-Wextra -std=c++11</avrgcccpp.compiler.miscellaneous.OtherFlags>
+  <avrgcccpp.linker.general.UseVprintfLibrary>True</avrgcccpp.linker.general.UseVprintfLibrary>
+  <avrgcccpp.linker.libraries.Libraries><ListValues><Value>libm</Value><Value>libprintf_flt</Value></ListValues></avrgcccpp.linker.libraries.Libraries>
+  <avrgcccpp.assembler.general.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcccpp.assembler.general.IncludePaths>
+  <avrgcc.compiler.symbols.DefSymbols><ListValues><Value>NDEBUG</Value></ListValues></avrgcc.compiler.symbols.DefSymbols>
+  <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
+  <avrgcccpp.compiler.symbols.DefSymbols><ListValues><Value>NDEBUG</Value></ListValues></avrgcccpp.compiler.symbols.DefSymbols>
+  <avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
+</AvrGccCpp>
+    </ToolchainSettings>
+    <PreBuildEvent>echo "C:\avrdude-6.2\avrdude.exe" -v -p$(avrdevice) %%* -Uflash:w:"$(OutputDirectory)\$(Name).hex":i &gt; "$(MSBuildProjectDirectory)\avrdude.bat"</PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <ToolchainSettings>
+      <AvrGccCpp>
+  <avrgcc.common.Device>-mmcu=atmega328p -B "%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\gcc\dev\atmega328p"</avrgcc.common.Device>
+  <avrgcc.common.optimization.RelaxBranches>True</avrgcc.common.optimization.RelaxBranches>
+  <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+  <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+  <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+  <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
+  <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
+  <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+  <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+  <avrgcc.compiler.directories.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcc.compiler.directories.IncludePaths>
+  <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+  <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+  <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+  <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
+  <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
+  <avrgcccpp.compiler.directories.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcccpp.compiler.directories.IncludePaths>
+  <avrgcccpp.compiler.optimization.PackStructureMembers>True</avrgcccpp.compiler.optimization.PackStructureMembers>
+  <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
+  <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
+  <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
+  <avrgcccpp.compiler.miscellaneous.OtherFlags>-Wextra -std=c++11</avrgcccpp.compiler.miscellaneous.OtherFlags>
+  <avrgcccpp.linker.general.UseVprintfLibrary>True</avrgcccpp.linker.general.UseVprintfLibrary>
+  <avrgcccpp.linker.libraries.Libraries><ListValues><Value>libm</Value><Value>libprintf_flt</Value></ListValues></avrgcccpp.linker.libraries.Libraries>
+  <avrgcccpp.assembler.general.IncludePaths><ListValues><Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.0.106\include</Value></ListValues></avrgcccpp.assembler.general.IncludePaths>
+  <avrgcc.compiler.symbols.DefSymbols><ListValues><Value>DEBUG</Value></ListValues></avrgcc.compiler.symbols.DefSymbols>
+  <avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
+  <avrgcc.compiler.optimization.DebugLevel>Default (-g2)</avrgcc.compiler.optimization.DebugLevel>
+  <avrgcccpp.compiler.symbols.DefSymbols><ListValues><Value>DEBUG</Value></ListValues></avrgcccpp.compiler.symbols.DefSymbols>
+  <avrgcccpp.compiler.optimization.level>Optimize (-O1)</avrgcccpp.compiler.optimization.level>
+  <avrgcccpp.compiler.optimization.DebugLevel>Default (-g2)</avrgcccpp.compiler.optimization.DebugLevel>
+  <avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
+</AvrGccCpp>
+    </ToolchainSettings>
+    <PreBuildEvent>echo "C:\avrdude-6.2\avrdude.exe" -v -p$(avrdevice) %%* -Uflash:w:"$(OutputDirectory)\$(Name).hex":i &gt; "$(MSBuildProjectDirectory)\avrdude.bat"</PreBuildEvent>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Clock.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="cppalloc.cpp">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="cppalloc.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="main.cpp">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="string.cpp">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="string.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="usart.cpp">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="usart.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="vector.h">
+      <SubType>compile</SubType>
+    </Compile>
+  </ItemGroup>
+  <Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
+</Project>
--- a/usart/usart.h
+++ b/usart/usart.h
@@ -0,0 +1,175 @@
+/*
+* Copyright (c) by BlackMark 2015-2016
+* Date 20/05/2016
+* Version 2.4
+*/
+
+#ifndef USART_H
+#define USART_H
+
+#include <avr/io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <ctype.h>
+#include "Clock.h"
+#include "string.h"
+#include "vector.h"
+
+#if defined (__AVR_ATmega168A__) || defined (__AVR_ATmega328P__) || defined (__AVR_ATmega644P__) || defined (__AVR_ATmega1284P__)
+#define USART_SPI
+#endif
+#if defined (__AVR_ATmega32A__) || (__AVR_ATmega8__)
+#define USART_SHAREDIO
+#endif
+#if defined (__AVR_ATmega1284P__)
+#define SECOND_USART
+#endif
+
+#ifdef USART_SHAREDIO
+#define RXEN_D RXEN
+#define TXEN_D TXEN
+#define UCSZ0_D UCSZ0
+#define UCSZ1_D UCSZ1
+#define UCSZ2_D UCSZ2
+#define UPM0_D UPM0
+#define UPM1_D UPM1
+#define USBS_D USBS
+#define RXC_D RXC
+#define UDRE_D UDRE
+#else
+#define RXEN_D RXEN0
+#define TXEN_D TXEN0
+#define UCSZ0_D UCSZ00
+#define UCSZ1_D UCSZ01
+#define UCSZ2_D UCSZ02
+#define UPM0_D UPM00
+#define UPM1_D UPM01
+#define USBS_D USBS0
+#define RXC_D RXC0
+#define UDRE_D UDRE0
+#endif
+
+#ifdef USART_SPI
+#define UMSEL0_D UMSEL00
+#define UMSEL1_D UMSEL01
+#else
+#define UMSEL_D UMSEL
+#endif
+
+class USART0
+{
+public:
+	enum class Mode
+	{
+		ASYNCHRONOUS = 0,
+		SYNCHRONOUS = 1,
+#ifdef USART_SPI
+		MASTERSPI = 2
+#endif
+	};
+	
+	enum class Parity
+	{
+		DISABLED = 0,
+		ODD = 1,
+		EVEN = 2
+	};
+	
+	enum class StopBit
+	{
+		ONE = 1,
+		TWO = 2
+	};
+	
+protected:
+	volatile uint8_t *m_vui8pUCSRA;
+	volatile uint8_t *m_vui8pUCSRB;
+	volatile uint8_t *m_vui8pUCSRC;
+	volatile uint8_t *m_vui8pUBRRH;
+	volatile uint8_t *m_vui8pUBRRL;
+	volatile uint8_t *m_vui8pUDR;
+
+private:
+	char m_szConvertBuffer[64];
+	uint8_t readUCSRC();
+	void setUCSRC( uint8_t ui8UCSRC );
+
+	void setRXState( bool bEnable );
+	void setTXState( bool bEnable );
+	void setBaudRate( uint32_t ui32BaudRate );
+	void setDataBits( uint8_t ui8DataBits );
+	void setParity( Parity enmParity );
+	void setStopBits( StopBit enmStopBits );
+	void setMode( Mode enmMode );
+
+public:
+	USART0();
+	~USART0();
+	
+	void init( uint32_t ui32BaudRate = 9600, uint8_t ui8DataBits = 8, Parity enmParity = Parity::DISABLED, StopBit enmStopBits = StopBit::ONE, Mode enmMode = Mode::ASYNCHRONOUS );
+	
+	bool receiveByte( unsigned char &chData, uint32_t ui32DelayMS );
+	unsigned char receiveByte();
+	string receiveLine( string strLineTerminator = "\r\n", size_t sizeMaxSize = 1024 );
+	
+	void receive( char &chReceived );
+	void receive( unsigned char &uchReceived );
+	void receive( short int &shiReceived );
+	void receive( unsigned short int &ushiReceived );
+	void receive( int &iReceived );
+	void receive( unsigned int &uiReceived );
+	void receive( long int &liReceived );
+	void receive( unsigned long int &uliReceived );
+	void receive( long long int &lliReceived );
+	void receive( unsigned long long int &ulliReceived );
+	void receive( float &fReceived );
+	void receive( double &dReceived );
+	void receive( long double &ldReceived );
+	
+	void transmitByte( unsigned char byteData );
+	void transmit( string strData );
+	
+	void transmit( char chData );
+	void transmit( unsigned char uchData );
+	void transmit( short int shiData );
+	void transmit( unsigned short int ushiData );
+	void transmit( int iData );
+	void transmit( unsigned int uiData );
+	void transmit( long int liData );
+	void transmit( unsigned long int uliData );
+	void transmit( long long int lliData );
+	void transmit( unsigned long long int ulliData );
+	void transmit( float fData );
+	void transmit( double dData );
+	void transmit( long double ldData );
+	
+	//////////////////////////////////////////////////////////////////////////
+	template<typename T>
+	USART0& operator<<( const T &RHS )
+	{
+		transmit( RHS );
+		return *this;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	template<typename T>
+	USART0& operator>>( T &RHS )
+	{
+		receive( RHS );
+		return *this;
+	}
+};
+
+#ifdef SECOND_USART
+
+class USART1 : public USART0
+{
+public:
+	USART1();
+	~USART1();
+};
+
+#endif
+
+#endif
--- a/usart/vector.h
+++ b/usart/vector.h
@@ -0,0 +1,188 @@
+/*
+* Copyright (c) by BlackMark 2015
+* Date 06/12/2015
+* Version 1.6
+*/
+
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <stdlib.h>
+#include <string.h>
+#include "cppalloc.h"
+
+template<typename T>
+class vector
+{
+private:
+	size_t m_sizeSize;
+	size_t m_sizeCapacity;
+	T* m_pData;
+	
+	//////////////////////////////////////////////////////////////////////////
+	void extend()
+	{
+		m_sizeCapacity = ( ( m_sizeCapacity > 0 ) ? ( 2 * m_sizeCapacity ) : ( 1 ) );
+		
+		T *pCopyData = new T[m_sizeCapacity];
+		memcpy( pCopyData, m_pData, m_sizeSize * sizeof( T ) );
+		
+		delete [] m_pData;
+		m_pData = pCopyData;
+	}
+	
+public:
+	//////////////////////////////////////////////////////////////////////////
+	vector() :
+	m_sizeSize( 0 ), m_sizeCapacity( 0 ), m_pData( nullptr )
+	{}
+	
+	//////////////////////////////////////////////////////////////////////////
+	vector( size_t sizeSize, const T &Value = T() ) :
+	m_sizeSize( sizeSize ), m_sizeCapacity( sizeSize ), m_pData( nullptr )
+	{
+		m_pData = new T[m_sizeCapacity];
+		
+		for( size_t i = 0; i < m_sizeSize; ++i )
+		{
+			m_pData[i] = Value;
+		}
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	vector( const vector &vecVector ) :
+	m_sizeSize( vecVector.m_sizeSize ), m_sizeCapacity( vecVector.m_sizeCapacity ), m_pData( nullptr )
+	{
+		m_pData = new T[m_sizeCapacity];
+		memcpy( m_pData, vecVector.m_pData, m_sizeSize * sizeof( T ) );
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	vector( vector &&vecVector ) :
+	m_sizeSize( vecVector.m_sizeSize ), m_sizeCapacity( vecVector.m_sizeCapacity ), m_pData( vecVector.m_pData )
+	{
+		vecVector.m_sizeSize = 0;
+		vecVector.m_sizeCapacity = 0;
+		vecVector.m_pData = nullptr;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	~vector()
+	{
+		delete [] m_pData;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	vector& operator=( const vector &vecRHS )
+	{
+		m_sizeSize = vecRHS.m_sizeSize;
+		m_sizeCapacity = vecRHS.m_sizeCapacity;
+		m_pData = new T[m_sizeCapacity];
+		memcpy( m_pData, vecRHS.m_pData, m_sizeSize * sizeof( T ) );
+
+		return *this;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	vector& operator=( vector &&vecRHS )
+	{
+		m_sizeSize = vecRHS.m_sizeSize;
+		m_sizeCapacity = vecRHS.m_sizeCapacity;
+		delete [] m_pData;
+		m_pData = vecRHS.m_pData;
+
+		vecRHS.m_sizeSize = 0;
+		vecRHS.m_sizeCapacity = 0;
+		vecRHS.m_pData = nullptr;
+
+		return *this;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	T* data()
+	{
+		return m_pData;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	const T* data() const
+	{
+		return m_pData;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	void clear()
+	{
+		delete [] m_pData;
+		m_pData = nullptr;
+		m_sizeSize = 0;
+		m_sizeCapacity = 0;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	void push_back( T const &Data )
+	{
+		if( m_sizeSize == m_sizeCapacity )
+		{
+			extend();
+		}
+		
+		m_pData[m_sizeSize++] = Data;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	void resize( size_t sizeSize, T val = T() )
+	{
+		if( sizeSize != m_sizeSize )
+		{
+			m_sizeCapacity = sizeSize;
+			
+			T *pCopyData = new T[m_sizeCapacity];
+			memcpy( pCopyData, m_pData, ( ( sizeSize < m_sizeSize ) ? ( sizeSize ) : ( m_sizeSize ) ) * sizeof( T ) );
+			
+			delete [] m_pData;
+			m_pData = pCopyData;
+			
+			if( sizeSize > m_sizeSize )
+			{
+				for( size_t i = m_sizeSize; i < sizeSize; ++i )
+				{
+					m_pData[i] = val;
+				}
+			}
+			
+			m_sizeSize = sizeSize;
+		}
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	size_t size() const
+	{
+		return m_sizeSize;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	bool empty() const
+	{
+		if( m_sizeSize == 0 )
+		{
+			return true;
+		}
+		
+		return false;
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	const T& operator[]( size_t sizeIndex ) const
+	{
+		return m_pData[sizeIndex];
+	}
+	
+	//////////////////////////////////////////////////////////////////////////
+	T& operator[]( size_t sizeIndex )
+	{
+		return m_pData[sizeIndex];
+	}
+};
+
+#endif