Torreta Nerf autónoma DIY: construye una pistola Nerf inteligente con motores paso a paso, cámara y Arduino

Componentes y suministros

Herramientas y máquinas necesarias

• Impresora 3D (genérica)
• Soldador (genérico)
• Fresadora CNC

Aplicaciones y servicios en línea

• Arduino IDE
• Autodesk Fusion 360

Sobre el proyecto

Idea

Hace unos años vi un proyecto que mostraba una torreta semiautónoma que podía disparar por sí sola una vez apuntada. Eso me dio la idea de usar una cámara Pixy 2 para adquirir objetivos y luego apuntar la pistola Nerf automáticamente, lo que podría luego enfocar y disparar todo por sí sola.

Los componentes

Para este proyecto, la pistola necesitaría ojos, así que elegí la Pixy 2 por lo fácil que es interconectarla con la placa principal. Luego necesité un microcontrolador, así que elegí un Arduino Mega 2560 por la cantidad de pines que tiene.

Como la pistola necesita dos ejes, guiñada y cabeceo, requiere dos motores paso a paso. Por eso, DFRobot me envió su placa de controlador de motor dual DRV8825.

Diseño CAD

Comencé cargando Fusion 360 e insertando un lienzo adjunto de la pistola Nerf. Luego creé un cuerpo sólido a partir de ese lienzo. Después de diseñar la pistola, hice una plataforma con algunos soportes basados en cojinetes que permitirían a la pistola rotar de izquierda a derecha. Coloqué un motor paso a paso junto a la plataforma giratoria para accionarla.

Pero la pregunta más grande es cómo hacer que la pistola apunte hacia arriba y abajo. Para eso, se necesitaba un sistema de accionamiento lineal con un punto unido al bloque móvil y otro punto en la parte trasera de la pistola. Una varilla conectaría los dos puntos, permitiendo que la pistola pivote a lo largo de su eje central.

Fabricación de las piezas

Casi todas las piezas de mi diseño están destinadas a imprimirse en 3D, así que usé mis dos impresoras para crearlas. Luego creé la plataforma móvil usando primero Fusion 360 para generar las trayectorias de herramienta necesarias para mi fresadora CNC, luego corté el disco de una hoja de contrachapado.

Montaje

Después de crear todas las piezas, fue hora de ensamblarlas. Comencé conectando los soportes de cojinetes al disco giratorio. Luego ensamblé el conjunto de cabeceo lineal pasando las varillas de aluminio de 6 mm y la varilla roscada a través de las piezas.

Por último, fijé la propia pistola Nerf con una varilla de acero y dos postes hechos de extrusiones de aluminio.

Programación

Ahora la parte más difícil del proyecto: la programación. Una máquina que dispara proyectiles es muy compleja, y las matemáticas detrás pueden ser confusas. Empecé escribiendo el flujo y lógica del programa paso a paso, detallando lo que sucedería en cada estado de la máquina. Los diferentes estados son:

• Adquirir objetivo
• Posicionar la pistola
• Acelerar los motores
• Disparar la pistola
• Desacelerar los motores

Adquirir el objetivo implica primero configurar la Pixy para rastrear objetos rosa neón como objetivos. Luego la pistola se mueve hasta que el objetivo está centrado en la vista de la Pixy, donde se mide su distancia desde el cañón de la pistola al objetivo. Usando esta distancia, las distancias horizontal y vertical pueden encontrarse usando funciones trigonométricas básicas. Mi código tiene una función llamada get_angle() que usa estas dos distancias para calcular cuánto ángulo se necesita para golpear ese objetivo.

La pistola luego se mueve a esta posición y enciende los motores a través de un MOSFET. Después de que ha acelerado durante cinco segundos, mueve el servomotor para accionar el gatillo. El MOSFET luego apaga el motor y la pistola Nerf vuelve a buscar objetivos.

Diversión

Puse una tarjeta de índice rosa neón en la pared para probar la precisión de la pistola. Funcionó bien, ya que mi programa calibra y ajusta el ángulo para la distancia medida. Aquí hay un video demostrando la pistola funcionando.

Código

Esquemático (C/C++)

Subir a Arduino Mega

#include <math.h>
#include <Arduino.h>
#include "BasicStepperDriver.h"
#include <Servo.h>
#include <Pixy2I2C.h>
// X es cabeceo, Y es guiñada
const int pins[] = {6,7,8,5,4,12}; // MX PASO, DIR, EN, MY PASO, DIR, EN
const int limit_switch = 26, laser_pin = 11, spool_pin = 10, servo_pin = 13, distance_trig = 29, distance_echo = 30;
double velocity = 21.336;
double velocity_squared = 455.225;
float current_angle = 0.0;
float hyp_distance; // distancia de pistola a objetivo en metros
#define X_MID 164
#define Y_MID 150
#define DEADZONE 15
#define G 9.8
#define STP_PER_DEG_YAW 3.333
#define STP_PER_DEG_PITCH 184859
#define MICROSTEPS 32
#define RPM 120
#define MOTOR_STEPS_Y 200
#define MOTOR_STEPS_X 1036 // 17.7777 pasos / grado
BasicStepperDriver pitch_stepper(MOTOR_STEPS_X, pins[1], pins[0]);
BasicStepperDriver yaw_stepper(MOTOR_STEPS_X, pins[4], pins[3]);
Servo trigger;
Pixy2I2C pixy;
enum States { ACQUIRE, POSITION, SPOOL, FIRE, WIND_DOWN, RETURN };
States state = ACQUIRE;
void setup() {
  Serial.begin(115200);
  init_pins();
  delay(1000);
  // home_pitch();
  pixy.init();
  Serial.println("Ready...");
}
void loop() {
  switch(state){
    case ACQUIRE:
      acquire_target();
      state = POSITION;
      digitalWrite(laser_pin,HIGH);
      break;
    case POSITION:
      Serial.println("positioning");
      position_gun();
      state = SPOOL;
      break;
    case SPOOL:
      Serial.println("spooling");
      digitalWrite(spool_pin,HIGH);
      delay(5000);
      state = FIRE;
      break;
    case FIRE:
      fire_gun();
      state = WIND_DOWN;
      break;
    case WIND_DOWN:
      Serial.println("winding down");
      digitalWrite(spool_pin,LOW);
      delay(2000);
      state = RETURN;
      digitalWrite(laser_pin,LOW);
      state = ACQUIRE;
      break;
  }
}
void fire_gun(){
  Serial.println("Firing gun!");
  trigger.write(108);
  delay(400);
  trigger.write(90);
  delay(2000);
}
void position_gun(){
  float x, y;
  hyp_distance = ping();
  hyp_distance /= 100;
  while(!hyp_distance){
    hyp_distance = ping();
    hyp_distance /= 100;
  }
  Serial.println(hyp_distance);
  x = cos(current_angle) * hyp_distance;
  y = sin(current_angle) * hyp_distance;
  float target_angle = get_angle(x,y);
  target_angle /= 100;
  Serial.println(target_angle);
  move_pitch(target_angle - current_angle);
  current_angle = target_angle;
}
void acquire_target(){
  int x=0, y=0;
  long steps_taken=0;
  bool lock = false;
  while(!lock){
    pixy.ccc.getBlocks();
    if(pixy.ccc.numBlocks){
      x = pixy.ccc.blocks[0].m_x;
      y = pixy.ccc.blocks[0].m_y;
      Serial.print("Target seen at location X: ");
      Serial.print(x);
      Serial.print(", Y: ");
      Serial.println(y);
      if(x <= (X_MID - DEADZONE)){
        // Si demasiado a la izquierda, mover pistola izquierda
        move_yaw(1);
      } else if(x >= (X_MID + DEADZONE)){
        move_yaw(-1);
      } else if(y <= (Y_MID - DEADZONE)){
        // demasiado arriba, mover pistola arriba
        pitch_stepper.move(33152);
        steps_taken += 33152;
      } else if(y >= (Y_MID + DEADZONE)){
        pitch_stepper.move(33152);
        steps_taken += 33152;
      } else {
        lock = true;
        Serial.print("Target locked at location X: ");
        Serial.print(x);
        Serial.print(", Y: ");
        Serial.println(y);
        Serial.print("Steps taken: ");
        Serial.println(steps_taken);
      }
    }
  }
  current_angle = steps_taken / STP_PER_DEG_PITCH;
  Serial.print("Current angle: ");
  Serial.println(current_angle);
}
void init_pins(){
  pinMode(pins[2],OUTPUT);
  pinMode(pins[5],OUTPUT);
  pinMode(limit_switch, INPUT_PULLUP);
  pinMode(laser_pin, OUTPUT);
  pinMode(spool_pin, OUTPUT);
  pinMode(distance_echo, INPUT);
  pinMode(distance_trig, OUTPUT);
  digitalWrite(pins[2],LOW);
  digitalWrite(pins[5],LOW);
  digitalWrite(laser_pin,LOW);
  digitalWrite(spool_pin,LOW);
  trigger.attach(servo_pin);
  pitch_stepper.begin(RPM, MICROSTEPS);
  yaw_stepper.begin(5, MICROSTEPS);
  trigger.write(90);
}
void move_yaw(float degrees){
  yaw_stepper.move(degrees*STP_PER_DEG_YAW*32);
}
void move_pitch(float degrees){
  current_angle += degrees;
  pitch_stepper.move(degrees*STP_PER_DEG_PITCH);
}
float get_angle(float distance, float height){
  float i = 2 * height * 455.225;
  float j = G * distance * distance;
  i += j;
  j = 9.8 * i;
  i = sqrt(pow(velocity_squared,2) - j);
  return atan((velocity_squared-i) / (G * distance))*(180/PI);
}
float ping(){
  Serial.println("Getting distance...");
  long duration;
  digitalWrite(distance_trig, LOW);
  delayMicroseconds(5);
  digitalWrite(distance_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(distance_trig, LOW);
  duration = pulseIn(distance_echo, HIGH);
  return duration / 2 / 29.1; // distancia en metros
}
void home_pitch(){
  Serial.println(digitalRead(limit_switch));
  if(!digitalRead(limit_switch)){
    // Si interruptor está activo
    pitch_stepper.rotate(720);
  }
  while(digitalRead(limit_switch)){
    pitch_stepper.move(-32);
  }
  pitch_stepper.rotate(2880*2);
}

Piezas personalizadas y envolventes

Repositorio Thingiverse: archivo CAD en thingiverse.com

Esquemáticos

[Imagen de esquemático]