Programacin de un ESC con Arduino

Saludos, humano. Alguna vez has intentado calibrar un ESC con Arduino? Si lo has
hecho, habrs visto que no es nada fcil: hay que hacer todo un ritual para activar el ESC, y
despus generar un pulso para controlarlo. Adems, cada uno de estos aparatos es un
mundo y se activa de forma diferente. Yo mismo me he quebrado mis circuitos neuronales
para intentar arrancar uno. Y no es agradable.

As que para ayudarte a conservar tu estabilidad mental, te explicar como programar un

ESC con Arduino. El objetivo ser escribir un cdigo para calibrarlo y despus variar
la velocidad de un motor brushless enviando comandos por Serial (un poco a la linea de
este tutorial, pero ms simple).

Lista de piezas
Motor Brushless

Batera LiPo/NiMH: vigila que tenga voltaje, amperaje y velocidad de descarga

para soportar el motor

ESC: la razn por la que ests aqu. Yo tengo un ESC GX de 20A. Si vas a utilizar
otro modelo, asegrate de que pueda proporcionar amperaje suficiente para el motor
brushless.

Placa Arduino
 Jumpers Macho-Macho: para conectar el ESC a Arduino.

Regletas: para hacer las conexiones entre el ESC, el motor y la batera si no quieres
soldar. Necesitars tambin un destornillador.

Conexiones

Debes tener cuidado al conectar el motor. Los motores brushless tienen 3 cables, al igual
que el ESC. El cable central del motor debe ir conectado al cable central del ESC.
Sino, puedes daar los componentes.

Pero no te preocupes si giras los otros dos cables (los extremos): slo cambiar la direccin
de giro del motor.

Rituales de activacin
Los ESC se controlan mediante pulsos. Podra dedicar todo un artculo a hablar de pulsos,
pero voy a dar una explicacin rpida.
Un pulso es una seal que se enva cada cierto tiempo, normalmente cada 20ms. Si
tienes un pin digital a LOW, y cada 20ms lo pones a HIGH durante un milisegundo, ests
creando un pulso de 1ms.

Esta imagen ilustra como vara la seal de un pulso de 1ms en funcin del tiempo:

Un pulso de 1.5ms se vera as:

Los ESC se controlan con pulsos de entre 1 y 2 milisegundos. A partir de ahora, me voy
a referir a los pulsos de 1ms como pulsos de amplitud mnima y a los de 2ms como pulsos
de amplitud mxima.

Antes de empezar a funcionar, los ESC esperan recibir un pulso de activacin. Algunos se
activan si reciben un pulso de amplitud mxima durante 2-5 segundos, y otros con un
pulso de amplitud mnima durante esta misma cantidad de tiempo.

Por desgracia, los ESC estn pensados para aficionados a RC, y no a la robtica. Por eso en
la documentacin casi nunca se especifica con qu amplitud de pulso debe activarse el
controlador. Hay antiguas leyendas que hablan de ESCs bien documentados, pero yo nunca
he dado mucho crdito a estos mitos.

He aqu las especificaciones tcnicas de mi ESC:

1. Encienda la emisora y mueva la palanca de gas a su posicin ms baja.

2. Conecte el motor al variador.

 3. Conecte el variador al canal de gas en el receptor.

4. Conecte la batera de alimentacin.

5. Espere la confirmacin acstica del variador.

6. El variador est listo para su utilizacin.

Lo importante aqu es el punto 1. Los ESCs estn pensados para funcionar con mandos de
radio, y lo que este punto dice es que para activar el ESC hay que mover el mando a su
posicin ms baja. Y en su posicin ms baja, los mandos generan un pulso de amplitud
mnima (excepto algunos modelos, pero esto no viene al caso).

Por lo tanto, mi ESC se activa con un pulso de 1ms.

Si tu documentacin dice que hay que mover la palanca de gas a su posicin mxima,
significa que para activar el ESC hay que generar un pulso de 2ms.

Despus, la velocidad del motor se hace variar enviando pulsos tambin entre 1ms
(velocidad mnima) y 2ms (velocidad mxima).

Programa con Arduino

Ya sabes activar un ESC, humano. Ahora slo te queda escribir un programa con Arduino
para mover el motor brushless.

Los pulsos se generarn con la funcin servo.writeMicroseconds() de la librera Servo.h .

1 /* Programacion de un ESC con Arduino

2 *
* La velocidad del motor puede cambiarse enviando
3 * un entero entre 1000 (vel. minima) y 2000 (vel. max.)
4 * por Serial.
5 *
6 * Programa escrito por Transductor
* www.robologs.net
7 */
8 #include<Servo.h>
9
1 Servo ESC; //Crear un objeto de clase servo
0
11 int vel = 1000; //amplitud del pulso
1
2
1 void setup()
{
3 //Asignar un pin al ESC
1 ESC.attach(9);
4
1 //Activar el ESC
5 ESC.writeMicroseconds(1000); //1000 = 1ms
1 //Cambia el 1000 anterior por 2000 si
//tu ESC se activa con un pulso de 2ms
6 delay(5000); //Esperar 5 segundos para hacer la activacion
1
7 //Iniciar puerto serial
1 Serial.begin(9600);
8 Serial.setTimeout(10);
1
9
2 }
0
2
void loop()
1 {
2 if(Serial.available() >= 1)
2 {
2 vel = Serial.parseInt(); //Leer un entero por serial
3 if(vel != 0)
{
2 ESC.writeMicroseconds(vel); //Generar un pulso con el numero
4 recibido
2 }
5 }
2 }
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6

Recomiendo desconectar el ESC de la batera a la hora de hacer el upload. Justo despus de

cargar el programa vuelve a conectar la batera.

El motor emitir un pitido cuando el ESC est activado. Despus puedes enviar valores
enteros entre 1000 y 2000 para cambiar la velocidad.

Si te ha surgido algun problema durante el tutorial, puedes escribirme un comentario ms

abajo y te ayudar a resolverla.

Final de lnea.

1 /* Programacion de un ESC con Arduino

2 ** La velocidad del motor puede cambiarse enviando
3 * un entero entre 1000 (vel. minima) y 2000 (vel. max.)
4 * por Serial.
5 *
6 * Programa escrito por Transductor
* www.robologs.net
7 */
8 #include<Servo.h>
9
1 Servo ESC; //Crear un objeto de clase servo
0
11 int vel = 1000; //amplitud del pulso
1
2
1 void setup()
{
3 //Asignar un pin al ESC
1 ESC.attach(9);
4
1 //Activar el ESC
5 ESC.writeMicroseconds(1000); //1000 = 1ms
1 //Cambia el 1000 anterior por 2000 si
//tu ESC se activa con un pulso de 2ms
6 delay(5000); //Esperar 5 segundos para hacer la activacion
1
7 //Iniciar puerto serial
1 Serial.begin(9600);
8 Serial.setTimeout(10);
1
9
2 }
0
2
void loop()
1 {
2 if(Serial.available() >= 1)
2 {
2 vel = Serial.parseInt(); //Leer un entero por serial
3 if(vel != 0)
{
2 ESC.writeMicroseconds(vel); //Generar un pulso con el numero
4 recibido
2 }
5 }
2 }
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6

/
**********************************************************************
****************************
* Alberto Lpez Gass
22/12/2011 *
* www.dieBotReise.blogspot.com
*
*
alblopgas@gmail.com *
*
*
* Descripcin: Programa que controla la velocidad de un control
Brushless a travs del *
* puerto Serial usando el monitor de Arduino.
*
* Software de libre distribucion Licencia Creative
Commons 3.0 *
**********************************************************************
****************************/

#include <Servo.h>
#define PINMOTOR 8 //pin conectado al ESC, en este caso CH_5 en
ARDUPILOT corresponde al pin 8
#define MAXIMOPWM 150 // Son grados Podia llegar hasta 180,paramas
seguridad lo dejo bajo
#define MINIMOPWM 40 // por si acaso empezar con un valor
inferior, mi motor no arranca hasta 65
#define PASO 1 // Incrementos del teclado
#define BAUD 9600 //velocidad puerto serial funciona hasta 38400

int pulsoMotor;
int ordenTeclado=0;
Servo myservo; // creamos el motor como elemento en la libreria
byte recibiendoByte ;
boolean iniciado = false;
void setup()
{
Serial.begin(BAUD);
myservo.attach(PINMOTOR); // inicializo el ESC en el pin
determinado
Serial.println(" Comienzo del test"); //
Serial.println (" Pulsar 'A' para arrancar \n Cuando escuche el
pitido de confirmacin");
while ( iniciado==false ){
myservo.write(0); // Aramado
recibiendoByte = Serial.read(); // Leemos el Byte recibido
if (recibiendoByte == 65 || recibiendoByte ==97) { // A o
a Mayusculas o minusculas
iniciado=true;
}
}
Serial.println("inicio del loop principal \n Para subir controlar
velocidad pulse \n 'A' para subir \n 'Z' para bajar \n 'S'
para terminar Stop \n");
}

void loop(){

ordenTeclado =OrdenSubirBajar ();

if (ordenTeclado != 0) { // Distinto de Cero

pulsoMotor = pulsoMotor + ordenTeclado;

pulsoMotor= constrain( pulsoMotor , MINIMOPWM, MAXIMOPWM); //

myservo.write(pulsoMotor); //Mientras no hay
cambios,automaticamente se siguen enviando los mismos pulsos
Serial.print("Velocidad del pulso--> ");
Serial.println (pulsoMotor);
}

delay (150); //delay para no colapsar

}

int OrdenSubirBajar (){

int orden=0;
// Serial.flush();// Limpiamos el Bufer de entrada (evitar efecto
ametralladora)
//delay (150);
 if (Serial.available() > 0) {
recibiendoByte = Serial.read(); // Leemos el Byte recibido
if (recibiendoByte == 65 || recibiendoByte ==97) { // A o A
Mayusculas o minusculas
Serial.println( " SUBIR");
orden = PASO;
}
if (recibiendoByte == 90 || recibiendoByte ==122) { // Z o z
Mayusculas o minisculas
Serial.println( " BAJAR");
orden = -PASO;
}
if (recibiendoByte == 83 || recibiendoByte == 115){ // t o T
Mayusculas o minisculas
Serial.println( " Stop!!");
orden = -(pulsoMotor- MINIMOPWM); // Deja el pulso en
MINIMOPWM
}
}
return (orden);
}

Hola mis hermanos.

En este post trataremos sobre el como se puede controlar un motor "Brushless" (Motor
comnmente usado en aeromodelismo), con lo que podremos realizar en un futuro nuestro
propio dron hecho en casa y de bajo costo.

Los motores sin escobillas funcionan debido a un campo magntico generado en su interior,
el cual se crea a partir de sus 3 bobinas, (existen variadas formas de bobinado las mas
comunes son de estrella o triangulo), estas para ser excitadas, se tiene que dar con el ancho
de pulso exacto en cada bobina para lograr un giro completo y por consiguiente generar una
aceleracin y fuerza suficiente para nuestros proyectos.

Lo bueno es que para facilitarnos la vida existen los ESC (Electronic Speed Controller),
que en Espaol seria : control de velocidad electrnico, esta pequea herramienta nos
facilitara la labor de controlar la velocidad enviando un valor desde nuestro Arduino.

ESC
 Mas informacin You are not allowed to view links. Register or Login

Motor Brushless

Mas informacin You are not allowed to view links. Register or Login

Para controla el motor solo se tiene que cargar el siguiente cdigo en nuestro arduino

/*

rojo (GRUESO)
_____(VCC de
alimentacion del motor)
 |
potenciometro | negro
(GRUESO)
| ____(GND de
alimentacion del motor)
___(MOTOR)___________|__|_________
negro
________________ | |
___(GND)______
| | | |
| |
| _____ | __(MOTOR)____| |
__| rojo |
| / \ | | ESC |
___(VCC)___ |
| | ( ) | | | |__
|
| \_____/ | __(MOTOR)______| |
| blanco |
| | | | | |__________________| |
__(SEAL) |
| | | | |
| |
| | | | | Codigo by RREEDD
| |
| | | |______|
| |
| | | _________________
| |
| | | |d13 D12|
| |
| | | |3v3 D11|
| |
| | |A(0) |REF D10|
D9 | |
| | |_______________|A0 Arduino D9|
_____________________________________| |
| | |A1 NANO D8|
|
| | |A2 D7|
|
| | |A3 D6|
|
| | |A4 D5|
|
| | |A5 D4|
|
| | |A6 D3|
|
| | VCC |A7 D2|
GND |
| |_________________|5v GND|
____________________________________________|
|GND |RST RST|
|______________________|GND TR|
|VIN TX|
|_______________|
*/
/*
Controlling a servo position using a potentiometer (variable resistor)
by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>

modified on 8 Nov 2013

by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Knob
*/

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer

int val; // variable to read the value from the analog pin

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
val = analogRead(potpin); // reads the value of the
potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 180); // scale it to use it with the
servo (value between 0 and 180)
myservo.write(val); // sets the servo position
according to the scaled value
delay(15); // waits for the servo to get
there
}

Motor DC Brushless

Un motor DC sin escobillas o motor brushless es un motor elctrico que no emplea

escobillas para realizar el cambio de polaridad en el rotor. Los motores elctricos solan
tener un colector de delgas o un par de anillos rozantes. Estos sistemas, que producen
rozamiento, disminuyen el rendimiento, desprenden calor y ruido, requieren mucho
mantenimiento y pueden producir partculas de carbn que manchan el motor de un polvo
que, adems, puede ser conductor.

Los primeros motores sin escobillas fueron los motores de corriente alterna asncronos.
Hoy en da, gracias a la electrnica, se muestran muy ventajosos, ya que son ms baratos de
fabricar, pesan menos y requieren menos mantenimiento, pero su control era mucho ms
complejo. Esta complejidad prcticamente se ha eliminado con los controles electrnicos.

Ms informacin:

https://en.wikipedia.org/wiki/Brushless_DC_electric_motor
 https://es.wikipedia.org/wiki/Motor_el%C3%A9ctrico_sin_escobillas

Para cotrolar los motores brushless necesitaremos un ESC (Electronic Speed Control)
https://en.wikipedia.org/wiki/Electronic_speed_control

El inversor debe convertir la corriente continua de la batera o fuente de alimentacin en

alterna de una frecuencia determinada. Algunas aplicaciones seran los coches y aviones
con radiocontrol, que funciona con pilas.

Los motores brushless se usan habitualmente en los drones y son trifsicos con un variador
para controlar de forma muy exacta la velocidad del motor.
Ms informacin: https://learn.adafruit.com/adafruit-motor-selection-guide/brushless-dc-
motor-control

Servomotor

Servomotor (o tambin llamado servo) es similar a un motor de corriente continua pero con
la capacidad de posicionarse en una posicin determinada y permanecer fija en esta.
Normalmente el ngulo es de 0 a 180 grados y se alimentan a 5 voltios mnimo.

Algunos servos servos pueden alimentarse directamente desde Arduino sin necesidad de un
driver, lo que supone una ventaja. En caso de usar varios servos con un mismo Arduino,
este no podr alimentarlos y habr que usar una fuente de alimentacin externa.

Un servomotor est formado por un motor de corriente continua, una caja reductora, un
juego de engranajes, un potencimetro y un circuito de control. Puede aguantar cierto peso
a travs del par o torque del servo indicado en sus caractersticas. Normalmente se indica
con Kg/cm, que quiere decir los kilos que aguanta a 1 cm de distancia.
Para controlar un servo, se usa el PWM. La mayora de los servos trabaja en una frecuencia
de 50 Hz (20ms). Cuando se manda un pulso, la anchura de este determina la posicin
angular del servo. La anchura vara segn el servomotor pero normalmente es entre 0,5ms a
2,5ms.

En Arduino la frecuencia por defecto de PWM es de 500 Hz, pero con la librera servo
conseguimos una seal PWM con la frecuencia y duty cycle adecuada.
El Arduino utiliza la librera <Servo.h> para controlar los servos y dispone de las siguientes
funciones:

http://arduino.cc/en/Reference/Servo

http://arduino.cc/en/Reference/ServoAttach
 http://arduino.cc/en/Reference/ServoWrite

http://arduino.cc/en/Reference/ServoRead

Fuente, ms informacin y cdigo en: http://diymakers.es/controlar-servomotor-con-

mando-ir/

Ms informacin de servos:
http://platea.pntic.mec.es/vgonzale/cyr_0204/ctrl_rob/robotica/sistema/motores_servo.htm

IMPORTANTE: La librera servo soporta hasta 12 servos en la mayora de los Arduinos,

pero deshabilita el uso de PWM en los pines 9 y 10 puesto que hace uso del timer que
controla esas seales. En el caso del mega hay otras restricciones.

Ms informacin:

http://en.wikipedia.org/wiki/Servomotor

http://www.info-ab.uclm.es/labelec/solar/electronica/elementos/servomotor.htm

Video explicativo de como funciona un servo: https://www.youtube.com/watch?

v=tsrAP8EgcbQ

Todos los servos tienen 3 cables de conexin uno para alimentacin DC (normalmente 5-
6V), otro para masa y el tercero para la seal.
Los tamaos de los servos son:

Caractersticas de los servos:

Torque: determina la mxima fuerza rotacional que puede aplicar el servo, se mide
en kg.cm. Cambia a mnimo y mximo voltaje

Voltaje: mnimo y mximo

Corriente: con carga y sin carga.

Velocidad: la medida del tiempo que tarda en rotar un cierto nmero de grados, se
mide en sec/60. Es diferente a mnimo y mximo voltaje.

Tipos de servos, en funcin de cmo es procesada la seal:

 Analgico: aplica seales de voltaje on off para controlar la velocidad. El voltaje es
constante. La frecuencia est estandarizada a 50 ciclos por segundo.

Digital: tiene un microprocesador dentro que analiza la seal y la procesa en pulsos

de voltaje de alta frecuencia hasta 300 pulsos por segundo. Los pulsos sern ms
cortos en tiempo. Con esto se consigue una mayor velocidad y un torque constante.
Estos servos tienen un tiempo de respuesta mayor y una mejor capacidad de
retencin. Estos servos tiene la desventaja de un mayor consumo elctrico.

Ms informacin sobre servos analgicos y digitales:

http://www.futabarc.com/servos/digitalservos.pdf

La mayora de los servos estndar y low cost, usan un motor DC estndar de 3 polos. Hay
servos con motores de 5 polos que hace que el servo sea ms rpido en aceleracin y mayor
torque en el arranque. Pero tambin hay servos:

Coreless: el ncleo de acero es sustituido por un bobinado ligero.

Brushless. Son ms eficiente y dan ms fuerza, adems de una vida til mayor.

El consumo elctrico de un servo depende de la carga y el modelo del servo. Un servo

analgico estndar consume entre 250-700mA. Por lo tanto si alimentamos varios servos
desde el pin de 5V de Arduino es posible que nos sea posible moverlos por la limitacin en
amperios de Arduino, esa limitacin viene del regulador de tensin que alimenta el bus de
5V de Arduino. Por ejemplo en el caso de Arduino UNO el regulador es el
NCP1117ST50T3G que como puede verse en su datasheet
http://www.onsemi.com/pub_link/Collateral/NCP1117-D.PDF puede dar hasta 1 amperio,
aunque soporta picos mayores.

Algunos servos comerciales y caractersticas:

https://www.servocity.com/

https://www.servocity.com/servos/hitec-servos

https://www.servocity.com/servos/futaba-servos

Servos lineales:https://www.servocity.com/servos/heavy-duty-linear-servos

Ranuras de los servos: https://www.servocity.com/servo-spline-info

Tabla de seleccin de servos:
https://www.ia.omron.com/data_pdf/guide/14/servo_selection_tg_e_1_1_3-
13(further_info).pdf

Controladores para servos

Un servo puede controlarse directamente con un Arduino para generar la seal de control
que hemos visto anteriormente.

Tambin es posible adquirir controladores de servo y especialmente con capacidad de

radiocontrol o para manejar muchos canales.

Controladores servo de pololu: https://www.pololu.com/category/12/rc-servo-controllers

Controlador de 6 canales: https://www.pololu.com/product/1350

Controlador servo de 18 canales: https://www.servocity.com/mini-maestro-18-

channel-usb e informacin:
https://www.servocity.com/files/index/download/id/1456932868/

Torobot controlador de 32 canales para servos:

http://www.bajdi.com/torobot-32-channel-servo-controller/

http://letsmakerobots.com/files/32_Servo_Controller_Manual.pdf

http://www.elabpeers.com/32-channel-servo-controller.html

Servo de rotacin continua

Un servo de rotacin continua es un motor cuyo circuito electrnico nos permite controlar
la direccin de giro. A diferencia del servos anteriormente mencionados, no se detiene en
una posicin, sino que gira continuamente. Son muy utilizados en robtica y en muchas
aplicaciones electrnicas, como en lectores de DVD.

En un servo de rotacin continua, la funcin write() configura la velocidad del servo en

lugar del ngulo de posicin. En este caso 0 es mxima velocidad en giro contrario al
sentido horario, 180 es mxima velocidad en sentido horario y 90 motor parado.
Trucar un servo a rotacin continua: http://www.ardumania.es/trucar-servo-a-rotacion-
continua/

Servos de rotacin continua comerciales:

http://tienda.bricogeek.com/motores/118-servomotor-de-rotacion-continua-sm-
s4303r.html

https://www.servocity.com/html/hsr-
2645cr_servo__continuous_r.html#.VqiH0_nhDct

https://www.pololu.com/product/1248

Tutorial sencillo de BQ: http://diwo.bq.com/muevete-el-servo-de-rotacion-continua/