Creación de un avión Rc con 2 Arduino: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Hacer un avión es un desafío divertido. Se vuelve especialmente desafiante cuando usa arduino en lugar de un controlador y receptor precompilados.

En este tutorial te mostraré cómo hice un avión controlado por radio con dos arduino.

Paso 1: lo que necesitará

Necesitará:

- Un motor sin escobillas

- Una esc para el motor

- 2 servos

- 1 arduino uno

- 1 arduino nano

- una hélice

- 2 módulos nrf24l01

- 2 condensadores de 10 uf

- Cartón pluma

- Un potenciómetro

- Un módulo de joystick

- Una batería niMH de 3 amperios y 7,2 voltios

Paso 2: los controles de radio

Usé un nrf24l01 para controlar el avión. Este módulo tiene un alcance de 1 km. Puede ver cómo conectar el nrf24l01 en el esquema que se muestra arriba. También necesita soldar el capacitor entre el suelo y los 3.3 voltios para compensar las posibles caídas de voltaje.

El siguiente paso es obtener información de su controlador. Usé un joystick para los controles del timón y del elevador y un potenciómetro para el control del motor. Tienes que conectar el potenciómetro al pin A0, conecté el joystick al pin A1 y A2.

Ahora necesitamos hacer el receptor. Usé un arduino nano para el receptor porque es más pequeño. También tienes que conectar el nrf24l01 a este adruino. Después de eso, debe conectar los servos y el esc (controlador de velocidad electrónico para el motor) al arduino. Me conecté a los servos al pin D4 y D5, el esc estaba conectado al pin D9.

Este es el código que utilicé para el transmisor:

#incluir #incluir #incluir

Radio RF24 (7, 8);

dirección de byte constante [6] = "00001";

configuración vacía () {

radio.begin (); radio.openWritingPipe (dirección); radio.setPALevel (RF24_PA_MAX); radio.setDataRate (RF24_250KBPS); radio.stopListening (); Serial.begin (9600); }

bucle vacío () {

int s = analogRead (0); int x = analogRead (1); int y = analogRead (2); Cadena str = Cadena (s); str + = '|' + Cadena (x) + '|' + Cadena (y); Serial.println (str); texto char const [20]; str.toCharArray (texto, 20); Serial.println (texto); radio.write (& texto, tamaño de (texto)); retraso (10);

}

y aquí está el código para el receptor:

#incluir #incluir #incluir #incluir

Servo esc;

Servo sx; Servo sy; Radio RF24 (7, 8);

dirección de byte constante [6] = "00001";

configuración vacía () {

// ponga su código de configuración aquí, para que se ejecute una vez: radio.begin (); radio.openReadingPipe (0, dirección); radio.setPALevel (RF24_PA_MAX); radio.setDataRate (RF24_250KBPS); esc.attach (9); sx. adjuntar (4); sy.attach (5); esc.writeMicroseconds (1000); // inicializa la señal a 1000 radio.startListening (); Serial.begin (9600); }

bucle vacío () {

char text [32] = ""; if (radio.available ()) {radio.read (& texto, tamaño de (texto)); String transData = String (texto); //Serial.println(getValue(transData, '|', 1));

int s = getValue (transData, '|', 0).toInt ();

s = mapa (s, 0, 1023, 1000, 2000); // mapeo de val al mínimo y al máximo (cambiar si es necesario) Serial.println (transData); esc.writeMicroseconds (s); // usando val como señal para esc int sxVal = getValue (transData, '|', 1).toInt (); int syVal = getValue (transData, '|', 2).toInt ();

sx.write (mapa (sxVal, 0, 1023, 0, 180));

sy.write (mapa (syVal, 0, 1023, 0, 180));

}

}

String getValue (datos de cadena, separador de caracteres, índice int)

{int encontrado = 0; int strIndex = {0, -1}; int maxIndex = data.length () - 1;

for (int i = 0; i <= maxIndex && encontrado <= índice; i ++) {if (data.charAt (i) == separador || i == maxIndex) {encontrado ++; strIndex [0] = strIndex [1] +1; strIndex [1] = (i == maxIndex)? i + 1: i; }}

retorno encontrado> índice? data.substring (strIndex [0], strIndex [1]): "";

}

Paso 3: El fusionado y los estabilizadores

Ahora que tienes los dispositivos electrónicos configurados, necesitas un avión para colocarlos. Usé cartón pluma porque es liviano y relativamente fuerte. El fusualge es solo un recto que se adelgaza hacia la cola. El fusualge no es tan importante para la aerodinámica. Lo más importante es que todo encajará en él y al mismo tiempo lo mantendrá lo más pequeño y ligero posible.

El estabilizador horizontal y vertical es muy fácil de hacer. Lo único importante es que sus estabilizadores estén perfectamente rectos. Los estabilizadores son los encargados de mantener estable el avión. Cuando sus estabilizadores no estén rectos, su avión será inestable.

Paso 4: las alas

Las alas son probablemente lo más importante, necesitas crear un perfil aerodinámico para generar sustentación. En la imagen de arriba puedes ver cómo hice mi perfil aerodinámico.

Lo más importante es que el centro de gravedad del avión se encuentra alrededor del punto más alto del perfil aerodinámico. de esta forma el avión será estable.

Paso 5: Poner todo junto

Ahora que tenemos todas las partes hechas, tenemos que juntarlas todas.

Los servos deben estar conectados a los estabilizadores. esto se puede hacer con barras de control (vea la imagen de arriba)

El motor debe colocarse en un trozo de espuma y pegarse frente al avión (o usar bandas elásticas para que pueda quitarlo cuando lo necesite).

necesitas una hélice para poner el motor, el tamaño de esta hélice depende del motor. Es muy complicado calcular el tamaño óptimo. Pero una regla general es que cuanto más fuerte es el motor, más grande puede ser la hélice.

Para la batería se recomienda utilizar baterías lipo. sin embargo, estas baterías necesitan un cargador especial si no quieres que exploten. Es por eso que usé baterías nimh, estas son más pesadas pero más fáciles y baratas de usar.