Apéndice del ejercicio 3: señales de control RC

Los elementos de radio control (RC a partir de ahora) nos brindan grandes ventajas a la hora de trabajar con ellos. Por ejemplo un servo de RC es la forma más sencilla de agregar un actuador mecánico a nuestro proyecto y están disponibles en tal variedad que es poco probable que no encontremos un modelo que se acople a nuestras necesidades. Otro ejemplo son los ESC o variadores que en RC se encargan de controlar los motores y en nuestro proyecto pueden hacer lo mismo dándonos un control sobre motores DC o brushless de cualquier tamaño e incluso, según el modelo que escojamos, con inversión de giro.

Los elementos de control de RC se comunican entre ellos mediante una señal de control de unas características muy concretas: se emiten pulsos de entre 1 y 2 milisegundos con una separación de 20 milisegundos entre sus flancos de subida.

arduino servo señal control

Según la anchura de ese pulso el elemento de RC al que se lo mandemos hará una cosa u otra. Por ejemplo los servos se posicionarán en un ángulo de 0º (posición de referencia) si el pulso es de 1ms, buscarán la posición central (90º) si el pulso es de 1’5ms y se establecerán en la posición final (180º) si el pulso es de 2ms.

Un ESC (Electronic Speed Controler) o variador adaptará la salida de potencia hacia el motor según este ancho de pulso y según sea para aviones o coches se comportará de una forma u otra (los aviones no necesitan inversión de giro, los coches si). Así un variador para aviones dejará los motores parados en la posición de 0º e irá aumentando la velocidad a medida que aumentemos el ángulo que le transmitamos, mientras que un variador para coches mantendrá el motor parado en la posición de 90º y aumentará la velocidad en los rangos de 90º a 0º y en el de 90º a 180º pero en sentidos diferentes.

El movimiento se demuestra andando, así que vamos a generar señales de control de RC desde nuestra Arduino UNO. La forma más sencilla es recurrir a la librería servo.h que viene con el IDE.

Para ello solo tenemos que hacer una llamada a la librería en el bloque inicial del Sketch:

1
#include <Servo.h>

Luego creamos un objeto para cada elemento que queramos controlar con una señal de control RC

1
Servo miActuador;

En el setup() conectaremos el objeto miActuador a un pin digital

1
miActuador.attach(7);

Se puede conectar a cualquiera, yo he puesto el 7 por que no está marcado como PWM. Llegado a este punto es hora de una pequeña aclaración: la señal de control RC se genera por software, por lo que se puede emitir por cualquier pin digital de Arduino. No tiene nada que ver con los pines marcados como PWM (aclaración completa al final del apéndice).

Luego en el loop() solo tenemos que insertar allí donde sea necesaria una línea con el comando de llamada al objeto que hemos creado y le decimos en que posición queremos que se ponga:

1
miActuador.write(posicion);

El valor de posición puede ser un número o una variable previamente declarada y que contenga un entero del rango requerido, es decir, entre 0 y 180. Y ya está, así de sencillo.

Es más, la señal de control de RC se puede definir como una sucesión de pulsos (de entre 1 y 2 milisegundos) separados por una pausa de 20 milisegundos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int lectura; // variable que almacenara el valor leído del potenciómetro.
int salida = 9; // pin por el que mandaremos un tren de pulsos
int pulso; // contendra la anchura del pulso

void setup()
{
pinMode(salida, OUTPUT);
}

void loop()
{
lectura = analogRead (A0); // leemos el pontenciometro
pulso = map(lectura, 0, 1023, 1000, 2000); // calculamos el ancho del pulso en microsegundos
digitalWrite(salida, HIGH); // activamos el pin de salida
delayMicroseconds(pulso); // esperamos el tiempo que dura el pulso en microsegundos
digitalWrite(salida, LOW); // desactivamos el pin de salida
delayMicroseconds(20000); // PAUSA de 20 milisegundos
}

Se aparta de lo que es la defición tanto de PWM como de la señal de control RC pero funciona siempre que el pulso se mantenga dentro del rango de 1 a 2 ms. Este mismo sketch puede ser modificado muy fácilmente para que la pausa (el ciclo bajo) se ajuste a la duración requerida para que entre los flancos de subida de la señal el tiempo sea de 20ms, lo dejo como un ejercicio para que os entrenéis en el bello arte de la programación.

Ahora vamos a hacer la acción contraria, supongamos que queremos leer una señal de RC que proviene de un receptor. La forma más sencilla es que a través de un pin digital cronometremos el pulso mediante el comando pulseIn().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int entrada = 7; // pin en el que meternos la señal que viene del receptor
unsigned long pulso; // variable en la que almacenaremos la lectura

void setup()
{
pinMode(entrada, INPUT); // configuramo el pin como entrada
Serial.begin(9600); // habilitamos puerto serie
}

void loop()
{
pulso = pulseIn(entrada, HIGH); // leemos el pulso
Serial.println(pulso); // mandamos el dato al monitor serie
delay(500); // pausa para no volver loco al monitor serie
}

Este sencillo sketch nos devolverá por el puerto serie la duración del pulso en microsegundos. Se trata de una función muy útil si queremos aplicar control PID o realizar cualquier otra operación con canales como su mezcla, inversión o cambiar su linealidad por una curva exponencial.

Dentro de los receptores de RC existe una línea de comunicación entre la parte que recibe la señal de radio y la parte que separa la señal de control en sus respectivos canales, por lo que es posible leer todos los canales con un solo pin digital. Pero eso depende mucho del tipo de receptor utilizado, más ahora que se imponen los receptores de 2,4GHz con protocolos propietarios. Así que este método lo dejaremos de momento para el nivel “avanzado”.

Vamos con las puntualizaciones:

¿Esta señal de control es PWM? Técnicamente si, se trata de una señal PWM con una frecuencia de 50Hz y un pulso comprendido entre 1 y 2 milisegundos. Es de unas características tan determinadas que en mi opinión se aparta de la definición general de PWM y no debe llamarse así para no confundir a los usuarios de Arduino con menos experiencia.
¿Tiene algo que ver con los pines marcados como PWM en la placa Arduino? No, los pines marcados como PWM en la placa Arduino tienen como función simular salidas analógicas mediante el comando analogWrite(), la frecuencia de funcionamiento de la señal PWM de Arduino es de 416Hz y el ancho de pulso puede ir del 0% al 100%, por lo que no es ni parecida a la señal de control de RC.
Desde Arduino podemos emitir una señal de control RC por cualquiera de sus pines digitales, no necesariamente marcado como PWM, es más, utilizar los pines marcados como PWM no nos aporta ninguna ventaja pues la señal de control RC se genera por software.
De la misma forma para leer una señal de control RC con un Arduino no se puede hacer desde los pines de entrada analógicos, si no que debe hacerse por software mediante el comando pulseIn().

2 Comments

  1. Pingback: Arduino | Tutorial | Servos | señal de control RC | Ardumanía

  2. arduino es lo maximo

Deja un comentario

Required fields are marked *.