STM32 Programming Reference

[Bert S. (kautschuck)]

Hi,

Ich bin gerade am erlernen von ARM auf einem STM32F3Discovery Board.
Die GPIO Manipulation habe ich nun verstanden und möchte mich nun dem 
USART widmen. Ich nutze folgende programming reference:

http://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf

Nun sind hier aber die Register nicht so beschrieben, wie ich mir das 
von AVR gewohnt bin, man sieht also nirgends, wo man die Flags setzen 
sollte.
Wenn ich z.B das Register USART_CR1 für die Wortlänge der Transmission 
beschrieben möchte, finde ich nirgends etwas, welche Bits ich 
manipulieren soll? Gibt es irgendwie noch eine detailliertere 
programming reference?

Grüsse Hans

[... (Gast)]

Was genau an Kapitel 27.6  reicht nicht aus, dachdem du den 
dazugehörigen Text [Kapitel 27] wenigstens 1x gelesen hast?

[Bert S. (kautschuck)]

Ok, das hatte ich nicht gelesen, danke. Der Einstieg ist schon ziemlich 
schwieriger als in AVR.

[Bert S. (kautschuck)]

Wenn ich nun z.B die Wortlänge auf 8bit setzen möchte, muss ich ja M1 
und M0 in  USART_CR1 zu 0 setzen.

In AVR konnte ich ja direkt USART_CR1 &= ...
In ARM aber muss ich nun USART_CR1_M abändern, doch wie setze ich diese 
beiden bits? Die grösse sollte doch 2bit sein?

Ich habe gesehen, es werden oft structs verwendet, um die GPIO-Pins oder 
auch USART zu initialisieren:

USART_InitTypeDef USART_InitStructure;

Welche Bibliotheken müssen da eingebunden werden? Gibt es da eine 
programming reference für all diese Funktionen?

Grüsse Hans

[... (Gast)]

Die Peripherien sind in Strukturen beschrieben und nicht so 
hingeklatscht wie im AVR.

das sieht dann so aus:

RCC->AHB1RSTR oder wie auch immer so ein Register heißen mag. Und da 
kannst du dann auch deine gewohnten Bitoperationen drauf ausführen.

RCC ist dann ein Pointer auf die Struktur.. schreib das einfach mal hin 
und lass von der IDE nach der Definition suchen. Dann wirst du sehen, 
dass es etwas ähnliches auch für die USART gibt.. musst nur mal ein 
bischen schauen.

[... (Gast)]

Ich hab grade mal geguckt.
Ich habe nur einen Header für einen STM32L hier.. da sind die USART so 
definiert:

#define USART2              ((USART_TypeDef *) USART2_BASE)
#define USART3              ((USART_TypeDef *) USART3_BASE)
#define UART4               ((USART_TypeDef *) UART4_BASE)
#define UART5               ((USART_TypeDef *) UART5_BASE)

Du schreibst im Code also

USART2->CR1 |= ....   ;

usw...

[PittyJ (Gast)]

Ich habe die letzten Wochen mit den ARMs von NXP herumgespielt.
Dort ist das viel einfacher. Die haben eine API mit dabei, teilweise 
sogar im ROM. Die serielle Schnittstelle war mit 10 Zeilen erledigt. 
Keine Bitfriemelei dabei, ich habe dafür kein Register direkt gesetzt.
Nur so als Hinweis, wie es auch besser gehen kann. Weil der STM doch oft 
so hoch gelobt wird...

[Horst (Gast)]

PittyJ schrieb:
> Keine Bitfriemelei dabei, ich habe dafür kein Register direkt gesetzt.

Dafür gibt es bei ST die SPL und die HAL. Aber man sollte es zumindest 
einmal richtig gemacht haben um zu wissen wie es geht, das erleichtert 
die Fehlersuche ungemein.

[W.S. (Gast)]

Bert S. schrieb:
> Nun sind hier aber die Register nicht so beschrieben, wie ich mir das
> von AVR gewohnt bin, man sieht also nirgends, wo man die Flags setzen
> sollte.

Es gibt mehrere Arten, die Hardware-Register für die Verwendung in C zu 
definieren. Eine Art ist, ein struct zu definieren und dann einen 
Pointer drauf zu definieren. Eine andere Art ist, jedes einzelne 
Register zu definieren. Mir liegt die zweite Version mehr, weil es in 
der ersten wegen diverser Leerstellen immer nötig ist, Fülleinträge in 
structs einzuführen und die gerade gültigen Alignment-Konventionen 
einzuhalten, sonst geht das schief.

Die zweite Version sieht etwa so aus:

#define USART1  0x40013800 

// Universal synchronous asynchronous receiver transmitter (USART)
#define USART1_CR1   (*((volatile dword *) (USART1 + 0x0)))
#define USART1_CR2   (*((volatile dword *) (USART1 + 0x4)))
#define USART1_CR3   (*((volatile dword *) (USART1 + 0x8)))
#define USART1_BRR   (*((volatile dword *) (USART1 + 0xC)))
#define USART1_GTPR  (*((volatile dword *) (USART1 + 0x10)))
#define USART1_RTOR  (*((volatile dword *) (USART1 + 0x14)))
#define USART1_RQR   (*((volatile dword *) (USART1 + 0x18)))
#define USART1_ISR   (*((volatile dword *) (USART1 + 0x1C)))
#define USART1_ICR   (*((volatile dword *) (USART1 + 0x20)))
#define USART1_RDR   (*((volatile dword *) (USART1 + 0x24)))
#define USART1_TDR   (*((volatile dword *) (USART1 + 0x28)))

Damit kannst du dann deinen USART so einrichten, wie du es haben willst. 
Etwa so in der Art:

dword InitSerial1 (long baudrate)    /* liefert tatsächliche Baudrate zurück */
{ long Baudteiler;

  Baudteiler = F_Platform / baudrate; /* SysClk Frequenz */
  U1Buf.InWP =                      /* alle Puffer rücksetzen */
  U1Buf.InRP =
  U1Buf.OutWP =
  U1Buf.OutRP = 0;
  /* Int 37 */
  NVIC_ICPR1 = (1<<(U1Int-32));     /* pending löschen */
  NVIC_ISER1 = (1<<(U1Int-32));     /* Int erlauben */
  USART1_CR1 = 0;                   /* erstmal aus */
  USART1_CR2 = (3<<12);             /* 1.5 Stopbits */
  USART1_CR3 = 0;
  USART1_GTPR = 0;
  USART1_BRR = Baudteiler & 0xFFFF; /* Baudratenteiler */
  USART1_CR1 = (1<<7)  |            /* TX Int enable */
               (1<<5)  |            /* RX Int enable */
         (1<<3)  |            /* TX enable     */
               (1<<2)  |            /* RX enable     */
               (1<<0);              /* UART enable   */
  return F_Platform / Baudteiler;
}

Ist dir jetzt klar, wie man Hardware-Register definiert und wie man sie 
dann auch verwendet?

W.S.

[Bert S. (kautschuck)]

Super, danke euch, jetzt glaube ich ist mir alles klar.

Grüsse Hans

[Bert S. (kautschuck)]

Wenn ich die Variante mit dem Struct verwende, kommt die Fehlermeldung:

"use of undeclared identifier USART_initTypeDef"

Muss ich noch eine Library einbinden, damit ich das verwenden kann?
Ich verwenden Keil uVision5. "Driver_USART.h" habe ich bereits 
eingebunden.

Ich habe gesehen, das es noch das STM32CubeMX gibt, lässt sich damit 
leichter alle Treiber einbinden?

[Bert S. (kautschuck)]

Ich begreife nicht ganz, wie ich mit STM32CubeMX ein Keil Projekt öffnen 
kann. Ich müsste ja in uVision 5 folgendes Framework haben:

http://www.keil.com/pack/doc/STM32Cube/General/html/cubemx_proj.html

Dies ist bei mir nicht vorhanden und ich kann es mit dem package 
installer in Keil auch nicht installieren. Ich verwende die Keil MDK521A
und die neuste STM32CubeMX Version.

Grüsse Hans

[Bert S. (kautschuck)]

Ich habe hier nun mal meine Einstellungen im Anhang. Wie komme ich zur
stm32F30x_gpio.h library etc? Irgendwie müsste ich doch im package 
installer noch ARM:CMSIS Driver auswählen können, ich habe aber nur 
validation zur Verfügung?

[Dr. Sommer (Gast)]

Bert S. schrieb:
> Ich bin gerade am erlernen von ARM auf einem STM32F3Discovery Board.
> Die GPIO Manipulation habe ich nun verstanden und möchte mich nun dem
> USART widmen. Ich nutze folgende programming reference:
Wie man am Titel erkennt, nennt sich dieses Dokument "Reference Manual", 
nicht "programming reference". Außerdem ist das für die STM32F1 
Controller, und daher für dein STM32F3 Discovery doch etwas ungeeignet.

[Bert S. (kautschuck)]

Ich finde einfach keine Library, damit ich USART_initTypeDef, 
GPIO_initTypeDef etc. nutzen kann. Dies sollte doch standardmäßig 
vorhanden sein in der Keil MDK 5?

[Cyblord -. (cyblord)]

Bert S. schrieb:
> Ich finde einfach keine Library, damit ich USART_initTypeDef,
> GPIO_initTypeDef etc. nutzen kann.

Die nennt sich "Standard Peripheral Library" und kann von der STM32 
Seite heruntergeladen werden.

> Dies sollte doch standardmäßig
> vorhanden sein in der Keil MDK 5?

Keine Ahnung, aber ich würde mal davon ausgehen.

[Bert S. (kautschuck)]

Von dieser Seite habe ich nun das STSW-STM32118.zip runtergeladen:

http://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-eval-tools/stm32-mcu-eval-tools/stm32-mcu-discovery-kits/stm32f3discovery.html

Darin ist ein Ordner STM32F30x_StdPeriph_Driver wo ich die 
stm32f30x_gpio.c und stm32f30x_gpio.h finde.

Nun könnte man ja denken, dass man die einfach dem Projekt hinzufügen 
kann und gut ist, aber aus irgend einem Grund findet er die files nicht.

[Lothar (Gast)]

Bert S. schrieb:
> Der Einstieg ist schon ziemlich schwieriger als in AVR

Hättest nur statt STM32 einen LPC ARM zu nehmen brauchen, da ist das 
Manual übersichtlich und mit Beispielen zum Abtippen.

[W.S. (Gast)]

Bert S. schrieb:
> Ich finde einfach keine Library, damit ich USART_initTypeDef,
> GPIO_initTypeDef etc. nutzen kann. Dies sollte doch standardmäßig
> vorhanden sein in der Keil MDK 5?

Sowas ist standardmäßig NIRGENDWO vorhanden. Allenfalls hat irgendwer 
(z.B. die von ST) sowas mal geschrieben und in deren herunterladbaren 
Krempel verpackt.

Aber WOZU willst du unbedingt darauf herumreiten? Schau in das 
Referenz-Manual, dort findest du die erschöpfende Beschreibung der 
Peripherie und deren Hardware-Register nebst den dort üblichen Namen der 
Register.

Das und nur das ist es eigentlich, was von allen anderen verstanden 
werden kann, denn das Referenzmanual ist eben das, was der Name sagt: 
die Referenz.

Sämtlicher Hoppelpoppel, der woanders und mit anderen Bezeichnern 
beschrieben oder definiert ist, ist eben keinerlei Referenz.

Wie man Hardwareregister in C definieren kann und sie anschließend 
benutzen kann, habe ich dir bereits geschrieben. Also solltest du damit 
keinerlei Probleme haben. Aber den Blick in die Doku des Chips kann dir 
keiner abnehmen, das mußt du schon selber tun.

Es ist nicht auszuschließen, daß ich eine aus dem RefMan der STM32F30x 
generierte Headerdatei hier schon mal jemand anderem gepostet habe. Aber 
ich suche jetzt nicht danach. Lerne du lieber mit den Originalen 
umzugehen. Das ist auf lange Sicht das Beste, was du für dich selbst tun 
kannst.

W.S.

[Nop (Gast)]

Tja.. das ST-Zeugs erzeugt halt bei Anfängern die Illusion, sie könnten 
sich das Durcharbeiten des Reference Manuals ersparen. Eigentlich sollte 
man mit der Einstellung lieber gleich zum Arduino gehen, der ist genau 
dafür gemacht.

Sobald aber auch nur irgendwas hakt, beispielsweise weil die ST-Libs 
buggy sind, muß man nicht nur das RefMan trotzdem durcharbeiten, sondern 
auch noch die Software von ST verstehen. Diese ist wiederum keine 
Abstraction Layer, sondern eher eine Obfuscation Layer.

Und dann kommen solche Fragen dabei raus.

[Christopher J. (christopher_j23)]

Bevor du dir den HOL oder die StdPeriphlib von ST antust schau lieber 
mal in den CMSIS-Header. Das ist in deinem Fall stm32f303xc.h . Damit 
geht dann nämlich folgendes:

... schrieb:
> RCC->AHB1RSTR oder wie auch immer so ein Register heißen mag. Und da
> kannst du dann auch deine gewohnten Bitoperationen drauf ausführen.
>
> RCC ist dann ein Pointer auf die Struktur.. schreib das einfach mal hin
> und lass von der IDE nach der Definition suchen. Dann wirst du sehen,
> dass es etwas ähnliches auch für die USART gibt.. musst nur mal ein
> bischen schauen.

Im Klartext steht dort in Zeile 647

typedef struct
{
  __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
  __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
  __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
  __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */
  __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
  __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */
  __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
  __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
  __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
  __IO uint16_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
  uint16_t  RESERVED1;  /*!< Reserved, 0x26                                                 */
  __IO uint16_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
  uint16_t  RESERVED2;  /*!< Reserved, 0x2A                                                 */
} USART_TypeDef;

Dann in Zeile 836:

#define USART2              ((USART_TypeDef *) USART2_BASE)

Damit kannst du dann konkret etwas wie

USART2->CR1 = bliblablub;

machen.

Was du sinnvollerweise statt bliblablub ins Register schreibst findest 
du ab Zeile 12131 (!) in besagtem Header, sprich die ganzen 
Bitdefinitionen für die USART-Register.

Dazu dann noch das richtige RefMan von hier:
http://www.st.com/content/ccc/resource/technical/document/reference_manual/4a/19/6e/18/9d/92/43/32/DM00043574.pdf/files/DM00043574.pdf/jcr:content/translations/en.DM00043574.pdf

und schon kann das was werden.

[Bert S. (kautschuck)]

So, ich habe versucht das ganze mal ohne Libraries zu lösen, jedoch kann 
ich es nicht genau testen, da ich auf dem STM32F3Discovery die RX und TX 
Pins nicht angeschlossen habe und ich auch keinen Pegelwandler zur 
Verfügung habe. Das Board hat ja einen USB USER Anschluss, kann ich den 
irgendwie verwenden oder wie würdet ihr die USART Kommunikation mit dem 
PC Herstellen? Ich möchte mal nur einen Char senden, um zu sehen, ob es 
klappt.

Grüsse Hans

/*----------------------------------------------------------------------------
 * CMSIS-RTOS 'main' function template
 *---------------------------------------------------------------------------*/

#define osObjectsPublic                     // define objects in main module
#include "osObjects.h"                      // RTOS object definitions
#include "stm32f3xx.h"                  // Device header


/*
 * Defines
 */
 #define SYS_FREQUENCY 8000000L  //8Mhz
 
 /*
  * Global Variables
  */
  
 long baudrate=9600;
  
 //----------------------------------------------------------------------------------------------------
 void initGPIO() {     
  // initialize peripherals here
    //Activate red LED Port
    RCC->AHBENR |= RCC_AHBENR_GPIOEEN;        //enable PORTE clock
    GPIOE->MODER |= GPIO_MODER_MODER9_0;      //PORTE9 (LED red) is output
  
 }
 
 void initUSART(long baudrate) {
   long baudratio=SYS_FREQUENCY/baudrate;
   RCC->APB1ENR |= (1<<17);                                //ENABLE USART2 Clock
   USART2->CR1 &=!((1<<28)|(1<<12));                       //8-bit transmission (bit 12,28)
   USART2->CR1 |=(1<<7)|(1<<5)|(1<<3)|(1<<2)|(1<<0);      //Enable RX/TX(2,3), TX/RX Interrupt (5,7), UART Enable(0)
   USART2->CR2 &=!((1<<13)|(1<<12));                      //1 stop bit
   USART2->BRR |= baudratio;                              //set Baudrate to 9600
 }
 
 void sendChar(void const *argument) {
   while(1) {
     USART2->TDR = 'x';
     osDelay(500);
   }

 }
 
 void Blinky (void const *argument) {
   while(1){
     GPIOE->BSRRL = (1<<9);    //LED on -> BSRRL is Bit Set Reset Register -> write 1 -> high
     osDelay(250);              //250ms Delay
     GPIOE->BSRRH = (1<<9);    //LED off
     osDelay(250);
   }
 }
 
 
 osThreadDef(Blinky,osPriorityNormal,1,0);  //Define Thread on function Blinky
 osThreadDef(sendChar,osPriorityNormal,1,0);
 
 //----------------------------------------------------------------------------------------------------
 
int main (void) {
  osKernelInitialize ();                    // initialize CMSIS-RTOS
  
  //----------------------------------------------------------------------------------------------------
  initGPIO();
  initUSART(baudrate);
  //----------------------------------------------------------------------------------------------------
  
  
  // create 'thread' functions that start executing,
  // example: tid_name = osThreadCreate (osThread(name), NULL);
  osThreadCreate(osThread (Blinky),NULL);
  osThreadCreate(osThread (sendChar),NULL);
  osKernelStart ();                         // start thread execution 
}

[Bernd K. (prof7bit)]

Bert S. schrieb:
> RCC->APB1ENR |= (1<<17);                                //ENABLE
> USART2 Clock
>    USART2->CR1 &=!((1<<28)|(1<<12));                       //8-bit
> transmission (bit 12,28)
>    USART2->CR1 |=(1<<7)|(1<<5)|(1<<3)|(1<<2)|(1<<0);      //Enable
> RX/TX(2,3), TX/RX Interrupt (5,7), UART Enable(0)
>    USART2->CR2 &=!((1<<13)|(1<<12));

Das ist vollkommen grausam.

Du solltest Dir abgewöhnen solche Sachen wie 
(1<<7)|(1<<5)|(1<<3)|(1<<2)|(1<<0) direkt in den Code reinzuschreiben 
sondern stattdessen die Bitdefinitionen aus den Headern zu verwenden, 
dann kann man es sogar lesen und verstehen ohne die Kommentare am Ende 
jeder Zeile.

Ich gebe Dir ein Beispiel:

Betrachte Deine Zeile aus obigem Code wo Du schreibst:

USART2->CR1 |=(1<<7)|(1<<5)|(1<<3)|(1<<2)|(1<<0);      //Enable RX/TX(2,3), TX/RX Interrupt (5,7), UART Enable(0)

Du warst gezwungen aufgrund der Tatsache daß kein Mensch beim Lesen 
auswendig wissen kann was bits 7,5,3,2 und 0 bedeuten ohne das Manual 
aufzuschlagen einen erklärenden Kommentar hinzuzufügen. Jedoch kann der 
Compiler nicht überprüfen ob der Kommentar zu den Zahlen passt und der 
geneigte Leser (oder der der den Fehler sucht) muss auf den Verdacht hin 
trotzdem wieder jedes einzelne Bit nachschlagen, allein schon um einen 
Tippfehler auszuschließen.

Aber in den Headern sind auch die Namen für alle Bits definiert!

Jetzt schau mal wie man obige Zeile ordentlich hinschreiben kann:

    USART2->CR1 |= USART_CR1_TXEIE
                 | USART_CR1_RXNEIE
                 | USART_CR1_TE
                 | USART_CR1_RE
                 | USART_CR1_UE;

Alle Bits haben Namen! Du kannst Dir auch die Auto-Vervollständigung 
zunutze machen: Wenn Du weißt daß du das TXEIE Bit in einem der USART 
config Register setzen willst (aber vergessen hast in welchem und wie 
das genau buchstabiert wird) schreibst Du USART_ drückst Ctrl-Space und 
gehst die Liste durch. Dann steht da irgendwo USART_CR1_TXEIE, das ist 
die Bitmaske für dieses Bit in diesem Register, dann weißt Du daß Du

USART2->CR1 |= USART_CR1_TXEIE

schreiben mußt.

Probiers aus, ist ganz einfach, die haben das konsequent durchgezogen. 
Jedes Bit ist definiert nach dem selben Schema:

PERIPHERIE_REGISTERNAME_BITNAME

und Das Register selbst ist

PERIPHERIE->REGISTERNAME

also um es zu setzen:

PERIPHERIE->REGISTERNAME |= PERIPHERIE_REGISTERNAME_BITNAME

Wobei REGISTERNAME und BITNAME wortwörtlich denen im Manual 
entsprechen. Keine Zahlen mehr merken oder nachschlagen oder noch 
schlimmer: nie mehr versehentlich die falsche Zahl hinschreiben und 
stundenlang nach dem Fehler suchen weil die nackte Zahl keinen Namen hat 
und in dem nichtssagenden Zahlenwust nicht weiter auffällt.

[Bert S. (kautschuck)]

Ok, dass hatte bei mir nicht geklappt, da ich keinen Unterstrich 
verwendet habe, danke. Ich kenne diese Darstellung von AVR her und 
bevorzuge das natürlich.

[Bert S. (kautschuck)]

Ich habe das mal umgeschrieben. Jedoch sollte ich doch nach folgender 
Manual ein Signal am Port PA2 sehen, wenn USART2 sendet?

http://www.st.com/content/ccc/resource/technical/document/user_manual/8a/56/97/63/8d/56/41/73/DM00063382.pdf/files/DM00063382.pdf/jcr:content/translations/en.DM00063382.pdf

/*----------------------------------------------------------------------------
 * CMSIS-RTOS 'main' function template
 *---------------------------------------------------------------------------*/

#define osObjectsPublic                     // define objects in main module
#include "osObjects.h"                      // RTOS object definitions
#include "stm32f3xx.h"                  // Device header


/*
 * Defines
 */
 #define SYS_FREQUENCY 8000000L  //8Mhz
 
 /*
  * Global Variables
  */
  
 long baudrate=9600;
  
 //----------------------------------------------------------------------------------------------------
 void initGPIO() {     
  // initialize peripherals here
    //Activate red LED Port
    RCC->AHBENR |= RCC_AHBENR_GPIOEEN;        //enable PORTE clock
    GPIOE->MODER |= GPIO_MODER_MODER9_0;      //PORTE9 (LED red) is output
  
 }
 
 void initUSART(long baudrate) {
   long baudratio=SYS_FREQUENCY/baudrate;
   RCC->APB1ENR |= RCC_APB1ENR_USART2EN;                    //ENABLE USART2 Clock
   USART2->CR1 &=!((USART_CR1_M0)|(1<<28));                 // USART_CR1_M1 does not exist???
   USART2->CR1 |= (USART_CR1_TXEIE
                 | USART_CR1_RXNEIE
                 | USART_CR1_TE
                 | USART_CR1_RE
                 | USART_CR1_UE);
   USART2->CR2 &=!((USART_CR2_STOP_0)|(USART_CR2_STOP_1));  //1 stop bit
   USART2->BRR |= baudratio;                                //set Baudrate to 9600
 }
 
 void sendChar(void const *argument) {
   while(1) {
     USART2->TDR = 'x';
     osDelay(500);
   }

 }
 
 void Blinky (void const *argument) {
   while(1){
     GPIOE->BSRRL = GPIO_BSRR_BS_9;      //LED on -> BSRRL is Bit Set Reset Register -> write 1 -> high
     osDelay(250);                      //250ms Delay
     GPIOE->BSRRH =  GPIO_BSRR_BS_9 ;    //LED off
     osDelay(250);
   }
 }
 
 
 osThreadDef(Blinky,osPriorityNormal,1,0);  //Define Thread on function Blinky
 osThreadDef(sendChar,osPriorityNormal,1,0);
 
 //----------------------------------------------------------------------------------------------------
 
int main (void) {
  osKernelInitialize ();                    // initialize CMSIS-RTOS
  
  //----------------------------------------------------------------------------------------------------
  initGPIO();
  initUSART(baudrate);
  //----------------------------------------------------------------------------------------------------
  
  
  // create 'thread' functions that start executing,
  // example: tid_name = osThreadCreate (osThread(name), NULL);
  osThreadCreate(osThread (Blinky),NULL);
  osThreadCreate(osThread (sendChar),NULL);
  osKernelStart ();                         // start thread execution 
}

[W.S. (Gast)]

Bernd K. schrieb:
> Das ist vollkommen grausam.

Naja.. JEIN.
Ganz so grausam ist das nicht, aber dazu gehört eben etwas anderes als 
lediglich irgend eine schlimme Funktion in main.c hineinzuklatschen.

Der TO hat sich offenbar lediglich eine grauselige unsystematische Art 
angewöhnt, seine Firmware zu schreiben. Bei seinem bisherigen AVR 
scheint ihm das nicht weiter auf die Füße gefallen zu sein:

Bert S. schrieb:
> Ich bin gerade am erlernen von ARM auf einem...
>
> Nun sind hier aber die Register nicht so beschrieben, wie ich mir das
> von AVR gewohnt bin,...

Aber wenn man von einem kleinen Achtbitter auf einen ARM umsteigt, dann 
sollte man zu allererst sich wenigstens ETWAS Systematik angewöhnen.

Das heiß im Klartext, sich Hardwaretreiber zu schreiben, die den 
zugrundeliegenden Kruscht abstrahieren und kapseln und in sich die 
gesamte Funktionalität erledigen, die man braucht, um sich in höheren 
Programmschichten nicht mehr um einzelne Bits und andere niedere Dinge 
kümmern zu müssen.

Innerhalb so eines Treibers kann man dann durchaus mit (x<<7) und 
dergleichen arbeiten, denn der Bereich des Ganzen ist eingeschränkt, ist 
also eher überschaubar und normalerweise muß man da nicht wieder ran, 
wenn das Ganze erstmal ausgetestet ist.

Viel eher hätte ich da Sorgen, daß all die von dir vorgeschlagenen 
Bit-Namen-Definitionen, die man in irgend einer obskuren Headerdatei 
findet, auch wirklich so stimmen wie im RefMan gedruckt.

Weitaus grauseliger finde ich sowas:

Bert S. schrieb:
> void sendChar(void const *argument) {
>    while(1) {
>      USART2->TDR = 'x';
>      osDelay(500);
>    }

Mal abgesehen von der Form, was soll das? Sieht SO etwa eine 
ernstzunehmende serielle Schnittstelle aus?

W.S.

[Bert S. (kautschuck)]

W.S. schrieb:
> Bert S. schrieb:
>> void sendChar(void const *argument) {
>>    while(1) {
>>      USART2->TDR = 'x';
>>      osDelay(500);
>>    }
>
> Mal abgesehen von der Form, was soll das? Sieht SO etwa eine
> ernstzunehmende serielle Schnittstelle aus?

Ich wollte nur mal schauen, ob ich ein Signal am richtigen PIN empfange, 
dass soll keine Schnittstelle darstellen, doch irgendwo scheint noch 
etwas mit dem USART2 nicht zu stimmen, bekomme zumindest kein Signal am 
PIN PA2.

Ich werde natürlich vernünftige Treiber selber schreiben, aber zuerst 
mal muss ich schauen, wie genau was funktioniert, daher ist ein einfach 
gehaltenes Programm sicher sinnvoll. Zumindest die Debug Schnittstelle 
mit Hilfe des USART sollte mal laufen.

Grüse Hans

[Bert S. (kautschuck)]

Ich habe das Programm mal ein bisschen überarbeitet und noch bei GPIO 
die Clock aktiviert, bekomme aber immer noch nichts am PD2 Ausgang:

/*----------------------------------------------------------------------------
 * CMSIS-RTOS 'main' function template
 *---------------------------------------------------------------------------*/

#define osObjectsPublic                     // define objects in main module
#include "osObjects.h"                      // RTOS object definitions
#include "stm32f3xx.h"                  // Device header

/*
 * Defines
 */
 #define SYS_FREQUENCY 8000000L  //8Mhz
 
 /*
  * Global Variables
  */
  
 long baudrate=9600;

 //----------------------------------------------------------------------------------------------------
 void initGPIO() {     
  // initialize peripherals here
    //Activate red LED Port
    RCC->AHBENR |= RCC_AHBENR_GPIOEEN;        //enable PORTE clock
    RCC->AHBENR |= RCC_AHBENR_GPIOAEN;        //enable PORTE clock
    GPIOE->MODER |= GPIO_MODER_MODER9_0;      //PORTE9 (LED red) is output
 }
 
 void initUSART(long baudrate) {
   long baudratio=SYS_FREQUENCY/baudrate;
   //GPIO
   GPIOA->MODER |= GPIO_MODER_MODER2_1;      //Alternating function
   GPIOA->OTYPER &= !(GPIO_OTYPER_OT_2);
   
   //USART
   RCC->APB1ENR |= RCC_APB1ENR_USART2EN;                    //ENABLE USART2 Clock
   USART2->CR1 &=!((USART_CR1_M0)|(1<<28));                 // USART_CR1_M1 does not exist???
   USART2->CR1 |= (USART_CR1_TE 
                 |USART_CR1_TXEIE 
                 | USART_CR1_RXNEIE                            
                 | USART_CR1_RE
                 | USART_CR1_UE);
   USART2->CR2 &=!((USART_CR2_STOP_0)|(USART_CR2_STOP_1));  //1 stop bit
   USART2->BRR |= baudratio;                                //set Baudrate to 9600
 }
 
 void sendChar(char c) {
     while(!USART_ISR_TXE);
     USART2->TDR = (c & 0xFF);
     GPIOE->BSRRL = GPIO_BSRR_BS_9;      //LED on -> BSRRL is Bit Set Reset Register -> write 1 -> high
     osDelay(250);                      //250ms Delay
     GPIOE->BSRRH =  GPIO_BSRR_BS_9 ;    //LED off
     osDelay(250);
 }
 
 void sendXThread(void const *argument) {
   while(1) {
    sendChar('X');
   }
 }
 
 osThreadDef(sendXThread,osPriorityNormal,1,0);
 
 //----------------------------------------------------------------------------------------------------
 
int main (void) {
  osKernelInitialize ();                    // initialize CMSIS-RTOS
  
  //----------------------------------------------------------------------------------------------------
  initGPIO();
  initUSART(baudrate);
  //----------------------------------------------------------------------------------------------------
  
  
  // create 'thread' functions that start executing,
  // example: tid_name = osThreadCreate (osThread(name), NULL);
  osThreadCreate(osThread (sendXThread),NULL);
  osKernelStart ();                         // start thread execution 
}

[Christopher J. (christopher_j23)]

Bei den neueren Discovery und Nucleo Boards ist normalerweise immer ein 
USART mit dem ST-Link verbunden, d.h. du kannst per virtuellem COM-Port 
damit interagieren, ohne das du einen dedizierten USB-UART-Wandler 
brauchst.

Im Falle des F3 Disco ist das USART1 (Achtung, der hängt an APB2 statt 
APB1!).

Warum kein Signal kommen kann:
Du MUSST jeden einzelnen Pin den du benutzen willst, entsprechend 
konfigurieren, da (fast) alle Pins nach einem Reset als Input mit PullUp 
konfiguriert sind.

Du musst (für den Fall USART1) PA9 und PA10 entsprechend konfigurieren, 
d.h. du setzt jeweils für PA9 und PA10 GPIOA->MODER auf "alternate 
function", GPIOA->PUPDR auf "pull up" und GPIOA->AFRH auf AF7 (siehe 
Tabelle im Datenblatt S.44).

[Uwe B. (Firma: TU Darmstadt) (uwebonnes)]

Beim F3-Discovery auf die Revision aufpassen! Erst ab Board Revision C 
wird der STLink V2-1 verwendet, der CDC-ACM kann und es sind die SB13/15 
geschlossen, so dass Uart Signale an den STLink kommen.

[Bert S. (kautschuck)]

Die GPIO Pins habe ich nun so definiert (Ich glaube nach Datenblatt ist 
PC4 der TX Pin für die ST-Link USB Schnittstelle):

RCC->AHBENR |= RCC_AHBENR_GPIOCEN;        //enable PORTE clock
GPIOC->MODER |= GPIO_MODER_MODER4_1 ;      //Alternating function, for TX (PC4)
GPIOC->OTYPER &= !(GPIO_OTYPER_OT_4);
GPIOC->PUPDR |= GPIO_PUPDR_PUPDR4_0;

Doch ich bekomme immer noch kein Ausgangssignal, nur konstant 3V vom 
Pull-Up. Keine Ahnung was man noch ergänzen könnte.

Grüsse Hans

Christopher J. schrieb:
> GPIOA->AFRH auf AF7 (siehe
> Tabelle im Datenblatt S.44).

Wie genau kann ich das setzen? Bei mir scheint es GPIOA_AFRH nicht zu 
geben, es kommt die Fehlermeldung undeclared identifier.

Uwe B. schrieb:
> Erst ab Board Revision C
> wird der STLink V2-1 verwendet

Wie erkenne ich welches Board ich habe, bzw. welche Revision? SB13/15 
scheinen nicht geschlossen zu sein.

[Christopher J. (christopher_j23)]

Sorry, AFRL und AFRH sind gebündelt in AFR[2], also GPIOA->AFR[0] und 
GPIOA->AFR[1].

Dabei ist AFRL für die Pins 0-7 und AFRH für die Pins 8-15 zuständig 
(jeweils vier Bits pro Pin). AF7 bedeutet die Bits für den 
entsprechenden Pin sind 0x0111.

Bert S. schrieb:
> Die GPIO Pins habe ich nun so definiert (Ich glaube nach Datenblatt ist
> PC4 der TX Pin für die ST-Link USB Schnittstelle):

Das stimmt glaube ich so nicht.

Im User Manual des F3-Disco steht unter 6.2.3 "VCP Configuration":
> The ST-LINK/V2-B on STM32F3DISCOVERY supports virtual Com port (VCP) on U2
> pin 12 (ST-LINK_TX) and U2 pin 13 (ST-LINK_RX), which are connected to the
> STM32F303 MCU target STM32 USART1 (PA9, PA10), thanks to SB11 and SB15
> solder bridges.
> The SB11 (PA9) and SB15 (PA10) default configurations for STM32F3DISCOVERY
> are given in Table 5: Solder bridges.

Hier kannst du selber nachschauen:
http://www.st.com/content/ccc/resource/technical/document/user_manual/8a/56/97/63/8d/56/41/73/DM00063382.pdf/files/DM00063382.pdf/jcr:content/translations/en.DM00063382.pdf

Aber Uwe hat Recht, dass das erst ab Rev C der Fall ist.

Bert S. schrieb:
> Wie erkenne ich welches Board ich habe, bzw. welche Revision? SB13/15
> scheinen nicht geschlossen zu sein.

Auf den Boards ist normalerweise ein weißer Aufkleber da steht so etwas 
wie "MB1035 B-00" drauf, wobei MB1035 für das Board steht und B-00 für 
die Revision.

Bert S. schrieb:

void initUSART(long baudrate) {
   long baudratio=SYS_FREQUENCY/baudrate;
   //GPIO
   GPIOA->MODER |= GPIO_MODER_MODER2_1;      //Alternating function
   GPIOA->OTYPER &= !(GPIO_OTYPER_OT_2);

   //USART
   RCC->APB1ENR |= RCC_APB1ENR_USART2EN;                    //ENABLE USART2 Clock
   USART2->CR1 &=!((USART_CR1_M0)|(1<<28));                 // USART_CR1_M1 does not exist???
   USART2->CR1 |= (USART_CR1_TE
                 |USART_CR1_TXEIE
                 | USART_CR1_RXNEIE
                 | USART_CR1_RE
                 | USART_CR1_UE);
   USART2->CR2 &=!((USART_CR2_STOP_0)|(USART_CR2_STOP_1));  //1 stop bit
   USART2->BRR |= baudratio;                                //set Baudrate to 9600
}

Da sind noch ein paar Fehler drin:
Wenn du einem Register mit einem &= einen Wert zuweisen willst, aber das 
Register als Reset-Wert bereits 0x00000000 ist, dann wird es auch nach 
dem &= immer noch 0 sein, egal was auf der rechten Seite steht.
Außerdem darfst du nicht das logische mit dem unären ("bitwise") "Nicht" 
verwechseln (! ist nicht gleich ~).
!(bliblablub) wird immer zu Null, es sei denn bliblablub ist Null, dann 
wird es Eins.

[Bert S. (kautschuck)]

Das AF7 habe ich nun im Low Register gesetzt, doch es tut sich leider 
immer noch nichts. Die Invertierung muss natürlich bitwise sein, hatte 
das irgendwie gerade vergessen.

Christopher J. schrieb:
> Wenn du einem Register mit einem &= einen Wert zuweisen willst, aber das
> Register als Reset-Wert bereits 0x00000000 ist, dann wird es auch nach
> dem &= immer noch 0 sein

Ist das nicht das Ziel? Das Bit wird gelöscht und wenn es bereits 0 ist, 
dann bleibt es Null?

Christopher J. schrieb:
> Auf den Boards ist normalerweise ein weißer Aufkleber da steht so etwas
> wie "MB1035 B-00" drauf, wobei MB1035 für das Board steht und B-00 für
> die Revision.

Bei mir ist es also Revision B-00 (MB1035 B-00). Dann kann ich das mit 
dem ST-Link vergessen. Kaufe mir halt ein UART->USB Pegelwandler.

Muss ich vielleicht irgendwelche Register clearen? Ich hatte sowas schon 
einmal in AVR, wo alles richtig Programmiert war, aber einige Register 
mussten zuerst resetet werden.

Grüsse und Danke Hans

/*----------------------------------------------------------------------------
 * CMSIS-RTOS 'main' function template
 *---------------------------------------------------------------------------*/

#define osObjectsPublic                     // define objects in main module
#include "osObjects.h"                      // RTOS object definitions
#include "stm32f3xx.h"                  // Device header

/*
 * Defines
 */
 #define SYS_FREQUENCY 8000000L  //8Mhz
 
 /*
  * Global Variables
  */
  
 long baudrate=9600;

 //----------------------------------------------------------------------------------------------------
 void initGPIO() {     
  // initialize peripherals here
    //Activate red LED Port
    RCC->AHBENR |= RCC_AHBENR_GPIOEEN;        //enable PORTE clock
    GPIOE->MODER |= GPIO_MODER_MODER9_0;      //PORTE9 (LED red) is output
 }
 
 void initUSART(long baudrate) {
   long baudratio=SYS_FREQUENCY/baudrate;
   //GPIO
   RCC->AHBENR |= RCC_AHBENR_GPIOAEN;        //enable PORTA clock
   GPIOA->MODER |= GPIO_MODER_MODER9_1 ;    //Alternating function, for TX (PC4)
   GPIOA->OTYPER &= ~(GPIO_OTYPER_OT_9);    //Push-Pull
   GPIOA->PUPDR |= GPIO_PUPDR_PUPDR9_0;      //
   GPIOA->AFR[0] |= GPIO_AFRL_AFRL7;        //
   
   //USART
   RCC->APB2ENR |= RCC_APB2ENR_USART1EN;                    //ENABLE USART2 Clock
   USART1->CR1 &=~((USART_CR1_M0)|(1<<28));                 // USART_CR1_M1 does not exist???
   USART1->CR1 |= (USART_CR1_TE |USART_CR1_TXEIE | USART_CR1_RXNEIE| USART_CR1_RE | USART_CR1_UE);
   USART1->CR2 &=~((USART_CR2_STOP_0)|(USART_CR2_STOP_1));  //1 stop bit
   USART1->BRR |= baudratio;                                //set Baudrate to 9600
 }
 
 void sendChar(char c) {
     while(!USART_ISR_TXE);
     USART1->TDR = (c & 0xFF);
     GPIOE->BSRRL = GPIO_BSRR_BS_9;      //LED on -> BSRRL is Bit Set Reset Register -> write 1 -> high
     osDelay(250);                      //250ms Delay
     GPIOE->BSRRH =  GPIO_BSRR_BS_9 ;    //LED off
     osDelay(250);
 }
 
 void sendXThread(void const *argument) {
   while(1) {
    sendChar('X');
   }
 }
 
 osThreadDef(sendXThread,osPriorityNormal,1,0);
 
 //----------------------------------------------------------------------------------------------------
 
int main (void) {
  osKernelInitialize ();                    // initialize CMSIS-RTOS
  
  //----------------------------------------------------------------------------------------------------
  initGPIO();
  initUSART(baudrate);
  //----------------------------------------------------------------------------------------------------
  
  
  // create 'thread' functions that start executing,
  // example: tid_name = osThreadCreate (osThread(name), NULL);
  osThreadCreate(osThread (sendXThread),NULL);
  osKernelStart ();                         // start thread execution 
}

[Nico W. (nico_w)]

Bert S. schrieb:
> USART1->BRR |= baudratio;

Du brauchst den Teil nicht einlesen. Ein einfaches = reicht.

Bert S. schrieb:
> while(!USART_ISR_TXE);

Was ist das? USART_ISR_TXE? Ist das eine Funktion die sich ändern kann?
Oder suchst du doch etwas wie:

while(!(USART1->SR & USART_SR_TXE));

?

Edit: Da stimmt noch einiges mehr nicht. TX ist da. RX nicht?
UE nicht am Ende gesetzt sondern zwischen der Config?
Sicher dass du die richtigen Pin konfiguriert hast?

[Christopher J. (christopher_j23)]

Bert S. schrieb:
> GPIOA->AFR[0] |= GPIO_AFRL_AFRL7;

Die AF Register haben jeweils 4 Bit pro Pin.
GPIO_AFRL_AFRL7 ist daher die Bitmaske für Pin 7 (0xF0000000).
Wenn du das direkt ins AFRL schreibst konfigurierst du PA7 mit AF15. 
Wenn du PA2 als AF7 willst musst du (GPIO_AFRL_AFRL2 & (7U << 8)) ins 
AFRL schreiben.

Guck am besten ins RefMan Kapitel 11.4.9

[W.S. (Gast)]

Bert S. schrieb:
> Doch ich bekomme immer noch kein Ausgangssignal, nur konstant 3V vom
> Pull-Up. Keine Ahnung was man noch ergänzen könnte.

Es jammert einen!
Ich hätte nicht gedacht, daß jemand der nach eigenen Angaben geübt ist 
mit Atmels AVR's, derartig heftige Schwierigkeiten hat.

Ich hänge dir mal drei Dinge hier dran:
1. ein Beispiel, wie man seinen STM32F3.. passabel und lesbar 
konfigurieren kann
2. ein Komplett-Treiber für die U(S)ART's
3. dito für USB-VCP

Aber die Definitionen der HW-Register und solcher Dinge wie byte, word, 
dword machst du dir selber, ebenfalls den Startupcode und die 
Programmteile, die auf diese unterste Treiberebene aufbauen, also sowas 
wie eine E/A-Weiche, Kommandoprogramm und so.

W.S.

[Stefan F. (Gast)]

Ich habe das gleiche Problem, allerdings nutze ich die CMSIS und USART2 
auf einem STM32F303RE.

Am TxD Ausgang habe ich ständig High Pegel.

#include <stdio.h>
#include "stm32f3xx.h"

uint32_t SystemCoreClock=8000000;

// delay loop for 8 MHz CPU clock
void delay(uint16_t msec)
{
    for (uint32_t j=0; j<2000*msec; j++)
    {
        __NOP();
    }
}

// Redirect standard output to the serial port
int _write(int file, char *ptr, int len)
{
    for (int i=0; i<len; i++)
    {
        while(!(USART2->ISR & USART_ISR_TXE));
        USART2->TDR = *ptr++;
    }
    return len;
}

int main(void)
{
    // Enable clock for Port A
    SET_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER5,  GPIO_MODER_MODER5_0);

    // Use system clock for USART2
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);
    MODIFY_REG(RCC->CFGR3, RCC_CFGR3_USART2SW, RCC_CFGR3_USART2SW_0);

    // PA2 (TxD) shall use the alternate function 7
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFRL2, 7U<<GPIO_AFRL_AFRL2_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER2, GPIO_MODER_MODER2_1);

    // Set baudrate
    USART2->BRR = (SystemCoreClock / 115200);

    // Enable transmitter of USART2
    USART2->CR1 = USART_CR1_UE + USART_CR1_TE;    

    while (1)
    {
        // LED Pin -> High
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS_5);
        delay(500);

        puts("Hello");

        // LED Pin -> Low
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay(500);
    }
}

Ich bin langsam am verzweifeln. Das kann doch nicht so schwer sein, eine 
UART zu programmieren. Nachdem ich das bisher mit jedem AVR geschafft 
habe, komme ich mir nun richtig doof vor.

Ich habe viele Beiträge hier und in anderen Foren gefunden, wo Leute 
genau das gleiche Problem haben. Aber leider enden alle ohne Lösung.

Was mache ich falsch?

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

W.S. schrieb:
> Es jammert einen!

Ja bei deinem Magic NUmber Code mal wieder!

Bzw es graust einem bei deiner serial.c und den IRQ Handlern:

if (USART2_ISR & ((1<<5)|(1<<3)))      // RX: Zeichen empfangen

würg

[Nico W. (nico_w)]

Stefanus F. schrieb:
> // Enable transmitter of USART2
>     USART2->CR1 = USART_CR1_UE + USART_CR1_TE;

Ich würde niemals sowas hier addieren. Immer verodern.

Ggf. mag der USART ja nicht, dass er angeschmissen wird und TE im selben 
Takt angeht. Ich würde da ggf. mal zunächst TE anschmeißen und den USART 
danach erst anmachen. Nur als Idee zum suchen.

Die Register vom PA2 hast dir im Debugger auch mal angesehen? Nicht das 
dort noch Überraschungen sind (Pullup oder so?).

[Stefan F. (Gast)]

Jetzt geht es plötzlich. Vielleicht hatte ich bei vorherigen 
fehlerhaften Versuchen irgendwie die HW blockiert und das Problem 
unbewusst durch Unterbrechen der Stromversorgung gelöst.

[Stefan F. (Gast)]

Nico W. schrieb:
> Ich würde niemals sowas hier addieren. Immer verodern.

Kommt das gleiche bei heraus.

[Nico W. (nico_w)]

Stefanus F. schrieb:
> Nico W. schrieb:
>> Ich würde niemals sowas hier addieren. Immer verodern.
>
> Kommt das gleiche bei heraus.

In dem Falle schon. Ich hatte einmal etwas ähnliches und das ist mir auf 
die Füße gefallen. Letzendlich willst du ein Bit ändern. Veroderst du 
das gleiche Bit ein paar Mal ist das OK. Addieren...

[Stefan F. (Gast)]

Nico W. schrieb:
> Letzendlich willst du ein Bit ändern.

In dieser Zeile will ich wirklich alle Bits des Registers in einem 
Abwasch anfassen.

> Veroderst du das gleiche Bit ein paar Mal ist das OK.

Ok, das ist ein einleuchtendes Argument (Fehler vermeiden).

[Achim W. (walder)]

Hallo, jetzt habe ich schon viele Seite durchgesehen und leider keinen 
passenden Vorschlag gefunden.
(Ich bin nicht gut mit C und dem STM32 vertraut!!)

Zur Steuerung meiner Modelleisenbahn möchte ich den STM32F103 einsetzen.
Das Ausgeben eines Textes über TX1 funktioniert,
aber vom Terminalprogramm einen Text einlesen über RX1 nicht.

Wer oder wo kann ich hilfe bekommen ?

Vielen Dank im Voraus !

[Stefan F. (Gast)]

Achim W. schrieb:
> Wer oder wo kann ich hilfe bekommen ?

https://www.programmieraufgaben.ch/aufgabe/ringpuffer-mit-arrays/yui8z5du

Guck Dir mal die Erklärung und dann die erste Lösung in Java an, die 
erscheint mir am einfachsten. Das kannst du sicher in C umsetzen.

Hier ist es noch ausführlicher erklärt: 
https://medium.com/@charlesdobson/how-to-implement-a-simple-circular-buffer-in-c-34b7e945d30e

Wichtig ist in deinem Fall, dass die beteiligten Variablen (auch das 
Array) mit "volatile" deklariert werden. Wenn du nach "volatile isr" 
suchst, findest du jede Menge Erklärungen dazu.

[Johnny B. (johnnyb)]

Achim W. schrieb:
> Hallo, jetzt habe ich schon viele Seite durchgesehen und leider keinen
> passenden Vorschlag gefunden.
> (Ich bin nicht gut mit C und dem STM32 vertraut!!)
>
> Zur Steuerung meiner Modelleisenbahn möchte ich den STM32F103 einsetzen.
> Das Ausgeben eines Textes über TX1 funktioniert,
> aber vom Terminalprogramm einen Text einlesen über RX1 nicht.
>
> Wer oder wo kann ich hilfe bekommen ?

Für folgende Aussagen werde ich jetzt vielleicht gesteinigt, aber egal:

Wenn Du neu bei STM32 bist, dann würde ich die Entwicklungsumgebung von 
ST nehmen, also STM32CubeIDE.
Die startest Du, machst ein neues STM32 Projekt (mit HAL), wählst den 
richtigen STM32F103 und konfigurierst alle Peripherie im integrierten 
CubeMX und erzeugst den Code. Dann hast Du schonmal ein funktionierendes 
Grundgerüst.

Hier gibts dazu haufenweise Trainingsmaterial:
https://www.st.com/content/st_com/en/support/learning/stm32-education/stm32-moocs.html

Wenn Du das ganze ohne HAL machen willst, dann würde ich mir das für 
etwas später aufheben, wenn Du Dich ein wenig besser mit STM32 
auskennst.