You are on page 1of 27

Material

-Arduino Uno
-Motor DC
-Potenciómetro
-L293D (driver motores)
-Fuente alimentación externa

Motor DC
Un motor de corriente continua convierte la energía eléctrica en
mecánica. Se compone de dos partes: el estator y el rotor.
El estator es la parte mecánica del motor donde están los polos del imán.
El rotor es la parte móvil del motor con devanado y un núcleo, al que
llega la corriente a través de las escobillas.
Cuando la corriente eléctrica circula por el devanado del rotor, se crea un
campo electromagnético. Este interactúa con el campo magnético del
imán del estator. Esto deriva en un rechazo entre los polos del imán del
estator y del rotor creando un par de fuerza donde el rotor gira en un
sentido de forma permanente.
Si queremos cambiar el sentido de giro del rotor, tenemos que cambiar
el sentido de la corriente que le proporcionamos al rotor; basta con
invertir la polaridad de la pila o batería.

L293D
Para controlar un motor DC desde Arduino, tendremos que usar un driver
para motores para proporcionarle más corriente al motor ya que las
salidas del Arduino sólo dan 40mA. De esta manera, con el driver
podemos alimentar el motor con una fuente de alimentación externa.
El L293D es un integrado para controlar motores DC que usa el sistema
puente en H. ¿Qué es el puente en H? Es un sistema para controlar el
sentido de giro de un motor DC usando cuatro transistores. En la imagen
vemos que los transistores se comportan como interruptores y
dependiendo que transistores conducen y cuáles no cambia la
polarización del motor, y con esto el sentido de giro.

5V y 36V tal y cómo pone en el datasheet. Pero ¿y la velocidad de giro? En este proyecto lo que haremos es controlar la velocidad y el giro del motor con un solo potenciómetro. los pins 3 y 6 son las salidas y se conectan a los bornes del motor. Y los pins 2 y 7 son las entradas donde conectaremos las salidas del Arduino. En el datasheet también hay el esquema que vamos a usar. Nosotros usaremos la parte de la izquierda (los diodos externos en el L293D están dentro). . Cómo se aprecia en la imagen.El L293D tiene dos puentes H y proporciona 600mA al motor y soporta un voltaje entre 4. Control velocidad a través de PWM Hasta este punto sabemos cómo controlar el sentido de giro del motor DC a través del L293D. Dependiendo que valor ponemos entre los pins 2 y 7 el motor girará en un sentido o en otro.

. en el otro PWM el mismo pulso sea valor bajo.Para hacerlo utilizaremos el PWM (véase PWM). En estas dos salidas habrá un PWM a cada una. ¿Qué quiere decir invertir? Pues que cuando en un PWM tengamos un pulso a un valor alto. Pero tenemos que invertir un PWM. En la imagen lo entenderemos de una manera más gráfica. Sabemos que hay que atacar los pins 2 y 7 del L293D desde dos salidas del Arduino.

MONTAJE .

-Pins 4. -Juntar las masas del Arduino y de la fuente de alimentación externa.5. .13 del L293D a masa.12.

//Variable del PWM 2 void setup() { //Inicializamos los pins de salida pinMode(pin2. 1023. el rango va de 0 a 1023. 0. //Entrada 2 del L293D int pin7=10. la salidas del Arduio son de 8 bits. //En cambio.diymakers. //Variable que recoge el valor del potenciómetro int pwm1. 0. //Por esta razón tenemos que mapear el número de un rango a otro usando este código. } void loop() { //Almacenamos el valor del potenciómetro en la variable valorpote=analogRead(pote). rango entre 0 a 255. pwm2 = map(valorpote. //Entrada 7 del L293D int pote=A0.García Control velocidad y sentido motor DC Tutorial en: http://diymakers. //El PWM 2 está invertido respecto al PWM 1 //Sacamos el PWM de las dos salidas usando analogWrite(pin.pwm1). analogWrite(pin7. //Potenciómetro int valorpote. Es el voltaje que proporciona al motor. 0). Es la alimentación del L293D. pinMode(pin7. -El potenciómetro pude ser de cualquier valor.pwm2).-Pin 8 del L293D a 9V de la fuente de alimentación externa.es by A. //Variable del PWM 1 int pwm2. pwm1 = map(valorpote.es/control-velocidad-y-sentido-de motor-dc/ */ int pin2=9.OUTPUT). pude alimentarse directamente desde la alimentación que proporciona el Arduino. } . PROGRAMA /* www. OUTPUT). 0. quiere decir. 255). //Como la entrada analógica del Arduino es de 10 bits. 255. -Pin 16 del L293D a 5V.valor) analogWrite(pin2. 1023.

 aprender a controlar motores de corriente continua y controladores de motores basados en puentes H. El SN754410 es un dispositivo más moderno y por lo tanto tiende aser más barato de comprar.ROBOT CON 2 MOTORES DE CC Y L293D (O SN754410) 22 FEBRERO. por lo que se puedenintercambiar entre ellos sin ningún cambio de hardware / código.6Apara el L293D. El controlador de motor L293D y el controlador del motor SN754410tienen exactamente las mismas salidas de pin. 2016 JADIAZ 1 COMENTARIO Objetivos  Con el integrado L293D control de un robot. asegúrate de comprar uno conla ‘D’ al final. Laúnica diferencia es que SN754410 puede suministrar 1A frente 0. El L293D. ya que tiene los diodos internos y no es necesario añadirningún componente externo. Material requerido .

 Una Protoboard. Esta sesión acepta cualquier otro modelo de Arduino. Arduino Uno o similar.  Chasis del robot  Un H bridge integrado L293D  Algunos cables de Protoboard. .

El esquema. int motorA1 = 6. pero conectando el segundo motor.  Dos motores de corriente continúa. El esquema será exactamente igual al de la entrada anterior. . El programa. //Testeando Motores con L293D //Definimos pins //Motor A int enableA = 5.

delay (1000). OUTPUT). HIGH). OUTPUT). void setup() { Serial. int motorB1 = 9. pinMode (motorB1. digitalWrite (enableB. OUTPUT).println (“Activamos motores”). OUTPUT).begin (9600). pinMode (motorA1. digitalWrite (enableA. OUTPUT).int motorA2 = 7. OUTPUT). int motorB2 = 10. pinMode (motorB2. } void loop() { //activamos motor A Serial. //Nos movemos . pinMode (motorA2. pinMode (enableB. //Motor B int enableB = 8. //configuración pinMode (enableA. HIGH).

//stop digitalWrite (enableA. //Durante 3 segundos delay (3000). digitalWrite (motorB1. . LOW). digitalWrite (motorB2.LOW). Escribiremos código para controlar mediante ordenador el robot con 2 motores CC desde el puerto serie.println (“Hacia delante”). digitalWrite (motorA2.println (“Paramos motores”). delay (3000). Serial.LOW). } Pero podemos mejorar esta programación. //Durante 3 segundos delay (3000).println (“Hacia atrás“). Serial. HIGH). LOW). digitalWrite (motorA1. digitalWrite (enableB. LOW). digitalWrite (motorA2. LOW).HIGH). digitalWrite (MotorB1.HIGH). digitalWrite (MotorB2. HIGH). Serial. digitalWrite (motorA1.

LOW). digitalWrite (dirmotorB1.HIGH).HIGH). .LOW).// gira motor B izquierda digitalWrite (dirmotorB2. //Métodos para el control adelante.LOW). // declaración de variables char val. // direccion motor a int dirmotorA2= 7. analogWrite (enableB. velocidad).HIGH).// gira motor A derecha digitalWrite (dirmotorA2. // direccion motor b int dirmotorB2= 10. derecha // izquierda y stop void adelante(){ digitalWrite (dirmotorA1. velocidad). int enableA = 5. //velocidad motor A int dirmotorA1 = 6.// gira motor B derecha digitalWrite (dirmotorB2. analogWrite (enableA. analogWrite (enableA. // direccion motor a int enableB = 8.HIGH). digitalWrite (dirmotorB1. velocidad). atras. //velocidad motor B int dirmotorB1 = 9. // direccion motor b int velocidad = 120. } void atras(){ digitalWrite (dirmotorA1.LOW).// gira motor A izquierda digitalWrite (dirmotorA2.

LOW).HIGH). analogWrite (enableB. 0).LOW).HIGH).// para motor A digitalWrite (dirmotorA2. analogWrite (enableB.// para motor B digitalWrite (dirmotorB2. 0). } void izquierda(){ digitalWrite (dirmotorA1.analogWrite (enableB.// gira motor A izquierda digitalWrite (dirmotorA2. . analogWrite (enableB.velocidad). } void paro(){ digitalWrite (dirmotorA1.HIGH).// gira motor B izquierda digitalWrite (dirmotorB2. digitalWrite (dirmotorB1. velocidad).LOW).HIGH).HIGH).// gira motor A derecha digitalWrite (dirmotorA2.HIGH).// gira motor B derecha digitalWrite (dirmotorB2. velocidad). } void derecha(){ digitalWrite (dirmotorA1. velocidad). digitalWrite (dirmotorB1. velocidad).LOW).HIGH). analogWrite (enableA.HIGH). digitalWrite (dirmotorB1. analogWrite (enableA. analogWrite (enableA.

6.available() ) { val = Serial. } switch (val) { case ‘s’: paro().10.begin(9600). } // Y el bucle principal void loop() { if( Serial.8. . break. break. case ‘a’: adelante(). for(i=5.7.i++){ pinMode(i.read(). paro().} // comenzamos parando los motores void setup(){ int i.i<11.11 de salida } Serial.9. OUTPUT). break. //poner pin 5. case ‘r’: atras().

2 x Arduino UNO o equivalente. . case ‘d’: derecha().. MATERIAL REQUERIDO. case ‘i’: izquierda(). } } OBJETIVOS o Mostrar la aplicación practica de los L293d para montar un control de apertura de una puerta motorizada de garaje. o Presentar los módulos RF de 433 MHz. break. break. o Ver su comportamineto como emisor y receptor.

1 x LED rojo Un H bridge integrado L293D Un pulsador una pareja de módulos RF 433 MHz fuente de alimentación externa para el motor .2 x Protoboard . Algunos cables de protoboard.

pertenecientes a la banda UHF de 70 cm. transmisores para conferencias. como los mandos de garaje.MODULOS SENCILLO DE RF Estos módulos. En la imagen superior. etc. dispositivos inalámbricos de TV. se pueden ver el módulo transmisor (izquierda) y el módulo receptor (derecha). . La transmisión de datos es en modo simplex (unidireccional) y a una velocidad no superior a 10 Kbps. Estas antenas se pueden comprar o hacerla uno mismo. las cuales hay que añadir soldándolas en los respectivos puntos marcados como “ANT”. que en 433 MHz corresponde a unos 17 cm (También se suele ver como 16. Trabajan con una frecuencia de radio de 433 MHz.5 cm). Nosotros usaremos 30 cm para el transmisor. son utilizados para radio control. de tipo látigo y para el receptor la tipo helicoidal. No traen antenas. la cual comparte segmentos con otros servicios y aplicaciones. de muy bajo costo. Antenas Las antenas para estos módulos suelen ser de 1/4 de la longitud de onda.

Luego la estiraremos un poco. Se puede montar los módulos sobre un soporte para elevarlos del plano de tierra. Deben estar alejadas de cables o similares pues pueden afectar a la transmisión. Se puede probar con otras medidas en la antena emisora y receptora. Es importante no acercar cables de alimentación o fuentes de ruido (motores) a las antenas. No se ha comprobado mayor distancia por limitación de espacio. y así alejarlos de cableado y demás. cogeremos 30 cm de cable rígido y pelando un poco uno de sus extremos.Para el transmisor. los arrollamos alrededor de un bolígrafo o similar. dejando un pequeño extremo en una punta para soldar y en la otra punta 1 cm aproximadamente. El alcance conseguido con las medidas expuestas en el montaje fué de 10 metros en interior. Se pueden hacer ensayos con otras medidas en base a los 17 cm. El cable debería quedar perpendicular al suelo Para el receptor. pero las diferencias parecen ser poco significativas. procedemos a soldarlo en la zona indicada como “ANT”. y mejorar la emisión y recepción de la señal: . cogemos los 30 cm restantes.

5V y 12V.5V. en cambio el receptor sólo admite 4. aunque se puede probar con otros voltajes para mayor potencia y alcance.3V para evitar la influencia del ruido.5V y 5. no superando los 12V. TRANSMISOR A Vcc .5mA.Alimentación El transmisor admite voltajes entre 3. El consumo es mínimo. teniendo el transmisor una potencia de 25mW a 12V y el receptor un consumo de unos 5. GND y datos. con lo que sólo necesitamos un pin para cada Arduino. El receptor lo alimentaremos con 5V. Conexiones Las conexiones son muy simples: Vcc. Se recomienda alimentar el transmisor con 3.

Pata derecha del pulsador a GND. . Data GND Resistencia entre Vcc y pata izquierda del pulsador. Pin 7 a la pata izquierda del pulsador.

16 Pin 2 Pin 7 Pin 3 y 6 A Pin 4 y 5 8 Al positivo de la fuente ali . 9. Se obtuvo mejor resultado con una de 330 Ohm Las conexiones del módulo receptor son algo más laboriosas: RECEPTOR A Vcc Data GNG LED Y para el control del motor L293D A Pin 1.Nota: La resistencia que aparece en el esquema es de 1K.

6.h la cual nos facilita el manejo de estos módulos. se debe cambiar los pines 7 y 8 por otros PWM. 5. Simulacion apertura de garaje Sketch del transmisor . Si se va a utilizar un Arduino Uno o Nano. como el 3. La batería representa la fuente externa para el motor. 9 y 10. El receptor trae dos pines DATA. Para este proyecto he usado un Arduino Mega en el receptor. Es indiferente a cual conectarlo. Transmisor EL programa del emisor quedaría parecido a esto mas o menos: /* Modulo RF 433 MHz. PROGRAMA DE CONTROL Necesitamos incluir la librería VirtualWire. ya que necesitamos que sean PWM para poder controlar la velocidad el motor.No olvidar unir la GND de Arduino a la GND de la fuente externa. la cual puede ser otra equivalente.

INPUT). */ #include <VirtualWire. hay una pausa y el motor vuelve a girar en sentido contrario. // enviamos activar delay(100). strlen(message)). // Espera hasta acabar de transmitir todo } Receptor Y en cuanto al receptor queda algo así: /* Modulo RF 433 MHz Sketch del receptor Espera hasta recibir la orden ACTIVAR para accionar un motor durante algunos segundos. simulando la apertura de una . //Envia el mensaje vw_wait_tx(). } } //Funcion para enviar el mensaje void send (char *message) { vw_send((uint8_t *)message. // definimos como entrada } void loop() { boton = digitalRead(pinBoton).h> // libreria para los modulos RF int pinBoton = 7.Envía la orden de ACTIVAR al pulsar un boton. El receptor la recibe y acciona el motor. // para la lectura del boton int boton = 0. // estado del boton void setup() { vw_setup(2000). // iniciamos la comunicacion por radio pinMode(pinBoton. // leemos la entrada if(boton == LOW) // si se ha pulsado { send("activar").

//pines para el motor pinMode(8. // apagamos motor analogWrite(8. vw_setup(2000). OUTPUT). Durante el movimiento. //Creamos un mensaje byte messageLength = VW_MAX_MESSAGE_LEN. se activa un LED. } void loop() { analogWrite(7. Luego queda a la espera de una nueva orden. */ #include <VirtualWire.0). OUTPUT).puerta de garaje. //Configuramos el pin 13 pinMode(7. OUTPUT).h> // libreria para utilizar los modulos RF byte message[VW_MAX_MESSAGE_LEN]. // iniciamos la comunicacion por radio vw_rx_start(). . //La constante VW_MAX_MESSAGE_LEN viene definida en la libreria void setup() { pinMode(13.0).

if (vw_get_message(message. sin sobrepasar los 12V. Si no. . // esperamos 4 segundos analogWrite(7. // esperamos 4 segundos analogWrite(7. // encendemos LED analogWrite(7. &messageLength)) // leemos el mensaje { if(comparar("activar") == 0) { // comparamos el mensaje digitalWrite(13. delay(4000). i++) { if(message[i] != cadena[i]) return 1.0). LOW). } return 0. se consiguió activar el receptor a unos 8 metros sin contacto visual.0). HIGH). // apagamos LED } } } char comparar(char* cadena) { // Esta funcion compara el string cadena con el mensaje recibido. i<messageLength. En el montaje propuesto. // Si son iguales. así como el voltaje del módulo transmisor. devuelve 1. // apagamos motor analogWrite(8. // encendemos motor en sentido opuesto analogWrite(8. // esperamos 3 segundos analogWrite(7. digitalWrite(13. for(int i = 0.180). // el valor 180 controla la velocidad de giro delay(4000).0). // encendemos motor en un sentido analogWrite(8.0). // apagamos motor analogWrite(8. devuelve 0. } NOTAS FINALES Podemos jugar con la longitud de las antenas emisora y receptora. encontrándos el transmisor en una estancia y el receptor en otra.0).180). delay(3000).0).

con lo que para usar servomotores con estos módulos tenemos dos opciones:  Controlar los servos con PWM y micropulsos (incluida en una función.h entra en conflicto con la librería Servo.h. . por ejemplo)  Trabajar con la librería ServoTimer2 (la cual no ha sido probada). La librería VirtualWire. al utilizar las dos el Timer de Arduino.