STM32F04 als Slave - Wie Frame lesen?

mr. mo Gast #4596141
Lesenswert?
• ▲
▼ 
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:
1
    Arduino Nano:    STM32F04:

2
SCK    13          PB3

3
MOSI   11          PB5

4
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.

1
extern "C" void EXTI15_10_IRQHandler(void)

2
{

3
  static uint8_t byte;

4
  if (EXTI_GetITStatus(EXTI_Line15) == SET)

5
  {

6
    GPIO_SetBits(GPIOA, GPIO_Pin_0);  // Fuer Logic Analyzer

7


8
    // Lese die vier Bytes

9
    for (int i = 0; i < 4; ++i)

10
    {

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

12
      byte = SPI_I2S_ReceiveData(SPI1);

13
    }

14


15
    EXTI_ClearITPendingBit(EXTI_Line15);

16
    GPIO_ResetBits(GPIOA, GPIO_Pin_0);  // Fuer Logic Analyzer

17
  }

18
}


Konfiguriert habe ich SPI1 wie folgt (hier mit External Interrupt):
1
void init_SPI1(void) {

2


3
    GPIO_InitTypeDef GPIO_InitStruct;

4
  NVIC_InitTypeDef NVIC_InitStructure;

5
  EXTI_InitTypeDef EXTI_InitStruct;

6
  SPI_InitTypeDef SPI_InitStruct;

7


8
  // Clocks

9
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);

10
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

11
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

12
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

13
  

14
  // GPIO

15
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_SPI1);

16
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_SPI1);

17
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_SPI1);

18


19
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5;

20
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;

21
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;

22
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;

23
  GPIO_Init(GPIOB, &GPIO_InitStruct);

24
  

25
  // Chip select

26
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;

27
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;

28
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;

29
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_25MHz;

30
  GPIO_Init(GPIOA, &GPIO_InitStruct);

31


32
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource15);

33


34
  EXTI_InitStruct.EXTI_Line = EXTI_Line15;

35
  EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;

36
  EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;

37
  EXTI_InitStruct.EXTI_LineCmd = ENABLE;

38
  EXTI_Init(&EXTI_InitStruct);

39


40
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

41
  NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;

42
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

43
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

44
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

45
  NVIC_Init(&NVIC_InitStructure);

46
  

47
  // SPI

48
  SPI_InitStruct.SPI_Direction = SPI_Direction_Rx;

49
  SPI_InitStruct.SPI_Mode = SPI_Mode_Slave;

50
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; 

51
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;

52
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;     

53
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Reset;

54
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;

55
  SPI_Init(SPI1, &SPI_InitStruct);

56


57
  SPI_Cmd(SPI1, ENABLE); 

58
}


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?
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
mr. mo Gast #4596155
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt. Bitte hier nur auf die ursprüngliche Frage antworten, für neue Fragen einen neuen Beitrag erstellen.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.