Bouw een Bluetooth-gestuurde Nerf-toren: Onderdelen & Montagehandleiding

Onderdelen en benodigdheden

Nodige tools en machines

Apps en online diensten

Over dit project

Bedankt voor het bekijken van mijn Bluetooth-gestuurde Nerf-torenproject. Er is niet zoveel uitleg nodig: dit is een Nerf-toren die via Bluetooth wordt bestuurd vanaf een Android-apparaat of een PC.

Meer informatie: https://www.littlefrenchkev.com/bluetooth-nerf-turret

HOE WERKT HET?

Niets super complex. De kantel- (tilt) en draai- (pan) beweging wordt afgehandeld door 2 servo's aangedreven door een Arduino Nano.

De pijlen worden afgeschoten met 2 rollen gedreven door 2 kleine DC-motoren. Een servo duwt de pijlen in de rollen wanneer het commando om te schieten wordt gestuurd. Het magazijn kan 7 pijlen bevatten.

Zoals hierboven vermeld, wordt het bestuurd via Bluetooth vanaf een Android-apparaat of een PC.

HOE BOUW JE HET?

MONTAGE:

De driepoot en het magazijn komen in twee verschillende versies: één ontworpen voor MG-90s servo's en de ander voor MG996r servo's. MG996r servo's kunnen veel stroom trekken. Zorg ervoor dat je voeding erbij past als je ervoor kiest om ze te gebruiken.

Driepoot:

Magazijn:

BEDRADING:

Zie het schema in de sectie Schema's.

SOFTWARE EN TESTEN!

ENKEL EXTRA FOTO'S OMWAAROM NIET!

Code

Arduino-code

Code om naar de Arduino te uploaden. De code blijft hetzelfde of je nu kiest voor besturing via de Android-app of een PC.

#include <Servo.h> //-----Servo's en variabelen declareren
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; // Hoek van de servo in rust
const byte recoil_pushed = 125; // Hoek die de servo moet bereiken om de pijl te duwen
//-----Variabelen gerelateerd aan seriële data-afhandeling
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;
//-----Variabelen gerelateerd aan motor-timing en vuur
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() {
  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-bestanden

De uitvoerbare bestanden en Android-app vind je hier:
https://www.littlefrenchkev.com/bluetooth-nerf-turret
https://github.com/LittleFrenchKev/Bluetooth_Nerf_turret

Schema's

Hier is het hoofdbedradingsschema. De bedrading is verdeeld in kleine secties die met Dupont-connectors met elkaar verbonden zijn voor gemakkelijke montage.

Hier is de HC-05 Bluetooth-bedrading. Dit deel bevat een spanningsdeler om de 5V van de Arduino te verlagen naar ongeveer 3.3V voor de HC-05-receiver-pin.