STM32F103 Dateneingabe über USART in PuTTy

Wirf doch mal einen Blick in das Beispiel Projekt:

~/STM32Cube/Repository/STM32Cube_FW_F1_V1.8.3/Projects/STM32F103RB-Nucle 
o/Examples_MIX/UART/UART_HyperTerminal_TxPolling_RxIT

Irgendwie hilft mir das nicht weiter, gibt´s dazu noch ne Alternative, 
welche eventuell auch erklärt was genau gemacht wird? Stehe da leider 
ziemlich sehr auf dem Schlauch

Hmm.
In der readme.txt und in der main.c stehen eigentlich alle nötigen 
Kommentare.
Wie sieht es mit deinem Englisch aus?

Vielleicht solltest Du nur erste einmal senden und dich dann mit den 
Interrupts beschäftigen....

Das ist ganz einfach. Du liest erstmal das Datenblatt damit du schlau 
wirst.

Dann programmierst du die RS232 so das sie bei jedem empfangenen Zeigen 
einen Interrupt macht. Das testet du dann.

Dann programmierst du dir eine FIFO. Deine Interruptfunktion wirft dann 
jedesmal wenn sie etwas empfangen hat dieses Byte in die Fifo. Eventuell 
setzt du noch ein Flag sobald einem CRLF empfangen wurde.

In deinem Hauptprogramm kuckst du nur ob irgendwann mal das Flag gesetzt 
ist, und liesst dann die Fifo bis zum CLRF aus.

Das was du dann als naechstes braucht nennt man Parser. Sowas kannst du 
entweder selber programmieren, oder von tools (flex/bison) fertig 
programmieren lassen.

Olaf

Olaf schrieb:
> Das was du dann als naechstes braucht nennt man Parser. Sowas kannst du
> entweder selber programmieren, oder von tools (flex/bison) fertig
> programmieren lassen.

Entschuldigung, wenn ich Thread kapere.

Gibt es Beispiele im Netz für einfache Anwendungen im 
Mikrocontrollerbereich?

Und dann machst du das ganze "ordentlich" mit der HAL und staunst 
darüber, dass die HAL alles nur noch komplizierter macht.

Tobi schrieb:
> Mein Ziel ist es Daten über PuTTy via UART einzugeben (Nen String mit
> Zeichen o. allgemein irgendwelche Werte) und ich benutze das Nucleo-64
> Board mit dem STM32F103.
>
> Ich hab schon probiert über den HAL_UART_Receive Befehl Daten in PuTTy
> einzulesen nur leider ohne Erfolg..

Hä? HAL-Uart-_Receive_ und Daten ---> Putty?

Das alles hängt doch wirklich NUR davon ab, was du in deiner 
selbstgeschriebenen Firmware so tust (oder auch vergessen hast) - 
vorausgesetzt, dein Putty oder was auch immer und dein OS und dein PC 
funktionieren so, wie sie sollen.

Also ganz generell zum Verfahren:
1. du drückst auf ne Taste, z.B. auf das 'A'.
2. dein Terminalprogramm nimmt das A als Tastendruck entgegen und sendet 
dieses A über's OS auf deine serielle Strippe hinaus in die Welt. (Ob da 
zwischendurchnoch irgend ein USB/Seriell-Konverter dazwischen ist, ist 
für's prinzip egal)
3. dein µC (genauer: der UART-Peripheriecore auf dem Silizium) empfängt 
das A und packt es in eines seiner Register
4. dein selbstgeschriebenes Programm kriegt mit, daß da was angekommen 
ist und liest das Register aus.
5. Dann hast du das A in deinem Programm und kannst nun überlegen, was 
du damit tun willst.
Zum Beispiel:
6. du stopfst dieses A in das Senderegister deines UART's
7. der UART sendet nun das A auf der seriellen Strippe hinaus in die 
Welt
8. dein PC empfängt das A und packt es in einen zum geöffneten Stream 
gehörigen Puffer des OS
9. dein Terminalprogramm schaut bein OS nach, ob da etwas empfangen 
wurde und läßt sich vom OS den Pufferinhalt liefern und zeigt dann das A 
auf deinem Display an.

So.
Verfahren kapiert?

Wenn es irgendwo hakt, dann kann das an irgend einer Stelle 1..9 
passieren.
Zum testen der PC-Seite kann man an der seriellen Strippe anstelle 
deines µC einfach mal ne Kurzschlußbrücke zwischen TxD und RxD 
einsetzen. Dann müßte alles, was du in deinem Terminalprogramm sendest 
postwendend auch auf deinem Display erscheinen (außer die Fluß-Steuerung 
ist falsch konfiguriert). Wenn das so ist, dann liegt es NUR an deinem 
µC.

Und fertige Projekte mit dem STM32F103 gibt es hier genug, mußt bloß man 
danach suchen. Ich hab z.B. sowas für den STM32F103C8T6 gepostet, auch 
mit fertigem Hexfile zum direkten Draufprogrammieren.

Mein wirklich dringender Rat ist, um sowas wie Cube einen Bogen zu 
machen und stattdessen zu lernen, es SELBST zu verstehen und zu machen.

W.S.

Stefan ⛄ F. schrieb:
> Und dann machst du das ganze "ordentlich" mit der HAL

Was bittesehr ist bei HAL von ST denn ordentlich? Das wirklich EINZIGE, 
was damit 'ordentlich' gemacht wurde ist, daß man damit mit der Nase an 
die Galeere von ST genagelt worden ist.

W.S.

Tobi,

verwende zunächst CubeMX und HAL, bis du gut und schnell damit arbeiten 
kannst.
Erst danach auf Registerebene gehen.
Was immer W.S. oder Stefanus schreiben: Deren Rat kannst du beherzigen, 
nach dem du die ST-Tools kennst und beherrschst - falls du die 
Weisheiten der beiden dann überhaupt noch ernst nimmst (was ich 
bezweifle).

brother schrieb:
> verwende zunächst CubeMX und HAL, bis du gut und schnell damit arbeiten
> kannst.

Das meinst du sicher nur gut, aber gerade bei der Anwendung des TO 
macht die HAL alles nur noch viel komplizierter.

[flex]
> Gibt es Beispiele im Netz für einfache Anwendungen im
> Mikrocontrollerbereich?

Es gibt sicher bergeweise Beispiele fuer Flex und dann hat flex 
natuerlich auch eine Manpage. Keine grosse Sache. Beim erstenmal braucht 
man bestimmt 1-2h laenger bis man die Idee dahinter begriffen hat. Aber 
danach ist es megacool wenn man einen neuen Befehl in seinen Parser 
einfuegt und nur einfach einmal Flex aufruft und der dann deine Funktion 
mit dem richtigen Parameter fuer dich aufruft.

Ich hab das schonmal fuer ein kleines Diagnoseinterface gemacht. Kann 
ich echt empfehlen.

Olaf

https://www.youtube.com/watch?v=f3NG7BJHXyU

In diesem Video macht der genau was Du möchtest.
Zeichen senden und empfangen.

Jeweils eine Funktion und ein Puffer.

Ist zwar Keil, aber das Watch Fenster hat CubeIDE auch.

pegel schrieb:
> In diesem Video macht der genau was Du möchtest.

Das sieht auf den ersten Blick gut aus. Die Funktion die er dort zeigt 
nutzt allerdings weder DMA noch Interrupts. Daraus folgt der Nachteil, 
dass der Mikrocontroller nur dann "zuhört" während diese receive 
Funktion läuft.

Wenn er gerade mit etwas anderem beschäftigt ist (z.B. eine Display 
Ausgabe), kann er sich nur das letzte Zeichen merken. Die anderen 
Zeichen von davor vergisst er.

Die Frage der Fragen ist nun, ob das für die Anwendung des Tobi relevant 
ist. Muss der Mikrocontroller "zuhören" können, während er mit etwas 
anderem beschäftigt ist?

E C H O

1

if(USART2_ISR_bit.RXNE){

2

  c = USART2_RDR;

3

  USART2_TDR = c;

4

}

Völlig ohne HAL!
Jetzt nur noch einen Parser darum basteln.

Und ohne Utube!