diff --git a/stm32h7/devicetest/GyroL3GD20H.cpp b/stm32h7/devicetest/GyroL3GD20H.cpp index 6b8fcc4..b0a16c1 100644 --- a/stm32h7/devicetest/GyroL3GD20H.cpp +++ b/stm32h7/devicetest/GyroL3GD20H.cpp @@ -18,19 +18,27 @@ alignas(32) std::array GyroL3GD20H::txBuffer __attribute__((section(".dma_buffer"))); TransferStates transferState = TransferStates::IDLE; +spi::TransferModes GyroL3GD20H::transferMode = spi::TransferModes::POLLING; + DMA_HandleTypeDef txDmaHandle; DMA_HandleTypeDef rxDmaHandle; -GyroL3GD20H::GyroL3GD20H(SPI_HandleTypeDef *spiHandle, spi::TransferModes transferMode): - spiHandle(spiHandle), transferMode(transferMode) { +GyroL3GD20H::GyroL3GD20H(SPI_HandleTypeDef *spiHandle, spi::TransferModes transferMode_): + spiHandle(spiHandle) { + transferMode = transferMode_; if(transferMode == spi::TransferModes::DMA) { set_dma_handles(&txDmaHandle, &rxDmaHandle); set_spi_msp_functions(&hal_spi_msp_init_dma, spiHandle, &hal_spi_msp_deinit_dma, spiHandle); } + else if(transferMode == spi::TransferModes::INTERRUPT) { + set_spi_msp_functions(&hal_spi_msp_init_interrupt, spiHandle, + &hal_spi_msp_deinit_interrupt, spiHandle); + } else if(transferMode == spi::TransferModes::POLLING) { set_spi_msp_functions(&hal_spi_msp_init_polling, spiHandle, &hal_spi_msp_deinit_polling, spiHandle); } + GPIO_InitTypeDef chipSelect = {}; __HAL_RCC_GPIOD_CLK_ENABLE(); chipSelect.Pin = GPIO_PIN_14; @@ -72,8 +80,11 @@ ReturnValue_t GyroL3GD20H::initialize() { case(spi::TransferModes::DMA): { return handleDmaTransferInit(); } + case(spi::TransferModes::INTERRUPT): { + return handleInterruptTransferInit(); + } case(spi::TransferModes::POLLING): { - return handlePollingTransfer(); + return handlePollingTransferInit(); } default: { return HasReturnvaluesIF::RETURN_FAILED; @@ -88,6 +99,12 @@ ReturnValue_t GyroL3GD20H::performOperation() { case(spi::TransferModes::DMA): { return handleDmaSensorRead(); } + case(spi::TransferModes::POLLING): { + return handlePollingSensorRead(); + } + case(spi::TransferModes::INTERRUPT): { + return handleInterruptSensorRead(); + } default: { return HasReturnvaluesIF::RETURN_FAILED; } @@ -132,19 +149,10 @@ ReturnValue_t GyroL3GD20H::handleDmaTransferInit() { } sif::printInfo("GyroL3GD20H::initialize: Configuring device\n"); - // Configure the 5 configuration registers uint8_t configRegs[5]; - // Enable sensor - configRegs[0] = 0b00001111; - configRegs[1] = 0b00000000; - configRegs[2] = 0b00000000; - configRegs[3] = 0b01000000; - // Big endian select - configRegs[4] = 0b00000000; + prepareConfigRegs(configRegs); - txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK; - std::memcpy(txBuffer.data() + 1, configRegs, 5); result = performDmaTransfer(6); if(result != HAL_OK) { // Transfer error in transmission process @@ -217,7 +225,7 @@ ReturnValue_t GyroL3GD20H::handleDmaSensorRead() { HAL_StatusTypeDef result = performDmaTransfer(15); if(result != HAL_OK) { // Transfer error in transmission process - sif::printWarning("Error transmitting SPI with DMA\n"); + sif::printDebug("GyroL3GD20H::handleDmaSensorRead: Error transmitting SPI with DMA\n"); } // Wait for the transfer to complete while (transferState == TransferStates::WAIT) { @@ -226,17 +234,7 @@ ReturnValue_t GyroL3GD20H::handleDmaSensorRead() { switch(transferState) { case(TransferStates::SUCCESS): { - uint8_t statusReg = rxBuffer[8]; - int16_t gyroXRaw = rxBuffer[9] << 8 | rxBuffer[10]; - float gyroX = static_cast(gyroXRaw) / INT16_MAX * L3G_RANGE; - int16_t gyroYRaw = rxBuffer[11] << 8 | rxBuffer[12]; - float gyroY = static_cast(gyroYRaw) / INT16_MAX * L3G_RANGE; - int16_t gyroZRaw = rxBuffer[13] << 8 | rxBuffer[14]; - float gyroZ = static_cast(gyroZRaw) / INT16_MAX * L3G_RANGE; - sif::printInfo("Status register: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(statusReg)); - sif::printInfo("Gyro X: %f\n", gyroX); - sif::printInfo("Gyro Y: %f\n", gyroY); - sif::printInfo("Gyro Z: %f\n", gyroZ); + handleSensorReadout(); break; } case(TransferStates::FAILURE): { @@ -263,6 +261,247 @@ HAL_StatusTypeDef GyroL3GD20H::performDmaTransfer(size_t sendSize) { return HAL_SPI_TransmitReceive_DMA(spiHandle, txBuffer.data(), rxBuffer.data(), sendSize); } +ReturnValue_t GyroL3GD20H::handlePollingTransferInit() { + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + auto result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 2, 1000); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET); + switch(result) { + case(HAL_OK): { + sif::printInfo("GyroL3GD20H::initialize: Polling transfer success\n"); + uint8_t whoAmIVal = rxBuffer[1]; + if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) { + sif::printDebug("GyroL3GD20H::performOperation: " + "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal); + } + break; + } + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + case(HAL_ERROR): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + default: { + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; + + sif::printInfo("GyroL3GD20H::initialize: Configuring device\n"); + // Configure the 5 configuration registers + uint8_t configRegs[5]; + prepareConfigRegs(configRegs); + + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 6, 1000); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET); + switch(result) { + case(HAL_OK): { + break; + } + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + case(HAL_ERROR): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + default: { + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; + + txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK; + std::memset(txBuffer.data() + 1, 0 , 5); + + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 6, 1000); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET); + switch(result) { + case(HAL_OK): { + if(rxBuffer[1] != configRegs[0] or rxBuffer[2] != configRegs[1] or + rxBuffer[3] != configRegs[2] or rxBuffer[4] != configRegs[3] or + rxBuffer[5] != configRegs[4]) { + sif::printWarning("GyroL3GD20H::initialize: Configuration failure\n"); + } + else { + sif::printInfo("GyroL3GD20H::initialize: Configuration success\n"); + } + break; + } + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + case(HAL_ERROR): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + default: { + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t GyroL3GD20H::handlePollingSensorRead() { + txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK; + std::memset(txBuffer.data() + 1, 0 , 14); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + auto result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 15, 1000); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET); + switch(result) { + case(HAL_OK): { + handleSensorReadout(); + break; + } + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + case(HAL_ERROR): { + sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + default: { + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() { + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 2)) { + case(HAL_OK): { + sif::printInfo("GyroL3GD20H::initialize: Interrupt transfer success\n"); + // Wait for the transfer to complete + while (transferState == TransferStates::WAIT) { + TaskFactory::delayTask(1); + } + + uint8_t whoAmIVal = rxBuffer[1]; + if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) { + sif::printDebug("GyroL3GD20H::initialize: " + "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal); + } + break; + } + case(HAL_BUSY): + case(HAL_ERROR): + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + } + + sif::printInfo("GyroL3GD20H::initialize: Configuring device\n"); + transferState = TransferStates::WAIT; + // Configure the 5 configuration registers + uint8_t configRegs[5]; + prepareConfigRegs(configRegs); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 6)) { + case(HAL_OK): { + // Wait for the transfer to complete + while (transferState == TransferStates::WAIT) { + TaskFactory::delayTask(1); + } + break; + } + case(HAL_BUSY): + case(HAL_ERROR): + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + } + + txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK; + std::memset(txBuffer.data() + 1, 0 , 5); + transferState = TransferStates::WAIT; + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 6)) { + case(HAL_OK): { + // Wait for the transfer to complete + while (transferState == TransferStates::WAIT) { + TaskFactory::delayTask(1); + } + if(rxBuffer[1] != configRegs[0] or rxBuffer[2] != configRegs[1] or + rxBuffer[3] != configRegs[2] or rxBuffer[4] != configRegs[3] or + rxBuffer[5] != configRegs[4]) { + sif::printWarning("GyroL3GD20H::initialize: Configuration failure\n"); + } + else { + sif::printInfo("GyroL3GD20H::initialize: Configuration success\n"); + } + break; + } + case(HAL_BUSY): + case(HAL_ERROR): + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t GyroL3GD20H::handleInterruptSensorRead() { + transferState = TransferStates::WAIT; + txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK; + std::memset(txBuffer.data() + 1, 0 , 14); + HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET); + switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 15)) { + case(HAL_OK): { + // Wait for the transfer to complete + while (transferState == TransferStates::WAIT) { + TaskFactory::delayTask(1); + } + handleSensorReadout(); + break; + } + case(HAL_BUSY): + case(HAL_ERROR): + case(HAL_TIMEOUT): { + sif::printDebug("GyroL3GD20H::initialize: Sensor read failure using interrupts\n"); + return HasReturnvaluesIF::RETURN_FAILED; + } + } + return HasReturnvaluesIF::RETURN_OK; +} + +void GyroL3GD20H::prepareConfigRegs(uint8_t* configRegs) { + // Enable sensor + configRegs[0] = 0b00001111; + configRegs[1] = 0b00000000; + configRegs[2] = 0b00000000; + configRegs[3] = 0b01000000; + // Big endian select + configRegs[4] = 0b00000000; + + txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK; + std::memcpy(txBuffer.data() + 1, configRegs, 5); +} + +void GyroL3GD20H::handleSensorReadout() { + uint8_t statusReg = rxBuffer[8]; + int16_t gyroXRaw = rxBuffer[9] << 8 | rxBuffer[10]; + float gyroX = static_cast(gyroXRaw) / INT16_MAX * L3G_RANGE; + int16_t gyroYRaw = rxBuffer[11] << 8 | rxBuffer[12]; + float gyroY = static_cast(gyroYRaw) / INT16_MAX * L3G_RANGE; + int16_t gyroZRaw = rxBuffer[13] << 8 | rxBuffer[14]; + float gyroZ = static_cast(gyroZRaw) / INT16_MAX * L3G_RANGE; + sif::printInfo("Status register: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(statusReg)); + sif::printInfo("Gyro X: %f\n", gyroX); + sif::printInfo("Gyro Y: %f\n", gyroY); + sif::printInfo("Gyro Z: %f\n", gyroZ); +} + /** * @brief TxRx Transfer completed callback. * @param hspi: SPI handle @@ -273,9 +512,11 @@ HAL_StatusTypeDef GyroL3GD20H::performDmaTransfer(size_t sendSize) { void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { transferState = TransferStates::SUCCESS; HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET); - // Invalidate cache prior to access by CPU - SCB_InvalidateDCache_by_Addr ((uint32_t *)GyroL3GD20H::rxBuffer.data(), - GyroL3GD20H::recvBufferSize); + if(GyroL3GD20H::transferMode == spi::TransferModes::DMA) { + // Invalidate cache prior to access by CPU + SCB_InvalidateDCache_by_Addr ((uint32_t *)GyroL3GD20H::rxBuffer.data(), + GyroL3GD20H::recvBufferSize); + } } /** @@ -288,29 +529,3 @@ void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) { transferState = TransferStates::FAILURE; } - -ReturnValue_t GyroL3GD20H::handlePollingTransfer() { - switch(HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 2, 1000)) { - case(HAL_OK): { - sif::printInfo("Polling transfer success\n"); - uint8_t whoAmIVal = rxBuffer[1]; - if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) { - sif::printDebug("GyroL3GD20H::performOperation: " - "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal); - } - break; - } - case(HAL_TIMEOUT): { - sif::printDebug("Polling transfer timeout\n"); - return HasReturnvaluesIF::RETURN_FAILED; - } - case(HAL_ERROR): { - sif::printDebug("Polling transfer failure\n"); - return HasReturnvaluesIF::RETURN_FAILED; - } - default: { - return HasReturnvaluesIF::RETURN_FAILED; - } - } - return HasReturnvaluesIF::RETURN_OK; -} diff --git a/stm32h7/devicetest/GyroL3GD20H.h b/stm32h7/devicetest/GyroL3GD20H.h index 917d3ea..72e9ccc 100644 --- a/stm32h7/devicetest/GyroL3GD20H.h +++ b/stm32h7/devicetest/GyroL3GD20H.h @@ -35,18 +35,24 @@ private: const uint32_t L3G_RANGE = 245; SPI_HandleTypeDef* spiHandle; - spi::TransferModes transferMode; + static spi::TransferModes transferMode; static constexpr size_t recvBufferSize = 32 * 10; static std::array rxBuffer; static constexpr size_t txBufferSize = 32; static std::array txBuffer; ReturnValue_t handleDmaTransferInit(); + ReturnValue_t handlePollingTransferInit(); + ReturnValue_t handleInterruptTransferInit(); + ReturnValue_t handleDmaSensorRead(); HAL_StatusTypeDef performDmaTransfer(size_t sendSize); + ReturnValue_t handlePollingSensorRead(); + ReturnValue_t handleInterruptSensorRead(); - ReturnValue_t handlePollingTransfer(); + void prepareConfigRegs(uint8_t* configRegs); + void handleSensorReadout(); }; #endif /* FSFW_HAL_STM32H7_DEVICETEST_GYRO_L3GD20H_H_ */ diff --git a/stm32h7/spi/interrupts.c b/stm32h7/spi/interrupts.c index 90e1047..5137f40 100644 --- a/stm32h7/spi/interrupts.c +++ b/stm32h7/spi/interrupts.c @@ -1,7 +1,12 @@ #include "interrupts.h" +#include "stm32h7xx_hal.h" +#include "stm32h7xx_hal_dma.h" +#include "stm32h7xx_hal_spi.h" + #include + void (*spi1_user_handler) (void* args) = NULL; void * spi1_user_args = NULL; @@ -37,3 +42,32 @@ void SPI2_IRQHandler() { } Default_Handler(); } + +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void dma_rx_irq_handler(void* dma_handle) { + HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dma_handle); +} + +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void dma_tx_irq_handler(void* dma_handle) { + HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dma_handle); +} + +/** + * @brief This function handles SPIx interrupt request. + * @param None + * @retval None + */ +void spi1_irq_handler(void* spi_handle) +{ + HAL_SPI_IRQHandler((SPI_HandleTypeDef *) spi_handle); +} + diff --git a/stm32h7/spi/interrupts.h b/stm32h7/spi/interrupts.h index 60d8fa0..060eaa1 100644 --- a/stm32h7/spi/interrupts.h +++ b/stm32h7/spi/interrupts.h @@ -20,6 +20,15 @@ typedef enum { */ void assign_spi_user_handler(SpiBus spiBus, user_handler_t user_handler, user_args_t user_args); +/** + * Generic interrupt handlers supplied for convenience. Do not call these directly! Set them + * instead with assign_dma_user_handler and assign_spi_user_handler functions. + * @param dma_handle + */ +void dma_rx_irq_handler(void* dma_handle); +void dma_tx_irq_handler(void* dma_handle); +void spi1_irq_handler(void* spi_handle); + #ifdef __cplusplus } #endif diff --git a/stm32h7/spi/mspInit.c b/stm32h7/spi/mspInit.c index 1964391..9025780 100644 --- a/stm32h7/spi/mspInit.c +++ b/stm32h7/spi/mspInit.c @@ -11,10 +11,6 @@ #include -void dma_rx_irq_handler(void* dma_handle); -void dma_tx_irq_handler(void* dma_handle); -void spi1_irq_handler(void* spi_handle); - /** * @brief SPI MSP Initialization * This function configures the hardware resources used in this example: @@ -195,3 +191,17 @@ void hal_spi_msp_deinit_polling(void *hspi) { /* Configure SPI MOSI as alternate function */ HAL_GPIO_DeInit(SPIx_MOSI_GPIO_PORT, SPIx_MOSI_PIN); } + +void hal_spi_msp_init_interrupt(void *hspi) { + hal_spi_msp_init_polling(hspi); + // Configure the NVIC for SPI + assign_spi_user_handler(SPI_1, &spi1_irq_handler, hspi); + HAL_NVIC_SetPriority(SPIx_IRQn, 1, 0); + HAL_NVIC_EnableIRQ(SPIx_IRQn); +} + +void hal_spi_msp_deinit_interrupt(void *hspi) { + hal_spi_msp_deinit_polling(hspi); + // Disable the NVIC for SPI + HAL_NVIC_DisableIRQ(SPIx_IRQn); +} diff --git a/stm32h7/spi/mspInit.h b/stm32h7/spi/mspInit.h index 48ac7b1..da352f6 100644 --- a/stm32h7/spi/mspInit.h +++ b/stm32h7/spi/mspInit.h @@ -11,6 +11,9 @@ void hal_spi_msp_deinit_dma(void *hspi); void hal_spi_msp_init_polling(void *hspi); void hal_spi_msp_deinit_polling(void *hspi); +void hal_spi_msp_init_interrupt(void *hspi); +void hal_spi_msp_deinit_interrupt(void *hspi); + #ifdef __cplusplus } #endif diff --git a/stm32h7/spi/spiCore.c b/stm32h7/spi/spiCore.c index 2516dbf..f0152d2 100644 --- a/stm32h7/spi/spiCore.c +++ b/stm32h7/spi/spiCore.c @@ -32,34 +32,6 @@ SPI_HandleTypeDef* get_spi_handle() { return spiHandle; } -/** - * @brief This function handles DMA Rx interrupt request. - * @param None - * @retval None - */ -void dma_rx_irq_handler(void* dma_handle) { - HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dma_handle); -} - -/** - * @brief This function handles DMA Rx interrupt request. - * @param None - * @retval None - */ -void dma_tx_irq_handler(void* dma_handle) { - HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dma_handle); -} - -/** - * @brief This function handles SPIx interrupt request. - * @param None - * @retval None - */ -void spi1_irq_handler(void* spi_handle) -{ - HAL_SPI_IRQHandler((SPI_HandleTypeDef *) spi_handle); -} - void set_spi_msp_functions(msp_func_t init_func, void* init_args, msp_func_t deinit_func, void* deinit_args) { msp_init_func = init_func;