STATE SPI READY - HAL Driver

[Vitor Schulter]

Hello,

I am working on a code that uses the HAL library for SPI communication. But I have a problem with SPI's state-checking routine.

void libera_escrita(void)

{

SPI_TxBuffer[0] = 6;

HAL_GPIO_WritePin(GPIOC, CS_Pin, GPIO_PIN_RESET);

while (HAL_SPI_GetState(&hspi1) != HAL_SPI_STATE_READY);

HAL_SPI_TransmitReceive_IT(&hspi1, (uint8_t*)SPI_TxBuffer, (uint8_t *)SPI_RxBuffer, 1);

while (HAL_SPI_GetState(&hspi1) != HAL_SPI_STATE_READY);

HAL_GPIO_WritePin(GPIOC, CS_Pin, GPIO_PIN_SET);

}

My code stays in that while, what could be causing this?

[T J]

You shouldn't be using the HAL_SPI_TransmitReceive_IT(),

I dont bother to DMA the SPI since I am not streaming data like Audio

I use these routines without issue:

void transfer(unsigned short data) {
 char RxSPI;
 
 while (!(hspi1.Instance->SR & SPI_FLAG_TXE)) ; // wait while not empty
 *((__IO uint8_t *)&hspi1.Instance->DR) = data; // send datat here
 RxSPI = hspi1.Instance->DR;// + readSPI_SR; // read Rx byte and discard, only clearing the buffer
}
char transfer_receive(unsigned short data) {
 
 char RxSPI; 
 while(!(hspi1.Instance->SR & SPI_FLAG_TXE))
 ;
 while ((hspi1.Instance->SR & SPI_FLAG_RXNE)) // load all the bytes received, only keep the last one
 RxSPI = hspi1.Instance->DR; //empty fifo
 
 *((__IO uint8_t *)&hspi1.Instance->DR) = data; // force the SPI to transceive 8 bit
 while(!(hspi1.Instance->SR & SPI_FLAG_TXE)) // wait to transmitter double buffer to shift into transmitter
 ; 
 while ((hspi1.Instance->SR & SPI_FLAG_BSY)) ; // wait for data to shift out of the processor pins
 while((hspi1.Instance->SR & SPI_FLAG_RXNE)) // load all the bytes received, only keep the last one
 RxSPI = hspi1.Instance->DR; // we only want the last byte
 
 return RxSPI;
}

like this:

void eraseSector(char command, uint32_t address){
 enableFlashWrites();
 
 
 // command should be BlockErase4k, or BlockErase12k or ChipErase
 HAL_GPIO_WritePin(AT25DN256_nSS_GPIO_Port, AT25DN256_nSS_Pin, GPIO_PIN_RESET); 
 transfer(command); 
 char addressByte2 = (address >> 16) & 0xff;
 char addressByte1 = (address >> 8) & 0xff;
 char addressByte0 = (address) & 0xff;
 
 char dummyByte = 0;
 transfer(addressByte2);
 transfer(addressByte1);
 transfer_receive(addressByte0);
 
 
 HAL_GPIO_WritePin(AT25DN256_nSS_GPIO_Port, AT25DN256_nSS_Pin, GPIO_PIN_SET); 
 // erase should start now 
}

and something a little more detailed :

void readFlashBytes(uint32_t address, int length, char*ptr){
 
 int flashStatus1 = readFlashCommand(ReadStatusByte); 
 int flashStatus2 = readFlashCommand(ReadStatusByte2); 
 
 // printf(string, "Flash Status bytes %02x", flashStatus1); 
 
 while((flashStatus1 & 0x01)) {
 // busy not ready
 checkBackgroundServices(); // this checks the Uart DMAs progress " OS services" 
 flashStatus1 = readFlashCommand(ReadStatusByte);
 } 
 
 HAL_GPIO_WritePin(AT25DN256_nSS_GPIO_Port, AT25DN256_nSS_Pin, GPIO_PIN_RESET);
 
 transfer(ReadFlashByte);
 char addressByte2 = (address >> 16) & 0xff;
 char addressByte1 = (address >> 8) & 0xff;
 char addressByte0 = (address) & 0xff;
 
 char dummyByte = 0;
 transfer(addressByte2);
 transfer(addressByte1);
 transfer(addressByte0);
 
 while (length--)
 { 
 *ptr = transfer_receive(dummyByte);
 ptr++;
 } 
 HAL_GPIO_WritePin(AT25DN256_nSS_GPIO_Port, AT25DN256_nSS_Pin, GPIO_PIN_SET); 
}

[Vitor Schulter]

Hello thank you for the answer

I used the routine you suggested, but it seems I still have the same problem. When executing the following line

while (! (hspi1.Instance-> SR & SPI_FLAG_TXE));

The code is locked on this line.

[Peter Mather]

Are you sure you have the relevant clocks running? Have a look at the SPI examples in CubeMX

[T J]

I use this to initialise ...

void CAN_Config() {
 CAN_FilterConfTypeDef sFilterConfig;
 static CanTxMsgTypeDef TxMessage;
 static CanRxMsgTypeDef RxMessage;
 
 //##-1- Configure the CAN peripheral #######################################
 hcan.pTxMsg = &TxMessage;
 hcan.pRxMsg = &RxMessage;
 
 hcan.pTxMsg->RTR	 	= CAN_RTR_DATA;
 hcan.pTxMsg->DLC	 	= 8; 		
 hcan.pTxMsg->StdId	 	= 0x101; 	
 hcan.pTxMsg->ExtId	 	= 0x102; 	
	
 hcan.pRxMsg->DLC	 	= 8; 	
 hcan.pRxMsg->StdId	 	= 0x101; 	
 hcan.pRxMsg->ExtId	 	= 0x102; 	 		
 hcan.pRxMsg->RTR	 	= CAN_RTR_DATA; 						
 
 if(HAL_CAN_Init(&hcan) != HAL_OK)
 {
 // Initiliazation Error 
 _Error_Handler(__FILE__, __LINE__);
 }
 
 //##-2- Configure the CAN Filter ###########################################
 sFilterConfig.FilterNumber 					= 0;
 sFilterConfig.FilterMode 					= CAN_FILTERMODE_IDMASK;
 sFilterConfig.FilterScale 					= CAN_FILTERSCALE_32BIT;
 sFilterConfig.FilterIdHigh 					= 0x400 << 5; //11-bit ID in top bits
 sFilterConfig.FilterIdLow 					= 0x0000;
 sFilterConfig.FilterMaskIdHigh	 	 = 0x600 << 5; 	// resolves as 0x0400 - 0x05FF
 sFilterConfig.FilterMaskIdLow				= 0x0000;
 sFilterConfig.FilterFIFOAssignment	 = 0;
 sFilterConfig.FilterActivation	 = ENABLE;
 sFilterConfig.BankNumber 	 			= 0;
 
 if (HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)
 {
 // Filter configuration Error 
 _Error_Handler(__FILE__, __LINE__);
 char string[38];
 
 sprintf( string, "Can Filter configuration Error\n\r");
 puts1( string);
 }
 
 //##-2- Configure the 2nd CAN Filter ###########################################
 sFilterConfig.FilterNumber 			= 1;
 sFilterConfig.FilterMode 			= CAN_FILTERMODE_IDMASK;
 sFilterConfig.FilterScale 			= CAN_FILTERSCALE_32BIT;
 sFilterConfig.FilterIdHigh 			= 0x600 << 5; //11-bit ID in top bits		// command channel
 sFilterConfig.FilterIdLow 			= 0x0000;
 sFilterConfig.FilterMaskIdHigh		= 0x700 << 5; 	// resolves as 0x0600 - 0x06FF
 sFilterConfig.FilterMaskIdLow		= 0x0000;
 sFilterConfig.FilterFIFOAssignment	= 1;
 sFilterConfig.FilterActivation		= ENABLE;
 sFilterConfig.BankNumber 			= 1;
 
 if (HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)
 {
 // Filter configuration Error 
 _Error_Handler(__FILE__, __LINE__);
 char string[38];
 sprintf( string, "Can Filter configuration Error\n\r");
 puts1( string);
 }
 
}

thats wrapped in my own CanStartup routine.

void initCairoCan(void) {
 CAN_Config();
 canRxpointerIN = 0;
 canRxMsgIN = 0;
 canRxMsgOUT = 0;
 canRxMsgTableEMPTY = true;
 canRxMsgTableFULL = false; 
 
 for (int i = 0; i < 16; i++)
 IOCanMsgFlag[i] = false;
 
			
	
 __HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP1);
 __HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);
		
 canTxMsgIN = 0;
 canTxMsgOUT = 0;
 canTxMsgTableEMPTY 		= true;
 canTxMsgTableFULL 		= false;
 canTxMsgTableOverflow = false;
 canTxMsgOverrun = false;
 blockCanTx = false;
 
}

then it all works.

[Vitor Schulter]

TJ, Is this routine that you sent is not for CAN protocol?

[T J]

my bad, wrong post... :)

[Vitor Schulter]

Hello, I still have the same problem. My code stops executing because the status of the SPI bus stays as:

 HAL_SPI_STATE_BUSY_TX_RX = 0x05U, / *! <Data Transmission and Reception process is ongoing * /

Would anyone have any more suggestions?

[Vitor Schulter]

I have now realized that the SPI problem is only caught after some data has been received by the UART

[T J]

Did you find the issue ?