El control de mecanismos es normalmente hecho con motores y es por eso importante conocer como se pueden hacer programas para controlar motores. en este articulo aprenderemos a controlar servo motores, motores de corriente continua y motores de paso. la plataforma de Arduino disponibiliza bibliotecas listas para ser usadas en el control de motores. esto facilita su uso y rápido desarrollo de cualquier proyecto donde se requiera el uso de motores.
MIC170
La Figura 1 muestra la tarjeta Arduino Uno y su Ambiente de Desarrollo (IDE) la cual puede ser bajado de la página web de Arduino. Esta tarjeta contiene un microcontrolador ATmega328P, el cual posee una memoria FLASH de programa de 32 KBytes, Memoria RAM de 2 KBytes, Memoria EEPROM de 1 KByte y 14 entradas/salidas de propósito general ( GPIOs ). La Figura 2 muestra las entradas analógicas, salidas analógicas ( PWM ) y entradas/salidas digitales. Note que las salidas con PWM son marcadas con el símbolo ~. En este artículo controlaremos con la tarjeta Arduino motores servo, motores de corriente continua y motores de paso. Vea la Figura 3.
CONTROLANDO UN SERVO MOTOR CON LA TARGETA ARDUINO UNO.
Un servo es un motor que permite un giro de posicionamiento, normalmente entre 0 y 180 grados. Su precisión es muy alta y por eso es usado en una serie de aplicaciones como robots, juguetes, aeromodelismo, etc. En esta práctica vamos a conectar un servo a la tarjeta Arduino para ser controlado por software. Como dicho anteriormente, la plataforma Arduino tiene una biblioteca o librería lista para el control de servos. Así el programador lo único que tiene que hacer es incluirla en el proyecto y usarla. Para incluir la librería Servo en el proyecto, es necesario ir al Menú: Programa->Incluir Libreria->Servo. En la Figura 4 podemos observar el camino para llegar a este menú.
Después de incluir la librería Servo es el proyecto, es posible usar sus funciones como se muestra en el siguiente práctica, encontrada en el IDE de Arduino. El código ejemplo puede ser encontrado en el Menú: Archivo->Ejemplos->Servo->Knob. Vea la Figura 5. En esta práctica vamos a controlar la posición del servo en función de un potenciómetro.
En la Figura 6 puede observar la manera de conectar el servo en la tarjeta Arduino. El cable negro, va conectado al tierra (GND).
El cable rojo, va conectado a positivo (Vcc). El cable amarillo o blanco, va conectado a una salida digital. Para el caso de esta práctica, se ha seleccionado el pin 9. Los pulsos enviados por este pin, tienen un ancho de 20 milisegundos y dependiendo de la posición, varían este ancho. El código para esta práctica es el siguiente:
#include // create servo object to control a servo Servo myservo; // analog pin used to connect the potentiometer int potpin = 0; // variable to read the value from the analog pin int val; void setup() { // attaches the servo on pin 9 to the servo object myservo.attach(9); } void loop() { // reads the value of the potentiometer (value between 0 and 1023) val = analogRead(potpin); // scale it to use it with the servo (value between 0 and 180) val = map(val, 0, 1023, 0, 180); // sets the servo position according to the scaled value myservo.write(val); // waits for the servo to get there delay(15); }
En el comienzo de programa encontramos la línea de código:
#include
la cual le indica al compilador que va a usar la biblioteca o librería para el servo. Todas la funciones que pueden ser usadas para controlar servos, se encuentran en un archivo llamado Servo.h y compilador busca este archivo para usarlo en el proyecto.
Después creamos un objeto Servo con la línea de código:
Servo myservo;
Esta línea de código, le dice al compilador que la variable myservo va asociar un conjunto de variables y funciones. Este estilo de programación, viene de la lenguaje C++ y es muy parecido a estructuras en lenguaje C. Si quiere conocer más sobre el código de la clase Servo, puede ir a la carpeta: D:\arduino-nightly\libraries\Servo\src. En el caso del anterior camino (path), Arduino está instalado en el disco duro o partición D:
En la Figura 7 puede ver el diagrama de clases para la clase Servo y el código para declarar la clase Servo, que se encuentra en el archivo Servo.h es el siguiente:
class Servo
{
public:
Servo();
uint8_t attach(int pin);
uint8_t attach(int pin, int min, int max);
void detach();
void write(int value);
void writeMicroseconds(int value);
int read();
int readMicroseconds();
bool attached();
private:
uint8_t servoIndex;
int8_t min;
int8_t max;
};
Después de esto, definimos en que pin va a ser conectado el potenciómetro. En nuestro caso lo vamos a conectar al canal '0' del conversor análogo para digital (ADC). La línea de código para esto es la siguiente:
int potpin = 0;
Después de esto definimos una variable para almacenar el valor leído del canal análogo '0'. Para esto usamos la siguiente línea de código:
int val;
Después, encontramos en este programa ejemplo la función setup(), en la cual asignamos el pin 9 para controlar el servo. Esto es hecho con la línea de código:
myservo.attach(9);
Note que la función attach(), pertenece a la clase Servo. El código para la función setup() es:
void setup() {
myservo.attach(9);
}
Finalmente encontramos la función loop(), donde lo primero que hacemos es leer el canal analógico '0', donde está conectado el potenciómetro. Este valor, que va de 0 hasta 1023 es almacenado en la variable val. Después, escalamos o mapeamos este valor entre 0 y 180 para ser usado por el servo. Después, usamos la función myservo.write(val); para posicionar el servo de acuerdo al valor escalado. Y finalmente damos un retardo de 15 milisegundos. El diagrama de flujo para este programa puede ser visto en la Figura 8. El código para la función loop() es:
void loop() {
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
myservo.write(val);
delay(15);
}
En la IDE de Arduino también encontramos otro código ejemplo para servo motor. Este ejemplo puede ser obtenido a través de Menú: Archivo->Ejemplos->Servo->Sweep. En este ejemplo, lo que hace es girar el servo en un sentido 180 grados y luego hacerlo en el sentido contrario. La Figura 9 muestra como conectar el servo a la tarjeta Arduino. El código para este ejemplo es:
#include Servo myservo; // create servo object to control a servo // twelve servo objects can be created on most boards int pos = 0; // variable to store the servo position void setup() { myservo.attach(9); // attaches the servo on pin 9 to the servo object } void loop() { for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees // in steps of 1 degree myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position } for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position } }
En este programa usamos una función for(), muy útil cuando necesitamos crear loops o repetir algún código. La función:
for (pos = 0; pos <= 180; pos += 1)
Incrementa la variable pos hasta llegar a 180. Y por cada incremento ejecuta el código que se encuentre entre sus { }. En este caso sería:
{
myservo.write(pos);
delay(15);
}
Lo mismo ocurre para la función:
for (pos = 180; pos >= 0; pos -= 1)
Pero en este caso la variable pos es inicializada con un valor de 180 y decrementa (down counter) por cada paso por el loop for(). Así controlamos que el servo gire en un sentido y luego en el otro sentido. La Figura 10 muestra el diagrama de flujo para esta práctica.
CONTROLANDO MOTORES DE CORIENTE CONTINUA CON LA TARGETA ARDUINO UNO.
El control de motores de corriente continua normalmente se hace con puentes H. Estos circuitos permiten controlar el sentido de giro y entregan la suficiente corriente y potencia para hacer funcionar correctamente el motor. En esta práctica usaremos el circuito integrado L293, el cual tiene 2 puentes H para controlar 2 motores de corriente continua. La Figura 11 muestra como conectar un motor al circuito integrado L293 y este a la tarjeta Arduino. Son necesarias 2 salidas digitales de la tarjeta Arduino Uno para controlar el motor.
Como dicho anteriormente, el L293 tiene 2 canales para 2 motores. Vea la Figura 12. Las entradas digitales para el canal 1 son los pines 2 y 7, etiquetadas como INPUT 1 y 2. Estos pines controlan el sentido de giro y apagado de motor. Las salidas del puente H para el canal 1 son los pines 3 y 6, etiquetados como OUTPUT 1 y 2.
En estos pines es conectado el motor. El pin 1 es usado para inhibir el puente H del canal 1. Este pin también puede ser usado para aplicar una señal PWM y controlar la velocidad de giro del motor. Las entradas digitales para el canal 2 son los pines 10 y 15, etiquetados como INPUT 3 y 4. Las salidas donde se conecta el motor son los pines 11 y 14, etiquetados como OUTPUT 3 y 4. Los pines 4, 5, 12 y 13, son tierra y deben ser conectados a GND. No olvide conectar esta tierra a la tierra de la tarjeta Arduino. Los pin 8 es la alimentación de voltaje que puede ser de 10 a 15 volts dependiendo del motor. El pin 16 va a 5 volts. Este circuito integrado maneja corrientes hasta de 600 miliampères. El circuito integrado L298 puede manejar corrientes hasta de 2 ampère.
Para controlar el motor se puede observar la tabla lógica de funcionamiento de cada canal en la Figura 13. Observe que para apagar el motor, es necesario colocar las 2 entradas a nivel lógico bajo o alto.
El siguiente es código ejemplo para controlar un motor de corriente continua:
// H-Bridge input pins const int in1Pin = 10; const int in2Pin = 11; void setup() { pinMode(in1Pin, OUTPUT); pinMode(in2Pin, OUTPUT); } void loop() { digitalWrite (in1Pin, HIGH); digitalWrite (in2Pin, LOW); delay (4000); digitalWrite (in1Pin, LOW); digitalWrite (in2Pin, LOW); delay (2000); digitalWrite (in1Pin, LOW); digitalWrite (in2Pin, HIGH); delay (4000); digitalWrite (in1Pin, LOW); digitalWrite (in2Pin, LOW); delay (2000); }
Este código es muy simple. Primero configuramos los pines 10 y 11 como salidas digitales. Esto lo hacemos en el inicio del programa y en la función setup(). El código para hacer esto es:
const int in1Pin = 10;
const int in2Pin = 11;
pinMode(in1Pin, OUTPUT);
pinMode(in2Pin, OUTPUT);
Luego en la función loop(), giramos el motor en un sentido y lo retardamos por 4 segundos. Después apagamos el motor por 2 segundos. Luego hacemos girar el motor en el otro sentido y retardamos más 4 segundos. Finalmente apagamos el motor por 2 segundos y repetimos el bucle. El diagrama de flujo para esta práctica puede ser visto en la Figura 14.
CONTROLANDO UN MOTOR DE PASO UNIPOLAR O BIPOLAR CON LA TARGETA ARDUINO UNO.
Motores de paso permiten un grado de precisión alto en su posicionamiento. Usado ampliamente en impresoras, escáner, robots, mecanismos, etc. Básicamente existen 2 clases de motores de paso. Los bipolares tienen apenas 4 cables y la forma de conectarlos a la placa Arduiono puede ser vista en la Figura 15.
Aquí usamos el circuito integrado L293 para controlar la potencia del motor. Si el motor es unipolar, él tiene 5 o 6 cables. La Figura 16 muestra como conectar este motor a la tarjeta Arduino, usando un circuito integrado ULN2003, como amplificador de potencia. Este motor tiene 2 pares de bobinas y cada bobina tiene una conexión al centro.
Es posible identificar los pares usando un multímetro. Mida la resistencia a través de pares de cables, para encontrar los 2 pares de cables que tienen la máxima resistencia. El cable del centro debe tener la mitad de la resistencia de toda la bobina. Motores con solo 5 cables tienen los centros de las bobinas conectados a un solo cable.
En la Figura 17 podemos ver el menú para código ejemplo para motores de paso. El menú para esta práctica es: Archivos->Ejemplos->Stepper->stepper_oneRevolution. El siguiente código puede ser usado para controlar cualquier motor de paso:
#include // change this to fit the number of steps per revolution for your motor const int stepsPerRevolution = 200; // initialize the stepper library on pins 8 through 11: Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11); void setup() { // set the speed at 60 rpm: myStepper.setSpeed(60); // initialize the serial port: Serial.begin(9600); } void loop() { // step one revolution in one direction: Serial.println("clockwise"); myStepper.step(stepsPerRevolution); delay(500); // step one revolution in the other direction: Serial.println("counterclockwise"); myStepper.step(-stepsPerRevolution); delay(500); }
El programa anterior lo que hace es girar el motor en una dirección y luego de un retardo, lo hace girar en la otra dirección. La Figura 18 muestra el diagrama de flujo para esta práctica. El programa puede ser usado para manejar tanto un motor de paso bipolar, como también un motor unipolar.
El motor es conectado a los pines 8, 9, 10 y 11 de la placa Arduino Uno. Dependiendo del número de pasos del motor que esté usando en esta práctica es necesario definirlo en la línea de código:
const int stepsPerRevolution = 200;
Para este ejemplo usamos un motor con 200 pasos por vuelta.
La IDE de arduino tiene una clase lista para controlar motores de paso llamada Stepper. Al igual que con la clase Servo, lo único que tenemos que hacer para usarla es incluirla en el proyecto. Para hacer esto vaya al menú: Programa->Incluir Libreria->Stepper. La Figura 19 muestra el menú para incluir la librería. La siguiente línea de código, declara una variable myStepper, y los pines usados para el motor, son el 8, 9, 10 y 11.
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
Como podemos observar, manejar motores es muy fácil con la targeta Arduino. Tenga en cuenta las potencias de los motores y la potencia de circuito controlador (driver).