hierodule_i2c.c

Go to the documentation of this file.

 
#include <hierodule_i2c.h>
 
static HIERODULE_I2C_Wrapper *I2C1_Wrapper;
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
static HIERODULE_I2C_Wrapper *I2C2_Wrapper;
 
#endif 
#ifdef __STM32F401xC_H 
static HIERODULE_I2C_Wrapper *I2C3_Wrapper;
#endif 
void Idle(HIERODULE_I2C_Wrapper *Wrapper, uint32_t NumberOfPeriods)
{
    for(uint32_t i = 0 ; i < Wrapper->I2C_Period_Length*NumberOfPeriods ; i++)
    {
        __NOP();
    }
}
 
void EnableClockStretching(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    CLEAR_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE);
    while( 1 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE) == (I2C_CR1_PE)) );
    #endif 
    CLEAR_BIT(Wrapper->_I2C->CR1, I2C_CR1_NOSTRETCH);
 
    while( 0 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_NOSTRETCH) != (I2C_CR1_NOSTRETCH)) );
 
    #ifdef __STM32F030x6_H 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE);
    while( 0 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE) == (I2C_CR1_PE)) );
    #endif 
}
 
void DisableClockStretching(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    CLEAR_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE);
    while( 1 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE) == (I2C_CR1_PE)) );
    #endif 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_NOSTRETCH);
 
    while( 1 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_NOSTRETCH) != (I2C_CR1_NOSTRETCH)) );
 
    #ifdef __STM32F030x6_H 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE);
    while( 0 == (READ_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE) == (I2C_CR1_PE)) );
    #endif 
}
 
static uint8_t ReceiveData(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    return (uint8_t)(READ_BIT(Wrapper->_I2C->RXDR, I2C_RXDR_RXDATA));
    #else 
    return (uint8_t)(READ_BIT(Wrapper->_I2C->DR, I2C_DR_DR));
    #endif 
}
 
void TransmitData(HIERODULE_I2C_Wrapper *Wrapper, uint8_t Byte)
{
    #ifdef __STM32F030x6_H 
    WRITE_REG(Wrapper->_I2C->TXDR, Byte);
    #else 
    MODIFY_REG(Wrapper->_I2C->DR, I2C_DR_DR, Byte);
    #endif 
}
 
void ACK_Next(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifndef __STM32F030x6_H 
    MODIFY_REG(Wrapper->_I2C->CR1, I2C_CR1_ACK, I2C_CR1_ACK);
    #else 
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_NACK, 0);
    #endif 
}
 
void NACK_Next(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifndef __STM32F030x6_H 
    MODIFY_REG(Wrapper->_I2C->CR1, I2C_CR1_ACK, 0);
    #else 
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_NACK, I2C_CR2_NACK);
    #endif 
}
 
void Start(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifndef __STM32F030x6_H 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_START);
    #else 
    SET_BIT(Wrapper->_I2C->CR2, I2C_CR2_START);
    #endif 
}
 
void Stop(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifndef __STM32F030x6_H 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_STOP);
    #else 
    SET_BIT(Wrapper->_I2C->CR2, I2C_CR2_STOP);
    #endif 
}
 
void ReceiveByteAsMaster(HIERODULE_I2C_Wrapper *Wrapper)
{
    (Wrapper->MRX_Buffer)[Wrapper->MRX_Counter] =
    ReceiveData(Wrapper);
 
    Wrapper->MRX_Counter++;
    if(Wrapper->MRX_Counter == Wrapper->MRX_BufferSize)
    {
        Wrapper->Status = HIERODULE_I2C_Status_IDLE;
        Wrapper->SlaveAddress = 0;
 
        Stop(Wrapper);
 
        #ifndef __STM32F030x6_H 
        EnableClockStretching(Wrapper);
        #endif 
        ACK_Next(Wrapper);
 
        if( Wrapper->MRX_Handler != NULL)
            Wrapper->MRX_Handler();
    }
    else if(Wrapper->MRX_Counter == Wrapper->MRX_BufferSize-1)
    {
        NACK_Next(Wrapper);
        __NOP();
    }
}
 
void ReceiveByteAsSlave(HIERODULE_I2C_Wrapper *Wrapper)
{
    Wrapper->SRX_Buffer[Wrapper->SRX_Index] =
    ReceiveData(Wrapper);
 
    Wrapper->SRX_Index++;
    Wrapper->SRX_Index %= Wrapper->SRX_BufferSize;
 
    if( Wrapper->SRX_New < Wrapper->SRX_BufferSize )
        Wrapper->SRX_New++;
}
 
void TransmitByteAsMaster(HIERODULE_I2C_Wrapper *Wrapper)
{
    TransmitData(Wrapper, (Wrapper->MTX_Buffer)[Wrapper->MTX_Counter]);
    Wrapper->MTX_Counter++;
    if( Wrapper->MTX_Counter == Wrapper->MTX_BufferSize )
    {
        #ifndef __STM32F030x6_H 
        while(READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_TXE) != (I2C_SR1_TXE))
        #else 
        while(READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_TC) != (I2C_ISR_TC));
        #endif 
        Wrapper->Status = HIERODULE_I2C_Status_IDLE;
        Wrapper->SlaveAddress = 0;
        Stop(Wrapper);
        #ifdef __STM32F030x6_H 
        while( 0 == READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_STOPF) );
        #endif 
        EnableClockStretching(Wrapper);
        if( Wrapper->MTX_Handler != NULL)
            Wrapper->MTX_Handler();
    }
}
 
void TransmitByteAsSlave(HIERODULE_I2C_Wrapper *Wrapper)
{
    if( Wrapper->STX_Buffer != NULL )
        TransmitData(Wrapper, (Wrapper->STX_Buffer)[(Wrapper->STX_Counter)++]);
    else
        TransmitData(Wrapper, 0);
 
    Idle(Wrapper, 1);
}
 
void ReturnToIdleState(HIERODULE_I2C_Wrapper *Wrapper)
{
    #ifdef __STM32F030x6_H 
    SET_BIT(Wrapper->_I2C->ICR, I2C_ICR_STOPCF);
    #else 
    SET_BIT(Wrapper->_I2C->CR1, I2C_CR1_PE);
    #endif 
    if( Wrapper->SRX_Handler != NULL)
        Wrapper->SRX_Handler();
    Wrapper->Status = HIERODULE_I2C_Status_IDLE;
}
 
void Receive_NACK(HIERODULE_I2C_Wrapper *Wrapper)
{
    if(Wrapper->Status == HIERODULE_I2C_Status_STX )
    {
        #ifdef __STM32F030x6_H 
        SET_BIT(Wrapper->_I2C->ICR, I2C_ICR_NACKCF);
        while( 1 == READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_NACKF) );
        #else 
        CLEAR_BIT(Wrapper->_I2C->SR1, I2C_SR1_AF);
        #endif 
        #ifdef __STM32F030x6_H 
        TransmitByteAsSlave(Wrapper);
        while( 0 == READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_STOPF) );
        SET_BIT(Wrapper->_I2C->ICR, I2C_ICR_STOPCF);
        while( 1 == READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_STOPF) );
        #endif 
        if( Wrapper->STX_Handler != NULL)
            Wrapper->STX_Handler();
        Wrapper->Status = HIERODULE_I2C_Status_IDLE;
 
    }
}
 
uint8_t HIERODULE_I2C_GetNextByte(HIERODULE_I2C_Wrapper *Wrapper)
{
    if(Wrapper->SRX_New > 0)
    {
        Wrapper->SRX_New--;
 
        return Wrapper->SRX_Buffer
        [
            (Wrapper->SRX_Index + Wrapper->SRX_BufferSize - (Wrapper->SRX_New+1) )
            % Wrapper->SRX_BufferSize
        ];
    }
    else
    {
        return 0;
    }
}
 
HIERODULE_I2C_Wrapper **HIERODULE_I2C_InitWrapper(I2C_TypeDef *_I2C, uint16_t SRX_BufferSize, void (*SRX_Handler)(void), void (*MTX_Handler)(void), void (*STX_Handler)(void), void (*MRX_Handler)(void))
{
    if( _I2C == NULL )
    {
        return NULL;
    }
 
    HIERODULE_I2C_Wrapper **Wrapper;
 
    uint32_t I2C_Address = (uint32_t)_I2C;
 
    switch(I2C_Address)
    {
        case ( (uint32_t)I2C1 ):
            Wrapper = &I2C1_Wrapper;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)I2C2 ):
            Wrapper = &I2C2_Wrapper;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)I2C3 ):
            Wrapper = &I2C3_Wrapper;
            break;
        #endif 
        default:
            return NULL;
            break;
    }
 
    (*Wrapper) = (HIERODULE_I2C_Wrapper*)malloc(sizeof(HIERODULE_I2C_Wrapper));
 
    (*Wrapper)->_I2C = _I2C;
 
    (*Wrapper)->SRX_Index = 0;
    (*Wrapper)->SRX_New = 0;
 
    (*Wrapper)->SRX_BufferSize = SRX_BufferSize;
    (*Wrapper)->SRX_Buffer = (uint8_t*)malloc( ((*Wrapper)->SRX_BufferSize) * sizeof(uint8_t));
    for( uint16_t _rxb_init = 0 ; _rxb_init < (*Wrapper)->SRX_BufferSize ; _rxb_init++ )
    {
        ((*Wrapper)->SRX_Buffer)[_rxb_init] = '\0';
    }
 
    (*Wrapper)->SRX_Handler = SRX_Handler;
    (*Wrapper)->MTX_Handler = MTX_Handler;
    (*Wrapper)->STX_Handler = STX_Handler;
    (*Wrapper)->MRX_Handler = MRX_Handler;
 
    (*Wrapper)->STX_Buffer = NULL;
    (*Wrapper)->STX_Counter = 0;
    
    (*Wrapper)->Status = HIERODULE_I2C_Status_IDLE;
    (*Wrapper)->SlaveAddress = 0;
 
    
    #ifdef __STM32F030x6_H 
    SET_BIT((*Wrapper)->_I2C->CR1, I2C_CR1_ADDRIE);
    SET_BIT((*Wrapper)->_I2C->CR1, I2C_CR1_NACKIE);
    SET_BIT((*Wrapper)->_I2C->CR1, I2C_CR1_STOPIE);
    CLEAR_BIT((*Wrapper)->_I2C->CR2, I2C_CR2_AUTOEND);
    SET_BIT((*Wrapper)->_I2C->CR1, I2C_CR1_TXIE);
    SET_BIT((*Wrapper)->_I2C->CR1, I2C_CR1_RXIE);
    #else 
    SET_BIT((*Wrapper)->_I2C->CR2, I2C_CR2_ITEVTEN | I2C_CR2_ITBUFEN);
    SET_BIT((*Wrapper)->_I2C->CR2, I2C_CR2_ITEVTEN | I2C_CR2_ITBUFEN);
    #endif 
    EnableClockStretching(*Wrapper);
    ACK_Next(*Wrapper);
 
    #ifdef __STM32F030x6_H 
    uint32_t bus_clock;
    if( ((uint32_t)READ_BIT(RCC->CFGR3, RCC_CFGR3_I2C1SW) ) == RCC_CFGR3_I2C1SW_SYSCLK)
        bus_clock = SystemCoreClock;
    else
        bus_clock = HSI_VALUE;
 
    double core_clock_rate = ((double)SystemCoreClock)/(bus_clock);
 
    (*Wrapper)->I2C_Period_Length = core_clock_rate *
    ((((uint32_t)(READ_BIT((*Wrapper)->_I2C->TIMINGR, I2C_TIMINGR_PRESC) >> I2C_TIMINGR_PRESC_Pos))+1) *
    (
    ((uint32_t)(READ_BIT((*Wrapper)->_I2C->TIMINGR, I2C_TIMINGR_SCLL) >> I2C_TIMINGR_SCLL_Pos))+1
    +((uint32_t)(READ_BIT((*Wrapper)->_I2C->TIMINGR, I2C_TIMINGR_SCLH) >> I2C_TIMINGR_SCLH_Pos))+1
    +((uint32_t)(READ_BIT((*Wrapper)->_I2C->TIMINGR, I2C_TIMINGR_SDADEL) >> I2C_TIMINGR_SDADEL_Pos))
    +((uint32_t)(READ_BIT((*Wrapper)->_I2C->TIMINGR, I2C_TIMINGR_SCLDEL) >> I2C_TIMINGR_SCLDEL_Pos))+1
    )
    );
 
    #else 
    (*Wrapper)->I2C_Period_Length = SystemCoreClock /
    (( ((uint32_t)(READ_BIT((*Wrapper)->_I2C->CCR, I2C_CCR_FS))) == 0)
    ? 100000 : 400000);
    #endif 
    return Wrapper;
}
 
void HIERODULE_I2C_ReleaseWrapper(HIERODULE_I2C_Wrapper *Wrapper)
{
    free(Wrapper->SRX_Buffer);
    Wrapper->SRX_Buffer = NULL;
 
    free(Wrapper->MTX_Buffer);
    Wrapper->MTX_Buffer = NULL;
 
    free(Wrapper->MRX_Buffer);
    Wrapper->MRX_Buffer = NULL;
 
    free(Wrapper->STX_Buffer);
    Wrapper->STX_Buffer = NULL;
 
    free(Wrapper);
    Wrapper = NULL;
}
 
void HIERODULE_I2C_MasterTransmit(HIERODULE_I2C_Wrapper *Wrapper, uint8_t SlaveAddress, uint8_t *MTX_Buffer, uint32_t Size)
{
    if(Size == 0)
        return;
 
    DisableClockStretching(Wrapper);
 
    #ifdef __STM32F030x6_H 
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_SADD, SlaveAddress<<1);
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_NBYTES, Size << I2C_CR2_NBYTES_Pos);
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_RD_WRN, 0);
    Wrapper->Status = HIERODULE_I2C_Status_MTX;
    #else 
    Wrapper->SlaveAddress = SlaveAddress<<1;
    Wrapper->Status = HIERODULE_I2C_Status_MTX_SB;
    #endif 
    Wrapper->MTX_Buffer = MTX_Buffer;
    Wrapper->MTX_BufferSize = Size;
    Wrapper->MTX_Counter = 0;
 
    Start(Wrapper);
}
 
void HIERODULE_I2C_MasterReceive(HIERODULE_I2C_Wrapper *Wrapper, uint8_t SlaveAddress, uint8_t *MRX_Buffer, uint32_t Size)
{
    if(Size == 0)
        return;
 
    DisableClockStretching(Wrapper);
 
    #ifdef __STM32F030x6_H 
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_SADD, (SlaveAddress<<1)+1);
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_NBYTES, Size << I2C_CR2_NBYTES_Pos);
    MODIFY_REG(Wrapper->_I2C->CR2, I2C_CR2_RD_WRN, I2C_CR2_RD_WRN);
    Wrapper->Status = HIERODULE_I2C_Status_MRX;
    #else 
    Wrapper->SlaveAddress = (SlaveAddress<<1)+1;
    Wrapper->Status = HIERODULE_I2C_Status_MRX_SB;
    #endif 
    Wrapper->MRX_Buffer = MRX_Buffer;
    Wrapper->MRX_BufferSize = Size;
    Wrapper->MRX_Counter = 0;
 
    if(Wrapper->MRX_BufferSize == 1)
    {
        NACK_Next(Wrapper);
        __NOP();
    }
 
    Start(Wrapper);
}
void I2C_IRQ_Handler(HIERODULE_I2C_Wrapper *Wrapper)
{
 
    #ifndef __STM32F030x6_H 
    uint8_t _ADDR_Active = (READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_ADDR) == (I2C_SR1_ADDR));
    #else 
    uint8_t _ADDR_Active = (READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_ADDR) == (I2C_ISR_ADDR));
    #endif
 
    #ifdef __STM32F030x6_H 
    if ( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_NACKF) == (I2C_ISR_NACKF) )
    {
        Receive_NACK(Wrapper);
    }
    #else 
    if ( READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_AF) == (I2C_SR1_AF) )
    {
        Receive_NACK(Wrapper);
    }
    #endif
 
    #ifdef __STM32F030x6_H 
    else if( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_RXNE) == (I2C_ISR_RXNE) )
    {
        if( Wrapper->Status == HIERODULE_I2C_Status_MRX )
            ReceiveByteAsMaster(Wrapper);
        else
        {
            if( Wrapper->Status == HIERODULE_I2C_Status_SRX )
                ReceiveByteAsSlave(Wrapper);
            else
                ReceiveData(Wrapper);
        }
    }
    #else 
    else if( READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_RXNE) == (I2C_SR1_RXNE) )
    {
        if( Wrapper->Status == HIERODULE_I2C_Status_MRX )
            ReceiveByteAsMaster(Wrapper);
        else
        {
            if( Wrapper->Status == HIERODULE_I2C_Status_SRX )
                ReceiveByteAsSlave(Wrapper);
            else
                ReceiveData(Wrapper);
        }
    }
    #endif
 
    #ifndef __STM32F030x6_H 
    else if ( READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_SB) == (I2C_SR1_SB) )
    {
        if( Wrapper->Status == HIERODULE_I2C_Status_MTX_SB )
            Wrapper->Status = HIERODULE_I2C_Status_MTX_ADR;
        else if( Wrapper->Status == HIERODULE_I2C_Status_MRX_SB )
            Wrapper->Status = HIERODULE_I2C_Status_MRX_ADR;
        TransmitData(Wrapper, Wrapper->SlaveAddress);
    }
    #endif 
    else if ( _ADDR_Active )
    {
        if(Wrapper->Status == HIERODULE_I2C_Status_IDLE)
        {
            #ifndef __STM32F030x6_H 
            uint32_t _t_dir = (uint32_t)(READ_BIT(Wrapper->_I2C->SR2, I2C_SR2_TRA));
            #else 
            uint32_t _t_dir = (uint32_t)(READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_DIR));
            #endif 
            if( 0 == _t_dir )
                Wrapper->Status = HIERODULE_I2C_Status_SRX;
            else
                Wrapper->Status = HIERODULE_I2C_Status_STX;
        }
        #ifndef __STM32F030x6_H 
        else if(Wrapper->Status == HIERODULE_I2C_Status_MTX_ADR)
        {
            Wrapper->Status = HIERODULE_I2C_Status_MTX;
        }
        else if(Wrapper->Status == HIERODULE_I2C_Status_MRX_ADR)
        {
            Wrapper->Status = HIERODULE_I2C_Status_MRX;
        }
        READ_REG(Wrapper->_I2C->SR1);
        READ_REG(Wrapper->_I2C->SR2);
        #else 
        SET_BIT(Wrapper->_I2C->ICR, I2C_ICR_ADDRCF);
        #endif 
    }
    #ifndef __STM32F030x6_H 
    else if ( (READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_TXE) == (I2C_SR1_TXE)) )
    {
        if(Wrapper->Status == HIERODULE_I2C_Status_MTX )
        {
            TransmitByteAsMaster(Wrapper);
        }
        else if(Wrapper->Status == HIERODULE_I2C_Status_STX )
        {
            TransmitByteAsSlave(Wrapper);
            while(READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_TXE) != (I2C_SR1_TXE))
            {
                if ( READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_AF) == (I2C_SR1_AF) )
                {
                    Receive_NACK(Wrapper);
                    break;
                }
            }
        }
    }
    #else 
    else if ( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_TXIS) == (I2C_ISR_TXIS) )
    {
        if(Wrapper->Status == HIERODULE_I2C_Status_MTX )
        {
            TransmitByteAsMaster(Wrapper);
        }
        else if(Wrapper->Status == HIERODULE_I2C_Status_STX )
        {
            TransmitByteAsSlave(Wrapper);
            while( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_TXIS) != (I2C_ISR_TXIS) )
            {
                if ( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_NACKF) == (I2C_ISR_NACKF) )
                {
                    Receive_NACK(Wrapper);
                    break;
                }
            }
        }
    }
    #endif
 
    #ifdef __STM32F030x6_H 
    else if ( READ_BIT(Wrapper->_I2C->ISR, I2C_ISR_STOPF) == (I2C_ISR_STOPF) )
    {
        ReturnToIdleState(Wrapper);
    }
    #else 
    else if ( READ_BIT(Wrapper->_I2C->SR1, I2C_SR1_STOPF) == (I2C_SR1_STOPF) )
    {
        ReturnToIdleState(Wrapper);
    }
    #endif 
}
 
#if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
extern void I2C1_EV_IRQHandler(void)
{
    if( I2C1_Wrapper != NULL )
        I2C_IRQ_Handler(I2C1_Wrapper);
}
 
extern void I2C2_EV_IRQHandler(void)
{
    if( I2C2_Wrapper != NULL )
        I2C_IRQ_Handler(I2C2_Wrapper);
}
 
#elif defined __STM32F030x6_H 
extern void I2C1_IRQHandler(void)
{
    if( I2C1_Wrapper != NULL )
        I2C_IRQ_Handler(I2C1_Wrapper);
}
#endif 
#ifdef __STM32F401xC_H 
extern void I2C3_EV_IRQHandler(void)
{
    if( I2C3_Wrapper != NULL )
        I2C_IRQ_Handler(I2C3_Wrapper);
}
#endif