hallo,
ich habe mich als oldtimer mit wenig englisch kenntnissen an den
bluepill getraut. eigentlich eine einfache sache, dachte ich. den mega
mit der arduino ide kenne ich schon ein wenig. testboard zusammen
gelötet und ein blink programm auf einen unbenutzten port mit st-link
geflasht, gestartet und nichts passiert. schnell (langsam) habe ich
rausgefunden, das einige pins schon vorbelegt sind. alleine damit der
sw-jtak funktioniert muss er mit dem pins verbunden werden. ich möchte
aber, das mir alle pins, außer die zwei sw-jtak pins pa13/pa14, als pins
zur verfügung stehen. in einigen dingen wurde die arduino ide beim stm32
begrenzt. es gibt zb kein stm32 header. Ein teil der pin software wurde
in die gpio.h gesteckt. nun sollte es doch für so eine ide ein befehl
geben, wo alle peripherie bausteine nach einander an oder abgeschaltet
werden, um so die pins nach belieben zu benutzen. diesen habe ich nicht
finden können. genau so einfach sollte die mehrfach nutzung der pins
scallierbar sein. wobei bei der mehrfachnutzung, die gpio.h noch etwas
hergibt.
als andere möglichkeit, um mein ziel umzusetzen, viel mir der inline
assembler ein, der auch zu funktionieren scheint. nur ein dokument mit
über 1000 seiten aufzuarbeiten und das in englisch scheint mir ein wenig
aufwendig. da ich bei soviel verkauften stm32 bestimmt nicht der erste
bin, der mit diesem problem zu kämpfen hat, würde ich mich über dieses
wissen freuen.
ein paar eckdaten die feststehen:
stm32f103 bluepill
sw-jtak
arduino ide 1.8.5
alle pins außer pa13, pa14 sollen zur freien verwendung sein.
auch kein usb.
hat jemand eine idee?
die idee von der arduino ide finde ich gut.
nur das diese von dritten, mit halben sachen verhunst wird, ist keine
gute idee. bei nicht funktionieren, wird die arduino ide von anfängern
in die ecke geschmissen und als etwas nicht funktionierendes abgetan.
bei den boards aus eigenem hause funktioniert die arduino ide aber sehr
gut. eine atmel cpu kann sogar dank avr-header alleine in c, ohne
arduino overhead programmiert werden. einfach setup und loop weglassen.
dann main aber nicht vergessen.
Bitte blamiere uns "Oldtimer" nicht.
Wir haben Groß- und Kleinschreibung noch gelernt.
Um heraus zu finden, was an den Pins verbaut ist, am besten in den
Schaltplan schauen:
http://wiki.stm32duino.com/images/c/c1/Vcc-gnd.com-STM32F103C8-schematic.pdf
Dann merkst du, dass nicht viel "Sinnloses" verbaut wurde.
Wenn die Pins nicht reichen, nimm einfach das nächst größere Board.
Muss es unbedingt Ardu* sein?
Siegfried S. schrieb:> hat jemand eine idee?
Dein Text ist inhaltlich als auch vom Erscheinungsbild her
(Gross/Kleinschreibung) dermassen anstrengend dass ich nicht
gewillt bin darauf einzugehen.
Leider schaffst du es auch nicht dein Problem klar und deutlich
darzulegen dass man gezielt mit ein paar wenigen Sätzen darauf
eingehen könnte.
Vielleicht macht sich jemand anders die Mühe. Ich jedenfalls nicht.
Hallo,
vom sinnlosen verbauen habe ich nicht geschrieben. Ich möchte nur, das
meine vielen Pins nicht mehr vorbelegt sind. Die Datenblätter habe ich
alle.
Hallo,
ich habe mich als Oldtimer mit wenig englisch Kenntnissen an den
bluepill getraut. Eigentlich eine einfache Sache, dachte ich. Den Mega
mit der Arduino Ide kenne ich schon ein wenig. Testboard zusammen
gelötet und ein blink Programm auf einen unbenutzten Pin mit ST-LINK
geflasht, gestartet und nichts passiert. Schnell (langsam) habe ich
rausgefunden, das einige Pins schon vorbelegt sind. Alleine damit der
SW-JTAG funktioniert muss er mit dem Pins verbunden werden. Ich möchte
aber, das mir alle Pins, außer die zwei SW-JTAG Pins Pa13/Pa14, als Pins
zur Verfügung stehen. In einigen Dingen wurde die Arduino Ide beim STM32
begrenzt. Es gibt zb kein STM32 Header. Ein Teil der Pin Software wurde
in die gpio.h gesteckt. Nun sollte es doch für so eine Ide einen Befehl
geben, wo alle peripherie Bausteine (SPI, I2C, UART usw.) nach einander
an oder abgeschaltet werden, um so die Pins nach belieben zu benutzen.
Diesen habe ich nicht finden können. Genau so einfach sollte die
Mehrfachnutzung der Pins scallierbar sein. Wobei bei der
Mehrfachnutzung, die gpio.h noch etwas hergibt.
Als andere Möglichkeit, um mein Ziel umzusetzen, viel mir der inline
Assembler ein, der auch zu funktionieren scheint. Nur ein Dokument mit
über 1000 Seiten aufzuarbeiten und das in englisch scheint mir ein wenig
aufwendig. Da ich bei soviel verkauften STM32 bestimmt nicht der erste
bin, der mit diesem Problem zu kämpfen hat, würde ich mich über dieses
wissen freuen.
ein paar Eckdaten die feststehen:
STM32F103 Bluepill
SW-JTAK
Arduino Ide 1.8.5
Alle Pins außer Pa13, Pa14 sollen zur freien Verwendung sein.
Auch kein USB.
Hat jemand eine Idee?
Das ist doch absurd, Arduino soll die Entwicklung vereinfachen und
stellt dafür einiges vorgekaut zur Verfügung. Wenn man das kastriert
bleibt eine schlechte IDE und maximal ein einfaches Buildsystem.
Wenn man Arduino nicht braucht nimmt ein leeres main.c(pp) und legt los.
Oder CubeMX, libopencm3, mbed oder andere Libs.
Du meinst also nur die Ardu* Definition für das Bord?
Wenn du den STM32 verstehen willst und nicht von dem Ardu Zeugs abhängig
sein willst, wäre es nicht besser ein Tutorial durch zu arbeiten?
z.B. http://diller-technologies.de/stm32.html
Es gibt mittlerweile auch viele andere davon.
Siegfried S. schrieb:> Nur ein Dokument mit> über 1000 Seiten aufzuarbeiten und das in englisch scheint mir ein wenig> aufwendig.
Daran führt kein Weg vorbei.
Siegfried S. schrieb:> Da ich bei soviel verkauften STM32 bestimmt nicht der erste> bin, der mit diesem Problem zu kämpfen hat, würde ich mich über dieses> wissen freuen.
Dann musst du dir das erarbeiten - so, wie alle Anderen auch.
Schmeiss als erstes den Arduino-Quatsch weg und installier dir Atollic
TrueStudio!
Das gibts hier:
https://atollic.com/
Und hier einige Tutorials dazu:
https://www.youtube.com/channel/UCZ5tf8T8odmacEAOpw68guA
Tja, und ohne Englisch geht nun mal bei dem Thema gar nix.
Schau Dir meine Notizen zu diesem Chip/Board an.
http://stefanfrings.de/stm32/index.html
Da gibt es ziemlich weit unten auch einen Hinweis, wie du mit dem
Arduino Framework die SWJ Schnittstelle deaktivieren kannst.
Wirf den arduino Quatsch über Bord und nimm eine richtige IDE. Für stm32
gibt's die sw4stm32 auf eclipse Basis. Falls noch etwas mehr klickibunti
gebraucht wird nimm stm32cube zur Konfiguration. Das kann direkt
sw4stm32 Projekte erzeugen.
Ich denke, das Arduino für erste schnelle Erfolge ganz nett ist.
Die STM32 Mikrocontroller können vieles, was in Arduino nicht vorgesehen
ist. Daraus würde ich allerdings nicht ableiten, dass Arduino für den
Anfang schon eine schlechte Wahl ist. Mein Laptop kann auch vieles, was
ich nicht nutze. Und erst der Fernseher! Dessen Funktionen habe ich nach
10 Jahren immer noch nicht erforscht, da ich ihn nur als Bildschirm für
Spielkosole und Receiver benötige.
Ich erlebe diesbezüglich gerade einen Generationskonflikt. Ich (Ü40)
habe zuerst die Grundlagen gelernt. Erst danach wurden µC (samt
Arbeitswerkzeuge) für mein Budget erschwinglich. Ich kannte die Theorie
schon lange bevor ich mein erstes Programm schrieb.
Das Lernen der Theorie war kein Zuckerschlecken. Es war Bestandteil
meiner Berufsausbildung. Allein die Erwartung, dieses Wissen später
sowohl im Beruf als auch im Hobby anwenden zu können, motivierte mich
dazu, den trockenen Stoff zu lernen.
Jetzt wachsen neue Hobbyelektroniker nach, die sich µC (samt
Arbeitswerkzeuge) schon im Teenager Alter vom Taschengeld leisten
können. Die wollen auch ohne vorher 2 Jahre Grundlagen zu lernen etwas
beeindruckendes mit µC bauen. Und genau da ist Arduino extrem hilfreich.
Wer weiter in die Tiefe gehen möchte, dem genügt anfangs die Erkenntnis,
dass Arduino ein wenig beschränkt ist. Trotzdem (oder gerade deswegen)
ist es für den Anfang nicht schlecht.
Stefanus F. schrieb:> Jetzt wachsen neue Hobbyelektroniker nach, die sich µC (samt> Arbeitswerkzeuge) schon im Teenager Alter vom Taschengeld leisten> können.
Teuer waren µC + Tools auch vor 20 Jahren nicht.
Eine Hand voll Drähte an eine D-SUB 25 Stecker gelötet - und schon gings
los!
offline schrieb:> Teuer waren µC + Tools auch vor 20 Jahren nicht.> Eine Hand voll Drähte an eine D-SUB 25 Stecker gelötet - und schon gings> los!
Als ich Ende der 70er meine ersten Z80-Boards gelötet hab, waren da aber
locker >100DM an Bauteilen verbaut...
Für einen Lehrlings-Lohn war das schon signifikant.
Zu der zeit entsprach das > 50 Bier.
Eine kompl. Arduino-Entwicklungsumgebung bekommt man heute für den
Gegenwert von 4 Bier.
Harry L. schrieb:> Als ich Ende der 70er meine ersten Z80-Boards gelötet hab, waren da aber> locker >100DM an Bauteilen verbaut...
Ja, genau.
Aber das waren CPUs, keine uC, da kam noch RAM, EEPROM, PIO etc. dazu
- und jedes Teil einzeln war meistens teurer als die CPU...
Dazu noch jede Menge TTL Gatter für die Adressierung und Ausgabe...
Damals brauchte man ein eprom Programmiergerät und eine Löschlampe.
Alleine diese beiden Teile kosteten mehr als ein Heimcomputer.
Oder man nutzte einen professionellen Rom Simulator, der war aber noch
teurer und benötigte einen PC, was damals einem Monatsgehalt entsprach.
Und man musste Assembler lernen, weil Compiler wieder hunderte Mark
kosteten.
So war das zu meiner Jugend Zeit vor 35 Jahren.
In meiner Anfangszeit gab es noch keine Compiler.
Mein erster Eprommer bestand aus einer Box mit 10 Schaltern für die
Adressen, 8 Schaltern für die Daten und einem "Roten Knopf" um ein Byte
zu schreiben.
Gelöscht wurden die Eproms unter der Höhensonne meiner Mutter.
Das war ca. 1978.
1 RAM (1kx1) kostet 12,50 DM und davon brauchte ich 16 Stück (2kB)
Harry L. schrieb:> Das war ca. 1978.
Ich kann all deinen Ausführungen nur zustimmen.
Heute bekommt man für 50DM bzw. 25€ einen ST-Link mit 10 Stück BluePill
Boards.
Jedes einzelne leistet mehr als alle damaligen Eigenbauten zusammen.
Oder man denke gar an die Kameras!
Aber der Bastelspaß ist dabei trotzdem schon irgendwie auf der Strecke
geblieben. :(
Sättigung ist auch kein glücklich machendes Ziel.
Wie wird es der heutige Basteljugend einst ergehen?
Danke für eure Ausschweife, das löst aber mein Problem nicht. Kann von
euch einer mit gcc arm inline Assembler in C programmieren? Eine
schreibe und eine lese Routine für die stm32 Register. Für so etwas
änliches wie ein HEX-Dumper mit der Möglichkeit der Änderung.
> Danke für eure Ausschweife, das löst aber mein Problem nicht.
Hast du meinen Vorschlag übersehen (verweis auf meine Homepage)?
1
voidsetup()
2
{
3
// Disable both SWD and JTAG to free PA13, PA14, PA15, PB3 and PB4
4
afio_cfg_debug_ports(AFIO_DEBUG_NONE);
5
6
or:
7
8
// Disable JTAG only to free PA15, PB3 and PB4. SWD remains active
9
afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY);
10
}
Wenn das nicht die Lösung ist, dann haben wir Dich hier wohl alle
missverstanden. Dann erkläre nochmal, was du willst.
> Eine schreibe und eine lese Routine für die stm32 Register.
Das ist auch wieder unklar formuliert. Es gibt ARM CPU Register und
Register von der Peripherie. Ich halte es für sinnlos, innerhalb eines C
Programms direkt auf die CPU Register zuzugreifen. Damit schießt du Dir
nur ins eigene Knie.
Auf die Peripherie-Register kannst du mit C einfach direkt zugreifen,
mit der gleichen Syntax als wären es Variablen (bzw. Strukturen). Zum
Beispiel:
1
uint16_tread_adc1_result()
2
{
3
returnADC1->DR&0b111111111111;
4
}
Allerdings solltest du das Konfigurieren der Peripherie schon komplett
dem Arduino Framework überlassen. Das Arduino Framework geht davon aus,
dass es ganz alleine die volle Kontrolle über den gesamten
Mikrocontroller hat.
Wenn du dazwischen funkst, provozierst du unerwartete Seiteneffekte. Die
bekommst du nur im Griff, indem du dich mit dem Referenzhandbuch des
Mikrocontrollers und dem Quelltext des Arduino Frameworks auseinander
setzt. Wer so weit ist, das zu beherrschen, der kann auch gleich auf
Arduino verzichten.
Du hast geschrieben, dass du nicht 1000 Seiten Doku lesen willst -
verständlich. Aber wenn du dich nicht mit den Beschränkungen von Arduino
zufrieden geben willst, kommst du nicht drum herum. Die Zeiten, wo
Verlage wie Verlage wie Elektor und Data Becker ganze Referenzhandbücher
auf deutsch übersetzten und als Buch verkauften sind definitiv vorbei.
Selbst deutsche Hersteller schreiben keine deutschen Datenblätter mehr
(bei Siemens war das zu meiner Teenagerzeit noch so, fand ich super).
Oder du verwendest einfachere AVR Mikrocontroller, da gibt es dann auch
weniger zu lesen.
> alle pins ... sollen zur freien verwendung sein. auch kein usb.
Der USB Port ist im Arduino Framework fest verankert. Den wirst du nicht
los, keine Chance.
> nur das diese (Arduino IDE) von dritten, mit halben sachen> verhunst wird, ist keine gute idee
Das Risiko hast du generell immer, wenn du ein Quell-offenes System mit
Plugins erweiterst, die nicht unter der Projektleitung stehen.
Es steht Dir frei, stattdessen die Closed-source Software zum Beispiel
von Keil zu benutzen. Man beachte den Preis.
Oder Software von ST, also Cube MX und Atollic Studio. Nur möchte ich
dich warnen: Diese Kombi ist viel komplizierter als Arduino und läuft
auch nicht 100% rund. Denn das Atollic Studio basiert auf Eclipse mit
zahlreichen third-party Plugins. Da hast du ein ähnliches
Ausfall-/Fehler-Risiko, wie mit der Arduino IDE. Es steht ST oben drauf,
aber nur ein winzig kleiner Bruchteil der Software kommt wirklich von ST
(bzw. von Atollic).
Zudem musst du dann NOCH MEHR lesen, nämlich das Referenzhandbuch des
Mikrocontroller UND die Doku der Cube HAL Library.
Bei Arduino ist das anders, da kommt man ohne Referenzhandbuch NUR mit
der kurzen knappen Arduino Doku recht weit.
>> Testboard zusammen
gelötet und ein blink Programm auf einen unbenutzten Pin mit ST-LINK
geflasht, gestartet und nichts passiert.
Was muss man bei einem bluepill löten? Die pins für den
Programmieradapter?
Wo ist das Programm? Welche ide?
Was heißt "nichts passiert"?
Bevor du eine neue Programmierumgebung entwickelst, solltest du
vielleicht den Fehler eingrenzen.
Ich tippe mal so ins Blaue auf Schreibschutz.
Stefanus F. schrieb:> Wenn das nicht die Lösung ist, dann haben wir Dich hier wohl alle> missverstanden.
Dann lies mal was der TO haben wollte, gerade JTAG/SWD sollte als eines
der wenigen Features bestehen bleiben.
Hallo grundschüler,
obwohl die Problembeschreibung ein bisschen undeutlich ist, hat
Siegfried S. alle deine Fragen schon im Eröffnungsbeitrag beantwortet.
Lies ihn nochmal.
> Was muss man bei einem bluepill löten?
Die Stiftleisten und (optional) den USB Pull-Up Widerstand korrigieren.
> Wo ist das Programm?
Spielt keine Rolle, er hat sein Problem (für USB und JTAG reservierte
Pins) ausreichend beschrieben.
> Welche ide?
Arduino.
> Was heißt "nichts passiert"?
Na was wohl: die LED blinkt nicht.
> Ich tippe mal so ins Blaue auf Schreibschutz.
Dann hätte er das Programm nicht hochladen können. Die Arduino IDE ist
ja doof, aber DAS hätte sie erkannt und gemeldet.
Ich schätze, du kennst die Arduino Erweiterung für den STM32F1 nicht.
Dann kannst du dem TO nicht helfen.
>> Wenn das nicht die Lösung ist, dann haben wir Dich hier wohl alle>> missverstanden.> Dann lies mal was der TO haben wollte, gerade JTAG/SWD sollte als eines> der wenigen Features bestehen bleiben.
Nein, er möchte nur JTAG deaktivieren aber die SWD Schnittstelle
beibehalten, und genau dafür habe ich eine Lösung präsentiert. Nur bei
USB muss ich passen, habe ich aber auch geschrieben.
Stefanus F. schrieb:> Nein, er möchte nur JTAG deaktivieren
das interpretiere ich anders, finde ich ziemlich eindeutig:
‚ich möchte aber, das mir alle pins, außer die zwei sw-jtak pins
pa13/pa14, als pins zur verfügung stehen‘
Danke für die vielen Antworten.
Die Seiten von
z.B. http://diller-technologies.de/stm32.html
und
http://stefanfrings.de/stm32/index.html
sind nicht schlecht.
Aber meine Eckdaten sind nun mal Arduino IDE 1.8.5
Nur SW-JTAK bleibt SW-JTAK, damit ich flashen kann.
Alle weiteren GPIO-Pins zur freien Verfügung.
Quasie wie neu, aus der Schmelze, ohne Voreinstellungen.
Die Arduino IDE
hat einen eingeschränkten Zugriff auf die C-Konstanten für STM32.
Meine Idee: Erst einmal den Zugriff auf die STM32 Hardware verschaffen.
Das geht mit den inline Assembler.
Ich weiß nur noch nicht wie.
Meine ersten Versuche:
void write_reg (uint32_t adresse, uint32_t wert) {
asm
(
"adr r1, %0 "
"ldr r2, [r1] " // r2 == adresse
"adr r1, %1 "
"ldr r3, [r1] " // r3 == wert
"str r3, [r2] " // store r3 nach Zeiger r2
);
}
uint32_t read_reg (uint32_t adresse) {
uint32_t data;
asm
(
"adr r1, adresse " // Lade in r1 den Zeiger auf adresse
"ldr r2, [r1] " // lade in r2 die adresse
"adr r1, data " // Lade in r1 den Zeiger auf data
"ldr r3, [r2] " // lade in r3 den Inhalt von der adresse
"str r3, [r1] " // store r3 nach Zeiger in r2 (data)
);
return data; // gebe den register wert über data zurück
}
Leider ist da noch der Wurm drinn
Stefanus F. schrieb:> Ich schätze, du kennst die Arduino Erweiterung für den STM32F1 nicht.> Dann kannst du dem TO nicht helfen.
Nein kenn ich nicht. Problemanalyse sehe ich aber auch nicht:
Jammer Lappen schrieb:> Leider schaffst du es auch nicht dein Problem klar und deutlich> darzulegen dass man gezielt mit ein paar wenigen Sätzen darauf> eingehen könnte.
völlig zutreffend.
Du unterstellst ein korrektes Programm, funktionierende ide und
erfolgreiches flashen.
Ich hab da Zweifel weil es dann ja wohl blinken müsste. Irgendeine
deiner Unterstellungen ist möglicherweise unzutreffend. Weiter kann ich
dem TO tatsächlich nicht helfen.
>> Nein, er möchte nur JTAG deaktivieren> das interpretiere ich anders, finde ich ziemlich eindeutig:>>> ich möchte aber, das mir alle pins, außer die zwei sw-jtak pins>>> pa13/pa14, als pins zur verfügung stehen
PA13 und PA14 sind die beiden Pins für das SWD Protokoll.
Die anderen Pins kommen für JTAG noch dazu, aber die will er frei
bekommen. ALso JTAG deaktivieren.
> Nur SW-JTAK bleibt SW-JTAK, damit ich flashen kann.
Es gibt kein SW-JATK.
Die Schnittstelle heißt SWJ. Sie unterstützt zwei Protokolle: JTAG und
SWD. Du willst SWD mit einem ST-Link Adapter benutzen.
> http://stefanfrings.de/stm32/index.html sind nicht schlecht.
Dann lies sie auch, da steht das nämlich deutlich drin.
> Alle weiteren GPIO-Pins zur freien Verfügung.
Das ist kein richtiger Satz. Ist das eine Frage, ein Wunsch oder eine
Feststellung? Und inwiefern passt das zu meiner obigen Aussage bezüglich
USB im Arduino Framework?
> Die Arduino IDE hat einen eingeschränkten Zugriff auf die C-Konstanten> für STM32.
Das stimmt nicht. Alle Konstanten stehen zur Verfügung.
> Quasie wie neu, aus der Schmelze, ohne Voreinstellungen.
Geht bei Arduino nicht. Arduino beruht auf der Idee, für Anfänger
sinnvolle Voreinstellungen festzulegen. Wenn Dir das nicht gefällt, hast
du das falsche Framework gewählt. Aber auch das hatten mehrere Leute
bereits mehrfach geschrieben.
> Meine Idee:> Erst einmal den Zugriff auf die STM32 Hardware verschaffen.> Das geht mit den inline Assembler.
Dann musst du auf Arduino verzichten. Das geht auch mit normalem C (ohne
Tricks). Außerdem enthalten bnormale C Projekte einen Startup-Code in
Assembler, den du editieren kannst.
Auch das habe ich weiter oben und auf meiner Notizen-Seite geschrieben.
Hast du unsere Antworten überhaupt gelesen? Ich habe das Gefühl, dass du
sie nur kurz überflogen hast. Passt dazu, dass du keine 1000 Seiten
Referenzhandbuch lesen magst. Da musst du aber durch, wirklich. Lesen,
Lesen, Lesen! Sonst wirst du mit ARM Controllern nicht glücklich.
Also lies die Antworten und meine Notizen dreimal durch und probiere die
Sachen aus. Danach kannst du bessere Fragen stellen.
Siegfried S. schrieb:> ein paar eckdaten die feststehen:> stm32f103 bluepill> sw-jtak> arduino ide 1.8.5> alle pins außer pa13, pa14 sollen zur freien verwendung sein.> auch kein usb.>> hat jemand eine idee?
Natürlich habe ich Ideen dazu.
Aber die setzen voraus, daß du dich besinnst und deine feststehenden
Eckdaten erstmal aufweichst, so daß sie nicht mehr feststehen, sondern
diskutabel werden. Was nicht diskutabel ist, ist hier auch nicht weiter
verhandelbar.
Als erstes vergiss das Benutzen von Inline-Assembler. Laß sowas
komplettissimo bleiben. Lade dir stattdessen mal das herunter:
https://www.mikrocontroller.net/attachment/316790/STM32F103C8T6.ZIP
und lies dort drin, wie man direkt in C auf die Peripherie zugreift.
Und wenn du schon dabei bist, dir den Inhalt dieser Zipdatei anzugucken,
dann kannst du auch mal das dort fertig übersetzte Hexfile in deinen
Chip brennen und dir angucken, wie sich das am USB als virtueller
COM-Port benimmt. Wie man zur passenden .inf kommt, steht in der usb.h
drin.
Mit sowas hast du wenigstens erstmal eine Basis, mit der du vom PC aus
kommunizieren kannst. Als nächstes guck dir an, wie du dort in config.c
alle deine Ports nach deinem Gutdünken aufsetzen kannst. Und vergiß
die STM32F103all.h nicht, die brauchst du zum Zugriff auf die Hardware.
Und lerne soviel Englisch, daß du die Dokumentation zum Chip lesen
kannst. Es wird dir heutzutage niemand sowas ins Deutsche übersetzen.
W.S.
> Lade dir stattdessen mal das herunter
Er will den USB Anschluss doch gar nicht als USB benutzen.
Abgesehen davon empfehle ich deinen Code auch auf meiner Webseite. Die
muss er nur mal lesen.
Stefanus F. schrieb:> Er will den USB Anschluss doch gar nicht als USB benutzen.
Das habe ich gelesen.
Aber mal ehrlich: der Appetit kommt oftmals beim Essen.
Und wer will schon umständlich mit dem Debugger irgendwas ausprobieren,
wenn man's elegant an seinem Lieblings-Terminalprogramm tun kann, wo man
ohne Intrusion durch den Debugger und mit an das Auszuprobierende
angepaßten Kommandos in cmd.c arbeiten kann.
Das, was tatsächlich immer gebraucht wird, ist der Programmer - um eben
den Code in den µC zu kriegen.
Aber der Debugger? Nach meiner Erfahrung sind es die Anfänger, die den
Debugger maßlos überbewerten.
Das kommt daher, daß die meisten anfangs noch gar nicht gegen den noch
unbekannten Chip kämpfen, sondern zu allererst gegen die
Programmiersprache C und gegen die benutzte IDE, von der die meisten
glauben, daß man sie unbedingt haben müßte, weil sie ebenso glauben, daß
die IDE ihnen die Arbeit und das Verstehenlernen erleichtern würde. Ist
ne Fehleinschätzung.
W.S.
> Und wer will schon umständlich mit dem Debugger irgendwas ausprobieren,
Arduino hat keinen Debugger. Insofern frage ich mich auch, wie er das
Ding ohne USB Anschluss sinnvoll nutzen will.
> Das, was tatsächlich immer gebraucht wird, ist der Programmer -> um eben den Code in den µC zu kriegen.
Wobei bei Arduino der Default ein USB Bootloader ist. ST-Link wird aber
auch problemlos unterstützt, ebenso ein serieller Bootloder (dann
braucht man USB-UART Adapter).
Mir scheint hier jede weitere Diskussion vollkommen witzlos zu sein.
Der TO will keine Doku lesen, mit dem Kopf durch die Wand und ist
vollkommen Beratungs-resistent...
Hallo Harry L. (mysth),
so kann man das auch sehen.
Dann muss ich aber sagen, hier gibt es Mitglieder die mir etwas
verkaufen wollen, was ich nicht haben will. Wenn ihr an der Entwicklung
vom Auto teilgenommen hättet, währe bestimmt ein Drachen draus geworden.
Hier besteht ein Kundenwunsch (quasi), der soll gelöst werden. Das man
alles anders machen kann ist mir bekannt. Was in einem Datenblatt steht
bekomme ich auch noch heraus. Nur ich dachte mal, in so einem Forum kann
ich etwas Kreativ und effektiver heraus arbeiten. Aber anscheinend wolle
viele (nicht alle) einfach ihren Senf dazu geben. Früher sagte man, Senf
macht dumm, ich weis jetzt warum.
Hat hier wirklich einer Arnung von der STM32 Arduino IDE?
Hat hier wirklich einer Arnung von den ARM GCC inline Assembler?
Hat hier wirklich einer Arnung von der STM32 Programmierung, die nicht
im Internet oder Buch stehen, also die kleinen Tips?
Da ich nicht ganz gesund bin kann ich mich leider nicht so gewählt
ausdrücken, wie Mansche es sich wünschen. Vielleicht sind diese Wünsche
über meiner Ausdrucksform nur heiße Luft, um von dem wesendlichen
abzulenken.
Wenn das hier so weiter geht, kann ich auch alleine zu Hause alles
rausfriemeln. Ich werde mein Ziel erreichen. Ihr auch? Bis zu meinem
Lebensende werde ich das wohl schaffen.
Danke an Alle, für diese Erkenntniss.
Siegfried S. schrieb:> Kann von> euch einer mit gcc arm inline Assembler in C programmieren?
Du brauchst in den ersten 2 Jahren keinen Inline-Assembler und auch
später nur maximal alle Schaltjahre einmal, wozu um alles in der Welt
willst Du in Deinem jetzigen Zustand Inline-Assembler brauchen?
Was Du wirklich brauchst ist:
* Mindestens durchschnittliche Englischkenntnisse
denn Du wirst 90% englischsprachige Fachliteratur
lesen, die Sprachkenntnisse werden sich durch diesen
jahrelangen intensiven Gebrauch der nun vor Dir liegt
automatisch von "mittel" auf "gut" anheben, keine
Sorge deswegen also, Fremdsprachenkenntnisse haben
sowieso noch keinem geschadet.
* Solide Kenntnis von C
+ inclusive Kenntnis über Build und Buildsysteme
+ inclusive Kenntnis von Editor/IDE Deiner Wahl
(also einen vollständigen C-Hintergrund von Grund auf
solltest Du haben oder Dir jetzt nachträglich
sorgfältig und gründlich erarbeiten, das geht
erstmal auch ohne µ-Controller nur am PC)
* das Referenzhandbuch (Reference Manual) des Chips
* Progtrammieradapter (ST-Link, J-link, etc. oder
passendes Demo-Board das diesen schon on-board hat)
* Ein paar fertige Beispielprogramme zum Rumspielen
und warm werden und auch als Ausgangsbasis für das
eigene Projekt.
In genau der Reihenfolge (1 und 2) kannst Du vielleicht parallel
angehen, Erste C Grundlagen kann man evtl. auch in deutsch lernen,
parallel dazu Bücher nur noch in englisch lesen, Filme, Fernsehserien
nur noch in englisch sehen, englischssprachige Foren lesen. Damit fängst
Du am besten heute noch an! Ich will keine Ausreden hören!
Nur für Einsteiger:
Es wird nur ein ST-Link für ein paar Euros und 2 Pins (PA13, PA14)
benötigt, um ein STM32 (BluePill) zu flashen. Mehr nicht. Der Rest ist
nur für besondere Anwendungen.
Beim BluePill ist an Pin PC13 eine LED angeschlossen. Wenn ihr die zum
blinken bekommt, könnt ihr mit dem selben Programm, nur mit Pin Änderung
im Code, das bei allen anderen Pins mit einer LED und Widerstand
ausprobieren (außer PA13, PA14). Die Pins, die ihr nicht zum blinken
bekommt, sind dann irgendwie anders belegt.
Beim BluePill mit Arduino IDE STM32, sind es einige Pins die schon
belegt sind.
Hier sollte mal das Ziel sein, diese Vorbelegung zu ändern.
Siegfried S. schrieb:> Hier sollte mal das Ziel sein, diese Vorbelegung zu ändern.
Ich vergaß zu erwähnen:
* Schaltplan des verwendeten Boards studieren
zusammen mit dem Referenzhandbuch des Chips
* Zusätzlich das Arduino-Framework entweder vollständig
verstehen inclusive seiner Einschränkungen und seiner
Beziehung zu und Wechselwirkung mit der echten Hardware
oder (wesentlich klarer und direkter, einfacher zu
durchschauen) auf Arduino von Anfang an komplett verzichten.
Vielleicht fängst Du auch erstmal mit nem kleineren Controller an, dann
sind es keine 1000 Seiten mehr sondern nur noch 500 oder so. Alles
andere trifft aber auch da immer noch zu.
Bernd K. (prof7bit) ,
du hast es immer noch nicht verstanden.
Ich gebrauche keinen Psychater mit Lebenberatung. Dann würde ich eine
andere Plattform wählen. Ich suche eine Lösung für ein bestehendes
technisches Problem zu erarbeiten. Dieses Problem wird aber nicht mit
gut zureden gelöst, sondern mit Fakten. Also mit Programmcode in Arduino
C und den dazu gehörigen GCC inline Assembler. Wer da, nichts dazu
beitragen kann, soll sich seine und meine Zeit sparren.
Sind wir schon so neben der Spur, das wir nur noch lamitieren?
Nur zur Info: Ich habe den elektor junior Computer 1980 auf eigen
entwickelten Leiterplatten gebaut und zum laufen gebracht.
Also ganz so dumm wie ich aussehen mag, bin ich nun auch nicht.
Siegfried S. schrieb:> Dieses Problem wird aber nicht mit> gut zureden gelöst, sondern mit Fakten. Also mit Programmcode in Arduino> C und den dazu gehörigen GCC inline Assembler. Wer da, nichts dazu> beitragen kann, soll sich seine und meine Zeit sparren.
Gehts noch? Du hast also eine konkrete Aufgabenstellung, ein konkretes
Projekt mit konkreten Anforderungen, verrätst aber mit keiner Silbe was
das ist und warum es ausgerechnet in Assembler und nichts anderem
programmiert sein muß von allen Sprachen dieser Welt und willst hier
trotzdem fix und fertigen Code frei Haus geliefert bekommen der das
unbekannte Problem löst? Aber sonst gehts Dir noch gut?
Siegfried S. schrieb:> Dann muss ich aber sagen, hier gibt es Mitglieder die mir etwas> verkaufen wollen, was ich nicht haben will.
Nun, das war's dann wohl.
Nur eines zum Bedenken: Niemand will oder kann dir hier etwas VERKAUFEN.
Du müßtest dafür nämlich was ZAHLEN.
Klaro?
Also: Hier hast du eine Reihe wirklich gut gemeinter Ratschläge. Du
kannst sie dir annehmen und was draus lernen, oder eben auch selbige als
Beleidigung auffassen und grollend dem Forum den Rücken kehren. Das ist
allein DEIN Problem.
Begreifst du eigentlich, wie sehr du mit deiner Einstellung und deinen
Worten genau diejenigen vor den Kopf trittst, die dir helfen wollen?
W.S.
Siegfried S. schrieb:> Ich vergass, beim ST-Link werden keine BOOT Stecker mehr benötigt.
Hast du dir den Schaltplan angesehen den ich dir in der ersten Antwort
geschickt habe?
BOOT0 ist BOOT0 und nichts anderes.
BOOT1 ist wahlweise PB2, also einfach den Jumper weglassen.
Was das alles mit Inline-Assembler zu tun hat, habe ich bis jetzt aber
auch nicht verstanden.
Alles in allem, wenn ich das Herumgeeiere hier verfolge
fühle ich mich schon sehr bestätigt zu dem was ich in
den Anfängen dazu gesagt habe.
(Beitrag "Re: stm32f103-bluepill-peripherie")
Und füge jetz noch hinzu: dies ist ein Troll-Thread der
nur dazu da ist den Internet-Traffic auf dieser Site am
Laufen zu halten bzw zu fördern.
Wem das zugute kommt und wer der Urheber ist kann sich
dann jeder selbst ausmalen.
W.S. schrieb:> Als erstes vergiss das Benutzen von Inline-Assembler. Laß sowas> komplettissimo bleiben. Lade dir stattdessen mal das herunter:> https://www.mikrocontroller.net/attachment/316790/STM32F103C8T6.ZIP> und lies dort drin, wie man direkt in C auf die Peripherie zugreift.
Und aufpassen dass der lernresistente W.S. da immer noch seine NOP() -
Funktion drin hat die beim GCC wegoptimiert wird. Wir wissen ja alle
dass er Keil benutzt und es damit eventuell geht. Trotzdem wiederhole
ich die Warnung vorsorglich. Am einfachsten wäre es natürlich W.S.
ändert das mal bevor er uns sein Zeug wie Sauerbier in jedem 3. Thread
anbietet..
Lieber Bernd K. (prof7bit) ,
ich habe von Anfang an geschrieben, das mein Ziel ein BluePill ohne
Voreinstellung der Pins sein soll. Und welche Eckdaten vorliegen.
Ich habe nicht geschrieben:
das ich eine Aufklärung für meine Ausbildungsziele,
welcher Englisch-Kurs der Beste ist,
welche verschiedene IDE's es gibt,
das die Arduino IDE nicht die Beste ist,
das man inline Assembler nicht benutzen soll,
wie gut meine Grammatik ist,
wie gut meine Ausdruchsform ist
und so weiter gebrauche.
Also nur, wie brinkt man ein BluePill in der Arduino IDE dazu, das er
alle Voreinstellungen an den Pin's vergisst, außer an Pin (PA13, PA14)
die für die Programmierung benötigt werden.
Von einem ferigen Programm habe ich auch nicht geschrieben.
Es reicht, wenn mir zb. einer schreiben kann, wie ich den obige inline
Assembler Code zum laufen bekomme.
Diesem, meinem Ziel, bin ich dank der lametiererei noch nicht weiter.
Siegfried S. schrieb:> Also nur, wie brinkt man ein BluePill in der Arduino IDE dazu, das er> alle Voreinstellungen an den Pin's vergisst, außer an Pin (PA13, PA14)> die für die Programmierung benötigt werden.
indem man seinen eigenen STM32 core schreibt. Einen Fork von
https://github.com/stm32duino/Arduino_Core_STM32
anlegen und die Bluepill Variante nach belieben verbiegen. Nur wird das
dann eben zu nix mehr kompatibel sein und das in der grottigen Arduino
IDE zu machen ist verschwendete Lebenszeit. Wenn schon Arduino dann auch
core/libs nutzen wie sie angeboten werden.
Und bei allem ist Inline Asm nicht nötig, der core verwendet die HAL/LL
Funktionen und man kann eigene Initialisierungen ohne weiteres mit der
HAL erledigen lassen und auch die Makros und defines verwenden:
Siegfried S. schrieb:> Also nur, wie brinkt man ein BluePill in der Arduino IDE dazu, das er> alle Voreinstellungen an den Pin's vergisst, außer an Pin (PA13, PA14)> die für die Programmierung benötigt werden.
Bevor du hier die großen Töne spuckst solltest du dich mit der Materie
vertraut machen. Dazu gehört nun mal das Manual von ST. Da wirst du auch
erkennen (eventuell), dass jedes Register und auch die Pins nach dem
Reset einen festgelegten Zustand haben. Das kannst du nicht verhindern.
Wenn du was anderes willst, musst du das Programmieren. Aber du wärst
der erste der dazu notwendigerweise Inline-Assembler benötigt.
Komisch, dass immer die Leute denken es ist alles ganz einfach die von
der Materie keine Ahnung haben....
Siegfried S. schrieb:> Es reicht, wenn mir zb. einer schreiben kann, wie ich den obige inline> Assembler Code zum laufen bekomme.
Hast du es immer noch nicht kapiert? Dir ist nicht zu helfen. Du
brauchst keinen Assembler um auf Register zuzugreifen. Das geht komplett
alles in reinem C.
Siegfried S. schrieb:> Also nur, wie brinkt man ein BluePill in der Arduino IDE dazu, das er> alle Voreinstellungen an den Pin's vergisst, außer an Pin (PA13, PA14)> die für die Programmierung benötigt werden.
dass lässt sich aus der "core/main.cpp" heraus finden. Hier:
1
__attribute__((constructor(101)))voidpremain(){
2
init();
3
}
4
5
intmain(void){
6
setup();
7
8
while(1){
9
loop();
10
}
11
return0;
12
}
die setup() und loop() Funktionen sind in deinem Code, die init() macht
die Framework Initialisierung. Bei mir sieht das so aus
(variant/wirish/boards.cpp):
1
voidinit(void){
2
setup_flash();
3
setup_clocks();
4
setup_nvic();
5
systick_init(SYSTICK_RELOAD_VAL);
6
wirish::priv::board_setup_gpio();
7
setup_adcs();
8
setup_timers();
9
#if F_CPU != 8000000
10
wirish::priv::board_setup_usb();
11
#endif
12
wirish::priv::series_init();
13
boardInit();
14
}
Es werden die ADCs eingeschaltet (und die pins gemappt), dazu per
default wird jtag aktiviert, und wohl die timer (PWM). USB wird
aktiviert wenn SERIAL_USB gesetzt ist, sonst nicht. Also ein
1
voidsetup(){
2
afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY);
3
timer_disable_all();
4
adc_disable_all();
5
}
sollte die Arduino spezifischen Einstellungen zurück nehmen, habs jetzt
nicht ausprobiert. Wenn als upload method "Serial" oder "BMP (Black
Magic Probe)" gewählt wird, dann wird SERIAL_USB nicht gesetzt und USB
ist auch deaktiviert (zu finden in der boards.txt).
Frank K. schrieb:> dann wird SERIAL_USB nicht gesetzt und USB> ist auch deaktiviert (zu finden in der boards.txt).
das ist lt. STM32duino repo beim BluePill sowieso nicht aktiv:
BluePill F103C8 (Basic support, no USB)
Hallo Johannes S. (jojos), danke
endlich etwas, mit dem man was anfangen kann.
Ich habe dein Beispiel umgesetzt.
Es kommt aber mecker.
void setup()
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
void loop() {
// put your main code here, to run repeatedly:
// Blink
gpio_write_bit(GPIOA,11,HIGH); // turn the LED on (HIGH is the
voltage level)
delay(1000); // wait for a second
gpio_write_bit(GPIOA,11,LOW); // turn the LED off by making the
voltage LOW
delay(1000); // wait for a second
}
Das war die Erste Antwort. Weitere solcher folgen.
blink_new_8.ino:3: error: 'GPIO_InitTypeDef' was not declared in this
scope
GPIO_InitTypeDef GPIO_InitStruct;
Der Inhalt der loop Funktion ist declariert.
3 mal
> Hat hier wirklich einer Arnung von ...
Antwort: 3 mal: ja, und das gilt nicht nur für mich.
> Du brauchst in den ersten 2 Jahren keinen Inline-Assembler
Sehe ich auch so. Deine Fragen zeigen, dass du nicht die nötigen
Kenntnisse hast, dieses Feature korrekt zu verwenden. Außerdem kannst du
mit C "einfach so" auf ALLE I/O Register zugreifen. Assembler bringt Dir
hier NULL Vorteile.
Wenn du dennoch Assembler verwenden willst, dann lies die Anleitung vom
arm-gcc Compiler. Wir werden Dir nicht dabei helfen, dein eigenes Knie
zu zerschießen.
> Beim BluePill mit Arduino IDE STM32, sind es einige Pins die schon belegt sind.> Hier sollte mal das Ziel sein, diese Vorbelegung zu ändern.
Ich habe Dir nun schon mehrfach geschrieben, wie du die SWD und/oder
JTAG Pins freimachen kannst.
Warum gehst du nicht darauf ein? Interessiert Dich meine Hilfestellung
nicht?
> Ich vergass, beim ST-Link werden keine BOOT Stecker mehr benötigt.
Was hat das mit diesem Thread zu tun?
> Und aufpassen dass der lernresistente W.S. da immer noch seine NOP() - Funktion
drin hat
Sorry, das ist völlig off-topic und nicht hilfreich. Diskutiere das mit
W.S. in einem separaten Thread aus.
> Also nur, wie brinkt man ein BluePill in der Arduino IDE dazu, das er> alle Voreinstellungen an den Pin's vergisst, außer an Pin (PA13, PA14)> die für die Programmierung benötigt werden.
Habe ich Dir geantwortet. Und ich habe Dir auch geschrieben, dass das
Arduino Framework diesen Wunsch bei dem USB port nicht erfüllt. Wenn Dir
das nicht passt, dann ist Arduino die falsche Wahl. Punkt.
Außerdem haben wir Dir mehrere Alternativen zu Arduino genannt, bei
denen du wirklich volle Kontrolle über den µC hast. Aber die willst du
ja nicht benutzen.
Höre bitte damit auf uns zu schimpfen, wir können nichts dafür. Du
kannst gerne den Roger Clark kontaktieren und von ihm dein persöhnliches
Arduino Plugin entwickeln lassen. Das wird er sicher nicht kostenlos
tun.
> Das bedeutet nichts anderes als das du einen Arduino ohne Arduino willst.
Ganz genau. Der Witz ist: sogar das ist machbar, wenngleich sinnlos.
Frank K. hat gezeigt, wie es geht. Aber jammere dann nicht herum, wenn
die ganzen Arduino Library Funktionen nicht funktionieren.
Hallo Johannes S. (jojos),
ich habe die ältere STM32 Plattform von Roger Clark in Betrieb. Deine
genannte habe ich nicht zum laufen bekommen.
Auch die doppelte Declarierung habe ich entfernt.
Leider ohne Erfolg.
gab es Arduino STM32 Plattformen, die diese Structuren noch nicht
unterstützt haben?
Siegfried S. schrieb:> blink_new_8.ino:3: error: 'GPIO_InitTypeDef' was not declared in this> scope
Dann lass den unsäglichen Arduino-Schrott weg und nimm normales C wo man
Kontrolle drüber hat was man wo includiert. Meinetwegen nimm die IDE die
man bei STM runterladen kann wenn Du keine eigene aufsetzen willst.
Du bist doch angeblich sowieso schon älter, warum willst Du also noch
kostbare Lebenszeit damit verschwenden mit diesem kastrierten Spielzeug
namens Arduino einen aussichtslosen Kampf zu führen den man nicht
gewinnen kann und dessen einzige verwertbare Lehre es am Schluß sein
wird zur Erkenntnis zu kommen daß es ratsam ist allen anderen dringend
zu empfehlen mit dieser Zeitverschwendung gar nicht erst anzufangen?
Um Dir das abzukürzen sage ich es Dir hiermit jetzt direkt. Von der
dadurch gesparten Lebenszeit kannst Du zum Dank gerne 30% hier
abliefern.
Mach es auf die normale Weise in einer normalen Programmiersprache C
oder C++ welche überall breit supportet ist und deren Kenntnisse man
auch in vielen anderen Bereichen noch verwenden kann und nicht mit
diesem grünen Kinderspielzeug mit Stützrädern und
Geschwindigkeitsbeschränkung von dessen Verwendung man Blasen an den
Fingern und allergischen Hautausschlag bekommt.
Hallo Stefanus F. (stefanus),
entschuldige, das ich dich so aufrege.
Ich habe alles gelesen und auch deine Webseite angeschaut.
Deine Informationen, führten aber bei mir nicht zum Erfolg.
Auch kannte ich schon einiges, was nur nicht funktionierte.
Wie sich jetzt aber herausstellt ist meine STM32 Arduino Plattform
vielleicht zu alt.
Ich kann morgen aber erst weiter schauen.
Siegfried S. schrieb:> Wie sich jetzt aber herausstellt ist meine STM32 Arduino Plattform> vielleicht zu alt.
Mit Arduino 1.8.5 funktioniert es, das Borad Package habe ich von der
von mir verlinkten Seite installiert. Wenn das alt ist zeigt die IDE das
auch an. Nur das digital_write_bit wurde offensichtlich umbenannt aber
die Doku nicht nachgezogen.
Hallo Johannes S. (jojos),
die GPIO_InitTypeDef Structur findet er noch immer nicht.
Ich kann morgen erst weiter machen und möchte erst einmal klären ob das
Problem an der alten Version liegt.
Stefanus F. schrieb:> Wenn du etwas mitteilsamer wirst, kann ich Dir helfen.Johannes S. schrieb:> Ist denn auch das STM32duino aus dem genannten Github Repo installiert> und das Bluepill Board ausgewählt?Frank K. schrieb:> dass lässt sich aus der "core/main.cpp" heraus finden. Hier:
Wie lange lasst ihr euch noch an der Nase herumführen?
Der TO lacht sich einen Ast.
Jammer Lappen schrieb:> Wie lange lasst ihr euch noch an der Nase herumführen?> Der TO lacht sich einen Ast.
Spinner. Die paar Zeilen sind schnell in ein Beispiel kopiert und es
kompiliert. Habe das erstbeste genommen,
Datei/Beispiele/CapacitiveSensorSketch und die Zeilen da rein kopiert.
Um ein Projekt schnell zu starten und etwas reinzukopieren taugt die
IDE, aber sich dann mühevoll die Funktionen/Variablen/Konstantennamen
aus den headern rauszusuchen finde ich nicht zeitgemäss. Genauso wie die
fehlende Debugmöchlichkeit (per debug probe). Aber das brauchen
Programmiergötter ja nicht (nur Anfänger wie W.S. immer sagt, ich meinte
nich Siegfried damit).
Board ist generic STM32F103, Boardverwalter sagt STM32 Cores Version
1.3.0
Der Unterschied sind wohl die vielen verschiedenen core Versionen die es
gibt, ich hatte
https://github.com/stm32duino/Arduino_Core_STM32
installiert und das verwendet die STM HAL/LL.
Dann gibt es noch die von Roger Clark:
https://github.com/rogerclarkmelbourne/Arduino_STM32
Da werden nur direkte Registerzugriffe ohne den HAL overhead verwendet
und es geht gpio_init_all(); zum initialisieren und gpio_write_bit()
ist da auch drin.
Verwirrenderweise wird in beiden auf das STM32duino verlinkt.
Damit reicht mir der Ausflug in die Arduino Welt, ich finds halt auch
Kacke :-/
Es ist eigentlich einfach. Mam muss sich anschauen, wie die Register
aufgebaut sind. Mit welcher Programmiersprache man auf die Register
zugreift, ist eigentlich egal.
Siegfried S. schrieb:> Die Arduino IDE>> hat einen eingeschränkten Zugriff auf die C-Konstanten für STM32.>> Meine Idee: Erst einmal den Zugriff auf die STM32 Hardware verschaffen.>> Das geht mit den inline Assembler.>> Ich weiß nur noch nicht wie.>> Meine ersten Versuche:>> void write_reg (uint32_t adresse, uint32_t wert) {> asm> (> "adr r1, %0 "> "ldr r2, [r1] " // r2 == adresse> "adr r1, %1 "> "ldr r3, [r1] " // r3 == wert> "str r3, [r2] " // store r3 nach Zeiger r2> );> }> uint32_t read_reg (uint32_t adresse) {> uint32_t data;> asm> (> "adr r1, adresse " // Lade in r1 den Zeiger auf adresse> "ldr r2, [r1] " // lade in r2 die adresse> "adr r1, data " // Lade in r1 den Zeiger auf data> "ldr r3, [r2] " // lade in r3 den Inhalt von der adresse> "str r3, [r1] " // store r3 nach Zeiger in r2 (data)> );> return data; // gebe den register wert über data zurück> }>> Leider ist da noch der Wurm drinn
Der Wurm hat einen Namen: A.S.M.
Das macht der Compiler (mit -O2 oder mehr) besser als von Hand
"optimiert".
Und dank inline spart er sich sogar den Aufruf.
Wobei es noch besser ist, die Register einer Peripheriebaugruppe als
Struktur anzulegen. Dann wird nur einmal die Adresse geladen und dann
indiziert zugegriffen. Aber das muß für's erste nicht sein.
Hallo Johannes,
hier bin ich wieder. Ich habe erst einmal einen anderen Computer
genommen und die ganze Arduino IDE und mit den Boardmanager STM32
aufgespiel so wie du mir das empfohlen hast. Grundsätzlich sprechen wir
jetzt die gleiche Sprache. Auch verstehe ich jetzt die Einwendungen der
anderen Mitglieder. Nochmals Entschuldigung wenn ich jemanden zur
Weisglut gebracht habe. Mit einem halben Arduino und einer halben HAL
wird das nicht so einfach, das sehe ich jetzt auch so. Nochmals Danke an
dir für dein Verständnis. Ich werde mich jetzt erst einmal mit der HAL
und wie das alles funktioniert beschäftigen. Auch werde ich mal schauen
ob das auch alles mit einem Linux Computer klappt.
Meisten zicken diese IDE's doch alle ein wenig rum. Wobei ich die
Erfahrung gemacht habe, das es meistens die Erweiterungen von
Dritthersteller sind und nicht das Grundgerüst.
zb. Arduino IDE 1.8.5 läuft auf dem alten WinXP super. Die neue
Boarderweiterung von ST für die STM32 Plattform (wie du sie mir
empfohlen hast), ich nenne die mal so wegen den Copyrighs von ST, macht
da nicht mit, obwohl von den Arduino Programmieren WinXP als unterstützt
noch gelistet wird. Zu bemängeln ist bei der Arduino IDE, das sich die
Struktur, wo sich die verschiedenen Programmteile im Verzeichnis
befinden, geändert hat. Das nur so am Rande. Aber man hat ja sonst
nichts zu tun als dieses raus zu finden.
Wenn ich das Blinkprogramm mit HAL Unterstützung, welches auf allen
freien Pins läuft, fertig habe, werde ich es hier veröffentlichen.
Auch wenn es jetzt noch nicht so wichtig erscheint, würde ich mich
freuen wenn Carl zeigt, wie man das mit dem inline Assembler richtig
macht, ohne weg Optimierung.
Leider ist meine Begrifflichkeit nicht mehr so gut wie früher. Beim
lesen der GCC inline Assembler Anleitung fing sich bei mir irgendwann
der Kopf zu drehen an.
Nochmals Danke an alle
Siegfried S. schrieb:> Mit einem halben Arduino und einer halben HAL> wird das nicht so einfach, das sehe ich jetzt auch so.
ich bin da auch hartnäckig und muss selber von überzeugt sein :) Wenn da
so Missionare kommen und nur erzählen das alles Mist ist glaube ich das
auch erstmal nicht. Also alles gut.
Für den ESP8266 nutze ich die Arduino IDE auch weil ich damit bisher nur
kleine Sachen gemacht habe und noch nicht nach einer Eclipse IDE gesucht
habe. Daher interessiert mich auch wie Arduino das unter der Oberfläche
macht, aber da ich mittlerweile viel mit Eclipse basierten IDE gemacht
habe, habe ich da keine Angst solche einzusetzen.
Die würde ich nicht zickig nennen, die Tools und PlugIns haben einen
sehr guten Entwicklungsstand erreicht. Es ist nur die enorme
Funktionsvielfalt die den Anfang nicht leicht macht, ich empfehle immer
da mit einem Tutorial ranzugehen weil man sich sonst am Anfang einen
Wolf sucht bei den vielen Einstellmöglichkeiten und Fenstern. Und da
Debughardware mittlwerweile für ein paar Euro zu haben ist und die SW
dafür kostenlos macht das auch richtig Spass.
Eine einfachere IDE ist EmBitz, aber wenn man etwas Mut hat würde ich
Eclipse nehmen weil man damit dann für alles kompilieren kann.
Die Nutzung aller Pins als IO kann nur eine sportliche Herausforderung
sein, es wurde ja schonmal nach der Anwendung gefragt. Fehlende IO kann
man durch Portexpander wie Schieberegister oder I2C Bausteine erweitertn
oder man nimmt den µC eine Nummer grösser, die STM Nucleo Boards sind ja
auch low cost und bieten gleich einiges mehr.
Genauso sportlich ist es da unbedingt Assembler einbauen zu wollen, da
wurde hier im Forum schon an vielen Beispielen gezeigt das es kaum was
bringt. Sinnvoller ist es die aufwändigen hardware units der modernen µC
richtig zu nutzen, und auch damit hat man schon genug zu tun.
Auf jeden Fall wünsche ich weiterhin maximale Erfolge.
Siegfried S. schrieb:> Ich werde mich jetzt erst einmal mit der HAL> und wie das alles funktioniert beschäftigen.
ich hatte ja schon geschrieben das es mehrere core Versionen für den
STM32 gibt, da kann man ja über GitHub in die Quellen reinschauen. Die
Roger Clark Version ist ohne HAL und da kann man sich das
Registergewusel ansehen. Mit HAL hätte den Vorteil das man einfacher
generierten Code vom CubeMX Tool dazupacken kann wenn man nicht alles
hardcore selber machen möchte.
Hallo Johannes,
ich habe da schon den günstigen BluePill mit einigen Beinen, den ich
auch nutzen möchte. Gekommen bin ich darauf, wo ich eine aktive Lösung,
die klein ist, für ein 16Bit LCD-Display, welches mit SPI über den
BluePill angesteuert wird, gesucht habe. Mit einem Arduino Due hatte ich
da keine Probleme. Daher noch die alte ARM Boardplattform. Als ich
merkte das ich die vielen Pins beim BluePill nicht nutzen kann, bin ich
hier gelandet. Es ist mir aus meine beruflichen Erfahrungen bekannt, das
Probleme in teile zerlegt werden müssen, weil man sonst nicht zum Ziel
kommt. Hier würde ja von einigen bestimmt die Antwort kommen, kannste
viel billiger im Laden kaufen,. Das wollte ich aber nicht. Ich kann mir
bei einigen Schnackern bestimmt vorstellen, das die noch nie ein
Lötkolben in der Hand hatten. Aber ich weiß, das hier auch Spezialisten
dabei sind, die echt etwas auf dem Kasten haben. Leider ist es mit denen
nicht immer so einfach, ihr wissen ans Tageslicht zu bekommen.
zb. Carl, der könnte bestimmt einiges über inline Assembler schreiben.
Oder du mit deiner Ruhe, echt Klasse wie du die Sache auf den Punkt
gebracht hast.
Und natürlich noch viele Andere.
Der ESP32 ist bei mir der nächste Kandidat. Auch den werde ich noch
quälen.
Dabei eigne ich mir immer nur die Bereiche an, die ich gebrauche. Sonst
schaffe ich das bis zu meinen Lebensende nicht mehr.
Nur zu Info; Ich habe das Englischsprachige elektor Buch: Programming
with STM32 NUCLEO BOARDS mit 2 Nucleo-L476. Mit einem Preis von ca.
15,00 Euro, gehören die in eine ganz andere Ecke. Nur die sind für eine
andere IDEE, die ich aus Indien habe, wo ich wissen muss, wie die STM
Peripherie zu bändigen ist. Aber ich liebe nun mal die Arduino IDE. Und
wie bei einer Frau tausche ich sie nicht aus, nur weil Sie mal zickt,
sie hat ja schließlich auch noch andere Qualitäten.
So jetzt habe ich genug lamitiert, jetzt muss erst einmal mein neues
Wissen ausprobiert werden.
So hier bin ich noch einmal.
Das Arbeiten mit STM32 und Arduino 1.8.5 funktioniert ab Win7.
Auch mit Linux Mint18 ist möglich nur da muss noch ein wenig Hand
angelegt werden. Vielleicht sagt da ein Linux Spezialist noch etwas
dazu.
Hier ist erst einmal meine versprochene Testmöglichkeit.
/*
STM32 BluePill blinky
Funktioniert mit einem unveränderten BluePill und ST-Link
Programmierung.
Auf den Pins PA0 bis PA12, PA15 und PB0 bis PB1, PB3 bis PB15 und PC13
bis PC15.
Nur PB13 hat noch Einschränkungen.
Vorraussetzung ist Arduino 1.8.5 in Voreinstellung eingetragen:
https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json
und mit dem Boardverwalter (Boardmanager) dann dazugeladen:
STM32 Cores by ST-Microelektronics Version 1.3.0
*/
#define LED_PCB PC13
// Setup Einstellungen nach einem Reset
void setup() {
// Stelle den digital pin LED_PCB als Ausgang ein
pinMode(LED_PCB, OUTPUT);
}
// Hier wird alles in wiederholender Schleife ausgeführt
void loop() {
digitalWrite(LED_PCB, HIGH); // Schaltet den Pin LED_PCB ein(HIGH
ist der Spannungspegel)
delay(1000); // warte eine Sekunde
digitalWrite(LED_PCB, LOW); // Schaltet den Pin LED_PCB aus(LOW ist
der Spannungspegel)
delay(1000); // warte eine Sekunde
}
Wie ihr seht, kein HAL und inline Assembler drinne.
Ich glaube ich habe mich hier durch fehlende Grundlagen und verschiedene
Versionen zum Affen gemacht.
Ich habe noch eine bitte, wenn ihr etwas veröffentlich, dann wäre es
nicht schlecht, wenn dabei steht, wie dieses zu Stande gekommen ist.
Welche Software, welche Version. So ein Zirkus wie mit mir, kann man
sich dann sparen.
Ansonsten, die oben vorgestellten Seiten von ua. Stefanus F. (stefanus)
sind sehr aufschlussreich. Danke das es Mitglieder gibt, die sich so
eine Mühe geben.
Ok. Es scheint wohl diesem NF Oszilloskop nahe zu kommen, das uns
derzeit aus Asien überall angeboten wird.
Wenn mann noch kein "richtiges" Oszilloskop hat ust das sicher eine
feine Sache.
Hallo Stefanus F. (stefanus),
ich habe jetzt nach nochmaligen langen rum pfriemeln verstanden das es
verschiedene Boardpakete bei der Arduino IDE für ein und der selben CPU
gibt. Das ganze wird noch gekrönt mit verschiedene
Hardware-Astraktions-layer. Irgendwie aber alles nur halb. Bei der ur
Arduino IDE mit der AVR Plattform wurde die avr.h eingebunden und alle
Hardware Möglichkeiten konnten unter dem Arduino C angesprochen werden,
wenn die eingebaute library nicht reichte. STM Core mit ihrem Arduino
Boardpaket macht HAL Fehler, weil nicht nur HAL Elemente benötigt
werden, die unter Arduino nicht vorhanden sind. Bei dem Clark Arduino
IDE STM32 Boardpaket geht es noch gruseliger zu. Hier wurde vieles von
einem anderen Board (Maple) abgeleitet. Zweimal halb ergibt auch kein
ganzes. Jetzt habe ich herausgefunden, das es von STM aber einen C
Hardware-Astraktions-layer (STM32F10x_StdPeriph_Lib_V3.5.0) gibt. Hier
sind alle für die Hardware benötigten Funktionen vorhanden, so wie bei
AVR. Nur wie bekomme ich diese Library in meiner Arduino IDE ?
Hast du oder jemand anderes eine Idee dafür ?
Von der Arduino IDE 1.8.5 möchte ich mich nicht trennen.
Zur Zeit versuche ich ein SPI 2 Master beim BluePill zum laufen zu
bekommen.
Siegfried S. schrieb:> STM Core mit ihrem Arduino Boardpaket macht HAL Fehler
Was soll das bedeuten? Arduino und HAL sind zwei völlig inkompatible
Welten (oder Alternativen), die haben nichts miteinander zu tun.
> Jetzt habe ich herausgefunden, das es von STM aber einen C> Hardware-Astraktions-layer (STM32F10x_StdPeriph_Lib_V3.5.0) gibt.
Welcher seit 6 Jahren deprecated ist. Lass besser die Finger davon. Wenn
du damit anfängst, kannst du deine Programme nicht auf neue µC Modelle
portieren.
> Nur wie bekomme ich diese Library in meiner Arduino IDE ?
Gar nicht, denn auch die StdPeriph_Lib ist eine Alternative zu Arduino.
> Von der Arduino IDE 1.8.5 möchte ich mich nicht trennen.
Dann bleibe besser bei den Arduino Plugins, alles andere ist nämlich
noch viel schlimmeres gefrickel.
Hallo Stefanus F. (stefanus),
hast du den schon einmal ein SPI 2 Master mit der Arduino IDE und STM32
Core Boardpaket gesehen. Die SPI hat folgende Daten:
name=SPI
version=1.0
author=Arduino, Wi6Labs
maintainer=stm32duino
sentence=Enables the communication with devices that use the Serial
Peripheral Interface (SPI) Bus.
paragraph=This library is based on the official Arduino SPI library and
adapted to STM32 boards.
category=Communication
url=http://www.arduino.cc/en/Reference/SPI
architectures=stm32
nicht Clark
Ein funktionierendes Beispiel wäre nicht schlecht.
Siegfried S. schrieb:> hast du den schon einmal ein SPI 2 Master mit der Arduino IDE und STM32> Core Boardpaket gesehen.
Die SPI Schnittstelle der STM32 Controller habe ich noch gar nicht
verwendet. Hatte dazu noch keinen Anwendungsfall.
Ich denke schon, dass man die Erweiterungen von Roger Clark vernünftig
nutzen kann. Ich bin für Arduino allerdings zu alt, ich mag diese IDE
überhaupt nicht und meide sie daher soweit es geht. Deswegen frag mich
besser nicht nach Erfahrungen mit Arduino. Ich habe kaum welche.
Nach folgendes funktioniert mit Arduino IDE
aber bei SPI noch noch nicht.
void setup() {
// put your setup code here, to run once:
// HAL GPIO GPIO Write Pin
HAL_GPIO_WritePin(
GPIOA
,GPIO_PIN_0 | GPIO_PIN_3 | GPIO_PIN_7
,GPIO_PIN_SET
);
// gpio write pin
/* Check the parameters */
assert_param(IS_GPIO_ALL_PERIPH(GPIOA));
assert_param(IS_GPIO_PIN(3));
GPIOA->BSRR = 3;
// gpio write
/* Check the parameters */
uint16_t PortVal = 33;
assert_param(IS_GPIO_ALL_PERIPH(GPIOA));
GPIOA->ODR = PortVal;
}
void loop() {
// put your main code here, to run repeatedly:
}
hatte ich doch schon hier erklärt:
Beitrag "Re: stm32f103-bluepill-peripherie"
Arduino ist nicht gleich Arduino, du kannst nicht irgendwelche cores
mixen oder addieren, was gibt ein halber Apfel + eine halbe Birne?
Entweder oder, und wenn man das System so missbraucht muss man selber in
die Quellen hinabsteigen und analysieren was da implementiert wird.
Einen gültigen Vertrag liefert nur das Arduino API, das liefert der
core. Wie, ist egal. Wenn man sich auf Dinge ausserhalb dieses Vertrages
verlassen will muss man selber sehen ob das sicher ist.
Ein SPI ist im Arduino API implementiert und wird so verwendet (am Ende
sind Links zu Beispielen):
https://www.arduino.cc/en/Reference/SPI
Der Arduino core hat in dem Fall nur die Aufgabe das SPI Objekt
bereitzustellen und muss nicht veraten wie er das macht.
Wenn man den core nur installiert um ihn zu umgehen ist das Murks hoch
3. Das wurde hier aber schon mehrfach erklärt, ich bin da jetzt auch
raus.
Siegfried S. schrieb:> Nach folgendes funktioniert mit Arduino IDE> aber bei SPI noch noch nicht.
Manchmal kann man wirklich nicht glauben was man hier alles lesen muss.
Danke an Johannes für die wohltuenden Worte.
Hallo Johannes S. (jojos),
ich habe doch dazu gelernt.
Arduino IDE 1.8.5 und STM32 Core Boardpaket. Das ist eine ganz normale
Zusammenstellung die auch eine SPI Library von Wi6Labs hat. Ist wohl
schon ein wenig älter, soll aber SPI 2 können. Ich habe nur noch nicht
gefunden wie. Das HAL Beispiel mit den Port habe ich nur geschrieben,
weil ja Arduino mit HAL ja nichts am Hut haben soll. Obwohl das STM32
Core Boardpaket damit zusammengestellt wurde. Aber das ist ja schon
bekannt.
Ich habe ja verstanden, das ich mit Arduino nicht tricksen soll. Aber
wie arbeite ich den nun mit der Arduino IDE? Oder ist die Arduino IDE
für dieses Forum nur zu einfach, wenn man weiß wie es geht. In der
letzten Maker wurde ja über dieses Phänomen berichtet.
Noch gebe ich nicht auf, auch wenn wohl keiner ein tiefgreifendes
Handbuch für die Arduino IDE mit STM32 geschrieben hat.
Nur wer wissen weiter gibt, kann es vermehren. Früher war das so, heute
wohl nicht mehr üblich.
In der Zeit, wo du dich mit dem Arduino-Müll herum ärgerst, hätte jeder
Andere längst gelernt, den Chip ohne diesen Wasserkopf zu nutzen....
Hier wirst du ansonsten kaum jemand finden, der sich sowas freiwillig
antut.
Siegfried S. schrieb:> Nur wer wissen weiter gibt, kann es vermehren. Früher war das so, heute> wohl nicht mehr üblich.
Das ist heute mehr denn je üblich, siehe Github und Co, du musst nur
jemanden finden der das auch als sinnvoll ansieht...
Wenn das Pferd tot ist sollte man absteigen passt meiner Meinung nach
eher.
Wer dem Pferd nichts zum fressen gibt, wird auch nicht lange Freude
haben, könnte auch passen. Wer jeden, mit einem Pickel, aus dem Weg
geht, kann auch Einsamkeit produzieren. Und das gilt für beide Seiten.
Nur was hat das mit SPI 2 und STM32 Arduino IDE zu tun. Ich habe schon
an Anfang geschrieben, das ich ein Ergebnis mit Arduino IDE suche. Ich
werde es finden, und wenn es ein Jahr dauert. Ich mag nämlich auch
Menschen mit Pickel.
Siegfried S. schrieb:> Ich habe schon> an Anfang geschrieben, das ich ein Ergebnis mit Arduino IDE suche. Ich> werde es finden, und wenn es ein Jahr dauert.
Ist das irgend so ein katholisches Selbstgeißelungsding das Dich da
antreibt? Irgendwas das Dir unter Strafe verbietet Spaß bei der
Programmierung haben zu dürfen? Oder was sonst könnte einen dazu bringen
sich selbst Schmerzen zufügen zu wollen indem man von allen frei(!)
verfügbaren Werkzeugen ausgerechnet den fußgerichteten
Bolzenschußapparat auswählt der am ungeeignetsten für die Aufgabe und am
unhandlichsten zu bedienen ist?
Bernd K. schrieb:> Ist das irgend so ein katholisches Selbstgeißelungsding
Jetzt hat mich aber einer erkannt!!!!
Anscheinend schreibst du da aus Erfahrung.
Programmieren hat auch halt etwas mit Selbstgeißelung zu tun.
Thread beobachten
Seitenaufteilung abschalten