Gut motorisiert mit Gleichstrommotoren

Inhaltsverzeichnis

Sie bewegen die Welt. Ohne sie wäre weder die heutige Industrie noch Heimautomatisierung denkbar. Sie sind Hoffnungsträger für nachhaltige Mobilität. Es gibt sie für Gleichstrom und Wechselstrom. Die Rede ist von Elektromotoren, dem Thema dieser und der nächsten zwei Folgen.

In dieser Ausgabe geht es um Gleichstrommotoren. Ausgehend von einer eher rudimentären Steuerung, begegnen uns zunächst spezielle Motortreiber-Bausteine, bis wir zuletzt eine Deluxe-Variante auf Basis von Motor-Shields kennenlernen.

Mehr Infos

Was bisher geschah:

• Arduino für Fledermäuse
• Bewegungserkennung durch Infrarot-Strahlung
  
• Anschluss von LCD-Displays über den IIC-Bus
  
• Lauschen mit Sensoren
  
• JavaScript an Arduino: Es werde Licht
  
• Anschluss vieler LEDs an wenige Ausgänge
  
• Do-it-Yourself-Projekt: iXduino – Arduino on a Breadboard
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 3 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 2 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 1 von 3)

Die vorliegende Folge ist umfangreicher als üblich, weil sie neben den elektronischen Grundlagen auch verschiedene Schaltungs-Optionen zur Ansteuerung von Gleichstrommotoren untersucht. Dafür können sich die nachfolgenden Folgen konzentrierter mit Servomotoren und Schrittmotoren beschäftigen. Immerhin bilden Gleichstrommotoren auch die Basis von Servo- und Schrittmotoren.

Wir beginnen mit den physikalischen Grundlagen, die notwendig sind, um das Funktionsprinzip von Elektromotoren zu verstehen.

Elektromagneten

Das Fundament elektromagnetischer Felder haben wir bereits im Physikunterricht kennengelernt. Bewegt sich Strom durch einen Leiter, entsteht ein magnetisches Feld. Wickelt man den Leiter zu einer Spule, entsteht ein konzentriertes, homogeneres Magnetfeld, das sich noch verstärken lässt, wenn das Innere der Spule, der sogenannte Kern, nicht aus Luft sondern aus magnetisierbarem Material wie zum Beispiel Eisen besteht.

Sie können sich vielleicht auch noch an die Recht-Hand-Regel (Dreifingerregel) erinnern, mit der sich die Richtung des erzeugten Magnetfelds aus der Windungsrichtung der Spule und der Stromrichtung ermitteln lässt. Für das Verstehen von Elektromotoren ist des Weiteren wichtig: Ein Magnetfeld hat einen Nordpol und einen Südpol. Zwei Nordpole stoßen sich ebenso ab wie zwei Südpole, während sich Nordpol und Südpol anziehen.

Elektromotoren

Die nachfolgenden Beschreibungen gehen übrigens primär von Gleichstrommotoren aus. Auf Wechselstrommotoren gehe ich aus Platzgründen nicht näher ein.

Der stationäre Teil des Elektromotors ist der Stator, der im allgemeinen aus einem Permanentmagneten besteht. Natürlich könnte der Stator auch ein Elektromagnet sein. Dann lässt sich der Motor besser steuern, hätte allerdings auch einen höheren Stromverbrauch.

Der Rotor als beweglicher Teil ist meistens auf Basis einer Spule (oder mehreren Spulen) aufgebaut und rotiert innerhalb des Stators.

Lässt man Strom durch die Spule des Rotors laufen, entsteht ein Elektromagnet mit Nordpol (blaue Spule) und Südpol. Der Nordpol dieses Elektromagneten wird durch den Nordpol des Permanentmagneten (blau in der Illustration) im Stator abgestoßen und von dessen Südpol (rot dargestellt) angezogen. Dadurch kommt der Rotor in Bewegung, sobald ein Strom anliegt. Diese Rotation wäre allerdings nur von kurzer Dauer. Der Rotor würde halten, sobald sein Nordpol dem Südpol des Permanentmagneten gegenüber liegt.

Hier kommt der Kommutator ins Spiel, der die Stromrichtung im Rotor umkeht, bevor dies passiert. Aus dem Nordpol des Rotors wird dadurch ein Südpol, und das Spiel beginnt von vorn. Wir erhalten eine dauerhafte Rotation.

Die maximale Drehgeschwindigkeit eines Elektromotors hängt von mehreren Faktoren ab, von denen nur die zugeführte Stromstärke von außen beeinflussbar ist.

In der obigen Beschreibung war der Stator außen und der Rotor innen. Es gibt auch Gleichstrommotoren, bei denen der Stator innen und der Rotor außen liegt.

Wer es ganz genau wissen und ausprobieren will: Es gibt im Internet zahlreiche Webseiten, die illustrieren, wie Sie einen Gleichstrommotor selbst bauen können. Eine einfache Variante zeigt die Khan-Academy hier, eine aufwändigere dieses YouTube-Video.

Arduino und Elektromotoren

Allerdings benötigen Gleichstrommotoren wesentlich mehr "Saft" als die rund 20 mA, die ein Arduino liefern kann. Wir müssen den Elektromotor deshalb an eine externe Spannungsquelle anschließen, entweder an ein Netzteil, an eine 9V-Blockbatterie, oder an ein LiPo-Akku. Die großen Stromstärken dürfen dabei nicht zum Arduino-Board gelangen, wollen wir diesem nicht den schnellen Garaus bereiten.

Wie können wir also den Elektromotor trotzdem durch den Arduino steuern? Die Antwort heißt: Durch einen Transistor, zum Beispiel einen n-Kanal MOSFET-Transistor (unipolarer Transistor) wie z.B. RFP30N06LE, IRF510, IRF520. Legen wir an dessen Gate eine Spannung an, können wir dadurch einen Schaltkreis mit höherer Stromstärke kontrollieren. Der Transistor trennt quasi den Stromkreis des Elektromotors von dem des Arduino. Zudem lässt sich die Stromstärke des Motorschaltkreises über die am Gate angelegte Spannung steuern. Je höher die Spannung, die wir vom Arduino aus anlegen, desto durchlässiger die Source-Drain-Verbindung des Transistors und desto schneller dreht sich der Motor.

Damit beide Schaltkreise denselben Bezugspunkt besitzen, verbinden wir GND des Arduino-Stromkreises mit GND des Motor-Stromkreises.

Wir können alternativ auch einen NPN-Transistor wie den TIP220 verwenden. MOSFETs wie die oben genannten halten höhere Spannungen und Stromstärken aus, lassen sich aber auch leichter ins e-Nirwana befördern.

Da sich im Rotor des Gleichstrommotors Spulen befinden, müssen wir uns auch um den Aspekt Induktion kümmern, die stets der Änderung entgegenwirkt. Die Diode (Typ 1N4001) eröffnet der Spule einen Weg, sich zu entladen. Andernfalls entstünde bei plötzlichem Stopp der Stromzufuhr eine unkontrollierte Spannungsspitze, die den MOSFET-Transistor zerstören würde.

Für Experimentierfreudige: Wir können das Funktionsprinzip des Elektromotors umkehren, indem wir den Rotor mit der Hand drehen, wodurch ein Stromgenerator entsteht. Sie können das ruhig einmal mit dem Multimeter testen.

Schaltung

Wir bauen die Schaltung wie oben illustriert auf. Um die Spannung am Gate des Transistors zu variieren, benutzen wir einen Digitalausgang des Arduino mit vorangestelltem Symbol ~, den wir mit dem Transistor-Gate verbinden. In der obigen Schaltung ist das der digitale Ausgang 9.

Hierbei handelt es sich um einen PWM-Port (PWM = Pulse-Width-Modulation) des Arduino, bei dem sich die durchschnittliche Stärke des ausgegebenen Signals variieren lässt. Dazu ist ein Wert zwischen 0 und 255 zu wählen. Bei 0 liegt immer LOW-Signal an, was insgesamt ein 0V-Ausgangssignal ergibt. Bei 255 liegt die gesamte Zeit über HIGH an, so dass sich insgesamt ein 5V-Signal ergibt. Reduzieren wir den Wert auf n, liegt die mittlere Spannung bei 5 * n / 255 V. Beispielsweise beträgt das Signal bei n = 128 im Mittelwert rund 2.5V. Wir können dadurch das Gate des Transistors von undurchlässig (n = 0) bis vollkommen durchlässig (n = 255) variieren.

Um einen Wert für n zu erhalten, kommt am Analogeingang A0 ein Potentiometer zum Einsatz. Durch Drehen des Potentiometerknopfes verändert sich dessen Widerstand. Der zurückgelieferte 10-Bit-Wert liegt zwischen 0 und 1023. Diesen Wert bilden wir über die map()-Funktion auf 0..255 ab und verwenden das Ergebnis als Basis für das PWM-Signal.

Durch Drehen am Poti lässt sich also die Motorgeschwindigkeit verändern.

Simpler Sketch

Im Vergleich zur Schaltung ist der Sketch trivial.

/*
 * Beispiel Motorsteuerung
 * am Analog-Pin A0: Potentiometer
 * am Digital-Pin 9, genutzt mit PWM: Gate des NRF120
 */

const int motorPin =  9; // Steuerung Motor über NRF120 Gate
int val = 0; // enthält später Wert des Poti
int speed = 0; // enthält Motorgeschwindigkeit

void setup() {
  pinMode(motorPin, OUTPUT); // Gate des NRF120 MOSFET
}

void loop() {
    val = analogRead(0);           // Wert am Poti: 0..1023 
    speed = map(val,0,1023,0,255); // 0 <= speed <= 255
    analogWrite(motorPin, speed);  // Motor über Gate steuern
}

Schaltung optimieren durch Half-Bridge

Die Drehrichtung des Rotors hängt bei bidirektionalen Motoren von der Richtung des Stroms ab.

Randnotiz: es gibt auch unidirektionale Gleichstrommotoren, die immer in die gleiche Richtung laufen.

Beim Umkehren der Stromrichtung dreht sich folglich auch die Drehrichtung um. Falls eine Fernsteuerung der Bewegungsrichtung über den Arduino möglich sein soll, müssen wir uns dafür schaltungstechnisch etwas einfallen lassen.

Folgender Aufbau auf Basis von Schaltern würde das Umschalten der Drehrichtung erlauben, wobei wir die Schalter durch Relais oder besser durch Transistoren realisieren könnten. Diese Schaltung realisiert eine sogenannte Half-Bridge oder kurz H-Bridge. Je nach Schalterstellung (linkes Bild gegenüber rechtem Bild) fließt der Strom in die eine oder andere Richtung und der Motor bewegt sich dementsprechend im Uhrzeigersinn oder entgegengesetzt zum Uhrzeigersinn.

Weitere Randnotiz: es wäre auch möglich, einen speziellen DPDT-Schalter einzusetzen (Double Pole Double Throw).

Das alles ist aufwändig und macht noch weniger Spaß, wenn wir mehrere Motoren steuern wollen, ein in der Praxis eher häufiges Szenario.

Zum Glück gibt es H-Bridges als fertige ICs. Bausteine des Typs SN754410 (enthält vier H-Bridges) und vor allem des Typs L293D sind eine sehr gute Wahl.

IC L293D

Am häufigsten finden Sie in freier Wildbahn den L293D. Diesen setzen wir auch für unsere modifizierte Schaltung ein.

Erläuterung

Anmerkung 1: Die Zählung der Pins beginnt wie immer links vom Kopf des IC, der mit einer sichtbaren Markierung gekennzeichnet ist. Dort liegt Pin 1. Die weiteren Pins sind relativ dazu im Gegenuhrzeigersinn angeordnet beziehungsweise nummeriert.

Anmerkung 2: Die Schaltung verwendet nur einen Motor, der an Kanal 1 des IC liegt. Theoretisch könnten Sie an Kanal 2 einen weiteren Motor betreiben. Wenn also in der der nachfolgenden Liste von Motor die Rede ist, bezieht sich dies auf Motor 1 bzw. Kanal 1.

Doch kommen wir zum Betrieb des Motors am L293D. Details wie den Anschluss des Potentiometers oder des Tasters entnehmen Sie bitte der obigen Schaltung.

• Pin 1 des Bausteins L293D verbinden wir mit dem PWM-fähigen Digital Pin 9 des Arduino (weiße Steckbrücke). Hier lässt sich die Geschwindigkeit des Motors regulieren, und zwar zwischen 0 (=> Bremsen) und 5V (=> Maximalgeschwindigkeit).
• Pin 2 des Bausteins verbinden wir mit Digital-Pin 3 des Arduino (grüne Steckbrücke). Das ist der sogenannte Input-Pin 1. Pin 7 ist Input-Pin 2, den wir mit Digital-Pin 2 des Arduino verbinden (violette Steckbrücke). Das Tupel (Input-Pin1, Input-Pin 2) legt die Drehungsrichtung fest.
• Bei (LOW, HIGH) dreht sich der Motor in eine Richtung
• Bei (HIGH, LOW) dreht sich der Motor in die entgegengesetzte Richtung
• Bei (LOW, LOW) oder (HIGH, HIGH) herrscht Leerlauf
• Pin 3 des Bausteins verbinden wir mit GND des Motors (blaue Steckbrücke vom Motor zum L293D)
• Pin 6 verbinden wir mit dem positiven Eingang des Motors. Pin 3 und 6 sind die Ausgangs-Pins zur Stromversorgung des Motors
• Pin 4 und Pin 5 verbinden wir mit GND (blaue Verbindungen)
• Pin 8 verbinden wir mit der Versorgungsspannung der externen Quelle, in unserem Fall mit der 9V-Blockbatterie.
• Pin 16 verbinden wir mit der vom Arduino bereitgestellten Versorgungsspannung

Achtung: Ein L293D hat Beschränkungen, was die angeschlossenen Motoren betrifft. Die übliche Stromstärke pro Motor (bzw. Kanal) sollte bei maximal 0.6A liegen, wobei der Baustein auch kurzfristige Peaks mit 1.2A verkraftet (100 Mikrosekunden). Die Eingangsspannung kann bis zu 36V betragen. Zudem besitzt der Chip eine Sicherung gegen überhöhte Temperatur. Damit lassen sich Hobbymotoren (Gleichstrom-, Servo-, Schrittmotoren) betreiben, wie sie üblicherweise in der Robotik und im Modellbau vorkommen. Für industrielle Motoren bräuchte unser Motortreiber ganz andere Leistungsdaten.

Programmbeispiel

Weiter unten sehen Sie ein Beispiel für die Programmierung der obigen Schaltung. Das Potentiometer dient wieder zum Festlegen der Geschwindigkeit.

Zudem hab ich an Digital-Pin 4 des Arduino einen simplen Taster angeschlossen. Je nachdem, ob der Schalter offen oder geschlossen ist, dreht sich der Motor entweder in die eine oder in die dazu entgegengesetzte Richtung. Normalerweise würde man dafür natürlich keinen Taster verwenden, sondern einen Kippschalter. Sollten Sie also einen Kippschalter übrig haben, nehmen sie besser diesen.

Zudem fällt Ihnen sicher auf, dass kein Widerstand im Schaltkreis des Tasters vorkommt. Sobald Sie den digitalen Eingang bei betätigtem Taster auslesen, erhalten Sie Messwerte, die zwischen LOW und HIGH schwanken, weil Leckströme oder elektromagnetische Einflüsse für Störungen sorgen. Ein Pull-up-Widerstand sorgt dafür, dass diese Fluktuationen unterbleiben. Zum Glück können wir uns einen extra dafür verwendeten Widerstand sparen. Die Eingänge des Arduino Uno besitzen integrierte Pull-up-Widerstände, die eine Entwicklerin mittels der Funktion

           pinMode(pinNummer, INPUT_PULLUP)

einschalten kann.

Und hier kommt endlich der eigentliche Sketch, der die Ansteuerung des Motors über den L293D anhand der ausgelesenen Werte von Potentiometer und Taster vornimmt. Verstellen des Potentiometers ändert die Motorgeschwindigkeit, den Taster gedrückt halten, kehrt die Drehrichtung um.

/* 
*  Steuerung eines Motors mit der Half-Bridge des L293D ICs
*/
const int controlPin1   = 2;     // Verbunden mit Pin 7 L293D 
const int controlPin2   = 3;     // Verbunden mit Pin 2 L293D  
const int motorSpeedPin = 9;     // Verbinden mit Pin 1 L293D
const int directionPin  = 4;     // Taster für Drehrichtung
const int potiPin = A0;          // Poti zum Regel einer  Geschwindigkeit

/*
* In setup() spezifizieren wir Pins, die am L293D
* oder am Poti
* oder am Taster 
* anliegen
*/

void setup() {
  pinMode(directionPin, INPUT_PULLUP); // Wichtig: Pull Up Widerstand 
  pinMode(controlPin1, OUTPUT); 
  pinMode(controlPin2, OUTPUT);
  pinMode(motorSpeedPin, OUTPUT);

  // Erst mal auf die Bremse
  digitalWrite(motorSpeedPin, LOW);
}

/*
* In loop() lesen wir den Poti aus
* konvertieren den Wert nach 0..255 als Motorgeschwindigkeit
* regeln die Motorgeschwindigkeit entsprechend
* und steuern die Drehrechnung abhängig von der Tasterstellung
*/

void loop() {
  // Einlesen den Potiwerts => Geschwindigkeitswert
  int motorSpeed = map(analogRead(potiPin), 0, 1023, 0, 255);
  analogWrite(motorSpeedPin, motorSpeed);

  // Schalter offen => Drehrichtung
  if (digitalRead(directionPin) == HIGH) {
    digitalWrite(controlPin1, HIGH);
    digitalWrite(controlPin2, LOW);
  } 

  // sonst in entgegengesetzter Richtung
  else {
    digitalWrite(controlPin1, LOW);    
    digitalWrite(controlPin2, HIGH);  
  }
}

IC SN754410

Auch der SN754410 besteht intern aus zahlreichen Transistoren und übernimmt daher auch die Rolle des MOSFET-Transistors in unserer ursprünglichen Schaltung, inklusive PWM-Steuerung versteht sich. Schutzdioden sind ebenfalls mit an Bord. Daher firmiert der IC wie sein Cousin L293D unter dem Begriff Motortreiber. Würden wir diese Funktionalität auf einem Breadboard selbst zusammensetzen, ergäbe sich neben großem Arbeitsaufwand auch ein großer Platzaufwand.

Motor-Shield

Noch bequemer ist ein Motor-Shield, das wir huckepack auf unseren Arduino Uno oder Mega aufsetzen können. Es gibt eine ganze Menge Motor-Shields für Arduino Uno und Mega. Wer auf johnny-five.io die API durchforstet und zu Motor navigiert, erkennt dies schnell. Hier ist der Anschluss mehrerer bidirektionaler Gleichstrommotoren, Hobby-Servos oder (unipolarer und bipolarer) Schrittmotoren vorgesehen. Entsprechende Shields finden sich bereits für 4-7 Euro auf ebay. Ein Motor-Shield gehört also nicht zum Luxuszubehör, und ist für Projekte mit mehreren Motoren alternativlos. Als Beispiele habe ich zwei verbreitete Shields herausgepickt. Auf dem Bild ist oben das originale Arduino-Motor-Shields zu sehen.

Auf ebay sind die am häufigsten angebotenen Motor-Shields Nachbauten eines Shields von Adafruit. Es handelt sich in der Abbildung unten um die erste Version des Shields. Inzwischen bietet Adafruit eine zweite Version an, von denen es aber noch keine oder allenfalls sehr wenige Nachbauten gibt, weshalb ich die erste Version im Original und als Nachbau nutze. Finanzieller Aufwand bei letzterem: 4 Euro.

Sie sehen auf der Adafruit-Platine links und rechts die bekannten L293D-Bausteine, die je 4 Half-Bridges enthalten. In der Mitte befindet sich das Shiftregister, das wir bereits früher zur LED-Ansteuerung verwendet haben, ein 8-Bit-Shiftregister des Typs 74HC595. Sie fragen sich jetzt vielleicht, wozu ein Motor-Shield ein Shiftregister braucht. Wie bei seinem Einsatz zur Ansteuerung mehrerer LEDs, dient der IC auch im vorliegenden Fall zum Einsparen von Pins. Das Motor-Shield unterstützt bis zu vier Motoren. Ein L293D erfordert pro Gleichstrommotor drei Arduino-Pins zur Steuerung, einen für die Geschwindigkeitsregulierung und zwei für die Drehrichtung. Macht also insgesamt 12 Pins. Am Motor-Shield gibt es allerdings pro Gleichstrommotor jeweils zwei Anschlüsse, sodass wir auf insgesamt acht Anschlüsse für vier Motoren kommen. Wo sind die fehlenden vier? Das Geheimnis dahinter: für jeden Motor benötigen wir nur einen Pin zur Festlegung der Drehrichtung. Einen daran angelegten Wert übersetzt das Shield mittels Shiftregister wieder in die benötigten (Control-Pin1, Control-Pin2)-Tupel, die wir bereits kennengelernt haben.

Wichtiger Hinweis!!!

Sie können den Arduino direkt an ein Netzteil anschließen und das Motor-Shield mit Energie des Arduino versorgen. Wenn allerdings Arduino und Motor-Shield von separaten Spannungsquellen gespeist werden, sollten Sie unbedingt den Jumper (Aufschrift z.B. EXT/PWR) auf dem Motor-Shield entfernen, um Schäden an Shield oder Arduino-Board zu vermeiden.

Auf Potentiometer und Taster habe ich in der Schaltung bewusst verzichtet, sondern setze die Funktionalitäten wie Umkehren der Drehrichtung rein programmatisch um.

Sketch für das Adafruit Motor-Shield

Sie haben es sicher nicht anders erwartet. Auch für das Programmieren des Motors auf dem Adafruit-Shield gibt es eine Bibliothek, deren Download hier über Github erfolgt.

Es ist auf dem ersten Blick zu erkennen, dass die Programmierung damit wesentlich leichter fällt, von dem geringeren Aufwand für die Schaltung ganz zu schweigen. Das Programm bildet ein Pendant zum berüchtigten Blinken einer LED, nur dass statt Blinken einer LED ständig die Drehrichtung des Motors umgedreht wird.

#include <AFMotor.h> 
// Motor 1 mit 64 KHz Signalfrequenz für PWM
AF_DCMotor motor(1, MOTOR12_64KHZ); 

void setup() {
    motor.setSpeed(255);     // Volle Kraft
} 

void loop() {
    motor.run(FORWARD);      // 2 Sekunden in eine Richtung
    delay(2000);
    motor.run(BACKWARD);     // 2 Sekunden in die andere Richtung
    delay(2000);
    motor.run(RELEASE);      // stopped
    delay(1000);
}

Adafruit/ladyada Motor Shield v2.x

Das verwendete Motor-Shield ist, wie eingangs erwähnt, in einer verbesserten Version 2.x verfügbar. Die Kosten schlagen mit über 20 Euro zu Buche, erste Nachbauten gibt es ab 6 Euro bei chinesischen Händlern. Auf dem Board befinden sich Half-Bridges des Typs TB6612, die statt 0.6A wie beim L293D sogar 1.2A vertragen. Bis zu 20 Millisekunden lang dürfen auch mal Spannungsspitzen von maximal 3A anliegen.

JavaScript mit Node.js und johnny-five

Auch mit JavaScript lässt sich der Motor problemlos fernsteuern. Dazu laden wir wie üblich den Sketch StandardFirmata auf unser Arduino-Board. Dann ist das Arduino-Board empfangsbereit für die Befehle aus der JavaScript-Welt.

Unser JavaScript-Programm startet den Motor (Anschluss am M1-Eingang des Shields) mit voller Geschwindigkeit und dreht sich danach in die Gegenrichtung. Im Programm setze ich ein Adafruit Motor-Shield (Version 1) oder einen Nachbau voraus. Auf johnny-five finden Sie genügend Information zur Motor-API und den unterstützten Bausteinen/Shields.

// j5-motortest.js
var five = require("johnny-five"), board = new five.Board();
var configs = five.Motor.SHIELD_CONFIGS.ADAFRUIT_V1;

board.on("ready", function() {
  var motor1 = new five.Motor(configs.M1);
  motor1.start(255);
  setTimeout(function(){ motor1.reverse(255);},2000);
});

Starten Sie das Skript wie üblich im Terminal oder der Konsole mit:

       node j5-motortest.js

Und variieren Sie den recht einfachen Sketch ruhig ein wenig. Wie heißt es doch so schön: Pimp up my sketch!

Fazit

In dieser Folge habe ich die Grundlagen zu Elektromotoren adressiert, und bin näher auf bidirektionale Gleichstrommotoren eingegangen. Mögliche Projekte mit diesen Motoren gibt es sehr viele, beispielsweise:

• Bau eines Kühlers bzw. Ventilators mit temperaturabhängiger Drehgeschwindigkeit
• Motorsteuerung für Jalousien, optional mit Helligkeitssensor gekoppelt
• Autotuningsystem für Gitarren und Bässe
• Robotikanwendungen (z.B. mobile Roboter)
• Mechatronik
• Spielzeug
• ...

In der nächsten Folge wollen wir uns mit Servomotoren beschäftigen. ()