Construye una Torreta Nerf Controlada por Bluetooth: Guía de Piezas y Montaje

Componentes y Suministros

Componente	Cantidad
Arduino Nano R3	1
Módulo Bluetooth HC-05	1
Convertidor Buck LM2596	1
Servos MG-90s	3
Motores DC Tipo 130	2
Diodo Rectificador FR207	1
MOSFET RFP30N06LE	1
Conector Jack 2.1x5.5mm	1
Resistencias 10kΩ	1
Resistencias 330Ω	1
Resistencias 680Ω	1
Tornillos Autorroscantes M2x10	30
Tornillos Avellanados M5x20	4
Conectores Dupont	15
Varilla Metálica 1.5mm	1
Cables	1 set
Termorretráctil	1
Goma Elástica 20mm	1
Fuente 9V (mín. 2.5A)	1

Herramientas Necesarias

• Destornillador
• Pelacables
• Alicates
• Soldador
• Multímetro
• Herramienta de Crimpado
• Impresora 3D

Aplicaciones y Servicios Online

• Microsoft Windows 10

Sobre el Proyecto

Gracias por visitar mi proyecto de torreta Nerf controlada por Bluetooth. No hay mucho que explicar: es una torreta Nerf controlada vía Bluetooth desde un dispositivo Android o un PC.

¿Cómo Funciona?

Nada super complejo. El movimiento de inclinación (tilt) y giro (pan) es gestionado por 2 servos controlados por un Arduino Nano.

Los dardos se disparan mediante 2 rodillos impulsados por 2 pequeños motores DC. Un servo empuja los dardos hacia los rodillos cuando se envía la orden de disparo. El cargador tiene capacidad para 7 dardos.

Como se mencionó, se controla vía Bluetooth desde un dispositivo Android o un PC.

¿Cómo Construirla?

Montaje

El trípode y el cargador vienen en dos versiones: una para servos MG-90s y otra para MG996r. Los MG996r pueden consumir mucha corriente. Asegúrate de que tu fuente de alimentación esté a la altura si decides usarlos.

Trípode: [Imagen de referencia]

Cargador: [Imagen de referencia]

Cableado

Consultar el diagrama esquemático en la sección correspondiente.

Software y Pruebas

El código Arduino es el mismo سواء elijas control por app Android o PC.

Fotos Adicionales

[Galería de imágenes del proyecto terminado]

Código

Código Arduino

#include <Servo.h>

//----- Declarar servos y variables
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;
const byte recoil_pushed = 125;

//----- Variables manejo datos serie
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;

//----- Variables temporización y disparo
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() {
  // Estructura esperada: [byte_inicio, pan, tilt, motor_on, fire_pressed, byte_fin]
  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_pos = map(inputBuffer[0], 0, 253, pan_limit_2, pan_limit_1);
  pan_servo.write(pan_pos);
  byte tilt_pos = map(inputBuffer[1], 0, 253, tilt_limit_2, tilt_limit_1);
  tilt_servo.write(tilt_pos);
}

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;
  }
}

Archivos Python / App Android

El ejecutable y la app Android están disponibles en: littlefrenchkev.com y GitHub

Esquemáticos

Diagrama principal de cableado. El cableado está dividido en secciones pequeñas unidas con conectores Dupont para facilitar el montaje.

Cableado del módulo Bluetooth HC-05: incluye un divisor de tensión para adaptar los 5V del Arduino a ~3.3V para el pin RX del HC-05.