UART echo bzw. loopback (STM32)

Und jetzt bitte noch mit Interrupt und Sleep mode, sodass der Core nicht 
jede Menge Rechenleistung/Energie aufs Nichtstun verschwendet.

Dr. Sommer schrieb:
> Und jetzt bitte noch mit Interrupt und Sleep mode, sodass der Core nicht
> jede Menge Rechenleistung/Energie aufs Nichtstun verschwendet.

gg

@Dr.Sommer:
Och komm, das ist nicht dein Ernst, oder? Er meinte es gut und wollte 
ein bisschen was zur Community beitragen.
Als Basis, auf der man aufbauen kann reicht sein Beispiel doch, oder? 
Zeig mir ein Code-Beispiel, welches du eins zu eins übernehmen konntest. 
Ich wette in 99,99% der Fälle nimmst du Änderungen vor, um anzupassen - 
und sei es nur die Code-Kommentierung.

Ralf

Ralf schrieb:
> Ich wette in 99,99% der Fälle nimmst du Änderungen vor, um anzupassen -
> und sei es nur die Code-Kommentierung.

Sven S. schrieb:
> ihr koennt das ja gerne mal mit Interrupt machen.
> Waere dran interessiert!

Offenbar scheint diese Änderung doch nicht ganz trivial zu sein. 
Aufgrund des hohen-Coretakts macht die UART-Nutzung auf einem STM32 
eigentlich nur mit Interrupts Sinn und wäre daher im Anfangsbeispiel 
angebracht. Außerdem fehlt hier die ganze Initialisierung, und die ist 
aufgrund der Komplexität der STM32 durchaus interessant. So in etwa:

1

const int bufSize = 255;

2

uint8_t buffer [bufSize], bufFill, txPtr;

3

4

void myUsartInit () {

5

  // Clock des USART einschalten:

6

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

7

  RCC_APB2PeriphClockLPModeCmd(RCC_APB2Periph_USART1, ENABLE);

8

  RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOBEN, ENABLE);

9

10

  // USART Pins einschalten

11

  GPIO_InitTypeDef GPIO_InitStructure;

12

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;

13

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;

14

  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;

15

  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;

16

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

17

  GPIO_Init(GPIOB, &GPIO_InitStructure);

18

  GPIO_PinAFConfig (GPIOB, GPIO_PinSource6, GPIO_AF_USART1);

19

20

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;

21

  GPIO_Init(GPIOB, &GPIO_InitStructure);

22

  GPIO_PinAFConfig (GPIOB, GPIO_PinSource7, GPIO_AF_USART1);

23

24

  // USART konfigurieren & einschalten

25

  USART_InitTypeDef uInit;

26

  USART_StructInit (&uInit);

27

  uInit.USART_BaudRate = 57600;

28

  uInit.USART_WordLength = USART_WordLength_8b;

29

  uInit.USART_StopBits = USART_StopBits_1;

30

  uInit.USART_Parity = USART_Parity_No;

31

  uInit.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

32

  uInit.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

33

  USART_Init (USART1, &uInit);

34

35

  USART_ClockInitTypeDef ucInit;

36

  USART_ClockStructInit (&ucInit);

37

  ucInit.USART_Clock = USART_Clock_Disable;

38

  USART_ClockInit (USART1, &ucInit);

39

40

  USART_Cmd (USART1, ENABLE);

41

42

  // Interrupt channel einschalten

43

  NVIC_InitTypeDef NVIC_InitStructure;

44

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

45

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

46

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

47

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

48

  NVIC_Init(&NVIC_InitStructure);

49

50

  // Interrupts einschalten

51

  USART_ITConfig (USART1, USART_IT_TXE, ENABLE); // TX register Empty - wir können was senden

52

  USART_ITConfig (USART1, USART_IT_RXNE, ENABLE); // RX register Not Empty - es wurde was empfangen

53

54

  bufFill = 0; txPtr = 0;

55

}

56

57

void USART1_IRQHandler (void) {

58

  // Können wir was senden?

59

  if (USART_GetFlagStatus (USART1, USART_FLAG_TXE) == SET) {

60

    // Gibts was zu senden?

61

    if (txPtr < bufFill) {

62

      // absenden

63

      USART_SendData (USART1, buffer [txPtr]);

64

      txPtr++;

65

    } else {

66

      // Wenn nicht - Interrupt abschalten, wir wollen nicht in Endlosschleife in diesem Interrupt landen

67

      USART_ITConfig (USART1, USART_IT_TXE, DISABLE);

68

    }

69

  }

70

  // Haben wir was empfangen?

71

  if (USART_GetFlagStatus (USART1, USART_FLAG_RXNE) == SET) {

72

    // Auslesen

73

    uint8_t rec = USART_ReceiveData (USART1);

74

    // Noch Platz im Puffer?

75

    if(bufFill < bufSize) {

76

      // Speichern

77

      buffer [bufFill] = rec;

78

      bufFill++;

79

80

      // TXE-Interrupt ein

81

      USART_ITConfig (USART1, USART_IT_TXE, ENABLE);

82

      // Können wir das direkt absenden?

83

      if(USART_GetFlagStatus (USART1, USART_FLAG_TXE) == SET) {

84

        // Absenden

85

        USART_SendData (USART1, buffer [txPtr]);

86

        txPtr++;

87

      } // Falls nicht, wird demnächst ein TXE-Interrupt eintreffen und wir können dann senden

88

    }

89

  }

90

}

In diesem Fall ist das etwas komplizierter als nötig - bei einem 
einfachen loopback müsste beim Empfang eines Bytes das TX-Register immer 
leer sein und man direkt senden können. Zu Demonstrationszwecken habe 
ich aber die Abfrage des "TX Register Empty" Flags eingebaut, d.h. es 
wird sichergestellt dass das TX-Register tatsächlich leer ist.

So, und jetzt darf wer anders das ganze mit DMA machen...

Sven S. schrieb:
> Funktioniert der Code Dr. Sommer? (selbst getestet ?)
Teilweise getestet, das wichtigste funktioniert auf jeden Fall, glaub 
aber nicht dass was falsch ist.
> 1)
> Wie ich das jetzt verstehe, werden deine Empfangenen Daten in buffer[]
> reingeschrieben oder?
Ja.
> 2)
> Wie koennte ich denn jetzt was ich in buffer[] empfangen habe in meine
> Variablen schreiben, wenn ich mal annehme das mir die gegenstelle
> mehrere bytes geschickt hat.  also bspw. 5 Ints.
buffer[] ist eine variable, du kannst die daten direkt da heraus 
verwenden. wenn du sie als int behandeln willst, musst du das nur dem 
compiler sagen:
uint32_t myInt = *((uint32_t*) &buffer);
Dies kopiert die ersten 4 bytes des "buffer" in eine int-Variable.

> 3)
> Aber ist ein Interrupt Empfang wirklich noetig wenn man bspw. nur in
> bestimmten faellen was empfangen moechte und nicht staendig?
Nicht zwangsweise nötig, aber äußerst sinnvoll - deine busy-wait-Methode 
mit while() verbraucht viel Energie (und der Controller wird warm), da 
der ganze Core aktiv ist, während man bei der Verwendung eines 
Interrupts die Hauptschleife mit __WFE(); schlafen legen kann, und der 
Core nur dann etwas tut, wenn tatsächlich etwas angekommen ist. Der 
Energieverbrauch ist dann nur noch ein kleiner Bruchteil (ich habs 
nachgemessen).


> Zum Beispiel gibts neben der Hauptroutine einen Empfangsmodus den der
> nutzer ab und an aktivieren kann.
>
> In diesem Fall ist doch der Interrupt nicht noetig, da der
> Empfangsamodus nach getaner Arbeit verlassen wird.

Nicht unbedingt noetig, aber sinnvoller. Außerden kannst du so noch 
gleichzeitig auf andere Events warten - zB auf einen Interrupt bei 
Tastendruck o.ä.

Mit DMA wär das ganze wohl noch effizienter, aber da hab ich grad keinen 
Code zur hand.

nochmal eine dummer Frage:

den Rx Interrupt verstehe ich ja...also wurde etwas empfangen, wird es 
an entsprechene Stelle in buffer geschrieben bis bufFil überläuft. Denn 
gehts wieder von vorne los. Aber das Senden wie läuft das genau ab?

also die isr wird immer aufgerufen, wenn etwas empfangen wurde (RXNE) 
und wenn nichts mehr zu senden ist (TXE).

Wenn ich jetzt was senden möchte schreibe ich das in den buffer etwas 
rein oder auch nicht und setze, denn den Bufferfil entsprechend hoch 
also wen ich 1 zeichen senden will schreibe ich:
buffer[0]=0x2;
bufFil++;
 die isr wird denn aufgerufen weil ja TXE ist, er sendet denn mein 
zeichen, beim nächsten isr aufruf ist txPtr denn gleich buFil und der 
TXE interrupt wird diabled. der RXNE ist aber aber dieses mal gesetzt 
und es wird wider etwas in den buffer geschrieben bufFil wird um 1 
erhöht und der RXNE interrupt wird wieder enabled es kann wieder was 
gesendet werden.

Hallo Dr. Sommer

Dank dir für den Loopback, er hat mir bei der Einarbeitung sehr 
geholfen! Nachdem die Examples in der Coocox Ide recht mager sind (oder 
miserabel strukturiert) würde ich diesen Code gerne dort posten und die 
Arbeit so für andere vereinfachen. Ist das möglich?

Hat schon jemand mit den Examples (USART) direkt von ST gearbeitet? 
Gerade beim USART scheint es mir so als wäre hier die Send Fkt. komplett 
unter den Tisch gefallen. Aber wie gesagt ich bin noch in der 
Einarbeitungsphase, vielleicht habe ich diese auch übersehen ;)

Grüße

Ralf L.