/*====================================================================================================*/
static void MPU9250_SetSpeed( uint8_t SpeedSel )
{
__HAL_SPI_DISABLE(&SPI_HandleStruct);
SPI_HandleStruct.Init.BaudRatePrescaler = SpeedSel;
HAL_SPI_Init(&SPI_HandleStruct);
__HAL_SPI_ENABLE(&SPI_HandleStruct);
}
/*====================================================================================================*/
void IMU_SetSpeed( uint8_t speedSel )
{
__HAL_SPI_DISABLE(&IMU_HandleStruct);
IMU_HandleStruct.Init.BaudRatePrescaler = speedSel;
HAL_SPI_Init(&IMU_HandleStruct);
__HAL_SPI_ENABLE(&IMU_HandleStruct);
}
/**
* Transmit an amount of data in non-blocking mode with Interrupt.
*
* @param hspi pointer to a SPI_HandleTypeDef structure that contains
* the configuration information for SPI module.
* @param pData pointer to data buffer
* @param Size amount of data to be sent
* @retval HAL status
*/
HAL_StatusTypeDef HAL_SPI_Transmit_IT_Custom(SPI_HandleTypeDef *hspi, uint8_t *pData,
uint16_t Size)
{
HAL_StatusTypeDef errorcode = HAL_OK;
/* Process Locked */
__HAL_LOCK(hspi);
errorcode = HAL_SPI_QueueTransmit(hspi, pData, Size);
if (errorcode) {
goto error;
}
/* Enable TXE interrupt */
__HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE));
/* Check if the SPI is already enabled */
if ((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE) {
__HAL_SPI_ENABLE(hspi);
}
error :
__HAL_UNLOCK(hspi);
return errorcode;
}
/**
* @brief IMU_Config
*/
void IMU_Config( void )
{
hImu.pTxBuf = IMU_TX_BUFFER;
hImu.pRxBuf = IMU_RX_BUFFER;
#if defined(__MPU9250_H)
MPU92_Config();
#endif
#if defined(__LPS22HB_H)
LPS22_Config();
#endif
/* SPI Init ****************************************************************/
hImu.handle->Instance = IMU_SPIx;
hImu.handle->Init.Mode = SPI_MODE_MASTER;
hImu.handle->Init.Direction = SPI_DIRECTION_2LINES;
hImu.handle->Init.DataSize = SPI_DATASIZE_8BIT;
hImu.handle->Init.CLKPolarity = SPI_POLARITY_HIGH;
hImu.handle->Init.CLKPhase = SPI_PHASE_2EDGE;
hImu.handle->Init.NSS = SPI_NSS_SOFT;
hImu.handle->Init.BaudRatePrescaler = IMU_SPIx_SPEED_LOW;
hImu.handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
hImu.handle->Init.TIMode = SPI_TIMODE_DISABLE;
hImu.handle->Init.CRCCalculation = SPI_CRCCALCULATION_ENABLE;
hImu.handle->Init.CRCPolynomial = 7;
HAL_SPI_Init(hImu.handle);
__HAL_SPI_ENABLE(hImu.handle);
}
/*====================================================================================================*/
void MPU9250_SetSpeed( uint8_t speedSel )
{
__HAL_SPI_DISABLE(&MPUPx_InitStruct);
MPUPx_InitStruct.Init.BaudRatePrescaler = speedSel;
HAL_SPI_Init(&MPUPx_InitStruct);
__HAL_SPI_ENABLE(&MPUPx_InitStruct);
}
/**
* Transmit and Receive an amount of data in non-blocking mode with Interrupt.
*
* @param hspi pointer to a SPI_HandleTypeDef structure that contains
* the configuration information for SPI module.
* @param pTxData pointer to transmission data buffer
* @param pRxData pointer to reception data buffer
* @param Size amount of data to be sent and received
* @retval HAL status
*/
HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT_Custom(SPI_HandleTypeDef *hspi,
uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
{
HAL_StatusTypeDef errorcode = HAL_OK;
/* Process locked */
__HAL_LOCK(hspi);
errorcode = HAL_SPI_Slave_Queue_TransmitReceive(hspi, pTxData, pRxData, Size);
if (errorcode) {
goto error;
}
/* Enable TXE, RXNE and ERR interrupt */
__HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
/* Check if the SPI is already enabled */
if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
{
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
}
error:
/* Process Unlocked */
__HAL_UNLOCK(hspi);
return errorcode;
}
/**
* Blocking interface to send a buffer and store the received values from the
* slave. The transmit and receive buffers are either arrays of 8-bit (uint8_t)
* values or 16-bit values depending on whether the spi is configured for 8 bit
* data or more than 8 bits per value. The 'cnt' parameter is the number of
* 8-bit or 16-bit values. Thus, if 'cnt' is 10, txbuf/rxbuf would point to an
* array of size 10 (in bytes) if the SPI is using 8-bit data; otherwise
* txbuf/rxbuf would point to an array of size 20 bytes (ten, uint16_t values).
*
* NOTE: these buffers are in the native endian-ness of the platform.
*
* MASTER: master sends all the values in the buffer and stores the
* stores the values in the receive buffer if rxbuf is not NULL.
* The txbuf parameter cannot be NULL.
* SLAVE: cannot be called for a slave; returns -1
*
* @param spi_num SPI interface to use
* @param txbuf Pointer to buffer where values to transmit are stored.
* @param rxbuf Pointer to buffer to store values received from peer.
* @param cnt Number of 8-bit or 16-bit values to be transferred.
*
* @return int 0 on success, non-zero error code on failure.
*/
int
hal_spi_txrx(int spi_num, void *txbuf, void *rxbuf, int len)
{
int rc;
struct stm32_hal_spi *spi;
int sr;
rc = -1;
if (!len) {
goto err;
}
STM32_HAL_SPI_RESOLVE(spi_num, spi);
if (spi->slave) {
goto err;
}
__HAL_DISABLE_INTERRUPTS(sr);
spi_stat.tx++;
__HAL_SPI_ENABLE(&spi->handle);
rc = HAL_SPI_TransmitReceive(&spi->handle, (uint8_t *)txbuf,
(uint8_t *)rxbuf, len,
STM32_HAL_SPI_TIMEOUT);
__HAL_ENABLE_INTERRUPTS(sr);
if (rc != HAL_OK) {
rc = -1;
goto err;
}
rc = 0;
err:
return rc;
}
void DevSPI::initSPI()
{
__HAL_SPI_ENABLE( spi );
if( nss_pin ) {
nss_pin->initHW();
}
nss_post_cond();
last_rc = HAL_OK; last_err = 0;
}
void DevSPI::resetDev()
{
__HAL_SPI_DISABLE( spi );
delay_ms( 1 );
__HAL_SPI_ENABLE( spi );
nss_post_cond();
delay_ms( 1 );
last_rc = HAL_OK;
}
static void init_spi(spi_t *obj)
{
SPI_HandleTypeDef *handle = &SpiHandle[obj->spi.module];
__HAL_SPI_DISABLE(handle);
HAL_SPI_Init(handle);
__HAL_SPI_ENABLE(handle);
}
void spi_abort_asynch(spi_t *obj)
{
// diable interrupt
vIRQ_DisableIRQ(SpiIRQs[obj->spi.module]);
// clean-up
SPI_HandleTypeDef *handle = &SpiHandle[obj->spi.module];
__HAL_SPI_DISABLE(handle);
HAL_SPI_DeInit(handle);
HAL_SPI_Init(handle);
__HAL_SPI_ENABLE(handle);
}
/*====================================================================================================*/
void MPU9250_Config( void )
{
GPIO_InitTypeDef GPIO_InitStruct;
/* SPI Clk ******************************************************************/
SPIx_CS_GPIO_CLK_ENABLE();
SPIx_SCK_GPIO_CLK_ENABLE();
SPIx_SDO_GPIO_CLK_ENABLE();
SPIx_SDI_GPIO_CLK_ENABLE();
SPIx_CLK_ENABLE();
/* SPI Pin ******************************************************************/
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Pin = SPIx_CS_PIN;
HAL_GPIO_Init(SPIx_CS_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Pin = SPIx_SCK_PIN;
HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = SPIx_SDO_PIN;
HAL_GPIO_Init(SPIx_SDO_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = SPIx_SDI_PIN;
HAL_GPIO_Init(SPIx_SDI_GPIO_PORT, &GPIO_InitStruct);
SPIx_CS_H; // 低電位有效
/* SPI Init ****************************************************************/
SPI_HandleStruct.Instance = SPIx;
SPI_HandleStruct.Init.Mode = SPI_MODE_MASTER;
SPI_HandleStruct.Init.Direction = SPI_DIRECTION_2LINES;
SPI_HandleStruct.Init.DataSize = SPI_DATASIZE_8BIT;
SPI_HandleStruct.Init.CLKPolarity = SPI_POLARITY_HIGH;
SPI_HandleStruct.Init.CLKPhase = SPI_PHASE_2EDGE;
SPI_HandleStruct.Init.NSS = SPI_NSS_SOFT;
SPI_HandleStruct.Init.BaudRatePrescaler = SPIx_SPEED_LOW;
SPI_HandleStruct.Init.FirstBit = SPI_FIRSTBIT_MSB;
SPI_HandleStruct.Init.TIMode = SPI_TIMODE_DISABLE;
SPI_HandleStruct.Init.CRCCalculation = SPI_CRCCALCULATION_ENABLE;
SPI_HandleStruct.Init.CRCPolynomial = 7;
HAL_SPI_Init(&SPI_HandleStruct);
__HAL_SPI_ENABLE(&SPI_HandleStruct);
}
void init_spi(spi_t *obj)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
__HAL_SPI_DISABLE(handle);
DEBUG_PRINTF("init_spi: instance=0x%8X\r\n", (int)handle->Instance);
if (HAL_SPI_Init(handle) != HAL_OK) {
error("Cannot initialize SPI");
}
__HAL_SPI_ENABLE(handle);
}
void spi_abort_asynch(spi_t *obj)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
// disable interrupt
IRQn_Type irq_n = spiobj->spiIRQ;
NVIC_ClearPendingIRQ(irq_n);
NVIC_DisableIRQ(irq_n);
// clean-up
__HAL_SPI_DISABLE(handle);
HAL_SPI_DeInit(handle);
HAL_SPI_Init(handle);
__HAL_SPI_ENABLE(handle);
}
uint16_t SpiInOut( Spi_t *obj, uint16_t outData )
{
uint8_t rxData = 0;
if( ( obj == NULL ) || ( obj->Spi.Instance ) == NULL )
{
assert_param( FAIL );
}
__HAL_SPI_ENABLE( &obj->Spi );
while( SpiGetFlag( obj, SPI_FLAG_TXE ) == RESET );
obj->Spi.Instance->DR = ( uint16_t ) ( outData & 0xFF );
while( SpiGetFlag( obj, SPI_FLAG_RXNE ) == RESET );
rxData = ( uint16_t ) obj->Spi.Instance->DR;
return( rxData );
}
/**
* @brief Initializes the SPI communication with the BlueNRG Shield.
* @param None
* @retval None
*/
void BNRG_SPI_Init(void)
{
BNRG_MSP_SPI_Init(&SpiHandle);
SPI_Context.hspi = &SpiHandle;
SPI_Context.Spi_Peripheral_State = SPI_AVAILABLE;
SPI_Context.SPI_Transmit_Context.RequestPending = FALSE;
__HAL_BLUENRG_SPI_ENABLE_DMAREQ(&SpiHandle, SPI_CR2_RXDMAEN | SPI_CR2_TXDMAEN);
__HAL_SPI_ENABLE(&SpiHandle);
#ifdef ENABLE_SPI_FIX
TIMER_Create(eTimerModuleID_Interrupt, &StartupTimerId, eTimerMode_SingleShot, TimerStartupCallback);
#endif
TIMER_Create(eTimerModuleID_Interrupt, &TxRxTimerId, eTimerMode_SingleShot, TimerTxRxCallback);
return;
}
/**
* @brief Set LIS3DSH Initialization.
* @param LIS3DSH_Config_Struct: pointer to a LIS3DSH_Config_TypeDef structure
* that contains the configuration setting for the LIS3DSH.
* @retval None
*/
void LIS3DSH_Init(LIS3DSH_InitTypeDef *LIS3DSH_InitStruct)
{
uint8_t ctrl = 0x00;
/* Configure the low level interface ---------------------------------------*/
/* SPI configuration -------------------------------------------------------*/
__HAL_RCC_SPI1_CLK_ENABLE();
HAL_SPI_DeInit(&SpiHandle);
SpiHandle.Instance = SPI1;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SpiHandle.Init.CRCPolynomial = 7;
SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SpiHandle.Init.NSS = SPI_NSS_SOFT;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
SpiHandle.Init.Mode = SPI_MODE_MASTER;
if (HAL_SPI_Init(&SpiHandle) != HAL_OK) {printf ("ERROR: Error in initialising SPI1 \n");};
__HAL_SPI_ENABLE(&SpiHandle);
/* Configure MEMS: data rate, update mode and axes */
ctrl = (uint8_t) (LIS3DSH_InitStruct->Power_Mode_Output_DataRate | \
LIS3DSH_InitStruct->Continous_Update | \
LIS3DSH_InitStruct->Axes_Enable);
/* Write value to MEMS CTRL_REG4 regsister */
LIS3DSH_Write(&ctrl, LIS3DSH_CTRL_REG4, 1);
/* Configure MEMS: Anti-aliasing filter, full scale, self test */
ctrl = (uint8_t) (LIS3DSH_InitStruct->AA_Filter_BW | \
LIS3DSH_InitStruct->Full_Scale | \
LIS3DSH_InitStruct->Self_Test);
/* Write value to MEMS CTRL_REG5 regsister */
LIS3DSH_Write(&ctrl, LIS3DSH_CTRL_REG5, 1);
}
static void init_spi(spi_t *obj) {
SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
__HAL_SPI_DISABLE(&SpiHandle);
SpiHandle.Init.Mode = obj->mode;
SpiHandle.Init.BaudRatePrescaler = obj->br_presc;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = obj->cpha;
SpiHandle.Init.CLKPolarity = obj->cpol;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SpiHandle.Init.CRCPolynomial = 7;
SpiHandle.Init.DataSize = obj->bits;
SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SpiHandle.Init.NSS = obj->nss;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
HAL_SPI_Init(&SpiHandle);
__HAL_SPI_ENABLE(&SpiHandle);
}
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size)
{
SPI_HandleTypeDef* hspi = &spiHandle[spiDeviceByInstance(Instance)].Handle;
DMA_HandleTypeDef* hdma = &dmaHandle[spiDeviceByInstance(Instance)].Handle;
hdma->Instance = Stream;
hdma->Init.Channel = Channel;
hdma->Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma->Init.PeriphInc = DMA_PINC_DISABLE;
hdma->Init.MemInc = DMA_MINC_ENABLE;
hdma->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma->Init.Mode = DMA_NORMAL;
hdma->Init.FIFOMode = DMA_FIFOMODE_DISABLE;
hdma->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;
hdma->Init.PeriphBurst = DMA_PBURST_SINGLE;
hdma->Init.MemBurst = DMA_MBURST_SINGLE;
hdma->Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_DeInit(hdma);
HAL_DMA_Init(hdma);
__HAL_DMA_ENABLE(hdma);
__HAL_SPI_ENABLE(hspi);
/* Associate the initialized DMA handle to the spi handle */
__HAL_LINKDMA(hspi, hdmatx, (*hdma));
// DMA TX Interrupt
dmaSetHandler(DMA2_ST1_HANDLER, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)spiDeviceByInstance(Instance));
// SCB_CleanDCache_by_Addr((uint32_t) pData, Size);
HAL_SPI_Transmit_DMA(hspi, pData, Size);
//HAL_DMA_Start(&hdma, (uint32_t) pData, (uint32_t) &(Instance->DR), Size);
return hdma;
}
int DevSPI::sendSame( uint8_t ds, int ns )
{
if( ns < 1 || spi->State != HAL_SPI_STATE_READY ) {
return 0;
}
__HAL_LOCK( spi );
spi->State = HAL_SPI_STATE_BUSY_TX;
spi->ErrorCode = HAL_SPI_ERROR_NONE;
if( ( spi->Instance->CR1 & SPI_CR1_SPE ) != SPI_CR1_SPE ) { // need to reenable?
__HAL_SPI_ENABLE( spi );
}
int n = 0;
for( n=0; n<ns; ++n ) {
if( waitForFlag( SPI_FLAG_TXE, SPI_FLAG_TXE ) != HAL_OK ) {
return 0;
}
*( (__IO uint8_t*)&spi->Instance->DR ) = ds;
}
/* Check the end of the transaction */
if( waitForFlag( SPI_FLAG_BSY, 0 ) != HAL_OK ) {
// TODO: error
return 0;
}
__HAL_SPI_CLEAR_OVRFLAG( spi );
spi->State = HAL_SPI_STATE_READY;
__HAL_UNLOCK( spi );
return n;
}
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size)
{
SPIDevice device = spiDeviceByInstance(Instance);
spiHardwareMap[device].hdma.Instance = Stream;
spiHardwareMap[device].hdma.Init.Channel = Channel;
spiHardwareMap[device].hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
spiHardwareMap[device].hdma.Init.PeriphInc = DMA_PINC_DISABLE;
spiHardwareMap[device].hdma.Init.MemInc = DMA_MINC_ENABLE;
spiHardwareMap[device].hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
spiHardwareMap[device].hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
spiHardwareMap[device].hdma.Init.Mode = DMA_NORMAL;
spiHardwareMap[device].hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
spiHardwareMap[device].hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;
spiHardwareMap[device].hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;
spiHardwareMap[device].hdma.Init.MemBurst = DMA_MBURST_SINGLE;
spiHardwareMap[device].hdma.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_DeInit(&spiHardwareMap[device].hdma);
HAL_DMA_Init(&spiHardwareMap[device].hdma);
__HAL_DMA_ENABLE(&spiHardwareMap[device].hdma);
__HAL_SPI_ENABLE(&spiHardwareMap[device].hspi);
/* Associate the initialized DMA handle to the spi handle */
__HAL_LINKDMA(&spiHardwareMap[device].hspi, hdmatx, spiHardwareMap[device].hdma);
// DMA TX Interrupt
dmaSetHandler(spiHardwareMap[device].dmaIrqHandler, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)device);
//HAL_CLEANCACHE(pData,Size);
// And Transmit
HAL_SPI_Transmit_DMA(&spiHardwareMap[device].hspi, pData, Size);
return &spiHardwareMap[device].hdma;
}
/**
* @brief SPI initialization function
* @param obj : pointer to spi_t structure
* @param speed : spi output speed
* @param mode : one of the spi modes
* @param msb : set to 1 in msb first
* @retval None
*/
void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
{
if(obj == NULL)
return;
SPI_HandleTypeDef *handle = &(obj->handle);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_TypeDef *port;
uint32_t spi_freq = 0;
// Determine the SPI to use
SPI_TypeDef *spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI);
SPI_TypeDef *spi_miso = pinmap_peripheral(obj->pin_miso, PinMap_SPI_MISO);
SPI_TypeDef *spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK);
SPI_TypeDef *spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL);
/* Pins MOSI/MISO/SCLK must not be NP. ssel can be NP. */
if(spi_mosi == NP || spi_miso == NP || spi_sclk == NP) {
printf("ERROR: at least one SPI pin has no peripheral\n");
return;
}
SPI_TypeDef *spi_data = pinmap_merge_peripheral(spi_mosi, spi_miso);
SPI_TypeDef *spi_cntl = pinmap_merge_peripheral(spi_sclk, spi_ssel);
obj->spi = pinmap_merge_peripheral(spi_data, spi_cntl);
// Are all pins connected to the same SPI instance?
if(obj->spi == NP) {
printf("ERROR: SPI pins mismatch\n");
return;
}
// Configure the SPI pins
if (obj->pin_ssel != NC) {
handle->Init.NSS = SPI_NSS_HARD_OUTPUT;
} else {
handle->Init.NSS = SPI_NSS_SOFT;
}
/* Fill default value */
handle->Instance = obj->spi;
handle->Init.Mode = SPI_MODE_MASTER;
spi_freq = spi_getClkFreqInst(obj->spi);
if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
} else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
} else {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
}
handle->Init.Direction = SPI_DIRECTION_2LINES;
if((mode == SPI_MODE_0)||(mode == SPI_MODE_2)) {
handle->Init.CLKPhase = SPI_PHASE_1EDGE;
} else {
handle->Init.CLKPhase = SPI_PHASE_2EDGE;
}
if((mode == SPI_MODE_0)||(mode == SPI_MODE_1)) {
handle->Init.CLKPolarity = SPI_POLARITY_LOW;
} else {
handle->Init.CLKPolarity = SPI_POLARITY_HIGH;
}
handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
handle->Init.CRCPolynomial = 7;
handle->Init.DataSize = SPI_DATASIZE_8BIT;
if(msb == 0) {
handle->Init.FirstBit = SPI_FIRSTBIT_LSB;
} else {
handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
}
handle->Init.TIMode = SPI_TIMODE_DISABLE;
#if defined(STM32F0xx) || defined(STM32F3xx) || defined(STM32F7xx) || defined(STM32L4xx)
handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
#endif
if(obj->pin_mosi != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_miso != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_sclk != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
/*
* According the STM32 Datasheet for SPI peripheral we need to PULLDOWN
* or PULLUP the SCK pin according the polarity used.
*/
if(handle->Init.CLKPolarity == SPI_POLARITY_LOW) {
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
} else {
GPIO_InitStruct.Pull = GPIO_PULLUP;
}
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_ssel != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
#if defined SPI1_BASE
// Enable SPI clock
if (handle->Instance == SPI1) {
__HAL_RCC_SPI1_CLK_ENABLE();
}
#endif
#if defined SPI2_BASE
if (handle->Instance == SPI2) {
__HAL_RCC_SPI2_CLK_ENABLE();
}
#endif
#if defined SPI3_BASE
if (handle->Instance == SPI3) {
__HAL_RCC_SPI3_CLK_ENABLE();
}
#endif
#if defined SPI4_BASE
if (handle->Instance == SPI4) {
__HAL_RCC_SPI4_CLK_ENABLE();
}
#endif
#if defined SPI5_BASE
if (handle->Instance == SPI5) {
__HAL_RCC_SPI5_CLK_ENABLE();
}
#endif
#if defined SPI6_BASE
if (handle->Instance == SPI6) {
__HAL_RCC_SPI6_CLK_ENABLE();
}
#endif
HAL_SPI_Init(handle);
/* In order to set correctly the SPI polarity we need to enable the peripheral */
__HAL_SPI_ENABLE(handle);
}
/* Private functions */
static void TM_SPIx_Init(SPI_TypeDef* SPIx, TM_SPI_PinsPack_t pinspack, TM_SPI_Mode_t SPI_Mode, uint16_t SPI_BaudRatePrescaler, uint16_t SPI_MasterSlave, uint16_t SPI_FirstBit) {
SPI_HandleTypeDef SPIHandle;
/* Save instance */
SPIHandle.Instance = SPIx;
#ifdef SPI1
if (SPIx == SPI1) {
/* Enable SPI clock */
__HAL_RCC_SPI1_CLK_ENABLE();
/* Init pins */
TM_SPI1_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI1_DATASIZE;
}
#endif
#ifdef SPI2
if (SPIx == SPI2) {
/* Enable SPI clock */
__HAL_RCC_SPI2_CLK_ENABLE();
/* Init pins */
TM_SPI2_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI2_DATASIZE;
}
#endif
#ifdef SPI3
if (SPIx == SPI3) {
/* Enable SPI clock */
__HAL_RCC_SPI3_CLK_ENABLE();
/* Init pins */
TM_SPI3_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI3_DATASIZE;
}
#endif
#ifdef SPI4
if (SPIx == SPI4) {
/* Enable SPI clock */
__HAL_RCC_SPI4_CLK_ENABLE();
/* Init pins */
TM_SPI4_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI4_DATASIZE;
}
#endif
#ifdef SPI5
if (SPIx == SPI5) {
/* Enable SPI clock */
__HAL_RCC_SPI5_CLK_ENABLE();
/* Init pins */
TM_SPI5_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI5_DATASIZE;
}
#endif
#ifdef SPI6
if (SPIx == SPI6) {
/* Enable SPI clock */
__HAL_RCC_SPI6_CLK_ENABLE();
/* Init pins */
TM_SPI6_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI6_DATASIZE;
}
#endif
/* Fill SPI settings */
SPIHandle.Init.BaudRatePrescaler = SPI_BaudRatePrescaler;
SPIHandle.Init.FirstBit = SPI_FirstBit;
SPIHandle.Init.Mode = SPI_MasterSlave;
SPIHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
SPIHandle.Init.CRCPolynomial = 7;
SPIHandle.Init.TIMode = SPI_TIMODE_DISABLE;
SPIHandle.Init.NSS = SPI_NSS_SOFT;
SPIHandle.Init.Direction = SPI_DIRECTION_2LINES;
#if defined(STM32F7xx)
SPIHandle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
SPIHandle.Init.CRCLength = SPI_CRC_LENGTH_8BIT;
#endif
/* SPI mode */
if (SPI_Mode == TM_SPI_Mode_0) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
} else if (SPI_Mode == TM_SPI_Mode_1) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
} else if (SPI_Mode == TM_SPI_Mode_2) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
} else if (SPI_Mode == TM_SPI_Mode_3) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
}
/* Disable first */
__HAL_SPI_DISABLE(&SPIHandle);
/* Init SPI */
HAL_SPI_Init(&SPIHandle);
/* Enable SPI */
__HAL_SPI_ENABLE(&SPIHandle);
}
static rt_err_t stm32_spi_init(struct stm32_spi *spi_drv, struct rt_spi_configuration *cfg)
{
RT_ASSERT(spi_drv != RT_NULL);
RT_ASSERT(cfg != RT_NULL);
SPI_HandleTypeDef *spi_handle = &spi_drv->handle;
if (cfg->mode & RT_SPI_SLAVE)
{
spi_handle->Init.Mode = SPI_MODE_SLAVE;
}
else
{
spi_handle->Init.Mode = SPI_MODE_MASTER;
}
if (cfg->mode & RT_SPI_3WIRE)
{
spi_handle->Init.Direction = SPI_DIRECTION_1LINE;
}
else
{
spi_handle->Init.Direction = SPI_DIRECTION_2LINES;
}
if (cfg->data_width == 8)
{
spi_handle->Init.DataSize = SPI_DATASIZE_8BIT;
spi_handle->TxXferSize = 8;
spi_handle->RxXferSize = 8;
}
else if (cfg->data_width == 16)
{
spi_handle->Init.DataSize = SPI_DATASIZE_16BIT;
}
else
{
return RT_EIO;
}
if (cfg->mode & RT_SPI_CPHA)
{
spi_handle->Init.CLKPhase = SPI_PHASE_2EDGE;
}
else
{
spi_handle->Init.CLKPhase = SPI_PHASE_1EDGE;
}
if (cfg->mode & RT_SPI_CPOL)
{
spi_handle->Init.CLKPolarity = SPI_POLARITY_HIGH;
}
else
{
spi_handle->Init.CLKPolarity = SPI_POLARITY_LOW;
}
if (cfg->mode & RT_SPI_NO_CS)
{
spi_handle->Init.NSS = SPI_NSS_SOFT;
}
else
{
spi_handle->Init.NSS = SPI_NSS_SOFT;
}
uint32_t SPI_APB_CLOCK;
#if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)
SPI_APB_CLOCK = HAL_RCC_GetPCLK1Freq();
#else
SPI_APB_CLOCK = HAL_RCC_GetPCLK2Freq();
#endif
if (cfg->max_hz >= SPI_APB_CLOCK / 2)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 4)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 8)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 16)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 32)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 64)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
}
else if (cfg->max_hz >= SPI_APB_CLOCK / 128)
{
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
}
else
{
/* min prescaler 256 */
spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
}
LOG_D("sys freq: %d, pclk2 freq: %d, SPI limiting freq: %d, BaudRatePrescaler: %d",
HAL_RCC_GetSysClockFreq(),
SPI_APB_CLOCK,
cfg->max_hz,
spi_handle->Init.BaudRatePrescaler);
if (cfg->mode & RT_SPI_MSB)
{
spi_handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
}
else
{
spi_handle->Init.FirstBit = SPI_FIRSTBIT_LSB;
}
spi_handle->Init.TIMode = SPI_TIMODE_DISABLE;
spi_handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
spi_handle->State = HAL_SPI_STATE_RESET;
#if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0)
spi_handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
#endif
if (HAL_SPI_Init(spi_handle) != HAL_OK)
{
return RT_EIO;
}
#if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F0) \
|| defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32G0)
SET_BIT(spi_handle->Instance->CR2, SPI_RXFIFO_THRESHOLD_HF);
#endif
/* DMA configuration */
if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)
{
HAL_DMA_Init(&spi_drv->dma.handle_rx);
__HAL_LINKDMA(&spi_drv->handle, hdmarx, spi_drv->dma.handle_rx);
/* NVIC configuration for DMA transfer complete interrupt */
HAL_NVIC_SetPriority(spi_drv->config->dma_rx->dma_irq, 0, 0);
HAL_NVIC_EnableIRQ(spi_drv->config->dma_rx->dma_irq);
}
if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG)
{
HAL_DMA_Init(&spi_drv->dma.handle_tx);
__HAL_LINKDMA(&spi_drv->handle, hdmatx, spi_drv->dma.handle_tx);
/* NVIC configuration for DMA transfer complete interrupt */
HAL_NVIC_SetPriority(spi_drv->config->dma_tx->dma_irq, 0, 1);
HAL_NVIC_EnableIRQ(spi_drv->config->dma_tx->dma_irq);
}
__HAL_SPI_ENABLE(spi_handle);
LOG_D("%s init done", spi_drv->config->bus_name);
return RT_EOK;
}
static rt_err_t stm32_spi_init(SPI_TypeDef *spix, struct rt_spi_configuration *cfg)
{
SPI_HandleTypeDef hspi;
hspi.Instance = spix;
if (cfg->mode & RT_SPI_SLAVE)
{
hspi.Init.Mode = SPI_MODE_SLAVE;
}
else
{
hspi.Init.Mode = SPI_MODE_MASTER;
}
if (cfg->mode & RT_SPI_3WIRE)
{
hspi.Init.Direction = SPI_DIRECTION_1LINE;
}
else
{
hspi.Init.Direction = SPI_DIRECTION_2LINES;
}
if (cfg->data_width == 8)
{
hspi.Init.DataSize = SPI_DATASIZE_8BIT;
}
else if (cfg->data_width == 16)
{
hspi.Init.DataSize = SPI_DATASIZE_16BIT;
}
else
{
return RT_EIO;
}
if (cfg->mode & RT_SPI_CPHA)
{
hspi.Init.CLKPhase = SPI_PHASE_2EDGE;
}
else
{
hspi.Init.CLKPhase = SPI_PHASE_1EDGE;
}
if (cfg->mode & RT_SPI_CPOL)
{
hspi.Init.CLKPolarity = SPI_POLARITY_HIGH;
}
else
{
hspi.Init.CLKPolarity = SPI_POLARITY_LOW;
}
if (cfg->mode & RT_SPI_NO_CS)
{
hspi.Init.NSS = SPI_NSS_SOFT;
}
else
{
hspi.Init.NSS = SPI_NSS_SOFT;
// hspi.Init.NSS = SPI_NSS_HARD_OUTPUT;
}
if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/2)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/4)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/8)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/16)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/32)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/64)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
}
else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/128)
{
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
}
else
{
/* min prescaler 256 */
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
}
if (cfg->mode & RT_SPI_MSB)
{
hspi.Init.FirstBit = SPI_FIRSTBIT_MSB;
}
else
{
hspi.Init.FirstBit = SPI_FIRSTBIT_LSB;
}
hspi.Init.TIMode = SPI_TIMODE_DISABLE;
hspi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi.Init.CRCPolynomial = 7;
hspi.State = HAL_SPI_STATE_RESET;
if (HAL_SPI_Init(&hspi) != HAL_OK)
{
return RT_EIO;
}
__HAL_SPI_ENABLE(&hspi);
return RT_EOK;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F103xB HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLE;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
SpiHandle.Init.CRCPolynomial = 7;
SpiHandle.Init.NSS = SPI_NSS_SOFT;
#ifdef MASTER_BOARD
SpiHandle.Init.Mode = SPI_MODE_MASTER;
#else
SpiHandle.Init.Mode = SPI_MODE_SLAVE;
#endif /* MASTER_BOARD */
if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
#ifdef MASTER_BOARD
/* SPI block is enabled prior calling SPI transmit/receive functions, in order to get CLK signal properly pulled down.
Otherwise, SPI CLK signal is not clean on this board and leads to errors during transfer */
__HAL_SPI_ENABLE(&SpiHandle);
/* Configure User push-button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
/* Wait for User push-button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_USER) != GPIO_PIN_RESET)
{
BSP_LED_Toggle(LED2);
HAL_Delay(100);
}
BSP_LED_Off(LED2);
#endif /* MASTER_BOARD */
/*##-2- Start the Full Duplex Communication process ########################*/
/* While the SPI in TransmitReceive process, user can transmit data through
"aTxBuffer" buffer & receive data through "aRxBuffer" */
/* Timeout is set to 5S */
switch(HAL_SPI_TransmitReceive(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE, 5000))
{
case HAL_OK:
/* Communication is completed ___________________________________________ */
/* Compare the sent and received buffers */
if (Buffercmp((uint8_t *)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE))
{
/* Transfer error in transmission process */
Error_Handler();
}
/* Turn LED2 on: Transfer in transmission/Reception process is correct */
BSP_LED_On(LED2);
break;
case HAL_TIMEOUT:
/* An Error Occur ______________________________________________________ */
case HAL_ERROR:
/* Call Timeout Handler */
Error_Handler();
break;
default:
break;
}
/* Infinite loop */
while (1)
{
}
}
HAL_StatusTypeDef HAL_SPI_Slave_Queue_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
{
uint32_t tmp = 0U, tmp1 = 0U;
HAL_StatusTypeDef errorcode = HAL_OK;
tmp = hspi->State;
tmp1 = hspi->Init.Mode;
if(!((tmp == HAL_SPI_STATE_READY) || ((tmp1 == SPI_MODE_MASTER) && (tmp == HAL_SPI_STATE_BUSY_RX))))
{
errorcode = HAL_BUSY;
goto error;
}
if((pTxData == NULL ) || (pRxData == NULL ) || (Size == 0))
{
errorcode = HAL_ERROR;
goto error;
}
/* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */
if(hspi->State == HAL_SPI_STATE_READY)
{
hspi->State = HAL_SPI_STATE_BUSY_TX_RX;
}
/* Set the transaction information */
hspi->ErrorCode = HAL_SPI_ERROR_NONE;
hspi->pTxBuffPtr = (uint8_t *)pTxData;
hspi->TxXferSize = Size;
hspi->TxXferCount = Size;
hspi->pRxBuffPtr = (uint8_t *)pRxData;
hspi->RxXferSize = Size;
hspi->RxXferCount = Size;
/* Set the function for IT treatment */
if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
{
hspi->RxISR = SPI_2linesRxISR_16BIT;
hspi->TxISR = SPI_2linesTxISR_16BIT;
}
else
{
hspi->RxISR = SPI_2linesRxISR_8BIT;
hspi->TxISR = SPI_2linesTxISR_8BIT;
}
/* Enable TXE, RXNE and ERR interrupt */
//__HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
/* MYNEWT: in slave mode write 1st byte to DR */
if ((hspi->Instance->CR1 & SPI_CR1_MSTR) == 0) {
hspi->TxISR(hspi);
}
#if 0
/* Check if the SPI is already enabled */
if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
{
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
}
#endif
error :
return errorcode;
}
HAL_StatusTypeDef HAL_SPI_QueueTransmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)
{
HAL_StatusTypeDef errorcode = HAL_OK;
if((pData == NULL) || (Size == 0))
{
errorcode = HAL_ERROR;
goto error;
}
if(hspi->State != HAL_SPI_STATE_READY)
{
errorcode = HAL_BUSY;
goto error;
}
/* Set the transaction information */
hspi->State = HAL_SPI_STATE_BUSY_TX;
hspi->ErrorCode = HAL_SPI_ERROR_NONE;
hspi->pTxBuffPtr = (uint8_t *)pData;
hspi->TxXferSize = Size;
hspi->TxXferCount = Size;
/* Init field not used in handle to zero */
hspi->pRxBuffPtr = (uint8_t *)NULL;
hspi->RxXferSize = 0U;
hspi->RxXferCount = 0U;
hspi->RxISR = NULL;
/* Set the function for IT treatment */
if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
{
hspi->TxISR = SPI_TxISR_16BIT;
}
else
{
hspi->TxISR = SPI_TxISR_8BIT;
}
#if 0 /* MYNEWT: TODO */
/* Enable TXE interrupt */
__HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE));
#endif
/* MYNEWT: in slave mode write 1st byte to DR */
if ((hspi->Instance->CR1 & SPI_CR1_MSTR) == 0) {
hspi->TxISR(hspi);
}
#if 0 /* MYNEWT: TODO */
/* Check if the SPI is already enabled */
if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
{
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
}
#endif
error :
return errorcode;
}
/**
* @brief MPU 片选使能
* @param None
* @retval None
*/
static void MPU_SPISelect(void)
{
__HAL_SPI_ENABLE(MPU_SPI);
HAL_GPIO_WritePin(SPI_CS_GPIO_Port, SPI_CS_Pin, GPIO_PIN_RESET);
}
/*====================================================================================================*/
void IMU_Config( void )
{
GPIO_InitTypeDef GPIO_InitStruct;
/* SPI Clk ******************************************************************/
IMU_CSM_GPIO_CLK_ENABLE();
IMU_CSB_GPIO_CLK_ENABLE();
IMU_SCK_GPIO_CLK_ENABLE();
IMU_SDO_GPIO_CLK_ENABLE();
IMU_SDI_GPIO_CLK_ENABLE();
// IMU_INTM_GPIO_CLK_ENABLE();
// IMU_INTB_GPIO_CLK_ENABLE();
IMU_SPIx_CLK_ENABLE();
/* SPI Pin ******************************************************************/
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Pin = IMU_CSM_PIN;
HAL_GPIO_Init(IMU_CSM_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = IMU_CSB_PIN;
HAL_GPIO_Init(IMU_CSB_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Pin = IMU_SCK_PIN;
GPIO_InitStruct.Alternate = IMU_SCK_AF;
HAL_GPIO_Init(IMU_SCK_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = IMU_SDO_PIN;
GPIO_InitStruct.Alternate = IMU_SDO_AF;
HAL_GPIO_Init(IMU_SDO_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = IMU_SDI_PIN;
GPIO_InitStruct.Alternate = IMU_SDI_AF;
HAL_GPIO_Init(IMU_SDI_GPIO_PORT, &GPIO_InitStruct);
// // EXIT Config
// GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
// GPIO_InitStruct.Pull = GPIO_PULLUP;
// GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
// GPIO_InitStruct.Pin = IMU_INTM_PIN;
// HAL_GPIO_Init(IMU_INTM_GPIO_PORT, &GPIO_InitStruct);
// HAL_NVIC_SetPriority(IMU_INTM_IRQ, 14, 0);
// HAL_NVIC_EnableIRQ(IMU_INTM_IRQ);
#ifdef _USE_BAROMETER
// GPIO_InitStruct.Pin = IMU_INTB_PIN;
// HAL_GPIO_Init(IMU_INTB_GPIO_PORT, &GPIO_InitStruct);
// HAL_NVIC_SetPriority(IMU_INTB_IRQ, 14, 0);
// HAL_NVIC_EnableIRQ(IMU_INTB_IRQ);
#endif
/* CS Pin Set High ******************************************************************/
IMU_CSM_H();
IMU_CSB_H();
/* SPI Init ****************************************************************/
IMU_HandleStruct.Instance = IMU_SPIx;
IMU_HandleStruct.Init.Mode = SPI_MODE_MASTER;
IMU_HandleStruct.Init.Direction = SPI_DIRECTION_2LINES;
IMU_HandleStruct.Init.DataSize = SPI_DATASIZE_8BIT;
IMU_HandleStruct.Init.CLKPolarity = SPI_POLARITY_HIGH;
IMU_HandleStruct.Init.CLKPhase = SPI_PHASE_2EDGE;
IMU_HandleStruct.Init.NSS = SPI_NSS_SOFT;
IMU_HandleStruct.Init.BaudRatePrescaler = IMU_SPIx_SPEED_LOW;
IMU_HandleStruct.Init.FirstBit = SPI_FIRSTBIT_MSB;
IMU_HandleStruct.Init.TIMode = SPI_TIMODE_DISABLE;
IMU_HandleStruct.Init.CRCCalculation = SPI_CRCCALCULATION_ENABLE;
IMU_HandleStruct.Init.CRCPolynomial = 7;
HAL_SPI_Init(&IMU_HandleStruct);
__HAL_SPI_ENABLE(&IMU_HandleStruct);
}