MT2625 SPI学习

https://blog.csdn.net/qq_38410730/article/details/80318821

https://zhuanlan.zhihu.com/p/37506796

https://wenku.baidu.com/view/cf7de1dcfd0a79563d1e7220.html

DMA Direct Memory Access. DMA is a feature of computer systems that allows certain hardware subsystems to access main system memory independent from the central processing unit (CPU).

FIFO First In, First Out. FIFO is a method for organizing and manipulating a data buffer, where the first entry, or 'head' of the queue, is processed first.

GPIO General Purpose Inputs-Outputs.

NVIC Nested Vectored Interrupt Controller. NVIC is the interrupt controller of ARM Cortex-M series processors.

IRQ Interrupt Request. For more information

MISO Master Input, Slave Output. Output from the SPI slave.

MOSI Master Output, Slave Input. Output from the SPI master.

SCLK Serial Clock. Output from the SPI master.

SS Slave Select. Output from the SPI master, active low.

SPI 串行外设接口是一种高速的，全双工，同步的通信总线

Serial Peripheral Interface. The Serial Peripheral Interface bus is a synchronous serial communication interface specification used for short distance communication.

mt2625 的 spi 有polling 、dma 、dma blocking模式，其中dma在初始化完成后需要注册回调函数，sample code如下：

// Callback function sample code. Pass this function to the driver while calling #hal_spi_master_register_callback().
void user_spi_callback (hal_spi_master_callback_event_t event,void *user_data)
{
    rin_log("
 user_spi_callback event=%d 
",event);
    
    if (HAL_SPI_MASTER_EVENT_SEND_FINISHED == event)
    {
        // Send finish event handler;
        // User code;
        hal_spi_master_deinit(MASTER_SPI_PORT); // Deinitialize, if no longer in use.
    }
    else if (HAL_SPI_MASTER_EVENT_RECEIVE_FINISHED == event)
    {
        // Receive finish event handler;
        // User code;
        hal_spi_master_deinit(MASTER_SPI_PORT); // Deinitialize, if no longer in use.
    }
}


void SPIInitMasterDMAMode(void)
{
    hal_spi_master_config_t spi_config_master;
    hal_spi_master_send_and_receive_config_t spi_send_and_receive_config;
    uint8_t status_cmd = 0x10;//SPIS_STATUS_CMD;
    
    hal_spi_master_status_t err = HAL_SPI_MASTER_STATUS_OK;
    
     // SPI init
    //hal_spi_master_send_and_receive_config_t spi_send_and_receive_config;
    uint8_t status_receive[2];
    uint8_t data[2] = {0x7E, 0x55};
    uint32_t size = 2;

    rin_log("
SPIInitMasterMode 
");
    
    spi_config_master.bit_order = HAL_SPI_MASTER_LSB_FIRST;
    spi_config_master.slave_port = HAL_SPI_MASTER_SLAVE_0;
    spi_config_master.clock_frequency = 1000000;
    spi_config_master.phase = HAL_SPI_MASTER_CLOCK_PHASE0;
    spi_config_master.polarity = HAL_SPI_MASTER_CLOCK_POLARITY0;
    status_receive[1] = 0;

    spi_send_and_receive_config.receive_length = 2;
    spi_send_and_receive_config.send_length = 1;
    spi_send_and_receive_config.send_data = &status_cmd;
    spi_send_and_receive_config.receive_buffer = status_receive;

    // Step 1. Call hal_gpio_init() to inite the pins,
    // if EPT tool hasn't been used to configure the related pinmux.
    hal_gpio_init(SPI_CS);
    hal_gpio_init(SPI_CLK);
    hal_gpio_init(SPI_MOSI);
    hal_gpio_init(SPI_MISO);
    
    // Step 2. Call hal_pinmux_set_function() to set GPIO pinmux,
    // if EPT tool hasn't been used to configure the related pinmux.
    hal_pinmux_set_function(SPI_CS, HAL_GPIO_19_SPI_MST1_CS);// Set the pin to be used as CS signal of SPI.
    hal_pinmux_set_function(SPI_CLK, HAL_GPIO_22_SPI_MST1_SCK);// Set the pin to be used as SCK signal of SPI.
    hal_pinmux_set_function(SPI_MISO, HAL_GPIO_20_SPI_MST1_MISO);// Set the pin to be used as MOSI signal of SPI.
    hal_pinmux_set_function(SPI_MOSI, HAL_GPIO_21_SPI_MST1_MOSI);// Set the pin to be used as MISO signal of SPI.

    // Step 3. Call hal_spi_master_init() to initialize one SPI master.
    // If the SPI master is already initialized by another user, user will get HAL_SPI_MASTER_STATUS_ERROR_BUSY.
    err = hal_spi_master_init(MASTER_SPI_PORT,&spi_config_master);
    
    if (HAL_SPI_MASTER_STATUS_OK == err)
    {
        rin_log("
HAL_SPI_MASTER_STATUS_OK 
");

        // Step 4. Call hal_spi_master_register_callback() to register a user callback.
        err = hal_spi_master_register_callback(MASTER_SPI_PORT, (hal_spi_master_callback_t)user_spi_callback, NULL);
        
        if (HAL_SPI_MASTER_STATUS_OK != err)
        {
            // Error handler;
            rin_log("
 reg cb fail err=%d 
",err);
        }
        rin_log("
 reg cb HAL_SPI_MASTER_STATUS_OK 
");
        
        TaskDelay(24);
        
        // Step 5. Call hal_spi_master_send_dma() to send data in the DMA mode.
        // Step 6. Call hal_spi_master_send_and_receive_dma() to send and receive data in the DMA mode.
        err = hal_spi_master_send_dma(MASTER_SPI_PORT,data,size);//Half-duplex

        TaskDelay(1000);

        // Call hal_spi_master_send_and_receive_dma() to send and receive data in the DMA mode.
        //if (HAL_SPI_MASTER_STATUS_OK != hal_spi_master_send_and_receive_dma(MASTER_SPI_PORT,&spi_send_and_receive_config))
        //{
            // Error handler;
            //rin_log("
 send and recv fail err=%d 
",err);
        //}
    
        if (HAL_SPI_MASTER_STATUS_OK != err)
        {
            // Error handler;
            rin_log("
 send fail err=%d 
",err);
        }
        else
        {
            rin_log("
 send suc data=0x%x 0x%x 
",data[0],data[1]);
        }
    }
    else
    {    
        // Error handler;
        rin_log("
 init fail err=%d 
",err);
    }

    // Step 6. Call hal_spi_master_deinit() to deinitialize the SPI master, if it's no longer in use.
    //err = hal_spi_master_deinit();//deinit in cb func
    rin_log("
 hal_spi_master_deinit err=%d 
",err);
    //vTaskDelete(g_HLSpi_task_handle);
    
}