Post on 31-Jul-2020
transcript
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 1 10.12.2018
Rubik’s Cube Roboter
Projektdokumentation
Samuel Ulrich, Andreas Jokiel
10.12.2018
GIBZ Zug, AU4
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 2 10.12.2018
Inhaltsverzeichnis
1.0 Einleitung ........................................................................................................................ 3
2.0 Manual ............................................................................................................................ 5
2.1 Inbetriebnahme ............................................................................................................ 6
3.0 Technischer Beschrieb .................................................................................................... 8
3.1 Hardware ..................................................................................................................... 8
3.2 Elektronik ..................................................................................................................... 9
3.3 Software .....................................................................................................................11
4.0 Zusammenfassung .........................................................................................................15
4.1 Probleme und Schwierigkeiten ....................................................................................15
4.2 Erfahrungen ................................................................................................................15
4.3 Weiterentwicklung .......................................................................................................15
5.0 Quellenverzeichnis .........................................................................................................16
6.0 Anhang ...........................................................................................................................16
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 3 10.12.2018
1.0 Einleitung
Diese technische Dokumentation dokumentiert einen Roboter, welcher einen Zauberwürfel
automatisch lösen kann.
Der Kern des Roboters besteht aus sechs Schrittmotoren, welche mit Hilfe von Adaptern die Würfelseiten mechanisch drehen.
Mit dieser Ausführung erreicht man höchste Effizienz zum Lösen des Würfels.
Bild 1: Funktionsaufbau Roboter
Alle Schrittmotoren werden in einem 3D-gedruckten Kunststoffgehäuse eingebaut. Der Starttaster sowie die Lampen sind ebenfalls mit in das Gehäuse eingebunden.
Um den Zauberwürfel in das Gehäuse einzusetzen oder herauszunehmen, muss erst der Deckel entfernt werden und dann einzeln die seitlichen Türme weggezogen werden. Danach kann der Würfel herausgenommen werden.
Bild 2: Grundgerüst Roboter
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 4 10.12.2018
Um den Roboter zu vervollständigen, wird die Konstruktion mit einem Netzgerät, einem Arduino Mega und einer selbst kreierten Treiberplatine für die Schrittmotoren ergänzt.
Das Ganze muss dann noch dem Elektroschema entsprechend verdrahtet und die Software auf den Arduino geladen werden.
Bild 3: kompletter Roboter Aufbau
Bild 4: Explosionszeichnung kompletter Aufbau
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 5 10.12.2018
2.0 Manual
Um den Rubik’s Cube Roboter in Betrieb zu nehmen braucht es folgendes Material:
- Vorgefertigten Roboter Aufbau
- Zauberwürfel
- Scanvorrichtung
- Persönlicher Computer
- Cube Explorer Software
- Arduino Software
Vorgefertigter Roboter Aufbau
Der vorgefertigte Roboter Aufbau besteht aus einem Netzgerät, Arduino, einer Treiberplatine sowie dem mechanischen Aufbau mit den Schrittmotoren. Genauere Informationen zur Weiterentwicklung dieses Projekts befinden sich im Technischen Beschrieb.
Bild 5: vorgefertigter Roboter Aufbau
Zauberwürfel
Der Rubik’s Cube Roboter funktioniert nur mit einem bestimmten Zauberwürfel oder Zauberwürfel mit ähnlichen Eigenschaften. Der Würfel sollte sich leicht bewegen lassen. Aus diesem Grund eignen sich sogenannte Speedcubes am besten. Ausserdem müssen die inneren Abdeckungen entfernbar sein.
Für dieses Projekt wird ein Dayan 3x3 Speedcube verwendet. (https://www.cubikon.de/hersteller/dayan/)
Bild 6: Zauberwürfel
Scanvorrichtung
Die Scanvorrichtung mit der installierten Web Cam wird benötigt, um den Zauberwürfel einzuscannen.
Bild 7: Scanvorrichtung
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 6 10.12.2018
Cube Explorer Software
Die Cube Explorer Software auf dem PC wird benötigt, um den Zauberwürfel einzuscannen.
Die Software berechnet dann auch den Lösungsweg, um den Zauberwürfel zu lösen.
Cube Explorer wird von Herrn Herbert Kociemba zur Verfügung gestellt und kann unter
folgendem Link aus dem Internet geladen und Installiert werden.
https://www.google.de/search?q=cube+explorer+download&gws_rd=ssl
Arduino Software
Die Arduino Software wurde von uns selbst geschrieben und befindet sich standardmässig
auf dem Arduino. Genauere Informationen zur Weiterentwicklung dieses Projekts befinden
sich im Technischen Beschrieb.
2.1 Inbetriebnahme Als erstes muss der Netzstecker vom Netzgerät an eine Steckdose angeschlossen werden.
Der Arduino sowie die Web Cam der Scanvorrichtung müssen mit dem USB Kabel an den
PC angeschlossen werden.
Bild 8: Elektrische Anschlüsse
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 7 10.12.2018
Bild 9: Cube Explorer
Wenn man das Setup soweit vorbereitet hat, muss in der Cube Explorer Software zum Reiter
„Web Cam“ navigiert werden. Im unteren Teil der Software muss man dann die
angeschlossene Web Cam von der Scanvorrichtung auswählen. Dies bewirkt, dass die Web
Cam aktiviert wird und diese bereit ist, den Zauberwürfel einzuscannen.
Danach wird der Zauberwürfel Seite für Seite mit Hilfe der Software eingescannt (die genaue
Anleitung dazu ist grafisch in der Software aufgezeigt). Wenn der Zauberwürfel fertig
eingescannt ist, kann man den Lösungs-Algorithmus laufen lassen, und dieser gibt dann den
Lösungs-String heraus, welcher vom Arduino benötigt wird.
Um den Lösungs-String auf den Arduino zu laden muss die Arduino IDE geöffnet werden
und der Serial Monitor mit der Baudrate von 9600 geöffnet werden. Der Arduino gibt einem
dann ein Feedback, dass man den Lösungs-Algorithmus in den Serial Monitor reinkopieren
kann. Der String kann mit Rechtklick auf Copy Solver to Clipboard aus Cube Explorer kopiert
werden. Wenn der String vom Arduino empfangen ist, befindet sich der Arduino in
Betriebsbereitschaft.
Bevor der Rubik’s Cube Roboter gestartet wird, muss der Zauberwürfel in den Aufbau
integriert werden und mit Hilfe der Motorenadapter an die Schrittmotoren angeschlossen
werden.
Wenn alle diese Schritte erfolgt sind, ist der Rubik’s Cube Roboter in Betriebsbereitschaft
und der Vorgang kann mit Hilfe des Tasters, der sich an der vorderen, roten Säule befindet,
gestartet werden. Während dem Setup leuchtet die rote LED, und während der Zauberwürfel
gelöst wird, leuchtet die grüne LED.
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 8 10.12.2018
3.0 Technischer Beschrieb
3.1 Hardware Die Hardware des Roboters besteht aus dem Grundgerüst mit den Motoren, sowie dem
Netzgerät, dem Arduino und der Treiberplatine. In diesem Abschnitt wird das Grundgerüst
mit den Schrittmotoren genauer beschrieben.
Grundgerüst
Mit Hilfe von Fusion360 (3D-CAD/CAM Programm) wurde das Grundgerüst konstruiert.
Diese 3D Dateien konnten wir dann mit dem Programm Cura und Slic3r in .gcode Dateien
umwandeln.
Das ganze Grundgerüst wurde dann mit dem 3D-Drucker ausgedruckt. Als Material wurde
handelsübliches PLA (Polyactide) verwendet. Wir haben PLA gewählt, da die mechanischen
und thermischen Anforderungen nicht besonders hoch gesetzt sind. Auch ein Vorteil ist, dass
das Material sehr günstig und einfach zu drucken ist – d.h. wir konnten im Budget sparen
und den Ausschuss durch Fehldrucke klein halten.
Motoren
Um die Seiten des Zauberwürfels zu drehen, benutzen wir bipolare NEMA 17 Schrittmotoren.
Wir haben Schrittmotoren gewählt, weil uns das ermöglicht, die Seiten des Zauberwürfels
sehr genau und schnell drehen zu können.
NEMA (National Electrical Manufacturers Association) ist die Bauform des Schrittmotors und
legt z.B. Flanschmass oder typisches Haltemoment fest. NEMA 17 gehört zu den
mittelgrossen Schrittmotoren der ganzen NEMA-Reihe (NEMA 08 – NEMA 34)
Funktionsweise eines bipolaren Schrittmotors:
Um den Schrittmotor zum Drehen zu bringen, muss an den Spulen eine Spannung angelegt werden. Wenn an Spule 1 eine Spannung angelegt wird, dreht sich der Rotor an die Position der Spule – dies entspricht einem Schritt des Motors. Unser Motor hat eine Auflösung von 1.8° pro Schritt und braucht somit 200 Schritte für eine volle Umdrehung.
Um die Auflösung und Performance des Motors zu verbessern, kann der Schrittmotor Teilschritte machen - sogenanntes Microstepping.
Bild 10: Funktionsweise Schrittmotor
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 9 10.12.2018
3.2 Elektronik Die Elektronik besteht aus einem Arduino Mega 2560 und einer von uns selbst hergestellten
Schrittmotor-Treiberplatine. Die elektrische Speisung vom Arduino erfolgt über die USB-
Buchse, und die Speisung der Schrittmotoren bzw. der Treiberplatine wird vom 24V
Netzgerät übernommen.
Arduino
Der Arduino Mega ist das Gehirn des Roboters. Er koordiniert den kompletten
Programmablauf, d.h. die Ansteuerung der Schrittmotortreiber mit dem STEP und DIR
Signal, den Input des Starttasters und die Outputs der Status-LED.
Die Software, welche sich auf dem Arduino Mega befindet, ist im nächsten Kapitel 3.3 genau
beschrieben.
Treiberplatine
Die Treiberplatine beinhaltet die elektrischen Treiber, welche die Schrittmotoren richtig
ansteuern. Die Output-Signale aus dem Arduino (STEP und DIR) sagen dem Treiber, wie
viele Schritte in welche Richtung die Schrittmotoren machen müssen. In diesem Projekt
haben wir Original Pololu DRV8825 Schrittmotortreiber benutzt.
Bild 11: Anschlussschema Schrittmotortreiber
Reset und Sleep sind Sicherheitsmassnahmen. Wenn an diesen Anschlüssen keine +5V
anliegen, ist der Treiber blockiert.
Step und Dir und GND sind die Signale, welche vom Mikrocontroller (Arduino Mega)
kommen.
A1 & A2, B1 & B2 sind die Anschlüsse für die beiden Spulen des Schrittmotors.
Vmot und GND ist die Speisung vom 24V Netzgerät.
M0, M1 und M2 sind Anschlüsse für das Microstepping.
Enable wird gebraucht, um den kompletten Treiber ein- oder auszuschalten.
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 10 10.12.2018
Wir haben uns dafür entschieden, eine eigene Treiberplatine herzustellen, da wir sonst einen
zu grossen Verdrahtungsaufwand hätten und das Ganze sehr unübersichtlich wäre.
In folgendem Bild ist das grafische Layout der Treiberplatine dargestellt. Die Platine
beherbergt zwei Stecker für Signal-Inputs vom Arduino sowie Power-Outputs für die
Motoren. Auch befinden sich in der oberen linken Ecke zwei LED’s, welche anzeigen, ob 5V
und 24V Spannung anliegen.
Das Herzstück der Treiberplatine sind die sechs Schrittmotorentreiber, welche einzeln je
einen Schrittmotor ansteuern.
Bild 12: Grafisches Layout Treiberplatine
Im Anhang befindet sich das detaillierte Elektroschema der Treiberplatine.
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 11 10.12.2018
3.3 Software
Das Arduino-Programm wandelt den Lösungsstring von Cube Explorer in Bewegungen um.
Für die Ausführung der Bewegungen der Schrittmotoren haben wir die Library von laurb9
verwendet. Diese kann auf GitHub heruntergeladen werden. Als erstes werden alle Eingänge
und Variablen definiert.
Bild 13: Softwareauszug 1
Danach werden die Schrittmotoren definiert. Mit dem Befehl A4988 stepper(x) werden die
Daten des Schrittmotors und dessen Treibers definiert. Zuerst wird die Anzahl Schritte für
360° angegeben, in unserem Fall 200, danach der Arduino Pin für die Richtung, und zum
Schluss der Pin für die Schritte angeben. Die Schrittmotortreiber DRV8825 haben 2
Eingänge, welche wir beschalten. Einmal DIR für die Richtung und STEP für die Anzahl
Schritte. Ist DIR auf HIGH geschalten, dreht der Motor im Gegenuhrzeigersinn. Wird STEP
auf HIGH geschaltet, so macht der Motor ein Schritt. Aus diesem Grund muss der STEP Pin
unbedingt auf einen PWM Ausgang des Arduinos angeschlossen werden. Nur so ist der
Motor schnell genug.
Bild 14: Softwareauszug 1
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 12 10.12.2018
Als nächstes kommt die Funktion GetValue. Mit dieser Funktion kann ein String in seine
einzelnen Bestandteile aufgeteilt werden. Dies wird mit der Unterfunktion Substring gemacht.
Es kann ein Separator definiert werden. Der String wird dann bei dem Zeichen, welches als
Separator definiert ist, getrennt. Die Funktion wird später im Programm aufgerufen.
Bild 15: Softwareauszug 1
Im Setup des Programmes werden die zu Beginn definierten Pins als Ein- oder Ausgang
konfiguriert. Ausserdem wird die serielle Verbindung zu Serial Monitor hergestellt und die
Motoren werden gestartet.
Bild 16: Softwareauszug 1
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 13 10.12.2018
Der Loopteil des Programms wird ständig wiederholt. Zu Beginn des Ablaufs werden die
Motortreiber über den Enable-Pin ausgeschaltet. So fliesst kein Haltestrom und die Treiber
werden geschont. Danach wir der Zustand des Drucktasters ausgelesen und in der Variable
buttonState gespeichert.
Bild 17: Softwareauszug 1
Im nächsten Teil des Programmes werden einige Informationen und Anweisungen auf den
Serial Monitor gedruckt. Es wird abgefragt ob ein Lösungstring gesendet wird, falls ja wird er
in der Variable loesung gespeichert. Danach werden wird die LED auf Rot geschaltet.
Bild 18: Softwareauszug 1
Nun wird die Funktion GetValue verwendet. Mit „String split = loesung“ wird definiert,
welcher String geteilt werden soll. Danach wird mit einer If Bedingung abgefragt, ob der
Taster gedrückt wird. Wird der Taster gedrückt, so beginnt eine For-Schleife, welche 25 Mal
wiederholt wird. Ausserdem wird die grüne LED eingeschaltet. In der For-Schleife wird der
String unterteilt. Die Funktion GetValue wird eingesetzt. In Klammer wird zuerst der zu
zerteilende String angeben, dann der Seperator, in unserem Fall ein Leerzeichen und zum
Schluss die Position des zu teilenden Zeichens im String.
Bild 19: Softwareauszug 1
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 14 10.12.2018
Nun folgt der Teil des Programmes, welcher die Bewegungen der Schrittmotoren steuert. Die
getrennte Variable aus dem String wir in mehreren If-Bedingungen abgefragt, bis die
Variable mit der Vorgabe der If-Bedingung übereinstimmt. In dieser If-Bedingung wird die
jeweilige Bewegung gestartet. Zuerst wird die Bewegung zur Kontrolle an den Serial Monitor
gedruckt, dann wird der Motor über den Enable-Pin freigegeben, mit dem Befehl
stepper.rotate(schritte) gedreht und schliesslich mit den Enable-Pin wieder deaktiviert. Diese
If-Bedingungen werden wiederholt, bis der String abgearbeitet ist.
Bild 20: Softwareauszug 1
Das komplette Programm befindet sich im Anhang.
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 15 10.12.2018
4.0 Zusammenfassung
4.1 Probleme und Schwierigkeiten Zu Beginn der Arbeit hatten wir grosse Schwierigkeiten mit der Ansteuerung der Motoren.
Wir mussten die Motortreiber auf den richtigen Nennstrom einstellen. Für diesen Zweck
haben wir einen Testaufbau mit einem Motor gemacht. So konnten wir jeden Motor optimal
einstellen. Meistens lag der Fehler bei uns, aber auch die Treiber waren zum Teil nicht mehr
funktionstüchtig. Die Schrittmotorentreiber sind sehr empfindich und gehen sehr schnell
kaputt. Eine grosse Schwierigkeit bei der Arbeit war das Programm. Das Trennen des
Lösungsstring war das Hauptproblem. Nach langer Recherche im Internet haben wir die
beste Funktion dafür gefunden und haben diese angepasst in unserem Projekt verwendet.
4.2 Erfahrungen Wir haben bei diesem Projekt viele neue Erfahrungen gemacht und neue Erkenntnisse
gewonnen. Wir begrüssen das praktische Arbeiten sehr. Wir konnten in diesem Projekt
mehrere Themengebiete vertiefen. So war die Konstruktion des mechanischen Aufbaus eine
grosse Aufgabe. Auch im Thema Elektrotechnik hatten wir mit dem Schema und der
Treiberplatine eine grosse Aufgabe. Das Thema Software war für uns beide ziemliches
Neuland. Wir hatten beide bereits Erfahrung mit Arduino, jedoch nur Grundlegende
Funktionen. Wir finden es schade, dass wir in der Berufschule nicht häufiger mit
Textbasierten Programmiersprachen in Kontakt kommen, da diese ein sehr Intressantes
Thema wären und heutzutage die Erlernten Programmiersprachen wie FUP fast nicht mehr
praktisch angewendet werden.
4.3 Weiterentwicklung Anders als Ursprünglich geplant konnten wir die Software nicht komplett selbst schreiben.
Für die Rechenarbeit wird das Open Source Programm Cube Explorer verwendet. In einem
nächsten Schritt könnte man das Kamera-Interface auf einem Rasberry Pi programmieren
und diesen auch zum Errechnen des Lösungsstring verwenden. Für das müsste man den
kompletten Algorythmus auf Python programmieren und eine Kommunikation zwischen
Rasberry Pi und Arduino errichten. Weiter könnte man 4 Kameras anbringen, welche den
Würfel auch in eingebauten Zustand erfassen und scannen können. So entfällt das lästige
Scannen.
Gewerblich-industrielles Bildungszentrum Zug Rubik’s Cube Roboter
Samuel Ulrich, Andreas Jokiel 16 10.12.2018
5.0 Quellenverzeichnis
Grafikverzeichnis
Nr. Seite Quelle
1 3 Grafikrender aus Fusion360
2 3 Grafikrender aus Fusion360
3 4 Grafikrender aus Fusion360
4 4 Explosionszeichnung Inventor
5 5 Foto Eigenproduktion
6 5 Foto Eigenproduktion
7 5 Foto Eigenproduktion
8 6 Foto Eigenproduktion
9 8 Screenshot Eigenproduktion
10 8 https://rn-wissen.de/wiki/index.php?title=Schrittmotoren
11 9 https://www.pololu.com/product/2133
12 10 Screenshot Eigenproduktion
13 11 Screenshot Eigenproduktion
14 11 Screenshot Eigenproduktion
15 12 Screenshot Eigenproduktion
16 12 Screenshot Eigenproduktion
17 13 Screenshot Eigenproduktion
18 13 Screenshot Eigenproduktion
19 13 Screenshot Eigenproduktion
20 14 Screenshot Eigenproduktion
6.0 Anhang
- Elektroschema
- Arduino Software
#include <Arduino.h> // Arduino Bibiothek eingefügt#include "A4988.h" // Stepper Library von laurb9 https://github.com/laurb9/StepperDriver
#define MOTOR_STEPS 200 // definiert wie viele Schritte der verwendete Schrittmotor für eine Umdrehung braucht#define Mot_1_Enable 25 // definiert die motor_enable Pins#define Mot_2_Enable 26#define Mot_3_Enable 27#define Mot_4_Enable 28#define Mot_5_Enable 29#define Mot_6_Enable 30#define step90 2860 // Definiert die Anzahl Schritte für 90°, CW#define step180 5720 // Definiert die Anzahl Schritte für 180°, CW#define stepminus90 -2860 // Definiert die Anzahl Schritte für 90°, CCW#define stepminus180 -5720 // Definiert die Anzahl Schritte für 180°, CCW#define LED_rot 23 // Definiert Pin für rotes LED#define LED_grun 22 // Definiert Pin für grünes LED#define button 42 // Definiert Pin für Tasterint buttonState = 0; // Definiert Taster Momentanzustandint x = 1; // Definiert Delay zwischen den Bewegungen#define y 50000 // Definiert MotorgeschwindigkeitString loesung; // Definiert eingehender String von Serialmonitor
A4988 stepper1(MOTOR_STEPS, 3, 2); // Definiert Stepperdriver anschlüsse, Anzahl Steps, DIR pin, STEP pinA4988 stepper2(MOTOR_STEPS, 5, 4);A4988 stepper3(MOTOR_STEPS, 7, 6);A4988 stepper4(MOTOR_STEPS, 9, 8);A4988 stepper5(MOTOR_STEPS, 11, 10);A4988 stepper6(MOTOR_STEPS, 12, 13);
String getValue(String data, char separator, int index) // Funktion teilt den String in seine Bestandteile auf. Für das wird die Funktion Substring verwendet. Index wird in Char gespeichert. Delimiter kann gewählt werden.{ int found = 0; int strIndex[] = {0, -1}; int maxIndex = data.length()-1;
for(int i=0; i<=maxIndex && found<=index; i++){ if(data.charAt(i)==separator || i==maxIndex){ found++; strIndex[0] = strIndex[1]+1;
strIndex[1] = (i == maxIndex) ? i+1 : i; } }
return found>index ? data.substring(strIndex[0], strIndex[1]) : "";}
void setup() {
Serial.begin(9600); //Serielle Verbindung aufbauen while (!Serial) { //Warten bis Serielle Verbindung steht. ; }
stepper1.begin(y, 32); // Stepper initialisieren (Geschwindigkeit, Microstepping) stepper2.begin(y, 32); stepper3.begin(y, 32); stepper4.begin(y, 32); stepper5.begin(y, 32); stepper6.begin(y, 32);
pinMode( Mot_1_Enable, OUTPUT); // Pins auf In oder Output definieren pinMode( Mot_2_Enable, OUTPUT); pinMode( Mot_3_Enable, OUTPUT); pinMode( Mot_4_Enable, OUTPUT); pinMode( Mot_5_Enable, OUTPUT); pinMode( Mot_6_Enable, OUTPUT); pinMode( LED_rot, OUTPUT); pinMode( LED_grun, OUTPUT); pinMode( button, INPUT);}
void loop() {
digitalWrite(Mot_1_Enable, HIGH); // Motor_Enable pins auf High setzen, sodass kein Haltestrom anliegtdigitalWrite(Mot_2_Enable, HIGH);digitalWrite(Mot_3_Enable, HIGH);digitalWrite(Mot_4_Enable, HIGH);digitalWrite(Mot_5_Enable, HIGH);digitalWrite(Mot_6_Enable, HIGH); buttonState = 0; // Taster Momentatanstatus aktulaisieren buttonState = digitalRead(button);
Serial.println("Betriebsbereit"); //Status auf Serail Monitor drucken Serial.println("Bitte Lösungsstring senden"); Serial.println();
if (Serial.available() > 0) {
loesung = Serial.readString(); Serial.println("String eingelesen String ="); // Serial Monitor auslesen und String in Variable in Lösung schreiben Serial.println(loesung); }
if(buttonState == LOW);{ digitalWrite(LED_rot, HIGH); // LED's entsprechend Tasterzustand schalten, Rot = Stop, Grün = Ablauf in Gang digitalWrite(LED_grun, LOW);
}
String split = loesung; // String für splitting in Variable split schreiben
if(buttonState == HIGH){ // Tasterzustand abfragen , wenn ja Ablauf starten
digitalWrite(LED_grun, HIGH); digitalWrite(LED_rot, LOW);
for (int i=0; i <= 25; i++){ // For Loop für 25 schritte
String aktuell = getValue(split, ' ', i); // String nach folgenden Kriterien auftrennen, Unterbruchzeichen ist ein Leerschlag, Position von zu teilendem Substring wird von i gegeben
Serial.println(aktuell);
if (aktuell == "U") { // If statemant für Bewegungsabarbeitung, Bewegung auf Serial Monitor drucken, Motor Enable abschalten, Bewegung ausführen, nach Delay wieder Motor_Enable einschalten Serial.println("Upper Face 90° CW"); digitalWrite(Mot_1_Enable, LOW); stepper1.rotate(step90); delay(x); digitalWrite(Mot_1_Enable, HIGH); delay(x);
}
if (aktuell == "U2") { Serial.println("Upper Face 180° CW"); digitalWrite(Mot_1_Enable, LOW); stepper1.rotate(step180); delay(x); digitalWrite(Mot_1_Enable, HIGH); delay(x);}if (aktuell == "U'") { Serial.println("Upper Face 90° CCW"); digitalWrite(Mot_1_Enable, LOW); stepper1.rotate(stepminus90); delay(x); digitalWrite(Mot_1_Enable, HIGH); delay(x);}
if (aktuell == "D") { Serial.println("Down Face 90° CW"); digitalWrite(Mot_2_Enable, LOW); stepper2.rotate(step90); delay(x); digitalWrite(Mot_2_Enable, HIGH); delay(x);}if (aktuell == "D2") { Serial.println("Down Face 180° CW"); digitalWrite(Mot_2_Enable, LOW); stepper2.rotate(step180); delay(x); digitalWrite(Mot_2_Enable, HIGH); delay(x);}if (aktuell == "D'") { Serial.println("Down Face 90° CCW"); digitalWrite(Mot_2_Enable, LOW); stepper2.rotate(stepminus90); delay(x); digitalWrite(Mot_2_Enable, HIGH); delay(x);}
if (aktuell == "F") { Serial.println("Front Face 90° CW"); digitalWrite(Mot_3_Enable, LOW); stepper3.rotate(step90); delay(x);
digitalWrite(Mot_3_Enable, HIGH); delay(x);}if (aktuell == "F2") { Serial.println("Front Face 180° CW"); digitalWrite(Mot_3_Enable, LOW); stepper3.rotate(step180); delay(x); digitalWrite(Mot_3_Enable, HIGH); delay(x);}if (aktuell == "F'") { Serial.println("Front Face 90° CCW"); digitalWrite(Mot_3_Enable, LOW); stepper3.rotate(stepminus90); delay(x); digitalWrite(Mot_3_Enable, HIGH); delay(x);}
if (aktuell == "B") { Serial.println("Back Face 90° CW"); digitalWrite(Mot_4_Enable, LOW); stepper4.rotate(step90); delay(x); digitalWrite(Mot_4_Enable, HIGH); delay(x);}if (aktuell == "B2") { Serial.println("Back Face 180° CW"); digitalWrite(Mot_4_Enable, LOW); stepper4.rotate(step180); delay(x); digitalWrite(Mot_4_Enable, HIGH); delay(x);}if (aktuell == "B'") { Serial.println("Back Face 90° CCW"); digitalWrite(Mot_4_Enable, LOW); stepper4.rotate(stepminus90); delay(x); digitalWrite(Mot_4_Enable, HIGH); delay(x);}
if (aktuell == "L") { Serial.println("Left Face 90° CW"); digitalWrite(Mot_5_Enable, LOW); stepper5.rotate(step90);
delay(x); digitalWrite(Mot_5_Enable, HIGH); delay(x);}if (aktuell == "L2") { Serial.println("Left Face 180° CW"); digitalWrite(Mot_5_Enable, LOW); stepper5.rotate(step180); delay(x); digitalWrite(Mot_5_Enable, HIGH); delay(x);}if (aktuell == "L'") { Serial.println("Left Face 90° CCW"); digitalWrite(Mot_5_Enable, LOW); stepper5.rotate(stepminus90); delay(x); digitalWrite(Mot_5_Enable, HIGH); delay(x);}
if (aktuell == "R") { Serial.println("Right Face 90° CW"); digitalWrite(Mot_6_Enable, LOW); stepper6.rotate(stepminus90); delay(x); digitalWrite(Mot_6_Enable, HIGH); delay(x);}if (aktuell == "R2") { Serial.println("Right Face 180° CW"); digitalWrite(Mot_6_Enable, LOW); stepper6.rotate(stepminus180); delay(x); digitalWrite(Mot_6_Enable, HIGH); delay(x);}if (aktuell == "R'") { Serial.println("Right Face 90° CCW"); digitalWrite(Mot_6_Enable, LOW); stepper6.rotate(step90); delay(x); digitalWrite(Mot_6_Enable, HIGH); delay(x);}delay(1);
}
}
}
09.12.2018 13:41 f=0.62 C:\Users\Andreas\Downloads\CubeSolver.sch (Sheet: 1/1)
02.05.2018 15:28 f=0.62 C:\Users\Andreas\Desktop\Andreas\Berufsschule\BEPR_04 Cubesolver\Schema\CubeSolver-Elektroschema.sch (Sheet: 1/3)
Klemmen
Verbraucher
10A@24VDC
230V
Änderung Datum Name
Datum
Bearb.
Gepr.
Norm
29.03.2018
Jokiel Andreas
Kunde:
Kunden-Zeichnung:
GIBZ BEPR_04
Urspr. Ers. f. Ers. d.
Auftrags-Nr:
Ersteller
Jokiel Andreas
Werks-Nr.
Zeichnungs-Nr. Blatt
1/3
Dateiname:
CubeSolver-Elektroschema
Projekt:
CubeSolver
T1123 4
PE
X1
1.1
1.2
X1
2.1
2.2
PE
L1
N
24V
DC
/2.1
A
0VD
C/2
.1A
A
B
C
D
E
F
G
H
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+
EIN
SP
EIS
UN
GL
N
PE
02.05.2018 15:28 f=0.62 C:\Users\Andreas\Desktop\Andreas\Berufsschule\BEPR_04 Cubesolver\Schema\CubeSolver-Elektroschema.sch (Sheet: 2/3)
Klemmen
Verbraucher
Start
1k
grün
rot
680
680
Änderung Datum Name
Datum
Bearb.
Gepr.
Norm
29.03.2018
Jokiel Andreas
Kunde:
Kunden-Zeichnung:
GIBZ BEPR_04
Urspr. Ers. f. Ers. d.
Auftrags-Nr:
Ersteller
Jokiel Andreas
Werks-Nr.
Zeichnungs-Nr. Blatt
2/3
Dateiname:
CubeSolver-Elektroschema
Projekt:
Cube Solver
A1
MEGA
RX/0TX/1
PWM/2
AIN0
PWM/3PWM/4PWM/5PWM/6PWM/7PWM/8PWM/9
PWM/10PWM/11PWM/12PWM/13
AIN1AIN2AIN3AIN4AIN5
5V
GNDGND
VIN
3V3
GND
AREF
RESET
AIN6AIN7AIN8AIN9AIN10AIN11AIN12AIN13AIN14AIN15
GND
TX3/14RX3/15
RX2/17TX2/16
TX1/18RX1/19SDA/20SCL/21
22232425262728293031323334353637383940414243
PWM/44PWM/45PWM/46
474849
MISO/50MOSI/51SCK/52
SS/53
5V5V
GND
IOREF
SDASCL
S1
1413
R1
LED
1
LED
2
R2
R3
24VDC/1.3G 24VDC
0VDC/1.4G 0VDC
STEP-A2/3.2FDIR-A2/3.2F
STEP-A3/3.5FDIR-A3/3.5F
STEP-A4/3.7FDIR-A4/3.7F
STEP-A5/3.10FDIR-A5/3.10F
STEP-A6/3.12FDIR-A6/3.12F
STEP-A7/3.15FDIR-A7/3.15F
EN-A2/3.3EEN-A3/3.5E
EN-A4/3.8EEN-A5/3.10E
EN-A6/3.12EEN-A7/3.15E
5V/3.1A
A
B
C
D
E
F
G
H
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
02.05.2018 15:28 f=0.62 C:\Users\Andreas\Desktop\Andreas\Berufsschule\BEPR_04 Cubesolver\Schema\CubeSolver-Elektroschema.sch (Sheet: 3/3)
Klemmen
VerbraucherSTEPPER_BIPOLAR STEPPER_BIPOLAR STEPPER_BIPOLAR STEPPER_BIPOLAR STEPPER_BIPOLAR STEPPER_BIPOLAR
Änderung Datum Name
Datum
Bearb.
Gepr.
Norm
29.03.2018
Jokiel Andreas
Kunde:
Kunden-Zeichnung:
GIBZ BEPR_04
Urspr. Ers. f. Ers. d.
Auftrags-Nr:
Ersteller
Jokiel Andreas
Werks-Nr.
Zeichnungs-Nr. Blatt
3/3
Dateiname:
CubeSolver-Elektroschema
Projekt:
CubeSolver
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A2
M1
BL R
DB
KG
N
M2
BL R
DB
KG
N
M3
BL R
DB
KG
N
M4
BL R
DB
KG
NM5
BL R
DB
KG
N
M6
BL R
DB
KG
N
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A3
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A4
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A5
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A6
VMOTGNDB2B1A1A2FLTGND2
ENM0M1M2
RSTSLP
STEPDIR
A7
24VDC24VDC/2.1A
0VDC0VDC/2.1A
5V/2.4B
STEP-A3/2.6B
DIR-A3/2.6B
STEP-A4/2.6B
DIR-A4/2.6B
STEP-A5/2.6B STEP-A6/2.6C
DIR-A6/2.6C
STEP-A7/2.6C
DIR-A7/2.6C
STEP-A2/2.6B
DIR-A2/2.6B DIR-A5/2.6C
EN-A2/2.6D EN-A3/2.6D EN-A4/2.6D EN-A5/2.6D EN-A6/2.6D EN-A7/2.6D
A
B
C
D
E
F
G
H
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
M M M M M M