#include "usart.h"

//////////////////////////////////////////////////////////////////////////
USART0 USART0::sm_cInstance;

//////////////////////////////////////////////////////////////////////////
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

	m_vsizeRXBufferHead = 0;
	m_vsizeRXBufferTail = 0;
	m_vsizeTXBufferHead = 0;
	m_vsizeTXBufferTail = 0;
}

//////////////////////////////////////////////////////////////////////////
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::setRXInterrupt( bool bEnable )
{
	if( bEnable )
	{
		*m_vui8pUCSRB |= ( 1 << RXCIE_D );
	}
	else
	{
		*m_vui8pUCSRB &= ~( 1 << RXCIE_D );
	}
}

//////////////////////////////////////////////////////////////////////////
void USART0::setUDREInterrupt( bool bEnable )
{
	if( bEnable )
	{
		*m_vui8pUCSRB |= ( 1 << UDRIE_D );
	}
	else
	{
		*m_vui8pUCSRB &= ~( 1 << UDRIE_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 );
}

//////////////////////////////////////////////////////////////////////////
uint32_t USART0::getBaudRate()
{
	uint16_t ui16UBRR;
	ui16UBRR = static_cast<uint16_t>( *m_vui8pUBRRH ) << 8;
	ui16UBRR |= *m_vui8pUBRRL;

	return F_CPU / ( static_cast<uint32_t>( 16 ) * ( ui16UBRR + 1 ) );
}

//////////////////////////////////////////////////////////////////////////
uint8_t USART0::getDataBits()
{
	if( *m_vui8pUCSRB & ( 1 << UCSZ2_D ) )
	{
		return 9;
	}

	uint8_t ui8UCSRC = readUCSRC();

	bool bZeroBit = ui8UCSRC & ( 1 << UCSZ0_D );
	bool bOneBit = ui8UCSRC & ( 1 << UCSZ1_D );

	return 5 + ( bOneBit << 1 | bZeroBit );
}

//////////////////////////////////////////////////////////////////////////
USART0::Parity USART0::getParity()
{
	uint8_t ui8UCSRC = readUCSRC();

	bool bZeroBit = ui8UCSRC & ( 1 << UPM0_D );
	bool bOneBit = ui8UCSRC & ( 1 << UPM1_D );

	if( bOneBit && !bZeroBit )
	{
		return Parity::EVEN;
	}

	if( bOneBit && bZeroBit )
	{
		return Parity::ODD;
	}

	return Parity::DISABLED;
}

//////////////////////////////////////////////////////////////////////////
USART0::StopBit USART0::getStopBits()
{
	uint8_t ui8UCSRC = readUCSRC();

	if( ui8UCSRC & ( 1 << USBS_D ) )
	{
		return StopBit::TWO;
	}

	return StopBit::ONE;
}

//////////////////////////////////////////////////////////////////////////
USART0::~USART0()
{
	flushTransmit();

	setBaudRate( 0 );

	setRXState( false );
	setTXState( false );

	setRXInterrupt( false );
	setUDREInterrupt( false );
}

//////////////////////////////////////////////////////////////////////////
USART0& USART0::inst()
{
	return sm_cInstance;
}

//////////////////////////////////////////////////////////////////////////
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 );

	setRXInterrupt( true );
	setUDREInterrupt( false );
}

//////////////////////////////////////////////////////////////////////////
bool USART0::receiveByte( uint8_t &ui8Data )
{
	if( m_vsizeRXBufferHead == m_vsizeRXBufferTail && !( SREG & ( 1 << SREG_I ) ) )
	{
		while( !( *m_vui8pUCSRA & ( 1 << RXC_D ) ) );
		ui8Data = *m_vui8pUDR;
		return true;
	}
	else if( m_vsizeRXBufferHead == m_vsizeRXBufferTail )
	{
		return false;
	}

	ui8Data = m_vui8aRXBuffer[m_vsizeRXBufferTail];
	m_vsizeRXBufferTail = ( m_vsizeRXBufferTail + 1 ) % sm_sizeRXBUFFER_SIZE;

	return true;
}

//////////////////////////////////////////////////////////////////////////
bool USART0::receiveByte( uint8_t &ui8Data, uint16_t ui16TimeoutMS )
{
	uint16_t ui16DelayCounter = 0;

	while( !receiveByte( ui8Data ) )
	{
		_delay_ms( 1 );

		if( ui16DelayCounter++ > ui16TimeoutMS )
		{
			return false;
		}
	}

	return true;
}

//////////////////////////////////////////////////////////////////////////
uint8_t USART0::receiveByteBlocked()
{
	uint8_t ui8Received;
	while( !receiveByte( ui8Received ) );
	return ui8Received;
}

//////////////////////////////////////////////////////////////////////////
uint8_t USART0::receivePeek()
{
	uint8_t ui8Received;

	if( !( SREG & ( 1 << SREG_I ) && m_vsizeRXBufferHead == m_vsizeRXBufferTail ) )
	{
		while( !( *m_vui8pUCSRA & ( 1 << RXC_D ) ) );
		ui8Received = *m_vui8pUDR;

		size_t sizeIndex = ( m_vsizeRXBufferHead + 1 ) % sm_sizeRXBUFFER_SIZE;

		if( sizeIndex != m_vsizeRXBufferTail )
		{
			m_vui8aRXBuffer[m_vsizeRXBufferHead] = ui8Received;
			m_vsizeRXBufferHead = sizeIndex;
		}

		return ui8Received;
	}

	while( m_vsizeRXBufferHead == m_vsizeRXBufferTail );
	return m_vui8aRXBuffer[m_vsizeRXBufferTail];
}

//////////////////////////////////////////////////////////////////////////
bool USART0::receiveLine( char *szBuffer, size_t sizeBufferLength, const char *szLineTerminator /* = "\r\n" */ )
{
	size_t sizeReceived = 0;

	while( sizeReceived < sizeBufferLength - 1 )
	{
		uint8_t ui8ReceiveByte;

		while( !receiveByte( ui8ReceiveByte ) );
		szBuffer[sizeReceived++] = ui8ReceiveByte;
		szBuffer[sizeReceived] = '\0';
		
		if( strstr( szBuffer, szLineTerminator ) )
		{
			szBuffer[sizeReceived - strlen( szLineTerminator )] = '\0';
			return true;
		}
	}

	return false;
}

//////////////////////////////////////////////////////////////////////////
bool USART0::receiveLine( char *szBuffer, size_t sizeBufferLength, uint16_t ui16TimeoutMS, const char *szLineTerminator /* = "\r\n" */ )
{
	size_t sizeReceived = 0;

	while( sizeReceived < sizeBufferLength - 1 )
	{
		uint8_t ui8ReceiveByte;
		uint16_t ui16DelayCounter = 0;

		while( !receiveByte( ui8ReceiveByte ) )
		{
			_delay_ms( 1 );

			if( ui16DelayCounter++ > ui16TimeoutMS )
			{
				szBuffer[sizeReceived] = '\0';
				return false;
			}
		}

		szBuffer[sizeReceived++] = ui8ReceiveByte;
		szBuffer[sizeReceived] = '\0';
		
		if( strstr( szBuffer, szLineTerminator ) )
		{
			szBuffer[sizeReceived - strlen( szLineTerminator )] = '\0';
			return true;
		}
	}

	return false;
}

//////////////////////////////////////////////////////////////////////////
void USART0::flushReceive()
{
	uint32_t ui32BaudRate = getBaudRate();
	uint8_t ui8BitsPerSymbol = 1;

	ui8BitsPerSymbol += getDataBits();
	
	if( getParity() != Parity::DISABLED )
	{
		ui8BitsPerSymbol += 1;
	}

	if( getStopBits() == StopBit::ONE )
	{
		ui8BitsPerSymbol += 1;
	}
	else
	{
		ui8BitsPerSymbol += 2;
	}

	uint16_t ui16BaudDelayMS = static_cast<uint16_t>( ( 1000.0 * ui8BitsPerSymbol ) / ui32BaudRate ) + 1;

	uint8_t ui8Received;

	if( !( SREG & ( 1 << SREG_I ) ) )
	{
		while( true )
		{
			for( uint16_t i = 0; i < ui16BaudDelayMS; ++i )
			{
				_delay_ms( 1 );
			}

			if( m_vsizeRXBufferHead != m_vsizeRXBufferTail )
			{
				receiveByte( ui8Received );
				continue;
			}

			if( ( *m_vui8pUCSRA & ( 1 << RXC_D ) ) )
			{
				ui8Received = *m_vui8pUDR;
				continue;
			}

			break;
		}
	}
	else
	{
		while( receiveByte( ui8Received, ui16BaudDelayMS ) );
	}
}

//////////////////////////////////////////////////////////////////////////
void USART0::transmitByte( uint8_t ui8Data )
{
	if( m_vsizeTXBufferHead == m_vsizeTXBufferTail && *m_vui8pUCSRA & ( 1 << UDRE_D ) )
	{
		*m_vui8pUDR = ui8Data;
		return;
	}

	size_t sizeIndex = ( m_vsizeTXBufferHead + 1 ) % sm_sizeTXBUFFER_SIZE;

	while( sizeIndex == m_vsizeTXBufferTail )
	{
		if( !( SREG & ( 1 << SREG_I ) ) && *m_vui8pUCSRA & ( 1 << UDRE_D ) )
		{
			transmitInterruptHandler();
		}
	}

	m_vui8aTXBuffer[m_vsizeTXBufferHead] = ui8Data;
	m_vsizeTXBufferHead = sizeIndex;

	if( !( SREG & ( 1 << SREG_I ) ) )
	{
		while( !( *m_vui8pUCSRA & ( 1 << UDRE_D ) ) );
		transmitInterruptHandler();
	}
	else
	{
		setUDREInterrupt( true );
	}
}

//////////////////////////////////////////////////////////////////////////
void USART0::transmitString( const char *szString )
{
	while( *szString )
	{
		transmitByte( *szString++ );
	}
}

//////////////////////////////////////////////////////////////////////////
void USART0::flushTransmit()
{
	while( m_vsizeTXBufferHead != m_vsizeTXBufferTail && !( *m_vui8pUCSRA & ( 1 << UDRE_D ) ) );
}

//////////////////////////////////////////////////////////////////////////
void USART0::receiveInterruptHandler()
{
	uint8_t ui8ReceivedByte = *m_vui8pUDR;
	size_t sizeIndex = ( m_vsizeRXBufferHead + 1 ) % sm_sizeRXBUFFER_SIZE;

	if( sizeIndex != m_vsizeRXBufferTail )
	{
		m_vui8aRXBuffer[m_vsizeRXBufferHead] = ui8ReceivedByte;
		m_vsizeRXBufferHead = sizeIndex;
	}
}

//////////////////////////////////////////////////////////////////////////
void USART0::transmitInterruptHandler()
{
	uint8_t ui8TransmitByte = m_vui8aTXBuffer[m_vsizeTXBufferTail];
	m_vsizeTXBufferTail = ( m_vsizeTXBufferTail + 1 ) % sm_sizeTXBUFFER_SIZE;

	*m_vui8pUDR = ui8TransmitByte;

	if( m_vsizeTXBufferHead == m_vsizeTXBufferTail )
	{
		setUDREInterrupt( false );
	}
}

//////////////////////////////////////////////////////////////////////////
ISR( USART0_RX_vect_D )
{
	USART0::inst().receiveInterruptHandler();
}

//////////////////////////////////////////////////////////////////////////
ISR( USART0_UDRE_vect_D )
{
	USART0::inst().transmitInterruptHandler();
}

/************************************************************************/
/************************************************************************/

#ifdef SECOND_USART

//////////////////////////////////////////////////////////////////////////
USART1 USART1::sm_cInstance;

//////////////////////////////////////////////////////////////////////////
USART1& USART1::inst()
{
	return sm_cInstance;
}

//////////////////////////////////////////////////////////////////////////
USART1::USART1()
{
	m_vui8pUCSRA = &UCSR1A;
	m_vui8pUCSRB = &UCSR1B;
	m_vui8pUCSRC = &UCSR1C;
	m_vui8pUBRRH = &UBRR1H;
	m_vui8pUBRRL = &UBRR1L;
	m_vui8pUDR = &UDR1;
}

//////////////////////////////////////////////////////////////////////////
ISR( USART1_RX_vect_D )
{
	USART1::inst().receiveInterruptHandler();
}

//////////////////////////////////////////////////////////////////////////
ISR( USART1_UDRE_vect_D )
{
	USART1::inst().transmitInterruptHandler();
}

#endif