Construimos un dirigible teledirigido de 2 metros de largo
El otro día estábamos viendo una película sobre la primera guerra mundial y vimos que los militares utilizaban los dirigibles y pensamos que cómo era eso posible si en principio con una sola bala le haces un agujero y lo derribas al instante. Bueno pues nos entró la curiosidad así que decidimos construir nuestro propio dirigible y comprobarlo nosotros mismos.
Resumen del proyecto dirigible
El principio de funcionamiento de un dirigible es básicamente el de un globo lleno de helio. Como el helio pesa menos que el aire, tiende a subir hacia arriba. Un decímetro cúbico de helio es capaz de levantar un gramo de peso. Por lo tanto, cuanto menos pese el dirigible y más helio pueda almacenar en su «globo», más fácil le será volar.
Como conseguir el menor peso posible es muy importante, hemos utilizado varillas de fibra de carbono para hacer la estructura y plástico de 32 micras de espesor para el «globo». La base del dirigible en nuestro caso es un helicóptero de juguete desmontado. Si no tienes uno podrías imprimir una base sencilla o usar una pequeña cesta que pese poco.
De todas formas, aunque el dirigible pueda elevarse solo gracias al helio, necesita de motores y hélices para poder controlar su trayectoria. Nosotros hemos usado unos pequeños motores de corriente continua. Ten en cuenta que normalmente, cuanto más potentes sean los motores más pesan, y por lo tanto más grande tendrá que ser el dirigible para poder almacenar más helio y elevarse.
En cuanto al control, hemos reutilizado el mando del aerodeslizador. Este mando tiene un transceptor de radiofrecuencia que se comunica con otro transceptor que tiene el dirigible, el cual está conectado a un Arduino Nano. Cuando el Arduino recibe la información se encarga de controlar la velocidad de los motores de corriente continua y los servomotores.
Los servomotores sirven para poder poner los motores de corriente continua en tres posiciones diferentes. Hacia abajo para bajar el dirigible, rectos para ir hacia delante, hacia atrás o girar y hacia arriba para elevarlo más fácilmente.
Lista de materiales del dirigible
El resto de materiales los compramos en tiendas locales. La estructura la hicimos con 20 varillas de fibra de carbono de 50 centímetros y 4 varillas de 100 centímetros. Cuanto más finas sean mejor. Nosotros las encontramos en una tienda deporte. Las venden para las tiendas de campaña.
Para el globo usamos plástico de 4 x 3 metros y 34 micras de espesor. El helio lo encontramos en una tienda online. Compramos dos garrafas, una grande de 0,36 metros cúbicos y otra de 0,14 metros cúbicos. Sin duda es lo más caro del dirigible. Te recomendamos que realices una búsqueda en Internet por si puedes encontrarlo más barato.
Y por último en cuanto a la base, ya sabes que nosotros utilizamos un helicóptero desmontado pero podrías utilizar una pequeña cesta, una base sencilla impresa en 3D o incluso una bolsa.
Lista de materiales del mando de control
Recomendamos utilizar un joystick de mando de PS4 porque los típicos joysticks que se utilizan con Arduino tienen muy poca sensibilidad y no son muy buenos.
Esquemas eléctricos
Como puedes ver los esquemas eléctricos no tienen ningún misterio. En el dirigible todo está alimentado por la batería excepto el transceptor RF que se alimenta con 3.3V desde el Arduino Nano. Los motores de corriente continua los controlamos con Arduino a través de un driver ya que consumen demasiada corriente para conectarlos directamente al microcontrolador.
Los servos se controlan mediante señales PWM con Arduino. En cuanto al mando de control, simplemente es un joystick, tres botones, otro transceptor RF, un Arduino y la batería.
Código del dirigible y del mando de control
Este proyecto tiene dos programas, el primero que es el del mando de control y el segundo que es para el dirigible. Si realizas las conexiones exactamente igual que nosotros no necesitas hacer ningún cambio. Si haces algún cambio tendrás que modificar el valor de la variable que haga referencia a la conexión que cambies.
Si quieres aprender a modificar código y crearlo desde 0, puedes entrar a nuestro curso de programación y electrónica con Arduino.
Curso de Arduino desde Cero
Aprende programación y electrónica de forma rápida y sencilla con Arduino para que puedas montar tus proyectos tecnológicos lo antes posible.
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
//Módulo RF
const int pinCE = 9;
const int pinCSN = 10;
RF24 radio(pinCE, pinCSN);
const uint64_t pipe = 0xE8E8F0F0E1LL;
/*
* Primer dato: grados de cada servo.
* Segundo dato: Velocidad motor izquierda
* Tercer dato: Velocidad motor derecha
* Cuarto dato: Hacia delante (0) o hacia atrás (1)
*/
int data[4]= {90, 0, 0, 0};
unsigned long lastTime = 0;
int threshold = 100;
//Controles
const int LEFT_JOYSTICK_VRY = A3;
const int RIGHT_JOYSTICK_VRX = A2;
const int GO_DOWN_L1 = 3;
const int GO_UP_R1 = 2;
const int GO_STRAIGHT_ARROW_UP = 6;
void setup(void){
delay(1000);
Serial.begin(9600);
delay(1000);
pinMode(GO_DOWN_L1, INPUT_PULLUP);
pinMode(GO_UP_R1, INPUT_PULLUP);
pinMode(GO_STRAIGHT_ARROW_UP, INPUT_PULLUP);
radio.begin();
radio.openWritingPipe(pipe);
}
void loop(void){
if((millis()-lastTime) > threshold){
lastTime = millis();
if(!digitalRead(GO_DOWN_L1))
data[0] = 180;
else if(!digitalRead(GO_UP_R1))
data[0] = 0;
else if(!digitalRead(GO_STRAIGHT_ARROW_UP))
data[0] = 90;
controlDirigible();
Serial.println(data[2]);
radio.write(data, sizeof data);
}
}
void controlDirigible(){
int right_vrx_lecture = analogRead(RIGHT_JOYSTICK_VRX);
int left_vry_lecture = analogRead(LEFT_JOYSTICK_VRY);
if(right_vrx_lecture > 525 && right_vrx_lecture <= 1023){
data[1] = 0;
data[2] = map(right_vrx_lecture, 525, 1023, 100, 255);
}
else if(right_vrx_lecture < 500 && right_vrx_lecture >= 0){
data[1] = map(right_vrx_lecture, 500, 0, 100, 255);
data[2] = 0;
}
else if(left_vry_lecture > 525 && left_vry_lecture <=1023){
data[1] = map(left_vry_lecture, 512, 1023, 100, 255);
data[2] = data[1];
data[3] = 0; //Hacia delante
}
else if(left_vry_lecture < 500 && left_vry_lecture >= 0){
data[1] = map(left_vry_lecture, 500, 0, 100, 255);
data[2] = data[1];
data[3] = 1; //Hacia atrás
}
else{
data[1] = 0;
data[2] = 0;
data[3] = 0;
}
}
#include <Servo.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
#include <nRF24L01.h>
const int pinCE = 2;
const int pinCSN = 4;
RF24 radio(pinCE, pinCSN);
const uint64_t pipe = 0xE8E8F0F0E1LL;
int data[4] = {90, 0, 0, 0};
Servo left_servo;
Servo right_servo;
const int AIA = 3;
const int AIB = 5;
const int BIA = 7;
const int BIB = 6;
byte servos_angle = 90;
byte left_motor_speed = 0;
byte right_motor_speed = 0;
void setup() {
// put your setup code here, to run once:
delay(1000);
Serial.begin(9600);
delay(1000);
radio.begin();
radio.openReadingPipe(1,pipe);
radio.startListening();
pinMode(AIA, OUTPUT);
pinMode(AIB, OUTPUT);
pinMode(BIA, OUTPUT);
pinMode(BIB, OUTPUT);
left_servo.attach(9);
right_servo.attach(10);
left_servo.write(servos_angle);
right_servo.write(servos_angle);
}
void loop() {
// put your main code here, to run repeatedly:
if(radio.available()){
radio.read(data, sizeof data);
servos_angle = data[0];
left_motor_speed = data[1];
right_motor_speed = data[2];
left_servo.write(180-servos_angle);
right_servo.write(servos_angle);
cc_motors_handler();
}
delay(50);
}
//CONTROL MOTORES DE CORRIENTE CONTINUA
void cc_motors_handler(){
if(data[3] == 0){
analogWrite(AIA, 0);
analogWrite(AIB, left_motor_speed);
analogWrite(BIB, right_motor_speed);
}
else{
analogWrite(AIA, right_motor_speed);
analogWrite(AIB, 0);
analogWrite(BIB, 0);
}
}
