STM32F04 als Slave - Wie Frame lesen?

[mr. mo (Gast)]

Guten Abend zusammen,

folgendes Szenario: An einem STM32F04 (Slave) ist am SPI1 ein Arduino 
(Master) angeschlossen welcher mir 4 Bytes schickt, dieses Frame ist mit 
einem CS umschlossen. (Siehe Anhang)

Ich habe es nicht geschafft diese 4 Bytes 'a' 'b' 'c' 'd' korrekt zu 
empfangen. Ich empfange immer zufällige Daten. Den SPI-Mode habe ich 
mehrere Male überprüft, das sollte passen.

Verbunden wie folgt:

    Arduino Nano:    STM32F04:
SCK    13          PB3
MOSI   11          PB5
CS     10          PA15

Folgendes hatte ich versucht:
1. Per RXNE Interrupt auf ankommende Daten reagieren:
Der RXNE Interrupt hat regelmäßig ausgelöst auch wenn keine Daten 
geschickt wurden. Immer im Interval von rund 40µs (mit Logic Analayzer 
geprüft). Die 4 gelesenen Bytes waren immer zufällig.

2. Per External Interrupt auf Fallende Flanke des CS reagieren:
Ich habe versucht im Interrupt-Handler die vier Bytes zu lesen. Es 
scheint dann aber nichts im Datenregister zu liegen, er bleibt immer in 
der Schleife hängen.

extern "C" void EXTI15_10_IRQHandler(void)
{
  static uint8_t byte;
  if (EXTI_GetITStatus(EXTI_Line15) == SET)
  {
    GPIO_SetBits(GPIOA, GPIO_Pin_0);  // Fuer Logic Analyzer

    // Lese die vier Bytes
    for (int i = 0; i < 4; ++i)
    {
      while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
      byte = SPI_I2S_ReceiveData(SPI1);
    }

    EXTI_ClearITPendingBit(EXTI_Line15);
    GPIO_ResetBits(GPIOA, GPIO_Pin_0);  // Fuer Logic Analyzer
  }
}

Konfiguriert habe ich SPI1 wie folgt (hier mit External Interrupt):

void init_SPI1(void) {

    GPIO_InitTypeDef GPIO_InitStruct;
  NVIC_InitTypeDef NVIC_InitStructure;
  EXTI_InitTypeDef EXTI_InitStruct;
  SPI_InitTypeDef SPI_InitStruct;

  // Clocks
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
  
  // GPIO
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_SPI1);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStruct);
  
  // Chip select
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_25MHz;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource15);

  EXTI_InitStruct.EXTI_Line = EXTI_Line15;
  EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
  EXTI_InitStruct.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStruct);

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  // SPI
  SPI_InitStruct.SPI_Direction = SPI_Direction_Rx;
  SPI_InitStruct.SPI_Mode = SPI_Mode_Slave;
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; 
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;     
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Reset;
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_Init(SPI1, &SPI_InitStruct);

  SPI_Cmd(SPI1, ENABLE); 
}

Inzwischen habe ich wahrscheinlich Tomaten auf den Augen. Sieht jemand 
den Fehler? Hat jemand schon einmal den STM32 als Slave betrieben und 
nur Daten empfangen?

[mr. mo (Gast)]

Sollte natürlich STM32F407 heißen, ...

[holger (Gast)]

>Sieht jemand den Fehler?

Ja, lass den STM das was der Arduino macht gleich mit
erledigen. Dann sparst du dir die Datenübertragung.

SCNR:)

[mr. mo (Gast)]

holger schrieb:
> Ja, lass den STM das was der Arduino macht gleich mit
> erledigen. Dann sparst du dir die Datenübertragung.

Der Arduino ist aktuell nur zum Testen gedacht. Eigentlich ist ein ADC 
angebunden der Daten über SPI an den STM feuert.

Da ich schon Probleme hatte die Daten vom ADC abzuholen, habe ich mir 
mit dem Arduino was zum Testen gebastelt um die SPI Hardware als Slave 
in Betrieb zu nehmen.