Construye una Torreta Portal 2 Real con Arduino – Movimiento 3 Ejes y Audio

Componentes y Suministros

Componente	Cantidad
Arduino Nano R3	1

Herramientas y Máquinas Necesarias

• Impresora 3D (genérica)

Sobre el Proyecto

La Historia

Esta Navidad decidí diseñar y construir una torreta Portal funcional del juego Portal 2. Para mí fue un ejercicio de modelar todo el ensamblaje en Fusion 360 antes de construir nada. Este diseño usa un Arduino Nano, un chip reproductor MP3, sensor de distancia, servos, LEDs y piezas impresas en 3D.

El objetivo era que se moviera en 3 "ejes", con sonidos hablados del juego y LEDs para simular disparos.

• Abrir las "alas" si detecta a alguien delante. Usar mecanismo de manivela con deslizadores, ¡solo porque sí!
• Si la persona sigue ahí tras abrir, disparar hasta que se vaya. LEDs y sonido de ametralladora.
• Si la persona ya no está, ejecutar una pequeña rutina de búsqueda/escaneo.
• Cerrar y dormir hasta que venga alguien más.
• Usar sonidos y voces de la torreta Portal del juego.

Me tomé ciertas libertades en el diseño, intentando que fuera apreciablemente igual al del juego, pero funcional e imprimible. Con bocetos básicos encontrados online, empecé a modelar y planificar...

Los sonidos se almacenan en una tarjeta microSD, accesible desde la parte trasera para actualizar o cambiar sonidos después. Está en línea con la franja de relleno negro, haciéndola esencialmente invisible una vez instalada. Se usaron 18 expresiones y sonidos individuales en esta versión.

El sensor lidar (time-of-flight) está en un chip con perfil rectangular. Este sensor es casi invisible desde el frente una vez ensamblado.

Paso 1: Modelado en Fusion 360

El diseño partió de bocetos encontrados online. Usando estas imágenes como lienzos, empecé a esbozar los contornos de las 3 vistas. Luego fue cuestión de extruirlos a 3D, hacer el vaciado general y hacer cortes. Todos los componentes electrónicos se construyeron en Fusion como componentes que se insertaron y colocaron donde pensé que tenía sentido. Parámetros de diseño:

• Arduino Nano debía tener el conector accesible para actualizar una vez totalmente ensamblado
• Tarjeta microSD accesible de la misma manera, e idealmente invisible una vez instalada
• Sensor time-of-flight también invisible
• Conector eléctrico 2.1mm para alimentación en la parte trasera
• Piezas impresas lo más grandes posible (no muchas piezas pequeñas)
• Imprimir sin soportes

Tras añadir los componentes (Nano, otros chips, servos) a la forma básica, se movieron y posicionaron según requería, y se construyeron las estructuras de soporte para sostenerlos dentro del caparazón.

El mecanismo de apertura de alas era de manivela y deslizador. ¿Por qué? ¡Porque quería usar un mecanismo de manivela! Esto añadió complicaciones, pero también tuvo un beneficio: una vez determinada la geometría, la repetibilidad operacional quedaba asegurada y los límites mínimos y máximos prácticamente garantizados.

Una vez construido el modelo completo y confiando en que funcionaría y se podría construir (imprimir) y ensamblar, imprimí las piezas y construí un prototipo. Una vez que funcionó, volví al modelo y hice ajustes para mejorar apariencia y ensamblabilidad (¿es esa una palabra?). Este modelo es el resultado de esos cambios.

Fue bastante intenso, ya que realmente no hay muchas formas cúbicas en esto, y se cierra muy herméticamente, sin acceso real para ajustes una vez montado. Aprendí bastante en este proyecto, como usar componentes incrustados dentro de otros componentes. Esto facilitó manipular y mantener sub-ensamblajes vinculados para acceso rápido. Al final, ¡valió la pena el esfuerzo!

Paso 2: Piezas Impresas en 3D

Portal turret v4.zip está actualizado y debería contener todas las piezas impresas necesarias para construir la última torreta.

--- Nueva "Pata Trasera de Prueba". No fiel al original, pero está en la parte trasera y permite usar un conector mini-USB recto hacia arriba. ---

Estas se imprimieron en una Prusa Mk2, usando PLA para todas las piezas. La orientación de impresión debería ser bastante evidente. El cuerpo se imprimió en posición vertical, sin soportes. Hay un gran hueco en los lados que debe salvarse, pero no tuve grandes problemas con ajustes estándar, salvo el abultamiento. El abultamiento en el frente y la parte trasera puede eliminarse prácticamente con buen filamento y buenos ajustes de impresión. Encontré que 0.2mm funcionaba bien en el laminador y producía un resultado decente. Cualquier cosa más grande y empezaban a aparecer huecos en el cuerpo cerca de la franja de relleno.

El diseño de canales y protuberancias se hizo con chaflanes de 45 grados, por lo que los elementos "colgando en el aire" serán mínimos.

Tuuve poca limpieza que hacer para montar el ensamblaje. Las franjas de relleno que se deslizan en los canales ahora son bastante directas, con ancho reducido y grosor consistente. Creo que se podría usar un material negro fino cortado en tiras en lugar de estas piezas impresas (impresas de canto).

El área que requiere delicadeza son los pines deslizadores en el marco de pitch. Pines rectos (clavos) en los orificios roscados con broca de 1/8" y algo de lubricante ayudarán mucho.

Archivos STL: Lens+v3b.stl, Body-RHS+v4.stl, Body-LHS+w+components+v4.stl, Wing+RH+bottom+v4.stl, Wing+RH+top+v4.stl, Wing+LH+bottom+v4.stl, Wing+LH+top+v4.stl, Pitch+Frame+v4.stl, Leg+-+REAR+v4.stl, Infill+strips+v3.stl, Leg+-+REAR+test.stl, Pitch+Frame+-+modified+1.stl, wings+v6.zip, Arduino+Base+w+Radio.stl, Portal+Turret+v4.zip

Paso 3: Componentes

V4 (torreta roja) tiene puentes más pequeños, requiriendo alas v4 y marco de pitch.

Las alas v6 son una opción que permite diferentes "armas" de color. No he hecho una personalmente así, pero debería funcionar bien.

Una vez completado el modelo y contento con mi prototipo, imprimí la rev 2 con los componentes plásticos como se muestra. Todo es PLA, con Negro y color de diseño (Azul en este caso), y un poco de PLA translúcido para la "Lente" central u ojo láser.

Paso 4: Electrónica

La construcción usa los siguientes componentes:

• Arduino Nano (1)
• DFPlayer Mini MP3 player (o MP3-TF-16P) (1)
• Sensor VL53L0X Time-of-Flight Ranging (1)
• Servos micro SG90 genéricos (3)
• LEDs rojos 5mm (5)
• Resistencias 220 Ohm para LEDs (5)
• Resistencia 1kOhm (1)
• Altavoz 4cm, 4Ohm, 3 Watt (1)
• Conector de alimentación 2.1mm (1)
• Clavos de enmarcar 3" (4)
• Tornillos M2 x 6 (8)
• Tornillos M2.5 x 8 (2)
• Tornillos M3 x 8 (4)
• Tornillos M3 x 12 (4)
• Tornillos M3 x 16 (2)
• Termorretráctil
• Bridas pequeñas

Todos los componentes están fácilmente disponibles en Arduino, Amazon, Banggood y otras fuentes. Los tornillos se consiguieron en un kit surtido. Es un dolor conseguirlos de otra forma...

Paso 5: Montaje Mecánico

La mayor parte del montaje mecánico es razonable. Las piezas impresas vienen con los agujeros grandes roscados donde es necesario, así que un repaso rápido con un tornillo antes del montaje final ayudará y hará fácil el montaje de los componentes atornillados.

El Arduino y el chip MP3 encajan en la cuna sin tornillos. El VL53LOX se desliza en el caparazón frontal sin fijaciones. Probar encaje primero, luego quitar e instalar una vez cableado.

El montaje del deslizador usa 4 clavos de enmarcar como raíles deslizantes. Tienen unos 1/8" de diámetro, con las cabezas cortadas. Sacados de una tira de clavos DeWalt para clavadora eléctrica. Imprescindible que los clavos sean lisos.

Los servos se montan como se muestra. La orientación es importante. Los servos de pitch y pivot están "centrados" al instalarlos en sus piezas. La manivela se instala de forma que, en posición abierta, cierre girando en sentido antihorario visto desde el frente. Posición abierta es varillas y manivela en línea recta, con otros 10 grados de rotación hasta bloqueo.

El montaje de las patas es la parte más fácil. Tornillos de 2-2.5mm, con las tapas de las patas encajando sobre los codos de cada pata. Usar fijaciones que no sobresalgan por encima de la placa de la pata. Así el cuerpo pivotante no se bloqueará si ajustas el rango de rotación.

Todas las conexiones de servos a piezas impresas se hacen usando el brazo blanco corto que viene con los servos. Estos brazos solo se presionan en las piezas impresas. Intenté imprimir el orificio estriado en las piezas que conectaban a cada servo, pero tuve éxito limitado y repetible. Mucho más fácil usar los brazos que vienen con los servos.

El montaje de la manivela usa los tornillos de 2.5mm más largos. Las varillas de la manivela no deben quedar apretadas entre las mitades de la manivela. De hecho, podrías probar con tornillos más cortos sin la pieza Crank2. Eso debería funcionar también (esperemos que no haya torque apreciable si las alas deslizan libremente).

El altavoz queda capturado por un soporte de servo (2 piezas) que capturan el altavoz. Altavoz entre estas "patas", y sujeto en posición asegurándolas al servo de pitch. Este servo luego se conecta al montaje de pitch (deslizador), seguido del montaje de manivela con varillas. Todo esto se ensambla antes de instalarlo en el cuerpo LHS con 4 tornillos pequeños.

Una vez instaladas las tripas principales, con el Arduino y el reproductor MP3 ubicados temporalmente, empieza la diversión: ¡el cableado!

Paso 6: Cableado

V5 - Opción Radio (fotos torreta roja). Incluye chip de radio nRF24L01. Cambia completamente el cableado de pines del Arduino para acomodar todas las conexiones. Detalles por venir...

El empaquetado final es ajustado, así que dedicar tiempo aquí a calcular longitudes de cable merece la pena. La mayoría de cables de interconexión acabaron entre 3" - 4".

Los LEDs se cablearon con las resistencias de 220 Ohm directamente, seguido de termorretráctil, algo de trenzado de cables, y se apartaron tras probarlos. Usé cable de calibre ligero (tipo cable de comunicaciones CAT5) que tenía por ahí y no quería que el cableado visible fuera llamativo.

Las partes mecánicas se probaron en el caparazón, luego se definió el enrutado de cables, luego corte y preparación de cables.

Construí los conectores de servos para poder enchufar y reemplazar servos si alguna vez fastidiaba algo y destrozaba los engranajes. ¡Definitivamente útil tras liarla en mi primer prototipo!

Una vez contento con la mayor parte del cableado, los LEDs se soldaron al final. Luego toca meter cuidadosamente el ensamblaje cableado en una mitad del caparazón. El último paso es soldar el conector de alimentación a los cables de alimentación una vez todo dentro.

-- Nota importante: ¡Asegúrate de que el cableado metido detrás del Nano no presione el botón de reset!! Esto causará problemas obvios y evitará que la unidad funcione correctamente. --

En este punto, todo el cableado está hecho, pero antes del montaje final, es importante subir el código al Nano y encenderlo para asegurar que LEDs, servos y reproductor MP3 funcionan como diseñados. Tras eso, hora de poner el resto de piezas mecánicas.

Paso 7: Código Arduino

¡Código actualizado! Limpieza y algunos ajustes.

El archivo adjunto es lo que ideé para impulsar la unidad como se muestra en los videos. Seguiré ajustando para cambiar el carácter de la Torreta y su comportamiento. Muchas opciones aquí.

Estructuré el código usando subrutinas que llamo según necesidad. Mantiene el cuerpo principal limpio y fue muy útil cuando jugaba con diferentes características. Me ayudó a manipular el código para diferentes comportamientos.

También usé muchas variables al principio lo que me ayudó a ajustar posiciones de reposo y rangos mínimos y máximos, por ejemplo.

Usé la librería DFMiniMP3 en mi código. Probé otras, como la de DFRobot, pero tuve problemas, así que volví a esta. Significaba que tenía que mantener las piezas 'static void' para mantenerla funcional. No son necesarias para la operación, pero bueno, no soy un maestro programador. Me encantaría saber de otra librería tan simple y limpia como la del VL53LOX. ¡Avísame si encuentras una forma mejor!

En cuanto a sonidos, la implementación es simple: una carpeta llamada "mp3" en la tarjeta SD, con archivos llamados 0001.mp3, 0002.mp3, etc. Los primeros cuatro dígitos deben ser en este formato, pero puedes añadir cualquier sufijo después para identificar los sonidos. Ver https://www.dfrobot.com/blog-277.html para un ejemplo. Incluí una foto de mis nombres de archivo usados en la carpeta. Los números corresponden a las llamadas en el código.

Los archivos de sonido los saqué de la página de Wikipedia sobre sonidos de torreta Portal. El código elige un archivo de sonido aleatorio (1 de 2, o 3 sonidos) para que no se vuelva repetitivo.

Paso 8: Montaje Final del Cuerpo

Esta parte es un poco complicada por las franjas de relleno negro. La escala del montaje final es lo bastante pequeña que las tiras y ranuras receptoras son diminutas. Esto requirió repasar el canal con un puntero u otro utensilio pequeño de raspado para asegurar que las tiras encajaran con poca resistencia antes de intentar poner el otro lado.

Atar los cables ordenadamente y usar bridas según sea necesario hará esto mucho más fácil.

He montado un par de estos ahora y encuentro más fácil juntar las dos mitades primero, luego insertar las franjas de relleno. Insertar un lado en la mitad con el "estante" que impide que la franja caiga dentro, luego separar ligeramente y presionar suavemente. No está mal ahora.

Fue una de las partes más complicadas. Quizás un día repiense este montaje, pero me gusta cómo queda cuando está hecho, y es bastante robusto.

Paso 9: Montaje de las Alas

Ahora que el cuerpo está junto, con los LEDs de las alas asomando, es hora de preparar las alas y montarlas.

Es imperativo que los agujeros deslizadores se repasen con broca de 1/8", luego se limpien. Cortar las cabezas de los clavos con cortapernos, alicates de presión, sierra de calar o herramienta favorita de corte de clavos. Los pines deslizadores (clavos cortados) se instalan en las alas por presión en cada pieza de ala. Clavos rectos, sin rebabas y lijados son la clave para que esto funcione. Los deslizadores y agujeros de las alas deben lubricarse y probarse antes de conectar las varillas de la manivela y hacer funcionar. Grafito seco, u otro lubricante apto para PLA recomendado. Encuentro que un tubo pequeño de lubricante personal funciona realmente bien, y es barato. Es muy resbaladizo. También requiere algo de 'explicación' cuando tu pareja o padre entra y pregunta qué necesitas exactamente eso para en el banco de trabajo!!

Empieza por averiguar qué pieza de ala va donde, y prueba deslizar esa pieza primero. Luego encaja las mitades superior e inferior una vez instalados los pines, aplica lubricante (un bastoncillo de algodón funciona bien) y asegúrate de que las alas deslizan bien. Esto puede ser complicado, pero sin asegurar que las alas deslizan sin esfuerzo, sin atascos, tendrás un mal rato. Confía en mí...

Una vez las alas van bien, es solo meterlas en su sitio, colocar la varilla de conexión sobre el agujero del ala y montar con un solo tornillo. Luego, los LEDs se insertan en los agujeros de los cañones, los cables se meten contra el ala y ¡listo! También puedes usar algo de silicona caliente para fijarlos una vez todo probado.

Paso 10: ¡Asusta y Sorprende a tus Amigos!!

La última pequeña salvedad de este diseño es que un enchufe en ángulo es una gran idea, ya que no interfiere con la pata trasera al pivotar. La pata trasera revisada (v3) se ha alargado para dar un poco más de espacio.

Una vez construida y enchufada (5V o apto para Nano), se quedará quieta hasta que alguien sea detectado dentro de la distancia programada, entonces cobrará vida y ¡aniquilará a cualquiera que entre en su dominio!!

Avísame si construyes una (o más) y si se te ocurren nuevas características o conceptos!

Código

• Portal turret w Radio (RED)

Portal turret w Radio (RED)C/C++

Código usado para la torreta. Incluye código que permite control por el Master Turret Control, en otra página. Diferentes versiones requieren ajustes.

// /* Portal Turret - Opción Con Radio!! * Chris Nowak - Feb 2019 * https://www.instructables.com/member/ChrisN219/ * https://create.arduino.cc/projecthub/Novachris/talking-portal-2-turret-gun-637bf3 * * Este código incluye todas las características para realizar la Ópera Cara Mia, * Chat Time y Modo Manual, controlados por el Master Turret Control (MTC). * El MTC es un controlador separado en otra construcción. La torreta * funcionará autónomamente usando este código sin el MTC. * * El código está construido para funcionar con tres torretas, pero cada una operará independientemente. * Mucho código de depuración dejado. Usar o limpiar como se desee. Está mayormente depurado, * pero no es perfecto. Dado el precio que pagaste, ¡figuro que está bien! ;) * ================= RED ==================== */ 
#include <Wire.h> 
#include <VL53L0X.h> 
#include "Arduino.h" 
#include <SoftwareSerial.h> 
#include <Servo.h> 
#include <DFMiniMp3.h> 
#include <RF24.h> 
#include <RF24Network.h> 
#include <SPI.h> 
class Mp3Notify { 
public: 
static void OnError(uint8_t errorCode) { 
Serial.println(); 
Serial.print("Com Error "); 
Serial.println(errorCode); 
} 
static void OnPlayFinished(uint8_t globalTrack) { 
Serial.println(); 
Serial.print("Play finished for #"); 
Serial.println(globalTrack); 
} 
static void OnCardOnline(uint8_t code) { 
Serial.println(); 
Serial.print("Card online "); 
Serial.println(code); 
} 
static void OnCardInserted(uint8_t code) { 
Serial.println(); 
Serial.print("Card inserted "); 
Serial.println(code); 
} 
static void OnCardRemoved(uint8_t code) { 
Serial.println(); 
Serial.print("Card removed "); 
Serial.println(code); 
} 
}; 
Servo servo_pivot; 
Servo servo_wings; 
Servo servo_pitch; 
VL53L0X sensor; 
// Configuración para tarjeta de sonido 
SoftwareSerial secondarySerial(4, 2); // RX, TX 
DFMiniMp3<SoftwareSerial, Mp3Notify> mp3(secondarySerial); 
// Configuración para radio 
RF24 radio(10, 9); // nRF24L01 (CE,CSN) 
RF24Network network(radio); // Incluir radio en la red 
const uint64_t this_node = 01; // Esta torreta - Roja - en formato octal (04,031, etc) 
const uint64_t WHT = 02; // Torreta 02 - Blanca 
const uint64_t BLU = 03; // Torreta 03 - Azul 
const uint64_t MTC = 00; // Master Turret Control 
unsigned long previousMillis1 = 0; 
unsigned long previousMillis2 = 0; 
unsigned long previousMillis3 = 0; 
byte LED_LH_up = A1; 
byte LED_LH_down = A2; 
byte LED_CENTRE = A3; 
byte LED_RH_up = 7; 
byte LED_RH_down = 8; 
byte PIVOT = 6; //blanco 
byte WINGS = 3; //amarillo 
byte PITCH = 5; //azul 
byte parkPIVOT = 96; //Número menor rota CW visto desde arriba 
byte posPIVOT = 96; 
byte maxPIVOT = 116; 
byte minPIVOT = 76; 
byte WINGclose = 165; 
byte WINGopen = 10; 
byte WINGpos = 160; 
byte parkPITCH = 86; 
byte posPITCH = 86; 
byte maxPITCH = 96; 
byte minPITCH = 75; 
byte pos = 90; 
byte pulse = 20; 
byte pitchCW = 1; 
byte pivotCW = 1; 
byte randomWake; 
byte randomOpen; 
byte randomFalse; 
byte randomStart; 
byte randomDisengage; 
int triggerDistance = 300; 
byte buttonStatus; 
byte busyRed = 1; 
byte restModeWhite; 
byte goState; 
int x; 
int y; 
byte pb1State; // Disparar 
byte pb2State; // decir comentario aleatorio 
byte pb3State; 
byte randomPic; 
// Payload desde Master Turret Control (MTC) 
int payload [6]; 
/* Este es el mapa de "conversación" para "Chat Time". 
* 0-99 = Dichos de Torreta Roja 
* 100-199 = Dichos de Torreta Blanca 
* 200-299 = Dichos de Torreta Azul 
* Archivos en todas las tarjetas SD guardados como 0-100. 
* Sumar 100 al número de archivo aquí para Blanca, 200 para Azul. 
* Archivo 204 sería torreta AZUL, archivo número 0004. */ 
int chatSayings [] = { 
0, // Pausa inicio en i = 0, seguido de "rondas"... 
204, 164, 25, // 1 
205, 127, 76, // 2 
208, 162, 65, // 3 
143, 230, 23, // 4 
130, 41, 225, // 5 
153, 31, 133, // 6 
234, 49, 155, // 7 
229, 175, 74, // 8 
231, 58, 226, // 9 
161, 223, 59, // 10 
227, 68, 236, // 11 
136, 50, 224, // 12 
34, 160, 78, // 13 
222, 42 // Fin 
}; 
/* Este es el mapa de tiempos para torreta ROJA y BLANCA. Comparten dichos. 
* Estos tiempos corresponden al tiempo necesario 
* para reproducir los dichos individuales, en milisegundos. 
* Cambia los dichos arriba como desees, pero no cambies estos tiempos. 
* Por ejemplo, i = 2 tomará 0.8 segundos (NormalTimings[2]) 
* para reproducir el archivo chatSayings[2]. */ 
int NormalTimings [] = { 
1000, // Pausa inicio en i = 0, seguido de "rondas"... 
2600, 800, 2800, 900, 1700, 1600, 1300, 2500, 1400, 1900, // 1 - 10 
1600, 2300, 800, 3000, 300, 100, 200, 0, 0, 300, // 11 - 20 
298000, 1300, 2600, 1300, 1400, 2100, 1900, 1600, 800, 1700, // 21 - 30 
1100, 1000, 1000, 2100, 1500, 1300, 1100, 800, 1200, 1000, // 31 - 40 
2200, 1700, 1300, 1400, 1500, 1000, 2000, 500, 2700, 9000, // 41 - 50 
1100, 1200, 900, 2400, 1200, 1100, 2100, 2000, 2500, 1700, // 51 - 60 
1100, 1000, 1100, 500, 1900, 0, 1300, 2100, 1700, 900, // 61 - 70 
1100, 800, 1100, 1700, 1100, 1100, 1500, 1500, 500, 900, // 71 - 80 
2100 // 81 
}; 
/* Este es el mapa de tiempos para torreta AZUL. 
* Estos tiempos corresponden al tiempo necesario 
* para reproducir los dichos individuales, en segundos. 
* Por ejemplo, i = 2 tomará 0.9 segundos (DefectiveTimings[2]) 
* para reproducir el archivo chatSayings[2]. */ 
int DefectiveTimings [] = { 
1000, // Pausa inicio en i = 0, seguido de "rondas"... 
1700, 900, 2000, 600, 1100, 1800, 1900, 3000, 1500, 800, // 1 - 10 
2100, 800, 1900, 900, 3200, 2700, 0, 0, 0, 2000, // 11 - 20 
4400, 800, 3200, 900, 1400, 2000, 2100, 1200, 1300, 1000, // 21 - 30 
1100, 1400, 2100, 1000, 1600, 1000, 1200 // 31 - 40 
}; 
/////////////////////////////////////////////////////////////////// 
//======================= SETUP =================================// 
/////////////////////////////////////////////////////////////////// 
void setup(){ 
secondarySerial.begin(9600); 
mp3.begin(); 
mp3.setVolume(22); 
Wire.begin(); 
SPI.begin(); 
// Configuración radio 
radio.begin(); 
radio.setPALevel(RF24_PA_LOW); // radio a baja potencia. Todas cerca 
radio.setDataRate(RF24_2MBPS); // Esto funciona mejor con múltiples radios 
network.begin(70, this_node); //(canal, dirección nodo) 
sensor_read(); 
pinMode(LED_LH_up, OUTPUT); 
pinMode(LED_LH_down, OUTPUT); 
pinMode(LED_CENTRE, OUTPUT); 
pinMode(LED_RH_up, OUTPUT); 
pinMode(LED_RH_down, OUTPUT); 
digitalWrite(LED_CENTRE, HIGH); 
activate_servos(); 
servo_wings.write(WINGopen); // abrir alas 
servo_pivot.write(parkPIVOT); // park pivot 
servo_pitch.write(parkPITCH); // park pitch 
randomWake = random(1, 3); 
mp3.playMp3FolderTrack(1); // reproducir comentario despertar 
delay(2000); 
servo_wings.write(WINGclose); // cerrar alas 
delay(1500); 
digitalWrite(LED_CENTRE, LOW); 
turn_off_servos(); 
busyRed = 0; 
} 
/////////////////////////////////////////////////////////////////// 
//======================= MAIN LOOP =============================// 
/////////////////////////////////////////////////////////////////// 
void loop(){ 
while (sensor.readRangeSingleMillimeters()>triggerDistance) { 
//nada frente al sensor, no hacer nada 
ReadNet(); 
WriteNet(); 
output_sensor(); 
if (payload[5] == 1) { // Condiciones con MTC. Torreta funciona automáticamente sin MTC 
delay(500); 
WriteNet(); 
Cara_Mia(); // ¡Hora de la Ópera!! 
} else if (payload[5] == 2) { 
delay(500); 
WriteNet(); 
Chatty_time(); // ¡Hora de charla!!} 
ReadNet(); 
} else if (payload[5] == 3) { 
delay(500); 
WriteNet(); 
ManualControl (); // Control Manual 
} 
} 
if (sensor.readRangeSingleMillimeters()<triggerDistance){ //algo frente al sensor 
delay (200); //esperar antes de comprobar de nuevo si alguien sigue ahí... 
if (sensor.readRangeSingleMillimeters()<triggerDistance){ //alguien ahí (no falso positivo) 
busyRed = 1; 
ReadNet(); 
WriteNet(); 
output_sensor(); 
activate_servos(); // despertar servos 
activate(); // abrir alas y decir comentario "te veo" 
if (sensor.readRangeSingleMillimeters()>triggerDistance){ // abierto y persona se fue 
falseActivate(); //decir "¿a dónde fuiste?" y cerrar 
delay (2000); 
scanArea(); //realizar escaneo de área 
} else { // alguien definitivamente ahí - ¡abrir fuego!! 
engage(); 
delay (2400); 
for (int j=0; j <= 2; j++){ 
if (sensor.readRangeSingleMillimeters()<triggerDistance){ // mientras alguien ahí... 
for (int i=0; i <= 25; i++){ // disparar por un período corto 
fire();} // dispararles... 
output_sensor(); 
} 
} 
} 
output_sensor(); 
disengage(); // no más objetivo, dejar de disparar y preparar para cerrar 
} else { 
output_sensor(); 
delay(350); 
} 
} 
} 
// ... (resto del código con subrutinas: sensor_read, output_sensor, increment_servos, activate, falseActivate, scanArea, engage, fire, disengage, turn_off_servos, activate_servos, Cara_Mia, Chatty_time, ManualControl, ReadNet, WriteNet)

Piezas Personalizadas y Recintos

• Lens+v3b.stl
• Body-RHS+v4.stl
• Body-LHS+w+components+v4.stl
• Wing+RH+bottom+v4.stl
• Wing+RH+top+v4.stl
• Wing+LH+bottom+v4.stl
• Wing+LH+top+v4.stl
• Pitch+Frame+v4.stl
• Leg+-+REAR+v4.stl
• Infill+strips+v3.stl
• Leg+-+REAR+test.stl
• Pitch+Frame+-+modified+1.stl
• Arduino+Base+w+Radio.stl

Esquemáticos

Esquemático que hice para construir la torreta.