Saltar al contenido
Instagram Youtube Tiktok Facebook-f

Cómo hacer un aerodeslizador

Hace bastante tiempo ya hicimos un brazo robótico, y nos apetecía hacer otro proyecto relacionado con la robótica, así que decidimos hacer un aerodeslizador capaz de mover por tierra y por agua. Por ahora es teledirigido, pero no descartamos integrarle una cámara y  hacerlo autónomo en algún momento. La verdad es que es un proyecto que se puede ampliar muchísimo. Esperemos que te guste esta primera versión, y si decides repetir el proyecto, ¡compártenoslo por Instagram a nuestra cuenta @wexter_home!

Resumen del proyecto

Como ya sabes, hemos hecho un aerodeslizador, que básicamente es un vehículo que se desliza al lanzar un chorro de aire contra la superficie que se encuentra debajo de él y le permite moverse por tierra, agua, hielo, arena y nieve. 

Para que nuestro aerodeslizador sea capaz de lanzar ese chorro de aire hemos utilizado un ventilador de PC. Para que se pueda mover hemos utilizado dos motores brushless A2212 de 1000 KV. Las hélices venían incluidas y miden 26 centímetros cada una. La verdad es que nos ha sorprendido para bien la potencia de estos motores. 

En cuanto a la estructura, la base la hemos hecho con dos laminas finas de polipropileno, y entre ellas hemos puesto perfiles de PVC. El borde de la base está hecho con coquillas aislantes. 

Consejos: utiliza un ventilador lo más potente posible. Cuanto más aire haya entre la base y la superficie, mejor se moverá. Por otro lado, cuanto más pequeño sea el aerodeslizador, menos pesará, y más rápido se deslizará, aunque si es más grande impresiona más. Tenlo en cuenta a la hora de hacer la estructura. 

Aquí tienes los diseños 3D para imprimir: diseños 3D del aerodeslizador.

Lista de materiales del aerodeslizador y el mando de control

  • 2x Motores Brushless Modelo A2212 1KV, ESC y hélices
  • Batería LiPo de 1500 mAh y 60C
  • Servomotor SG90
  • Ventilador de 4 pines
  • Transistor NPN S9013
  • 2x Arduino Nano
  • 2x Transceptores NRF24L01
  • 10x Conectores XT60, 5 macho y 5 hembra
  • 2x Laminas de polipropileno
  • 2x Perfiles de PVC
  • 3x Coquillas aislantes
  • 2x Joystick
  • Pulsador

Estos son los materiales que hemos utilizado nosotros para crear el aerodeslizador y el mando de control, pero si quieres repetir el proyecto no tienes por qué comprar exactamente los mismos componentes. 

Por ejemplo, la batería LiPo puede tener otras características, dependiendo de si quieres que sea un poco más barata o quieres más autonomía. Lo mismo ocurre con los motores brushless, puedes comprar unos más potentes o unos más baratos si es que los que hemos elegido nosotros no te convencen. 

Esquemas eléctricos

Esquema eléctrico del aerodeslizador

El primer esquema eléctrico es el del aerodeslizador. El servomotor que se encarga de mover la aleta solo tiene 3 pines, el de tierra, el de alimentación y el de la señal de control, que hay que conectarlo a un pin digital PWM. Los motores brushless tienes que conectarlos a los ESC y estos a la batería LiPo. Además el ESC tiene 3 pines más, uno de los cuales sirve para enviarle la señal que controla la velocidad de los motores. 

El ventilador es de 4 pines. Eso significa que podemos controlar su velocidad a través de un pin digital con una señal PWM. Sin embargo, no podemos parar el ventilador a través de este pin. Para poder hacer que se detenga hay que cortar su alimentación, y para ello hemos utilizado un transistor NPN. 

Por último solo hay que conectar el transceptor NRF24L01 que tiene 8 pines, 3 de los cuales hay que conectar a los pines MOSI, MISO y SCK, que en Arduino Nano son los pines 11, 12 y 13. Respecto a los otros 4 pines, 2 son Vcc y GND y los otros 2 hay que conectarlos a 2 pines digitales. En nuestro caso los hemos conectado a los pines 9 y 10. 

Esquema eléctrico mando de control

El segundo esquema eléctrico es el del mando de control. Este es bastante más fácil. Simplemente tienes que conectar VRy de un joysitck y VRx del otro joystick, un pulsador físico y el módulo NRF24L01.

Códigos

Aquí tienes tanto el código del mando como el del aerodeslizador. Simplemente asegúrate de tener todas las librerías que utilizamos instaladas y de elegir el modelo correcto de tu Arduino. Si no has utilizado los mismos pines digitales que nosotros, también tendrás que cambiar los valores de las variables que hacen referencia a ellos. Si no sabes cómo hacer todo esto, revisa nuestro post de Cómo subir un programar a Arduino.

De todas formas nosotros siempre te recomendamos leer el código y entenderlo antes de utilizarlo. Así te aseguras de que no hay ningún error y puedes modificarlo en caso de que lo necesites. 

Si quieres aprender a programar y a montar circuitos eléctricos para poder crear proyectos como los nuestros o de cualquier tipo, ¡puedes acceder a nuestro curso de Arduino desde 0!

				
					/////////////////////////////////////////////////
///////////CÓDIGO DEL AERODESLIZADOR/////////////
/////////////////////////////////////////////////

#include <Servo.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
#include <nRF24L01.h>

const int pinCE = 9;
const int pinCSN = 10;
RF24 RFreceiver(pinCE, pinCSN);
const uint64_t pipe = 0xE8E8F0F0E1LL;
int data[3] = {0, 1000, 90};

Servo brushless1;
Servo brushless2;
Servo servo;
const int fan = 6;
const int fanControl = 3;

//Prototipo de las funciones
void configure25KHzPwm();
void escCalibration();

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  RFreceiver.begin();
  RFreceiver.openReadingPipe(1,pipe);
  RFreceiver.startListening();
  brushless1.attach(7);
  brushless2.attach(8);
  servo.attach(5);
  //Timón recto
  servo.write(90);
  pinMode(fan, OUTPUT);
  pinMode(fanControl, OUTPUT);
  //Ventilador parado
  digitalWrite(fan, LOW);
  //Configurar la señal PWM del ventilador
  configure25KHzPwm();
  //Calibración de los motores brushless
  escCalibration();
}

void loop() {
  // put your main code here, to run repeatedly:
  if(RFreceiver.available()){
    RFreceiver.read(data, sizeof data);
    //Si se ha apagado el aerodeslizador o algún dato está
    //corrupto, se detiene el aerodeslizador
    if((data[0] == 0) || (data[1]<1000) || (data[1]>2000) || (data[2]<45) || (data[2]>135)){
      digitalWrite(fan, LOW);
      data[1] = 1000;
      data[2] = 90;
    }
    //Si el aerodeslizador está encendido y no hay ningún
    //dato corrupto se enciende el ventilador
    else{
      digitalWrite(fan, HIGH);
    }
    //Se controla la velocidad de los motores brushless
    brushless1.writeMicroseconds(data[1]);
    brushless2.writeMicroseconds(data[1]);
    //Se controla la posición del timon (giro del aerodeslizador)
    servo.write(data[2]);    
    
    Serial.print("On: ");
    Serial.println(data[0]);
    Serial.print("Brushless: ");
    Serial.println(data[1]);
    Serial.print("Servo: ");
    Serial.println(data[2]);
    
  }
}

void escCalibration(){
  delay(5000);
  brushless1.writeMicroseconds(2000);
  brushless2.writeMicroseconds(2000);
  delay(5000);
  brushless1.writeMicroseconds(1000);
  brushless2.writeMicroseconds(1000);
  delay(5000);
}

void configure25KHzPwm(){
  TCCR2A = 0x23;
  TCCR2B = 0x0A;
  OCR2A = 79;
  OCR2B = 79; //Ventilador siempre al máximo
}
				
			
				
					//////////////////////////////////////
///////////CÓDIGO DEL MANDO///////////
//////////////////////////////////////

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24_config.h>
#include <RF24.h>

//Módulo RF
const int pinCE = 9;
const int pinCSN = 10;
RF24 mandoRF(pinCE, pinCSN);
const uint64_t pipe = 0xE8E8F0F0E1LL;

//Controles
const int joystickVRy1 = A1;
const int joystickVRx2 = A2;
const int xButton = 8;

/*
 * El mando envía un array de tipo float que contiene
 * 3 datos:
 *  - Encendido o apagado del aerodeslizador (0 o 1)
 *  - Velocidad de los motores brushless, entre 1000
 *    (parados) y 2000 (velocidad máxima).
 *  - Giro del servomotor (timón), entre 45 y 135. 
 */
 
int data[3] = {0, 1000, 90};
bool hovercraftOn = false;
unsigned long lastTime = 0;
int threshold = 200;

//Prototipos de las funciones
void controlHovercraftSpeed(int joystick);
void controlHovercraftDirection(int joystick);

void setup() {
  // put your setup code here, to run once:
  pinMode(xButton, INPUT_PULLUP);
  mandoRF.begin();
  mandoRF.openWritingPipe(pipe);
}

void loop() {
  // put your main code here, to run repeatedly:
  if((millis()-lastTime) > threshold){
    if(!digitalRead(xButton)){
      if(hovercraftOn==true){
        hovercraftOn = false;
        data[0] = 0;
      }
      else{
        hovercraftOn = true;
        data[0] = 1;
      }
    }
    lastTime = millis();
  }
  controlHovercraftSpeed(joystickVRy1);
  controlHovercraftDirection(joystickVRx2);
  mandoRF.write(data, sizeof data);
}

void controlHovercraftSpeed(int joystick){
  int joystickLecture = analogRead(joystick);
  if((joystickLecture>520) && (joystickLecture<1024)){
    data[1] = map(joystickLecture, 520, 1023, 1000, 2000);
  }
  else if(joystickLecture < 520){
    data[1] = 1000;
  }
}

void controlHovercraftDirection(int joystick){
  int joystickLecture = analogRead(joystick);
  if((joystickLecture>=0) && (joystickLecture<1024)){
    data[2] = map(joystickLecture, 0, 1023, 45, 135);
  }
}