hierodule_usart.c

Go to the documentation of this file.

 
#include <hierodule_usart.h>
 
static HIERODULE_USART_Wrapper *USART1_Wrapper = NULL;
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
static HIERODULE_USART_Wrapper *USART2_Wrapper = NULL;
#endif 
#ifdef __STM32F103xB_H 
static HIERODULE_USART_Wrapper *USART3_Wrapper = NULL;
#endif 
#ifdef __STM32F401xC_H 
static HIERODULE_USART_Wrapper *USART6_Wrapper = NULL;
#endif 
uint8_t ReceiveByte(HIERODULE_USART_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    return (uint8_t)(READ_BIT(Wrapper->USART->RDR, USART_RDR_RDR));
    #else 
    return (uint8_t)(READ_BIT(Wrapper->USART->DR, USART_DR_DR));
    #endif 
}
 
HIERODULE_USART_Wrapper **HIERODULE_USART_InitWrapper
(
    USART_TypeDef *USART,
    uint16_t RX_BufferSize,
    void (*RX_Handler)(uint8_t)
)
{
    if( USART == NULL )
    {
        return NULL;
    }
 
    HIERODULE_USART_Wrapper **Wrapper;
 
    uint32_t USART_Address = (uint32_t)USART;
 
    switch(USART_Address)
    {
        case ( (uint32_t)USART1 ):
            Wrapper = &USART1_Wrapper;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)USART2 ):
            Wrapper = &USART2_Wrapper;
            break;
        #endif
        #ifdef __STM32F103xB_H 
        case ( (uint32_t)USART3 ):
            Wrapper = &USART3_Wrapper;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)USART6 ):
            Wrapper = &USART6_Wrapper;
            break;
        #endif 
        default:
            return NULL;
            break;
    }
 
    (*Wrapper) = (HIERODULE_USART_Wrapper*)malloc(sizeof(HIERODULE_USART_Wrapper));
 
    (*Wrapper)->USART = USART;
 
    (*Wrapper)->RX_Index = 0;
    (*Wrapper)->RX_New = 0;
 
    (*Wrapper)->RX_BufferSize = RX_BufferSize;
    (*Wrapper)->RX_Buffer = (uint8_t*)malloc( ((*Wrapper)->RX_BufferSize) * sizeof(uint8_t));
    for( uint16_t _rxb_init = 0 ; _rxb_init < (*Wrapper)->RX_BufferSize ; _rxb_init++ )
    {
        ((*Wrapper)->RX_Buffer)[_rxb_init] = '\0';
    }
    (*Wrapper)->RX_Handler = RX_Handler;
 
    CLEAR_BIT((*Wrapper)->USART->CR1, USART_CR1_RE);
 
    #ifdef __STM32F030x6_H 
    CLEAR_BIT((*Wrapper)->USART->ISR, USART_ISR_RXNE);
    #else 
    CLEAR_BIT((*Wrapper)->USART->SR, USART_SR_RXNE);
    #endif 
    return Wrapper;
}
 
void HIERODULE_USART_ReleaseWrapper(HIERODULE_USART_Wrapper *Wrapper)
{
 
    CLEAR_BIT(Wrapper->USART->CR1, USART_CR1_RE);
 
    #ifdef __STM32F030x6_H 
    CLEAR_BIT(Wrapper->USART->ISR, USART_ISR_RXNE);
    #else 
    CLEAR_BIT(Wrapper->USART->SR, USART_SR_RXNE);
    #endif 
    free(Wrapper->RX_Buffer);
    Wrapper->RX_Buffer = NULL;
 
    free(Wrapper);
    Wrapper = NULL;
}
 
void HIERODULE_USART_Enable_IT_RXNE(HIERODULE_USART_Wrapper *Wrapper)
{
    SET_BIT(Wrapper->USART->CR1, USART_CR1_RXNEIE);
    SET_BIT(Wrapper->USART->CR1, USART_CR1_RE);
}
 
void HIERODULE_USART_Disable_IT_RXNE(HIERODULE_USART_Wrapper *Wrapper)
{
    CLEAR_BIT(Wrapper->USART->CR1, USART_CR1_RXNEIE);
    CLEAR_BIT(Wrapper->USART->CR1, USART_CR1_RE);
}
 
uint32_t HIERODULE_USART_IsActiveFlag_RXNE(HIERODULE_USART_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    return (READ_BIT(Wrapper->USART->ISR, USART_ISR_RXNE) == (USART_ISR_RXNE));
    #else 
    return (READ_BIT(Wrapper->USART->SR, USART_SR_RXNE) == (USART_SR_RXNE));
    #endif 
}
 
uint32_t HIERODULE_USART_IsActiveFlag_TXE(HIERODULE_USART_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    return (READ_BIT(Wrapper->USART->ISR, USART_ISR_TXE) == (USART_ISR_TXE));
    #else 
    return (READ_BIT(Wrapper->USART->SR, USART_SR_TXE) == (USART_SR_TXE));
    #endif 
}
 
uint8_t HIERODULE_USART_GetNextByte(HIERODULE_USART_Wrapper *Wrapper)
{
    if(Wrapper->RX_New > 0)
    {
        Wrapper->RX_New--;
 
        return Wrapper->RX_Buffer
        [
            (Wrapper->RX_Index + Wrapper->RX_BufferSize - (Wrapper->RX_New+1) )
            % Wrapper->RX_BufferSize
        ];
    }
    else
    {
        return '\0';
    }
}
 
void HIERODULE_USART_TransmitByte(HIERODULE_USART_Wrapper *Wrapper, uint8_t Byte)
{
    while
    (
        ( HIERODULE_USART_IsActiveFlag_RXNE(Wrapper) )
        ||
        ( !(HIERODULE_USART_IsActiveFlag_TXE(Wrapper)) )
    );
 
    #ifdef __STM32F030x6_H 
    Wrapper->USART->TDR = Byte;
    #else 
    Wrapper->USART->DR = Byte;
    #endif 
}
 
void HIERODULE_USART_TransmitString(HIERODULE_USART_Wrapper *Wrapper, char *String)
{
    volatile uint32_t _ctr = 0;
    while( 1 )
    {
        if( String[_ctr] == '\0' )
        {
            break;
        }
        else
        {
            HIERODULE_USART_TransmitByte( Wrapper, String[_ctr] );
            _ctr++;
        }
    }
}
 
void USART_IRQHandler(HIERODULE_USART_Wrapper *Wrapper)
{
    if( HIERODULE_USART_IsActiveFlag_RXNE(Wrapper) )
    {
        if(Wrapper != NULL)
        {
            Wrapper->RX_Buffer[Wrapper->RX_Index] =
            ReceiveByte(Wrapper);
 
            Wrapper->RX_Index++;
            Wrapper->RX_Index %= Wrapper->RX_BufferSize;
 
            if( Wrapper->RX_New < Wrapper->RX_BufferSize )
                Wrapper->RX_New++;
 
            if(Wrapper->RX_Handler != NULL)
            {
                Wrapper->RX_Handler
                (
                    HIERODULE_USART_GetNextByte(Wrapper)
                );
            }
        }
    }
}
extern void USART1_IRQHandler(void)
{
    USART_IRQHandler(USART1_Wrapper);
}
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
extern void USART2_IRQHandler(void)
{
    USART_IRQHandler(USART2_Wrapper);
}
#endif
 
#ifdef __STM32F103xB_H 
extern void USART3_IRQHandler(void)
{
    USART_IRQHandler(USART3_Wrapper);
}
#endif
 
#ifdef __STM32F401xC_H 
extern void USART6_IRQHandler(void)
{
    USART_IRQHandler(USART6_Wrapper);
}
#endif