Several issues that need to be paid attention to when using SPI communication with STM8

Overview:

     When using the STM8L101F3 microcontroller and SPI communication to read the data of the three-axis sensor ADXL362, a series of problems occurred. I will make a note here and hope it can give you a small reference.

Question one:

      During the SPI initialization process, the three pins MISO, MOSI, and SCLK were not initialized, which caused problems in writing and reading data during the communication process. So here is the SPI initialization code that can run normally after testing. (STM8L101F3, using the official standard library)

#include "stm8l10x.h"

#include "stm8l10x_spi.h"

#include "stm8l10x_gpio.h"

/***************************SPI related definitions**************************/

#define SPI_GPIO_PORT GPIOB

#define SPI_CS_PIN GPIO_Pin_4

#define SPI_SCLK_PIN GPIO_Pin_5

#define SPI_MOSI_PIN GPIO_Pin_6

#define SPI_MISO_PIN GPIO_Pin_7

/*The following settings are in accordance with the corresponding configuration of my three-axis sensor*/

#define SPI_FIRSTBIT_TYPE SPI_FirstBit_MSB

#define SPI_SPEED_PRESC SPI_BaudRatePrescaler_4

#define SPI_MODE SPI_Mode_Master

#define SPI_CPOL SPI_CPOL_Low

#define SPI_CPHA SPI_CPHA_1Edge

#define SPI_DATA_MODE SPI_Direction_2Lines_FullDuplex

#define SPI_CS_CTRL SPI_NSS_Soft

/*SPI initialization*/

void spi_init(void)

{

  //Start the SPI peripheral clock

  CLK_PeripheralClockConfig(CLK_Peripheral_SPI, ENABLE);

  //SPI reset

  SPI_DeInit();

  //SPI related GPIO initialization

  GPIO_Init(SPI_GPIO_PORT, SPI_CS_PIN, GPIO_Mode_Out_PP_High_Fast);

  GPIO_Init(SPI_GPIO_PORT, SPI_SCLK_PIN, GPIO_Mode_Out_PP_High_Fast);

  GPIO_Init(SPI_GPIO_PORT, SPI_MOSI_PIN, GPIO_Mode_Out_PP_High_Fast);

  //This setting is critical. As the master device, it must be set as input

  GPIO_Init(SPI_GPIO_PORT, SPI_MISO_PIN, GPIO_Mode_In_PU_No_IT);

  //SPI initialization

  SPI_Init(SPI_FIRSTBIT_TYPE, SPI_SPEED_PRESC, SPI_MODE, SPI_CPOL, SPI_CPHA,           

  SPI_DATA_MODE, SPI_CS_CTRL);

  //SPI start

  SPI_Cmd(ENABLE);

}

Question 2:

     Regarding the data writing and data reading issues, during my use, the official library provides two functions, one for writing data and the other for receiving data. Because in my application, I need to write two bytes of command and address data first, and then read the subsequent data. Therefore, in use, I first use the SPI_SendData() function to write data without reading the corresponding received data. (In fact, to read data through SPI communication, you must write it first before you can read it, and only when you write to the slave device will there be a clock.) Then I started to read the data, and found that the data I read was always wrong. Later, through instrument analysis, I found that the data I needed was in the response data, but the first data I read was actually the data of the first byte response when I wrote it. That is to say, when writing data, if we do not read the corresponding data, and then read the data after writing the data, it is actually the data returned when the first byte is written, and the subsequent data will not be overwritten and updated. Here is the modified code.

/*This part is the code for writing and reading data. Remember to turn on and off the chip select signal before and after reading and writing data*/

void spi_write(uint8_t data)

{

    while(SPI_GetFlagStatus(SPI_FLAG_TXE) == RESET);

    SPI_SendData(data);

    //It must not be omitted. If the corresponding data is not received, reading the data immediately will cause incorrect data to be read.

    while (SPI_GetFlagStatus(SPI_FLAG_RXNE) == RESET);

    u8 dd = SPI_ReceiveData();

}

uint8_t spi_read()

{

    //Select an invalid data to send (customized, just to provide a clock to the slave device), and then read the corresponding data

    uint8_t data = 0xff;

    while (SPI_GetFlagStatus(SPI_FLAG_TXE) == RESET);

    SPI_SendData(data);

    while (SPI_GetFlagStatus(SPI_FLAG_RXNE) == RESET);

    uint8_t rxdata = SPI_ReceiveData();

    return rxdata;

}

//Write data and read required data

void spi_write2read(uint8_t *wdata, uint8_t wlen, uint8_t *rdata, uint8_t rlen)

{

    uint8_t i;

    if (wdata == NULL || rdata == NULL) {

        return;

    }

    //Write data

    for (i = 0; i < wlen; i++) {

        spi_write(wdata[i]);

    }

    //Read data

    for (i = 0; i < rlen; i++) {

        rdata[i] = spi_read();

    }

}

     Summarize:

              I have a better understanding of using SPI on microcontrollers, haha.