Bluetooth-gesteuerter Nerf-Geschützturm: Teile & Aufbauanleitung

Komponenten und Zubehör

Komponente	Menge
Arduino Nano R3	1
HC-05 Bluetooth-Modul	1
LM2596 Step-Down-Wandler	1
MG-90s Servos	3
Typ 130 DC-Motoren	2
FR207 Gleichrichterdiode	1
RFP30N06LE MOSFET	1
2,1×5,5 mm Hohlstecker	1
Widerstände 10 kΩ	1
Widerstände 330 Ω	1
Widerstände 680 Ω	1
M2×10 Selbstschneidschrauben	30
M5×20 Senkschrauben	4
Dupont-Steckverbinder	15
1,5 mm Metallstift	1
Drähte	1
Schrumpfschlauch	1
20 mm Gummiband	1
9V Netzteil (min. 2,5 A)	1

Benötigte Werkzeuge und Maschinen

• Schraubendreher
• Abisolierzange
• Zange
• Lötkolben
• Multimeter
• Crimpzange
• 3D-Drucker

Apps und Online-Dienste

• Microsoft Windows 10

Über dieses Projekt

Danke fürs Anschauen meines Bluetooth-gesteuerten Nerf-Geschützturm-Projekts. Es gibt nicht allzu viel zu erklären – es ist ein Nerf-Geschützturm, der über Bluetooth entweder von einem Android-Gerät oder einem PC gesteuert wird.

Weitere Details: littlefrenchkev.com/bluetooth-nerf-turret

Wie funktioniert es?

Nichts übermäßig Komplexes. Die Neigungs- und Schwenkbewegung wird von 2 Servos gesteuert, die von einem Arduino Nano angesteuert werden.

Die Pfeile werden durch 2 Rollen abgeschossen, die von 2 kleinen DC-Motoren angetrieben werden. Ein Servo schiebt die Pfeile in die Rollen, wenn der Schießbefehl gesendet wird. Das Magazin fasst 7 Pfeile.

Wie erwähnt wird es über Bluetooth entweder von einem Android-Gerät oder einem PC gesteuert.

Wie baut man es?

MONTAGE:

Stativ und Magazin gibt es in zwei verschiedenen Versionen: eine für MG-90s Servos und eine für MG996r Servos. MG996r Servos können stromhungrig sein – stellen Sie sicher, dass Ihr Netzteil damit zurechtkommt, falls Sie diese verwenden.

Stativ:

Magazin:

VERKABELUNG:

SOFTWARE UND TEST!!!

Einige zusätzliche Fotos – weil warum nicht!!!

Code

Arduino Code

Code für den Arduino. Der Code bleibt gleich, egal ob Sie den Turm über die Android-App oder einen PC steuern.

#include <Servo.h> //-----Servos und Variablen deklarieren
Servo recoil_servo;
Servo pan_servo;
Servo tilt_servo;
const byte pan_limit_1 = 0;
const byte pan_limit_2 = 180;
const byte tilt_limit_1 = 65;
const byte tilt_limit_2 = 180;
const byte recoil_rest = 180; // Winkel des Servos in Ruhelage
const byte recoil_pushed = 125; // Winkel, den der Servo erreichen muss, um den Pfeil zu schieben
//-----Variablen für serielle Datenverarbeitung
byte byte_from_app;
const byte buffSize = 30;
byte inputBuffer[buffSize];
const byte startMarker = 255;
const byte endMarker = 254;
byte bytesRecvd = 0;
boolean data_received = false;
//-----Variablen für Motor-Timing und Schießen
bool is_firing = false;
bool can_fire = false;
bool recoiling = false;
unsigned long firing_start_time = 0;
unsigned long firing_current_time = 0;
const long firing_time = 150;
unsigned long recoil_start_time = 0;
unsigned long recoil_current_time = 0;
const long recoil_time = 2 * firing_time;
const byte motor_pin = 12;
boolean motors_ON = false;

void setup() {
  pinMode(motor_pin, OUTPUT);
  digitalWrite(motor_pin, LOW);
  recoil_servo.attach(9);
  pan_servo.attach(10);
  tilt_servo.attach(11);
  recoil_servo.write(recoil_rest);
  pan_servo.write(90);
  delay(1000);
  tilt_servo.write(105);
  Serial.begin(9600);
}

void loop() {
  getDataFromPC();
  set_motor();
  if (data_received) {
    move_servo();
    set_recoil();
    set_motor();
  }
  fire();
}

void getDataFromPC() {
  // Erwartete Datenstruktur: [Startbyte, Pan-Wert, Tilt-Wert, Motor an, Feuer-Button gedrückt, Endbyte]
  // Startbyte = 255, Pan/Tilt = 0-253, Motor an = 0/1, Feuer = 0/1, Endbyte = 254
  if (Serial.available()) {
    byte_from_app = Serial.read();
    if (byte_from_app == 255) {
      bytesRecvd = 0;
      data_received = false;
    } else if (byte_from_app == 254) {
      data_received = true;
    } else {
      inputBuffer[bytesRecvd] = byte_from_app;
      bytesRecvd++;
      if (bytesRecvd == buffSize) bytesRecvd = buffSize - 1;
    }
  }
}

void move_servo() {
  byte pan_servo_position = map(inputBuffer[0], 0, 253, pan_limit_2, pan_limit_1);
  pan_servo.write(pan_servo_position);
  byte tilt_servo_position = map(inputBuffer[1], 0, 253, tilt_limit_2, tilt_limit_1);
  tilt_servo.write(tilt_servo_position);
}

void set_recoil() {
  if (inputBuffer[3] == 1) {
    if (!is_firing && !recoiling) can_fire = true;
  } else {
    can_fire = false;
  }
}

void set_motor() {
  if (inputBuffer[2] == 1) {
    digitalWrite(motor_pin, HIGH);
    motors_ON = true;
  } else {
    digitalWrite(motor_pin, LOW);
    motors_ON = false;
  }
}

void fire() {
  if (can_fire && !is_firing && motors_ON) {
    firing_start_time = millis();
    recoil_start_time = millis();
    is_firing = true;
  }
  firing_current_time = millis();
  recoil_current_time = millis();
  if (is_firing && firing_current_time - firing_start_time < firing_time) {
    recoil_servo.write(recoil_pushed);
  } else if (is_firing && recoil_current_time - recoil_start_time < recoil_time) {
    recoil_servo.write(recoil_rest);
  } else if (is_firing && recoil_current_time - recoil_start_time > recoil_time) {
    is_firing = false;
  }
}

Python-Dateien

Die ausführbare Datei und die Android-App finden Sie hier:
littlefrenchkev.com/bluetooth-nerf-turret
GitHub Repository

Schaltpläne

Hier ist der Haupt-Verkabelungsplan. Die Verkabelung ist in kleine Abschnitte unterteilt, die über Dupont-Steckverbinder miteinander verbunden sind – für einfacheren Aufbau.

Hier ist die HC-05 Bluetooth-Verkabelung. Dieser Teil enthält einen Spannungsteiler, um die 5V vom Arduino auf ca. 3,3V für den HC-05 Empfänger-Pin zu reduzieren.