Elements of the module that are not confined to the scope of the compilation unit. Perfectly corresponds to the module's header file, except the IRQ handlers. More...

Data Structures
struct	HIERODULE_I2C_Wrapper
	Struct that keeps variables for the data buffers, a pointer to the I2C peripheral, the slave address and pointers to the transmission end callback routines. More...

Enumerations
enum	HIERODULE_I2C_Status { HIERODULE_I2C_Status_IDLE , HIERODULE_I2C_Status_MTX_SB , HIERODULE_I2C_Status_MTX_ADR , HIERODULE_I2C_Status_MTX , HIERODULE_I2C_Status_SRX , HIERODULE_I2C_Status_MRX_SB , HIERODULE_I2C_Status_MRX_ADR , HIERODULE_I2C_Status_MRX , HIERODULE_I2C_Status_STX }
	I2C wrapper status enumeration. More...

Functions
uint8_t	HIERODULE_I2C_GetNextByte (HIERODULE_I2C_Wrapper *Wrapper)
	Fetches the next byte in the SRX ring buffer.

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))
	Initializes a wrapper for the specified I2C peripheral.

void	HIERODULE_I2C_ReleaseWrapper (HIERODULE_I2C_Wrapper *Wrapper)
	Frees the memory allocated to an I2C wrapper.

void	HIERODULE_I2C_MasterTransmit (HIERODULE_I2C_Wrapper Wrapper, uint8_t SlaveAddress, uint8_t MTX_Buffer, uint32_t Size)
	Puts the peripheral in master transmitter mode and handles the transmission.

void	HIERODULE_I2C_MasterReceive (HIERODULE_I2C_Wrapper Wrapper, uint8_t SlaveAddress, uint8_t MRX_Buffer, uint32_t Size)
	Puts the peripheral in master receiver mode and handles the transmission.

void	I2C1_EV_IRQHandler (void)
	I2C1 IRQ implementation. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined.

void	I2C2_EV_IRQHandler (void)
	I2C2 IRQ implementation. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined.

void	I2C1_IRQHandler (void)
	I2C1 IRQ implementation. Requires the device specific macro __STM32F030x6_H to be defined.

void	I2C3_EV_IRQHandler (void)
	I2C3 IRQ implementation. Requires the device specific macro __STM32F401xC_H to be defined.

Detailed Description

Consists of general I2C comm routines, a I2C wrapper initalizer and typedefs for module routines.
Device-specific macro constants and type definitions are imported with an include directive to main.h, where the device driver headers are assumed to be included.
stddef.h and stdlib.h also included for NULL and malloc/free, respectively.

Enumeration Type Documentation

◆ HIERODULE_I2C_Status

enum HIERODULE_I2C_Status

Notice that different devices may not follow the same status succession.

Enumerator
HIERODULE_I2C_Status_IDLE	Peripheral is expecting a start condition.
HIERODULE_I2C_Status_MTX_SB	Master transmitter, waiting for the start condition to commence.
HIERODULE_I2C_Status_MTX_ADR	Master transmitter, waiting for a slave to acknowledge the address.
HIERODULE_I2C_Status_MTX	Master transmitter, transmitting bytes.
HIERODULE_I2C_Status_SRX	Slave receiver, receiving bytes.
HIERODULE_I2C_Status_MRX_SB	Master receiver, waiting for the start condition to commence.
HIERODULE_I2C_Status_MRX_ADR	Master receiver, waiting for a slave to acknowledge the address.
HIERODULE_I2C_Status_MRX	Master receiver, receiving bytes.
HIERODULE_I2C_Status_STX	Slave transmitter, transmitting bytes.

Definition at line 42 of file hierodule_i2c.h.

{
    HIERODULE_I2C_Status_IDLE,
 
    HIERODULE_I2C_Status_MTX_SB,
    HIERODULE_I2C_Status_MTX_ADR,
    HIERODULE_I2C_Status_MTX,
    HIERODULE_I2C_Status_SRX,
 
    HIERODULE_I2C_Status_MRX_SB,
    HIERODULE_I2C_Status_MRX_ADR,
    HIERODULE_I2C_Status_MRX,
    HIERODULE_I2C_Status_STX
 
} HIERODULE_I2C_Status;

Function Documentation

◆ HIERODULE_I2C_GetNextByte()

uint8_t HIERODULE_I2C_GetNextByte ( HIERODULE_I2C_Wrapper * Wrapper )

Parameters

Wrapper Pointer to the I2C wrapper.

Returns: The next byte in the ring buffer, 0 if there's none.

SRX_New and SRX_Index are also updated on call, to revolve the ring buffer, so as to say.

Definition at line 397 of file hierodule_i2c.c.

{
    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;
    }
}

References Wrapper.

◆ HIERODULE_I2C_InitWrapper()

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

Parameters

_I2C	I2C peripheral of the wrapper.
SRX_BufferSize	Length of the SRX ring buffer array.
SRX_Handler	Pointer to the callback routine for slave receiver mode.
MTX_Handler	Pointer to the callback routine for master transmitter mode.
STX_Handler	Pointer to the callback routine for slave transmitter mode.
MRX_Handler	Pointer to the callback routine for master receiver mode.

Returns: Double pointer to the initialized wrapper.

The buffers get a new addresses allocated to them.
The SRX ring buffer is filled with null characters.
Also configures the peripheral's control register and calculates the I2C clock period.
The wrapper pointer gets a new address allocated, to be freed at some future point via HIERODULE_I2C_ReleaseWrapper, hence the reason a pointer is used for the wrapper; likewise, a double pointer is used to return it by reference.
Device specific checks are performed for the I2C peripheral specified.

Definition at line 421 of file hierodule_i2c.c.

{
    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;
}

References ACK_Next(), EnableClockStretching(), HIERODULE_I2C_Status_IDLE, I2C1_Wrapper, I2C2_Wrapper, I2C3_Wrapper, and Wrapper.

◆ HIERODULE_I2C_MasterReceive()

void HIERODULE_I2C_MasterReceive	(	HIERODULE_I2C_Wrapper *	Wrapper,
		uint8_t	SlaveAddress,
		uint8_t *	MRX_Buffer,
		uint32_t	Size )

Parameters

Wrapper	Pointer to the I2C wrapper.
SlaveAddress	Target device address.
MRX_Buffer	Byte array where the received data will be saved.
Size	Number of bytes to be received.

Returns: None

Transmission won't commence if Size is zero.

Definition at line 583 of file hierodule_i2c.c.

{
    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);
}

References DisableClockStretching(), HIERODULE_I2C_Status_MRX, HIERODULE_I2C_Status_MRX_SB, NACK_Next(), Start(), and Wrapper.

◆ HIERODULE_I2C_MasterTransmit()

void HIERODULE_I2C_MasterTransmit	(	HIERODULE_I2C_Wrapper *	Wrapper,
		uint8_t	SlaveAddress,
		uint8_t *	MTX_Buffer,
		uint32_t	Size )

Parameters

Wrapper	Pointer to the I2C wrapper.
SlaveAddress	Target device address.
MTX_Buffer	Byte array to be transmitted.
Size	Number of bytes to be transmitted.

Returns: None

Transmission won't commence if Size is zero.

Definition at line 554 of file hierodule_i2c.c.

{
    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);
}

References DisableClockStretching(), HIERODULE_I2C_Status_MTX, HIERODULE_I2C_Status_MTX_SB, Start(), and Wrapper.

◆ HIERODULE_I2C_ReleaseWrapper()

void HIERODULE_I2C_ReleaseWrapper ( HIERODULE_I2C_Wrapper * Wrapper )

Parameters

Wrapper Pointer to the I2C wrapper.

Returns: None

Buffer addresses are also freed.
Using a released I2C wrapper or its fields may result in unexpected behavior.
Keep in mind this clears up the I2C wrapper pointer in this file scope; it is recommended to free your double pointer to the wrapper, likewise.

Definition at line 534 of file hierodule_i2c.c.

{
    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;
}

References Wrapper.

◆ I2C1_EV_IRQHandler()

void I2C1_EV_IRQHandler ( void )

extern

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 806 of file hierodule_i2c.c.

{
    if( I2C1_Wrapper != NULL )
        I2C_IRQ_Handler(I2C1_Wrapper);
}

References I2C1_Wrapper, and I2C_IRQ_Handler().

◆ I2C1_IRQHandler()

void I2C1_IRQHandler ( void )

extern

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 830 of file hierodule_i2c.c.

{
    if( I2C1_Wrapper != NULL )
        I2C_IRQ_Handler(I2C1_Wrapper);
}

References I2C1_Wrapper, and I2C_IRQ_Handler().

◆ I2C2_EV_IRQHandler()

void I2C2_EV_IRQHandler ( void )

extern

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 817 of file hierodule_i2c.c.

{
    if( I2C2_Wrapper != NULL )
        I2C_IRQ_Handler(I2C2_Wrapper);
}

References I2C2_Wrapper, and I2C_IRQ_Handler().

◆ I2C3_EV_IRQHandler()

void I2C3_EV_IRQHandler ( void )

extern

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 845 of file hierodule_i2c.c.

{
    if( I2C3_Wrapper != NULL )
        I2C_IRQ_Handler(I2C3_Wrapper);
}

References I2C3_Wrapper, and I2C_IRQ_Handler().

Data Structures

Enumerations

Functions

Detailed Description

Enumeration Type Documentation

◆ HIERODULE_I2C_Status

Function Documentation

◆ HIERODULE_I2C_GetNextByte()

◆ HIERODULE_I2C_InitWrapper()

◆ HIERODULE_I2C_MasterReceive()

◆ HIERODULE_I2C_MasterTransmit()

◆ HIERODULE_I2C_ReleaseWrapper()

◆ I2C1_EV_IRQHandler()

◆ I2C1_IRQHandler()

◆ I2C2_EV_IRQHandler()

◆ I2C3_EV_IRQHandler()