Programmierbare Schrittmotoransteuerung RN-Schrittmotor

Programmierbare Schrittmotor Ansteuerung 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)

Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

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.

Befehls CodeFunktion des Befehles
10Motorstrom festlegen
11Anlauf Motorstrom festlegen (Motorboard nutzt eventuell kurzzeitig einen höheren Anlaufstrom)
12Haltestrom für Stillstand festlegen
13Vollschritt oder Halbschrittmodi festlegen (gilt für beide Motoren)
14Schrittzähler auf Null setzen
50Motor einschalten / Motorstellung halten (Haltestrom aktiv)
51Motor komplett ausschalten
52Drehrichtung festlegen
53Geschwindigkeit und Beschleunigung festlegen
54Motoren Endlos bis zu einem Stopbefehl drehen
100Reserviert – derzeit nicht nutzen
101Motorstatus abrufen (ob er steht, noch dreht)
102Aktuell gedrehte Schrittzahl abrufen (daraus lässt sich Wegstrecke errechnen)
103Letzte Befehlsbestätigung abrufen
200Schrittmotormodi einstellen (Intelligente RS232/I2C oder passive Taktsteuerung)
201CRC-Prüfsummenmode aktivieren bzw. deaktivieren
202I2C Slave ID festlegen
254Eeprom Werte abrufen
255Firmware-Version,Copyright, Betriebsmodi und Slave-ID werden per RS232 ausgegeben

RN-Schrittmotor: Aufbau des Schrittmotor Boards

Leiterplatte Programmierbare Schrittmotor Ansteuerung RN-SchrittmotorDer 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!

Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

Erläuterung der Anschlüsse, Regler und Jumper

Bitte jeweiligen Punkt anklicken um die Beschreibung zu lesen.

Mot1

Anschluss des ersten Schrittmotor
Über diese 4 polige Schraubklemme (steckbare Schraubklemme) wird ein Schrittmotor angeschlossen. Dabei ist darauf zu achten das eine Wicklung an die beiden linken und eine Wicklung an die beiden rechten Schraubklemmen angeschlossen wird.
Dreht sich später ein Motor nicht, so muss eine Wicklung umgepolt werden. Dreht der Motor falsch herum, dann Wicklungen umtauschen.

Die Motoren werden bipolar angesteuert. Das bedeutet das eine eventuelle Mittelanzapfung an der Motorwicklung nicht benötigt wird.

Es können Motoren von Nennspannungen ab ca. 1V bis zur Motorspannung (max. 34V) angeschlossen werden. Dies ist deshalb möglich, da später vor dem einschalten zuerst mit einem Befehl der maximale Nennstrom übermittelt wird. Dadurch überwacht das Board automatisch die richtige Motorspannung, ein großer Vorteil gegenüber einfachen Schrittmotoransteuerungen die mit Festpannung arbeiten.

Wird der Nennstrom nicht eingestellt, so ist dieser auf maximal 100mA begrenzt. Dies kann bis zu 2A je Motor erhöht werden.

Mot2

Anschluss des zweiten Schrittmotor
Über diese 4 polige Schraubklemme (steckbare Schraubklemme) wird ein Schrittmotor angeschlossen. Dabei ist darauf zu achten das eine Wicklung an die beiden linken und eine Wicklung an die beiden rechten Schraubklemmen angeschlossen wird.

Dreht sich später ein Motor nicht, so muss eine Wicklung umgepolt werden. Dreht der Motor falsch herum, dann Wicklungen umtauschen.

Die Motoren werden bipolar angesteuert. Das bedeutet das eine eventuelle Mittelanzapfung an der Motorwicklung nicht benötigt wird.

Es können Motoren von Nennspannungen ab 1V bis zur Motorspannung (max. 34V) angeschlossen werden. Dies ist deshalb möglich, da später vor dem einschalten zuerst mit einem Befehl der maximale Nennstrom übermittelt wird. Dadurch überwacht das Board automatisch die richtige Motorspannung, ein großer Vorteil gegenüber einfachen Schrittmotoransteuerungen.

Wird der Nennstrom nicht eingestellt, so ist dieser auf maximal 100mA begrenzt. Dies kann bis zu 2A je Motor erhöht werden.

LOWPOW

Spannungsversorgung für Elektronik
Über diese Schraubklemme wird das Board mit der Betriebsspannung versorgt. Es reicht eine unstabilisierte Gleichspannung von ca. 7 bis 24V aus.

Plus + und Minus – sind auf der Platine markiert, von hinten gesehen ist Plus links!

HIGHPOW

Motorspannung
Über diese Schraubklemme wird die Motorspannung angelegt. Es reicht eine umstabilisierte Gleichspannung von ca. 7 bis maximal 35V aus. Damit das Board den Strom optimal regeln kann, sollte diese Spannung immer höher sein als die Nennspannung des Motors.

Plus + und Minus – sind auf der Platine markiert, von hinten gesehen ist Plus links!

Möchte man nur ein Spannung nutzen, so kann man die Schraubklemme „+“ von LowPow und HighPow einfach überbrücken, dann darf allerdings nicht mehr als 24V angelegt werden.

RS232

PC kompatible RS232 Schnittstelle
Über ein Adapterkabel kann die serielle Schnittstelle des PC direkt mit dem Board verbunden werden. Dadurch können bei der RS232-Version des Boards alle Motorfunktionen per PC gesteuert werden.

Ein entsprechendes Demo-Steuerprogramm steht zum Download bereit
Hat man ein Controllerboard wie RN-Control, so kann man dieses ebenfalls über eine dreipolige Leitung miteinander verbinden.

Die Belegung entspricht der Roboternetz-Definition:

Pin 1 RX
Pin 2 GND
Pin 3 TX

I2C-Bus

I2C-Bus
Alle Funktionen des Boardes sind auch über ein I2C-Bus ansteuerbar. Es können sogar mehrere Boards an einen I2C-Bus angeschlossen werden.
Der I2C-Bus benötig nur 2 Leitungen für alle Funktionen. Entsprechend der Roboternetz-Definition wird hier ein 2×5 poliger Stecker angeschlossen. Die Belegung entspricht exakt der von den meisten Roboternetz-Projekten:

Pin 1 SCL (Taktleitung)
Pin 3 SDA (Datenleitung)
Pin 5 +5V (Kann über Jumper I2C5V getrennt werden)
Pin 7 +5V (Kann über Jumper I2C5V getrennt werden)
Pin 9 Batteriespannung Diese Leitung wird jedoch bei RN-Motor nicht benutzt
Pin 2,4,6,8 GND
Pin 10 INT Diese Leitung wird jedoch bei RN-Schrittmotor nicht benutzt

Ext1

Erweiterungsstecker 1
Dieser Anschluss hat derzeit keine Funktion. Er ist nur für eine eventuelle Erweiterung der Firmware vorsorglich angelegt worden. Sie sollten diesen Stecker nicht nutzen!
Wenn Sie eine eigene Firmware für das Board entwickeln, so können Sie diese Buchse mit eigenen Funktionen belegen. Die entsprechende Portbelegung kann man dem Schaltplan entnehmen.

Ext2

Erweiterungsstecker 2
Dieser Anschluss hat derzeit keine Funktion. Er ist nur für eine eventuelle Erweiterung der Firmware vorsorglich angelegt worden. Sie sollten diesen Stecker nicht nutzen!
Wenn Sie eine eigene Firmware für das Board entwickeln, so können Sie diese Buchse mit eigenen Funktionen belegen. Die entsprechende Portbelegung kann man dem Schaltplan entnehmen.

NOEXT

Jumper zum überbrücken von einem Erweiterungsstecker
Die Erweiterungbuchsen Ext1 und Ext2 sind in Reihe geschaltet. Dieser Jumper überbrückt eine davon. Derzeit hat dieser Jumper keine Bedeutung.
Entwickler einer eigenen Firmware können die Funktion über den Schaltplan analysieren.

JP1

Konfiguration
Über 6 Jumper können hier verschiedene Dinke eingestellt werden.

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)
JP2

MOT1 PWM Port

Über diesen Jumper können verschiedene PWM-Ports für die Ansteuerung der Motor H-Bridges festgelegt werden. Je nach Firmware muss dieser Jumper immer eine spezielle Stellung besitzen.
Derzeit muss hie rein Jumper so eingesteckt werden das er die Nummern 1 und 2 überbrückt. Im Bestückungsplan ist die Position auch markiert.

JP3

MOT2 PWM Port

Über diesen Jumper können verschiedene PWM-Ports für die Ansteuerung der Motor H-Bridges festgelegt werden. Je nach Firmware muss dieser Jumper immer eine spezielle Stellung besitzen.
Derzeit muss hie rein Jumper so eingesteckt werden das er die Nummern 1 und 2 überbrückt. Im Bestückungsplan ist die Position auch markiert.

JP4

Taktsteuerung / Endschalter
Diese Steckklemme hat je nach Betriebsmodi unterschiedliche Aufgaben. Angesteuert werden die PIN´s mit normalen TTL-Pegel, also entweder 5V oder GND. Da über Pullup-Widerstände bereits 5V vorgegeben wird, müssen die Pin´s zur Aktivierung nur mit GND verbunden werden.

Ist der Taktsteuermodi aktiv, so ist die Belegung wie folgt beschrieben:

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

Ist der intelligente Betriebsmode (I2C/RS232) aktiv, so ist die Belegung wie folgt beschrieben:

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
JP5

5 Volt für externe Elektronik
Über diese Stiftleiste kann die stabilisierte 5V Spannung auch für externe Elektronik genutzt werden. Belastungen bis maximal 250 mA sind möglich

JP6

5 Volt für externe Elektronik
Über diese Stiftleiste kann die stabilisierte 5V Spannung auch für externe Elektronik genutzt werden. Belastungen bis maximal 250 mA sind möglich

Taster T1

Testschalter 1
Motor 1 wird in Endosdrehung (linksrum) versetzt. Erneutes drücken schaltet den Motor wieder aus. Der Schalter eignet sich vor allem um den Aufbau des Schrittmotorboards und den korrekten Anschluss der Motoren zu prüfen. Es wird der einprogrammierte Strom genutzt, vorgegeben ist 100mA.

Taster T2

Testschalter 2
Motor 2 wird in Endosdrehung (linksrum) versetzt. Erneutes drücken schaltet den Motor wieder aus. Der Schalter eignet sich vor allem um den Aufbau des Schrittmotorboards und den korrekten Anschluss der Motoren zu prüfen. Es wird der einprogrammierte Strom genutzt, vorgegeben ist 100mA.

TASTER RESET

Motorboard wird in Grundstellung versetzt. Motoren werden ausgeschaltet

LED1

Die Leuchtdiode signalisiert verschiedene Dinge
Ein RESET wird durch kurzes Blinken der LED angezeigt.
Firmware übertragungen per ISP werden durch Flackern signalisiert

Wenn ein Motor läuft und die Betriebsspannung nicht ausreicht um den Nennstrom zur erreichen, leuchtet die LED auf.

LED2

Blinkt beim Einschalten oder RESET kurz, wenn die Taktsteuerung aktiviert ist.

LED3

Zeigt Status von M1R bzw. M1END1 an

LED4

Zeigt Status von M2R bzw. M2END1 an

LED5

Leuchtet bei Tastendruck von T1

LED6

Leuchtet bei Tastendruck von T2

LED7

Leuchtet immer wenn Board mit Betriebsspannung versorgt wird

 

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

Schaltplan Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

RN-Schrittmotor Schaltplan Teil 2

Schaltplan Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

 

RN-Schrittmotor Bestückungsplan

Bestückungsplan Leiterplatte Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

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)

Empfohlene Leiterplatten Hersteller

Leiterplatte Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

Programmierbare Schrittmotor Ansteuerung RN-Schrittmotor

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 http://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

Weitere Bezugsquellen

Hilfreiche Bücher zum Thema

Richtig löten
EUR 19,95
In Haushalt, Hobby und Freizeit sind immer wieder kleine Reparaturen erforderlich, bei denen der Lötkolben wertvolle Dienste leistet. Durch richtiges Löten können Sie z.B. defekte elektronische Geräte wieder flottmachen, Leitungen reparieren usw. Kleine elektronisch...
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Mit Schrittmotoren steuern, regeln und antreiben
EUR 35,98
Versandfertig in 1 - 2 Werktagen
Mehr Infos* >>  |  zum Shop* >>

* = Fotos stammen von der Amazon-API (Amazon-Partnerprogramm )/Link ist ein Affiliate-Link zu Amazon

Geeignete Lötstation bzw. Lötkolben

Ersa 0RDS80 Elektronisch geregelte Lötstation 80W 0RDS80
EUR 135,60 EUR 135,60
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Ersa 0920BD Lötkolben Multitip C 25 25W 230V
EUR 20,75 EUR 25,88
Versandfertig in 1 - 2 Werktagen
Mehr Infos* >>  |  zum Shop* >>

* = Fotos stammen von der Amazon-API (Amazon-Partnerprogramm )/Link ist ein Affiliate-Link zu Amazon

Weitere Hinweise

Vor dem Aufbau bitte nachfolgende Hinweise lesen:

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:


cc_logo310

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 http://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!



Achtung: Es kann keinerlei Garantie für die Fehlerfreiheit der Schaltung oder anderer Projektdateien übernommen werden! Der Nachbau und Betrieb geschieht auf eigene Gefahr! Jegliche Haftung für Schäden oder Verletzungen wird ausgeschlossen! Schadensersatzansprüche, gleich aus welchem Rechtsgrund, sind ausgeschlossen.

Sicherheitshinweise und Haftungsausschluss (zum Aufklappen anklicken)

Dieses Projekt dient vornehmlich für Lehrzwecke und zum Experimentieren. Für den Aufbau sollten ausreichend Elektronik Grundkenntnisse und Kenntnisse bezüglich der Sicherheit (Experimentieren mit Strom und Handhabung gängiger Werkzeuge wie Lötkolben etc.) vorhanden sein. Unter dem Menüpunkt Buchvorstellungen als auch auf der Seite RN-Wissen.de empfehle ich diesbezüglich noch interessante Literatur mit der man sich dies erarbeiten kann. Für Fragen bezüglich Elektronik und Mikrocontroller empfehle ich das Forum: Roboternetz.de

Sicherheitshinweise und Haftungsausschluss
×

2 Gedanken zu “Programmierbare Schrittmotoransteuerung RN-Schrittmotor

  1. Phil

    Hi,
    ich suche schon länger nach einem Schrittmotortreiber.

    Ich benötige aber mehr Leistung, also möchte ich den größeren Bruder L6203 nutzten.

    Ich frage mich nur welche Frequenzen für die Stromsteuerung genutzt werden.

    Ein Mega32 kann bei geringerer Auflösung maximal 80kSPS ?!
    Wenn ich eine Chopping-Freuquenz von min. 20kHz sind das nur vier Abtastungen. Reicht das ?
    Oder arbeitet das Board mit einer geringeren Choppingfreuquenz ?

    LG Phil

    Antworten
    • Frank Autor des Beitrags

      Dieses Board arbeitet mit einer Chopping-Frequenz von ca. 15 khz. Das reicht aber auch nur aus um Schrittzahlen bis bestenfalls 1000 Schritte pro Sekunde gut zu bewältigen. Bei höheren Schrittgeschwindigkeiten sollte auch Chopping-Frequenz höher sein, wie hoch genau müsste man erproben.

      Antworten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Top