STM32F405 als SPI Slave sendet verwirrende daten

[Stefan (Gast)]

Hallo liebe Technikfreunde,

ich habe zwei STM32F05 Boards die über SPI Daten austauschen sollen. Das 
eine Board ist als Master konfiguriert, das andere als Slave.

Von Master zu Slave läuft alles super, die Daten kommen korrekt an.
Vom Slave zum Master kommen aber mal korrekte Zeichen, mal Bit-Foo.

Folgendes weiß ich bisher:

-Die Signale sind sauber (keine Verzerrungen, Störungen oder so)

-Auf dem Oszi ist zu sehen, dass das was der Master empfängt auch vom 
Slave genau so gesendet wurde.

-Der Master empfängt zufälligen Bitsalat, aber ab und zu sind ein oder 
zwei korrekte Zeichen an den korrekten Stellen dabei.

-Wenn ich das SPI-DR register vom Slave auf einen konstanten Wert setze 
und den TX-DMA vom Slave abschalte, dann kommt dieser Konstante Wert 
auch korrekt am Master an. (in mehreren Versuchen getestet)

-Wenn der Slave DMA die Sendewerte aus dem tx-Array aus in das SPI-DR 
schreibt, dann kommt da Müll raus

-Das Array wird bei der initialisierung mit Nullen geflutet (habe das 
sehr oft überprüft) und dann in der Sendefunktion befüllt.

Bevor ich den DMA implementiert hab, war das Ganze Interruptgesteuert. 
Gleiches Phänomen. Ich dachte erst der Slave sei einfach zu langsam 
wenns über ISRs läuft, also hab ich den DMA dazugebaut. Aber die 
Veränderung ist leider Null.

Hier ist der Quellcode des Slaves:

 void mcu_spi_spc_init_slave(void (*xfer_done)(uint8_t* data, uint32_t dlen))
{
  spi2_xfer_done = xfer_done;

  for (int c=0;c<128;c++)
  {
    spi2_tx_buffer[c] = 0;
    spi2_rx_buffer[c] = 0;
  }

  // Enable the SPI2 peripheral clock
  RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;

  // Enable port B Clock
  RCC->AHB1ENR |= (1<<1);

  // Enable DMA1 Clock
  RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN;

  // Reset the SPI2 peripheral to initial state
  RCC->APB1RSTR |=  RCC_APB1RSTR_SPI2RST;
  RCC->APB1RSTR &= ~RCC_APB1RSTR_SPI2RST;

  /*
 * SPC SPI2 SS:    Pin33 PB12
 * SPC SPI2 SCK:  Pin34 PB13
 * SPC SPI2 MISO:  Pin35 PB14
 * SPC SPI2 MOSI:  Pin36 PB15
   */

  // Configure the SPI2 GPIO pins
  GPIOB->MODER |= (2<<24) | (2<<26) | (2<<28) | (2<<30);
  GPIOB->PUPDR |= (02<<26) | (2<<28) | (2<<30);
  GPIOB->OSPEEDR |= (3<<24) | (3<<26) | (3<<28) | (3<<30);    // "very High speed"
  GPIOB->AFR[1] |= (5<<16) | (5<<20) | (5<<24) | (5<<28);    // Alternate function 5 (SPI2)

  //-------------------------------------------------------

  // Clock Phase and Polarity = 0
  // CR1 = LSByte to MSByte, MSBit first
  // DFF = 8bit
  // 6 MHz Clock (48MHz / 8)
  spi_spc->CR1 = (7<<3) | (0<<2) | (0<<1) | (0<<0)  // 0:CPHA, 1:CPOL, 2:MASTER, 3:CLOCK_DIVIDER
        | (0<<7) | (0<<11);            // 7:LSB first, 11:DFF(8Bit)

  spi_spc->CR2 = (0<<2) | (1<<0);      // 2:SSOE, 0:Enable RX DMA IRQ

  // DMA config  (Stream3:RX p2mem, Stream4:TX mem2p
  // DMA for RX Stream 3 Channel 0
  DMA1_Stream3->CR &= ~(1<<0);        // EN = 0: disable and reset
  while((DMA1_Stream3->CR & (1<<0)) != 0);  // Wait

  DMA1_Stream4->CR &= ~(1<<0);        // EN = 0: disable and reset
  while((DMA1_Stream4->CR & (1<<0)) != 0);  // Wait

  DMA1->LIFCR = (0x3D<<22);  // clear all ISRs related to Stream 3
  DMA1->HIFCR = (0x3D<< 0);  // clear all ISRs related to Stream 4

  DMA1_Stream3->PAR = (uint32_t) (&(spi_spc->DR));  // Peripheral addresse
  DMA1_Stream3->M0AR = spi2_rx_buffer;    // Memory addresse

  DMA1_Stream3->NDTR = 0xFFFF;  // Datenmenge zum Empfangen

  DMA1_Stream3->FCR &= ~(1<<2);  // ENABLE Direct mode by CLEARING Bit 2
  DMA1_Stream3->CR = (0<<25) |   // 25:Channel selection(0)
             (1<<10) |  // 10:increment mem_ptr,
             (0<<9) |    // 9: Do not increment periph ptr
             (0<<6);    // 6: Dir(P -> Mem)

  // DMA for TX Stream 4 Channel 0
  DMA1_Stream4->PAR = (uint32_t) (&(spi_spc->DR));  // Peripheral addresse
  DMA1_Stream4->M0AR = spi2_tx_buffer;    // Memory addresse

  DMA1_Stream4->NDTR = 1;  // Datenmenge zum Empfangen

  DMA1_Stream4->FCR &= ~(1<<2);  // ENABLE Direct mode by CLEARING Bit 2
  DMA1_Stream4->CR = (0<<25) |   // 25:Channel selection(0)
             (1<<10) |  // 10:increment mem_ptr,
             (0<<9) |    // 9: Do not increment periph ptr
             (1<<6) |    // 6: Dir(Mem -> P)
             (1<<4);

  // Setup the NVIC to enable interrupts.
  // Use 4 bits for 'priority' and 0 bits for 'subpriority'.
  NVIC_SetPriorityGrouping( 0 );

  uint32_t pri_encoding = NVIC_EncodePriority( 0, 1, 0 );
  NVIC_SetPriority( DMA1_Stream4_IRQn, pri_encoding );
  NVIC_EnableIRQ( DMA1_Stream4_IRQn );

  DMA1_Stream3->CR |= (1<<1);  // Enable DMA1_Stream3 (RX)
  spi_spc->CR1 |= (1<<6);    // 6:EnableSPI

}

Die Slave Sendefunktion:

void mcu_spi_spc_send_slave(uint8_t*data, uint32_t dlen)
{
  if (dlen >= 128)
  {
    dlen = 128;
  }

  for (uint32_t c = 0; c < dlen; c++)
  {
    spi2_tx_buffer[c] = data[c];
  }

  if (dlen > 0)
  {
    DMA1_Stream4->CR &= ~(1<<0);        // Disable stream 4
    while((DMA1_Stream4->CR & (1<<0)) != 0);  // Wait till disabled

    DMA1->HIFCR = (0x3D<< 0);  // clear all ISRs related to Stream 4
    DMA1_Stream4->NDTR = dlen;  // Datenmenge zum Senden
    DMA1_Stream4->CR |= (1<<0);  // Enable DMA1_Stream4 (TX)
    spi_spc->CR2 |= (1<<1);    // SPI TX DMA Request enable
  }

}

Benutzt wird das Ganze in der main (Auszug):

volatile uint8_t tx_buffer_slave[] = "test_erfolgreich!";

void spi_slave_test()
{
  mcu_spi_spc_init_slave(0);
  mcu_spi_spc_send_slave(tx_buffer_slave, 17);
  led_blink();

  while(1)
  {
    if (rx_buffer_len_slave != 0)
    {
      led_blink_lang();
      if ((rx_buffer_slave[0] == '1') && (rx_buffer_slave[1] == '2') && (rx_buffer_slave[2] == '3') )
      {
        for (uint8_t c=0;c<3;c++)
        {
          led_blink();
        }

      }else
      {
        // Loopback der Empfangenen Daten
        mcu_spi_spc_send_slave(rx_buffer_slave, rx_buffer_len_slave);
        led_blink_2();
      }

      rx_buffer_len_slave = 0;

    }
    else
    {
      led_blink_2_lang();
    }

  }

}

int main(void)
{
  init_leds();

  int i = 0;

  spi_slave_test();

  /* Infinite loop */
  while (1)
  {
      i++;
  }
}

Hat jemand eine Idee was da falsch läuft?

[Stefan (Gast)]

STM32F405! Sorry für den Tippfehler!

[au weia (Gast)]

Stefan schrieb:
> Hat jemand eine Idee was da falsch läuft?

Was soll dieses endlos lange gescrolle in so einem Text?

Dein Source-Text gehört in eine Datei als Anhang zum Beitrag.

Siehe:
---------------------------------------------
Wichtige Regeln - erst lesen, dann posten!
    ..........
    Längeren Sourcecode nicht im Text einfügen,
    sondern als Dateianhang
---------------------------------------------

Lesen, verstehen und verinnerlichen.