/// @returns the number of bytes transferred, or `0` if nothing transferred
static int spi_master_start_asynch_transfer(spi_t *obj, transfer_type_t transfer_type, void *tx, void *rx, size_t length)
{
if (transfer_type != SPI_TRANSFER_TYPE_TX) DEBUG_PRINTF("SPI%u: Start: %u, %u\n", obj->spi.module+1, transfer_type, length);
SPI_HandleTypeDef *handle = &SpiHandle[obj->spi.module];
obj->spi.transfer_type = transfer_type;
bool is16bit = (handle->Init.DataSize == SPI_DATASIZE_16BIT);
// the HAL expects number of transfers instead of number of bytes
// so for 16 bit transfer width the count needs to be halved
size_t words;
if (is16bit) words = length / 2;
else words = length;
// enable the interrupt
IRQn_Type irq_n = SpiIRQs[obj->spi.module];
vIRQ_EnableIRQ(irq_n);
// enable the right hal transfer
static uint16_t sink;
int rc = 0;
switch(transfer_type) {
case SPI_TRANSFER_TYPE_TXRX:
rc = HAL_SPI_TransmitReceive_IT(handle, (uint8_t*)tx, (uint8_t*)rx, words);
break;
case SPI_TRANSFER_TYPE_TX:
// TODO: we do not use `HAL_SPI_Transmit_IT`, since it has some unknown bug
// and makes the HAL keep some state and then that fails successive transfers
// rc = HAL_SPI_Transmit_IT(handle, (uint8_t*)tx, words);
rc = HAL_SPI_TransmitReceive_IT(handle, (uint8_t*)tx, (uint8_t*)&sink, 1);
length = is16bit ? 2 : 1;
break;
case SPI_TRANSFER_TYPE_RX:
// the receive function also "transmits" the receive buffer so in order
// to guarantee that 0xff is on the line, we explicitly memset it here
memset(rx, SPI_FILL_WORD, length);
rc = HAL_SPI_Receive_IT(handle, (uint8_t*)rx, words);
break;
default:
length = 0;
}
if (rc) {
DEBUG_PRINTF("SPI%u: RC=%u\n", obj->spi.module+1, rc);
length = 0;
}
return length;
}
Spi::Status Spi::txrx(const uint8_t* txData, uint8_t* rxData, uint16_t n, TxRxCallback cb, void* args) {
if (!txData || !rxData) return ILLEGAL;
if (n < 1) return OK; // nothing to do
if (cb) { // Use async spi transfer
_txrxCallback = cb;
_txrxArgs = args;
return (Spi::Status) HAL_SPI_TransmitReceive_IT(&_spi, const_cast<uint8_t*>(txData), rxData, n);
} else { // Use blocking spi transfer
return (Spi::Status) HAL_SPI_TransmitReceive(&_spi, const_cast<uint8_t*>(txData), rxData, n, DEFAULT_TIMEOUT);
}
}
void flexsea_start_receiving_from_master(void)
{
// start receive over SPI
if (HAL_SPI_GetState(&spi4_handle) == HAL_SPI_STATE_READY)
{
if(HAL_SPI_TransmitReceive_IT(&spi4_handle, (uint8_t *)aTxBuffer, (uint8_t *)aRxBuffer, COMM_STR_BUF_LEN) != HAL_OK)
{
// Transfer error in transmission process
flexsea_error(SE_RECEIVE_FROM_MASTER);
}
}
}
/// @returns the number of bytes transferred, or `0` if nothing transferred
static int spi_master_start_asynch_transfer(spi_t *obj, transfer_type_t transfer_type, const void *tx, void *rx, size_t length)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
bool is16bit = (handle->Init.DataSize == SPI_DATASIZE_16BIT);
// the HAL expects number of transfers instead of number of bytes
// so for 16 bit transfer width the count needs to be halved
size_t words;
DEBUG_PRINTF("SPI inst=0x%8X Start: %u, %u\r\n", (int)handle->Instance, transfer_type, length);
obj->spi.transfer_type = transfer_type;
if (is16bit) {
words = length / 2;
} else {
words = length;
}
// enable the interrupt
IRQn_Type irq_n = spiobj->spiIRQ;
NVIC_DisableIRQ(irq_n);
NVIC_ClearPendingIRQ(irq_n);
NVIC_SetPriority(irq_n, 1);
NVIC_EnableIRQ(irq_n);
// enable the right hal transfer
int rc = 0;
switch(transfer_type) {
case SPI_TRANSFER_TYPE_TXRX:
rc = HAL_SPI_TransmitReceive_IT(handle, (uint8_t*)tx, (uint8_t*)rx, words);
break;
case SPI_TRANSFER_TYPE_TX:
rc = HAL_SPI_Transmit_IT(handle, (uint8_t*)tx, words);
break;
case SPI_TRANSFER_TYPE_RX:
// the receive function also "transmits" the receive buffer so in order
// to guarantee that 0xff is on the line, we explicitly memset it here
memset(rx, SPI_FILL_WORD, length);
rc = HAL_SPI_Receive_IT(handle, (uint8_t*)rx, words);
break;
default:
length = 0;
}
if (rc) {
DEBUG_PRINTF("SPI: RC=%u\n", rc);
length = 0;
}
return length;
}
/**
* @brief Slave synchronization with Master
* @param None
* @retval None
*/
static void Slave_Synchro(void)
{
uint8_t txackbyte = SPI_SLAVE_SYNBYTE, rxackbyte = 0x00;
do
{
if (HAL_SPI_TransmitReceive_IT(&SpiHandle, (uint8_t *)&txackbyte, (uint8_t *)&rxackbyte, 1) != HAL_OK)
{
Error_Handler();
}
while (HAL_SPI_GetState(&SpiHandle) != HAL_SPI_STATE_READY)
{}
}
while (rxackbyte != SPI_MASTER_SYNBYTE);
}
/**
* @brief EXTI line detection callbacks
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if(GPIO_Pin == GPIO_PIN_4)
{
// transfer over the buffer
// Todo: transfer over the number of bytes that have been received instead of COMM_STR_BUF_LEN every time
for (unsigned char i = 0; i < COMM_STR_BUF_LEN; i++)
{
update_rx_buf_byte_spi(aRxBuffer[i]);
//ToDo update to array
}
// clear the SPI buffer
for (unsigned char i = 0; i < COMM_STR_BUF_LEN; i++)
{
aRxBuffer[i] = 0;
}
// reset the SPI pointer and counter
spi4_handle.RxXferCount = COMM_STR_BUF_LEN;
spi4_handle.pRxBuffPtr = aRxBuffer;
spi4_handle.pTxBuffPtr = aTxBuffer; //Test
//Data for the next cycle:
//comm_str was already generated, now we place it in the buffer:
comm_str_to_txbuffer();
if(HAL_SPI_TransmitReceive_IT(&spi4_handle, (uint8_t *)aTxBuffer, (uint8_t *)aRxBuffer, COMM_STR_BUF_LEN) != HAL_OK)
{
// Transfer error in transmission process
flexsea_error(SE_SEND_SERIAL_MASTER);
}
// handle the new data however this device wants to
SPI_new_data_Callback();
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- 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: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED2, LED4 and LED3 */
BSP_LED_Init(LED2);
BSP_LED_Init(LED4);
BSP_LED_Init(LED3);
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
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
/* Configure User push-button 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_SET)
{
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" */
if(HAL_SPI_TransmitReceive_IT(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you must wait the callback call
to get the transfer complete confirmation or an error detection.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (wTransferState == TRANSFER_WAIT)
{
}
switch(wTransferState)
{
case TRANSFER_COMPLETE :
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
break;
default :
Error_Handler();
break;
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx 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.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED3, LED4 and LED5 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
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_DISABLE;
SpiHandle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
SpiHandle.Init.CRCLength = SPI_CRC_LENGTH_8BIT;
#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
/* Configure Tamper push button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
/* Wait for Tamper Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_USER) != GPIO_PIN_SET)
{
BSP_LED_Toggle(LED3);
HAL_Delay(40);
}
BSP_LED_Off(LED3);
#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" */
if(HAL_SPI_TransmitReceive_IT(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_SPI_GetState(&SpiHandle) != HAL_SPI_STATE_READY)
{
}
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED3, LED4, LED5 and LED6 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
/* Configure the system clock to 84 MHz */
SystemClock_Config();
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
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_DISABLE;
#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
/* Configure Tamper push button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for Tamper Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 1)
{
BSP_LED_Toggle(LED3);
HAL_Delay(40);
}
BSP_LED_Off(LED3);
#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" */
if(HAL_SPI_TransmitReceive_IT(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_SPI_GetState(&SpiHandle) != HAL_SPI_STATE_READY)
{
}
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Transfer error in transmission process */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
#ifdef MASTER_BOARD
GPIO_InitTypeDef GPIO_InitStruct;
#endif
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch, Flash preread and Buffer caches
- 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.
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 2 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
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
/* Configure PA.12 (Arduino D2) button */
GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
/* Enable GPIOA clock */
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Wait Until PA.12 (Arduino D2) is connected to GND */
while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == GPIO_PIN_SET)
{
BSP_LED_Toggle(LED3);
HAL_Delay(100);
}
BSP_LED_Off(LED3);
#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" */
if(HAL_SPI_TransmitReceive_IT(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you must wait the callback call
to get the transfer complete confirmation or an error detection.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (wTransferState == TRANSFER_WAIT)
{
}
switch(wTransferState)
{
case TRANSFER_COMPLETE :
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
break;
default :
Error_Handler();
break;
}
/* Infinite loop */
while (1)
{
}
}
