Arduino RC-Luftkissenboot bauen: Vollständig 3D-gedrucktes Design & Programmierung

In diesem Tutorial lernen wir, wie man ein Arduino-basiertes RC-Luftkissenboot (Hovercraft) baut. Ich zeige den gesamten Bauprozess: vom Design und 3D-Druck der Teile (inkl. Propeller) über den Elektronik-Anschluss bis zur Arduino-Programmierung.

Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Zur Steuerung nutze ich meinen DIY Arduino RC-Sender aus einem früheren Video. Rechter Joystick steuert das Servo für die Ruder am Schubpropeller, ein Potentiometer den Lift-Propeller (bürstenloser DC-Motor), linker Joystick den Vortrieb.

Hovercraft 3D-Modell

Zunächst entwarf ich das Hovercraft in einer 3D-Modellierungssoftware.

Das 3D-Modell finden Sie auf Thangs zum Download und zur Browser-Ansicht.

Assembly 3D-Modell auf Thangs herunterladen.

STL-Dateien für 3D-Druck:

Hovercraft Funktionsprinzip

Das Grundprinzip: Das Fahrzeug wird von einem Luftpolster getragen. Der zentrale Propeller bläst Luft unter das Fahrzeug, was einen aus weichem Material bestehenden „Rock“ (Skirt) aufbläht.

Wenn der Luftdruck im Rock hoch genug ist, hebt das Fahrzeug ab. Die ständig zugeführte Luft entweicht mittig zwischen Rock und Boden, was zusätzlichen Auftrieb erzeugt und die Reibung reduziert.

Einmal angehoben, erzeugt der zweite Propeller Schub für den Vortrieb.

Auf der Rückseite des Schubpropellers sitzt ein einfaches Ruderpaar zur Steuerung.

3D-Druck

Nach Designfertigstellung begann der 3D-Druck der Teile.

Der Rumpf (Hull) ist das größte Teil und passt genau auf das Druckbett meines Creality CR-10 (30x30cm).

Link zum Drucker falls Interesse.

Nach dem Druck: Aufräumen. Der Cockpit-Hauptkörper war der längste Druck (~18h). Wegen des kurvigen Designs und dem Wunsch nach einem Stück viel Stützmaterial.

Doch das Stützmaterial ließ sich leicht entfernen, das Teil wurde perfekt. Der Rumpf wurde kopfüber gedruckt, wenig Support. Ich musste nachträglich etwas Material im zentralen Gebläsegehäuse wegschneiden, damit der Rock-Halter passt.

Das 3D-Modell ist bereits aktualisiert, damit Sie dieses Problem nicht haben.

Einige Rundungen waren rau – mit Schleifpapier geglättet.

Die Propeller brauchten keine Nachbearbeitung und funktionierten direkt aus dem Drucker gut.

Hovercraft lackieren

Nun die 3D-gedruckten Teile lackieren. Kein Primer, direkt Acryllack als Spray.

Erste Schicht: Schokoladenbraun. Kleinere Dekor-Teile in hellerem Braun.

Für einen cooleren Look nach Trocknung zwei weitere Farben per Schablonen-Technik: Zufällige Muster auf Papier, damit Streifen und Tupfen in Hellbraun und Schwarz aufbringen.

Arduino RC Hovercraft zusammenbauen

Die Teile gefielen mir gut, nach dem Trocknen ging es an den Zusammenbau.

Zuerst das Servo für die Ruder am Schubgebläse-Gehäuse montieren. Mit zwei M2-Schrauben/Muttern fixiert.

Dann der bürstenlose Motor. Meiner ist ein D2830 (28mm Ø, 30mm Länge), das Gehäuse ist passgenau dafür designed.

Beim Einbau erst Kabel durch Öffnungen führen (etwas eng, aber machbar). Rückseitig mit M3-Schrauben Motor am Gehäuse fixieren.

Nun Schubgehäuse mit Hauptkörper verbinden. Dieses Teil hat Öffnung für Servo- und BLDC-Kabel. Mit vier M3-Schrauben fest verschrauben.

Dann zweiten bürstenlosen Motor am Rumpf montieren. Gleiche Methode: Kabel durchführen, rückseitig mit vier M3-Schrauben fixieren.

Schaltplan

Die Elektronik sitzt zwischen Rumpf und Hauptkörper. Erst Schaltplan ansehen:

Das Gehirn ist ein Arduino Board. Damit steuern wir das Servo und die zwei bürstenlosen Motoren über zwei ESCs (Electronic Speed Controller). Für die BLDC-Motoren: 3S Li-Po (ca. 11V). Arduino wird über die geregelten 5V der ESCs versorgt (BEC-Funktion).

Funk: NRF24L01 Transceiver (mit verstärkter Antenne bis 700m Reichweite im Freiland). Der RC-Sender ist mein DIY-Bau aus früherem Tutorial. Detaillierte Tutorials zu NRF24L01 und Brushless-Motor-Steuerung mit Arduino gibt es ebenfalls. Grundprinzip: Sender überträgt Joystick/Poti-Daten an Empfänger, der ESC-Geschwindigkeit und Servo-Position steuert.

Ein Detail: Batterieüberwachung. Ein simpler Spannungsteiler (zwei Widerstände) direkt am Akku, Ausgang an Arduino Analogeingang. Teilt 11V auf ~4V herunter (für 5V-Pins verträglich). Damit können wir Akkuspannung überwachen und LED bei <11V aktivieren.

Benötigte Komponenten:

• NRF24L01 Transceiver Modul
• NRF24L01 + PA + LNA
• Bürstenloser Motor
• ESC 30A
• Li-Po Akku
• XT60 2 Female zu 1 Male
• XT60 Stecker
• Servomotor
• Arduino Board

Komponenten verbinden: Zwei ESCs per Parallel-Verteiler (XT60 Y-Splitter) an einen Akku.

Für Netzschalter: Weiteren XT60-Stecker, ein Kabel durchtrennen, Kippschalter einlöten. Eine Seite zum Y-Splitter, andere zum Akku.

ESCs in Hauptkörper legen, zwischen diesem und Rumpf einklemmen. Mit vier M3-Schrauben beide Teile verbinden. Von der oberen Körperöffnung Akku in Cockpit-Bereich einsetzen.

Für Arduino-Verbindung zwei Pin-Header als GND und 5V hinzugefügt.

Alles an Arduino anschließen, NRF24L01-Antenne, Kontroll-LED und Netzschalter durch Cockpit-Deckel führen.

Alles in Cockpit quetschen – etwas eng mit Arduino UNO, besser wäre Arduino Nano gewesen.

Trotzdem alles unterbringen, kleines Dekor-Teil am Deckel befestigen, Deckel auf Cockpit aufclipsen.

Lenksystem montieren: Kleines Glied per M2-Schraube/Mutter an Servohorn. Erstes Ruder einsetzen, mit 2mm Metalldraht durch dessen Körper am Schubgehäuse fixieren (Ruder dreht sich darum). Zweites Ruder genauso.

Zweites Ruder hat zusätzlichen Schlitz für Verbindung zum ersten Glied. Wieder M2-Schraube/Mutter. Schließlich beide Ruder per weiterem Glied verbinden – Lenksystem fertig.

Kleines Dekor-Teil an Hovercraft-Seite: Loch bohren, per Schraube am Rumpf fixieren. Beide Seiten bestückt – passt gut zum Gesamtbild.

Nun den Rock (Skirt) bauen. Der Rock-Halter hat Löcher ringsum zur Befestigung am Rumpf.

Auch Nutschlitze für Muttern – so lässt sich der Halter per M3-Schrauben ringsum am Rumpf befestigen. Alle Muttern eingesetzt, dann Rock aus einfachem Müllbeutel-Plastik gefertigt.

AC-Kleber auf mittleren Halterbereich, auf Plastikbeutel kleben. Umfang des Halters um ca. 6cm versetzen, Punkte markieren, verbinden.

Mit Cuttermesser Beutel zuschneiden. Rock wenden, zusätzliche Halter an zuvor geklebtem Mittelbereich anbringen.

Äußerer Beutelrand oben am Halter festkleben – wieder AC-Kleber, sorgfältig andrücken.

Fertiger Rock:

Löcher durch Beutel für Schrauben bohren. Rock-Halter ist 1mm kleiner als Rumpf – mit Beutel passt er perfekt hinein. M3-Schrauben ringsum festziehen.

Ein letzter Schritt: Zentralen Bereich des Plastikbeutels ausschneiden.

Damit strömt die Hälfte der Luft direkt in den Rock, die andere Hälfte durch die Öffnung – zusätzlicher Luftpolster in der Mitte.

Zum Schluss Propeller an bürstenlose Motoren montieren. Dazu den mitgelieferten Spannzangenkolben (Collet) des Motors nutzen – einfache, effektive Befestigung.

Einen Kolben hatte ich verloren, daher eine alternative Propeller-Version gedruckt, die direkt auf die 3,15mm Motorwelle passt. Druck kam perfekt, saß fest ohne Kleber.

Unser ferngesteuertes Luftkissenboot ist endlich fertig.

Was bleibt: Arduino-Code und Programm-Funktionsweise.

Arduino RC Hovercraft Code

Hier der Code für dieses DIY Arduino RC Hovercraft Projekt:

/* Arduino based RC Hovercraft == Receiver Code - ESC and Servo Control = by Dejan, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>

#define led 10
RF24 radio(8, 9); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

Servo esc1; // Servo-Objekt für ESC
Servo esc2;
Servo servo1;

int esc1Value, esc2Value, servo1Value;

struct Data_Package {
  byte j1PotX; byte j1PotY; byte j1Button;
  byte j2PotX; byte j2PotY; byte j2Button;
  byte pot1; byte pot2;
  byte tSwitch1; byte tSwitch2;
  byte button1; byte button2; byte button3; byte button4;
};
Data_Package data;

void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening();
  resetData();
  esc1.attach(7);
  esc2.attach(6);
  servo1.attach(5);
  pinMode(led, OUTPUT);
}

void loop() {
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) {
    resetData();
  }
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }

  // Servo steuern (Ruder)
  servo1Value = map(data.j2PotX, 0, 255, 0, 50);
  servo1.write(servo1Value);

  // Bürstenlose Motoren via ESC steuern
  // Lift-Propeller
  esc1Value = map(data.pot1, 0, 255, 1000, 2000);
  esc1.writeMicroseconds(esc1Value);

  // Schub-Propeller
  esc2Value = constrain(data.j1PotY, 130, 255); // Joystick Mitte = 127, nur oberer Bereich 130-255
  esc2Value = map(esc2Value, 130, 255, 1000, 2000);
  esc2.writeMicroseconds(esc2Value);

  // Batterie überwachen
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.00 / 1023.00) * 3; // 5V auf 12V umrechnen
  Serial.println(voltage);
  if (voltage < 11) { digitalWrite(led, HIGH); }
  else { digitalWrite(led, LOW); }
}

void resetData() {
  data.j1PotX = 127; data.j1PotY = 127;
  data.j2PotX = 127; data.j2PotY = 127;
  data.j1Button = 1; data.j2Button = 1;
  data.pot1 = 1; data.pot2 = 1;
  data.tSwitch1 = 1; data.tSwitch2 = 1;
  data.button1 = 1; data.button2 = 1;
  data.button3 = 1; data.button4 = 1;
}Code language: Arduino (arduino)

Beschreibung: Zuerst RF24-Bibliothek für Funk und Servo-Bibliothek für Servo & bürstenlose Motoren (ESC) einbinden. Radio- und Servo-Objekte definieren, Variablen und Datenstruktur für eingehende Senderdaten (mein DIY RC-Sender). Details zur Kommunikation im zugehörigen Tutorial.

Im setup() Funk initialisieren, Pins für Servo und ESCs definieren.

Im loop() eingehende Senderdaten lesen und für Servo/Brushless-Motoren nutzen. Joystick-Daten (0-255) per map() auf 0-50 für Servo-Position. Gleiches für ESCs: 0-255 auf 1000-2000µs mappen, per writeMicroseconds() als PWM-Steuersignal senden.

Batterieüberwachung: Analogwert vom Spannungsteiler einlesen, per simpler Mathematik in echte Akkuspannung umrechnen. Bei <11V LED einschalten.

Das war's. Für mehr Details die verlinkten Tutorials prüfen, um alles vollständig zu verstehen.

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Fragen gerne in den Kommentaren und schauen Sie in meine Arduino-Projektsammlung.