avr_usart.h

Go to the documentation of this file.

 
#ifndef AVR_USART_H_
#define AVR_USART_H_
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include "avr_macros.h"
#include "avr_utils.h"
 
#pragma message ( "avr_usart.h included" )
 
#define USART_SYNCHRONOUS_CLOCK_PRIORITY 0   
#define USART_MODE_ASYNCHRONOUS (0<<UMSEL00)                                    
#define USART_MODE_SYNCHRONOUS  (1<<UMSEL00) | USART_SYNCHRONOUS_CLOCK_PRIORITY 
#define USART_MODE_MASK         (1<<UMSEL00) 
#define USART_PARITY_BIT_NO   (0<<UPM00)              
#define USART_PARITY_BIT_EVEN (1<<UPM01)              
#define USART_PARITY_BIT_ODD  (1<<UPM01) | (1<<UPM00) 
#define USART_PARITY_BIT_MASK (1<<UPM01) | (1<<UPM00) 
#define USART_STOP_BIT_ONE  (0<<USBS0) 
#define USART_STOP_BIT_TWO  (1<<USBS0) 
#define USART_STOP_BIT_MASK (1<<USBS0) 
#define USART_DATA_BIT_FIVE  (0<<UCSZ00)               
#define USART_DATA_BIT_SIX   (1<<UCSZ00)               
#define USART_DATA_BIT_SEVEN (1<<UCSZ01)               
#define USART_DATA_BIT_EIGHT (1<<UCSZ01) | (1<<UCSZ00) 
#define USART_DATA_BIT_MASK  (1<<UCSZ01) | (1<<UCSZ00) 
#define USART_RX_COMPLETE_INTERRUPT         (1<<RXCIE0) 
#define USART_TX_COMPLETE_INTERRUPT         (1<<TXCIE0) 
#define USART_DATA_REGISTER_EMPTY_INTERRUPT (1<<UDRIE0) 
typedef struct USART_ConfigData
{
    uint8_t  UsartMode;
    uint16_t BaudRate;
    uint8_t  ParityBit;
    uint8_t  StopBit;
    uint8_t  DataBit;
} USART_ConfigData;
static volatile uint8_t *USART_TransmitBuffer;           
static volatile uint8_t  USART_TransmitBusyFlag = 0;     
static volatile uint16_t USART_TransmitBufferIndex = 0;  
static volatile uint16_t USART_TransmitBufferLength = 0; 
static volatile uint8_t *USART_ReceiveBuffer;            
static volatile uint8_t  USART_ReceiveBusyFlag = 0;      
static volatile uint16_t USART_ReceiveBufferIndex = 0;   
static volatile uint16_t USART_ReceiveBufferLength  = 0; 
void USART_FlushTransmitBuffer();
void USART_FlushReceiveBuffer();
inline void USART_EnableTransmitInterrupt();
inline void USART_DisableTransmitInterrupt();
inline void USART_EnableReceiveInterrupt();
inline void USART_DisableReceiveInterrupt();
void USART_Init(USART_ConfigData Data);
void USART_DeInit();
uint8_t USART_ReceiveBlocking();
uint8_t USART_ReceiveByte(uint8_t *Buffer);
uint8_t USART_ReceiveTwoBytes(uint16_t *Buffer);
uint8_t USART_ReceiveBytes(uint8_t *Buffer, uint16_t Size);
uint8_t USART_ReceiveChar(char *Character);
uint8_t USART_ReceiveInt(int *Number, uint8_t Size);
uint8_t USART_ReceiveLong(long *Number, uint8_t Size);
uint8_t USART_ReceiveString(char *Buffer, uint16_t Size);
void USART_CancelReceive();
uint8_t USART_TransmitBlocking(uint8_t *Buffer);
uint8_t USART_TransmitByte(uint8_t *Buffer);
uint8_t USART_TransmitTwoBytes(uint16_t *Buffer);
uint8_t USART_TransmitBytes(uint8_t *Buffer, uint16_t Size);
uint8_t USART_TransmitChar(char Character);
uint8_t USART_TransmitInt(int Number);
uint8_t USART_TransmitLong(long Number);
uint8_t USART_TransmitFloat(float Number, uint8_t Precision);
uint8_t USART_TransmitString(char *Buffer);
void USART_CancelTransmit();
void USART_FlushReceiveBuffer()
{   
    for (int i = 0; i < USART_ReceiveBufferLength; i++)
    {
        USART_ReceiveBuffer[i] = 0;
    }
    
    USART_ReceiveBuffer = 0;
    USART_ReceiveBusyFlag = 0;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBufferLength = 0;
}
 
void USART_FlushTransmitBuffer()
{
    for (int i = 0; i < USART_TransmitBufferLength; i++)
    {
        USART_TransmitBuffer[i] = 0;
    }
    
    USART_TransmitBuffer = 0;
    USART_TransmitBusyFlag = 0;
    USART_TransmitBufferIndex = 0;
    USART_TransmitBufferLength = 0;
}
 
inline void USART_EnableTransmitInterrupt()
{
    UCSR0B |= USART_DATA_REGISTER_EMPTY_INTERRUPT;
}
 
inline void USART_DisableTransmitInterrupt()
{
    UCSR0B &= ~USART_DATA_REGISTER_EMPTY_INTERRUPT;
}
 
inline void USART_EnableReceiveInterrupt()
{
    UCSR0B |= USART_RX_COMPLETE_INTERRUPT;
}
 
inline void USART_DisableReceiveInterrupt()
{
    UCSR0B &= ~USART_RX_COMPLETE_INTERRUPT;
}
 
void USART_Init(USART_ConfigData Data)
{   
    uint16_t USART_BaudPrescaler = 0;
     
    if (Data.UsartMode == (USART_MODE_ASYNCHRONOUS))
    {
        USART_BaudPrescaler =  (((F_CPU / (Data.BaudRate * 16UL))) - 1);
    } 
    else if (Data.UsartMode == (USART_MODE_SYNCHRONOUS))
    {
        USART_BaudPrescaler =  (((F_CPU / (Data.BaudRate * 2UL))) - 1);
    }
    
    /* Set Baud Rate */
    UBRR0H = USART_BaudPrescaler >> 8;
    UBRR0L = USART_BaudPrescaler;
    
    /* Set Frame Format */
    UCSR0C = Data.UsartMode | Data.ParityBit | Data.StopBit | Data.DataBit;
    
    /* Enable Receiver and Transmitter */
    UCSR0B = (1<<RXEN0) | (1<<TXEN0);
    
    /* Enable Global Interrupt */
    sei();
}
 
void USART_DeInit()
{
    UCSR0B = 0x00;
    UCSR0C = 0x06;
}
 
uint8_t USART_ReceiveBlocking()
{
    uint8_t DataByte;
    while ((UCSR0A & (1<<RXC0)) == 0); // Do nothing until data have been received
    DataByte = UDR0;
    return DataByte;
}
 
uint8_t USART_ReceiveByte(uint8_t *Buffer)
{
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = Buffer;
    USART_ReceiveBufferLength = 1;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    return OK;
}
 
uint8_t USART_ReceiveTwoBytes(uint16_t *Buffer)
{
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = (uint8_t*)Buffer;
    USART_ReceiveBufferLength = 2;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    return OK;
}
 
uint8_t USART_ReceiveBytes(uint8_t *Buffer, uint16_t Size)
{
    if (Size == 0) return ERROR;
    
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = Buffer;
    USART_ReceiveBufferLength = Size;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    return OK;
}
 
uint8_t USART_ReceiveChar(char *Character)
{
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = (uint8_t*)Character;
    USART_ReceiveBufferLength = 1;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    return OK;
}
 
uint8_t USART_ReceiveInt(int *Number, uint8_t Size)
{
    if (Size == 0) return ERROR;
    
    char localbuffer[7] = {0};
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = (uint8_t*)localbuffer;
    USART_ReceiveBufferLength = Size;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    while (USART_ReceiveBusyFlag);
    *Number = UTILS_StringToInt(localbuffer);
    return OK;
}
 
uint8_t USART_ReceiveLong(long *Number, uint8_t Size)
{
    if (Size == 0) return ERROR;
    
    char localbuffer[12] = {0};
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = (uint8_t*)localbuffer;
    USART_ReceiveBufferLength = Size;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    while (USART_ReceiveBusyFlag);
    *Number = UTILS_StringToLong(localbuffer);
    return OK;
}
 
uint8_t USART_ReceiveString(char *Buffer, uint16_t Size)
{
    if (Size == 0) return ERROR;
    
    while (USART_ReceiveBusyFlag)
    {
        return BUSY;
    }
    USART_ReceiveBuffer = (uint8_t*)Buffer;
    USART_ReceiveBufferLength = Size;
    USART_ReceiveBufferIndex = 0;
    USART_ReceiveBusyFlag = 1;
    USART_EnableReceiveInterrupt();
    return OK;
}
 
void USART_CancelReceive()
{
    USART_DisableReceiveInterrupt();
    USART_ReceiveBusyFlag = 0;
}
 
uint8_t USART_TransmitBlocking(uint8_t *Buffer)
{
    while ((UCSR0A & (1<<UDRE0)) == 0); // Do nothing until UDR is ready
    UDR0 = *Buffer;
    return OK;
}
 
uint8_t USART_TransmitByte(uint8_t *Buffer)
{
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    USART_TransmitBuffer = Buffer;
    USART_TransmitBufferLength = 1;
    USART_TransmitBufferIndex = 0;
    USART_TransmitBusyFlag = 1;
    USART_EnableTransmitInterrupt();
    return OK;
}
 
uint8_t USART_TransmitTwoBytes(uint16_t *Buffer)
{   
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    USART_TransmitBuffer = (uint8_t*)Buffer;
    USART_TransmitBufferLength = 2;
    USART_TransmitBufferIndex = 0;
    USART_TransmitBusyFlag = 1;
    USART_EnableTransmitInterrupt();
    return OK;
}
 
uint8_t USART_TransmitBytes(uint8_t *Buffer, uint16_t Size)
{
    if (Size == 0) return ERROR;
    
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    USART_TransmitBuffer = Buffer;
    USART_TransmitBufferLength = Size;
    USART_TransmitBufferIndex = 0;
    USART_TransmitBusyFlag = 1;
    USART_EnableTransmitInterrupt();
    return OK;
}
 
uint8_t USART_TransmitChar(char Character)
{
    uint8_t* data = (uint8_t*)&Character;
    return USART_TransmitByte(data);
}
 
uint8_t USART_TransmitInt(int Number)
{
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    static uint8_t localbuffer[7] = {0};
    uint16_t Length = UTILS_IntToString(Number,(char*)localbuffer);
    return USART_TransmitBytes(localbuffer,Length);
}
 
uint8_t USART_TransmitLong(long Number)
{
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    static uint8_t localbuffer[12] = {0};
    uint16_t Length = UTILS_LongToString(Number,(char*)localbuffer);
    return USART_TransmitBytes(localbuffer,Length);
}
 
uint8_t USART_TransmitFloat(float Number,uint8_t Precision)
{
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    static uint8_t localbuffer[17] = {0};
    uint16_t Length = UTILS_FloatToString(Number,(char*)localbuffer,Precision);
    return USART_TransmitBytes(localbuffer,Length);
}
 
uint8_t USART_TransmitString(char *Buffer)
{
    while (USART_TransmitBusyFlag)
    {
        return BUSY;
    }
    const char *p = Buffer;
    while (*p) ++p;
    uint16_t Size = p - Buffer;
    USART_TransmitBuffer = (uint8_t*)Buffer;
    USART_TransmitBufferLength = Size;
    USART_TransmitBufferIndex = 0;
    USART_TransmitBusyFlag = 1;
    USART_EnableTransmitInterrupt();
    return OK;
}
 
void USART_CancelTransmit()
{
    USART_DisableTransmitInterrupt();
    USART_TransmitBusyFlag = 0;
}
 
ISR(USART_RX_vect)
{
    if(USART_ReceiveBufferIndex < USART_ReceiveBufferLength)
    {
        USART_ReceiveBuffer[USART_ReceiveBufferIndex] = UDR0;
        USART_ReceiveBufferIndex++;
    }
    if(USART_ReceiveBufferIndex >= USART_ReceiveBufferLength)
    {
        USART_ReceiveBusyFlag = 0;
        USART_DisableReceiveInterrupt();
    }
}
 
ISR(USART_UDRE_vect)
{
    if(USART_TransmitBufferIndex < USART_TransmitBufferLength)
    {
        UDR0 = USART_TransmitBuffer[USART_TransmitBufferIndex];
        USART_TransmitBufferIndex++; 
    }
    if(USART_TransmitBufferIndex >= USART_TransmitBufferLength)
    {
        USART_TransmitBusyFlag = 0;
        USART_DisableTransmitInterrupt();
    }
}
 
#endif /* AVR_USART_H_ */