hierodule_spi.c

Go to the documentation of this file.

 
#include <hierodule_spi.h>
 
static HIERODULE_SPI_Wrapper *SPI1_Wrapper;
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
static HIERODULE_SPI_Wrapper *SPI2_Wrapper;
#endif 
#ifdef __STM32F401xC_H 
static HIERODULE_SPI_Wrapper *SPI3_Wrapper;
#endif 
static uint8_t ReceiveData(HIERODULE_SPI_Wrapper *Wrapper)
{
    return (uint8_t)(Wrapper->_SPI->DR);
}
 
 
void Enable(HIERODULE_SPI_Wrapper *Wrapper)
{
    SET_BIT(Wrapper->_SPI->CR1, SPI_CR1_SPE);
}
 
static void Disable(HIERODULE_SPI_Wrapper *Wrapper)
{
    CLEAR_BIT(Wrapper->_SPI->CR1, SPI_CR1_SPE);
}
 
uint8_t HIERODULE_SPI_GetNextByte(HIERODULE_SPI_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_SPI_TransmitByte(HIERODULE_SPI_Wrapper *Wrapper, uint8_t Byte)
{
    *((volatile uint8_t*) &(Wrapper->_SPI->DR)) = Byte;
}
 
HIERODULE_SPI_Wrapper **HIERODULE_SPI_InitWrapper( SPI_TypeDef *_SPI, uint8_t Mode, uint16_t RX_BufferSize, void (*TC_Handler)(void) )
{
    if( _SPI == NULL )
    {
        return NULL;
    }
 
    HIERODULE_SPI_Wrapper **Wrapper;
 
    uint32_t SPI_Address = (uint32_t)_SPI;
 
    switch(SPI_Address)
    {
        case ( (uint32_t)SPI1 ):
            Wrapper = &SPI1_Wrapper;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)SPI2 ):
            Wrapper = &SPI2_Wrapper;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)SPI3 ):
            Wrapper = &SPI3_Wrapper;
            break;
        #endif 
        default:
            return NULL;
            break;
    }
 
    (*Wrapper) = (HIERODULE_SPI_Wrapper*)malloc(sizeof(HIERODULE_SPI_Wrapper));
 
    (*Wrapper)->_SPI = _SPI;
 
    (*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)->TC_Handler = TC_Handler;
 
    (*Wrapper)->Mode = Mode;
 
    if( (*Wrapper)->Mode == 1 )
    {
        SET_BIT((*Wrapper)->_SPI->CR2, SPI_CR2_TXEIE);
    }
    else
    {
        SET_BIT((*Wrapper)->_SPI->CR2, SPI_CR2_RXNEIE);
        Enable(*Wrapper);
        (*Wrapper)->TX_Counter = 0;
        HIERODULE_SPI_TransmitByte(*Wrapper, 0);
    }
 
    return Wrapper;
}
 
void HIERODULE_SPI_ReleaseWrapper(HIERODULE_SPI_Wrapper *Wrapper)
{
    free(Wrapper->RX_Buffer);
    Wrapper->RX_Buffer = NULL;
 
    free(Wrapper);
    Wrapper = NULL;
}
 
void HIERODULE_SPI_TransmitPackage(HIERODULE_SPI_Wrapper *Wrapper, uint8_t *TX_Buffer, uint32_t Size)
{
    if(Size == 0)
        return;
 
    Wrapper->TX_Buffer = TX_Buffer;
    Wrapper->TX_BufferSize = Size;
    Wrapper->TX_Counter = 0;
 
    Enable(Wrapper);
}
 
void SPI_IRQ_Handler(HIERODULE_SPI_Wrapper *Wrapper)
{
    if( Wrapper->Mode == 1 )
    {
        if( READ_BIT(Wrapper->_SPI->CR1, SPI_CR1_SPE) == (SPI_CR1_SPE) )
        {
            if( READ_BIT(Wrapper->_SPI->SR, SPI_SR_TXE) == (SPI_SR_TXE) )
            {
                HIERODULE_SPI_TransmitByte(Wrapper, Wrapper->TX_Buffer[Wrapper->TX_Counter++]);
                while( READ_BIT(Wrapper->_SPI->SR, SPI_SR_TXE) != (SPI_SR_TXE) );
 
                while( READ_BIT(Wrapper->_SPI->SR, SPI_SR_RXNE) != (SPI_SR_RXNE) );
                Wrapper->RX_Buffer[Wrapper->RX_Index++] = ReceiveData(Wrapper);
                Wrapper->RX_Index %= Wrapper->RX_BufferSize;
                if( Wrapper->RX_New < Wrapper->RX_BufferSize )
                    Wrapper->RX_New++;
 
                if( Wrapper->TX_Counter == Wrapper->TX_BufferSize )
                {
                    while( READ_BIT(Wrapper->_SPI->SR, SPI_SR_BSY) == (SPI_SR_BSY) );
                    Disable(Wrapper);
                    if( Wrapper->TC_Handler != NULL )
                        Wrapper->TC_Handler();
                }
            }
        }
    }
    else if( Wrapper->Mode == 0 )
    {
        if( READ_BIT(Wrapper->_SPI->SR, SPI_SR_RXNE) == (SPI_SR_RXNE) )
        {
            Wrapper->RX_Buffer[Wrapper->RX_Index++] = ReceiveData(Wrapper);
            Wrapper->RX_Index %= Wrapper->RX_BufferSize;
            if( Wrapper->RX_New < Wrapper->RX_BufferSize )
                Wrapper->RX_New++;
 
            HIERODULE_SPI_TransmitByte(Wrapper, Wrapper->TX_Buffer[Wrapper->TX_Counter++]);
 
            if( Wrapper->TC_Handler != NULL )
                Wrapper->TC_Handler();
        }
    }
}
 
extern void SPI1_IRQHandler(void)
{
    if( SPI1_Wrapper != NULL )
        SPI_IRQ_Handler(SPI1_Wrapper);
}
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
extern void SPI2_IRQHandler(void)
{
    if( SPI2_Wrapper != NULL )
        SPI_IRQ_Handler(SPI2_Wrapper);
}
#endif 
#ifdef __STM32F401xC_H 
extern void SPI3_IRQHandler(void)
{
    if( SPI3_Wrapper != NULL )
        SPI_IRQ_Handler(SPI3_Wrapper);
}
#endif