stm32 SPI NSS Signal Anfänger

[Seb (Gast)]

Hallo, ich bin totaler Anfänger in Dingen SPI. Ich messe momentan direkt 
an den Ausgangspins des STM32F107VC und habe den unten stehenden Code am 
laufen. Die Clocks und die Daten werden soweit ich das sehen kann 
übermittelt, auch wenn das Signal ziemlich wackelig aussieht. Der NSS 
allerdings zuckt sich bis auf die Störungen die durch den Clock rein 
kommen überhaupt nicht. Ich hatte das jetzt so verstanden dass der Pegel 
nur bei Datenübermittlung auf Low geht und sonst immer ein High 
aufweist?! Vielleicht kann mir einer von euch sagen was ich falsch 
mache, bzw. woran ich nicht gedacht habe. Muss eventuell noch ein Pullup 
beschaltet werden?
Der Code sollte lauffähig sein, sofern jetzt beim kopieren nichts 
verloren gegangen ist.

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"



/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/
#define BufferSize       32

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
SPI_InitTypeDef  SPI_InitStructure;
DMA_InitTypeDef  DMA_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;


/* Private function prototypes -----------------------------------------------*/
void RCC_Configuration(void);
void GPIO_Configuration(void);

/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{


  /* System clocks configuration ---------------------------------------------*/
  RCC_Configuration();

  /* GPIO configuration ------------------------------------------------------*/
  GPIO_Configuration();



// SPI_MASTER configuration ------------------------------------------------------
  SPI_InitStructure.SPI_Direction              = SPI_Direction_1Line_Tx;
  SPI_InitStructure.SPI_Mode                   = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize               = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL                   = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA                   = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS                     = SPI_NSS_Soft;    // NSS Software Controlled
  SPI_InitStructure.SPI_BaudRatePrescaler      = SPI_BaudRatePrescaler_4;
  SPI_InitStructure.SPI_FirstBit                 = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial       = 7;
  SPI_Init(SPI1, &SPI_InitStructure);

  // Take NSS line high by default
  GPIO_SetBits(GPIOA,  GPIO_Pin_4);


  /* Enable SPI_MASTER NSS output for master mode */
  SPI_SSOutputCmd(SPI1, ENABLE);



  /* Enable SPI_MASTER */
  SPI_Cmd(SPI1, ENABLE);


  while (1)
  {


    GPIO_ResetBits(GPIOA, GPIO_Pin_4);

    SPI_I2S_SendData(SPI1, 150);

    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
    {}

    GPIO_SetBits(GPIOA, GPIO_Pin_4);


  }


}


void RCC_Configuration(void)
{
  /* PCLK2 = HCLK/2 */
  RCC_PCLK2Config(RCC_HCLK_Div2);

  /* Enable peripheral clocks --------------------------------------------------*/


  /* Enable SPI_MASTER clock and GPIO clock for SPI_MASTER and SPI_SLAVE */

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 ,ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);

}

void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;



  /* Configure SPI_MASTER pins: NSS, SCK and MOSI */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7  | GPIO_Pin_5 | GPIO_Pin_4  ;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

[(prx) A. K. (prx)]

NSS ist bei den STM32 etwas verwirrend. Es gibt letztlich keinen 
vollautomatischen Hardware-Support für die SS-Leitung(en) eines Masters, 
d.h. die Aktivierung vor und Deaktivierung nach Ende des Transfers ist 
Sache der Software. Die dann natürlich auch dran denken muss, diese 
Leitung erst zu deaktivieren, wenn alle Bits wirklich raus sind.

[Seb (Gast)]

Ich war der Meinung genau das zu machen mit der Schleife:

  while (1)
  {


    GPIO_ResetBits(GPIOA, GPIO_Pin_4);

    SPI_I2S_SendData(SPI1, 150);

    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
    {}

    GPIO_SetBits(GPIOA, GPIO_Pin_4);


  }

[Matthias K. (matthiask)]

NSS musst Du als normalen Output-Pin definieren nicht als AF

[(prx) A. K. (prx)]

Ich habe die Doku der Library nicht vorliegen (die sowieso nicht mein 
Ding ist), war aber über deinen Kommentar gestolpert:

  /* Enable SPI_MASTER NSS output for master mode */
  SPI_SSOutputCmd(SPI1, ENABLE);

[Seb (Gast)]

Achso ich hatte das ganze auch schon mit einer Warteschleife zwischen am 
Ende probiert. Sowas wie:

while(warte < 100)
{
   warte++;
}
warte = 0;

[Seb (Gast)]

Ah ok, ich hatte das in allen Beispielen als AF gesehen. Ich versuchs 
mal als normalen OP.

[(prx) A. K. (prx)]

Seb schrieb:

> Achso ich hatte das ganze auch schon mit einer Warteschleife zwischen am
> Ende probiert. Sowas wie:

Diese Schleife wartet ohnehin nicht.

[Seb (Gast)]

>Ich habe die Doku der Library nicht vorliegen (die sowieso nicht mein
>Ding ist), war aber über deinen Kommentar gestolpert:

Ah ja, jetzt weiß ich was du meinst AK. das ganze rührt daher, dass ich 
zuerst die Hardwareaktivierung drinn hatte, das hat nicht funktioniert, 
also bin ich auf Software umgestiegen. Den müsste ich noch mal raus 
nehmen. Danke.

[Seb (Gast)]

Also als "GPIO_Mode_Out_PP" sieht es so aus als würde er endlich das tun 
was ich möchte, ich fines es nur verwirrend dass sogar die STM Beispiele 
bringen wie:

  /* Configure SPI_MASTER NSS pin */
  GPIO_InitStructure.GPIO_Pin = SPI_MASTER_PIN_NSS;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(SPI_MASTER_GPIO_NSS, &GPIO_InitStructure);

[Matthias K. (matthiask)]

Seb schrieb:
> Also als "GPIO_Mode_Out_PP" sieht es so aus als würde er endlich das tun
> was ich möchte, ich fines es nur verwirrend dass sogar die STM Beispiele
> bringen wie:
>
>   /* Configure SPI_MASTER NSS pin */
>   GPIO_InitStructure.GPIO_Pin = SPI_MASTER_PIN_NSS;
>   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
>   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
>   GPIO_Init(SPI_MASTER_GPIO_NSS, &GPIO_InitStructure);

Wenn Du "SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;"
definierst, weiß der Pin, welchen Du für NSS verwenden willst, nichts 
von seiner SPI-Funktion. Ist ein ganz normaler Output. Das Beispiel, 
welches Du hier zitierst, ist nicht für NSS Soft!

[Seb (Gast)]

Ja, kann sein dass ich da was durcheinander gebracht habe, ich habe 
leider immer noch nicht herausgefunden wie man das ganze in der Hardware 
Variante realisieren soll und werde wohl bei der Software bleiben. Das 
Beispiel hatte ich ursprünglich aus diesem STM Example (DMA). Ich hatte 
mich nicht sehr um die DMA gekümmert und nur das nötigste behalten, mag 
sein dass es im Zusammenspiel mit dieser Sinn ergibt:

/**
  ******************************************************************************
  * @file    SPI/DMA/main.c 
  * @author  MCD Application Team
  * @version V3.5.0
  * @date    08-April-2011
  * @brief   Main program body
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  ******************************************************************************
  */ 

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include "platform_config.h"


/** @addtogroup STM32F10x_StdPeriph_Examples
  * @{
  */

/** @addtogroup SPI_DMA
  * @{
  */ 

/* Private typedef -----------------------------------------------------------*/
typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;

/* Private define ------------------------------------------------------------*/
#define BufferSize       32

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
SPI_InitTypeDef  SPI_InitStructure;
DMA_InitTypeDef  DMA_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;

uint8_t SPI_MASTER_Buffer_Tx[BufferSize] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                                            0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
                                            0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
                                            0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
                                            0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
                                            0x1F, 0x20};
uint8_t SPI_SLAVE_Buffer_Rx[BufferSize];
__IO uint8_t TxIdx = 0;
volatile TestStatus TransferStatus = FAILED;


/* Private function prototypes -----------------------------------------------*/
void RCC_Configuration(void);
void GPIO_Configuration(void);
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength);

/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{
  /*!< At this stage the microcontroller clock setting is already configured, 
       this is done through SystemInit() function which is called from startup
       file (startup_stm32f10x_xx.s) before to branch to application main.
       To reconfigure the default setting of SystemInit() function, refer to
       system_stm32f10x.c file
     */     
       
  /* System clocks configuration ---------------------------------------------*/
  RCC_Configuration();

  /* GPIO configuration ------------------------------------------------------*/
  GPIO_Configuration();

  /* SPI_SLAVE_Rx_DMA_Channel configuration ---------------------------------------------*/
  DMA_DeInit(SPI_SLAVE_Rx_DMA_Channel);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_SLAVE_DR_Base;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_SLAVE_Buffer_Rx;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = BufferSize;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(SPI_SLAVE_Rx_DMA_Channel, &DMA_InitStructure);

  /* SPI_MASTER configuration ------------------------------------------------------*/
  SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(SPI_MASTER, &SPI_InitStructure);

  /* SPI_SLAVE configuration ------------------------------------------------------*/
  SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
  SPI_Init(SPI_SLAVE, &SPI_InitStructure);

  /* Enable SPI_MASTER NSS output for master mode */
  SPI_SSOutputCmd(SPI_MASTER, ENABLE);

  /* Enable SPI_SLAVE Rx request */
  SPI_I2S_DMACmd(SPI_SLAVE, SPI_I2S_DMAReq_Rx, ENABLE);

  /* Enable SPI_SLAVE */
  SPI_Cmd(SPI_SLAVE, ENABLE);
  /* Enable SPI_MASTER */
  SPI_Cmd(SPI_MASTER, ENABLE);

  /* Enable DMA1 Channel4 */
  DMA_Cmd(SPI_SLAVE_Rx_DMA_Channel, ENABLE);

  /* Transfer procedure */
  while (TxIdx < BufferSize)
  {
    /* Wait for SPI_MASTER Tx buffer empty */
    while (SPI_I2S_GetFlagStatus(SPI_MASTER, SPI_I2S_FLAG_TXE) == RESET);
    /* Send SPI_MASTER data */
    SPI_I2S_SendData(SPI_MASTER, SPI_MASTER_Buffer_Tx[TxIdx++]);
  }

  /* Wait for DMA1 channel4 transfer complete */
  while (!DMA_GetFlagStatus(SPI_SLAVE_Rx_DMA_FLAG));

  /* Check the correctness of written data */
  TransferStatus = Buffercmp(SPI_SLAVE_Buffer_Rx, SPI_MASTER_Buffer_Tx, BufferSize);
  /* TransferStatus = PASSED, if the transmitted and received data
     are equal */
  /* TransferStatus = FAILED, if the transmitted and received data
     are different */

  while (1)
  {}
}

/**
  * @brief  Configures the different system clocks.
  * @param  None
  * @retval None
  */
void RCC_Configuration(void)
{
  /* PCLK2 = HCLK/2 */
  RCC_PCLK2Config(RCC_HCLK_Div2); 

  /* Enable peripheral clocks --------------------------------------------------*/
  /* Enable SPI_SLAVE DMA clock */
  RCC_AHBPeriphClockCmd(SPI_SLAVE_DMA_CLK, ENABLE);

#ifdef USE_STM3210C_EVAL
  /* Enable GPIO clock for SPI_MASTER and SPI_SLAVE */
  RCC_APB2PeriphClockCmd(SPI_MASTER_GPIO_CLK | SPI_SLAVE_GPIO_CLK |
                         RCC_APB2Periph_AFIO, ENABLE);

  /* Enable SPI_MASTER Periph clock */
  RCC_APB1PeriphClockCmd(SPI_MASTER_CLK, ENABLE);
                           
#else
  /* Enable SPI_MASTER clock and GPIO clock for SPI_MASTER and SPI_SLAVE */
  RCC_APB2PeriphClockCmd(SPI_MASTER_GPIO_CLK | SPI_SLAVE_GPIO_CLK |
                         SPI_MASTER_CLK, ENABLE);
#endif
  /* Enable SPI_SLAVE Periph clock */
  RCC_APB1PeriphClockCmd(SPI_SLAVE_CLK, ENABLE);
}

/**
  * @brief  Configures the different GPIO ports.
  * @param  None
  * @retval None
  */
void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

#ifdef USE_STM3210C_EVAL
  /* Enable SPI3 Pins Software Remapping */
  GPIO_PinRemapConfig(GPIO_Remap_SPI3, ENABLE);

  /* Configure SPI_MASTER pins: SCK and MOSI */
  GPIO_InitStructure.GPIO_Pin = SPI_MASTER_PIN_SCK | SPI_MASTER_PIN_MOSI;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(SPI_MASTER_GPIO, &GPIO_InitStructure);

  /* Configure SPI_MASTER NSS pin */
  GPIO_InitStructure.GPIO_Pin = SPI_MASTER_PIN_NSS;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(SPI_MASTER_GPIO_NSS, &GPIO_InitStructure);

#else
  /* Configure SPI_MASTER pins: NSS, SCK and MOSI */
  GPIO_InitStructure.GPIO_Pin = SPI_MASTER_PIN_NSS | SPI_MASTER_PIN_SCK | SPI_MASTER_PIN_MOSI;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(SPI_MASTER_GPIO, &GPIO_InitStructure);
#endif

  /* Configure SPI_SLAVE pins: NSS, SCK and MISO*/
  GPIO_InitStructure.GPIO_Pin = SPI_SLAVE_PIN_NSS | SPI_SLAVE_PIN_SCK;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(SPI_SLAVE_GPIO, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin =  SPI_SLAVE_PIN_MISO;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(SPI_SLAVE_GPIO, &GPIO_InitStructure);
  
}

/**
  * @brief  Compares two buffers.
  * @param  pBuffer1, pBuffer2: buffers to be compared.
  * @param  BufferLength: buffer's length
  * @retval PASSED: pBuffer1 identical to pBuffer2
  *         FAILED: pBuffer1 differs from pBuffer2
  */
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
{
  while (BufferLength--)
  {
    if (*pBuffer1 != *pBuffer2)
    {
      return FAILED;
    }

    pBuffer1++;
    pBuffer2++;
  }

  return PASSED;
}

#ifdef  USE_FULL_ASSERT

/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {}
}

#endif

/**
  * @}
  */ 

/**
  * @}
  */ 

/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

[(prx) A. K. (prx)]

Seb schrieb:

> leider immer noch nicht herausgefunden wie man das ganze in der Hardware
> Variante realisieren soll

Soweit mir bekannt überhaupt nicht. Darüber sind schon viele gestolpert 
und haben beispielsweise ihr Leid im Forum von ST beklagt (hier aber 
auch schon).

Besonders perfide ist das bei DMA, weil man bei nur sendendem Transfer 
keinen Interrupt für das Ende der Datenübertragung hat, der sich im 
Timing für die Deaktivierung eignen würde. Der Abschluss-Interrupt vom 
Transmit-DMA kommt zu früh. Man kann gezwungen sein, die Daten völlig 
unnötig wieder per DMA rückzulesen, um dessen Abschluss-Interrupt dafür 
einspannen zu können, wenn man keine Timer oder Zeitverzögerungen 
einsetzen will.

Beitrag "STM32 SPI2 mit DMA Problem (DMA TC-Flag kommt zu früh)"
Beitrag "STM32 SPI - Wozu dieses NSS?"

[Matthias K. (matthiask)]

Seb schrieb:
> a, kann sein dass ich da was durcheinander gebracht habe, ich habe
> leider immer noch nicht herausgefunden wie man das ganze in der Hardware
> Variante realisieren soll und werde wohl bei der Software bleiben.

Lass es bei der Software-Variante. Damit hast Du das Timing am CS Pin 
selber unter Kontrolle. Der Aufwand für den Pin setzen/rücksetzen ist 
doch vertretbar.