STM32CubeMX SPI1 receive and send char ?

[antonius]

Posted on September 27, 2015 at 05:37

Guys,

I want to port some a code below to STM32CubeMX

/*******************************************************************************
* Function Name : SPIPutChar
* Description : Send one byte by SPI1
* Input : outb--the byte to be sended 
* Output : None
* Return : None
*******************************************************************************/
unsigned char SPIPutChar(unsigned char outb)
{ 
/* Write and Read a byte on SPI interface. */
unsigned char inb;
/* Wait if TXE cleared, Tx FIFO is full. */
while ((SPI1->SR & TXE) == 0);
SPI1->DR = outb;
/* Wait if RNE cleared, Rx FIFO is empty. */
while ((SPI1->SR & RXNE) == 0);
inb = SPI1->DR;
return (inb);
}
/*******************************************************************************
* Function Name : SPIGetChar
* Description : Read a byte from the SPI.
* Input : None.
* Output : None
* Return : The received byte.
*******************************************************************************/
u8 SPIGetChar(void)
{
u8 Data = 0;
/* Wait until the transmit buffer is empty */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
/* Send the byte */
SPI_I2S_SendData(SPI1, 0xFF);
/* Wait until a data is received */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
/* Get the received data */
Data = SPI_I2S_ReceiveData(SPI1);
/* Return the shifted data */
return Data;
}

I can see from stm32_hal_spi.c

static void SPI_TxCloseIRQHandler(SPI_HandleTypeDef *hspi);
static void SPI_TxISR(SPI_HandleTypeDef *hspi);
static void SPI_RxCloseIRQHandler(SPI_HandleTypeDef *hspi);
static void SPI_2LinesRxISR(SPI_HandleTypeDef *hspi);
static void SPI_RxISR(SPI_HandleTypeDef *hspi);
static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma);
static void SPI_DMAError(DMA_HandleTypeDef *hdma);
static HAL_StatusTypeDef SPI_WaitOnFlagUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, FlagStatus Status, uint32_t Timeout);

Which one is suitable for the function above ? any examples ? I found :

/**
* @brief Transmit an amount of data in blocking mode
* @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
* @param Timeout: Timeout duration
* @retval HAL status
*/
HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
if(hspi->State == HAL_SPI_STATE_READY)
{
if((pData == NULL ) || (Size == 0)) 
{
return HAL_ERROR;
}
/* Check the parameters */
assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));
/* Process Locked */
__HAL_LOCK(hspi);
/* Configure communication */
hspi->State = HAL_SPI_STATE_BUSY_TX;
hspi->ErrorCode = HAL_SPI_ERROR_NONE;
hspi->pTxBuffPtr = pData;
hspi->TxXferSize = Size;
hspi->TxXferCount = Size;
/*Init field not used in handle to zero */
hspi->TxISR = 0;
hspi->RxISR = 0;
hspi->pRxBuffPtr = NULL;
hspi->RxXferSize = 0;
hspi->RxXferCount = 0;
/* Reset CRC Calculation */
if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
{
SPI_RESET_CRC(hspi);
}
if(hspi->Init.Direction == SPI_DIRECTION_1LINE)
{
/* Configure communication direction : 1Line */
SPI_1LINE_TX(hspi);
}
/* Check if the SPI is already enabled */ 
if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
{
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
}
/* Transmit data in 8 Bit mode */
if(hspi->Init.DataSize == SPI_DATASIZE_8BIT)
{
if((hspi->Init.Mode == SPI_MODE_SLAVE)|| (hspi->TxXferCount == 0x01))
{
hspi->Instance->DR = (*hspi->pTxBuffPtr++);
hspi->TxXferCount--;
}
while(hspi->TxXferCount > 0)
{
/* Wait until TXE flag is set to send data */
if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_TXE, RESET, Timeout) != HAL_OK)
{ 
return HAL_TIMEOUT;
}
hspi->Instance->DR = (*hspi->pTxBuffPtr++);
hspi->TxXferCount--;
}
/* Enable CRC Transmission */
if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE) 
{
SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);
}
}
/* Transmit data in 16 Bit mode */
else
{
if((hspi->Init.Mode == SPI_MODE_SLAVE) || (hspi->TxXferCount == 0x01))
{
hspi->Instance->DR = *((uint16_t*)hspi->pTxBuffPtr);
hspi->pTxBuffPtr+=2;
hspi->TxXferCount--;
}
while(hspi->TxXferCount > 0)
{
/* Wait until TXE flag is set to send data */
if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_TXE, RESET, Timeout) != HAL_OK)
{ 
return HAL_TIMEOUT;
}
hspi->Instance->DR = *((uint16_t*)hspi->pTxBuffPtr);
hspi->pTxBuffPtr+=2;
hspi->TxXferCount--;
}
/* Enable CRC Transmission */
if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE) 
{
SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);
}
}
/* Wait until TXE flag is set to send data */
if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_TXE, RESET, Timeout) != HAL_OK)
{
SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);
return HAL_TIMEOUT;
}
/* Wait until Busy flag is reset before disabling SPI */
if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_BSY, SET, Timeout) != HAL_OK)
{ 
SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);
return HAL_TIMEOUT;
}
/* Clear OVERUN flag in 2 Lines communication mode because received is not read */
if(hspi->Init.Direction == SPI_DIRECTION_2LINES)
{
__HAL_SPI_CLEAR_OVRFLAG(hspi);
}
hspi->State = HAL_SPI_STATE_READY; 
/* Process Unlocked */
__HAL_UNLOCK(hspi);
return HAL_OK;
}
else
{
return HAL_BUSY;
}
}

Any examples on how to use it ? I try : HAL_SPI_Transmit(&hspi1, 0x01, 3, 100); I got : ..\Src\main.c(99): error: #167: argument of type ''int'' is incompatible with parameter of type ''uint8_t *'' I'm not sure, any clues ? Correct me if I'm wrong :

uint8_t data[3] = {0x01, 0x02, 0x03};
HAL_SPI_Transmit(&hspi1, data, 3, 100);

It can be compiled....is it the right way ? Thanks

[antonius]

Posted on September 28, 2015 at 00:03

Anyone ?

[Trev]

Posted on September 28, 2015 at 13:27

uint8_t data[3] = {0x01, 0x02, 0x03};
HAL_SPI_Transmit(&hspi1, data, 3, 100);

>It can be compiled....is it the right way ? Looks reasonable, did it compile? If not what was the error message?

[antonius]

Posted on September 28, 2015 at 15:32

Yes I can read the result clearly on Logic analyzer....

How can I send multiple bytes from parameter ? Is this one correct ?thanks

void Mp3WriteRegister(unsigned char addressbyte, unsigned char highbyte, unsigned char lowbyte)
{
Mp3DeselectData();
Mp3SelectControl(); //XCS = 0
uint8_t data6[4] = { VS_WRITE_COMMAND, addressbyte, highbyte, lowbyte };
HAL_SPI_Transmit_DMA(&hspi1,data6,4); 
Mp3DeselectControl();
}