Ding:Schrittmotor Controller TMC222micro

Aus FabLab Nürnberg Wiki
Wechseln zu: Navigation, Suche
Foto
TMC222microt.png
Basisdaten
Status unbenutzbar
Schöpfer Udo (Diskussion)



Discontinued

Die Zeit hat mich überholt, der Hersteller hat die Produktion des IC eingestellt, daher macht es keinen Sinn dieses Bauteil weiter zu entwickeln. Sorry

https://www.trinamic.com/support/help-center/discontinued-products/discontinued-details/tmc222/


Diese Seite wird NICHT weiter bearbeitet (BETA Status)

==

Aufgrund unerwarteter technischer Problemen und anstehenden Zeitmangel muss ich dieses Projekt vorerst zurück stellen. SORRY


Für dieses Projekt benötigt

  • 1x TMC222micro Platine, fertig aufgebaut (TMC222 noch nicht programmiert, also Fabrikneu)
  • 1x Adruino
  • 2x 10K Widerstände
  • 1x Schrittmotor BiPolar (4-Kabel)
  • 1x Stromversorgung für Arduino (kann auch von USB erfolgen)
  • 1x Netzteil min. 8V 800mA (empf. 12V/1A) oder eine 9V Batterie (hält aber nicht lange durch) für den TMC
  • versch. Verbindungskabel / Jumperwires vom TMC22micro zum Arduino

Beschreibung der Schaltung

Der TMC222 ist ein Schrittmotor Controller für Positionierungsaufgaben

Die Position kann hierbei mit einem 16-Bit breiten Wert (0 - 65535) bestimmt werden. Im Idealfall wird dem Chip nur die Position angegeben an welche er den Motor steuern soll, der Rest wie Beschleunigung, Verzögerung, Geschwindigkeit, StepMode, Strombegrenzung usw. usf. wird vom Chip gesteuert, dies muss im IC natürlich vorher einmalig eingestellt sein.

Anwendungen

Mir fallen für diesen Einsatzzweck folgende Anwendungen ein:

  • Modellbahn: Drehscheibensteuerung, Schrankensteuerung, Hebebrückensteuerung
  • Regalsystem: Regalroboter fü z.B. CD-Sammlung ;-)
  • Zeigersteuerung: Zeiger für Analog Uhr, Anzeigeistrumente (Amaturenbrett im KFZ)
  • Lüftung: Schiebersteuerung für Luftverteiler
Außerdem ist im TMC222 eine Wegoptimierung eingebaut

Ist die angegebene Position von der aktuellen Position z.B. links herum kürzer als rechts herum wird dieser Weg eingeschlagen. Beispiel: akt. Pos = 250, Zielpos = 65530 (links herum wären nur -250 & -5 also -255 Schritte nötig) Dies kann durch abfragen der aktuellen Position und geschickter Programmierung der Zielposition umgangen werden. Auch kann die aktuelle Position jederzeit genullt oder auf einen beliebigen Wert gesetzt werden.

Genau aus diesem Grund ist dieses IC auch NICHT für z.B. CNC Steuerungen geeignet. Vielmehr eignet sich dieses IC um bestimmte Positionen mit definierten Parametern zu "anzufahren".

Dieses Sketch wird diskret ohne TMC Library (GitHub) aufgebaut
  • Beachte: Die I2C Leitungen, SCL und SDA benötigen einmalig einen 10kR Pull Up Widerstand zu +5V des Arduino
  • Beachte: Die Versorgungsspannung des TMC222 darf nicht unter 8V liegen
  • Beachte: Es muss ein Schrittmotor am TMC222 angeschlossen sein
  • Beachte: Die Pins HW und SWI haben keinen Logic Level!
HW löst den zweiten Adressbereich aus mehr dazu im Datenblatt
SWI ist ein Eingang für einen Refernzschalter mehr dazu im Datenblatt
Um diese Eingange auszulösen reicht ein Schalten auf (+UB)/GND im anderen Fall sind diese offen zu halten.
Im Layout wurde ein Schalten gegen GND vorgesehen
Important Hint: The SWI is not a logic level input as usual;
it needs to be connected via 1K resistor either to (+VBAT) or GND;

ansonsten kann der TMC keine sinnvollen Daten generieren

Datenblatt zum TMC222: http://www.trinamic.com/_articles/products/integrated-circuits/tmc222/_datasheet/TMC222_datasheet.pdf

Adressierung und OTP Memory

Der TMC222 wird über I2C (TWI) Bus angesprochen, dazu ist es erforderlich dass bei Verwendung mehrerer dieser ICs jeder seine eigene Adresse erhält, da sonst auf dem BUS Konflikte auftreten. Also NICHT gleich mehrere unkonfigurierten (fabrikneuen) IC's sofort und gleichzeitig anschließen. Diese müssen zuerst nach und nach auf eine individuelle Adresse programmiert werden (zu späteren einfachen Identifizierung habe ich auch das weiße Feld für eine Beschriftung mit der Programmierten Adresse auf der Platine vorgesehen).


Hierzu hat der TMC22 einen sog. OPT Speicher (frei übersetzt Einmalig programmiererbarer Speicher) Die Speicherzellen in diesem Speicher können ähnlich wie in einem EPROM gesetzt aber nie wieder zurückgesetzt werden. d.h. der Speicher inhalt kann jederzeit verändert werden aber nur nach oben. Es ist also Vorsicht beim beschreiben dieser Speicherzellen gegeben. Es muss also dem IC einmalig eine eindeutige Adresse gegeben werden. Hilfreich kann hier der HW Eingang sein, dieser Schaltet zwischen zwei Adressbereichen um.

Siehe auch im Datenblatt Abschnitt "6.3 Physical Address of the circuit"

Es ist somit möglich bis zu maximal 32 Motoren an einem einzigen Arduino I2C-Bus unabhängig voneinander anzusteuern Wenn das nicht reichen sollte kann man ja einen anderen Controller mit einbeziehen, welcher dann entweder über LAN oder Seriell (RS485) mit anderen Controllern Synchronisiert werden kann.

Werden alle 32 Treiber mit voller Leistung gefahren, dann hat man in Summe fast 26 Ampere an Stromaufnahme, also schon eine ordentliche Hausnummer für ein oder mehrere passende Netzteile. So ein 'normales' Kabel wie für die Breadboard's Verwendung findet kann da natürlich auch nicht mehr verwendet werden, das wird ganz schnell zum leuchten anfangen (BSQ)


Aufbau / Berechnung der I2C Adressierung (1 Byte)
       Im Datenblatt wird AD0 auf Bit1 genannt, da Bit0 IMMER die Richtung (schreiben/lesen) definiert.
          Bit7  Bit6  Bit5  Bit4  Bit3  Bit2  Bit1  Bit0
          ^     ^     ^     ^     ^     ^     ^     ^
          |     |     |     |     |     |     |     |
          |     |     |     |     |     |     |     Schreiben/Lesen
          |     |     |     |     |     |     HW-Pin Status
          |     |     |     |     |     programmierbares Adress-Bit
          |     |     |     |     programmierbares Adress-Bit 
          |     |     |     programmierbares Adress-Bit      
          |     |     programmierbares Adress-Bit      
          |     Immer 1 (HIGH) fest eigebrannt
          Immer 1 (HIGH) fest eigebrannt      
    

Auch die Motorparameter können in diesem OTP Speicher abgelegt werden, diese sind allerdings auch in einem flüchtigen RAM konfigurierbar und müssen dann eben bei jedem Neustart/Reset neu parametriert werden.

Die Steuerung geschieht immer mit einem sog. Daten-Telegramm, in welchen die einzelnen Paramerter eingetragen sind. Je nach Befehl an den TMC222 sind diese Telegramme anders aber ähnlich aufgebaut. Hierzu habe ich eingenen Funtionen im Nachfolgenden Sketch geschrieben.



Der Entwurf des Programms

Aufbau des Sketches Schritt für Schritt Damit das ganze nicht zu sehr Theorie wird, baue ich in den kommenden Tagen das Arduino Sketch so nach und nach auf, welches dann natürlich auch entsprechend dokumentiert den Einstieg in die Ansteuerung des TC222 erleichtern soll.

Im Gegensatz zu einfachen Bausteinen wie z.B. dem PCF8574, wird an den TMC22 nicht nur ein Byte gesendet oder empfangen, sondern gleich mehrere Bytes, in welchen die Daten codiert sind.

Ein bisschen Verständnis für die Programmierung speziell mit dem Arduino und Grundlagen im Umgang mit dem Arduino setze ich voraus.

Die TMC222 Befehle

Diese definieren wir als Konstanten mit sprechenden Bezeichnungen, damit wir uns nicht den Wert merken müssen

 // TMC222 Befehlssatz
 const byte _TMC222GetFullStatus1     = 0x81;
 const byte _TMC222GetFullStatus2     = 0xFC;
 const byte _TMC222GetOTPParam        = 0x82;
 const byte _TMC222GotoSecurePosition = 0x84;
 const byte _TMC222HardStop           = 0x85;
 const byte _TMC222ResetPosition      = 0x86;
 const byte _TMC222ResetToDefault     = 0x87;
 const byte _TMC222RunInit            = 0x88;
 const byte _TMC222SetMotorParam      = 0x89;
 const byte _TMC222SetOTPParam        = 0x90;
 const byte _TMC222SetPosition        = 0x8B;
 const byte _TMC222SoftStop           = 0x8F;

Variablen und Arrays

       byte _TMC222dump[9];                      // Ein Array zum arbeiten mit den TMC222 Daten
       byte _TMC222adr[32];                      // Ein Array mit allen erlaubten Adressen der TMC222 IC's
       int  _TMC222current[16];                  // Ein Array mit den Motorstromdaten des TMC222 IC's

Blibliotheken (Includes)

include <Wire.h>                                 // Bibliothek damit wir Daten über I2C Senden/Empfangen können

Der Setup Teil

  void setup() {
  // put your setup code here, to run once:
  // Nach einem Reset MUSS immer ein _TMC222GetFullStatus1 ausgeführt werden!
     Serial.begin(9600);        // open the serial port at 9600 bps:

Vordefinition aller erlaubten Adressen für die TMC222 IC's

Der Übersichtlichkeit wegen, habe ich alle erlaubten TMC222 Adressen hier in einem Array definiert.

Da man in der realen Anwendung selten so viele Bausteine gleichzeitig verwendet, kann dies später auch vereinfacht werden.

     // Vordefinition aller erlaubten Adressen für die TMC222 IC's (nur der Übersicht wegen)
     _TMC222adr[0] =  0x60;  // BIN =  1100000  DEZ = 96    - wenn HW = offen 
     _TMC222adr[1] =  0x62;  // BIN =  1100010  DEZ = 98    - wenn HW = offen
     _TMC222adr[2] =  0x64;  // BIN =  1100100  DEZ = 100   - wenn HW = offen 
     _TMC222adr[3] =  0x66;  // BIN =  1100110  DEZ = 102   - wenn HW = offen 
     _TMC222adr[4] =  0x68;  // BIN =  1101000  DEZ = 104   - wenn HW = offen 
     _TMC222adr[5] =  0x6A;  // BIN =  1101010  DEZ = 106   - wenn HW = offen 
     _TMC222adr[6] =  0x6C;  // BIN =  1101100  DEZ = 108   - wenn HW = offen 
     _TMC222adr[7] =  0x6E;  // BIN =  1101110  DEZ = 110   - wenn HW = offen 
     _TMC222adr[8] =  0x70;  // BIN =  1110000  DEZ = 112   - wenn HW = offen 
     _TMC222adr[9] =  0x72;  // BIN =  1110010  DEZ = 114   - wenn HW = offen 
     _TMC222adr[10] =  0x74; // BIN =  1110100  DEZ = 116   - wenn HW = offen 
     _TMC222adr[11] =  0x76; // BIN =  1110110  DEZ = 118   - wenn HW = offen 
     _TMC222adr[12] =  0x78; // BIN =  1111000  DEZ = 120   - wenn HW = offen 
     _TMC222adr[13] =  0x7A; // BIN =  1111010  DEZ = 122   - wenn HW = offen 
     _TMC222adr[14] =  0x7C; // BIN =  1111100  DEZ = 124   - wenn HW = offen 
     _TMC222adr[15] =  0x7E; // BIN =  1111110  DEZ = 126   - wenn HW = offen 
                          
     _TMC222adr[16] =  0x61; // BIN =  1100001  DEZ = 97    - wenn HW = GND oder +UB  
     _TMC222adr[17] =  0x63; // BIN =  1100011  DEZ = 99    - wenn HW = GND oder +UB
     _TMC222adr[18] =  0x65; // BIN =  1100101  DEZ = 101   - wenn HW = GND oder +UB
     _TMC222adr[19] =  0x67; // BIN =  1100111  DEZ = 103   - wenn HW = GND oder +UB
     _TMC222adr[20] =  0x69; // BIN =  1101001  DEZ = 105   - wenn HW = GND oder +UB
     _TMC222adr[21] =  0x6B; // BIN =  1101011  DEZ = 107   - wenn HW = GND oder +UB
     _TMC222adr[22] =  0x6D; // BIN =  1101101  DEZ = 109   - wenn HW = GND oder +UB
     _TMC222adr[23] =  0x6F; // BIN =  1101111  DEZ = 111   - wenn HW = GND oder +UB
     _TMC222adr[24] =  0x71; // BIN =  1110001  DEZ = 113   - wenn HW = GND oder +UB
     _TMC222adr[25] =  0x73; // BIN =  1110011  DEZ = 115   - wenn HW = GND oder +UB
     _TMC222adr[26] =  0x75; // BIN =  1110101  DEZ = 117   - wenn HW = GND oder +UB
     _TMC222adr[27] =  0x77; // BIN =  1110111  DEZ = 119   - wenn HW = GND oder +UB
     _TMC222adr[28] =  0x79; // BIN =  1111001  DEZ = 121   - wenn HW = GND oder +UB
     _TMC222adr[29] =  0x7B; // BIN =  1111011  DEZ = 123   - wenn HW = GND oder +UB
     _TMC222adr[30] =  0x7D; // BIN =  1111101  DEZ = 125   - wenn HW = GND oder +UB
     _TMC222adr[31] =  0x7F; // BIN =  1111111  DEZ = 127   - wenn HW = GND oder +UB
  • Die Bits 7 und 6 sind im TMC222 fest auf 1 vorprogrammiert und können nicht verändert werden (Binäre Darstellung: 11xxxxxx)
  • das Bit-0 (LSB) definiert bei I2C-Protokoll immer ob es sich um einen lesende oder schreibenden Zugriff auf das IC handelt (Binäre Darstellung: 11xxxxxX) in der Programmiersprache des Arduino (C) wird das Bit0 schlichtweg ignoriert,

da diese die Datenrichtung (lesen oder schreiben) definiert und somit im I2C Protokoll immer gleich definiert ist. Daher wurde die Übergabe diese Bit's schlichtweg weg gelassen.

  • Das Bit-1 stellt beim TMC222 den Zustand de Eingang-Pins HW dar und ist daher per Programm nicht beeinflussbar (Binäre Darstellung: 11xxxxXx) und wird in der Adressangabe als BIT0 (11xxxxX) übergeben.
(Zugegeben ich habe dies etwas verwirrend ausgedrückt, nehmt es als gegeben hin.)
Im Prinzip ist die Adressierung wie in der Tabelle von Trinamic dargestellt Bitweise um eins nach rechts verschoben zu betrachten, das niedrigste Bit fällt also raus und von links wird eine 0 "reingeschoben" damit das Byte wieder voll ist. (bei so viel Bit muss man ja voll sein)
Mit dem HW Eingang am TMC222micro können ohne Änderung der Speicherzellen im OTP zwei TMC222-ICs gleichzeitig und unabhängig von einander verwendet werden ohne dass es einen Adressenkonflikt gibt.

Vordefinition der Motor Stromstärken

Leider steigt der vom TMC222 einstellbare Motorstom nicht linear mit dem Übergabe Wert an, daher muss eine Tabelle definiert werden. Dafür werden am TMC22 keine externen Messwiderstände benötigt, diese sind bereits im IC integriert. Übrigens wird laut Datenblatt kein Kühlkörper für das IC benötigt

TMC222 Motorstrom Tabelle

     // Vordefinition der Motor Stromstärken, leider lassen sie die Werte nicht mittels MAP-Befehl errechnen.
     _TMC222current[0]  =  59;  // Irun oder Ihold =  59mA
     _TMC222current[1]  =  71;  // Irun oder Ihold =  71mA
     _TMC222current[2]  =  84;  // Irun oder Ihold =  84mA
     _TMC222current[3]  = 100;  // Irun oder Ihold = 100mA
     _TMC222current[4]  = 119;  // Irun oder Ihold = 119mA
     _TMC222current[5]  = 141;  // Irun oder Ihold = 141mA
     _TMC222current[6]  = 168;  // Irun oder Ihold = 168mA
     _TMC222current[7]  = 200;  // Irun oder Ihold = 200mA
     _TMC222current[8]  = 238;  // Irun oder Ihold = 238mA
     _TMC222current[9]  = 283;  // Irun oder Ihold = 283mA
     _TMC222current[10] = 336;  // Irun oder Ihold = 336mA
     _TMC222current[11] = 400;  // Irun oder Ihold = 400mA
     _TMC222current[12] = 476;  // Irun oder Ihold = 476mA
     _TMC222current[13] = 566;  // Irun oder Ihold = 566mA
     _TMC222current[14] = 673;  // Irun oder Ihold = 673mA
     _TMC222current[15] = 800;  // Irun oder Ihold = 800mA
}

Wie in der Tabelle ersichtlich kann der Strom nicht auf 0mA gesetzt werden,

also wird der Motor theoretisch immer bestromt. Allerdings kann man im TMC222 den Motor auch noch abschalten,

was wiederum dazu führt dass kein Strom mehr durch den Motor fließt.

Der loop Teil

 void loop() {
   // put your main code here, to run repeatedly:
  cleardump();
  TMC222GetFullStatus1(_TMC222adr[0]);     // Prozedur zum auslesen des TMC als Parameter wird die Adresse des IC's übegeben
  printdump();
  delay(10000);
 }

Nach dem Loop Teil können wir eigene Prozeduren schreiben

welche wir dann vom Hauprogramm (loop-Teil) aus aufrufen werden

Satzaufbau zur Abfrage des TMC222 GetFullStatus1

TMC222GetFullStatus1.png

  void TMC222GetFullStatus1(byte Adresse) {
     _TMC222dump[0] = Adresse;                                // I2C Adresse eines TMC222
     _TMC222dump[1] = _TMC222GetFullStatus1;                  // Den Befehl GetFullStatus1 in das Array schreiben
  }

Dieses Array wird an den TMC222 gesendet und anschließend werden die Empfangenen Daten darin abgelegt um diese dann anschließend entsprechend auszuwerten

Die Zeilen 0 bis 8 aus der Grafik entsprechen exakt dem Array Index 0 bis 8

Allerdings ist es etwas aufwändig die Daten sinngemäß aus dem Array zu lesen, bzw. in dass Array zu schreiben. Ich werde dies absichtlich etwas umständlicher schreiben in der Hoffnung dass es dadurch verständlicher wird. Die "Hacker" unter Euch mögen es mir nachsehen ;-)

Ausgabe des Zwischenspeichers

Darin werden die Befehle und Daten abgelegt welche wir zum TMC22 senden oder von diesem empfangen werden

 void printdump() {
    // ein einfaches darstellen des Array's _TMC222dump[]
    for (int i=0;  i<9; i++){
       Serial.print("Dump Data (");
       Serial.print(i);
       Serial.print(")   : ");
       Serial.println(_TMC222dump[i], BIN);
    }
    Serial.println();
 }

Leeren des Zwischenspeichers

  void cleardump() {
     // ein einfaches nullen des Array's _TMC222dump[]
     for (int i=0;  i<9; i++){
        _TMC222dump[i]=0;
     }
  }

Zusammenfassung

Übersicht der verwendeten Konstanten, Variablen und Funktionen

Konstanten

Der TMC222 Befehlssatz
_TMC222GetFullStatus1
_TMC222GetFullStatus2
_TMC222GetOTPParam
_TMC222GotoSecurePosition
_TMC222HardStop
_TMC222ResetPosition
_TMC222ResetToDefault
_TMC222RunInit
_TMC222SetMotorParam
_TMC222SetOTPParam
_TMC222SetPosition
_TMC222SoftStop

Variablen

_TMC222dump[9]
_TMC222adr[32]
_TMC222current[16]

Funktionen

printdump()
cleardump()
TMC222GetFullStatus1(Adresse des TMC222)

Wichtige Tipps

Ich kann es nicht oft genug wiederholen:

  • Die I2C Leitungen, SCL und SDA benötigen jeweils und einmalig einen 10kR Pull Up Widerstand zu +5V des Arduino
  • Die Versorgungsspannung des TMC222 darf nicht unter 8V liegen
  • Es muss ein Schrittmotor am TMC222 angeschlossen sein
  • Die Pins HW und SWI haben keinen Logic Level! und dürfen keinesfalls an den Arduino angeschlossen werden.
HW löst den zweiten Adressbereich aus mehr dazu im Datenblatt (am besten beim ersten Test unbeschaltet lassen)
SWI ist ein Eingang für einen Referenzschalter mehr dazu im Datenblatt (am besten beim ersten Test unbeschaltet lassen)

Nützliche Werkzeuge

Der TMC222micro als Baustein für Fritzing

Das TMC222micro als Bauteil zum Import in die Fritzing Software. eine gepackte ZIP Datei. Nach dem entpacken kann das Modul im den Fritzing Bauteilkatalog importiert werden

I2cScanner

Sollte es in irgendeiner Weise Problme mit der I2C Kommunikation geben? Ich habe Im Playground einen I2C Scanner gefunden:

Dieses Programm sucht den kompletten I2C Adress-Bereich nach I2C kompatiblen Devices ab.

TMC222+UNO+I2C-SCN.png

Mit diesem Tool habe ich z.B. festgestellt dass in Arduino C im Gegensatz von z.B. Bascom (das ist eine andere Programmiersprache für die AVR Prozessoren wie sie auch der Arduino verwendet und mit welchem ich meine ersten I2C Erfahrungen sammeln konnte), möglicherweise auch andere Programmiersprachen, das Bit0 nicht mit gerechnet wird. Die Adresse des I2C Bauteils also einen 7-Bit Wert darstellt (Bit1 bis Bit7).

Somit hat mir das kleine Programm schon viel Ärger und Frust erspart.

Üblicherweise wird die I2C-Adresse als 8Bit Zahl angegeben, wobei das niederwertigste Bit bestimmt, ob vom Baustein gelesen oder ob der Baustein beschrieben werden soll. Die Arduino-Bibliothek hingegen betrachtet die I2C Adresse als 7 Bit Zahl, so dass die Adresse aus dem Datenblatt erst halbiert werden bzw. besser um 1 Bit nach rechts "geshiftet/geschoben" werden muss.


     // --------------------------------------
     // i2c_scanner
     //
     // Version 1
     //    This program (or code that looks like it)
     //    can be found in many places.
     //    For example on the Arduino.cc forum.
     //    The original author is not know.
     // Version 2, Juni 2012, Using Arduino 1.0.1
     //     Adapted to be as simple as possible by Arduino.cc user Krodal
     // Version 3, Feb 26  2013
     //    V3 by louarnold
     // Version 4, March 3, 2013, Using Arduino 1.0.3
     //    by Arduino.cc user Krodal.
     //    Changes by louarnold removed.
     //    Scanning addresses changed from 0...127 to 1...119,
     //    according to the i2c scanner by Nick Gammon
     //    http://www.gammon.com.au/forum/?id=10896
     // Version 5, March 28, 2013
     //    As version 4, but address scans now to 127.
     //    A sensor seems to use address 120.
     // Version 6, November 27, 2015.
     //    Added waiting for the Leonardo serial communication.
     // 
     //
     // This sketch tests the standard 7-bit addresses
     // Devices with higher bit address might not be seen properly.
     //
      #include <Wire.h>
      void setup()
     {
       Wire.begin();
     
       Serial.begin(9600);
       while (!Serial);             // Leonardo: wait for serial monitor
       Serial.println("\nI2C Scanner");
     }
     void loop()
     {
       byte error, address;
       int nDevices;
       Serial.println("Scanning...");
       nDevices = 0;
       for(address = 1; address < 127; address++ ) 
       {
         // The i2c_scanner uses the return value of
         // the Write.endTransmisstion to see if
         // a device did acknowledge to the address.
         Wire.beginTransmission(address);
         error = Wire.endTransmission();
         if (error == 0)
         {
           Serial.print("I2C device found at address 0x");
           if (address<16) 
             Serial.print("0");
           Serial.print(address,HEX);
           Serial.println("  !");
           nDevices++;
         }
         else if (error==4) 
         {
           Serial.print("Unknow error at address 0x");
           if (address<16) 
             Serial.print("0");
           Serial.println(address,HEX);
         }    
       }
       if (nDevices == 0)
         Serial.println("No I2C devices found\n");
       else
         Serial.println("done\n");
       delay(5000);           // wait 5 seconds for next scan
     }

Jetzt fangen die Probleme an

Die Umsetzung der Kommunikation bereitet mit etwas Schwierigkeiten. Egal was ich teste ich erhalte immer das gleiche, falsche Resultat. Was mir in Bascom noch einleuchtend erschien, bereitet mit in der Arduino Umgebung einige Probleme, zumal es für mich an aussagekräftigen Beispielen für komplexe Kommunikation über den I2c Bus mit der Arduino Software mangelt.

Ich lasse keinesfalls locker, bitte jedoch um Geduld.

Üblicherweise wird die I2C-Adresse als 8Bit Zahl angegeben, wobei das niederwertigste Bit bestimmt, ob vom Baustein gelesen oder ob der Baustein beschrieben werden soll. Die Arduino-Bibliothek hingegen betrachtet die I2C Adresse als 7 Bit Zahl, so dass die Adresse aus dem Datenblatt erst halbiert werden muss.

BASCOM Version einer früheren Entwicklung

Zu meiner Ehrenrettung muss ich erwähnen das ich bereits eine funktionierende Programmierung im Roboternetz veröffentlicht hatte aber aus unerfindlichen Gründen dort nicht mehr auffindbar ist. Daher stelle ich die Dokumentation hier nochmals zur Verfügung.

Damals gab es noch keinen Arduino daher ist die komplette Beschreibung für einen ATmega32 ausgelegt. Ich versuche eine Umsetzung für den Arduino zu erstellen...

Datei:oldANL-BAS-TMC222.pdf

Im folgenden das Bascom Programm für den Arduino UNO umgeschrieben

Datei:TMC222micro für ArduinoUNO Configurator V5.zip

Abkürzungen

OTP = One Time Programmable
LSB = Least significant Bit (Niederstwertiges Bit)
MSB = Most significant Bit (Höchstwertiges Bit)
BSQ = Beißend Schwarzer Qualm