TMC222 Ansteuerung bzw Programmierung über USB vom Rechner..

Hallo zusammen.
Ich habe hier chon etliche Foren durchgelesen, aber es bleiben immernoch viele Fragen offen bzgl der Ansteuerung des TMC222 und wie ich den überhaupt einsetze.

1. Der TMC 222 ist ja quasi der Treiber für einen Schrittmotor und beinhaltet die wichtigen Daten eines Schrittmotor im Vmax Vmin usw....

Wie sag ich dem TMC denn dass er einfach nur nen Schritt weiterdrehen soll und wieso muss ich immer nen MC hinzunehmen?
Kann ich nicht einfach direkt per Befehle vom Computer dem TMC sagen was er machen soll im quasi realtimebetrieb?

Oder hat jemand schon den Aufbau so ungefähr hinbekommen.
I/O Warrior über usb am Rechner, und dann per I2C Bus an den TMC gehend um den Schrittmotor die Drehbefehle zu geben????

Hab das irgendwie noch nicht so drauf :-(

danke für die Hilfe

Natürlich per I2C denn was anderes versteht er nicht.

Les dir das Datenblatt in ruhe einmal durch dann siehst du viel klarer. ;)

Forensuche schon benutzt?
https://www.roboternetz.de/phpBB2/ze...ag.php?t=21730 gefunden?

Per I2C ist mir auch klaro, aber wie steuer ich dann den I2C Controller per USB z.B. an ? Kann ich quasi in basic ein programm schreiben, das dann über usb an den MC senden und der sendet dann befehle rüber über i2c zum TMC222?

Hab hier schon alles mögliche durchgelesen und blick da noch nicht ganz durch...

Wir müssen das ganze auf jeden Fall vom Rechner aus per USB ansteuern, kennt da jemand eine Möglichkeit?

Hi mull,
ich hab den TMC222 nur ganz kurz benutzt... steht aber alles schön im Datenblatt erklärt. Zum Thema USB: Der IO-Warrior kann ja als I2C-Master verwendet werden... also sollte der TMC222 kein Problem sein. Schau dir halt von allen Modulen mal die Doku an, dann sollte das schaffbar sein.

Gruß,
SIGINT

In wie weit hast du den denn am laufen gehabt und mit welchem MC?

Kann man den TMC über I2C auch an einen USB - I2C Adapter direkt am Rechner betreiben ?
Oder ich geh en Weg über den Io Warrior, den hatte ich mir auch schon ausgepickt.
Hab mir die Dokus alle schon durchgelesen, manche Dinge werden mir aber noch nicht klar.
Wenn der die ganzen Infos im OPT hat, mit welchem Befehl lass ich dann nen Schrittmotor drehen?

Grüssle

Ich hab damals mit dem C-Control I Station 2 das TMC222-Modul angesteuert. Da gab es ein Beispiel auf der CD, wenn ich mich richtig erinnere. Aber du kannst das Modul, da es ja ein I2C Interface besitzt, sogar an einer BT878 TV-Karte anschließen... die besitzt nämlich auch einen I2C-Bus. Jeder I2C-Bus sollte ohne Probleme funktionieren.

Ab Seite 29 werden die Befehle beschrieben, die der TMC kennt. Wenn ich mich richtig erinnere, dann kannst du mit ResetPosition die aktuelle Position des Motors als Nullposition festlegen und mit SetPosition eine neue Position, relativ zur Nullposition, anfahren.
Noch eine wichtige Sache, die mir am Anfang nich klar war und einige Probleme bereitet hat: Der Endtaster, den man am TMC anschliessen kann, wird nicht vom TMC zur Nullpunktsuche verwendet. Der Taster kann nur per Software abgefragt werden. Also könnte man den Taster direkt am µC anschliessen.

Leider ist es schon ne Ewigkeit her, daß ich mit dem Modul rumgespielt hab und ich war damit auch nicht wirklich zufrieden, deshalb kann ich nichts genaueres mehr sagen.

Gruß,
SIGINT

Achso, du meinst damit das Atmel Gerät von Conrad...
Ich hatte daran gedacht das Modul RN-Mega2560 zu benutzen und daran den TMC222 zu hängen....
Mit Bascom dann das ganze fertig zu programmieren.
Jetzt meine Frage, wodurch lass ich den Schrittmotor dann anfangen zu drehen oder eine Strecke abfahren. Das Programm lade ich ja in das RN-Mega2560 Modul und wie gehts dann weiter ?

Danke für die Bemühungen bislang.
Michael

Von Conrad ist das... aber Atmel bin ich mir nicht sicher. Ich glaube da ist ein 68HC_irgendwas drin.

Zum TMC:
Wenn ich das richtig in erinnerung habe, dann geht das so:
1) Motorparameter und Adresse einstellen
2) Referenzpunkt anfahren oder Position auf 0 setzen. Dafür gibts passende Befehle, wobei ich die Referenzsuche nicht wirklich verstanden habe.
3) Mit SetPosition die neue Zielposition festlegen

Dann sollte der Motor automatisch die Zielposition anfahren. Ein genaues Studium des Datenblattes ist aber dringend notwendig, da die Motorparameter richtig eingestellt werden müssen.

Gruß,
SIGINT

Ok die Befehle habe ich mir auch schon angeguckt, aber ich glaueb das Grundprinzip ist mir noch nicht so ganz klar.

Ich Programmier also in Bascom eine "Fahrt", lade die dann in das Modul, und dann düst der Schrittmotor direkt los?

Gibts da nicht sowas wie, ich lege einen Schalter um und dann gehts erst los...

Ne, einen Schalter gibts da nicht... sobald der Befehl erkannt wurde fährt der los.

P.S.: Schau doch mal, ob du im Netz die Doku von dem Conrad-Modul findest, da wurde das ganz gut erklärt.

Warum den nen Schalter ?

Egal.
Pack den "Schalter" halt an den Controller der dann bei Betätigung den passenden Befehl sendet.

Gib doch einfach mal mehr IUnfos was du machen möchtest.

Der TMC222 kann einen Schalter (Referenzpunkt) verarbeiten,
und dessen Status (offen oder Vcc/GND = egal) wird dann im I2C Protokoll übermittelt.

SWI hat den einen Status (1) bei LOW (GND) oder HI (VCC) und den anderen Status (0) bei OPEN!

Dies hat jedoch keinen Einfluss auf den Motor sondern ist für die Weiterverarbeitung im uC vorgesehen.

Um eines klar zu stellen:
der TMC222 ist für Positionierungsaufgaben entwickelt worden.
Ein permanentes (ständiges) drehen des Motors ist nicht vorgesehen.
Der TMC222 optimiert auch die Strecke zu den angegebenen Positionen.
Wenn die Richtung von der aktuelle Position zur neuen Position links herum kürzer ist als rechts herum dann drehrt der Motor eben anders herum als beabsichtigt. (Man muss dies bei der Programmierung berücksichtigen ggf akt. Pos. neu setzten.)
Möglich wäre eine pseudo kontinuierliche drehung, indem man immer wieder abfragt, in welcher Position sich der Motor gerade befindet und bei überschreiten einer "Zwischenposition" dann eine neue Zielposition senden.

[highlight=yellow:3ed0598469]WICHTIG:[/highlight:3ed0598469]
Please check that the correct supply voltage is applied to the circuit before zapping the OTP
(See: Table 39: DC Parameters Supply and Voltage regulator on page 38 ),
otherwise the circuit will be destroyed.

Wichtig ist es auch die richtigen Motorparameter einzustellen.

[highlight=red:3ed0598469]GANZ WICHTIG:[/highlight:3ed0598469]
Der TMC arbeitet nicht mit 5V sondern benötigt mindestens 8V sonst geht da garnix.
Ich habe es auch zunächt mit der VCC (5V) vom Controller probiert aber so funktioniert er eben nicht!

Wenn dann der TMC erst mal antwortet,
einfach eine neue Motor-Position senden und er legt los.

Hier mal die einfachste Einstellung der

Motorparameter:
------------------------------------------
Irun [0..15 = max] = 15
Ihold [15..0 = max] = 13
Vmax [0..15 = max] = 15
Vmin [Vmax =0..15 1/32 Vmax] = 0
Shaft Richtung d. Achse[0/1] = 0
Acceleration [0..15 = max] = 1
Sichere Position [0..2047] = 0
Acc Form [0/1] = 0
Step Mode ( 1/2 Step ) = 0
------------------------------------------

Danach muss eine Status1 ([highlight=green:3ed0598469]getFullStatus1[/highlight:3ed0598469]) Abfrage durchgeführt werden,
damit der TMC die Parameter "frisst", sonst tut sich da nicht viel.

GetFullStatus1 Code 0x81 (= 129 dez)
(daraufhin erhält man eine 8-Byte Antwort wie im Datenblatt unter 6.8.1 GetFullStatus1 erläutert (Byte 0 ist in Bascom nicht relevant)

Erst danach kannst Du eine neue Motorposition anfahren.

Jetzt sollte der Motor bestromt zu werden (Haltemoment).
Ist dies der Fall hats du schon gewonnen.

Nicht ganz so einfach ist die zerlegung bzw. die Zusammenstellung der Bitmuster
um die Parameter / Befehle an den TMC zu senden.

Schau Dir hierzu am besten meine Beispiel-Sources (in Bascom) an:

Beispielprogramm Downloaden

Informelle Links:
- Datenblatt des TMC222 : http://www.trinamic.com/tmc/media/Do...ircuits/Tmc222
- Mein TMC222 Projekt : https://www.roboternetz.de/phpBB2/ze...ag.php?t=21730
- Roboternetz Beitrag : https://www.roboternetz.de/phpBB2/ze...trag.php?t=783
- Roboternetz Beitrag : https://www.roboternetz.de/phpBB2/ze...rag.php?t=2627

Code:

' Original TMC222 Command Set ' Folgend der komplette Befehlssatz des TMC 222 ' ------------------------------------------ ---------------------------------------------------- Const Tmc222_getfullstatus1 = &H81 ' Returns complete status of the chip 0x81 Const Tmc222_getfullstatus2 = &HFC ' Returns actual, target and secure position 0xFC Const Tmc222_getotpparam = &H82 ' Returns OTP parameter 0x82 Const Tmc222_gotosecureposition = &H84 ' Drives motor to secure position 0x84 Const Tmc222_hardstop = &H85 ' Immediate full stop 0x85 Const Tmc222_resetposition = &H86 ' Sets actual position to zero 0x86 Const Tmc222_resettodefault = &H87 ' Overwrites the chip RAM with OTP contents 0x87 Const Tmc222_runinit = &H88 ' Reference Search 0x88 Const Tmc222_setmotorparam = &H89 ' Sets motor parameter 0x89 Const Tmc222_setotpparam = &H90 ' Zaps the OTP memory 0x90 Const Tmc222_setposition = &H8B ' Programmers a target and secure position 0x8B Const Tmc222_softstop = &H8F ' Motor stopping with deceleration phase 0x8F Const Tmc222_factory_adr_hwl = &HC0 ' Adresse im Auslieferzustand bei HW = LOW Const Tmc222_factory_adr_hwh = &HC2 ' Adresse im Auslieferzustand bei HW = HI Const Tmc222_general_adr = &H00 ' General Adresse zur Ermittlung der 'realen' Adresse

Auszug aus meinem TMC222 Projekt : https://www.roboternetz.de/phpBB2/ze...ag.php?t=21730

Code:

Sub Getstatus1(byval Tmc_index As Byte) Local W_adresse As Byte Local R_adresse As Byte R_adresse = Bar_ad(tmc_index) Or &B00000001 ' R/W - Bit setzten (lesen) W_adresse = R_adresse And &B11111110 ' R/W - Bit löschen (schreiben) Call Clear_tmp_rw() ' Array löschen ' Befehl an den TMC senden I2csend W_adresse , Cst_getfullstatus1 ' Befehl an TMC senden ' Daten vom TMC empfangen I2creceive R_adresse , Bar_tmp_rw(1) , 0 , 8 ' Empfange 8 Bytes von Adresse ' Empfange Daten auswerten ' --- Byte 1 --- Bar_st1adr(tmc_index) = Bar_tmp_rw(1) And &B00011111 ' maskieren ' --- Byte 2 --- ' > Irun Bar_irun(tmc_index) = Bar_tmp_rw(2) And &B11110000 ' oberes Nibble maskieren Shift Bar_irun(tmc_index) , Right , 4 ' und nach rechts schieben ' > Ihold Bar_ihold(tmc_index) = Bar_tmp_rw(2) And &B00001111 ' unteres Nibble maskieren ' --- Byte 3 --- ' > Vmax Bar_vmax(tmc_index) = Bar_tmp_rw(3) And &B11110000 ' oberes Nibble maskieren Shift Bar_vmax(tmc_index) , Right , 4 ' und nach rechts schieben ' > Vmin Bar_vmin(tmc_index) = Bar_tmp_rw(3) And &B00001111 ' unteres Nibble maskieren ' --- Byte 4 --- ' > AccShape Bar_accshape(tmc_index) = Bar_tmp_rw(4) And &B10000000 ' maskieren Shift Bar_accshape(tmc_index) , Right , 7 ' und nach rechts schieben ' > StepMode Bar_stepmode(tmc_index) = Bar_tmp_rw(4) And &B01100000 ' maskieren Shift Bar_stepmode(tmc_index) , Right , 5 ' und nach rechts schieben ' > Shaft Bar_shaft(tmc_index) = Bar_tmp_rw(4) And &B00010000 ' maskieren Shift Bar_shaft(tmc_index) , Right , 4 ' und nach rechts schieben ' > ACC Bar_acc(tmc_index) = Bar_tmp_rw(4) And &B00001111 ' maskieren ' --- Byte 5 --- ' > VddReset Bar_vddreset(tmc_index) = Bar_tmp_rw(5) And &B10000000 ' maskieren Shift Bar_vddreset(tmc_index) , Right , 7 ' und nach rechts schieben ' > StepLoss Bar_steploss(tmc_index) = Bar_tmp_rw(5) And &B01000000 ' maskieren Shift Bar_steploss(tmc_index) , Right , 6 ' und nach rechts schieben ' > ElDef Bar_eldef(tmc_index) = Bar_tmp_rw(5) And &B00100000 ' maskieren Shift Bar_eldef(tmc_index) , Right , 5 ' und nach rechts schieben ' > UV2 Bar_uv2(tmc_index) = Bar_tmp_rw(5) And &B00010000 ' maskieren Shift Bar_uv2(tmc_index) , Right , 4 ' und nach rechts schieben ' > TSD Bar_tsd(tmc_index) = Bar_tmp_rw(5) And &B00001000 ' maskieren Shift Bar_tsd(tmc_index) , Right , 3 ' und nach rechts schieben ' > TW Bar_tw(tmc_index) = Bar_tmp_rw(5) And &B00000100 ' maskieren Shift Bar_tw(tmc_index) , Right , 2 ' und nach rechts schieben ' > Tinfo(1:0) Bar_tinfo(tmc_index) = Bar_tmp_rw(5) And &B00000011 ' maskieren ' --- Byte 6 --- ' > Motion(2:0) Bar_motion(tmc_index) = Bar_tmp_rw(6) And &B11100000 ' maskieren Shift Bar_motion(tmc_index) , Right , 5 ' und nach rechts schieben ' > ESW Bar_esw(tmc_index) = Bar_tmp_rw(6) And &B00010000 ' maskieren Shift Bar_esw(tmc_index) , Right , 4 ' und nach rechts schieben ' > OVC1 Bar_ovc1(tmc_index) = Bar_tmp_rw(6) And &B00001000 ' maskieren Shift Bar_ovc1(tmc_index) , Right , 3 ' und nach rechts schieben ' > OVC2 Bar_ovc2(tmc_index) = Bar_tmp_rw(6) And &B00000100 ' maskieren Shift Bar_ovc2(tmc_index) , Right , 2 ' und nach rechts schieben ' 1 &B00000010 ' nichts zum auswerten ' > CPFail Bar_cpfail(tmc_index) = Bar_tmp_rw(6) And &B00000001 ' maskieren ' --- Byte 7 --- ' &B11111111 ' --- Byte 8 --- ' &B11111111 End Sub End

Code:

Sub Showstatus1(byval Tmc_index As Byte) Local Txt As String * 8 Txt = Str_stepmode(bar_stepmode(tmc_index) ) Print " Adress (ST1) : " ; Bin(bar_st1adr(tmc_index) ) Print " Irun : " ; Bin(bar_irun(tmc_index)) Print " Ihold : " ; Bin(bar_ihold(tmc_index)) Print " Vmax : " ; Bin(bar_vmax(tmc_index) ) Print " Vmin : " ; Bin(bar_vmin(tmc_index) ) Print " AccShape : " ; Bin(bar_accshape(tmc_index)) Print " StepMode : " ; Bin(bar_stepmode(tmc_index) ); Print " (" ; Txt; Print ")" Print " Shaft : " ; Bin(bar_shaft(tmc_index) ) Print " ACC : " ; Bin(bar_acc(tmc_index) ) Print " VddReset : " ; Bin(bar_vddreset(tmc_index) ) Print " StepLoss : " ; Bin(bar_steploss(tmc_index) ) Print " ElDef : " ; Bin(bar_eldef(tmc_index) ) Print " UV2 : " ; Bin(bar_uv2(tmc_index) ) Print " TSD : " ; Bin(bar_tsd(tmc_index) ) Print " TW : " ; Bin(bar_tw(tmc_index) ) Print " Tinfo : " ; Bin(bar_tinfo(tmc_index) ) Print " Motion : " ; Bin(bar_motion(tmc_index) ) Print " ESW : " ; Bin(bar_esw(tmc_index) ) Print " OVC1 : " ; Bin(bar_ovc1(tmc_index) ) Print " OVC2 : " ; Bin(bar_ovc2(tmc_index) ) Print " CPFail : " ; Bin(bar_cpfail(tmc_index) ) End Sub End

Wow, danke für die Antwort.

Also eigentlich hatte ich vor, mit dem TMC Plottermässig in Määnderform eine Fläche abzufahren, um an jedem Haltepunkt, voerst jeden 1cm , kurz eine Lichtintensitätsmessung vorzunehmen und dann zum nächsten Punkt zu fahren. Sprich, 10 mal nach rechts fahren, einmal hoch, 10 mal nach links fahren, einen hoch, wieder 10 mal nacht rechts usw.....
Bis die ganze Fläche quasi abgetastet ist, brauche ich für meine Studienarbeit.
Oder meint ihr ich sollte dafür eine andere Schrittmotoransteuerung benutzen?

Vielen Dank, Michael

Je nach gusto...

Für Deine "kurzen" Strecken ist die Schrittmotor-Lösung durchaus praktikabel und auch mit einigermaßen normalen Programmieraufwand zu bewältigen.
(Egal ob mit TMC222 oder L297/L298 oder oder oder, das hängt letztendlich von der Leistung der Motoren und deren Stromaufnahme sowie deren Schrittgeschwindikeit ab).

Vorteil vom TMC222 für Dich:
1. alles Motortechnische in einem IC (Ansteuerung und Endstufe)
2. brauchst Du Dir keinen Kopf über die Anstuerung des Motors machen (dafür über die Programmierung der Befehle)
3. Sind die gelieferten 800mA durchaus für Dein Projekt ausreichend (denke ich mir mal so).
3. zu 100% programmtechnisch parametrierbar.

Etwas aufwendiger zu programmieren als ein L297 dafür können mit weniger Ports (eigentlich nur ein I2C) mehre Motoren angesteuert werden (bis zu 32!!! Motoren an einem Port)

Braucht auch weniger platz, und ich glaube ist auch günstiger als die L297/L298 Lösung (Die Liefert aber auch mehr Stom).

Es geht aber auch mit noch weniger Strom (L293) oder andere Chips
siehe: Schrittmotor Beschreibung im RN-WiKi

Sollten es längere Strecken werden oder ist ein "normaler" Fahrantrieb benötig,
so sind "normale" Motoren (ggf. mit Getriebe) und PWM Ansteuerung sowie Odometrie (Wegsteckenzähler/Tachometer) sicherlich eine einfachere Lösung. (vgl. ASURO)

Evtl. bietet Dir der ASURO schon alles was du brauchst:

Fertiger Bausatz (alles dabei)
frei programmierbar
relativ günstig (so etwa €50,-)
relativ klein (naja kein Winzling aber auch nicht groß, auf jeden Fall für den Tisch geeignet).

Geprüfte und durchdachte Hard/Software
Wird hier im Roboternetz auch diskutiert/geholfen

Für Deine Lichtmessung bestimmt einfach zu erweitern

Bild hier

ASURO beschreibung im RN-WiKi

ASURO-Forum im Roboternetz

PS: VDO steht auf fast jedem Tacho und bedeutet "Vereinigte Deutsche Odometerwerke"

Also ich habe mir jetzt den Atmel2560 zugelegt und versuche dann damit die Strecke abzufahren. Die Motorparameter muss ich auf jeden Fall am Anfang des Programms angeben oder ?

Der Schrittmotor soll eigentlich erstmal nur ne Fahrt von 2000 Schritten machen, dann kurz stoppen, danach wieder 2000 Schritte.
Das ganze sieht aus wie ein X/Y Schreiber und soll erst einmal im Ratser von 1em cm Haltepunkte anfahren, um danach die Lichtintensität zu messen.

Ist für manche hier, die schon Erfahrung damit gesammelt haben wahrscheinlich nicht so wahnsinnig schwer das zum Laufen zu bringen, oder ?

Grüssle

@mull
Sagmal in wieviel Foren willst Du mit dem gleichen Thema vollmüllen?

Bis jetzt gefundenen Einträge:
I²C Bus dringend Hilfe gesucht.
TMC222 Ansteuerung bzw Programmierung über USB vom Rechner..
RN2560 und TMC kommunizieren nicht über I2C ....
Problem mit RN2560 und TMC222 kommunikation über I2C

Eine Nachricht soll reichen und dann noch einen PN an mich...
(welche ich übrigens gerade beantwotet habe)

Kannst es scheinbar nicht erwarten,
da sind Fehler schon vorprogrammiert, und eine Nettikette ist das auch nicht (dem Forum gegenüber).

Beherrsche Dich etwas !

Naja, hie rginsg mir eigentlich eher darum ob schon jemand erfahrung mit dem 2560 gesammelt hat und mir nen Hinweis geben könnte wie das am einfachsten zu realisieren wäre.
Denke der 2560 wurde bislang noch kaum eingesetzt und ich will für ne Studienarbeit das Dingen einsetzen....

Aber die anderen Crosspostings waren mist, seh ich ein,sorry.