AnsweredAssumed Answered

stm32f0 SPI1 Unidirectional receive-only procedure

Question asked by Md Mubdiul Hasan on Oct 19, 2016
Latest reply on Oct 20, 2016 by Md Mubdiul Hasan

Dear All,
According to Reference RM0008 (DocID13902 Rev 16), I need to make a SPI for  MAX31855 as it works on unidirectional full duplex mode.
Kindly check my code and help me to understand my mistake.



        // GPIO setting 
        RCC_APB2PeriphClockCmd( SPI_CLK, ENABLE); // Enable the clock for SPI1


        // Configure GPIO for SPI slave: SCK, MOSI, SS as inputs
        GPIO_InitStructure.GPIO_Pin = SPI1_MOSI_PIN |TEMP__CS_Pin| TEMP_SCK_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  // Configure SCK and MOSI pins as Input Floating 
        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);


        // Configure GPIO for SPI slave: MISO as AF output
        GPIO_InitStructure.GPIO_Pin = TEMP_SO_Pin;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
        
        
        static void MX_SPI1_Init(void)
                {


                  hspi1.Instance = SPI1;
                  hspi1.Init.Mode = SPI_MODE_MASTER;
                  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
                  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
                  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
                  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
                  hspi1.Init.NSS = SPI_NSS_SOFT;
                  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
                  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
                  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
                  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
                  hspi1.Init.CRCPolynomial = 10;
                  hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
                  hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
                  if (HAL_SPI_Init(&hspi1) != HAL_OK)
                  {
                    Error_Handler();
                  }
                  
                  /* (1) Master selection, BR: Fpclk/256 (due to C27 on the board, SPI_CLK is
                                    set to the minimum) CPOL and CPHA at zero (rising first edge) */
                                    /* (2) Slave select output enabled, RXNE IT, 8-bit Rx fifo */
                                    /* (3) Enable SPI1 */
                                    SPI1->CR1 = SPI_CR1_MSTR | SPI_CR1_BR; /* (1) */
                                    SPI1->CR2 = SPI_CR2_SSOE | SPI_CR2_RXNEIE | SPI_CR2_FRXTH
                                    | SPI_CR2_DS_2 | SPI_CR2_DS_1 | SPI_CR2_DS_0; /* (2) */
                                    SPI1->CR1 |= SPI_CR1_SPE; /* (3) */
                                    




                  if((SPI1_CR1 & (SPI_CR1_BIDIMODE | SPI_CR1_BIDIOE)) == SPI_CR1_BIDIMODE) {
                                 /* force to transmit mode. dont forget to 
                                  * set SPI_CR2_TXDMAEN and disable TX-DMA-CHANNEL,
                                  * to prevent sending garbage
                                  */
                                 SPI1_CR1 |= SPI_CR1_BIDIOE;
                             } else {
                                 /* Wait to receive last data */
                                 while(SPI1_SR & SPI_SR_RXNE);


                                 /* Wait to transmit last data */
                                 while(!(SPI1_SR & SPI_SR_TXE));


                                 /* Wait until not busy */
                                 while(SPI1_SR & SPI_SR_BSY);
                             }
                  
                  //Setup SPI DMA for TX


                    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &(SPI1->DR); 


                    DMA_InitStructure.DMA_Channel = DMA1_Channel_3; 


                    DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; 


                    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; 


                    DMA_InitStructure.DMA_Memory0BaseAddr = 0;      //Setting only needed to suppress in case assert macro is active


                    DMA_InitStructure.DMA_BufferSize = 1;           //Setting only needed to suppress in case assert macro is active


                    DMA_Init(DMA2_Stream3, &DMA_InitStructure);


                    DMA_ITConfig(DMA1_Stream3, DMA_IT_TC, ENABLE);
      
                    // Rx Channel
                    
                       DMA_StructInit(&SPI1RX_DMA_InitStructure);
                      _DMA_InitStructure.DMA_Channel = DMA_Channel_3;
                       DMA_InitStructure.DMA_PeripheralBaseAddr =(uint32_t) &(SPI1->DR); 
                       DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;; 
                       SPI1RX_DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
                       DMA_Init(DMA1_Stream2, &SPI1RX_DMA_InitStructure);
                       // Enable DMA Stream Transfer Complete interrupt 
                       DMA_ITConfig(DMA1_Stream3, DMA_IT_TC, ENABLE);
                       
                       // Enable SPI1
                          SPI_Cmd(SPI1, ENABLE);
                    
                          //Setup interrupt for completed DMA transfers


                    NVIC_InitTypeDef NVIC_InitStructure;


                    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn;


                    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;


                    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;


                    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;


                    NVIC_Init(&NVIC_InitStructure); 


                    SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);    //Enable DMA TX request
                    SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);    //Enable DMA RX request
                  }   
   


  void DMA_beginWrite()


  {


    DMA1_Stream3->NDTR = (uint32_t) sizeof(_pixelData);


    DMA1_Stream3->M0AR = (uint32_t) _pixelDataPtr;


    DMA_Cmd (DMA1_Stream3, ENABLE);


  }






  void SPI1_IRQHandler(void)
   {


     /* SPI in Slave Receiver mode--------------------------------------- */
     if (SPI_I2S_GetITStatus(SPI1, SPI_I2S_IT_RXNE) == SET)
     {
                   /*------- Master --> Slave */
       if (CmdStatus == 0x00)


      {


             CmdReceived = SPI1_RXDR8;
                     Rx_Idx=0;
                     Tx_Idx=0;


                     switch(CmdReceived){
                         case 0x01:
                               receiveSPI=0x01;
                               CmdStatus = 0x01;
                               StartSend=0x00;
                               Cpt_Spi=0;
                             break;


                             case 0x81 :


                                     SendSPI=0x01;
                                     CmdStatus = 0x01;
                                     Spi_Case=0x01;
                                     if (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != RESET)
                       SPI1_RXDR8=SPI_Tx1[Tx_Idx++];   // prepare the first byte to be send when the clock is received
                             break;


                             case 0x84:


                                     SendSPI=0x01;
                                     Spi_Case=0x02;
                                     CmdStatus = 0x01;
                                     if (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != RESET)
                        SPI1_RXDR8=SPI_Tx2[Tx_Idx++];  //  // prepare the first byte to be send when the clock is received
                               }
                             break;


                             default:
                                SendSPI=0x00;
                    Spi_Case=0x00;
                    CmdStatus = 0x00;
                    receiveSPI=0x00;
                             break;


                           }// end of switch
             }// end of cmdStatus =0x00
             else
         {


               if(receiveSPI)  // in this case the slave receives data from the master
               {
              SPI_Rx[Rx_Idx++] = SPI1_RXDR8;  // the array sent by the Master in the receive mode

Outcomes