Fortgeschrittenes Autopilot-System für Segelboote – Präzise Automatische Steuerung

Komponenten und Zubehör

Arduino UNO	×	1
Arduino Nano R3	×	1

Projektbeschreibung

Vorwort

Ich segle gern allein, denn wenn ein Mensch mit seinem Segelboot auf dem Meer ist, hat er alles, um auf ein höheres Level zu wachsen. Segeln in rauher See bei schlechtem Wetter ist hart, aber an guten Tagen mit Sonne und Wind ist der Genuss maximal.

Glück bedeutet unendliche Horizonte, perfekte Technik, optimale Entscheidungen – aber auch menschliche Dinge: ein gutes Getränk und ein leckeres Sandwich! Genau hier hilft der Autopilot: Er arbeitet für Sie, während Sie Ihren 17-Uhr-Tee & Kekse auf See genießen. :-)

Was der Autopilot für Sie tut

Ein Segelboot hat keinen Motor und kann keine programmierte Route (Hafen → Strand → Angelplatz → Leuchtturm → zurück) selbst fahren. Nicht möglich.

Die ganze Arbeit macht der Segler: Segel trimmen, Wetter/Wind kontrollieren, Leinen fieren/holen, Verkehr beachten, Kurs entscheiden, steuern... Wenn der Segler Pause macht (10 Sekunden bis Minuten – die berühmte "Tea Time"), schaltet er Autopilot ein. In Sekunden erfasst GPS Position, Geschwindigkeit, Richtung und hält den Kurs (Route). Das Steuersystem (Pinne mit Ruder), sonst von Expertenhänden bewegt, wird nun vom Autopilot über Schrittmotor mit Riemenscheiben und Seilen gesteuert.

Das Ruder steuern ist kontinuierliche Fein- oder Grobjustierung. Je kleiner/leichter das Boot, desto stärker beeinflussen Wellen, Windrichtung/-druck, Gewichtsverlagerung, Strömung den Kurs. Der Segler bleibt wachsam, auch mit Autopilot, und korrigiert Kurs per Fernbedienung: 4 Tasten +1, -1, +10, -10 für kleine/große Gradänderungen. Diese Tasten sind auch am Autopilot: Grün (rechts), Rot (links). Blau (Mitte) = Autopilot aktivieren/deaktivieren (Pause). Schwarz = Parameter im Speicher einstellen.

Die Schaltung

Hauptverarbeitung: MCU Arduino Uno. Zweiter MCU Arduino Nano als Watchdog: Interner Watchdog im Uno existiert, aber ich wollte unabhängigen externen Mikrocontroller – ein Lebenstraum, jetzt erfüllt! Uno muss Nano über Pin 3 → A0 füttern (High/Low, 5/0V), mindestens alle 2,5 Sekunden (feedingInterval); sonst ist Uno "schlafend" oder "blockiert", und Nano setzt Uno zurück. Noch nie passiert – glauben Sie's?

Beliebtes Display mit I2C-Wandler verlötet → nur 4 Drähte, spart digitale Pins. Tasten und Fernbedienung über Spannungsteiler an Analog-Pins → wenige MCU-Ports. 1% Präzisionswiderstände, Analog-Vergleichswerte im Code; bei anderen Widerständen: Konstanten in checkRfRC() und checkHWButtons() anpassen. RF 433MHz Fernbedienung (XD-YK04) funktioniert gut; Spulenantenne aus Kupferdraht selbst gemacht für Reichweite. Getestet 10m, denke 20m+ möglich – genug für 4,20m Testboot.

GPS-Einheit: Zuerst EM406A, aber Week-Rollover-Bug (zu alt). Getauscht gegen Beitian BN-220T. Konfigurationssoftware: 2Hz, nur nötiges $GNRMC NMEA-Satz. GPS sendet (TX) an Pin 0 (RX) von Uno. Daten: Datum, Zeit, Position, True Course, Geschwindigkeit, Satelliten-Fix-Validität. Wichtig: Arduino IDE nutzt Pin 0 (RX) zum Programmieren → GPS während Upload kurz trennen!

Ein weiterer Traum: EEPROM nutzen. IC 24C04 (512 Bytes I2C) für Schrittmotor-Parameter (später unter "Software").

Komponentenliste

• Arduino Uno als MCU
• Arduino Nano als Watchdog
• Beitian BN-220T GPS
• Schrittmotor, Modell 23LM, 54 Schritte = 1/4 Umdrehung
• Controller Keyes L298 für Motor
• RF433MHz RC XD-YK04 + 4-Tasten-Fernbedienung + Spulenantenne
• 6 Taster Normal-Open (2×Rot, 2×Grün, 1×Schwarz, 1×Blau)
• Ein-/Ausschalter (Weiß)
• 6-polige Rundstecker (Buchse/Stecker) für externen Schrittmotor
• Summer (Buzzer)
• LCD1602 2×16 Zeichen + I2C-Wandler
• 3 LEDs (Rot, Blau, Gelb)
• IC 24C04 I2C EEPROM
• IC 4051 Multiplexer
• LiPo Akku 2S 7,4V 2600mAh
• IC 7805 Spannungsregler + Kühlkörper
• Thermistor NTC MF52-103 10k
• Selbstheilende Sicherung 2A
• 6× 1N4148 Dioden (D1-D6)
• Widerstände Power Shield (R1-R4=10k, R5=100k)
• Widerstände Autopilot Shield (R1=330, R2=1k, R3=2k, R4=5,1k, R5=1k, R6/R7/R14=330, R8-R13=10k, R15=10M)
• Kondensatoren (C1=470µF 16V, C2=100nF)
• 2W 0,22 Ohm Widerstand (R6)
• Male Pins, Female Long-Pin Header
• Gehäuse transparent & "wasserdicht"

Einige Sensoren über IC 4051 Multiplexer an Arduino Uno: Thermistor für Spannungsregler-Kühlkörper-Temperatur, 2W Widerstand + 4×10k als Spannungsteiler für Stromverbrauch gesamt. Akku-Spannung überwacht: LiPo kritisch unter 3,3V/Zelle; hier 2S-Pack, bei <7,0V warnt Summer mit schnellen kurzen Piepsen. Nicht zu lange warten – ausschalten & laden! LEDs: Gelb blinkt 1Hz = Watchdog läuft; Blau an = Autopilot aktiv, aus = Pause; Rot blinkt bei Fernbedienung-Tastendruck.

Gesamte Schaltung bei 5,0V aus LiPo 2S 7,4V 2600mAh + IC 7805. Strom <800mA, typisch 100-450mA. Kühlkörper auf 7805! Thermistor darauf, Summer piept bei >50°C.

PCB Layout & Aufbau

Einseitige PCBs → wenige Drahtbrücken (gepunktete Linien) für Routing. Bauteilseite gezeigt, unten alle Dateien (Bauteil-/Lötseite, gespiegelt) zum Download & Druck per Laserdrucker auf "gelbe" oder "blaue" Folien. Gelbe genutzt, blaue sollen besser sein (teurer). Drucken: Toner-Sparen aus, 1200 dpi für tiefes Schwarz. Tonertransfer per Bügeleisen. Beidseitiger Druck (auch Bauteilseite) erleichtert Bestückung & wirkt "professionell".

Beide PCBs passen gestapelt auf Arduino Uno: unten Power-Unit, oben Autopilot-Unit.

Alles zusammengefasst: PCBs, MCUs, RC, Motortreiber, Akku, GPS, Tasten, Schalter, Kabel, Stecker. Nicht verlötet, sondern Header & Dupont-Kabel für Wiederverwendbarkeit. ~200 ungelötete Verbindungen → gelegentliche Fehlfunktionen normal. Empfehlung: Alles verlöten für stabilere Schaltung!

Parameter-Setup & Sensoranzeige

Schwarze Taste an Gehäuseseite → Setup-Modus; auch während aktiver Navigation, Pause nicht nötig. 1. Display-Seite: Akku-Spannung (V=7,83), Stromverbrauch (mA=177), Thermistor-Temperatur (38°C). Schwarze Taste wiederholt → nächste Seiten. Seiten 2-5: Parameter ändern per -1/+1 Tasten. Seite 6: "Updating..." bei Änderungen → Werte im EEPROM gespeichert.

• Intervall: z.B. 2000 ms, Zeit zwischen Schrittmotor-Korrekturen um Heading "H" auf Route "R" zu bringen (Ruder rechts/links)
• Minimum: z.B. 2°, minimale Abweichung für Autopilot-Eingriff; bis dahin Ruder mittig
• Max: z.B. 40°, maximaler Lenkwinkel pro Schrittmotor-Schritt; Berechnung 50° → nur 40° ausgeführt
• Koeff.: z.B. 1,50 × °, Koeffizient für Lenkwinkel; Berechnung 40° → Motor bewegt (40 × 1,50) = 60°

Parameter nötig für Feintuning auf dem Boot. Ansprechverhalten, Empfindlichkeit, Sanftheit hängen ab von: Riemenscheiben-Durchmesser, Anzahl, Hauptscheiben-Durchmesser am Motor, Ruderempfindlichkeit, Ruderpinne-Länge, etc. Alles einbauen, an sonnigem Tag mit leichtem Wind testen!

Live-Betrieb

Sie navigieren auf See/See/Hafen. Tea Time, Cola & Sandwich in der Tasche. Autopilot einschalten, GPS-Fix abwarten. Display zeigt: Geschwindigkeit in Knoten, Uhrzeit, Kurs z.B. H270° (R=Route, H=Heading) in Grad (180°=Süd, 270°=West, 360/0°=Nord, 90°=Ost). R und H identisch im Pause-Modus (STOP angezeigt). Steuerseil (Schrittmotor → Ruderpinne) verbinden, blaue Taste drücken → Autopilot steuert; hält R-Richtung, überwacht H. Heading ändert sich, langsam/schnell je Wetter. Autopilot korrigiert z.B. -10°, +5°... bis H = R. Kursänderung per Rot/Grün Tasten am Gerät (-1/-10/+1/+10) oder Fernbedienung. Manuelle Steuerung zurückgewinnen: Blaue Pause-Taste drücken, Seil vom Ruder lösen, selbst steuern. Fertig.

Software-Seite

Code lang, aber hoffentlich verständlich. Erklärung: Sketch nutzt ~65% Programmspeicher, ~45% RAM. Trotz String-Klasse (mostly Serial NMEA-Manipulation) stabiler Ablauf; nutzt serialEvent() für GPS-Daten 2×/Sekunde, ruft nmeaExtractData(), prüft mit nmea0183_checksum() Datenintegrität. Andere GPS-Modelle: Satzstruktur prüfen, ggf. anpassen. Beispiel: EM406A nutzt $GPRMC, BT220 $GNRMC – nur Namensänderung. NMEA-Checksum-Test: https://nmeachecksum.eqth.net. Beispiel vollständiger NMEA-Satz:

$GPRMC,095836.000,A,4551.9676,N,01328.7118,E,2.09,341.84,280519,,*08

In setup() EEPROM prüfen: neu/unbekannt → initialisieren (formatieren). Parameter als Bytes: 0=0x29, 1=0x00, 2-3=Intervall, 4-5=Min, 6-7=Max, 8-11=Koeffizient (Byte, Byte, Int, Int, Float). EEPROM R/W defensiv programmiert. Sensoren alle 10 Sekunden via readMuxSensors() durch Multiplexer – Alarm bei niedrigem Akku/hoher Temperatur. Stromverbrauch-Auflösung gering (~40mA Schritte). Hardware & RC-Tasten kontinuierlich geprüft; Aktion abhängig von IsSetup Boolean wie RefreshDisplay(). Kern: STEERING CONTROL Sektion ruft gomotor() für Schrittmotor vor/zurück; bewegt Ruder z.B. 10° rechts, nach Intervall zurück auf Null, neuer Berechnungszyklus. Steering auch während Setup aktiv (beeinflusst nur wenige Tasten/Display). Watchdog-Fütterung simpel aber wichtig: Pin so oft wie möglich togglen.

Installation auf Segelboot

Wie Bild: Autopilot & Schrittmotor achtern, beide fest verschraubt. 6mm Seil von Motor-Hauptscheibe um zwei weitere Scheiben an Backbord/Steuerbord. Diese Scheiben über Bungee-Ringe am Boot fixiert → Seil leicht gespannt. Schließlich: Seil an Ruderpinne verbinden (temporär); nur bei aktivem Autopilot verbunden, einfach an/abkupplbar. Autopilot-System trocken halten! :-)

News & Updates

• 10.05.2020: .STEP 3D-CAD-Dateien für Schrittmotor-Scheibe (von mir) und Montageplatte (von Andrew Barney) + 3D-Vorschau zum Download.

Disclaimer & Warnungen

Betrachten Sie dies als Spiel, nichts Ernstes! Vor Jahren 16 Monate Weltumsegelung mit echtem Autopilot (NICHT DIESER!) in allen Bedingungen, auch Schlechtwetter. Echter Autopilot: extrem robust hard- & softwaremäßig, dem man vertrauen muss. Dieser Arduino-Autopilot ist ein fantastisches Spielprojekt zum Spaß & Zeitvertreib.

Viel Spaß!

Marco Zonca

Code

• Autopilot Sketch (für Uno)
• WatchDog Sketch (für Nano)

Autopilot Sketch (für Uno) Arduino

/* Autopilot für kleine Segelboote, Marco Zonca 2019
 * Arduino UNO CPU, Arduino Nano Watchdog, GPS BT-220 NMEA,
 * Schrittmotor + Treiber, RF433MHz RC, 6 Tasten, Summer,
 * I2C Display, 2 LEDs, I2C 24C04 EEPROM, Mux 4051 Sensoren,
 * LiPo 2S 7,4V 2600mAh, 7805 Regler, Thermistor
 */
#include <LiquidCrystal_I2C.h>
#include <NewTone.h>
#include <Stepper.h>
#include <Wire.h>

String inputString = "";
String nm_time = "00:00:00";
String nm_validity = "V";
String nm_latitude = "ddmm.mmmm'N";
String nm_longitude = "dddmm.mmmm'E";
String nm_knots = "0.0kn";
float nmf_knots = 0.0;
String nm_truecourse = "360";
float nmf_truecourse = 360;
String nm_date = "dd/mm/yyyy";
String nm_routetofollow = "000";
float nmf_routetofollow = 0;

unsigned long previousStearingMillis = 0;
unsigned long currentStearingMillis = 0;
unsigned long prevCheckSensorsMillis = 0;
unsigned long currCheckSensorsMillis = 0;
int CheckSensorsInterval = 10000;

bool stringComplete = false;
bool isfirstfix = true;
bool ispause = true;
bool isStearing = false;
bool isSetup = false;

int s=0, y=0, z=0, d=0;
int rfRemoteControlValue = 0;
int HWButtonValue = 0;
int SetupParameter = 0;
float calcmove = 0, cm = 0, Stearing = 0, prevStearing = 0, t = 0;

int EEdisk = 0x50;
int EEid1 = 0x29;
int EEid2 = 0x00;
unsigned int EEaddress = 0;
unsigned int EEbytes = 12;
byte EEdata[12];
byte EEbytedata;
int EEerr = 0;

float SensorVBatt=0, SensorVRes=0, SensorTemp=0, SensormAmp=0;

// EEPROM Parameter (Defaults, werden gelesen/geschrieben)
// Adresse 0-255 bei 0x50, 256-512 bei 0x51 (ungenutzt)
// 0: 1B byte 0x29 (Projekt-ID1)
// 1: 1B byte 0x00 (Projekt-ID2)
int StearingInterval = 2000;      // ms, 2-5000 Schritt 100
int StearingMinToMove = 2;        // Grad, 0-20 Schritt 1
int StearingMaxMove = 40;         // Grad, 10-45 Schritt 1
float StearingCoeffMove = 1.5;    // Faktor, 0.1-4 Schritt 0.1

byte bStearingInterval[sizeof(int)];
byte bStearingMinToMove[sizeof(int)];
byte bStearingMaxMove[sizeof(int)];
byte bStearingCoeffMove[sizeof(float)];

int prev_StearingInterval=0, prev_StearingMinToMove=0, prev_StearingMaxMove=0;
float prev_StearingCoeffMove=0;

const int ledpausePin = 2;
const int watchDogPin = 3;
const int MuxSelBit0Pin = 7;  // 00=Vin 01=Vbatt 10=Temp
const int MuxSelBit1Pin = 6;
const int motorsABenablePin = 13;
const int MuxIOPin = 14;
const int ButtonsPin = 15;
const int rfRemoteControlPin = 16;
const int speakerPin = 17;

const int RCleftbutton = 201, RCrightbutton = 202, RCleft10button = 203, RCright10button = 204;
const int HWleftbutton = 101, HWrightbutton = 102, HWpausebutton = 103, HWsetupbutton = 104;
const int HWleft10button = 105, HWright10button = 106;

const int motorStepsPerRevolution = 200; // 23LM: 54 Schritte = 1/4 Umdrehung

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
Stepper motor(motorStepsPerRevolution, 9, 10, 11, 12);

void setup() {
  Serial.begin(4800);
  lcd.begin(16,2);
  Wire.begin();
  motor.setSpeed(60);
  inputString.reserve(200);
  pinMode(motorsABenablePin, OUTPUT);
  pinMode(MuxSelBit0Pin, OUTPUT);
  pinMode(MuxSelBit1Pin, OUTPUT);
  digitalWrite(motorsABenablePin, LOW);
  digitalWrite(MuxSelBit0Pin, LOW);
  digitalWrite(MuxSelBit1Pin, LOW);
  pinMode(ledpausePin, OUTPUT);
  pinMode(watchDogPin, OUTPUT);
  digitalWrite(ledpausePin, LOW);
  digitalWrite(watchDogPin, LOW);

  // EEPROM prüfen & formatieren falls neu
  lcd.clear(); lcd.setCursor(0,0); lcd.print("Memory check...");
  lcd.setCursor(0,1);
  for (s = 0; s < EEbytes; s++) {
    EEaddress = s;
    EEbytedata = readEEPROM(EEdisk, EEaddress);
    EEdata[s] = EEbytedata;
  }
  if (EEerr) { lcd.print("E="); lcd.print(EEerr); delay(1000); }
  if ((EEdata[0] != EEid1) || (EEdata[1] != EEid2)) {
    lcd.print(" init!"); goupdateEEPROM();
    if (EEerr) { lcd.print("E="); lcd.print(EEerr); delay(1000); }
  }
  memcpy(bStearingInterval, EEdata+2, sizeof(int));
  memcpy(bStearingMinToMove, EEdata+4, sizeof(int));
  memcpy(bStearingMaxMove, EEdata+6, sizeof(int));
  memcpy(bStearingCoeffMove, EEdata+8, sizeof(float));
  StearingInterval = *((int*)bStearingInterval);
  StearingMinToMove = *((int*)bStearingMinToMove);
  StearingMaxMove = *((int*)bStearingMaxMove);
  StearingCoeffMove = *((float*)bStearingCoeffMove);
  prev_StearingInterval = StearingInterval;
  prev_StearingMinToMove = StearingMinToMove;
  prev_StearingMaxMove = StearingMaxMove;
  prev_StearingCoeffMove = StearingCoeffMove;
  lcd.print(" OK"); delay(1000);
  lcd.clear(); lcd.print("GPS reading..."); delay(1000);
}

void loop() {
  // SENSOR PRÜFUNG alle 10s
  currCheckSensorsMillis = millis();
  if (currCheckSensorsMillis - prevCheckSensorsMillis >= CheckSensorsInterval) {
    readMuxSensors();
    if ((SensorVBatt <= 7.0) || (SensorTemp >= 50)) {
      lcd.clear(); lcd.setCursor(0,0); lcd.print("Alarm sensors! ");
      lcd.setCursor(1,1); lcd.print("V="); lcd.print(SensorVBatt);
      lcd.print(" "); lcd.print(int(SensorTemp)); lcd.write(0xDF); lcd.print("C");
      NewTone(speakerPin,10); delay(1000); noNewTone();
    }
    prevCheckSensorsMillis = currCheckSensorsMillis;
  }

  // STEUERUNG
  currentStearingMillis = millis();
  if (currentStearingMillis - previousStearingMillis >= StearingInterval) {
    if (!isStearing && !ispause) {
      // Korrektur versuchen
      calcmove = nmf_routetofollow - nmf_truecourse;
      if (calcmove < -180) calcmove += 360;
      else if (calcmove > 180) calcmove -= 360;
      if (abs(calcmove) >= StearingMinToMove) {
        if (abs(calcmove) >= StearingMaxMove) {
          cm = (calcmove < 0) ? -StearingMaxMove : StearingMaxMove;
          calcmove = cm;
        }
        Stearing = calcmove * StearingCoeffMove;
        gomotor(int((Stearing * 216) / 360)); // 54 Schritte = 1/4 Umdrehung
        prevStearing = Stearing;
        isStearing = true;
      }
    } else {
      // Zurück auf Nullposition
      if (isStearing) {
        Stearing = -prevStearing;
        gomotor(int((Stearing * 216) / 360));
        Stearing = 0; prevStearing = 0; isStearing = false;
      }
    }
    previousStearingMillis = currentStearingMillis;
  }

  // RF FERNBEDIENUNG
  rfRemoteControlValue = checkRfRC();
  if (rfRemoteControlValue) {
    switch (rfRemoteControlValue) {
      case RCleftbutton: goleft(); break;
      case RCrightbutton: goright(); break;
      case RCleft10button: goleft10(); break;
      case RCright10button: goright10(); break;
    }
  }

  // HARDWARE TASTEN
  HWButtonValue = checkHWButtons();
  if (HWButtonValue) {
    switch (HWButtonValue) {
      case HWleftbutton:  if (!isSetup) goleft(); else setupMinus(); break;
      case HWrightbutton: if (!isSetup) goright(); else setupPlus(); break;
      case HWpausebutton: gopause(); break;
      case HWsetupbutton: gosetup(); break;
      case HWleft10button: goleft10(); break;
      case HWright10button: goright10(); break;
    }
  }

  // GPS NMEA
  if (stringComplete) {
    bool ret = nmeaExtractData();
    inputString = ""; stringComplete = false;
    if (ret) RefreshDisplay();
  }

  // WATCHDOG FÜTTERN
  digitalWrite(watchDogPin, !digitalRead(watchDogPin));
}

// ... (restliche Funktionen: readMuxSensors, nmeaExtractData, setupPlus/Minus, gomotor, 
// RefreshDisplay, serialEvent, nmea0183_checksum, checkRfRC, checkHWButtons, gosetup,
// goupdateEEPROM, goleft, goleft10, goright, goright10, gopause, readEEPROM, writeEEPROM,
// roundZeroDec, roundOneDec, roundTwoDec – im Originalcode vollständig enthalten)

WatchDog Sketch (für Nano) Arduino

/* Watchdog für Client-Kontrolle, Arduino Nano 3.0, Marco Zonca
 * Client muss Watchdog vor feedingInterval füttern, sonst Neustart erzwungen
 */
const int feedingPin = 14;
const int ledPin = 15;
const int restartPin = 16;
const int buzzerPin = 17;
const long ledInterval = 1000;
const long feedingInterval = 2500;
const long timeForClientStart = 16000;

int ledState = LOW;
int previousFeedingState = LOW;
int feedingState = LOW;
unsigned long previousLedMillis = 0;
unsigned long previousFeedingMillis = 0;

void setup() {
  digitalWrite(restartPin, HIGH); // LOW = Client Reset
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(restartPin, OUTPUT);
  pinMode(feedingPin, INPUT);
  delay(timeForClientStart); // Client Startzeit
}

void loop() {
  unsigned long currentMillis = millis();
  
  // LED BLINKEN
  if (currentMillis - previousLedMillis >= ledInterval) {
    previousLedMillis = currentMillis;
    ledState = !ledState;
    digitalWrite(ledPin, ledState);
  }

  // FÜTTERUNG PRÜFEN
  feedingState = digitalRead(feedingPin);
  if (feedingState == HIGH) {
    if (previousFeedingState == LOW) previousFeedingMillis = currentMillis;
    previousFeedingState = HIGH;
  } else {
    previousFeedingState = LOW;
  }

  if (currentMillis - previousFeedingMillis > feedingInterval) {
    // Client schläft → Reset
    ledState = HIGH; digitalWrite(ledPin, ledState);
    tone(buzzerPin, 1500); delay(500);
    digitalWrite(restartPin, LOW); // Client Reset
    tone(buzzerPin, 1500); delay(500);
    digitalWrite(restartPin, HIGH);
    tone(buzzerPin, 1500); delay(timeForClientStart);
    noTone(buzzerPin);
    currentMillis = millis();
    previousFeedingState = LOW;
    previousFeedingMillis = currentMillis;
    previousLedMillis = currentMillis;
  }
}

Custom Parts & Enclosures

23lm-stepper-plate-v2_PlvJaff9Hl.step

23lm-stepper-pulley-56_UhsbaWbiBt.step

Schaltpläne