Zwei DC Motoren mit Schalterabfrage steuern

Hallo zusammen,

ich heiße Mathias und beschäftige mich gerade mit dem Bau eines Funktionsmodelles eines Fahrgeschäftes im großen Maßstab. Ein wenig Erfahrung mit einem Arduino Uno konnte ich zwar schon sammeln, aber mehr als einen Motor mit Anfahr- und Bremsvorgang anzusteuern wurde noch nicht benötigt.

Bei diesem Modell sollen durch betätigen eines Schalters (Taster ginge auch, wenn möglich) zwei Getriebemotoren (12 V) mit einer Rampe gleichzeitig anfahren.
Sobald Motor 1 seine Nenndrehzahl erreicht hat, soll Motor 2 anhalten. Wenn der Schalter von 1 auf 0 geschaltet (oder ein anderer Taster betätigt) wird, soll Motor 1 abbremsen und Motor zwei gleichzeitig umgepolt werden und in die andere Richtung drehen, bis beide gleichzeitig zum Stillstand kommen.
Ich hoffe es ist verständlich beschrieben.
Vorhandene Hardware ist ein Arduino Uno, sowie das Velleman Motorshield und natürlich die beiden DC 12 V (max. 2A) Getriebemotoren mit Spannungsversorgung.

Ich habe schon einige Zeit versucht den Einstieg zu finden, aber es will nicht so recht klappen den Code zu schreiben.
Vor allem die Drehrichtungsumkehr, Schalterabfrage und das gewünschte gleichzeitige Anfahren beider Motoren bereiten mir Probleme.
Kann mir vielleicht jemand weiterhelfen? Vielen Dank im vorraus!

Grüße, Mathias

Hallo Mathias,

Helfen werden wir gern, aber zuerst musst du liefern.
Wir brauchen von dir den Sketch, den du bisher zu deinem Projekt geschrieben hast.

Dann wissen wir auch, wie wir dir helfen können.
Allerdings ist nicht so ganz klar was du erreichen willst. Aber das kannst du in deinem Sketch ja dokumentieren.

Und damit willkommen im Forum.

Hallo Matthias,

mir stellen sich folgende Fragen:

  • woran erkennst Du die Nenndrehzahl? Da muss also noch ein Geber mit Auswertung ran.
  • Motor 2 soll also mal flott umgepolt werden und läuft mit Motor 1 synchron an. Ich gehe mal davon aus, das mag jeder Motor sehr gerne ... :o
  • wie willst Du die beiden Motoren beim Runterfahren sychronisieren, dass sie gleichzeitig zum Stillstand kommen?
  • über welche Drehzahl reden wir eigentlich?

Freue mich auf Antworten

Guten Abend,

vorweg vielen Dank für Eure Antworten und das ihr mir helfen möchtet.
Ich glaube der Ablauf ist etwas missverständlich von mir beschrieben worden, ich versuche es etwas konkreter zu beschreiben:
Das Modell besteht aus einem großen Drehverbund an dessen Umfang zwanzig frei schwingende Gondeln aufgehängt sind. Mit zunehmender Drehgeschwindigkeit (Motor 1) desselben, soll ein zweiter Motor über eine Mechanik die Gondeln zum Ausschwingen bringen, da das über die beim Vorbild vorhandene Massenträgheit in Zusammenspiel mit der Fliehkraft im Modell nicht funktioniert.
Der zweite Motor muss nur ein kleines Stück drehen, bis der Hauptmotor (Motor 1) volle Geschwindigkeit erreicht hat, dann stoppt er. Wird nun der Hauptmotor bis zum Stillstand abgebremst, soll Motor 2 umgepolt wieder anfangen zu drehen, um die Gondeln in ihre Ausgangslage zurück zu bewegen. Wenn der Drehverbund (Motor 1) steht, soll Motor 2 ebenfalls zum Stillstand kommen.
Ausgelöst werden soll der ganze Ablauf entweder durch einen Kippschalter (Stellung 1= Start des Vorganges, Stellung 0= Anhalten), oder (falls besser realisierbar) durch einen Starttaster und einen Stopptaster.

Ich habe bisher versucht den Code schrittweise und erstmal für den Hauptmotor aufzubauen (deshalb habe ich Motor 2 erstmal “ausgeklammert”. Da ich aber nicht genau weiß, wo der Schalter eingefügt werden muss und generell Zweifel habe, ob das so realisierbar ist, habe ich mich an das Forum gewandt.

Hier mal der bisherige Stand:

int dir_b=8;
int pwm_b=9;
 
int dir_a=2;
int pwm_a=3;
 
void setup(){
 pinMode(pwm_a, OUTPUT);  //Set control pins to be outputs
 pinMode(pwm_b, OUTPUT);
 pinMode(dir_a, OUTPUT);
 pinMode(dir_b, OUTPUT); 
}
 
void loop(){
 
 {delay(100);
 }
 
 // Motor1 Beschleunigen
 for (int i=0; i<256; i+=5){
   // means the motor will turn right
   digitalWrite(dir_b,LOW);
   analogWrite(pwm_b,i); // speed counts from 0 to 255
   delay(200);
 }

 // motor2 Beschleunigen
// for (int i=0; i<256; i+=5){
   // LOW means the motor will turn right
 //  digitalWrite(motor2_A,LOW);
 //  analogWrite(motor2_Speed,i); // speed counts from 0 to 255
  // delay(200);
// }

// Motor1 Abbremsen
for (int i=255; i>0; i-=5){
   //LOW means the motor will turn right
   digitalWrite(dir_b,LOW);
   analogWrite(pwm_b,i); // speed counts from 0 to 255
   delay(200);
 }
 
{delay(200);
}
 
 // Umkehr Drehrichtung motor2 Ausschwung 

 // motor2 Beschleunigen
// for (int i=0; i<256; i+=5){
   // A = LOW and B = HIGH means the motor will turn left
  // digitalWrite(motor2_A,HIGH);
   //analogWrite(motor2_Speed,i); // speed counts from 0 to 255
   //delay(20);
 // }

 // motor 2 Abbremsen
 //for (int i=255; i>0; i-=5){
   //HIGH means the motor will turn left
   //digitalWrite(motor2_A,HIGH);
   //analogWrite(motor2_Speed,i); // speed counts from 0 to 255
   //delay(20);
// }
}

Am Anfang hatte ich überlegt an Stelle des Motor 2 ein Servo zu verwenden, aber die Bewegungen müssen langsam und gleichmäßig sein, deshalb fiel meine Wahl auf einen Getriebemotor.

Nochmals danke und viele Grüße,

Mathias

Wenn ich das richtig verstanden habe: Der Motor 2 soll die am Ras drehenden (mehreren) Gondeln nach außen auslenken und wieder zurück?
Wie willst Du das mechanisch umsetzen? Oder soll das 1 Motor pro Gondel werden?

Gruß Tommy

Hallo Mathias,
Du benötigst eine Ablaufsteuerung, die Du ja schon probiert hast, und den Umstieg von der Denkweise “Das Programm fängt vorne an und ist am Ende fertig” hin zu “loop ist die Schleife und kommt immer bei den Programmteilen vorbei, die gerade im Ablauf benötigt werden”.

Außerdem hilfreich ist die Verwendung von millis() anstelle delay().

Bei Motor 2 hast Du m. E. eine Konzeptionsfehler: Wenn Motor 2 ständig dreht, drehen ja uch die Gondeln. Die sollen doch aber nur nach außen schwingen. Das ist dann eine endliche Bewegung, also Beschleunigen und Bremsen. Oder?

Als Anregung:

const int dir_b = 8;
const int pwm_b = 9;
const int dir_a = 2;
const int pwm_a = 3;
const int schalterPin = A0;
enum Zustaende {M1BESCHL, M2BESCHL, M2BREMS};
byte zustand = M1BESCHL;
unsigned long previousMillis, currentMillis;
unsigned int intervall = 20;
byte speed;

void setup() {
  pinMode(pwm_a, OUTPUT);
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);
  pinMode(schalterPin, INPUT_PULLUP);
}

void loop() {
  currentMillis = millis();
  if (!digitalRead(schalterPin)) {
    if (currentMillis - previousMillis >= intervall) {
      previousMillis = currentMillis;
      switch (zustand) {
        case M1BESCHL:  // Motor1 Beschleunigen
          if (speed < 255) {
            speed++;
            digitalWrite(dir_b, LOW);
            analogWrite(pwm_b, speed);
          } else {
            zustand = M2BESCHL;
            speed = 0;
          }
          break;
        case M2BESCHL:  // Motor2 Beschleunigen
          if (speed < 50) {
            speed++;
            digitalWrite(dir_a, LOW);
            analogWrite(pwm_a, speed);
          } else {
            zustand = M2BREMS;
          }
          break;
        case M2BREMS:  // Motor2 Bremsen
          if (speed > 0) {
            speed--;
            digitalWrite(dir_a, LOW);
            analogWrite(pwm_a, speed);
          }
          break;
      }
    }
  }
}

Wenn Du im Forum nach “agnue Anleitung” suchst, stößt Du auf weiteren Lesestoff.

Wie groß soll das “Fahrgeschäft im großen Maßstab” denn werden?

ich glaube es soll ein Kettenkarussell werden. Die werden aber nicht so gut nach aussen getrieben wie das Orginal, weil Masse fehlt.

Nun soll der Winkelmotor ab einer bestimmten Drehzahl des Drehmotors anfangen langsam die Sessel nach aussen zu treiben. Vermutlich sind die Ketten versteift.

Und wenn das Karussell anhält sollen die Ketten wieder zurück "schwingen".

Die Geschwindigkeit ist dann leicht aus dem PWM abzuleiten. IST-wert reicht dann völlig

Hallo zusammen,

danke agmue für Deine Mühe, die Hinweise und das Beispiel! Die Funktion millis kannte ich nicht. Du hast das richtig verstanden, der Motor 2 soll nur ein Stück drehen, dann stoppen und wenn der Hauptdreh verzögert, das kleine Stück wieder in die Gegenrichtung.
Das Modell hat einen Durchmesser von etwas über einem Meter, es handelt sich um den Nachbau einer Huss (Hersteller) "Enterprise", ein Klassiker unter den Fahrgeschäften.

@ chefin: Kein Kettenkarussell :wink: obwohl die Problematik die gleiche wäre.
Genau, an so etwas wie Geschwindigkeit mittels der PWM auszuprobieren, dachte ich auch. Vielleicht habe ich mich mit dem "Nennwert" falsch ausgedrückt.

@ tommy: der Ausschwung soll über einen Zentralen Motor mittels Seilen realisiert werden.

Grüße,
Mathias

Jo, also Sitze die sich mit der Fliekraft nach Aussen bewegen und Fliehkraft ist von Durchmesser abhängig bei gleicher Geschwindigkeit. Realistisch wird das im Modell nie, weil entweder muss man bei dem kleineren Durchmesser die Drehzahl erhöhen, was unnatürlich wirkt oder sie bewegen sich nicht genug nach Aussen.

So wie ich Idiot mich fast vom Baukran schleudere. Weil ein 60m Ausleger und 5U/min 110kmh Umfangsgeschwindigkeit sind. Das Modell hätte bei 1:18 aber nur 6,3kmh Umfanggeschwindigkeit. Und das reicht nunmal nicht für sauberes Ausschwingen der Gondeln.

MPK2000:
... der Motor 2 soll nur ein Stück drehen, dann stoppen und wenn der Hauptdreh verzögert, das kleine Stück wieder in die Gegenrichtung.

Du benötigst auch noch eine Lageerkennung für die Gondeln, also Gondeln hängen senkrecht runter oder Gondeln schwingen maximal aus. Mit einem Gleichstrommotor kannst Du nur im Zusammenspiel mit einer Positionserkennung reproduzierbar Positionen anfahren. Lösungsansätze gibt es da mehrere.