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.
:
Bearbeitet durch User
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 | void setup() |
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_t read_adc1_result() |
2 | {
|
3 | return ADC1->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
:
Bearbeitet durch User
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...
Nicht so eilig. Es ist mal gerade ein Tag um, so schnell kann er das alles gar nicht lesen. Gebt ihm Zeit.
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!
:
Bearbeitet durch User
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.
:
Bearbeitet durch User
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.
:
Bearbeitet durch User
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?
:
Bearbeitet durch User
Ich vergass, beim ST-Link werden keine BOOT Stecker mehr benötigt.
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.
:
Bearbeitet durch User
Siegfried S. schrieb: > alle Voreinstellungen an den Pin's vergisst Das bedeutet nichts anderes als das du einen Arduino ohne Arduino willst.
Denn womit sollen all die Ardu Funktionen arbeiten wenn du ihnen die Pin Definitionen entziehst?
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:
1 | void setup() |
2 | {
|
3 | GPIO_InitTypeDef GPIO_InitStruct; |
4 | GPIO_InitStruct.Pin = GPIO_PIN_14; |
5 | GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; |
6 | GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; |
7 | HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); |
8 | |
9 | Serial.begin(9600); |
10 | }
|
akzeptiert der Compiler ohne Mecker.
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))) void premain() { |
2 | init(); |
3 | }
|
4 | |
5 | int main(void) { |
6 | setup(); |
7 | |
8 | while (1) { |
9 | loop(); |
10 | }
|
11 | return 0; |
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 | void init(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 | void setup() { |
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)
Kommt wahrscheinlich auf den gewählten Board Typ an, ich habe "Generic STM32F103C series" verwendet, und dort wurde USB aktiviert.
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.
Ist denn auch das STM32duino aus dem genannten Github Repo installiert und das Bluepill Board ausgewählt?
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.
Siegfried S. schrieb: > GPIO_InitTypeDef GPIO_InitStruct; das ist ein Fehler, GPIO_InitStruct wird zweimal deklariert. Die zweite Deklaration löschen.
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.
:
Bearbeitet durch User
Siegfried S. schrieb: > Auch die doppelte Declarierung habe ich entfernt. > Leider ohne Erfolg. aber jetzt kommt eine andere Fehlermeldung?
1 | digital_write_bit() |
gibbet scheinbar nicht mehr, ersetze es durch
1 | digital_io_write() |
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.
> Deine Informationen, führten aber bei mir nicht zum Erfolg.
Wenn du etwas mitteilsamer wirst, kann ich Dir helfen.
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.
Hallo Johannes S. (jojos), da die Function loop bei mir funktioniert, wird es vielleicht doch an der Version liegen. Bis morgen Danke
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 :-/
ich hatte mal universelle Macros zum Setzen der IOs geschrieben:
1 | #define GLUE(a, b) a##b
|
2 | #define PORT(x) GLUE(PORT, x)
|
3 | #define GPIO(x) GLUE(GPIO, x)
|
4 | #define PORTA 0
|
5 | #define PORTB 1
|
6 | #define PORTC 2
|
7 | #define PORTD 3
|
8 | //#define PORT(x) GLUE(PORT, x)
|
9 | #define pinDIRout(port,pin) {*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)&=~(0b1111<<(4*(pin%8)));*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)|=(0b0011<<(4*(pin%8)));}
|
10 | #define pinDIRin(port,pin) {*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)&=~(0b1111<<(4*(pin%8)));*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)|=(0b1000<<(4*(pin%8)));}
|
11 | #define pinSET(x,y) (*(uint32_t*)(GPIOA_BASE + PORT(x)*0x400 + 12))|=(1<<y)
|
12 | #define pinCLR(x,y) (*(uint32_t*)(GPIOA_BASE + PORT(x)*0x400 + 12))&=~(1<<y)
|
13 | #define pinTOG(x,y) (*(uint32_t*)(GPIOA_BASE + PORT(x)*0x400 + 12))^=(1<<y)
|
14 | #define pinVAL(x,y) (*(uint32_t*)(GPIOA_BASE + PORT(x)*0x400 +8 ) & (1<<y))
|
15 | //#define pinVAL(x,y) (*(uint32_t*)(GPIOA_BASE + PORT(x)*0x400 + 8) & (1<<y)))
|
16 | //#define io_to_tim(port,pin) {*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)&=~(0b1111<<(4*(pin%8)));*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)|=(0b1000<<(4*(pin%8)));}
|
17 | #define GPIO_AF_PP 0b1011
|
18 | #define GPIO_AF_OPD 0b1111
|
19 | #define GPIO_IN_PuPd 0b1000
|
20 | #define GPIO_OUT_PP 0b0011
|
21 | #define clrGPIO_CRHL(port,pin) *(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)&=~(0b1111<<(4*(pin%8)))
|
22 | #define setGPIO_CRHL(port,pin,mask4bit) do{clrGPIO_CRHL(port,pin);*(uint32_t*)(GPIOA_BASE + PORT(port) *0x400 + (pin/8)*4)|=(mask4bit<<(4*(pin%8)));}while(0)
|
23 | #define pgm_read_byte *
|
Es ist eigentlich einfach. Mam muss sich anschauen, wie die Register aufgebaut sind. Mit welcher Programmiersprache man auf die Register zugreift, ist eigentlich egal.
Unnötig, solche Makros sind bereits in der CMSIS Library enthalten, welche wiederum die Grundlage für die SPL und Cube HAL ist.
1 | #define SET_BIT(REG, BIT) ((REG) |= (BIT))
|
2 | |
3 | #define CLEAR_BIT(REG, BIT) ((REG) &= ~(BIT))
|
4 | |
5 | #define READ_BIT(REG, BIT) ((REG) & (BIT))
|
6 | |
7 | #define CLEAR_REG(REG) ((REG) = (0x0))
|
8 | |
9 | #define WRITE_REG(REG, VAL) ((REG) = (VAL))
|
10 | |
11 | #define READ_REG(REG) ((REG))
|
12 | |
13 | #define MODIFY_REG(REG, CLEARMASK, SETMASK) WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))
|
14 | |
15 | #define POSITION_VAL(VAL) (__CLZ(__RBIT(VAL)))
|
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.
1 | inline void write_reg (uint32_t adresse, uint32_t wert) { |
2 | *((uint32_t*)adresse) = wert; |
3 | }
|
4 | inline uint32_t read_reg (uint32_t adresse) |
5 | return *((uint32_t*)adresse); |
6 | }
|
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
:
Bearbeitet durch User
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.
:
Bearbeitet durch User
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.
> Wie ihr seht, kein HAL
Nee, aber dafür ein Arduino Framework. Das ist ebenso ein
Hardware-Astraktions-layer, nur ein anderer.
Ich hab z.B. das 10$ Oszi mit der Arduino IDE unter Debian recht problemlos ans Laufen gebracht. Nur das Brennprogramm musste noch selbst compilieren.
> das 10$ Oszi mit der Arduino IDE
Kenne ich nicht, gibt es dazu eine Webseite?
http://www.stm32duino.com/viewtopic.php?t=107 Ist ein riesen Thread, aber es steht wirklich viel wissenswertes drin...
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: }
Also noch einmal an Alle, wie bekomme ich mit der Arduino IDE und STM32 Core Boardpaket ein SPI 2 Master programmiert ?
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.
:
Bearbeitet durch User
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.
Also das 10$ Oszi hab ich mal in der Arduino IDE ans Laufen gebracht.
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?
:
Bearbeitet durch User
Beitrag #5540923 wurde von einem Moderator gelöscht.
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.
Beitrag #6871060 wurde von einem Moderator gelöscht.
Beitrag #6871070 wurde von einem Moderator gelöscht.
Beitrag #6871541 wurde von einem Moderator gelöscht.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.