STM32 SPI Init

[Moritz M. (Gast)]

Hallo,

ich versuche grade die SPI Schnittstelle von dem STM32F407 zum laufen zu 
bringen. Eig. möchte ich dann eine SD Karte ansteuern. Nur leider kommt 
noch nicht mal ein Takt Signal heraus. Vielleicht könnt ihr euch mal den 
Code ansehen.

#include "stm32f4xx.h"

void SDCard_InitLowLevel(void);
void SDCard_Init(void);

uint16_t response;

int main(void)
{
  SystemInit(); // 8MHz extern -> PLL -> 168MHz

  response = 0x00;

  SDCard_InitLowLevel();

    while(!response)
    {
      SDCard_Init();
    }

    response = response; // Breakpoint

    //while(1);

    return 1;
}

void SDCard_InitLowLevel(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  SPI_InitTypeDef SPI_InitStruct;

  /*
   * Clocks
   */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

  /*
  * DeInit
  */
  SPI_I2S_DeInit(SPI1);

  /*
   * Alternate Function
   */
  GPIO_PinAFConfig(GPIOA, GPIO_Pin_5, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOA, GPIO_Pin_6, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOA, GPIO_Pin_7, GPIO_AF_SPI1);

  /*
   * GPIO Init
   * PA5 (SCK) to SD card pin 5 (SCLK)   PP NOPULL
   * PA6 (MISO) to SD card pin 7 (DO)  PP UP
   * PA7 (MOSI) to SD card pin 2 (DI)  PP UP
   * PA8 (NSS) to SD card pin 1 (CS)  PP UP
   */
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_5;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_SET);

  /*
   * SPI1 Init
   */
  SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStruct.SPI_CRCPolynomial = 0;
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
  SPI_Init(SPI1, &SPI_InitStruct);

  SPI_Cmd(SPI1, ENABLE);
}

void SDCard_Init(void)
{
  uint16_t CMD0[] = {0x40, 0x00, 0x00, 0x00, 0x00, 0x95};

  for(uint16_t i = 0; i < 100; i++); // min. 74 Takte an SCK warten

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);

  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_RESET);
  for(uint8_t i = 0; i < 6; i++)
  {
    SPI_I2S_SendData(SPI1, CMD0[i]);
  }
  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_SET);

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  response = SPI_I2S_ReceiveData(SPI1);
}

Moritz

[Moritz M. (Gast)]

Hallo,

weiß niemand was genaues darüber?

Moritz

[AVerr (Gast)]

Ich glaube du musst noch die AFIO-Geschichte mit einem Takt versorgen 
...

[holger (Gast)]

>  for(uint16_t i = 0; i < 100; i++); // min. 74 Takte an SCK warten

Das wird sicher keine 74 SCK warten. Es kommt kein SCK
ohne das man Bytes schreibt. Die Schleife optimiert dir
sowieso der Compiler weg weil sie nichts tut.

>    SPI_I2S_SendData(SPI1, CMD0[i]);

Schau dir mal an was die Routine macht. Die prügelt Daten
ins Dataregister, mehr nicht. Du schreibst also sechs mal
schnell hintereinander Daten ohne zu warten ob die schon
gesendet wurden.

[Moritz M. (Gast)]

Hallo,

vielen Dank für die Antwort. Selbst wenn ich immer nur ein Byte senden 
will und warte bis SPI_I2S_FLAG_BSY gelöscht ist, kommt kein Takt raus.

>  Ich glaube du musst noch die AFIO-Geschichte mit einem Takt versorgen

Bei den F4ern gibt es das nicht.

Moritz

[Thomas W. (ratos)]

Auf den ersten Blick sieht für mich fast alles OK aus.
Ich würde aber den CS-Pin nicht als AF-Pin initialisieren, sondern als 
OUT (bei NSS-Soft).
Wenn es wirklich nicht funktionieren will, kannst du ja mal alles exakt 
so wie in den Beispielen von ST machen, d.h. z.B. Pull-Down und nicht 
Up.
Oder du versuchst gleich das Beispiel von ST zum laufen zu bringen.

[Moritz M. (Gast)]

Hallo,

ja das mit AF ist mir schon aufgefallen. Macht aber auch keinen 
Unterschied für SPI. Wenn ich UP in Down ändere passiert auch nichts 
anderes

Moritz

[Moritz M. (Gast)]

Hallo nochmal.

Könnte es sein, das der SCK Prescaler vielleicht falsch eingestellt ist.
(SCK = APB2 / Prescaler)? Ich hab HCLK = 168MHz APB1 = 42MHz APB2 = 
84MHz

Also müsste doch SCK eig. 84MHz / 256 = 328,8125kHz sein oder?

Moritz

[holger (Gast)]

>vielen Dank für die Antwort. Selbst wenn ich immer nur ein Byte senden
>will und warte bis SPI_I2S_FLAG_BSY gelöscht ist, kommt kein Takt raus.

Woher weisst du das da kein Takt rauskommt?
Hoffentlich hast du da ein Osci dran. Aus SCK kommt kein
Takt wenn du nicht sendest. Also senden, senden, senden, senden...
Nicht nur ein popeliges Byte.

[Moritz M. (Gast)]

Hallo,

ja ich hab nen Oszi dran. Und ich sende immer 100x 0b10101010 direkt 
hintereinander.
Ich hab das ganze mal auf SPI2 umgeändert. Das Problem ist jetzt, dass 
wenn ich den MISO Pin(PB14) auf SPI2 mittels GPIO_PinAFConfig() remappen 
möchte, in der Funktion GPIO_PinAFConfig() an der Stelle:

GPIOx->AFR[GPIO_PinSource >> 0x03] &= ~((uint32_t)0xF << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)) ;

der Defaul-Handler angesprungen wird.

Moritz

[Moritz M. (Gast)]

Hallo nochmal,

wenn ich MISO einfach weg lasse geht es trotzdem nicht. kein Takt/Daten

Moritz

[Ingo (Gast)]

Es gibt im www ein deutsches Tutorial wo alles beschrieben wird. Is 
total genial, nur leider hab ich den Link nicht zur Hand. SPI is da auch 
beschrieben!


Ingo

[Moritz M. (Gast)]

Hallo,

meinst du vllt. das von Moritz Diller?
Da hab ich schon nachgesehn aber auch nichts gefunden.

Moritz

[Moritz M. (Gast)]

Hallo,

ich hab grade heraus gefunden das es sich um ein HardFault Exception 
handelt. Weiß jemand was darüber?

Moritz

[Moritz M. (Gast)]

Hier nochmal mein Code mit SPI2:

#include "stm32f4xx.h"

void SDCard_InitLowLevel(void);
void SDCard_Init(void);

int main(void)
{
  SystemInit();

  SDCard_InitLowLevel();

    while(1)
    {
      SDCard_Init();
    }

    return 1;
}

void SDCard_InitLowLevel(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  SPI_InitTypeDef SPI_InitStruct;

  /*
   * Clocks
   */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB, ENABLE);

  /*
  * DeInit
  */
  SPI_I2S_DeInit(SPI2);

  /*
   * Alternate Function
   */
  GPIO_PinAFConfig(GPIOB, GPIO_Pin_10, GPIO_AF_SPI2);
  //GPIO_PinAFConfig(GPIOB, GPIO_Pin_14, GPIO_AF_SPI2);
  GPIO_PinAFConfig(GPIOB, GPIO_Pin_15, GPIO_AF_SPI2);

  /*
   * GPIO Init
   * PB10 (SCK) to SD card pin 5 (SCLK)   PP UP AF
   * PB14 (MISO) to SD card pin 7 (DO)  PP UP AF
   * PB15 (MOSI) to SD card pin 2 (DI)  PP UP AF
   * PA8 (NSS) to SD card pin 1 (CS)    PP UP OUT
   */
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10 | /*GPIO_Pin_14 |*/ GPIO_Pin_15;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_SET);

  /*
   * SPI2 Init
   */
  SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStruct.SPI_CRCPolynomial = 7;
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStruct.SPI_Direction = SPI_Direction_1Line_Tx;
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
  SPI_Init(SPI2, &SPI_InitStruct);

  SPI_Cmd(SPI2, ENABLE);
}

void SDCard_Init(void)
{
  while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);

  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_RESET);

  for(int i = 0; i < 1000; i++)
  {
    SPI_I2S_SendData(SPI2, 0b10101010);

    while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  }

  GPIO_WriteBit(GPIOA, GPIO_Pin_8, Bit_SET);
}

Moritz

[holger (Gast)]

>Hier nochmal mein Code mit SPI2:

Hör auf im dunkeln rumzustochern.

In der StandardPeripheralLib zum STM32F4 ist ein Beispiel
für ein SPI Flash. Da ist alles drin was du brauchst.

Vergiss das hier:

    while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);

RXNE ist das was du abfragen musst. SPI_I2S_FLAG_BSY kommt in dem
Code überhaupt nicht vor. Im Datenblatt steht warum.

[Moritz M. (moritz_m72)]

Hallo,

ja den Code hab ich mir schon x-mal angesehn und nichts gefunden.

Moritz

[holger (Gast)]

>ja den Code hab ich mir schon x-mal angesehn und nichts gefunden.

Nicht ansehen, benutzen.

Im Anhang mal meine Routinen für SPI1.
Die funktionieren, sind also über jeden Zweifel erhaben;)

Deine CS Leitung musst du noch selber initialisieren.

[Michael F. (startrekmichi)]

Ich habe es mal kurz mit meinem Code verglichen und auf die Schnelle 
folgende Unterschiede gefunden:

- GPIO_Speed_100MHz und GPIO_PuPd_UP
- SPI_BaudRatePrescaler_256
- beim Senden teste ich auf:
    while (SET != SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE));
- ganz am Anfang der Initialisierung:
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE);
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2); //sck
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2); //mosi