eforth220 auf Arduino Nano

  • Forth Programming on Arduino Nano VI


    Früher codierte worte hab ich im hinblick auf redundanz überarbeitet.

    Das resultat ist:

    • schlankerer code
    • weniger speicher verbraucht
    • bessere lesbarkeit

    Capture1.JPG


    In beiden dateien wurden die motorbewegungen erst in sequenzen festgelegt und erst danach in den worten für eine ganze umdrehung verwertet.

    Die version für den motor mit 48 schritten sowie für den motor mit 200 schritten werden jetzt nur noch 560 byte benötigt.

    motor mit array-a.txt

    motor mit array-b.txt


    Capture2.JPG


    Im programm mit der tastensteuerung wurde der ganze blaue bereich eliminiert und anders gebaut.

    Das menu wird ja nicht gebraucht weil da kein bildschirm vohanden sein wird. Nur als kommentar gibt es ein hinweis auf die bedienung.

    Die worte runcw runccw und run sind neu in der definition run vereint.

    Die richtung wird direkt in go angefragt.

    Die alte version links verbrauchte 787 bytes wärend die neue links nur noch 438 bytes beansprucht.

    tasten.txt

    tasten-neu.txt


    Captur3.png


    Das programm gurkenwascher erhielt ebenfalls eine verbesserung.

    Da im "motor-mit-array-b.txt" jetzt sequenzen zugänglich sind, lässt sich auch hier redundanz abbauen.

    Einige unnötige speed-anweisungen wurden entfernt.

    gurken-alt brauchte 928 bytes, gurken neu noch 694 bytes.

    gurkenalt.txt

    gurken.txt


    Mit dem bereits vorhandenen wort mem kann der noch verfügbare speicher angezeigt werden.

    So lässt sich der speicherverbrauch eines wortes oder einer wortfamilie leicht errechnen indem man

    mem vor und nach der kompilation ausführt und dann den zweiten wert vom ersten subtrahiert.


    hermosos días 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Also ganz so einfach ist es nicht. Man muss bestimmte Register setzen um einen Timer zu konfigurieren. Der Atmel Atmega328p hat drei Timer. Ob alle bei der Nutzung von eForth verwendet werden können entzieht sich meiner Kenntnis.


    Im Prinzip arbeiten die Timer mit internen „Zählern“. Wenn diese einen bestimmten Wert erreicht haben, wird von dem Controller eine sog. Interrupt Service Routine (ISR) aufgerufen. Wenn man den Timer so konfiguriert, dass er jede Millisekunde einmal die ISR aufruft, kann man eine Variable hochzählen und hätte so eine millis() Funktion geschaffen. Die ISR läuft ja mit dem Start des Controllers automatisch los. In der Variable oder auf irgend einem Stack stünde dann also die Anzahl der vergangenen Millisekunden seit dem letzten Start des Controllers.


    Über die Arduinoumgebung bzw. durch das Arduino C-Framework ist das bereits eingebaut. Wie es in eForth aussieht weiß ich nicht aber dort müsste es ja auch einen Zugriff auf die entsprechenden Interrupts geben, über die man ISR Code einbinden kann.


    Wie die ganze Timermimik beim Atmel funktioniert ist hier sehr schön beschrieben: https://wolles-elektronikkiste.de/timer-und-pwm-teil-1


    Es gibt auf der Seite auch noch einen Teil über den 16Bit Timer.

  • Arduino-Funktion MILLIS in eforth umsetzen


    MILLIS aus der arduino-ide ist sicher vielen bekannt. Mir ist auch klar was sie macht und wie sie anzuwenden ist.

    Um in den eforth-beispielen das delay zu umgehen, möcht ich ein forth-wort MILLIS erstellen.

    Um schneller an's ziel zu kommen bin ich für eure hilfe dankbar.

    Meine frage: wie ist MILLIS intern aufgebaut?

    Ich denke dass ein timer-register abgefragt wird und mit ein wenig rechnen bekommt man schliesslich die millisekunden.

    Gruss nische


    PS Hier noch zahlen zum speicherverbrauch durch hinzugeführte forth-worte.

    • IA.HEX geflasht 22749 bytes free
    • MOTOR MIT ARRAY A.TXT geladen 22265 bytes free. ergo sum 484 bytes
    • TASTEN .TXT geladen. 21483 btes free. ergo sum 782 bytes

    motor mit array-a.txt

    tasten-b.txt

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Forth Programming on Arduino Nano V


    Dieses Beispiel stellt eine steuerung über taster vor.

    Die taster liegen an den pin's 2 bis 7 am arduino-nano und ziehen die pin's wenn gedrückt gegen gnd.


    Taste an pin2 stop

    Taste an pin3 start

    Taste an pin4 rueckwaerts

    caste an pin5 vorwaerts

    Taste an pin6 langsamer

    Taste an pin7 schneller


    testaufbau.jpg


    Hier gleich das VIDEO mit dem testlauf


    words.jpg

    Auf signal-led's hab ich verzichtet. Es ist aber ein leichtes solche an den noch freien pins anzusteuern.

    Worte dafür wären z.b. led.on, led.off, led.richtung und würden in den worten der tastenabfrage aufgerufen werden.

    Ausserdem ist eine entprellung der tasten mit dieser art von abfrage bereits implementiert.


    Gruss 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Hallo KaiR und nische


    ich bin auch ein wenig schlauer geworden.

    Externe Dioden scheinen mir nur dann notwendig, wenn die Dioden im FET langsamer sein sollten, was dann aber bedeuten würde, dass der falsche FET ausgesucht wurde (das machen wir ja nicht;)). Daher würde aus meiner Sicht die interne Diode jeweils ausreichen, ausser man möchte die Verlustleistung auf FET und externe Diode verteilen.


    oder wie es ein Achim schreibt:

    Achim S.

    Extra-Freilaufdioden können dann sinnvoll sein, wenn sie "bessere

    Eigenschaften" haben als die Substratdioden der FETs (beim Betrieb

    weniger Verluste erzeugen).


    Richtig, nische, schnelle Dioden sollten es dann aber sein.

    Aus der Sicht von EMV scheinen mir aber schnelle Dioden, so nah am Motor wie möglich aber trotzdem sinnvoll, da man damit den Abbau der Energie so nahe an der Quelle erledigt. Der eigentliche Schaltvorgang wird dann aber immer noch mit der Zuleitung als Antenne seinen Anteil beitragen.

    Zusätzlich ist es wichtig, das die Betriebsspannung mit einem Elko gestützt wird und für die höherfrequenten Anteile schadet ein Kerko nie.


    pers. bin noch immer unter Druck (das scheint als Pensionär normal zu sein) und seit 3 Wochen ist mein E-Auto in der Werkstatt. Na ja, Verbrenner ist eben nicht Elektro und die Fachleute fehlen. Wie war die erste Diagnose? "Der Ganghebel wird defekt sein" Ich musste mir das Lachen verkneifen.

  • Es ist mir klar geworden, dass die externen dioden vom typ "schotky" sein müssen.

    Kleinere flussspannung, schnelleres schaltverhalten. Merci für alle hinweise :)

    So hab ich das früher selbst zusammengebaut ---- ist ein paar tage her


    20210716_165237(1).jpg


    Der l298, ein veteran, hat keine internen dioden.

    Ein umfänglicher und verständlicher artikel über L297/l298 von Stephan Mischnick auf seiner seite strippenstrolch

    schrittmotortreiber-mit-chopper

    nische

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • nische, @Pius,


    Pius‘ Ausführung zu der internen Diode war eigentlich der Hintergrund meiner Frage. Es könnte ja gute Gründe geben, eine extra Diode zu verwenden. Ich weiß es halt auch nicht, darum hatte ich nachgefragt.


    Ergänzung:


    Ich habe ein bisschen gestöbert und im MOSFET-Artikel auf Wikipedia den Abschnitt über die Inversdiode gefunden.


    Dort steht unter anderem:

    Zitat

    Bei manchen Schaltanwendungen ist eine Leitung von Strom entgegen der „normalen“ Richtung sogar erwünscht. So sind Brückenschaltungen so konzipiert, dass die Inversdiode leitend wird. Bei Anwendungen mit hoher Schaltfrequenz ist allerdings die vergleichsweise lange Sperr-Erholzeit der Inversdiode eine Begrenzung. Außerdem führt ihre recht hohe Flussspannung zu erhöhter Verlustleistung. In diesen Fällen wird extern eine schnelle Schottkydiode mit niedrigerer Flussspannung parallel zur Inversdiode an Source und Drain hinzugefügt.


    Und nun zurück zu eForth ;)

  • Forth Programming on Arduino Nano IV-b


    In posting #14 zeigte ich den code für den gurkenwascher. Dabei missachtete ich die regel der wieder-verwendbarkeit von bereits kompilierten forth-worten. Ich machte mir also zuviel arbeit. Es geht dabei um das FAKTORING beim coden.

    (Grosse probleme in nützliche fragmente aufteilen) Brodie "in forth denken, seite 170


    Anschaulich in einem bild:

    Die beiden oberen codes enthalten die bereits compilierten worte für schrittsequenzen.

    Die beiden unteren zeigen den code vom gurkenprogramm. Das rechte enthält den modifizierten code.

    Die grau unterlegten textstellen heben das erklärte hervor.

    4-files.png


    Und ausserdem wachsen bei mir schwimmhäute zwischen den zehen.

    Gruss. 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • @pius

    ich meine irgendwo mal gelesen zu haben, dass die internen Dioden im FET nicht die idealste Lösung sind, da sie thermisch auf dem selben Substrat mit steigender Temperatur ihre Kennlinie verändern und daher sind zusätzliche Reverse Dioden nicht grundsätzlich überflüssig (aber ich habe da wie so oft keine Erfahrungen).

    Danke davon hatte ich keine kenntnis. Sind die internen dioden für ihre funktion speziell dotiert? Ich meine: sprechen die exakter oder schneller auf überspannungen an als externe "normalosdiodos".


    L297 und L298 sind bei mir auf einem testboard verbaut. Alles mit steppers wird damit sehr einfach und bequem. Für eine ernsthafte anwendung käme wohl ein hybrid- oder inegrierter treiber zur anwendung.

    More about here what-is-a-chopper-drive-for-a-stepper-motor/

    Mehr dazu hier wie-funktioniert-der-chopper-treiber-fuer-den-schrittmotor


    Im gezeigten fall dient es lediglich der visuellen darstellung der in eforth programmierten sequenzen.


    Die printplatte tönt vermutlich wegen des lasziven aufbaus. Da kann schon mal etwas vibrieren :-)))))

    20210715_104020(1).jpg  20210715_104031(1).jpg


    grüsse nische

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Hallo nische


    Du legst Dich richtig in die "Spulen", super einfache Lösung. Der Hinweis von Kai mit den Dioden ist für mich nicht neu. Ich meine irgendwo mal gelesen zu haben, dass die internen Dioden im FET nicht die idealste Lösung sind, da sie thermisch auf dem selben Substrat mit steigender Temperatur ihre Kennlinie verändern und daher sind zusätzliche Reverse Dioden nicht grundsätzlich überflüssig (aber ich habe da wie so oft keine Erfahrungen).


    Das andere Problem mit den Vorwiderständen bei deinem Stepper ist auch nicht neu. Da diese Antriebe auch zum Bremsen oder als Gegenkraft zur Drehrichtung benutzt werden und in solchen Fällen der Motor nicht oder nur sehr langsam dreht, erhöht sich der Gleichstromanteil in der Wicklung. Bei stillstehendem Motor muss der Strom in der Wicklung stark reduziert werden, um ein Verbrennen der Wicklung zu verhindern und vor allem auch um unnötige Verluste zu vermeiden. Dazu haben bereits kleine Schrittmotortreiber eine Stromregelung mit eingebaut, die mit einem Rsense in jeder Wicklung den Strom messen (siehe L298, L297).


    Auch da sind meine Erfahrungen zu klein, um richtige Tipps zu geben aber vielleicht findest Du hier die entsprechenden Lösungen.


    zieht nun die Gummistiefel wieder an ;)


    Gruss

    Pius

  • @kai - Tja, jetzt machst du mich ein wenig verlegen. Pure nachmacherei gemäss schema, aber danke für die nachfrage :|


    Die mosfets klaubte ich ab einer schrottplatine, die dioden aus sparlampen und die led's sind aus einem beutel.

    Ich wollte einfach auf sicher gehen und schaute die mosfets gar nicht näher an. Das datenblatt sagt dass du recht hast.

    MosFet STD38NH02LT4-STMicroelectronics.pdf


    Mit dem IBM-stepper-motor machte ich noch weitere tests. Von maximaltempo bis langsam bei 5V ohne vorwiderstand.

    Der motor drönte und seltsam, die printplatte war ein kleiner lautsprecher, das drehmoment enorm.

    Das ding scheint aber z'vrhebe. Von den motoren habe ich zwei stück. Es besteht die möglichkeit diese auf bipolar umzubauen.

    Gruss. nische

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Hallo Nische,


    mal eine Frage zu dem Treiber. In den Mosfets ist doch eigentlich schon eine Diode von Source nach Drain enthalten. Reicht die nicht aus oder warum hast du zwei Dioden pro Fet verbaut?


    Das,Winken kommt gut ;).

  • Forth Programming on Arduino Nano IV


    Ein weiteres kleines programm zur steuerung eines schrittmotors. Diesmal verwende ich ein schweres kaliber.
    20210714_135926(1).jpg

    Dieser stepper ist sehr niederohmig und zieht eine menge strom.

    200 vollschritte und 400 halbschritte pro umdrehung.

    Um die versorgung sicher zu stellen wird ein computernetzteil verwendet.

    5V und ein 5Ω leistungswiderstand in serie zum motor machen die sache lauffähig.

    Der motor stammt von einem IBM drucker.

    Die treiberplatine mit dem ULN2803APG würde hier schnell abdampfen. Darum baute ich einen spulentreiber mit 4 n-channel mosfet's:

    20210714_114840(1).jpg. unipolar-stepper-arduino-driver-schematic.png


    Das beispielprogramm soll einen automatisierten maschinencyklus darstellen.

    strip.jpg  Video Gurkenwascher


    Grüsse an die Community 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Forth Programming on Arduino Nano IV


    Das programm von 0033mer das einen schrittmotor antreibt habe ich nun mit meiner version fertig codiert.

    Bei einem ersten Versuch nahm ich den entwurf der version 2 in posting #10. Es stellte sich heraus dass in den phrasen

    : mot.cw.hs seq.cw.hs 8 times ;

    8 times zur wiederholung der vorangegangenen worte zum verhängnis wird, wenn zwei solche worte aufeinande folgen.

    Der nano geht in eine endlosschleife und ist nur noch mit reset zu stoppen. Warum das so ist, kann ich nicht erklären, weil ich das glossar (beschreinung der forth-worte) von 0033mer nicht kenne.

    Mit der code-version 1 in posting #10 klappte es dann wie gewünscht. Dort werden die wiederholungen mizteinem for-konstrukt erledigt.

    Hier gleich mal das gesamte programm nach dem beispiel von 0033mer.

    Ich versuchte im code zu erklären wie das funktioniert und hoffe einigermassen verständlich kommentiert zu haben.


    Vielleicht scheint der code kompliziert und kryptisch. Es ist halt sehr maschinen-nah, aber man weiss genau was man tut.

    Im grund sind es kleine unterprogramme mit dem unterschied, dass parameter über einen stapelspeicher übergeben / übernommen werden.

    Ein geübter programmierer kann das beispiel sicher noch eleganter codieren.

    Bei worten wie : mot.cw.fs 3 for 0 step 2 step 4 step 6 step next off ; kann zum beispiel der schleifen-index 3 nicht im wort sondern ausserhab auf dem stack übergeben werden. Auf diese weise kann die schritt-anzahl stehts geändert und den bedürfnissen angepasst werden

    Betrachte dazu das codebeispiel 1 im posting #10


    &thumbnail=1

    Das prinzip der schaltung. Ich verwende das darlington-array ULN2803APG

    Der arduino-nano wird über das usb-kabel mit 5 volt versorgt

    Der motorkreis erhält 7.4 V von zwei lithium-akkus

    Gesteuert mit dem virtual-terminal TeraTerm


    stepper.jpg


    Video vom Stepper-Motor in Betrieb


    Tschau zämme 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Forth Programming on Arduino Nano III


    0033mer zeigt in seinem video einen interessanten entwurf um einen schrittmotor zu bewegen.


    stepper steps.jpg Stellungen des schrittmotors mit verschiedenen ansteuerungen


    Stepper-Motor-Interface.jpgSchema des versuchaufbaus


    0033mer Video Arduino Nano Stepper Motor Control

    Gegen ende des videos zeigt 033mer am steppermotor die auswirkungen seines programms.

    Es sind nacheinander geschriebene forth-worte die einfach nacheinander abgearbeitet werden.

    Wie er das mit den eben erzeugten worten codiert hat, bleibt verborgen.


    CW 2 Rotation 3 seconds
    4 Steps 3 seconds
    12 Steps 3 seconds
    CCW 2 seconds
    12 Steps 3 seconds
    24 Steps 3 seconds
    4 Rotations 3 seconds
    CW 2 seconds
    Rotate.180 2 seconds
    CCW 2 seconds
    Rotate.90 2 seconds
    3 Rotations
    Kill ;


    Hier fehlt eindeutig, und das bei vielen schrittmotor tutorials, die möglichkeit das verhalten des motors in laufendem zustand zu steuern.

    Auch wird die motordrehzahl mit delays 10 ms erzeugt, was im beispiel nicht mal in einer variablen gehalten wird. Dies soll keine kritik sein, sondern die finessen zeigen, die in einer brauchbaren applikation nötig werden.


    Ich beabsichtige das oben aufgeführte programm mit meinem entwurf zu codieren.

    • Das lästige delay loswerden
    • Einige der optionen mit tastern aufrufen
    • Schneller und langsamer taster verwenden
    • Evt. ungerade schritte ausführen
    • Den motor am schluss in die startposition zurück fahren

    Hebet e feini wuche 1416-wink2-gif

  • Forth Programming on Arduino Nano II fortsetzung Korrekturen

    posting #10

    Das problem mit den 80 zeichen ist gefunden: Es ist teraterm das bei zeilen länger als 80 streikt.

    Nun schrieb ich zu kurze worte ausführlicher, was die lesbarkeit verbessert.

    Code version1 und code version 2 sind in erneuerter form eingefügt.

    Das wort off ist neu dazu gekommen. es schaltet alle portb-pins am ende auf low.

    nische

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Forth Programming on Arduino Nano II fortsetzung


    Im posting #9 erwähnte ich 2 mängel:


    1. Verzögerungen mit einer funktion ähnlich "millis" statt mit einem konstrukt wie "delay" in der arduino ide.
      Hier brauche ich Hilfe. Wer weiss wie die funktion "millis" intern funktioniert?
    2. die schrittsequenz in ein byte-array schreiben und mittels schleife auslesen.
      Dazu sind zwei varianten unten aufgeführt. Die erste mit einer for-schleife, die zweite mit dem wort TIMES



    new words version 1

    MOT.CCW.FS MOT.CCW.HS MOT.CW.FS MOT.CW.HS STEP OFF TEMPO BITS

    ------------------

    create bits 1100 c, 0100 c, 0110 c, 0010 c, 0011 c, 0001 c, 1001 c, 1000 c,

    create erzeugt den kopf eines eindimensionalen arrays mit dem name bits, das beliebig mit beifügen von werten erweitert werden kann.

    c, schreibt jeweils ein byte, mit , wird ein 16 bit wert gespeichert.

    Im beispiel entsteht somit ein bite-array mit 8 einträgen.

    Beim aufruf von bits wird die adresse des ersten wertes auf den stack gelegt.

    Mit @ wird der wert ausgelesen und steht nun anstelle der adresse auf dem stack.

    ----------------------

    : step bits + c@ portb ! t ;

    Es wird das wort step erzeugt. Der array-index wird auf dem stack erwartet ( 0 bis 7 bei halbstep-betrieb)

    bits liefert die adresse des ersten wertes im array ( -- index )

    Dann wird der index zur adresse addiert ( index adresse -- zieladresse )

    und der indexierte wert mit c@ auf den stack geholt (zieladresse -- byte )

    portb liefert die portb-dataregister-adresse auf den stack ( -- byte adresse )

    ! nimmt das byte (bitmuster) vom stack und speichert es in der adresse des portb-dataregisters. (bite adresse -- )

    Die entsprechenden pins liegen jetzt auf HIGH

    ----------------------

    Mit diesen werkzeugen können nun beliebige motorbewegungen erzeugt werden

    : mot.cw.fs 3 for 0 step tempo 2 step tempo 4 step tempo 6 step tempo next off ;

    Es wird das wort mot.cw.fs erzeugt. (motor clockwise fullstepp)

    for eröffnet eine schleife mit dem inex 3 auf dem stack. Sie wird 4mal durchlaufen.

    0, der array-index, wandert auf den stack ( -- 0 )

    jetzt kommt das eben generierte wort step und macht was oben beschrieben wurde.

    Das bitmuster dieses schrittes liegt jetzt an den pins.

    Das geschieht 4 mal dann wird mit next zurückgesprungen und der schleifenindex um 1 reduziert. Nach 0 ist dann schluss.

    tempo ist das delay zwischen den schritten : tempo 100 ms ; ( verzoegerung 100 ms motortempo )

    Der nächste schritt ist mit 2 indexiert etc. Bei fullstep wird nur jedes 2. bitmuster benötigt.

    Am ende werden alle pins mit off : 0 portb ! ; auf low gesetzt.

    new words version 2

    MOT.CCW.FS MOT.CW.FS MOT.CCW.HS MOT.CW.HS SEQ.CCW.FS SEQ.CCW.HS SEQ.CW.FS SEQ.CW.HS STEP OFF TEMPO BITS


    In dieser version werden die bitmuster-sequenzen mit seq.cw.fs generiert

    und mit step bits + c@ portb ! verarbeitet

    step enthält am ende das delay mit tempo
    Es folgen die mot-worte welche die sequenzen n times wiederholen


    Eine deutsche forth-anleitung Einführung in Forth als Computersprache.pdf

    Ist zwar veraltet aber das forth-prinzip ist stehts das gleiche.


    Allen ein schönes wochenende 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Forth Programming on Arduino Nano II


    Anknüpfen an posting #5 zeige ich wie ein schrittmotor, mit dem nötigen treiber an den pins 8 9 10 11 am arduino nano (atmega 328) betrieben werden kann.

    Verwendung finden die worte:

    \ kommentar

    init setzt portb als output und portd als input pullup

    binary setzt system in den binärmodus

    decimal setzt system in den binärmodus

    constant erzeug eine konstante mit den step-werten. Konstanten werden schneller abgearbeitet.

    variable erzeugt die variable für die motordrehzahl

    portb legt die adresse des portb-dataregisters auf den stack

    times führt die voangegangenen worte nach dem obersten wert auf dem stack, hier 8 mal aus.

    : ein neues wort definieren

    ; abschluss nach wort-definition

    flush ist nötig nach der compilierung neuer worte

    extend macht die neuen lexikoneinträge permanent. Auch hier ein flush nach dem extend eingeben.


    Neue worte werden interaktiv im fenster von teraterm (in meinem fall) entworfen und getestet.

    Tun sie was man will, kopiert man den code in eine textdatei und stellt das programm schlussendlich zusammen.

    In teraterm kann diese quelldatei geöffnet werden und als imputstream an den Nano gesendet werden. Das programm wird wort für wort compiliert und in das lexikon geschrieben.

    Das lexicon sieht anschliessend so aus. Alle worte ab INIT sind neu vorhanden und können verwendet werden.

    lexicon.jpg

    Tipt man in teraterm MOTOR ein, so wird ein an pins 8 9 10 11 angeschlosseneer stepper 8 halbschritte machen.

    Ein motor mit 64 halbschritten pro umdrehung benötigt dann den ausdruck 8 times im wort 1cicle.


    Mit den neuen worten kann nun jeder motor betrieben werden indem man wenige anpassungen macht.

    zB. motorcw motorccw motor374stepcw motor100timesvorandback etc.


    Unschön ist die verwendung des wortes tempo, das ein delay beinhaltet.

    Hier wäre eine verzögerung mit dem prinzip milis in der arduino-ide zu entwerfen.

    Auch könnte eine schrittsequenz in ein byte-array geschrieben werden.


    20210613_111814(1)_resized(1).jpg


    Ich weile am lac de la gruiere und kann darum kein video mitliefern. Heit e glückligi zyt 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Mecrisp Stellaris Forth auf STM32 Bluepill


    Zum arbeiten mit Stellaris benötigt es ein Terminal. Hier wird Tera_Term verwendet.

    TeraTerm downloaden und installieren

    usb-serial zu stm32 bluepill.jpgStm32 Bluepill mit USB-Seriell-Aadapter am PC USB einstecken und Reset drücken


    Tera-Term starten, serial-modus auswählen und OK klickenDas terminalfenster popt auf.

    teraterm1.PNG

    Bei einstellungen serieller port wählen und OK klicken


    teraterm2.PNG

    Einstellungen Serieller Port. Hier speed auf 115200 stellen. Mit klick auf New setting übernehmen


    Das leere terminalfenster erscheint wieder


    Drückst du jetzt den reset-knopf, startet das program mit dieser meldung:

    teraterm4.PNG


    Zur korrekten darstellung einstellungen - terminaleinstellungen bei neue zeile beide werte auf LF wechseln.


    Wer will kann noch die schriftart anpassen. einstellungen - einstellungen - schriftart

    teraterm3.PNG

    Nach OK ist Jetzt auch das terminal-fenster grösser.


    Entertaste drücken und der bekannte forth-promt OK erscheint.

    teraterm5.PNG


    Abschliessend noch einige links:


    Dokumentation. https://mecrisp-stellaris-folkdoc.sourceforge.io


    jephthai zeigt einiges auf einem STM32 Bluepill.

    0033mer zeigt einiges auf einem STM32 Blackpill.


    Bis zum nächsten posting heit e gueti wuche 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *



  • Mecrisp Stellaris Forth auf STM32 Bluepill


    Eine weitere möglichkeit bietet sich mit dem STM32 Bluepill Board.

    Um die installation flink zu halten, bereitete ich alles vor.

    Mit diesen anweisungen lässt sich mecrisp stellaris auf das stm32-board flashen.


    usb-serial zu stm32 bluepill.jpg Ein USB.Serial Adapter verbunden mit dem STM32 Bluepill.


    stm32 bluepill.jpg Am STM32 Verbindung anschliessen: Gelb A9 - grün A10 - blau GND - orange 3.3V


    usb-serial-adapter.jpg Am USB-Serial Adapter Verbindung anschliessen: gelb RXD - grün TXD - blau GND - orange 3V3


    usb-serial adapter ch340.jpg Auch dieser billig Adapter funktioniert: rot 3V3 - grün TXD - orange RXD - schwarz GND


    wenn nötig CH341 Treiber abholen und installieren


    flash_loader_demo_v2.8.0 abholen und installieren

    The STM32 Flash loader demonstrator (FLASHER-STM32) is a free software PC utility from STMicroelectronics


    mecrisp-stellaris-stm32f103.hex abholen zum flashen des STM32 Bluepill

    mecrisp-stellaris-stm32f103rb ist frei auf GitHub erhältlich


    Den STM32 Bluepill und USB-Serial-Adapter wie gezeigt miteinander verbinden und das USB-Serial-Modul mit dem PC verbinden.

    Der verbindungston ertönt und im gerätemanager wird sie bei mir als USB-Serial CH340 (COM6) angezeigt.

    Den STM32 Bluepill in den programmmodus setzen

    Blue-Pill-Operating-Modes-1024x581.jpg

    dann den RESET-botton drücken


    flash_loader_demo_v2.8.0 starten und folgende einstellungen machen:


    Capture1.PNGder com-port wird automatisch erkannt

    next klicken

    Capture2.PNGdie grüne ampel zeigt bereitschaft, Flash-size 64kb des stm32 bluepill

    next klicken

    Capture3.PNGalle die grünen blöcke sind bereit

    next klicken

    In folgenden open-dialog unten rechts von "s19 Files" auf "hex Files" umstellen und zur "mecrisp-stellaris-stm32f103.hex" navigieren

    Capture4.PNGzur datei mecrisp-stellaris-stm32f103.hex navigieren und öffnen

    next klicken

    Die datei wird in den STM32 Bluepill geflasht

    Capture5.PNGder blaue verlaufbalken läuft und endet bei grün wenn alles ok ist

    auf close klicken


    Achtung! Jetzt bevor die kabel abgezogen werden den Jumper auf Operating-Mode zurücksetzen und den Resetknopf drücken.


    Fortsetzung folgt 1416-wink2-gif

    * letzte Worte des Fallschirmspringers : " scheiss Motten" ! *