SPI Public API

Public functions to interact with the SPI peripheral. More...

Collaboration diagram for SPI Public API:

Functions
void	spi_init (SPI_CFG_ts *spi_cfg)
	Initializes the SPI peripheral with the given configuration.
void	spi_deinit (SPI_REGDEF_ts const *spi_instance)
	Deinitializes the SPI peripheral and disables its clock.
void	spi_send (SPI_REGDEF_ts *spi_instance, uint8_t *tx_buffer, uint32_t len)
	Blocking SPI transmit. Sends len bytes from tx_buffer.
void	spi_receive (SPI_REGDEF_ts *spi_instance, uint8_t *rx_buffer, uint32_t len)
	Blocking SPI receive. Reads len bytes into rx_buffer.
void	spi_set_pclk_div (SPI_REGDEF_ts *spi_instance, SPI_MASTER_SCLK_SPEED_te pclk_div)
	Changes the SPI master clock speed divisor at runtime.
void	spi_set_comm (SPI_REGDEF_ts *spi_instance, EN_STATUS_te en_status)
	Enables or disables the SPI peripheral (SPE bit).

Detailed Description

Public functions to interact with the SPI peripheral.

Function Documentation

spi_init()

void spi_init

(

SPI_CFG_ts *

spi_cfg

)

Initializes the SPI peripheral with the given configuration.

Enables the peripheral clock and configures data frame format, clock polarity, clock phase, bit order, slave select mode, master/slave mode, and (in master mode) the SCK speed. Does not enable the peripheral for communication; call spi_set_comm with ENABLE to do so.

Default values if fields are zero-initialized:

• Mode: slave
• Data frame: 8-bit
• Clock polarity: idle low (CPOL = 0)
• Clock phase: first transition (CPHA = 0)
• Bit order: MSB first
• Slave select: hardware
• Master speed: PCLK / 2

Parameters

[in]

spi_cfg

Pointer to the SPI configuration structure.

Note

It is recommended to zero-initialize SPI_CFG_ts before use.

See also

spi_init

Definition at line 24 of file stm32f401re_spi.c.

                                   {
    spi_set_pclk(spi_cfg->instance, ENABLE);
 
    // Configure data frame format (8-bit or 16-bit)
    spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_DFF);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->data_frame_format << SPI_CR1_DFF);
 
    // Configure clock polarity (CPOL)
    spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_CPOL);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->clock_polarity << SPI_CR1_CPOL);
 
    // Configure clock phase (CPHA)
    spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_CPHA);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->clock_phase << SPI_CR1_CPHA);
 
    // Configure bit order (MSB or LSB first)
    spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_LSBFIRST);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->bit_first << SPI_CR1_LSBFIRST);
 
    // Configure slave select management (HW or SW)
    spi_cfg->instance->SPI_CR1 &= ~(0b1 << SPI_CR1_SSM);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->slave_select_mode << SPI_CR1_SSM);
 
    if(spi_cfg->mode == SPI_MODE_MASTER) {
        // Set SSI to prevent MODF fault in software NSS mode
        spi_cfg->instance->SPI_CR1 |= (0x1 << SPI_CR1_SSI);
 
        // Enable SSOE for hardware NSS output
        if(spi_cfg->slave_select_mode == SPI_SLAVE_SELECT_MODE_HW) {
            spi_cfg->instance->SPI_CR2 &= ~(0x1 << SPI_CR2_SSOE);
            spi_cfg->instance->SPI_CR2 |= (0x1 << SPI_CR2_SSOE);
        }
 
        // Configure master SCK speed (BR bits)
        spi_cfg->instance->SPI_CR1 &= ~(0x07 << SPI_CR1_BR);
        spi_cfg->instance->SPI_CR1 |= (spi_cfg->master_sclk_speed << SPI_CR1_BR);
    }
    else if(spi_cfg->mode == SPI_MODE_SLAVE) {
        // Clear SSI to pull NSS internally low in slave mode
        spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_SSI);
    }
 
    // Set master/slave mode
    spi_cfg->instance->SPI_CR1 &= ~(0x1 << SPI_CR1_MSTR);
    spi_cfg->instance->SPI_CR1 |= (spi_cfg->mode << SPI_CR1_MSTR);
}

Here is the call graph for this function:

Here is the caller graph for this function:

spi_deinit()

void spi_deinit

(

SPI_REGDEF_ts const *

instance

)

Deinitializes the SPI peripheral and disables its clock.

Triggers an RCC peripheral reset for the given instance and then disables the peripheral clock.

Parameters

[in]

spi_instance

Pointer to the SPI instance to deinitialize.

See also

spi_deinit

Definition at line 72 of file stm32f401re_spi.c.

                                               {
    if(instance == SPI1) {
        rcc_reset_periph_apb2(RCC_APB2RSTR_SPI1RST);
    }
    else if(instance == SPI2) {
        rcc_reset_periph_apb1(RCC_APB1RSTR_SPI2RST);
    }
    else if(instance == SPI3) {
        rcc_reset_periph_apb1(RCC_APB1RSTR_SPI3RST);
    }
    else if(instance == SPI4) {
        rcc_reset_periph_apb2(RCC_APB2RSTR_SPI4RST);
    }
 
    spi_set_pclk(instance, DISABLE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

spi_send()

void spi_send	(	SPI_REGDEF_ts *	instance,
		uint8_t *	tx_buffer,
		uint32_t	len )

Blocking SPI transmit. Sends len bytes from tx_buffer.

Transmits data one frame at a time, polling TXE before each write and RXNE after each write to drain the receive FIFO (required in full-duplex mode to prevent overrun). Supports both 8-bit and 16-bit frame formats.

Parameters

[in]	spi_instance	Pointer to the SPI peripheral instance.
[in]	tx_buffer	Pointer to the transmit data buffer.
[in]	len	Number of bytes to transmit. Must be even for 16-bit frames.

Note

The peripheral must be enabled via spi_set_comm before calling this function.

Blocking SPI transmit. Sends len bytes from tx_buffer.

See also

spi_send

Definition at line 90 of file stm32f401re_spi.c.

                                                                         {
    while(len != 0) {
        if(((instance->SPI_CR1 >> SPI_CR1_DFF) & 0x1) == 0) {
            // 8-bit frame: wait for TXE, write one byte
            while(!((instance->SPI_SR >> SPI_SR_TXE) & 0x1));
            instance->SPI_DR = *tx_buffer;
            tx_buffer++;
            len--;
        }
        else {
            // 16-bit frame: wait for TXE, write two bytes
            while(!((instance->SPI_SR >> SPI_SR_TXE) & 0x1));
            instance->SPI_DR = *((uint16_t*)tx_buffer);
            tx_buffer += 2;
            len -= 2;
        }
 
        // Drain receive FIFO to prevent overrun in full-duplex mode
        while(!((instance->SPI_SR >> SPI_SR_RXNE) & 0x1));
        uint16_t dummy_rx = instance->SPI_DR;
        (void)dummy_rx;
    }
}

Here is the caller graph for this function:

spi_receive()

void spi_receive	(	SPI_REGDEF_ts *	instance,
		uint8_t *	rx_buffer,
		uint32_t	len )

Blocking SPI receive. Reads len bytes into rx_buffer.

Receives data by transmitting dummy bytes (0xFF) to generate the SCK clock signal, then reads the received byte from the data register. Supports both 8-bit and 16-bit frame formats.

Parameters

[in]	spi_instance	Pointer to the SPI peripheral instance.
[out]	rx_buffer	Pointer to the receive data buffer.
[in]	len	Number of bytes to receive. Must be even for 16-bit frames.

Note

The peripheral must be enabled via spi_set_comm before calling this function.

Blocking SPI receive. Reads len bytes into rx_buffer.

See also

spi_receive

Definition at line 115 of file stm32f401re_spi.c.

                                                                            {
    uint16_t dummy_tx = 0xFFFF;
 
    while(len != 0) {
        if(((instance->SPI_CR1 >> SPI_CR1_DFF) & 0x1) == 0) {
            // 8-bit frame: send dummy byte to generate clock, then read
            instance->SPI_DR = (uint8_t)dummy_tx;
            while(!((instance->SPI_SR >> SPI_SR_TXE) & 0x1));
 
            while(!((instance->SPI_SR >> SPI_SR_RXNE) & 0x1));
            *rx_buffer = instance->SPI_DR;
            len--;
            rx_buffer++;
        }
        else {
            // 16-bit frame: send dummy word to generate clock, then read
            instance->SPI_DR = dummy_tx;
            while(!((instance->SPI_SR >> SPI_SR_TXE) & 0x1));
 
            while(!((instance->SPI_SR >> SPI_SR_RXNE) & 0x1));
            *((uint16_t*)rx_buffer) = instance->SPI_DR;
            len -= 2;
            rx_buffer += 2;
        }
    }
}

Here is the caller graph for this function:

spi_set_pclk_div()

void spi_set_pclk_div	(	SPI_REGDEF_ts *	spi_instance,
		SPI_MASTER_SCLK_SPEED_te	pclk_div )

Changes the SPI master clock speed divisor at runtime.

Updates the BR field in SPI_CR1 without a full re-initialization. Used by the SD card driver to ramp the SCK from the slow initialization speed (100–400 kHz) to the maximum speed after card initialization.

Parameters

[in]	spi_instance	Pointer to the SPI peripheral instance.
[in]	pclk_div	The new clock divisor to apply.

Note

The peripheral should be disabled (SPE = 0) before changing BR. In practice this is called between transactions so the peripheral is idle, but be cautious if calling mid-transaction.

See also

spi_set_pclk_div

Definition at line 143 of file stm32f401re_spi.c.

                                                                                      {
    spi_instance->SPI_CR1 &= ~(0x7 << SPI_CR1_BR);
    spi_instance->SPI_CR1 |= (pclk_div << SPI_CR1_BR);
}

Here is the caller graph for this function:

spi_set_comm()

void spi_set_comm	(	SPI_REGDEF_ts *	instance,
		EN_STATUS_te	en_status )

Enables or disables the SPI peripheral (SPE bit).

• ENABLE: sets SPE, activating the peripheral for communication. Must be called before the first spi_send or spi_receive.
• DISABLE: waits for the BSY flag to clear (transfer complete), then clears SPE. Must be called after the last transfer.

Parameters

[in]	spi_instance	Pointer to the SPI peripheral instance.
[in]	en_status	ENABLE to activate, DISABLE to deactivate.

Enables or disables the SPI peripheral (SPE bit).

See also

spi_set_comm

Definition at line 149 of file stm32f401re_spi.c.

                                                                   {
    if(en_status == ENABLE) {
        instance->SPI_CR1 &= ~(0x1 << SPI_CR1_SPE);
        instance->SPI_CR1 |= (0x1 << SPI_CR1_SPE);
    }
    else if(en_status == DISABLE) {
        // Wait for any ongoing transfer to complete before clearing SPE
        while((instance->SPI_SR >> SPI_SR_BSY) & 0x01);
        instance->SPI_CR1 &= ~(0x1 << SPI_CR1_SPE);
    }
}

Here is the caller graph for this function: