Wie baut man einen professionellen Motorfader (mit Touch-Sense)?

Hast du schon mal diese High-End-Mischpulte in Tonstudios gesehen, bei denen sich die Regler wie von Geisterhand bewegen? Das nennt man „Flying Faders“ oder Motorfader. Sie sind perfekt, um gespeicherte Einstellungen (Presets) abzurufen, ohne den Überblick zu verlieren.

Der Clou an der Sache: Ein guter Motorfader muss wissen, wann du ihn anfasst. Er muss sofort stoppen, damit du gegen den Motor nicht „ankämpfen“ musst. In diesem Tutorial bauen wir genau so ein System – mit Berührungserkennung und sanfter Motorsteuerung.

1. Die Einkaufsliste

Für ein professionelles Ergebnis brauchen wir Komponenten, die Kraft haben und präzise sind. Spielzeugmotoren reichen hier nicht.

• Arduino Uno (oder Nano/Mega)
• Motorfader mit Touch-Bahn: Der Industriestandard ist hier der ALPS RSA0N11M9 (10k linear, 100mm Weg). Er hat eine extra Leiterbahn, die mit dem Metallknopf verbunden ist – essenziell für die Berührungserkennung!
• Motortreiber: Wir nutzen den TB6612FNG. Er ist effizienter und präziser als alte L298N-Treiber und wird nicht so heiß.
• Netzteil: 9V bis 12V DC (mind. 1A). Wichtig: Der USB-Strom des Arduino reicht nicht für schnelle Bewegungen!
• Widerstand: 1x 1 Megaohm (für den Touch-Sensor).
• Kabel & Breadboard

2. Die Theorie: Wie funktioniert das?

Das System besteht aus drei Logik-Ebenen:

1. Positionserkennung: Das Potentiometer im Fader sagt dem Arduino, wo der Regler steht (0-1023).
2. Touch-Sense (Kapazitive Messung): Über den leitenden Faderknopf misst der Arduino die Kapazität deines Fingers. Berührst du den Knopf, stoppt der Motor sofort (Override).
3. Soft-Control (P-Regler): Wir fahren nicht stur „Vollgas“. Je näher der Fader dem Ziel kommt, desto langsamer wird der Motor. Das verhindert Ruckeln und Überschwingen.

3. Der Schaltplan

Wir müssen zwei Stromkreise beachten: 5V für die Logik und 9V-12V für den Motor.

Achtung: Verbinde unbedingt GND vom Arduino mit GND vom Netzteil!

A. Den Motortreiber (TB6612FNG) anschließen

• VM (Motor Voltage): An das Pluspol deines 9V/12V Netzteils.
• VCC (Logic Voltage): An Arduino 5V.
• GND: An Arduino GND (und Netzteil Minus).
• PWMA: An Arduino Pin 3 (muss PWM-fähig sein).
• AIN1: An Arduino Pin 4.
• AIN2: An Arduino Pin 5.
• STBY: An Arduino 5V (aktiviert den Treiber).

B. Den ALPS Fader anschließen

Der Fader hat zwei Seiten. Eine für den Motor/Touch (meist 6 Pins, oft 2 davon Dummy) und eine für das Poti (3 Pins).

• Motor-Pins: Die beiden Motoranschlüsse gehen an AO1 und AO2 des Treibers.
• Poti-Pins:
  • Oben: 5V
  • Unten: GND
  • Mitte (Schleifer): An Arduino Analog A0.
• Touch-Pin: Das ist der Pin, der elektrisch mit dem Metallgehäuse/Hebel verbunden ist. Dieser geht an Arduino Pin 9.

C. Die Touch-Schaltung

Verbinde einen 1 Megaohm Widerstand zwischen Arduino Pin 8 und Pin 9.

• Pin 8 ist der Sender.
• Pin 9 ist der Empfänger (und geht, wie oben erwähnt, an den Fader-Touch-Pin).

4. Der Code

Du benötigst die Bibliothek CapacitiveSensor. Installiere sie über den Bibliotheksverwalter in der Arduino IDE.

Der Code nutzt einen einfachen „Proportional-Regler“. Das heißt: Großer Abstand zum Ziel = schnell fahren. Kleiner Abstand = langsam fahren.

C++

#include <CapacitiveSensor.h>

// --- Pin Konfiguration ---
const int faderPotiPin = A0;  // Analog Input vom Fader
const int motorPWM = 3;       // Geschwindigkeit
const int motorIn1 = 4;       // Richtung A
const int motorIn2 = 5;       // Richtung B

// Touch Sensor Setup:
// 1M Ohm Widerstand zwischen Pin 8 (Send) und Pin 9 (Receive/Sensor)
CapacitiveSensor touchSensor = CapacitiveSensor(8, 9); 

// --- Einstellungen ---
int targetPosition = -1;      // Aktuelles Ziel (-1 = keins)
int tolerance = 15;           // Wie genau muss er treffen? (Deadzone)
int minSpeed = 60;            // Mindestkraft (0-255), damit der Motor anläuft
int maxSpeed = 255;           // Maximale Geschwindigkeit
long touchThreshold = 1000;   // Ab diesem Wert gilt der Fader als "berührt" (KALIBRIEREN!)

void setup() {
  pinMode(motorPWM, OUTPUT);
  pinMode(motorIn1, OUTPUT);
  pinMode(motorIn2, OUTPUT);
  
  // Touch-Sensor kalibrieren
  touchSensor.set_CS_AutocaL_Millis(0xFFFFFFFF);
  
  Serial.begin(115200);
  Serial.println("Motorfader System gestartet.");
  
  // Demo: Fahre nach 2 Sekunden zur Mitte
  delay(2000);
  goTo(512); 
}

void loop() {
  // 1. Sensoren lesen
  long touchValue = touchSensor.capacitiveSensor(30); 
  int currentPos = analogRead(faderPotiPin);

  // Debugging: Werte im Serial Monitor prüfen!
  // Serial.print("Touch: "); Serial.print(touchValue);
  // Serial.print(" | Pos: "); Serial.println(currentPos);

  // 2. Sicherheits-Check: Wird der Fader angefasst?
  if (touchValue > touchThreshold) {
    stopMotor();       // Sofort aus!
    targetPosition = -1; // Ziel verwerfen, User hat die Kontrolle
    return;            // Loop hier abbrechen
  }

  // 3. Motorsteuerung (P-Regler)
  if (targetPosition != -1) {
    int error = targetPosition - currentPos; // Abstand berechnen

    if (abs(error) > tolerance) {
      // Geschwindigkeit berechnen: Je größer der Fehler, desto schneller
      int speed = map(abs(error), 0, 1023, minSpeed, maxSpeed);
      speed = constrain(speed, minSpeed, maxSpeed);

      // Motor bewegen
      if (error > 0) {
        moveUp(speed);
      } else {
        moveDown(speed);
      }
    } else {
      // Ziel erreicht
      stopMotor();
      targetPosition = -1; 
    }
  }
  
  // Neue Befehle über Serial Monitor empfangen (z.B. "900")
  if (Serial.available() > 0) {
     int newTarget = Serial.parseInt();
     if (newTarget > 0) goTo(newTarget);
  }
}

// --- Hilfsfunktionen ---

void goTo(int pos) {
  targetPosition = pos;
}

void stopMotor() {
  digitalWrite(motorIn1, LOW);
  digitalWrite(motorIn2, LOW);
  analogWrite(motorPWM, 0);
}

void moveUp(int speed) {
  digitalWrite(motorIn1, HIGH);
  digitalWrite(motorIn2, LOW);
  analogWrite(motorPWM, speed);
}

void moveDown(int speed) {
  digitalWrite(motorIn1, LOW);
  digitalWrite(motorIn2, HIGH);
  analogWrite(motorPWM, speed);
}

5. Wichtige Kalibrierung

Bevor alles perfekt läuft, musst du zwei Werte an deine Hardware anpassen:

1. Touch Threshold (touchThreshold):
   • Lade den Code hoch.
   • Öffne den „Serial Monitor“ (Baudrate 115200).
   • Entferne die // vor den Serial.print Zeilen im Loop.
   • Beobachte den „Touch“-Wert: Wie hoch ist er, wenn du den Fader nicht anfasst? (z.B. 50). Wie hoch ist er, wenn du den Finger drauflegst? (z.B. 3000).
   • Setze touchThreshold auf einen Wert genau dazwischen (z.B. 1000).
   • Tipp: Wenn du einen Knopf aus Plastik hast, musst du ihn mit leitfähigem Lack bestreichen oder Alufolie nutzen, sonst klappt es nicht!
2. Minimale Geschwindigkeit (minSpeed):
   • Jeder Motor braucht eine gewisse Mindestspannung, um die Haftreibung zu überwinden. Ist der Wert zu niedrig, summt der Motor nur, bewegt sich aber nicht. Ist er zu hoch, fährt er zu ruppig an. Experimentiere mit Werten zwischen 40 und 80.

Fazit

Mit diesem Setup hast du die Grundlage für dein eigenes DAW-Controller-Deck oder ein smartes Home-Automation-Panel gebaut. Der Motorfader reagiert nun intelligent auf deine Berührung und fährt Ziele sanft an, statt hektisch zu zucken.