STM32: SPI MISO Bug

[Tim R. (mugen)]

Ich verstehe die Welt seit einigen Stunden nicht mehr. Ich habe Probleme 
mit einem simplen SPI Bus und finde einfach nicht die Ursache dafür.

Ich benutzte das stm32 discovery board als SPI Master um Daten zu senden 
und zu empfangen.

Folgendes geht:

- CLK ist da
- CS geht
- MOSI funktioniert einwandfrei und die Bits habe ich xmal schon geprüft 
und gezählt
- Daten kommen an MISO richtig an!

Ich benutze CooCox als IDE.
Ich habe bereits auch eine Lösung gefunden, allerdings geht die wirklich 
nur über CooCox. Nach der SPI Initialisierung setze CPOL und CPHA auf 
High über das JTAG-Interface und lasse SPI1 kurz falsch laufen (Nur ein 
Frame). Danach setze ich CPOL und CPHA wieder auf 0 und dann 
funktioniert alles. Leider finde ich nicht den Grund dafür und ich würde 
mich sehr darüber freuen, wenn ich den Controller ohne JTAG Anbindung zu 
laufen bekomme ;)


Hier meine GPIO Initialisierung:

    // GPIO_Pin_5 - SPI1_SCK      OUT
    // GPIO_Pin_6 - SPI1_MISO      IN
    // GPIO_Pin_7 - SPI1_MOSI      OUT
    // GPIO_Pin_10 -                              // BLOCK-TEST: SPI_CS

    /* Configure SPI1 pins: SCK, MISO and MOSI -------------------------------*/
    GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_5 | GPIO_Pin_7;//
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);


    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStruct);

Hier meine SPI Initialisierung:

void init_SPI1(void)
{
  SPI_InitTypeDef SPI_InitStructure;

  //=======================================================================
    /* 1st phase: SPI1 Master */
    /* SPI1 Configuration ----------------------------------------------------*/

    /* Deinitializes the SPIx peripheral registers to their default reset values */
  SPI_I2S_DeInit(SPI1);

  SPI_StructInit(&SPI_InitStructure);

  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    // SPI MODE Configuration:
    //
    //   Mode   CPOL   CPHA
    //   0      0      0
    //   1      0      1
    //   2      1      0
    //   3      1      1
    //
    //          0           SPI_CPOL_Low
    //          1           SPI_CPOL_High
    //                 0    SPI_CPHA_1Edge
    //                 1    SPI_CPHA_2Edge

    // SPI MODE 3:
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;          // SPI_DataSize_8b   or SPI_DataSize_16b
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;          // SPI_FirstBit_MSB or SPI_FirstBit_LSB
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;              // SPI_NSS_Soft   or SPI_NSS_Hard
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;            // SPI_Mode_Master  or SPI_Mode_Slave
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //SPI_Direction_1Line_Tx;//
    SPI_InitStructure.SPI_CRCPolynomial = 7;

    SPI_Init(SPI1, &SPI_InitStructure);      // SPI initialisieren

    SPI_CalculateCRC(SPI1, DISABLE);

    SPI_I2S_ITConfig(SPI1, SPI_I2S_IT_RXNE, DISABLE);

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

    /* Wait for SPI1 Tx buffer empty */
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
}

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

Eine Kleinigkeit fehlt leider: nämlich was genau nicht funktioniert. 
Also was du versuchst, was dabei deiner Ansicht nach passieren sollte 
und was tatsächlich passiert.

Und der Code dazu fehlt auch.

[Tim R. (mugen)]

Okay...

Was genau nicht funktioniert ist, dass ich keine Daten im 
Empfangsregister vorfinde obwohl das richtige Byte an MISO anliegt. Der 
Slave funktioniert somit einwandfrei. Ich bekomme die JTAG Lösung auch 
nicht per Code nachgestellt. Achselzuck

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

Takte laufen?

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

Es bringt einen nicht immer weiter, nur den Code zu zeigen, in dem man 
selbst den Fehler vermutet. Manchmal hilft es, auch den Code zu zeigen, 
in dem man ihn nicht vermutet.

[Tim R. (mugen)]

Ja die Takte laufen, die Bits in den RCC Registern habe ich auch bereits 
geprüft. Ansonsten würde kein SPI Frame nach außen gesendet werden.

Gerne kann ich den Test-Code posten, aber dort vermutlich keine 
Probleme. Der Code ist nicht fertig und auch der Stil gefällt mir noch 
nicht:

#include "stm32f10x.h"
#include "system.h"

/***************************************************************************//**
 @brief Double_Pulse_Main
 ******************************************************************************/

uint16_t SPI1_TX(uint16_t DATA_TX);
uint16_t SPI1_RX();

uint16_t ARRAY_TEST[3] = { 0x01, 0x02, 0x03 };

void Double_Pulse_Main_TEST_BLOCKRAM(uint32_t l_pulse_t1, uint32_t l_pulse_t2, uint32_t l_pulse_t3)
{
    static int i=0;
    static int l_j=0;

    static uint16_t l_pulse[3];

    //*LESEN getestet mit SPI_CPOL_Low & SPI_CPHA_1Edge ********************************************************************************************
      ARRAY_TEST[0] = 0;
        ARRAY_TEST[1] = 0;
        ARRAY_TEST[2] = 0;

        if(i == 1)
        {
          GPIOA->BSRR = GPIO_Pin_1;  // RAM: WE auf 1
          i = 0;
          l_j += 1;

          if(l_j >= 200)
            l_j = 0;
        }
        else
        {
          GPIOA->BRR = GPIO_Pin_1;    // RAM: WE auf 0
          i = 1;
        }

      GPIOA->BRR   = GPIO_Pin_10;  // SPI_!CS auf 0
    Delay(1);//10 µs

    if(i == 1)
    {
      ARRAY_TEST[0] = SPI1_TX(l_j);      // 23-16 bit

      ARRAY_TEST[1] = SPI1_TX(l_j);    // 15-08 bit

      ARRAY_TEST[2] = SPI1_TX(l_j);    // 07-00 bit

      GPIOA->BRR   = GPIO_Pin_2;    // ADD0 auf 0
      GPIOA->BRR   = GPIO_Pin_3;    // ADD1 auf 0
      Delay(1);//10 µs

      GPIOA->BSRR  = GPIO_Pin_9;    // CLK zunächst auf 1
      Delay(1);//10 µs
      GPIOA->BRR   = GPIO_Pin_9;    // CLK zunächst auf 0
      Delay(1);//10 µs
    }
    else
    {
      GPIOA->BSRR  = GPIO_Pin_9;    // CLK zunächst auf 1
      Delay(1);//10 µs
      GPIOA->BRR   = GPIO_Pin_9;    // CLK zunächst auf 0
      Delay(1);//10 µs

      ARRAY_TEST[0] = SPI1_RX();    // 23-16 bit

      ARRAY_TEST[1] = SPI1_RX();    // 15-08 bit

      ARRAY_TEST[2] = SPI1_RX();    // 07-00 bit
    }

     Delay(1);//10 µs
     GPIOA->BSRR   = GPIO_Pin_10;  // SPI_!CS auf 1
     Delay(100);//1000 µs
}

uint16_t SPI1_TX(uint16_t DATA_TX)
{
  uint16_t l_value = 0;

  while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE)==RESET); // Wait for SPI1 Tx buffer empty
  SPI_I2S_SendData(SPI1,DATA_TX);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == 1);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
  l_value = SPI_I2S_ReceiveData(SPI1);  /* Clear pending RXNE*/

  return l_value;
}

uint16_t SPI1_RX()
{
  uint16_t l_DATA_RX=0;

  while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE)==RESET); // Wait for SPI1 Tx buffer empty
  SPI_I2S_SendData(SPI1,0x00);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == 1);

  while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE)==RESET);
  l_DATA_RX=SPI_I2S_ReceiveData(SPI1); /* Clear pending RXNE*/

  return l_DATA_RX;
}

Initialisierung:

  SystemInit();


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

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



    /* TIMER configuration ---------------------------------------------------*/
    //init_TIM2_PWM();
    init_TIM1_Pulse();
    init_TIM2_Pulse();
    init_TIM3_Pulse();
    //init_TIM1M_TIM3S_PULSE();
    init_TIM3M_TIM2S_PULSE();
    init_TIM4_ENC();
    init_TIM7_SW();

    init_SysTick_1msec();

    init_SPI1(); // INIT SPI1

[Daniel (Gast)]

Hallo,
nur ne Vermutung, sollte der GPIO6 also der MISO nicht auch als 
GPIO_Mode_AF konfiguriert werden?

Gruß Daniel

[RayOfLight (Gast)]

Problem ist genau hier:

GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;

[Tim R. (mugen)]

RayOfLight schrieb:
> Problem ist genau hier:
>
> GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;

GPIO_Mode habe ich bereits mehrmals gewechselt und dies funktioniert 
auch nicht:

    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP; //GPIO_Mode_IN_FLOATING;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

Im Internet habe ich bereits unterschiedlichste Meinungen über die 
richtige Konfigurationen von MISO gefunden und gefühlt habe ich alles 
ausprobiert. Aber ich lasse mich sehr gerne belehren, so ist es ja 
nicht.

[Tim R. (mugen)]

Bitte beachtet den sehr wichtigen Hinweis, dass die Kummunikation 
funktioniert wenn SPI_CPOL und SPI_CPHA über JTAG kurzzeitig auf High 
gezogen wird. Warum auch immer ?!?

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

Die SS Steuerung rund um NSS hat wohl alle irritiert, die je mit STM32 
und SPI zu tun hatten. CR1:NSS=1 heisst, dass der interne SS-Pin des SPI 
Moduls von CR1:SSI gesteuert wird, an Stelle des externen Pins SS. Und 
wenn man einem Master extern SS=0 anlegt, dann nimmt er an, dass ein 
anderer Master schneller war als er und schaltet ab. Folglich 
funktioniert NSS=1 nur bei SSI=1.

[Tim R. (mugen)]

@ A.K.

Diese Aussage habe ich auch öfters im Internet gelesen, dass es wegen 
NSS nur Verwirrungen kommt. Ich benutze GPOIA PIN10 als CS und steuere 
ihn auch über SW an. Für mich auch kein Problem, da mir die 
Geschwindigkeit in dieser Applikation recht egal ist. Andererseits frag 
ich mich wirklich was ST sich dabei gedacht hat, aber da scheinen wohl 
die alten Thomson Zeiten durch. In Verbindung mit DMA ist die ganze NSS 
Steuerung total sinnfrei.

Im übrigen habe ich sogar den neuesten GNU complire installiert, mir 
gehen langsam die Ideen aus ;-)

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

Tim R. schrieb:
> Ich benutze GPOIA PIN10 als CS und steuere
> ihn auch über SW an.

Ist mir klar. Es geht bei NSS=1 allerdings um das interne SS Signal des 
SPI-Moduls. Also das SS Signal, das bei NSS=1 aussen auf dem Pin nicht 
aufkreuzt, intern aber dennoch existiert. Wenn diese interne Signal auf 
0 steht, dann ist Essig. Und dieses interne Signal ist SSI, bei NSS=1.

Ich mag die STM32 Lib nicht so, also darfst du selber suchen. ;-)

> In Verbindung mit DMA ist die ganze NSS Steuerung total sinnfrei.

Yep.

[holger (Gast)]

>    // SPI MODE 3:
>    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
>    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;


Vieleicht möchte das was du da angeschlossen hast
tatsächlich Mode3 haben? Eingestellt ist jedenfalls Mode0.

[Jannis C. (kabelwurm)]

Was mir noch einfällt, den gesamten Code ohne die Libs zu schreiben. 
Damit kannst du einen Softwarefehler besser finden und möglicherweise 
den Fehler finden, wenn du im Datenblatt ließt. Mir geht es inzwischen 
so, dass ich die Libs garnicht mehr benutze und die Register direkt 
beschreibe. Zudem ist der Code damit maximal schnell und mit etwas 
Einarbeitung auch übersichtlicher, da man nach verfolgen kann, wann 
welches Bit gesetzt/gelöscht wird.
Gruß Jannis

[RayOfLight (Gast)]

Versuche mal GPIO_PinAFConfig fur den MISO pin

[Tim R. (mugen)]

holger schrieb:
>>    // SPI MODE 3:
>>    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
>>    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
>
>
> Vieleicht möchte das was du da angeschlossen hast
> tatsächlich Mode3 haben? Eingestellt ist jedenfalls Mode0.

Soll 0 sein, mein Kommentar habe ich noch nicht zurück geändert.

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

SETZ DAS VERDAMMTE SSI BIT!

Falls meine Erklärung oben zu umständlich gewesen sein sollte. ;-)

[Tim R. (mugen)]

> Ich mag die STM32 Lib nicht so, also darfst du selber suchen. ;-)

Also das bit SSM und SSI sind bei mir beide auf High.

Zu STM32 Lib: Ich stimme da sehr gerne zu, da vieles kryptisch und als 
großes Monster gelöst wurde. Was ich aber mag ist die struct Lösung. Hex 
Files noch zur Parametrierung zu nutzen finde ich persönlich als lästig.

[holger (Gast)]

>> Vieleicht möchte das was du da angeschlossen hast
>> tatsächlich Mode3 haben? Eingestellt ist jedenfalls Mode0.
>
>Soll 0 sein, mein Kommentar habe ich noch nicht zurück geändert.

Dann muss das wohl ein anderes Problem sein.
Deine Config für Mode0 ist jedenfalls in Ordnung.
Vieleicht liegts auch an der Schaltung.

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

Tim R. schrieb:
> Also das bit SSM und SSI sind bei mir beide auf High.

Vor oder nach dem Hack?

[Tim R. (mugen)]

A. K. schrieb:
> SETZ DAS VERDAMMTE SSI BIT!
>
> Falls meine Erklärung oben zu umständlich gewesen sein sollte. ;-)

In der Tat habe ich das SSi bit wirklich suchen müssen und es wurde 
elegant in der Datei stm32f10x_spi.h in diese Zeile versteckt:

 #define SPI_Mode_Master                 ((uint16_t)0x0104)

Man beachte 0x100 (SSI bit)

Ach wie ich diese define Programmierung hasse.

[Tim R. (mugen)]

A. K. schrieb:
> Tim R. schrieb:
>> Also das bit SSM und SSI sind bei mir beide auf High.
>
> Vor oder nach dem Hack?

Vor und wie auch nach dem Hack. Ich habe mal das Register direkt 
angesprochen und die Initialisierung ein wenig aufgeräumt. Leider kein 
Unterschied:

void init_SPI1(void)
{
  struct STRUCT_INIT_CR1_SPI{
    uint16_t CPHA:1;
    uint16_t CPOL:1;
    uint16_t MSTR:1;
    uint16_t BR:3;
    uint16_t SPE:1;
    uint16_t LSBFIRST:1;
    uint16_t SSI:1;
    uint16_t SSM:1;
    uint16_t RXONLY:1;
    uint16_t DFF:1;
    uint16_t CRCNEXT:1;
    uint16_t CRCEN:1;
    uint16_t BIDIOE:1;
    uint16_t BIDIMODE:1;
  };

  union STRUCT_SPI_CR1{
    uint16_t          all;
    struct  STRUCT_INIT_CR1_SPI  bit;
  };

  union STRUCT_SPI_CR1 SPI_CR1;

    // SPI MODE Configuration:
    //
    //   Mode   CPOL   CPHA
    //   0      0      0
    //   1      0      1
    //   2      1      0
    //   3      1      1
    //
    //          0           SPI_CPOL_Low
    //          1           SPI_CPOL_High
    //                 0    SPI_CPHA_1Edge
    //                 1    SPI_CPHA_2Edge

    // SPI MODE 0:

    SPI_CR1.all       = 0;
    SPI_CR1.bit.CPOL     = 0;
    SPI_CR1.bit.CPHA     = 0;
    SPI_CR1.bit.DFF     = 0;  //  8-bit data frame format is selected for transmission/reception
    SPI_CR1.bit.LSBFIRST   = 0;  //  MSB transmitted first
    SPI_CR1.bit.SSI      = 1;
    SPI_CR1.bit.SSM      = 1;
    SPI_CR1.bit.MSTR    = 1;  // Master configuration
    SPI_CR1.bit.SPE      = 1;  // Peripheral enable
    SPI_CR1.bit.BR      = 7;

    SPI1->CR1 = SPI_CR1.all;
}