Tutorial de uso do RT-Thread SPI

Tutorial SPI RT-Thread

O ambiente experimental utiliza a placa de desenvolvimento Pandora da pontual atom.

O dispositivo escravo SPI usa o sensor de temperatura, umidade e pressão atmosférica BMP280.

Use o RT-Thread Studio para criar funções básicas.

1. Crie um projeto

Use o RT-Thread Studio IDE para criar projetos de nível de chip. Após a conclusão da criação, você pode compilar e baixar diretamente para teste.

2. Adicionar motorista

2.1 Configuração do projeto

Após a criação do projeto, 组建和服务层/Drivers/SPIabra o driver SPI no RT-Thread Studio.

Em seguida, configure o SPI:

Após a conclusão da configuração, Ctrl+Ssalvar a configuração atualizará automaticamente o código do projeto.

Depois de concluir a configuração, você também precisa board.habrir a macro do SPI que precisa ser usado no .

Em seguida, board.cadicione o código de inicialização STM32 SPI, você pode gerar o código configurando o CubeMX:

SPI_HandleTypeDef hspi2;

/* SPI2 init function */
void MX_SPI2_Init(void)
{
    
    

  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    
    
    Error_Handler();
  }

}

void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
{
    
    

  GPIO_InitTypeDef GPIO_InitStruct = {
    
    0};
  if(spiHandle->Instance==SPI2)
  {
    
    
  /* USER CODE BEGIN SPI2_MspInit 0 */

  /* USER CODE END SPI2_MspInit 0 */
    /* SPI2 clock enable */
    __HAL_RCC_SPI2_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**SPI2 GPIO Configuration
    PB13     ------> SPI2_SCK
    PB14     ------> SPI2_MISO
    PB15     ------> SPI2_MOSI
    */
    GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* USER CODE BEGIN SPI2_MspInit 1 */

  /* USER CODE END SPI2_MspInit 1 */
  }
}

void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
{
    
    

  if(spiHandle->Instance==SPI2)
  {
    
    
  /* USER CODE BEGIN SPI2_MspDeInit 0 */

  /* USER CODE END SPI2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_SPI2_CLK_DISABLE();

    /**SPI2 GPIO Configuration
    PB13     ------> SPI2_SCK
    PB14     ------> SPI2_MISO
    PB15     ------> SPI2_MOSI
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);

  /* USER CODE BEGIN SPI2_MspDeInit 1 */

  /* USER CODE END SPI2_MspDeInit 1 */
  }
}

Após a conclusão, o driver SPI é adicionado.

2.2 Análise de Código

2.2.1 Processo de uso do driver SPI

1. O dispositivo de barramento SPI rt_spi_bus_register() é registrado na estrutura do driver de dispositivo SPI por meio da interface.
2. A estrutura do driver de dispositivo SPI rt_device_register()registra o dispositivo de barramento SPI no gerenciador de dispositivos de E/S por meio da interface.
3. O driver escravo SPI rt_spi_bus_attach_device()monta o dispositivo escravo no dispositivo de barramento SPI por meio da interface e o registra na estrutura do driver de dispositivo SPI.
4. O driver escravo SPI acessa o hardware do dispositivo escravo SPI por meio da interface do dispositivo SPI.

2.2.2 Código

No grupo de motoristas drv_spi.c:

int rt_hw_spi_init(void)
{
    
    
    stm32_get_dma_info();
    return rt_hw_spi_bus_init();
}
INIT_BOARD_EXPORT(rt_hw_spi_init);

Com a declaração here INIT_BOARD_EXPORT(), adicione o código de inicialização à .rti_fn.1seção:

#define INIT_EXPORT(fn, level)                                                       \
            RT_USED const init_fn_t __rt_init_##fn SECTION(".rti_fn." level) = fn
#define INIT_BOARD_EXPORT(fn)           INIT_EXPORT(fn, "1")

Em seguida, concentre-se em inicializar o driver do dispositivo board.cem rt_hw_board_init()-> em.rt_components_board_init()

void rt_components_board_init(void)
{
    
    
    volatile const init_fn_t *fn_ptr;

    for (fn_ptr = &__rt_init_rti_board_start; fn_ptr < &__rt_init_rti_board_end; fn_ptr++)
    {
    
    
        (*fn_ptr)();
    }
#endif
}

rt_hw_spi_bus_init()Chamado novamente rt_spi_bus_register(), rt_spi_bus_register()ligue rt_spi_bus_device_init()para ligar para rt_device_register()concluir o registro.

static rt_err_t spi_configure(struct rt_spi_device *device,
                              struct rt_spi_configuration *configuration)
{
    
    
    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(configuration != RT_NULL);

    struct stm32_spi *spi_drv =  rt_container_of(device->bus, struct stm32_spi, spi_bus);
    spi_drv->cfg = configuration;

    return stm32_spi_init(spi_drv, configuration);
}

static const struct rt_spi_ops stm_spi_ops =
{
    
    
    .configure = spi_configure,
    .xfer = spixfer,
};

HAL_SPI_Init()A inicialização stm32_spi_init()é feita e registrada em ops. Após anexar, chame diretamente rt_spi_configure()para concluir a inicialização.

Observe que, ao contrário do uso de i2c, o SPI deve ser vinculado por meio de conexão para usar a interface do dispositivo SPI.

3. Usando SPI

Complete o código bmp280 para ler o Device ID, adicione-o ao arquivo bmp280.ce, em seguida, adicione o arquivo ao projeto:

#include <rtthread.h>
#include <rtdevice.h>
#include <drv_spi.h>

#define BME280_SPI_DEVICE_NAME "spi20"
#define BEM280_REG_ID 0XD0

rt_bool_t initialnized = RT_FALSE;

static void spi_bme280_demo(void)
{
    
    
    uint8_t data = BEM280_REG_ID | (1 << 7);
    rt_err_t err;

    struct rt_spi_device * spi_bme280;
    if (!initialnized) {
    
    
        initialnized = RT_TRUE;
        err = rt_hw_spi_device_attach("spi2", BME280_SPI_DEVICE_NAME, GPIOB, GPIO_PIN_12);
        if (err) {
    
    
            rt_kprintf("attach device error\r\n");
            return ;
        }
    }

    spi_bme280 = (struct rt_spi_device *)rt_device_find(BME280_SPI_DEVICE_NAME);
    if (spi_bme280 == RT_NULL) {
    
    
        rt_kprintf("find %s error\r\n", BME280_SPI_DEVICE_NAME);
        return ;
    }

    struct rt_spi_configuration cfg = {
    
    
            .mode = RT_SPI_MASTER | RT_SPI_MODE_0 | RT_SPI_MSB,
            .data_width = 8,
            .max_hz = 1 * 1000 * 1000
    };
    err = rt_spi_configure(spi_bme280, &cfg);
    if (err != RT_NULL) {
    
    
        rt_kprintf("spi configurate error\r\n");
        return ;
    }

    uint8_t send_buf[5] = {
    
    data, 0xff};
    uint8_t recv_buf[5];
    if (rt_spi_transfer(spi_bme280, send_buf, recv_buf, 2) == 0) {
    
    
        rt_kprintf("spi transfer error\r\n");
    }

    rt_kprintf("bme280 id: 0x%02x\r\n", recv_buf[1]);
}

MSH_CMD_EXPORT(spi_bme280_demo, read bme280 id);

O CS Pin que uso aqui é o PB12, preste atenção aos parâmetros da interface anexada.

4. Teste

O ID do dispositivo de BMP280 é 0x58, BME280 é 0x60.

Compile e grave o projeto acima e digite o comando para verificar: