STM32F303VC SPI Communication: SPI2 (Slave) SPI1 (Master)

[AT.8]

Is it possible to send data from SPI2 to SPI1 ? SPI2 being the slave. In SPI, Master initiates the communication, correct ?

This is how i do it:

When the Slave SPI2 receives a byte from SPI1, i set a flag, and i check for this flag in main context.

If this flag is set, i send a dummy byte from Master and wait for the interrupt in SPI1 IRQ Handler (configured for RXNE interrupt).

if( Slave_Rx_Flag == 1 ){
 
     SPI_Master_Tx_Data(0x00); //Dummy byte
     SPI_Slave_Tx_Data(0x5D);
     Delay_us(50);
      Slave_Rx_Flag = 0;
}

My transmit function for slave looks so:

while (!LL_SPI_IsActiveFlag_TXE(SPI2))
     ; // wait while not empty
LL_SPI_TransmitData8(SPI2, byte); // NO EFFECT ??

void SPI1_IRQHandler( void ) {
 
	Master_Rx_Flag =1;
	uint8_t spi2_data ;
	spi2_data = SPI1->DR;
}

I am reading 0x00 when i expect 0x5D.

SPI2 (Slave) is initialized this way:

 /** MASTER      SLAVE
     * **********   **********
     * PA4 - NSS    PB12 - NSS
     * PA5 - SCK    PB13 - SCK
     * PA6 - MISO   PB14 - MISO
     * PA7 - MOSI   PB15 - MOSI
     */
	if (RESET == __HAL_RCC_GPIOB_IS_CLK_ENABLED())
	{
	     __HAL_RCC_GPIOB_CLK_ENABLE();
	}
 
	LL_GPIO_InitTypeDef gpioSPIInitStr;
 
	gpioSPIInitStr.Alternate = LL_GPIO_AF_5;
	gpioSPIInitStr.Pin       =  LL_GPIO_PIN_13  | LL_GPIO_PIN_15;
	gpioSPIInitStr.Mode      = LL_GPIO_MODE_ALTERNATE;
	gpioSPIInitStr.Speed     = LL_GPIO_SPEED_FREQ_HIGH;
	gpioSPIInitStr.Pull      = LL_GPIO_PULL_UP; 
	gpioSPIInitStr.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
 
	LL_GPIO_Init(GPIOB, &gpioSPIInitStr);
 
	gpioSPIInitStr.Alternate = LL_GPIO_AF_5;
	gpioSPIInitStr.Pin       =  LL_GPIO_PIN_14;
	gpioSPIInitStr.Mode      = LL_GPIO_MODE_INPUT;
	gpioSPIInitStr.Speed     = LL_GPIO_SPEED_FREQ_HIGH;
	gpioSPIInitStr.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
 
	LL_GPIO_Init(GPIOB, &gpioSPIInitStr);
 
	gpioSPIInitStr.Alternate = LL_GPIO_AF_5;
	gpioSPIInitStr.Pin       =  LL_GPIO_PIN_12; //NSS
	gpioSPIInitStr.Mode      = LL_GPIO_MODE_INPUT;
	gpioSPIInitStr.Pull      = LL_GPIO_PULL_NO;	                                           
	gpioSPIInitStr.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
 
	LL_GPIO_Init(GPIOB, &gpioSPIInitStr);
 
 
 __HAL_RCC_SPI2_CLK_ENABLE();
 
    LL_SPI_InitTypeDef SPI_SlaveInitStruct;
    SPI_SlaveInitStruct.BaudRate          = LL_SPI_BAUDRATEPRESCALER_DIV4;
    SPI_SlaveInitStruct.ClockPhase        = LL_SPI_PHASE_2EDGE;
    SPI_SlaveInitStruct.ClockPolarity     = LL_SPI_POLARITY_HIGH;
    SPI_SlaveInitStruct.CRCCalculation    = LL_SPI_CRCCALCULATION_DISABLE;
    SPI_SlaveInitStruct.DataWidth         = LL_SPI_DATAWIDTH_8BIT;
    SPI_SlaveInitStruct.TransferDirection = LL_SPI_FULL_DUPLEX;
    SPI_SlaveInitStruct.BitOrder          = LL_SPI_MSB_FIRST;
    SPI_SlaveInitStruct.Mode              = LL_SPI_MODE_SLAVE;
    SPI_SlaveInitStruct.NSS               = LL_SPI_NSS_HARD_OUTPUT; 
 
    LL_SPI_Init(SPI2, &SPI_SlaveInitStruct);
    LL_SPI_Enable(SPI2);
 
    LL_I2S_EnableIT_RXNE(SPI2);
    HAL_NVIC_SetPriority(SPI2_IRQn, 0 , 0 );
    HAL_NVIC_EnableIRQ(SPI2_IRQn);

[KnarfB]

It is possible, but I don't know the API functions you are using for TX. The slave must be prepared to receive/transmit ahead, because it all happens at the same time. Can be done with polling:

for(;;)
  {
	  while( !(SPI2->SR & SPI_SR_TXE) ); // poll for TX empty
	  SPI2->DR = tx[ti++];
 
	  while( !(SPI3->SR & SPI_SR_RXNE) ); // poll for RX non-empty
	  rx[rxi++] = SPI3->DR;
  }

but this is kinda cheating because we assume exactly when to read. In a more realistic scenario you might use interrupt or DMA for the receiver.

hth

KnarfB

[AT.8]

My Transmit function from Slave to Master looks so:

while (!LL_SPI_IsActiveFlag_TXE(SPI2))
     ; // wait while not empty
LL_SPI_TransmitData8(SPI2, byte); // NO EFFECT ??

My Receive interrupt handler looks so:

void SPI1_IRQHandler( void ) {
	Master_Rx_Flag =1;
	uint8_t spi2_data ;
	spi2_data = SPI1->DR;
}

[TDK]

> Is it possible to send data from SPI2 to SPI1 ? SPI2 being the slave. In SPI, Master initiates the communication, correct ?

Yes. Correct.

> SPI_Master_Tx_Data(0x00); //Dummy byte

> SPI_Slave_Tx_Data(0x5D);

The slave needs to be ready to send before the maser starts the clock. Your order is backwards.

[S.Ma]

Please try developping using 2 boards. Loop back on the same chip to have only one debug plateform will cause additional debug and recode effort when dissociating master slave to 2 devices. Overall time spent will be lesser.