Programmierbare Schrittmotoransteuerung RN-Schrittmotor

Eine preiswerte und flexible Schrittmotoransteuerung die im Gegensatz zu vielen herkömmlichen Schrittmotoransteuerungen auf vielfältige Weise angesteuert werden kann. Das Schrittmotor Board RN-Schrittmotor verfügt über 3 Möglichkeiten der Schrittmotor Ansteuerung. Entweder per I2C-Bus, per RS232-Schnittstelle oder im herkömmlichen Taktmodus mit Takt und Richtungseingängen.
Auf diese Weise können sowohl PCs aber auch Mikrocontroller das Board bequem ansteuern. Eine eingebaute Eigenintelligenz entlastet PC und Controllerboard durch eine automatische Stromregelung und vielfältige und genaue Funktionen zum Ausführen von gezielten Schrittenfolgen. Die Motoren können natürlich völlig unabhängig aber auch gleichzeitig angesteuert werden. Bis zu 30 Volt Motorspannung und Phasenströme bis 2A sind möglich! 

Features und Leistungsmerkmale  dieses Schrittmotor-Projektes

• Deutlich höheres Drehmoment (Motorkraft) durch automatische PWM-Stromregelung gegenüber Schrittmotor Ansteuerung mit fester Spanung
• Voll- und Halbschrittmodus (im I2C-Betrieb, in RS232-Betrieb und bei Taktsteuerung)
• Maximal zulässige Strombegrenzung (bei Schrittmotor Strangstrommbegrenzung) kann durch einfachen Befehl von einem Controller oder PC zwischen ca. 100mA und max. 2A festgelegt werden. Kein rumschrauben mehr an Potis!
• Auch wenn kurzzeitig höhere Belastungen möglich sind, wird eine maximale Dauerbelastung von ca. 2 – 3 A pro Schrittmotor (Stangstrom 1 bis 1,5 A) empfohlen
• Getrennte Eingänge für Motorspannung und Betriebsspannung. Die Motorspannung kann 7V bis 35V annehmen. Die Betriebsspannung darf zwischen 7 und 24V liegen. Durch Brückung kann man auch mit einer Spannung auskommen.
• Es können nahezu alle bipolaren Schrittmotoren beliebiger Nennspannung ca. 3V bis zur Motorspannung (max 35V) angesteuert werden. Beispiel: Sie können auch einfach einen 4V Motor an ein Board mit 9V oder 12V anschließen, der Motor wird nicht überlastet da der max. Strom eingestellt wird. Dieses Schrittmotor arbeitet etwas ähnlich wie die beliebte L297/L298 Schaltung, bietet jedoch mehr High Level-Funktionen
• Durch die Verwendung eines größeren programmierten Controllers benötigt das ganze Board nur wenig Bauteile. Dies reduziert Kosten und die großzügige Dimensionierung der Platinenmaße erleichtert den Aufbau.
• Ein mitgelieferter Demo-Steuerprogramm erlaubt die Ansteuerung der Schrittmotoren bequem per Mausklick. Durch die Möglichkeit unterschiedliche Ströme und Geschwindigkeiten einzustellen, lassen sich Schrittmotoren auch optimal austesten.
• VB6-Quellcode des Steuerprogramms steht zum Download bereit. Natürlich kann man sich auch sehr leicht ein Programm in einer anderen Programmiersprache erstellen
• Übermittelt wird nur der Befehl der beschreibt wieviel Schritte ein bestimmter Motor in welcher Geschwindigkeit und Drehrichtung erfolgen soll. Um die Generierung und das zählen der Schritte kümmert sich das Board völlig automatisch. Dadurch wird der steuernde Controller oder PC erheblich entlastet
• 255 exakte Geschwindigkeitsstufen sind möglich
• Bei jeder Geschwindigkeit kann auch ein Beschleunigungswert angegeben werden. Dadurch können die Motoren langsamer beschleunigt werden (eine Rampe). So sind auch höhere Geschwindigkeiten ohne Schrittverlust möglich. Das gleiche ist auch beim Abbremsen möglich.
• Drehrichtung und max Strombedarf jederzeit änderbar
• Viele Vorgaben können dauerhaft im Board (EEPROM) abgespeichert werden
• Endlosfunktion, welche Schrittmotoren solange dreht bis ein Stopp Befehl kommt
• Schrittzähler, die ausgeführten Schritte der Motoren können jederzeit abgerufen werden, somit lässt sich exakt die Länge der gefahrenen Strecke berechnen
• Getrennter Strom für Halt, Beschleunigung und Betrieb einstellbar. Somit kann das Board wahlweise bei Motorstillstand automatisch einen geringeren Strom einstellen um z.B. die Batterie zu schonen.
• Neben I2C, RS232 kann das Board auch ganz normal über Taktleitungen, Richtungsleitung angesteuert werden, also so wie die meisten anderen Boards. So kann es auch mit üblichen Schrittmotorprogrammen für den PC angesteuert werden. Die Taktleitungen sind dann mit dem Druckerport zu verbinden (hier sind die Hinweise des jeweiligen PC Programmes zu beachten).
• Zwei Taster erlauben den schnellen Test des Boards auch ohne das ein anzusteuerndes Board oder PC vorhanden sein muss. Dies erleichtern Anfängern den Anschluss der Motoren.
• LED signalisiert wenn die Betriebsspannung nicht ausreicht um den Schrittmotor-Nennstrom (also maximale mögliche Leistung) bei der gewählten Geschwindigkeit zu erreichen. Eine recht nützliche Analysefunktion.
• Zur Steuerung des Board´s würde im Notfall ein RS232 TX PORT reichen. Bei der Boards wie z.B. RN-Control oder einem Arduino Uno könnte fast jeder Port dafür verwendet werden wenn in Basic programmiert wird. Ideal sind jedoch zwei Ports um auch die Rückmeldungen des Motorboards auswerten zu können.
• Ansteuerung über beliebige Controller z.B. Arduino-Boards, Raspberry Pi, RN-Control, RNBFRA,  RN-Mega8Plus, RN-MiniControl, PC und viele andere
• Europaformat nach Roboternetz-Definition. Dadurch mit anderen RN-Boards nach Roboternetz-Standard huckepack verschraubbar.
• Programmbeispielen für RN-Control stehen zum Download bereit
• Eagle-Datei für Platinenlayout steht zum Download bereit
• Firmware für Programmierung des AVR-Controllers von RN-Schrittmotor steht kostenlos zum Download bereit (Quellcode wird nicht benötigt, kann jedoch als Option für eigene Firmware-Entwicklungen erworben werden)

RN-Schrittmotor: Befehlsübersicht

Hier eine Kurzübersicht der Befehle die das Schrittmotorboard per RS232 oder I2C versteht. Die genauere Erläuterung per Parametern folgen dann etwas weiter unten in diesem Beitrag.

RN-Schrittmotor: Aufbau des Schrittmotor Boards

Der Aufbau der Schaltung ist durch eine vorgefertigte Platine und die überschaubare Anzahl an Bauelementen völlig problemlos auch von Einsteigern mit Elektronik Grundkentnissen zu bewerkstelligen. Das Eagle-Platinenlayout steht kostenfrei zum Download bereit. Über einen Leiterplattenhersteller (siehe Empfehlung Leiterplattenhersteller) kann man einfach eine Leiterplatte anfertigen lassen. Wenn man sich mit der CAD Software Eagle etwas aus kennt, kann man zuvor sogar eigene individuelle Änderungen am Layout vornehmen. Zum Teil sind Leiterplatten auch preiswert über Ebay erhältlich, versuchen Sie es über diesen Ebay Link*

Durch den Bestückungsplan und die Bestückungsliste, etwas weiter unten in dieser Dokumentation, ist der Aufbau recht unkritisch. Auf schwierig zu lötende und schwierig reparierbare SMD Teile wurde wieder absichtlich verzichtet. Die Schaltung ist je nach Erfahrung in ca. 60 Minuten aufgebaut.

Dennoch einige Anmerkungen zu kleinen Hürden:

1. Bei den Netzwerkwiderständen (RN1 bis RN4) auf die Polung achten. Der kleine Punkt auf dem Bauteil muss auf der Seite liegen wo die kleine 1 auf der Platine aufgedruckt ist.
2. Bei den Kondensatoren (Elkos) die Polung beim einlöten beachten. Diese ist auf Bauelementen und Platine aufgedruckt.
3. Den 16 Mhz Quarz mit ca. 2 mm Abstand zur Platinenoberfläche einlöten damit das Metallgehäuse keine Leiterbahnen verbindet.
4. Nicht vergessen das die zwei IC´s gesockelt werden. Also erst Sockel einlöten und dann IC einsetzen.
5. Die Polung der Leuchtdioden ist im Bestückungsdruck weiter hinten in dieser Anleitung zu ersehen. Die Anode ist das lange Bein einer LED, die Kathode das kurze Bein.
6. Der Kühlkörper kann direkt auf die Platine aufgesetzt und von unten angeschraubt werden. Unterlegscheiben sind nicht notwendig da die darunterliegende Leiterbahn ebenfalls GND führt.
7. Beim Einlöten der Motortreiber IC´s L298 ist zu bedenken das diese eine genaue Höhe einnehmen müssen, damit diese später bequem an den montierten Kühlkörper geschraubt werden können. Daher ist es empfehlenswert zuerst den Kühlkörper zu montieren. Der Kühlkörper wird durch zwei kurze handelsübliche 3mm Schrauben (ca. 4 bis 6 mm Länge) von der Unterseite der Platine angeschraubt. Er paßt genau auf die vordefinierten Löcher.

.Das waren eigentlich schon die besonderen Punkte die zu beachten sind. Ansonsten natürlich sauber mit einem 15 – 30 W Lötkolben oder einer Lötstation alles auf der Unterseite verlöten. Grundkenntnisse beim Löten werden schon empfohlen.
Nach dem Aufbau sollten Sie noch mal alle Lötpunkte kontrollieren. Wenn Sie dann Spannung anlegen, dann sollten in etwa 50 bis 100 mA Strom fließen. Ist der Strom deutlich höher, dann deutet das auf ein Lötfehler hin.

Wenn die Schrittmotoren korrekt angeschlossen sind, können diese nach dem Aufbau sofort über die Taster eingeschaltet werden. Sie sollten sich dann in langsamer Geschwindigkeit drehen. Für diesen Testmodi verwendet das Board die Grundeinstellungen, also ca. 100 mA Motorstrom.

Nach dem Aufbau muss man noch die Firmware (ein AVR-Programm das in binärer Form zum Download bereitsteht) in den Controller übertragen. Da das Board selbst keine kompatible ISP-Buchse besitzt, muss ein anderes Board zum programmieren des Controllers genutzt werden (z.B. RN-Control) . Oder man nutzt einen geeigneten Programmer mit  40 pol Sockel. Natürlich kann man auch eine eigene Firmware entwickeln, alle notwendigen Informationen dafür kann man aus dem Schaltplan entnehmen. Den Quellcode der aktuellen Firmware könnte man zur Hilfestellung für 99 Euro erwerben (Anfrage). Für die Funktion reicht aber auch das kostenlose HEX-File!

Erläuterung der Anschlüsse, Regler und Jumper

Bitte jeweiligen Punkt anklicken um die Beschreibung zu lesen.

1: I2C-SDA PullupWiderstand wird aktiviert (Standard Offen)
2: I2C-SCL PullupWiderstand wird aktiviert (Standard Offen)
3: Pullup für Leitung MyOKInt ein (Standard geschlossen)
4: LED 1 und LED 2 einschalten (Standard geschlossen)
5: 5V auf I2C-Stecker legen (Standard geschlossen)
6: Betriebsspannung auf I2C-Stecker legen (Standard offen)

1. M1R  Richtung von Motor 1
2. M1T  Takt für Motor 1 (eine kurze GND Verbindung bewegt Motor um einen Schritt)
3. M2R  Richtung von Motor 2
4. M2T  Takt für Motor 1
5. EN   Enable-Motoren ausschalten (GND schaltet Motoren ab)
6. MyOK Resevierter Port – derzeit nicht nutzen
7. GND
8. GND

1 M1END1 Wahlweise externer Endschalter für Motor 1  
         Motor stoppt wenn GND anliegt!
2 M1END2 Wahlweise externer Endschalter für Motor 1 
         Motor stoppt wenn GND anliegt!
3 M2END1 Wahlweise externer Endschalter für Motor 2 
         Motor stoppt wenn GND anliegt!
4 M2END2 Wahlweise externer Endschalter für Motor 2 
         Motor stoppt wenn GND anliegt!
5        keine Bedeutung
6 MyOK   Resevierter Port – derzeit nicht nutzen
7 GND
8 GND

RN-Schrittmotor: Wie sieht die Befehlssyntax aus?

Wie schon geschildert wird RN-Schrittmotor wahlweise über den I2C-Bus oder die serielle Schnittstelle RS232 angesteuert. Über beide Schnittstellen können die gleichen Befehle ausgeführt werden. Auch die Befehlssyntax ist über beide Schnittstellen nahezu identisch, so das man sich sehr schnell mit den Kommandos vertraut machen kann. Erwähnenswert ist noch das auch im Wechsel RS232 und I2C ohne eine Umschaltung genutzt werden kann.

Bei der Befehlssyntax wurde bewusst auf Übertragungssicherheit und einfache Handhabung Wert gelegt. Jeder Befehl besteht grundsätzlich aus 9 Byte, auch wenn nicht immer alle Bytes benötigt werden.

Die grundsätzlich Befehlssyntax für die RS232 Befehle sieht wie folgt aus:

1. Byte: Kennung immer 33 also ASCII-Zeichen “!”
2. Byte: Kennung immer 35 also ASCII-Zeichen “#”
3. Byte: Befehlscode (dieses Byte legt die Art des Befehles fest)
4. Byte: Motor (endweder 1 oder 2 oder 3 für beide)
5. Byte: Parameter 1 (je nach Befehl)
6. Byte: Parameter 2 (je nach Befehl)
7. Byte: Parameter 3 (je nach Befehl)
8. Byte: Parameter 4 (je nach Befehl)
9. Byte: CRC-Prüfsumme (falls CRC Mode genutzt wird)

Beispiel wie ein Befehl aussehen kann (in Bascom Basic):

Print "!#": chr(54);chr(3);chr(0); chr(0); chr(0); chr(0); chr(0);

Dieser Befehl würde beide Motoren in Endlosdrehung versetzen. Da dieser Befehl außer dem Motor keine Parameter benötigt, werden für die letzte 5 Bytes Nullen übertragen.

Befehlssyntax für I2C Übertragung:

Wie schon geschildert, ist die Befehlssyntax auch beim I2C-Bus nahezu identisch. Da jedoch I2C-Übertragungen in der Praxis sicherer sind, ist die Syntax leicht unterschiedlich. Eine Kennung ist hier nicht notwendig.

Die Syntax sieht wie folgt aus:

1. Byte: Befehlscode (dieses Byte legt die Art des Befehles fest)
2. Byte: Motor (endweder 1 oder 2 oder 3 für beide)
3. Byte: Parameter 1 (je nach Befehl)
4. Byte: Parameter 2 (je nach Befehl)
5. Byte: Parameter 3 (je nach Befehl)
6. Byte: Parameter 4 (je nach Befehl)
7. Byte: CRC-Prüfsumme (falls CRC Mode genutzt wird)

Es werden also generell immer 7 Bytes übertragen, auch wenn einige Befehle weniger Bytes benötigen. Für oberes Beispiel müsste der Befehl also bei der I2C Übertragung wie folgt aussehen (Bascom Basic):

I2cstart
  I2cwbyte slaveid
  I2cwbyte 54
  I2cwbyte 3
  I2cwbyte 0
  I2cwbyte 0
  I2cwbyte 0
  I2cwbyte 0
  I2cwbyte 0
I2cstop

Zusätzliche Sicherheit bei der Befehlsübertragung

Die zuvor geschilderte Befehlssyntax reicht gewöhnlich für die Übertragung von Befehlen aus. Werden bei der Übertragung jedoch Störungen erwartet, zum Beispiel bei sehr langen Leitungsverbindungen oder ungewöhnlichen Störquellen, so könnten in sehr seltenen Fällen Befehle nicht richtig erkannt werden.

Möchte man jedoch sicherstellen das die Schrittmotoransteuerung RN-Schrittmotor genau das tut, was es soll, so gibt es verschiedene Möglichkeiten. Sie könnten einfach die Rückmeldung des Boards prüfen. Wird ein Befehl korrekt ausgeführt, so wird über die RS232 Schnittstelle immer der ASCII-Code 42 (“*”) zurück geliefert.

Wird ein Befehl nicht korrekt ausgeführt, so wird ein Fehlercode zurückgegeben. Da bei der I2C-Übertragung keine Rückgabe erfolgt, kann man über einen I2C-Befehl (Befehlscode 103) den Status als Abfrage selektieren. Der nächste I2C Lesebefehl würde dann ebenfalls die 42 oder den Fehlercode des letzten Befehles liefern.

Fehlercode Fehlerbeschreibung
 1         CRC Prüfsumme stimmt nicht
 2         Unbekannter Befehl
42         Kein Fehler, Befehl korrekt ausgeführt

Wahlweise zusätzliche Sicherheit durch CRC-Prüfsumme

Wem die geschilderte Methode nur nicht ausreicht, kann auch das falsche interpretieren von Befehlen durch eine CRC-Checksumme ausschließen. Dazu muss man lediglich den CRC-Befehlsmodi über den Befehlscode 201 aktivieren.
Durch diese Aktivierung erwartet RN-Schrittmotor am Schluss jeder Befehlsbyte-Folge noch ein zusätzliches CRC-Byte. Dieses CRC-Byte bildet ein 8-Bit CRC-Summe von dem Befehlscode bis zum letzten Parameterbyte.

Bei folgenden Beispiel würde also der CRC-Prüfsumme aus den Bytes 54+3+0+0+0+0 berechnet. Also die CRC Summe wird immer aus Befehl und Parametern berechnet. Diese CRC-Prüfzahl würde dann im letzten Byte übertragen.

Print "!#": chr(54);chr(3);chr(0); chr(0); chr(0); chr(0); chr(0);

In Bascom-Basic kann man im übrigen sehr einfach den Bascom-Befehl Crc8 zum bilden dieser Prüfsumme nutzen.

Möchte man diese Prüfsumme in einer anderen Programmiersprache berechnen benötigt man eine entsprechende Funktion. Hier ein Beispiel für Visual Basic auf dem PC:

Function BerechneCRC(s As String) As Byte
 Dim j As Byte
 Dim k As Byte
 Dim crc8 As Byte
 Dim m As Byte
 Dim x As Integer

 crc8 = 0
 For m = 1 To Len(s)
   x = Asc(Mid(s, m, 1))
   For k = 0 To 7
     j = 1 And (x Xor crc8)
     crc8 = Fix(crc8 / 2) And &HFF
     x = Fix(x / 2) And &HFF
     If j <> 0 Then
       crc8 = crc8 Xor &H8C
     End If
    Next k
 Next
 Docrc8 = crc8
End Function

RN-Schrittmotor: Die Übersicht über RS232-Schrittmotor Befehle

RN-Schrittmotor arbeitet wie bereits geschildert immer mit Befehlen konstanter Länge. Über RS232 werden immer 9 Byte und über I2C immer 7 Byte (ohne Signatur) übertragen. Aus dieser Tabelle kann man sehr leicht die Syntax für beie Schnittstellen entnehmen. Zu beachten ist noch das RN-Schrittmotor im RS232 Betrieb immer mit 9600 Baud / 8 Bit arbeitet. Die einzelnen Befehle können bei den meisten Programmiersprachen durch einfache Print-Anweisungen erfolgen. Wird in Bascom-Basic programmiert, kann z.B. fast jeder Port als RS232 benutzt werden.

Motorstrom einstellen

Der Strom der gewöhnlich zum Drehen des Motors verwendet werden soll.
Vorgegeben ist 100 mA

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         10    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Low Byte – Strom in mA
 6         4         x     High Byte – Strom in mA
 7         5         x     Gültigkeit der Einstellung:
                           0=Nur bis zum nächsten Reset einstellen
                           1=Dauerhaft einstellen und im Eeprom sichern
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Gibt für beide Motoren 100 mA Motorstrom vor

Print "!#": chr(10);chr(3);chr(100); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Gibt für beide Motoren 100 mA Motorstrom vor

I2cstart
  I2cwbyte slaveid
  I2cwbyte 10 'Befehl 
  I2cwbyte 3 'Motoren
  I2cwbyte 100 'Strom Low Byte
  I2cwbyte 0 'Strom High Byte
  I2cwbyte 0 'Nur bis Reset einstellen
  I2cwbyte 0 'Par 4 hier beliebiger Wert da nicht benötigt
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Anlaufstrom einstellen

Über diesen Befehl kann ein etwas höherer Anlaufstrom festgelegt werden. Das Motorboard verwendet dann kurzzeitig beim Beschleunigen des Motors einen etwas höheren Strom. Gewöhnlich ist das nicht notwendig.
Vorgegeben ist 100 mA

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         11    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Low Byte – Strom in mA
 6         4         x     High Byte – Strom in mA
 7         5         x     Gültigkeit der Einstellung:
                           0=Nur bis zum nächsten Reset einstellen
                           1=Dauerhaft einstellen und im Eeprom sichern
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Gibt für beide Motoren 100 mA Anlaufstrom vor

Print "!#": chr(11);chr(3);chr(100); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Gibt für beide Motoren 100 mA Anlaufstrom vor

I2cstart
  I2cwbyte slaveid
  I2cwbyte 11 'Befehl 
  I2cwbyte 3 'Motoren
  I2cwbyte 100 'Strom Low Byte
  I2cwbyte 0 'Strom High Byte
  I2cwbyte 0 'Nur bis Reset einstellen
  I2cwbyte 0 'Par 4 hier beliebiger Wert da nicht benötigt
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Haltestrom einstellen

Über diesen Befehl kann ein niedrigerer Strom definiert werden, welcher automatisch bei Stillstand des Motors fließt. Gewöhnlich reicht ein niedriger Strom zum halten der Position aus, daher kann ein niedriger Haltestrom die Erwärmung des Motor´s reduzieren als auch viel Energie sparen.
Der Haltestrom ist automatisch aktiv wenn der Motor steht, beim drehen schaltet die Steuerung automatisch wieder auf Anlauf– und dann Motorstrom. Lediglich im Taktsteuermode wird dieser Haltestrom nicht genutzt.
Vorgegeben ist 100 mA

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         12    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Low Byte – Strom in mA
 6         4         x     High Byte – Strom in mA
 7         5         x     Gültigkeit der Einstellung:
                           0=Nur bis zum nächsten Reset einstellen
                           1=Dauerhaft einstellen und im Eeprom sichern
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Gibt für beide Motoren 100 mA Haltestrom vor

Print "!#": chr(12);chr(3);chr(100); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Gibt für beide Motoren 100 mA Haltestrom vor

I2cstart
  I2cwbyte slaveid
  I2cwbyte 12 'Befehl 
  I2cwbyte 3 'Motoren
  I2cwbyte 100 'Strom Low Byte
  I2cwbyte 0 'Strom High Byte
  I2cwbyte 0 'Nur bis Reset einstellen
  I2cwbyte 0 'Par 4 hier beliebiger Wert da nicht benötigt
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Vollschritt- oder Halbschrittmodus

Über diesen Befehl kann wahlweise der Vollschritt oder Halbschrittmodus aktiviert werden. Diese Einstellung gilt generell für beide Motoren. Im Halbschrittmodus sind doppelt soviele Schritte für eine Umdrehung notwendig. Vorgegeben ist der Vollschrittmodus.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         13    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Modus:
                           0=Vollschrittmodus
                           1=Halbschrittmodus
 6         4         x     Gültigkeit der Einstellung:
                           0=Nur bis zum nächsten Reset einstellen
                           1=Dauerhaft einstellen und im Eeprom sichern
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Schaltet beide Motoren in den Halbschrittmodus

Print "!#": chr(13);chr(3);chr(1); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Schaltet beide Motoren in den Halbschrittmodus

I2cstart
  I2cwbyte slaveid
  I2cwbyte 13 'Befehl 
  I2cwbyte 3 'Motoren
  I2cwbyte 1 'Halbschrittmodi
  I2cwbyte 0 'Nur bis Reset einstellen
  I2cwbyte 0 'Par 3 hier beliebiger Wert da nicht benötigt
  I2cwbyte 0 'Par 4 hier beliebiger Wert da nicht benötigt
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Schrittzähler auf 0 setzen

RN-Schrittmotor zählt jeden Schritt den der Motor macht mit. Mit diesem Befehl kann dieser Schrittzähler wieder auf 0 gesetzt werden.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         14    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Setzt den Schrittzähler von Motor 2 auf 0

Print "!#": chr(14);chr(2);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Setzt den Schrittzähler von Motor 2 auf 0

I2cstart
  I2cwbyte slaveid
  I2cwbyte 14 'Befehl 
  I2cwbyte 2 'Motoren
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Motor einschalten / Stellung halten

Dieser Befehl schaltet den Motor ein aber dreht diesen nicht. Es wird lediglich die augenblickliche Position mittels Haltestrom gehalten. Hat sich der Motor zuvor durch einen anderen Befehl gedreht, so wird dieser durch diesen Befehl gestoppt und die Position gehalten.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         50    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Schaltet Motor 2 ein bzw. stoppt diesen

Print "!#": chr(50);chr(2);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Schaltet Motor 2 ein bzw. stoppt diesen

I2cstart
  I2cwbyte slaveid
  I2cwbyte 50 'Befehl 
  I2cwbyte 2  'Motoren
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Motor ausschalten

Dieser Befehl schaltet den Motor komplett aus, also auch kein Haltestrom!.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         51    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Schaltet Motor 2 aus

Print "!#": chr(51);chr(2);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Schaltet Motor 2 aus

I2cstart
  I2cwbyte slaveid
  I2cwbyte 51 'Befehl 
  I2cwbyte 2  'Motoren
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Drehrichtung festlegen

Dieser Befehl legt fest ob der Motor links oder rechts herum gedreht wird.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         52    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Drehrichtung:
                           0=links herum
                           1=rechts herum
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Drehrichtung von Motor 2 rechts

Print "!#": chr(52);chr(2);chr(1); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Drehrichtung von Motor 2 rechts

I2cstart
  I2cwbyte slaveid
  I2cwbyte 52 'Befehl 
  I2cwbyte 2  'Motoren
  I2cwbyte 1  'Drehrichtung
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Geschwindigkeit und Beschleunigung festlegen

Über diesen Befehl wird festgelegt wie schnell sich der Motor drehen soll. Zudem wird ein Beschleunigungswert angegeben. Ist der Beschleunigungswert 0 so wird die gewählte Geschwindigkeitsstufe sofort aktiviert. Bei anderen Werten wird die Geschwindigkeit langsamer verändert, eine Art Rampe. Das langsamere Anfahren macht Sinn wenn hohe Geschwindigkeiten notwendig sind, man reduziert dadurch die Gefahr eines Schrittverlustes.

Die Geschwindigkeit errechnet sich wie folgt: G=1000 / (Geschwindigkeit+1) G= Schritte pro Sekunde
Also höhere Geschwindigkeiten als 1000 Schritte sind mit der vorhanden Firmware nicht möglich. Mit einer anderen Firmware ist eventuell auch eine etwas höhere  Taktrate denkbar, ich habe das aber nicht getestet und kann es daher nicht garantieren.

Schrittmotor Geschwindigkeit der Stufen:

0= 1000 Schritte pro Sek.
1= 500 Schritte pro Sek.
2= 333 Schritte pro Sek.
3= 250 Schritte pro Sek.
4= 200 Schritte pro Sek.
5= 167 Schritte pro Sek
6= 142 Schritte pro Sek
7= 125 Schritte pro Sek
8= 111 Schritte pro Sek
…
255= 4 Schritte pro Sekunde

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         53    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         x     Zielgeschwindigkeit 0 bis 255
                           (0=ganz schnell 255= ganz langsam)
 6         4         x     Beschleunigung 0 bis 255 
                           0=schlagartig ändern
                           255 Geschwindigkeit ganz langsam ändern
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Beide Motoren schlagartig recht schnell (Stufe 10) drehen

Print "!#": chr(53);chr(3);chr(10); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Beide Motoren schlagartig recht schnell (Stufe 10) drehen

I2cstart
  I2cwbyte slaveid
  I2cwbyte 53 'Befehl 
  I2cwbyte 2  'Motoren
  I2cwbyte 10 'Beschleunigung
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Endlosdrehung starten

Dies ist wohl der wichtigste Befehl Er kann ganz am Anfang stehen, sobald dieser Befehl kommt beginnen den gewählten Motoren sich endlos mit der eingestellten Geschwindigkeit, Drehrichtung, Motorstrom zu drehen, egal ob Motor vorher ausgeschaltet oder im Stillstand war.
Die Motoren drehen solange bis ein Stopp- oder Haltebefehl kommt. Oder aber bis ein Endschalter die Signaleingänge M1END oder M2END auf GND legt.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         54    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Dreht beide Motoren endlos

Print "!#": chr(54);chr(3);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Dreht beide Motoren endlos

I2cstart
  I2cwbyte slaveid
  I2cwbyte 54 'Befehl 
  I2cwbyte 3  'Motoren
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Bestimmte Schrittzahl drehen

Sobald dieser Befehl kommt beginnen den gewählten Motoren sich eine bestimmte Schrittzahl mit der eingestellten Geschwindigkeit, Drehrichtung, Motorstrom zu drehen, egal ob Motor vorher ausgeschaltet oder im Stillstand war.
Die Motoren bleiben automatisch stehen wenn die Schrittzahl erreicht ist oder ein Stopp- oder Haltebefehl kommt. Oder aber bis ein Endschalter die Signaleingänge M1END oder M2END auf GND legt.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1         55    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Low Byte Schrittzahl
 6         4         0     High Byte Schrittzahl
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Dreht beide Motoren 200 Schritte

Print "!#": chr(55);chr(3);chr(200); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Dreht beide Motoren 200 Schritte

I2cstart
  I2cwbyte slaveid
  I2cwbyte 55 'Befehl 
  I2cwbyte 3  'Motoren
  I2cwbyte 200 'Schrittzahl
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Motorstatus abrufen

Über diesen Befehl kann man ermitteln ob ein Motor noch dreht oder bereits gestoppt hat..

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1        101    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Ermittelt ob Motor 1 noch dreht

Print "!#": chr(101);chr(1);chr(0); chr(0); chr(0); chr(0); chr(0);

Liefert ein zurück:

Erste Byte
0 =Aus
1 =Stop (Haltestrom)
2 =Dreht bis Fahrschritte erreicht
3 =Dauerdrehung bis Stop
Zweite Byte
übliche Rückgabecode (42)

I2C-Beispiel
Ermittelt ob Motor 1 noch dreht

I2cstart
  I2cwbyte slaveid
  I2cwbyte 101 'Befehl 
  I2cwbyte 1 'Motoren
  I2cwbyte 0
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Da es bei I2C-Bus keine direkten Rückgabewerte gibt,
muss nach dem Befehl noch ein Lesezugriff erfolgen:

I2cstart
  I2cwbyte slaveid+1
  I2crbyte motorstatus, Nack
I2cstop

Bewegte Schrittzahl abrufen

Über diesen Befehl kann die Schrittzahl, die sich der Motor bislang gedreht hat, abgerufen werden. Es handelt sich hier um ein Long Wert..

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1        102    Befehlscode
 4         2         m     Motor für den dieser Befehl gilt:
                           1= Motor 1
                           2= Motor 2
                           3= beide Motoren
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Ermittelt die gefahrenen Schritte von Motor 1

Print "!#": chr(102);chr(1);chr(0); chr(0); chr(0); chr(0); chr(0);

Liefert ein zurück:

1.Byte: Schrittanzahl (Low Byte von Low Word)
2.Byte: Schrittanzahl (High Byte von Low Word)
3.Byte: Schrittanzahl (Low Byte von High Word)
4.Byte: Schrittanzahl (High Byte von High Word)

I2C-Beispiel
Ermittelt die gefahrenen Schritte von Motor 1

I2cstart
  I2cwbyte slaveid
  I2cwbyte 102 'Befehl 
  I2cwbyte 1 'Motoren
  I2cwbyte 0
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

Da es bei I2C-Bus keine direkten Rückgabewerte gibt,
muss nach dem Befehl noch ein Lesezugriff erfolgen. 
In dem folgenden Beispiel wurden die Bytewerte 
gleich in einen Long Wert umgerechnet:

I2cstart
  I2cwbyte slaveid+1
  I2crbyte Temp , Ack
  Schritte = Temp
  I2crbyte Temp , Ack
  Ltemp = Temp * 256
  Schritte = Schritte + Ltemp
  I2crbyte Temp , Ack
  Ltemp = Temp * 65536
  Schritte = Schritte + Ltemp
  I2crbyte Temp , Nack
  Ltemp = Temp * 16777216
  Schritte = Schritte + Ltemp
I2cstop

RN-schrittmotor Schnittstellenmodus festlegen

Über diesen Befehl wird festgelegt ob die Schrittmotor im intelligenten I2C/RS232 Modus oder aber im passiven Taktmodus arbeiten soll.
Wenn der Taktmodus aktiviert wird, dann werden die Motoren ausschließlich über die Eingänge der Steckklemme JP4 angesteuert (siehe Beschreibung JP4). Eine solche manuelle Ansteuerung ist mit PC-Schrittmotorsoftware oder aber auch mit Controllerboards möglich. Die Schaltung ähnelt dann weiterhin einer L297/L298 Schaltung, das bedeutet der Motorstrom wird weiterhin von RN-Schrittmotor geregelt, allerdings gibt es in diesem Mode keinen reduzierten Haltestrom. Über den EN-Pin können die Motoren aber abgeschaltet werden. Die Schrittmotorbefehle per RS232 / I2C sind im Taktmodus teilweise deaktiviert und sollten nicht gemischt verwendet werden. Lediglich die Motorstromstärke oder die Aktivierung des intelligenten Modus sind natürlich weiterhin per RS232 / I2C möglich.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1        200    Befehlscode
 4         2         x     Schrittmotormodus:
                           0=Intelligent über RS232 und I2C Befehle
                           2=über Taktleitungen
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Intelligenten Modus aktivieren

Print "!#": chr(200);chr(0);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Intelligenten Modus aktivieren

I2cstart
  I2cwbyte slaveid
  I2cwbyte 200 'Befehl 
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  '
  I2cwbyte 0  'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

RN-Schrittmotor Eeprom Werte abrufen

Viele wichtige Einstellungen wie SlaveID, Motorstrom, Haltestrom usw. werden in RN-Schrittmotor dauerhaft in einem sogenannten Eeprom gespeichert. Normalerweise braucht man sich um deren Inhalt nicht kümmern, da die jeweiligen Befehle diese Werte ablegen und beim Reset auch wieder aktivieren.

Haben Sie jedoch vergessen welche Werte Sie einmal eingestellt haben, dann können Sie diesen Befehl nutzen um die Eeprom-Daten abzurufen. Es können bis zu 50 Bytes abgerufen werden, das sind mehr Byte als derzeit eigentlich in der Firmware genutzt werden.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1        254    Befehlscode
 4         2         x     Anzahl der Eeprom Bytes die zurückgegeben
                           werden sollen (1 bis 50)
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Gibt die ersten 20 Byte des Eeprom´s aus

Print "!#": chr(254);chr(20);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Gibt die ersten 20 Byte des Eeprom´s aus

I2cstart
  I2cwbyte slaveid
  I2cwbyte 254 'Befehl 
  I2cwbyte 20 'Bytes
  I2cwbyte 0
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
  I2cstop

Da es bei I2C-Bus keine direkten Rückgabewerte gibt,
muss nach dem Befehl noch ein Lesezugriff erfolgen:

I2cstart
  I2cwbyte slaveid+1
  I2crbyte byte1, ack
  I2crbyte byte2, ack
  ...
  I2crbyte byte20, Nack
I2cstop

Die Bedeutung der zurückgegebenen Eeprom Bytes

Byte Nr.  Bedeutung
0         I2C Slave ID
1         Motorstrom in mA Motor 1 Low-Byte 
2         Motorstrom in mA Motor 1 High-Byte 
3         Motorstrom in mA Motor 2 Low-Byte
4         Motorstrom in mA Motor 2 High-Byte
5         Haltestrom in mA Motor 1 Low-Byte
6         Haltestrom in mA Motor 1 High-Byte
7         Haltestrom in mA Motor 2 Low-Byte
8         Haltestrom in mA Motor 2 High-Byte
9         Anlaufstrom in mA Motor 1 Low-Byte
10        Anlaufstrom in mA Motor 1 High-Byte
11        Anlaufstrom in mA Motor 2 Low-Byte
12        Anlaufstrom in mA Motor 2 High-Byte
13        Schrittmotormodus 0=Vollschritt 1=Halbschritt
14        Schnittstellenmodus 1=Intelligent 2=Takt
15-24     derzeit nicht verwendet oder dokumentiert

Firmware-Version und Infos über RS232 ausgeben

Über diesen Befehl lassen sich wichtige Infos wie Slave-ID, Firmware-Version und Schnittstellenmodus im Klartext über RS232 ausgeben. Der Befehl kann zwar auch über I2C erfolgen, jedoch gibt dieser ausnahmsweise alle Daten nur über RS232 aus.

RS232     I2C        Wert  Beschreibung
Byte Nr.  Byte Nr.
 1         -         33    Immer 33 (Ascii '!')
 2         -         35    Immer 35 (Ascii '#') 
 3         1        255    Befehlscode
 4         2         0     Nicht benötigt, daher 0 übertragen
 5         3         0     Nicht benötigt, daher 0 übertragen
 6         4         0     Nicht benötigt, daher 0 übertragen
 7         5         0     Nicht benötigt, daher 0 übertragen
 8         6         0     Nicht benötigt, daher 0 übertragen
 9         7         CRC   Wahlweise CRC-Prüfsumme

RS232-Beispiel
Copyright und Firmware-Informationen ausgeben

Print "!#": chr(255);chr(0);chr(0); chr(0); chr(0); chr(0); chr(0);

I2C-Beispiel
Copyright und Firmware-Informationen ausgeben

I2cstart
  I2cwbyte slaveid
  I2cwbyte 255 'Befehl 
  I2cwbyte 0
  I2cwbyte 0
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 '
  I2cwbyte 0 'CRC Falls CRC Mode aktiv dann hier CRC Wert angeben
I2cstop

RN-Schrittmotor Schaltplan Teil 1

RN-Schrittmotor Schaltplan Teil 2

RN-Schrittmotor Bestückungsplan

RN-Schrittmotor Bauteile Bestückungsliste & Bestellliste

Platinenbezeichnung    Beschreibung                      Link zur Bezugsquelle
C2,C3,C6,C9,C10        100n Keramik Kondensator          Reichelt*
C11,C12,C13,C14,C15,
C17,C18,C23,C25,C27
C1,C16                 Elko 220uF 35V                    Reichelt*
C26                    Elko 470uF 6,3V                   Reichelt*
C4,C5                  Elko 2200uF 35V                   Reichelt*
C7,C8                  Keramik Kondensator               Reichelt*
C19,C20,C21,C22        Elko 4,7uF                        Reichelt*
D1,D2,D3,D4,D5,        Diode                             Reichelt*
D6,D7,D8,D9,D10,
D11,D12,D13,D14,D15,
D16,D17
EXT1,EXT2,I2C          Wannenstecker 10pol               Reichelt*
IC1,IC2                L298 Motortreiber                 Reichelt*
IC3                    Spannungsregler 5V/2A             Reichelt*
IC4                    Microcontroller ATMega32          Reichelt*
IC5                    RS232 Treiber                     Reichelt*
JP1                    Stiftleiste 2x6polig              Reichelt*
JP2,JP3,JP5,JP6,NOEXT  Stiftleiste 2polig                Reichelt*
JP4                    Wago Steckklemme 8 polig          Reichelt*
KK2                    Kühlkörper HEATSINK               Reichelt*
L1                     Induktivität 10uH                 Reichelt*
LED1,LED7              Leuchdiode Low grün               Reichelt*
LED2,LED5,LED6         Leuchdiode Low gelb               Reichelt*
LED3,LED4              Leuchdiode Low rot                Reichelt*
LOWPOW,MOTPOW          Wannenstecker 2 pol gewinkelt     Reichelt*
MOT1,MOT2              Wannenstecker 4 pol gewinkelt     Reichelt*
Q1                     Quarz 16 Mhz                      Reichelt*
R1,R2,R3,R4,R5,R6      Widerstand 1K                     Conrad*
R7,R8,R9,R10           Drahtwiderstand 0,51 Ohm          Reichelt*
RESET,T1,T2            Minitaster liegend                Reichelt*
RN1                    Netzwerkwiderstand 9x4,7k         Reichelt*
RN2                    Netzwerkwiderstand 5x1k           Reichelt*
RN3                    Netzwiderstand 4x10k              Reichelt*
RS232                  Stiftleiste 3 polig               Reichelt*

Weiterhin notwendig:
1 Stück                IC-Fassung/Sockel 16 polig        Reichelt*
1 Stück                IC-Fassung/Sockel 40 polig        Reichelt*
5 Stück                Befestigungsbolzen für Platine    Reichelt*
1 Stück                Leiterplatte
                       über Leiterplattenhersteller anfertigen
                       lassen (Eagle Datei siehe unten)
                       öfters auch über Ebay erhältlich  hier über Ebay*
7 Stück                Jumper vergoldet                  Reichelt*
2 Stück                Stecker für Betriebsspannungen    Reichelt*
2 Stück                Stecker für Motoren               Reichelt*

Alle Angaben ohne Gewähr

Downloads

  Firmware für den ATMega32 Controller von RN-Schrittmotor (ZIP)
  Eagle-Dateien zu RN-Schrittmotor (ZIP)
  RN-Control steuert RN-Schrittmotor Beispielprogramme (ZIP)
  Java Code für RN-Schrittmotor Ansteuerung (ZIP)
  PC - Steuerprogramm als Beispiel (ZIP)

_{Das Leiterplattenangebot  ist ein Service Angebot der jeweiligen Anbieter. Bei Fragen bezüglich Lieferung und Preis bitte dort nachfragen!}

Im Bild sieht man die I2C Verbindung zwischen RN-Control und RN-Schrittmotor

Bascom Beispiel: RN-Control steuert RN-Schrittmotor

Diese Beispiel demonstriert die Schrittmotoransteuerung über RS232. Ein Beispiel für I2C wird aber oben auch zum Download bereitgestellt. Natürlich eignet sich auch jede andere Programmiersprache wie z.B. C oder Java für die Ansteuerung.

'###################################################
'Schrittmotoransteuerung mit RN-Control und
'Ansteuerungsboard RN-SCHRITTMOTOR über RS232
'rncontrol_schrittmotor_rs2321.bas
'
'Aufgabe:
' Dieses Testprogramm beschreibt die Motorboard RS232-Funktionen
' und legt einige der Befehle auf die 5 Tasten

' Den verschiedenen Tasten sind bestimmte Funktionen zugeordnet
' Taste 1: Motor endlos drehen (schaltet den Motor automatisch ein)
' Taste 2: Richtungswechsel
' Taste 3: Fragt der bereits ausgeführten Motorschritte
'          des linken Motors vom Board ab und
'          berechnet daraus Umdrehungen und Fahrtstrecke
'          Daten werden über RS232 angezeigt
' Taste 4: Ändert die Geschwindigkeit des linken Motors
'          mit jedem Tastendruck
' Taste 5: Schaltet den linken Motor wieder aus
'
'Autor: Frank
'Weitere Beispiele und Beschreibung der Hardware
'in der Anleitung zu RN-Schrittmotor
'Anleitung findet man unter https://www.mikrocontroller-elektronik.de/
'Weitere Beispiele sind dort gerne willkommen!
'##############################################################

$programmer = 12 'MCS USB (Zeile weglassen wenn anderer Programmer)

' -------------- RN-Control übliche _____________________
Declare Function Tastenabfrage() As Byte

$regfile = "m32def.dat"
$framesize = 64
$swstack = 64
$hwstack = 64

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1

Config Adc = Single , Prescaler = Auto 'Für Tastenabfrage und Spannungsmessung
Config Pina.7 = Input 'Für Tastenabfrage
Porta.7 = 1 'Pullup Widerstand ein
Dim Taste As Byte
Dim Ton As Integer

I2cinit
Start Adc
Sound Portd.7 , 400 , 450 'BEEP
Sound Portd.7 , 400 , 250 'BEEP
Sound Portd.7 , 400 , 450 'BEEP
Print
Print "**** RN-CONTROL V1.4 *****"
Print "Demoprogramm um Zusatzboard RN-Schrittmotor zu testen/demonstrieren"
Print
' -------------- Ende RN-Control übliche _____________________

Declare Sub Sendebytearray()

'Befehle im Schrittmotorbetrieb
'Ein RN-Schrittmotor Befehl besteht immer aus 7 Bytes, auch wenn einige Befehle
'weniger Parameter benötigen. Wenn weniger Bytes erforderlich sind, werden die unnötigen
'Bytes mit beliebigen Wert gefüllt und ignoriert. .Die konstante Zahl erleichtert und
'beschleunigt die Interpretation und Verarbeitung!

'Befehlssyntax:
'Befehl, Motor , Par1, Par2, Par3, Par4, crc

Const Befehl_ausschalten = 51 'Motor ausschalten
Const Befehl_drehrichtung = 52 'Drehrichtung festlegen
Const Befehl_geschwindigkeit = 53 'Geschwindigkeit (wahlweise mit Rampe)
Const Befehl_endlosdrehung = 54 'Motoren endlos bis zu einem Stoppbefehl drehen
Const Befehl_schrittzahlabrufen = 102 'Aktuell bewegte Schrittzahl abrufen (Long Wert)
Const Befehl_versionstatus = 255 'Version & Copyright per RS232 ausgeben

Const Motor_1 = 1
Const Motor_2 = 2

Dim Rs232daten(7) As Byte 'Array um Befehlsfolge auszunehmen
Dim Lowbyte As Byte
Dim Highbyte As Byte
Dim Richtung As Bit

Dim Schritte As Long
Dim Temp As Byte
Dim Ltemp As Long
Dim Umdrehungen As Single
Dim Fahrstrecke As Word

Dim Geschwindigkeit As Byte

'------------------------------------------------------------
' Dieser Abschnitt ist nur notwendig wenn RN-KeyLCD als
' LCD Ausgabe genutzt werden soll
Const Rnkeylcd_slaveid_write = &H40 'I2C SlaveAdresse
Const Rnkeylcd_slaveid_read = &H41
Dim Empfang(5) As Byte
Dim Stemp As String * 100
I2cinit
'-------------------------------------------------------------

Richtung = 0
Geschwindigkeit = 250

Do
 Taste = Tastenabfrage()
 If Taste <> 0 Then

 Select Case Taste
   Case 1 'Motor endlos drehen
           Rs232daten(1) = Befehl_endlosdrehung 'Befehlscode
           Rs232daten(2) = Motor_1 '1 Parameter
           Sendebytearray

 Case 2 'Motor endlos drehen
           Toggle Richtung
           Rs232daten(1) = Befehl_drehrichtung 'Befehlscode
           Rs232daten(2) = Motor_1 '1 Parameter
           Rs232daten(3) = Richtung '2 Parameter
           Sendebytearray

 Case 3 'Geschwindigkeit ändern
          If Geschwindigkeit > 40 Then
             Geschwindigkeit = Geschwindigkeit - 20
          Else
             Geschwindigkeit = Geschwindigkeit - 1
          End If
          Rs232daten(1) = Befehl_geschwindigkeit 'Befehlscode
          Rs232daten(2) = Motor_1 '1 Parameter
          Rs232daten(3) = Geschwindigkeit '2 Parameter
          Rs232daten(4) = 0 '3 Parameter (wie schnell Geschwindigkeit geändert werden soll)
          Sendebytearray

 Case 4 'Motor für Datenabruf anwählen
          Do : Loop Until Inkey() = 0 'Diese Zeile leert Buffer
          Rs232daten(1) = Befehl_schrittzahlabrufen 'Befehlscode
          Rs232daten(2) = Motor_1 '1 Parameter
          Sendebytearray
          Inputbin Empfang(1) , 5
          Schritte = Empfang(1)
          Ltemp = Empfang(2) * 256
          Schritte = Schritte + Ltemp
          Ltemp = Empfang(3) * 65536
          Schritte = Schritte + Ltemp
          Ltemp = Empfang(4) * 16777216
          Schritte = Schritte + Ltemp

          'LCD Löschen (nur wenn Sie Board RN-KeyLCD einsetzen)
          Stemp = Chr(12) : I2csend Rnkeylcd_slaveid_write , Stemp , 1 
          'Schritte auf LCD ausgeben
          Stemp = Str(schritte) : I2csend Rnkeylcd_slaveid_write , Stemp , 10 

 Case 5 'Motor ausschalten
          Rs232daten(1) = Befehl_ausschalten 'Befehlscode
          Rs232daten(2) = Motor_1 '1 Parameter
          Sendebytearray
 End Select
 Sound Portd.7 , 400 , 500 'BEEP
 End If

 Waitms 100
Loop

End


' Diese Unterfunktion fragt die Tastatur am analogen Port ab
' Sollte beim betätigen einer Taste kein Quittungston kommen, dann
' muss die die Tastenabfrage (Select Case Anweisung in Funktion )
' an ihr Board angepaßt werden. Widerstandstoleranzen sorgen in
' Einzelfällen manchmal dafür das die Werte etwas anders ausfallen
' Am besten dann den WS wert mit Print für jede Taste ausgeben lassen

Function Tastenabfrage() As Byte
Local Ws As Word

 Tastenabfrage = 0
 Ton = 600
 Ws = Getadc(7)
' Print "ws= " ; Ws
 If Ws < 1010 Then
   Select Case Ws
     Case 400 To 455
         Tastenabfrage = 1
         Ton = 550
     Case 335 To 380
         Tastenabfrage = 2
         Ton = 500
     Case 250 To 305
        Tastenabfrage = 3
        Ton = 450
     Case 180 To 220
        Tastenabfrage = 4
        Ton = 400
     Case 100 To 130
        Tastenabfrage = 5
        Ton = 350
   End Select
 Sound Portd.7 , 400 , Ton 'BEEP
End If

End Function


'Hilfsfunktion um Befehle zu senden
Sub Sendebytearray()
Local I As Byte
  Print "!#";
  For I = 1 To 7
  Print Chr(rs232daten(i));
  Next I
End Sub

Weblinks zum Thema

• Forum für Diskussionen
• Bascom
• Schrittmotor Grundlagen in RN-Wissen
• Alternatives Schrittmotor Projekt RN-Stepp297

Weitere Bezugsquellen

• für Schrittmotoren z.B. hier bei Ebay* oder Amazon*
• andere Schrittmotortreiber hier bei Ebay*

Hilfreiche Bücher zum Thema

Richtig löten: Die perfekte Lötstelle*

Schulz, Dieter (Autor)

Elektrische Schrittmotoren und -antriebe: Funktionsprinzip - Betriebseigenschaften - Messtechnik (Kontakt & Studium)*

Rummich, Erich (Autor)

57,40 EUR

Mit Schrittmotoren steuern, regeln und antreiben: Schrittmotorarten, Betriebsverhalten, Auswahlrichtlinien*

Schörlin, Felix (Autor)

Letzte Aktualisierung am 2024-11-20 / * Affiliate Links 

Geeignete Lötstation bzw. Lötkolben

Angebot

ERSA RDS80 Digital Lötstation 80W Leistung mit einstellbarer Temperatur 150 – 450 °C inkl. Lötspitze 2,2mm meißelförmig ERSADUR und...*

158,11 EUR −13,86 EUR 144,25 EUR

ERSA Lötkolben Multitip C 25 25W 230V 0920BD*

elektrischer Lötkolben mit einer Anheizleistung von 25 Watt; Anheizzeit 60 Sekunden mit einer maximalen Temperatur von 450 °C

39,99 EUR

Letzte Aktualisierung am 2024-11-20 / * Affiliate Links 

Weitere Hinweise

Das Projekt unterliegt einer CC-Lizenz - Lizenzhinweis (zum Aufklappen anklicken)

Um ihnen weitgehende Möglichkeiten zum Nutzen der Schaltung einzuräumen, wurde dieses Projekt jetzt unter die CC-Lizenz gestellt. Sie haben So die Möglichkeit die Schaltung beliebig zu verändern oder weiterzugeben. Lediglich die kommerzielle Weitergaben ist nur mit Genehmigung möglich! Genauere Hinweise finden Sie im Lizenztext. Bei einer Veröffentlichung oder Weitergabe ist nachfolgender Text sichtbar zu übernehmen:

---

Falls Dir der Beitrag gefallen oder geholfen hat kannst Du dem Autor aber gerne durch eine kleine Spende Danke sagen!

Projekt (Schaltung & Projektdateien) von Frank ist lizenziert unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 4.0 International Lizenz. Über diese Lizenz hinausgehende Erlaubnisse können Sie unter https://www.mikrocontroller-elektronik.de/ erhalten. Lizenziert wurde das Projekt von: www.Roboternetz.de & www.Mikrocontroller-Elektronik.de  -  Autor/User Frank Dieser Name und diese Webseiten sind bei der Weitergabe stets deutlich sichtbar zu nennen!

---