TMC222 Ansteuerung bzw Programmierung über USB vom Rechner..

[SIGINT]

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.

[Ratber]

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.

[darwin.nuernberg]

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

' 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

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

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

[mull]

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

[darwin.nuernberg]

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"

[mull]

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

[darwin.nuernberg]

@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 !

[mull]

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.