fischertechnik Motorhalterung aus dem 3D-Drucker

fischertechnik power motor holder
fischertechnik power motor holder

Halterungen für fischertechnik Power Motoren aus dem 3D-Drucker

Die alten fischertechnik Getriebemotoren wurden inzwischen durch einbaufreundlichere Versionen ersetzt.
Viele Anwender besitzen aber noch diese Motoren. Die einzige Befestigungsmöglichkeit über die Frontplatte war nicht immer optimal.
Ich habe einen Einbaurahmen im üblichen fischertechnik Nut-System erstellt.
Leider ist der Motordurchmesser > 30mm, so dass die Halterung in das nächste Rastermaß von 45mm fällt.
Also etwas klobig ausfällt. Der Motor ist damit von 4 Seiten verbaubar.
Ich habe 2 Versionen mit 15 und 30mm Einbautiefe bei Thingiverse hinterlegt. Mit dem hinterlegten Fusion 360 File kann man selber beliebige Abwandlungen erstellen.

Die Motoren sind bis auf die Einbaumaße nicht schlecht, da recht drehmomentstark und in diversen Übersetzungen erhältlich gewesen. Es gibt aber im Modellbausektor noch immer diese Bauform. Auch bei ebay kann man für wenige Euro diese Motoren aus China beziehen.
Damit man mit fischertechnik kompatibel bleibt, sollte die Achse 5mm Durchmesser und eine Fase haben. Die zulässige Betriebsspannung sollte bei 9 bzw. 12 Volt liegen.

Mein Entwurf erlaubt einen maximalen Motordurchmesser von 33mm und einen Abstand der Befestigungslöcher untereinander von 23 mm.
fischertechnik power motor holder

China Post – PCA9685 16-Channel 12-bit PWM Servo Motor Driver

PCA9685 16-Channel 12-bit PWM Servo Motor Driver
PCA9685 16-Channel 12-bit PWM Servo Motor Driver

PCA9685 – 16 Servo Motoren am Arduino

Der 16 Kanal Servo Treiber basiert auf dem Entwurf von Adafruit. In der China Variante ist er etwas günstiger. Die Platine hat 6 I2C  Adresspins. Damit wären 62 Treiber mit insgesamt 992 Ausgängen adressierbar. Das sollte reichen. Die Platinen kaskadiert man einfach mit einem 6-poligen Kabel hintereinander. Die Basisadresse des Boards ist 0x40 . Eine Lötbrücke bei A0 würde 0x41 ergeben.
Pegel und Betriebsspannung können 3,3 Volt als auch 5 Volt betragen.
Die Betriebsspannung setzt man am besten auf die des Mikrocontrollers. Damit hat man keine Pegel Probleme am I2C-Bus.
Die Servos sollte man auf jeden Fall über eine externe Spannungsquelle betreiben. Ein kleiner Stütz-Elko kann nachträglich eingelötet werden.
Die Ausgänge verfügen über 330 Ohm Widerstände um LED´s direkt zu treiben. Bei manchen Boards sind es 220 Ohm.

Der Arduino Uno wird wie folgt angeschlossen:

  • +5v -> VCC
  • GND -> GND
  • Analog 4 -> SDA
  • Analog 5 -> SCL

 



/*************************************************** 
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 16 servos, one after the other
  Pick one up today in the adafruit shop!
  ------> http://www.adafruit.com/products/815
  These displays use I2C to communicate, 2 pins are required to  
  interface. For Arduino UNOs, thats SCL -> Analog 5, SDA -> Analog 4
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!
  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// you can also call it with a different address you want
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);

// Depending on your servo make, the pulse width min and max may vary, you 
// want these to be as small/large as possible without hitting the hard stop
// for max range. You'll have to tweak them as necessary to match the servos you
// have!
#define SERVOMIN  150 // this is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX  600 // this is the 'maximum' pulse length count (out of 4096)

// our servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("16 channel Servo test!");

  pwm.begin();
  
  pwm.setPWMFreq(60);  // Analog servos run at ~60 Hz updates

  yield();
}

// you can use this function if you'd like to set the pulse length in seconds
// e.g. setServoPulse(0, 0.001) is a ~1 millisecond pulse width. its not precise!
void setServoPulse(uint8_t n, double pulse) {
  double pulselength;
  
  pulselength = 1000000;   // 1,000,000 us per second
  pulselength /= 60;   // 60 Hz
  Serial.print(pulselength); Serial.println(" us per period"); 
  pulselength /= 4096;  // 12 bits of resolution
  Serial.print(pulselength); Serial.println(" us per bit"); 
  pulse *= 1000;
  pulse /= pulselength;
  Serial.println(pulse);
  pwm.setPWM(n, 0, pulse);
}

void loop() {
  // Drive each servo one at a time
  Serial.println(servonum);
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) { pwm.setPWM(servonum, 0, pulselen); } delay(500); for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    pwm.setPWM(servonum, 0, pulselen);
  }

  delay(500);

  servonum ++;
  if (servonum > 7) servonum = 0;
}

China Post – Arduino Motortreiber L9110

L9110 Motor Driver
L9110 Motor Driver

Arduino L9110 Motorsteuerung für 2 Motoren

Dieses kleine Modul verfügt über zwei unabhängige HG7881 (L9110S) Motor-Treiber-Chips, die jeweils 800mA Dauerstrom liefern können. Logik und Spannungsversorgung der Motoren können von 2,5 V bis 12 V betrieben werden, so dass dieses Modul mit 3,3V und 5V Mikrocontrollern verwendet werden kann.
Ein PWM Pulsweitenmodulationssignal wird verwendet, um die Drehzahl eines Motors zu steuern und ein digitaler Ausgang wird verwendet, um seine Richtung zu ändern. Dieses Modul kann 2 Gleichstrommotoren oder einen zwei Phasen-Schrittmotor antreiben. Die Ausgänge verfügen über Integrierte Schutzdioden. Einen Temperatur-/ Überlastungsschutz gibt es wohl nicht. Bei einem 1A Steppermotor fingen die Treiber-IC an zu rauchen. Erstaunlicherweise haben sie dies überstanden. Die maximale Chiptemperatur ist mit 80 Grad angegeben.

Betrieb Gleichstrommotoren am Arduino
Motor an Klemme A bzw. B.
Eingang IA steuert per PWM vom Arduino die Drehzahl. Für IB reicht ein einfacher Digital Pin für die Drehrichtung.

Betrieb Stepper am Arduino

Arduino L9110 Stepper Modul
Arduino L9110 Stepper Modul

4 Digitalpins. Die zwei Wicklungen an den A bzw. B-Ausgang. Polung beachten bzw. ausprobieren. Der L9110 Treiber kommt mit der Arduino Stepper Bibliothek gut zurecht. Der Funktionsumfang ist allerdings bescheiden.

Für den Treiber auf jeden Fall eine externe Versorgungsspannung verwenden.
Mangels Kühlung kommen die Treiber bei größeren Motoren schnell an ihre Grenzen.

Bei eBay wird das Modul ab 2€ gehandelt.

Motor Control Interface
Pin Description
B-IA Motor B Input A (IA)
B-IB Motor B Input B (IB)
GND Ground
VCC Operating Voltage 2.5-12V
A-IA Motor A Input A (IA)
A-IB Motor A Input B (IB)


IA IB Motor State
Low Low Off
High Low Forward
Low High Reverse
High High Off

Fazit:
Billig, klein und einfach zu verwenden. Für Modellbau-Gleichstrommotoren (fischertechnik & Co) und kleinere Schrittmotoren ideal.

/* Adafruit Arduino - Lesson 16. Stepper */

#include &lt;Stepper.h&gt;

int in1Pin = 10;
int in2Pin = 11;
int in3Pin = 12;
int in4Pin = 13;

Stepper motor(512, in1Pin, in2Pin, in3Pin, in4Pin);  

void setup()
{
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);

  // this line is for Leonardo's, it delays the serial interface
  // until the terminal window is opened
  while (!Serial);
  
  Serial.begin(9600);
  motor.setSpeed(20);
}

void loop()
{
  if (Serial.available())
  {
    int steps = Serial.parseInt();
    motor.step(steps);
  }
}
/*
 HG7881_Motor_Driver_Example - Arduino sketch
  
 Arduino digital output D10 to motor driver input B-IA.
 Arduino digital output D11 to motor driver input B-IB.
 Motor driver VCC to operating voltage 5V.
 Motor driver GND to common ground.
 Motor driver MOTOR B screw terminals to a small motor.
*/
 
// wired connections
#define HG7881_B_IA 10 // D10 --> Motor B Input A --> MOTOR B +
#define HG7881_B_IB 11 // D11 --> Motor B Input B --> MOTOR B -
 
// functional connections
#define MOTOR_B_PWM HG7881_B_IA // Motor B PWM Speed
#define MOTOR_B_DIR HG7881_B_IB // Motor B Direction
 
// the actual values for "fast" and "slow" depend on the motor
#define PWM_SLOW 50 // arbitrary slow speed PWM duty cycle
#define PWM_FAST 200 // arbitrary fast speed PWM duty cycle
#define DIR_DELAY 1000 // brief delay for abrupt motor changes
 
void setup()
{
 Serial.begin( 9600 );
 pinMode( MOTOR_B_DIR, OUTPUT );
 pinMode( MOTOR_B_PWM, OUTPUT );
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
}
 
void loop()
{
 boolean isValidInput;
 // draw a menu on the serial port
 Serial.println( "-----------------------------" );
 Serial.println( "MENU:" );
 Serial.println( "1) Fast forward" );
 Serial.println( "2) Forward" );
 Serial.println( "3) Soft stop (coast)" );
 Serial.println( "4) Reverse" );
 Serial.println( "5) Fast reverse" );
 Serial.println( "6) Hard stop (brake)" );
 Serial.println( "-----------------------------" );
 do
 {
 byte c;
 // get the next character from the serial port
 Serial.print( "?" );
 while( !Serial.available() )
 ; // LOOP...
 c = Serial.read();
 // execute the menu option based on the character recieved
 switch( c )
 {
 case '1': // 1) Fast forward
 Serial.println( "Fast forward..." );
 // always stop motors briefly before abrupt changes
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
 delay( DIR_DELAY );
 // set the motor speed and direction
 digitalWrite( MOTOR_B_DIR, HIGH ); // direction = forward
 analogWrite( MOTOR_B_PWM, 255-PWM_FAST ); // PWM speed = fast
 isValidInput = true;
 break; 
 
 case '2': // 2) Forward 
 Serial.println( "Forward..." );
 // always stop motors briefly before abrupt changes
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
 delay( DIR_DELAY );
 // set the motor speed and direction
 digitalWrite( MOTOR_B_DIR, HIGH ); // direction = forward
 analogWrite( MOTOR_B_PWM, 255-PWM_SLOW ); // PWM speed = slow
 isValidInput = true;
 break; 
 
 case '3': // 3) Soft stop (preferred)
 Serial.println( "Soft stop (coast)..." );
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
 isValidInput = true;
 break; 
 
 case '4': // 4) Reverse
 Serial.println( "Fast forward..." );
 // always stop motors briefly before abrupt changes
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
 delay( DIR_DELAY );
 // set the motor speed and direction
 digitalWrite( MOTOR_B_DIR, LOW ); // direction = reverse
 analogWrite( MOTOR_B_PWM, PWM_SLOW ); // PWM speed = slow
 isValidInput = true;
 break; 
 
 case '5': // 5) Fast reverse
 Serial.println( "Fast forward..." );
 // always stop motors briefly before abrupt changes
 digitalWrite( MOTOR_B_DIR, LOW );
 digitalWrite( MOTOR_B_PWM, LOW );
 delay( DIR_DELAY );
 // set the motor speed and direction
 digitalWrite( MOTOR_B_DIR, LOW ); // direction = reverse 
 analogWrite( MOTOR_B_PWM, PWM_FAST ); // PWM speed = fast
 isValidInput = true;
 break;
 
 case '6': // 6) Hard stop (use with caution)
 Serial.println( "Hard stop (brake)..." );
 digitalWrite( MOTOR_B_DIR, HIGH );
 digitalWrite( MOTOR_B_PWM, HIGH );
 isValidInput = true;
 break; 
 
 default:
 // wrong character! display the menu again!
 isValidInput = false;
 break;
 }
 } while( isValidInput == true );

Franzis Lernpaket V8 Motor

 


Franzis V8 – Was für eine Schrauberei

Man sollte etwas Geduld für diesen Bausatz mitbringen.
Belohnt wird man hinterher mit einem funktionstüchtigen Modell, wo neben Kolben- und Ventilfunktion auch die Zündfolge zu sehen ist.

Meine Bauzeit betrug gut 3 Stunden. Wobei ich den Motor nochmal zerlegen durfte, da ich die Kurbelwelle falsch herum eingebaut hatte. Auch sollte man die Nocken nicht gleich aus der Pressform lösen. Die Beschriftung hängt nicht an der Nocke. So musste ich mühsam nach Bild die Nocken sortieren.
Bei den Ventilen fehlte eine Feder, für die sich noch Ersatz in der Bastelkiste fand.

Das Modell sieht auf den ersten Blick sehr komplex aus. Der Aufbau geht aber an Hand der Abbildungen zügig voran. Wenn es um die Ausrichtung von Teilen geht hilft das ausführliche Handbuch. Dieses bietet noch zahlreiche Hintergrundinformationen zum Thema Verbrennungsmotor.

Auf Grund der Komplexität ist er für Kinder allein nicht geeignet. Die Zielgruppen sind eher technikbegeisterte Männer und Jugendliche.

Fazit: Hinterher weiß man mit Sicherheit wie ein Motor aufgebaut ist und funktioniert.