Vollständig 3D-gedruckter Panzer: Vielseitige Kettenroboter-Plattform bauen

In diesem Tutorial zeige ich, wie ich ein super cooles ferngesteuertes Kettenfahrzeug – Roboterplattform oder Panzer – gebaut habe. Von Grund auf als vollständig 3D-druckbar designed, damit du alles leicht drucken und selbst bauen kannst.

Video ansehen oder schriftliche Anleitung unten lesen.

Überblick

Ziel: Vielseitige Plattform für verschiedenste Gelände und Anwendungen. Kettenantrieb ideal: Gewicht auf größere Fläche verteilt → hervorragender Grip, geringeres Festfahren in weichem Boden, Schlamm, Schnee.

Fährt gut im Schlamm (Schnee-Test steht aus – zukünftige Videos: Roboterarm oder Turm). Mit Roboterarm: Greifen, Bewegen, Kamera für Inspektion. Oder Nerf-Dart-Turm + coole LED-Beleuchtung → Spielspaß.

Federung: Christie-System (jahrzehntelang in Panzern bewährt). Jedes Laufrad hat eigene Federung (Feder + Stoßdämpfer). Sanftes Überfahren unebenen Geländes, Hindernisüberwindung, guter Ketten-Kontakt.

Steuerung: Günstiger RC-Sender → Empfänger auf Plattform → Mikrocontroller. Gehirn: Atmega2560-Board. Custom PCB für saubere Verkabelung, direkt aufgesteckt.

Los geht’s: Design, 3D-Druck, Montage, Elektronik, Programmierung.

Roboterplattform Design

Design in SOLIDWORKS – Sponsor dieses Videos.

— Gesponserter Abschnitt —

„Industrielle Profi-Designtools jetzt für Maker zu bemerkenswert niedrigem Preis: 99 $/Jahr oder 9,99 $/Monat. 3DEXPERIENCE SOLIDWORKS for Makers – ideal für Lernen, DIY-Projekte.

Enthält: 3DEXPERIENCE SOLIDWORKS Professional (lokal auf PC, Dateien lokal oder Cloud). „xDesign“ – browserbasiertes CAD, mit SOLIDWORKS oder standalone. „xShape“ – browserbasiertes Freiform-CAD für Flächenmodellierung. „Visualize Connected“ – fotorealistische Bilder, Animationen, interaktive Webinhalte. „NC Shop Floor Programmer“ – CAM für 3-Achs-Fräsen/Draht-EDM.

Link unten: 20 % Rabatt – mit den Besten starten! Danke an SOLIDWORKS für Sponsoring und Bildungsförderung.“

Kaufen: https://www.solidworks.com/makers20

Mehr: https://discover.solidworks.com/3dexperience-solidworks-makers

— Zurück zum Thema —

Design-Herleitung: Erste Parameter: RC-Stoßdämpfer (8 Stück → 4 Laufrollen pro Seite), 41 mm ausgefahren, 11 mm Hub. Für größeren Radhub (16 mm vertikal) Mechanismus entwickelt. Näher am Drehpunkt → mehr Hub, aber Federkraftverlust/steifere Feder nötig. SOLIDWORKS-Simulationen für Federkräfte bei verschiedenen Mechanismen → gewählter Kompromiss aus Hub und Kompaktheit.

Vorderes Laufrad: Mit Leitrad (Idler) verbunden für dynamische Kettenspannung. Hebt sich Rad → Kettenumfang verkleinert → Spannung sinkt → Leitrad wird nach vorne gedrückt, spannt Kette. Statische Vorspannung über Schraube + Distanzmutter einstellbar.

Hinteres Antriebsrad (Sprocket): 3 Teile – Wellenkupplung, linker/rechter Sprocket-Teil, 3× M3 verschraubt. Kritisch: Teilung (Pitch) = Ketten-Pitch. 11 mm Pitch, 12 Zähne → Teilkreisdurchmesser ~42 mm.

11 mm Pitch durch Kettenglied-Design definiert: So kompakt wie möglich, Verbindung mit 1 Stift, stark genug für 3D-Druck. Kein Support-Material nötig – Ziel erreicht.

Kettenglied-Verbindung: 2 mm Stifte. Eine Seite 2,0 mm (Presspassung), andere 2,3 mm (Spielpassung für freie Drehung). Sprocket-Zähne greifen in Öffnung wo Stift sitzt (8,8 mm Ø), Sprocket 9,1 mm Ø (Spiel).

Mit definierten Teilen: Skizze im Assembly (geschlossener Kontur um Sprocket, Leitrad, Laufrollen). SOLIDWORKS Chain Component Pattern → alle Kettenglieder entlang Kontur generieren.

Rest der Plattform (Basis, Seiten mit LEDs, Top-Cover) in modernem, coolem Stil. Gesamt ~400×300 mm > typische Druckbetten → alle Teile in zwei Sektionen geteilt (für fast jeden Drucker). Verbindung über Winkel + M3-Schrauben.

Montage: Diverse M3/M4 Schrauben/Muttern, Gewindeeinsätze, Lager. Komplette Liste unten in Montage.

3D-Modell und STL-Download

3D-Modell und STL-Dateien für 3D-Druck auf Cults3D.

3D-Druck

Für dimensionsgenaue Teile: Horizontal Expansion & Hole Horizontal Expansion im Slicer nutzen. Standard → Außenmaße & Löcher zu klein.

Ich: Horizontal Expansion +0,02 mm, Hole Horizontal Expansion +0,04 mm. Testdrucke für optimale Werte auf eigenem Drucker. Genauigkeit wichtig für einfache Montage (Lager, Schrauben).

Kettenglieder: Raft als Haftung (kleine Auflagefläche). Besonders bei Großchargen sicherer.

3D-gedruckter Panzer montieren – Kettenroboter-Plattform

Alle 3D-Teile bereit. Druckzeit: Basis-Sektionen je ~22 h, 156 Kettenglieder ~96 h. Gesamt ~200 h. Zwei Drucker → ~100 h.

Teileliste (Mechanik)

• 8× RC-Stoßdämpfer – Amazon / AliExpress
• 8× Federn – Amazon / AliExpress
• 40× Kugellager 624 (4×13×5 mm) – Amazon / AliExpress
• M3 Gewindeeinsätze – Amazon / AliExpress
• M3/M4 Schrauben & Muttern – Amazon / AliExpress
  Schrauben: M4×40 (8), M4×35 (2), M4×30 (8), M4×25 (2), M3×25 (16), M3×20 (8), M3×16 (10), M3×12/14 (32), M3×10 (8), M3×8 (14)
  Muttern: M4 (25), M3 (30)
  Unterlegscheiben: M4 (30)

Hinweis: Affiliate-Links.

Basis-Montage: Zwei Sektionen, verbunden über Winkel + M3-Schrauben/Muttern. Seitenwinkel: M3 5 mm Gewindeeinsätze in Seitenwand → außen sauber, Ketten laufen vorbei. Stoßdämpfer-Halter mit M3-Schrauben fixieren.

Lager für Laufrad-Arm-Drehpunkt: 13/4 mm, je 2 pro Laufrad. Bolzen: M4×30 mm. Unterlegscheibe zwischen Lager und Arm, innen selbstsichernde Mutter. Nicht zu fest/zu lose anziehen.

Stoßdämpfer einbauen: Mit beiliegender M1,4-Schraube. Kleiner Schraubendreher fehlte → Zange genutzt. Mechanik funktioniert perfekt.

Laufrad unten am Arm: Zweiteilig (Support-vermeidend). Verbindung: 2 mm Stahlstifte (Messing-Schweißdraht – weich, mit Zange schneidbar). 3 Stifte à ~23 mm pro Rad. Wieder dieselben Lager beidseitig, M4-Schraube, Scheibe, selbstsichernde Mutter. Rad frei drehbar, kein Spiel.

Wiederholen für andere Laufrollen. Vorderes Laufrad: Arm mit Hebel für dynamische Kettenspannung, Montage gleich.

Leitrad-Mechanismus: 3 3D-Teile, Schrauben, Distanzmutter. Vor 1. Glied: M4-Kontermutter hinten (später Leitrad). 2 mm Kupferstifte für Gelenke. Am 2. Glied (Leitrad-Seite): M3-Distanzmutter 15 mm mit M3-Schraube. Andere Seite: M3×20 Schraube + Mutter in Distanzmutter. Jetzt Abstand Leitrad–Laufradarm einstellbar → statische & dynamische Kettenspannung. Leitrad mit M4-Schraube fixieren → Spannsystem & Federsystem fertig.

Antriebsrad (Sprocket) montieren: Zuerst Motor einbauen. Basis nimmt 37 mm Motoren (zentral/versetzter Wellenanschluss). Beliebiger 12V DC-Motor 20–1000 U/min (je nach Anwendung). 6× M3 Schrauben.

Sprocket an Motorwelle: Wellenkupplung vorbereiten (Gewindeeinsätze), einsetzen, M3-Madenschraube fixieren. Zwei Sprocket-Hälften einsetzen, 3× M3 verschrauben. Antriebsstrang fertig.

Kette montieren – macht echt Spaß! Kettenglieder: clean, supportfrei aus Drucker. 2 mm Stifte (Messing-Schweißdraht). Außenbohrungen Presspassung (Kraft nötig, sitzt bombenfest). Innenbohrungen Spielpassung (freie Drehung). Tee/Kaffee, paar Stunden genießen. 78 Glieder pro Kette. Stablänge: ~3,5 m pro Kette (Stift ~43 mm).

Kette um Sprocket, Laufrollen, Leitrad legen, Kreis mit Stift schließen. 78 Glieder → Spannung passt, letztes Laufrad hebt leicht an (Feder zu weich). Stoßdämpfer-Mutter nachjustieren half nicht → stärkere Feder. Federwechsel einfach: Ein Ende aufschrauben, stärkere Feder rein, zuschrauben. Meine Feder etwas breiter → M4-Unterlegscheibe unten. Jetzt hält Feder Laufrad bei 78 Gliedern. Alle Stoßdämpfer getauscht (Original zu schwach für Gesamtgewicht). Antriebssystem fertig – sieht gut aus.

Kettenspannung notfalls an Distanzmutter Leitrad nachjustieren. Obere lockere Kette liegt auf Stoßdämpfer-Haltern auf.

Motor an Strom → Testlauf. Perfekt! Tolles Gefühl, so viele 3D-Teile in Aktion zu sehen.

Andere Seite identisch aufbauen. Plattform ~80 % fertig. Seitenpaneele (Optik) anbringen: Winkel + M3-Schrauben. Top-Cover (Optik). Zukünftig: Roboterarm/Turm → Top-Cover neu designen.

Elektronik – Roboterplattform Schaltplan

ATmega2560-Board.

• 2× 12V DC-Motor 50–500 U/min – Amazon / AliExpress
• DRV8871 DC-Motortreiber – Amazon / AliExpress
• Arduino MEGA – Amazon / AliExpress
• 3S LiPo Akku – Amazon / AliExpress
• XT60 Stecker – Amazon / AliExpress
• FLYSKY RC Sender – Amazon / AliExpress

Hinweis: Affiliate-Links.

Zwei DRV8871 für zwei Motoren (PWM, bis 3,6 A Peak). Motoren 12V, 3S LiPo (~12V). LM350 5V-Regler für zukünftige Nutzung (z. B. Servos). Hier: 5V für RC-Empfänger & LEDs.

LEDs: 5 mm weiß/rot. Anordnung: Hinten je 2 rot (Rücklicht), vorne je 3 weiß (Scheinwerfer). Oben 6 LEDs (Fernlicht). Schaltung: Reihen-/Parallelkombination mit Vorwiderständen. Front: 2 parallele Stränge 12V, je 3 LEDs in Reihe → 150 Ω pro Strang. Ansteuerung: NPN-Transistoren (200 mA).

Spannungsteiler für Akku-Monitoring: 12V → <5V → Analogeingang Mikrocontroller. Software: Wert in echte Spannung umrechnen, via RC-Empfänger an Sender senden → Anzeige auf Display.

Custom PCB Design

Viele Verbindungen → Custom PCB für Ordnung. Kompatibel mit ATmega2560-Board (Aufsteckbar). 3,3V-Regler + NRF24L01-Anschluss (alternative Steuerung). 12V, 5V, 6V-Schienen mit Digitalpins für Servos. 6V-Schiene per externem Buck-Converter speisbar.

PCBWay: Gerber hochladen, Eigenschaften, bestellen. Nur Farbe Weiß geändert. Gerber in PCBWay Community.

PCB-Montage: Beschriftet → einfach. Unten Pinheader für ATmega2560, dann Oberseite. Erst kleine Teile (Widerstände, Transistoren), dann große (LEDs, Stromanschlüsse). Alle Verbindungen per Pinheader (Flexibilität). Externer Buck-Converter & 3,3V-Regler nicht bestückt (nicht genutzt). Weißer PCB – clean & nice.

3D-gedruckten Panzer fertigmontieren

Mikrocontrollerboard mit M3-Schrauben fixieren, Custom PCB drauf.

LEDs einbauen: In Seitenpaneele per Halter (5 mm LED, Presspassung → clean). Schaltung: Je LED-Reihe in Reihe löten. Kathode schwarz, Anode rot. Kabel durch Öffnung in Seitenpaneel → PCB.

Fernlicht-LEDs direkt auf vorderem Top-Cover.

LED-Anschluss: XH2.54mm Dupont-Stecker auf PCB → passende Buchsen an Kabel crimpen. Crimpzange fehlte → kleine Zange genutzt, klappte. Jede LED-Reihe in passenden, beschrifteten PCB-Stecker.

Motoren: Keine passenden Stecker → direkt angelötet. Motor → DRV8871 → PCB.

Funk: FLYSKY Sender/Empfänger (günstig, top). Empfänger → Mikrocontroller: Jumperkabel. I-BUS über Serial → 3 Drähte (VCC, GND, Signal). Rückkanal (Akku-Spannung an Sender): Sensor-I-BUS am Empfänger an 2. Serial.

LiPo-Akku: Passender Stecker → 12V-Buchse. Daneben ON/OFF-Buchse für Schalter.

Wichtig: Vor Inbetriebnahme RC-Empfänger stromlos machen, LM350 Trimmer auf 5V einstellen!

Top-Rückdeckel drauf → Projekt fertig.

Roboterplattform programmieren

Arduino Code für 3D-gedruckten Panzer/Roboterplattform:

/* 3D Printed Tracked Robot Platform - Arduino Code by Dejan, www.HowToMechatronics.com
Libraries: IBusBM: https://github.com/bmellink/IBusBM */
#include 
#define motorLeft_IN1 4
#define motorLeft_IN2 5
#define motorRight_IN1 6
#define motorRight_IN2 7
IBusBM IBus;
IBusBM IBusSensor;
int ch0, ch1, ch6, ch8 = 0;
int motorSpeed, steeringValue, leftMotorSpeed, rightMotorSpeed = 0;
int ledBlinkPeriod = 50;
int isOn = LOW;
unsigned long time_now = 0;
void setup() {
  Serial.begin(115200);
  IBus.begin(Serial1, IBUSBM_NOTIMER); // Servo iBUS
  IBusSensor.begin(Serial2, IBUSBM_NOTIMER); // Sensor iBUS
  IBusSensor.addSensor(IBUSS_INTV); // voltage sensor
  // DC motors stationary
  digitalWrite(motorLeft_IN1, LOW); digitalWrite(motorLeft_IN2, LOW);
  digitalWrite(motorRight_IN1, LOW); digitalWrite(motorRight_IN2, LOW);
  digitalWrite(46, LOW); digitalWrite(47, LOW); digitalWrite(48, LOW);
}
void loop() {
  IBus.loop();
  ch0 = IBus.readChannel(0); // left/right
  ch1 = IBus.readChannel(1); // forward/backward
  ch6 = IBus.readChannel(6); // Headlights
  ch8 = IBus.readChannel(8); // High beam
  // PWM conversion
  steeringValue = map(ch0, 1000, 2000, -185, 185);
  motorSpeed = map(ch1, 1000, 2000, -185, 185);
  motorSpeed = abs(motorSpeed);
  leftMotorSpeed = 70 + motorSpeed + steeringValue; // 70-255
  rightMotorSpeed = 70 + motorSpeed - steeringValue;
  leftMotorSpeed = constrain(leftMotorSpeed, 0, 255);
  rightMotorSpeed = constrain(rightMotorSpeed, 0, 255);
  if (leftMotorSpeed < 72) leftMotorSpeed = 0;
  if (rightMotorSpeed < 72) rightMotorSpeed = 0;
  // Forward
  if (ch1 > 1510 && ch1 < 2000) {
    analogWrite(motorLeft_IN1, leftMotorSpeed); digitalWrite(motorLeft_IN2, LOW);
    analogWrite(motorRight_IN1, rightMotorSpeed); digitalWrite(motorRight_IN2, LOW);
  }
  // Backward
  if (ch1 > 1000 && ch1 < 1420) {
    digitalWrite(motorLeft_IN1, LOW); analogWrite(motorLeft_IN2, leftMotorSpeed);
    digitalWrite(motorRight_IN1, LOW); analogWrite(motorRight_IN2, rightMotorSpeed);
  }
  // Neutral / Turn in place
  if (ch1 > 1420 && ch1 < 1520) {
    if (leftMotorSpeed < 75 && rightMotorSpeed < 75) {
      digitalWrite(motorLeft_IN1, LOW); digitalWrite(motorLeft_IN2, LOW);
      digitalWrite(motorRight_IN1, LOW); digitalWrite(motorRight_IN2, LOW);
    } else {
      analogWrite(motorLeft_IN1, leftMotorSpeed); digitalWrite(motorLeft_IN2, LOW);
      analogWrite(motorRight_IN1, rightMotorSpeed); digitalWrite(motorRight_IN2, LOW);
    }
  }
  // LEDs
  if (ch6 > 1500) { digitalWrite(47, HIGH); digitalWrite(48, HIGH); }
  else { digitalWrite(47, LOW); digitalWrite(48, LOW); }
  if (ch8 == 1500) { digitalWrite(46, HIGH); }
  else if (ch8 == 2000) {
    if (millis() >= time_now + ledBlinkPeriod) {
      time_now += ledBlinkPeriod;
      isOn = (isOn == HIGH) ? LOW : HIGH;
      digitalWrite(46, isOn);
    }
  } else { digitalWrite(46, LOW); }
  // Battery voltage
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.00 / 1023.00) * 3.02;
  IBusSensor.loop();
  IBusSensor.setSensorMeasurement(1, voltage * 100);
}

Code-Überblick

IBusBM liest RC-Sender:

IBus.loop();
ch0 = IBus.readChannel(0); // left/right
ch1 = IBus.readChannel(1); // forward/backward
ch6 = IBus.readChannel(6); // Headlights
ch8 = IBus.readChannel(8); // High beam

Rechter Joystick (Kanäle 0,1) = Fahrt. Zwei Kippschalter (6,8) = LEDs.

Eingänge auf PWM 0–255 mappen:

steeringValue = map(ch0, 1000, 2000, -185, 185);
motorSpeed = map(ch1, 1000, 2000, -185, 185);
motorSpeed = abs(motorSpeed);
leftMotorSpeed = 70 + motorSpeed + steeringValue;
rightMotorSpeed = 70 + motorSpeed - steeringValue;
leftMotorSpeed = constrain(leftMotorSpeed, 0, 255);
rightMotorSpeed = constrain(rightMotorSpeed, 0, 255);

PWM per analogWrite() an Treiber/Motoren.

if (ch1 > 1510 && ch1 < 2000) {
  analogWrite(motorLeft_IN1, leftMotorSpeed); digitalWrite(motorLeft_IN2, LOW);
  analogWrite(motorRight_IN1, rightMotorSpeed); digitalWrite(motorRight_IN2, LOW);
}

Code überschaubar – Plattform hat keine komplexen Funktionen.

Test der 3D-gedruckten Roboter – Kettenroboter-Plattform

Nach Upload: Plattform & Sender an. Senderdisplay: LiPo-Spannung, Empfänger-/Sender-Spannung.

Rechter Joystick = Bewegung. Linker Kippschalter = Scheinwerfer/Rücklicht. Rechter 3-Wege-Kippschalter = Fernlicht (Dauerlicht + Blinken).

Motoren etwas untermotorisiert: Joystick fast ganz oben nötig für Anfahren. Kette per Hand leicht blockierbar. Federung & Kette erzeugen großen Widerstand. Motoren 888 U/min, aber klein (<500 mA). Größere Motoren (1280 U/min) brachten ähnliche Ergebnisse (weniger Reduktion = weniger Drehmoment).

Trotzdem: Fährt ganz gut. Macht Spaß, besonders mit blinkenden LEDs, Burnouts, Donuts.

Draußen: Schnell Ausfall. Problem: Untermotorisiert + Kettenglied-Design. Dirt sammelt sich dort, wo Sprocket-Zähne greifen.

Redesign: Öffnung auf anderer Seite → Dreck fällt durch. Sprocket 0,2 mm kleiner (lockerer Sitz).

Mit Updates: Außenfahrt möglich. Aber Motoren bleiben Problem: Hänger, Steigungen nicht schaffbar. Empfehlung: ≤500 U/min, ≥1–2 A Nennstrom.

Test mit starken Motoren (20 U/min): Langsam, aber wie echter Panzer – klettert überall. 20 U/min zu langsam für Spaß/Donuts. Für spezifische Anwendungen okay. Vorschlag: ~50 U/min für langsame, ~500 U/min für schnelle Einsätze.

Hoffe, Video gefiel und was gelernt. Fragen in Kommentaren, abonnieren für Updates, Arduino-Projektsammlung checken.