Arduino GUIA No 2

1 Guía 2 – Control de Motores, transistores y relés con Arduino Profesor: Carlos Pocasangre

Diseñada por: Br. Manfred González

MARCO TEÓRICO.

Relés. El relé o relevador es un dispositivo electromecánico. Funciona como un interruptor controlado

por un circuito eléctrico en el que, por medio de una bobina y un electroimán, se acciona un juego

de uno o varios contactos que permiten abrir o cerrar otros circuitos eléctricos independientes.

Dado que el relé es capaz de controlar un circuito de salida de mayor potencia que el de entrada,

puede considerarse, en un amplio sentido, como un amplificador eléctrico.

Existen multitud de tipos distintos de relés, dependiendo del número de contactos, de

su intensidad admisible, del tipo de corriente de accionamiento, del tiempo de activación y

desactivación, etc. Cuando controlan grandes potencias se les llama contactores en lugar de relés.

Etapas de potencia (Drivers).

Representan el enlace entre las señales lógicas de control y las señales de potencia, corriente que

circula por los bobinados. Éstas tienen que responder con rapidez a las excitaciones, así como

proporcionar la corriente necesaria a la tensión de trabajo requerida para la alimentación.

Representan los interruptores de potencia que conmutan según el control, formados por

transistores bipolares.

El bobinado de los motores paso a paso es inductivo y aparece en combinación de una inductancia

y una resistencia en serie. Cuando el motor gira nos encontramos con una fuerza electro motriz

producida en el bobinado. Las etapas de potencia que controlan los bobinados se ven sometidas a

los efectos de las pendientes en la corriente y las sobretensiones que produce la carga inductiva,

por lo que se hace necesario la utilización de supresores para evitar daños en los elementos de

potencia.

http://es.wikipedia.org/wiki/Contactor



Circuitos supresores

Cuando el transistor es desactivado, se induce un alto voltaje en el bobinado en función de

L(di/dt). Este voltaje queda aplicado sobre el transistor, pudiendo llegar a dañarlo. Existen diversos

métodos para suprimir el pico de tensión y proteger el transistor, el más usado es Si un diodo es

situado en paralelo con el bobinado. Con la polaridad tal como muestra la figura (a), la circulación

de la corriente fluye por éste cuando el transistor es desactivado, y la corriente decae en este

momento.

Motores Paso a Paso.

Los motores unipolares se llaman así porque la corriente que circula por los diferentes bobinados

siempre circula en el mismo sentido. En los motores bipolares para que el motor funcione la

corriente que circula por los bobinados cambia de sentido en función de la tensión que se aplica.

Por lo que un mismo bobinado puede tener en uno de sus extremos distinta polaridad (bipolar).

Es importante conocer el tipo de motor que es, la potencia, grados por pasos, el par de fuerza, la

tensión de alimentación y la corriente que demanda este.

Bipolar: Estos tiene generalmente cuatro cables de salida. Necesitan ciertos trucos para ser

controlados, debido a que requieren del cambio de dirección del flujo de corriente a través de las

bobinas en la secuencia apropiada para realizar un movimiento. El control de estos motores se

realiza mediante el uso de un puente en H (H-Bridge), será necesario un H-Bridge por cada bobina

del motor, es decir que para controlar un motor Paso a Paso de 4 cables (dos bobinas),

http://www.monografias.com/trabajos2/mercambiario/mercambiario.shtml

http://www.monografias.com/trabajos15/direccion/direccion.shtml

http://www.monografias.com/trabajos15/kinesiologia-biomecanica/kinesiologia-biomecanica.shtml

http://www.monografias.com/trabajos14/control/control.shtml



necesitaremos usar dos H-Bridges. El circuito de la figura es a modo ilustrativo y no corresponde

con exactitud a un H-Bridge. En general es recomendable el uso de H-Bridge integrados como son

los casos del L293.

Ejemplo ilustrativo de un puente H.

Circuito de uso de puentes H integrados en el L293.

Los motores paso a paso, difieren de los motores de CC, en la relación entre velocidad y torque o

"par motor". Su mayor capacidad de torque se produce a baja velocidad.

Cuando se requieren mayores potencias, se deben agregar algunos componentes, como

transistores y diodos para las contracorrientes, aunque esto no es del todo necesario en los

pequeños motores.

Unipolar: Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su conexionado

interno. Este tipo se caracteriza por ser más simple de controlar.

En la figura se muestra un ejemplo de conexionado para controlar un motor paso a paso unipolar

mediante el uso de un ULN2803, el cual es una array de 8 transistores tipo Darlington capaces de

manejar cargas de hasta 500mA. Las entradas de activación (Activa A, B, C y D) pueden ser

directamente activadas por un microcontrolador.

En general para los motores bipolares y unipolares puedes invertir las polarizaciones y al final te

sorprenderá que el motor siga girando en la misma dirección. Lo único que hará que cambie de

dirección es que reciba la secuencia de pasos en orden invertido; es decir repetir la secuencia que

lo hace girar en una dirección al revés.



EJEMPLO 1: Control de relé mediante transistor.

//Ejemplo para activar un relé de 12V mediante un transistor. int boton_on = 12, boton_off = 11, salida = 13; int estado = 0; void setup(){ pinMode(boton_on, INPUT); pinMode(boton_off, INPUT); pinMode(salida, OUTPUT); } void loop(){ if(digitalRead(boton_on) == HIGH) estado = 1; if(digitalRead(boton_off) == HIGH) estado = 0; digitalWrite(salida, estado); }

EJEMPLO 2: Control de un motor DC.

Para el siguiente circuito se realiza el control de un motor DC y la inversión de giro de este

mediante la utilización del integrado L293.



int a = 13, b = 12; int boton_derecha = 11, boton_izquierda = 10; void setup(){ pinMode(a, OUTPUT); pinMode(b, OUTPUT); pinMode(boton_derecha, INPUT); pinMode(boton_izquierda, INPUT); } void loop(){ if(digitalRead(boton_derecha) == HIGH && digitalRead(boton_izquierda) == LOW){ digitalWrite(a, HIGH); digitalWrite(b, LOW); } else if(digitalRead(boton_izquierda) == HIGH && digitalRead(boton_derecha) == LOW){ digitalWrite(a, LOW); digitalWrite(b, HIGH); } else{ digitalWrite(a, LOW); digitalWrite(b, LOW); } }



EJEMPLO 3: Control de motor paso unipolar (secuencia normal).

Esta es la secuencia más usada y la que generalmente recomienda el fabricante. Con esta

secuencia el motor avanza un paso por vez y debido a que siempre hay al menos dos bobinas

activadas, se obtiene un alto torque de paso y de retención.

Paso A B C D

1 1 0 0 0

2 0 1 0 0

3 0 0 1 0

4 0 0 0 1

1 0 0 0 1

2 0 0 1 0

3 0 1 0 0

4 1 0 0 0

Armar en Proteus el siguiente circuito. El puente H utilizado es el L293, el motor paso unipolar se

puede encontrar como MOTOR-STEPPER.

int a = 13, b = 12, c = 11, d = 10, retardo = 100; int boton_derecha = 9, boton_izquierda = 8; void setup(){ pinMode(a, OUTPUT); pinMode(b, OUTPUT); pinMode(c, OUTPUT);

Giro normal.

Giro sentido inverso.



pinMode(d, OUTPUT); pinMode(boton_derecha, INPUT); pinMode(boton_izquierda, INPUT); } void loop(){ if(digitalRead(boton_derecha) == HIGH && digitalRead(boton_izquierda) == LOW) giroDerecha(); else if(digitalRead(boton_izquierda) == HIGH && digitalRead(boton_derecha) == LOW) giroIzquierda(); else{ digitalWrite(a, LOW); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, LOW); } } //Secuencia para girar a la derecha void giroDerecha(){ digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); } //Secuencia para girar a la izquierda void giroIzquierda(){ digitalWrite(a,0); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,0);



digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); }

EJEMPLO 4: Control de motor paso unipolar (Secuencia del tipo wave

drive).

En esta secuencia se activa solo una bobina a la vez. En algunos motores esto brinda un

funcionamiento más suave. La contrapartida es que al estar solo una bobina activada, el torque de

paso y retención es menor.

Para este ejemplo se usara el mismo circuito del ejemplo 2. La secuencia se detalla a continuación:

Paso A B C D

1 1 1 0 0

2 0 1 1 0

3 0 0 1 1

4 1 0 0 1

1 1 0 0 1

2 0 0 1 1

3 0 1 1 0

4 1 1 0 0

int a = 13, b = 12, c = 11, d = 10, retardo = 100; int boton_derecha = 9, boton_izquierda = 8; void setup(){ pinMode(a, OUTPUT); pinMode(b, OUTPUT); pinMode(c, OUTPUT); pinMode(d, OUTPUT); pinMode(boton_derecha, INPUT); pinMode(boton_izquierda, INPUT);

Giro normal.




} void loop(){ if(digitalRead(boton_derecha) == HIGH && digitalRead(boton_izquierda) == LOW) giroDerecha(); else if(digitalRead(boton_izquierda) == HIGH && digitalRead(boton_derecha) == LOW) giroIzquierda(); else{ digitalWrite(a, LOW); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, LOW); } } //Secuencia para girar a la derecha void giroDerecha(){ digitalWrite(a,1); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,1); delay(retardo); digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); } //Secuencia para girar a la izquierda void giroIzquierda(){ digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,0); digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,1);



delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); digitalWrite(a,1); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,0); delay(retardo); }

EJEMPLO 5: Control de motor paso bipolar.

Paso A B C D

1 1 0 1 0

2 1 0 0 1

3 0 1 0 1

4 0 1 1 0

1 0 1 1 0

2 0 1 0 1

3 1 0 0 1

4 1 0 1 0

Armar en Proteus el siguiente circuito. El puente H utilizado es el L293, el motor paso bipolar se

puede encontrar como MOTOR-BISTEPPER.

Giro normal.




int a = 13, b = 12, c = 11, d = 10, retardo = 100; int boton_derecha = 9, boton_izquierda = 8; void setup(){ pinMode(a, OUTPUT); pinMode(b, OUTPUT); pinMode(c, OUTPUT); pinMode(d, OUTPUT); pinMode(boton_derecha, INPUT); pinMode(boton_izquierda, INPUT); } void loop(){ if(digitalRead(boton_derecha) == HIGH && digitalRead(boton_izquierda) == LOW) giroDerecha(); else if(digitalRead(boton_izquierda) == HIGH && digitalRead(boton_derecha) == LOW) giroIzquierda(); else{ digitalWrite(a, LOW); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, LOW); } } //Secuencia para girar a la derecha void giroDerecha(){ digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,0);



delay(retardo); digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); } //Secuencia para girar a la izquierda void giroIzquierda(){ digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); digitalWrite(a,0); digitalWrite(b,1); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,0); digitalWrite(d,1); delay(retardo); digitalWrite(a,1); digitalWrite(b,0); digitalWrite(c,1); digitalWrite(d,0); delay(retardo); }



EJEMPLO 6: Control de motor paso bipolar con 2 salidas.

Paso A B C D

1 1 0 1 0

2 1 0 0 1

3 0 1 0 1

4 0 1 1 0

1 0 1 1 0

2 0 1 0 1

3 1 0 0 1

4 1 0 1 0

Dependiendo de la aplicación que deseamos implementar es necesario poder controlar un motor

paso con solo dos salidas en lugar de 4. Esto se puede lograr ya que si nos fijamos en la secuencia

de pasos, se puede notar algo interesante. Entre las entradas A y B de la tabla anterior, nunca son

iguales, siempre están en contraposición. Es decir lo que ocurre en la entrada B es lo opuesto a la

entrada A. Lo mismo ocurre con el par C y D.

De modo que, si utilizamos dos salidas de Arduino como entradas A y C del L293 y conectamos dos

inversores para las entradas B y D, dispondremos de las cuatro entradas necesarias para el L293,

podemos eliminar pasos innecesarios de la secuencia, y una entrada a cada lado.

Para esto se puede utilizar compuertas NOT (74LS04) o podemos realizar la inversión mediante

dos transistores NPN (para este caso el B547) para realizar la inversión. Si usted le da un 1, le

entregará un 0 y si le da un 0, se obtendrá un 1, siempre la inversa.

Armar en Proteus el siguiente circuito. El puente H utilizado es el L293, el motor paso unipolar se

puede encontrar como MOTOR-STEPPER y los transistores usados son el BC547.

Giro normal.




int a = 13, c = 12, retardo = 100; int boton_derecha = 11, boton_izquierda = 10; void setup(){ pinMode(a, OUTPUT); pinMode(c, OUTPUT); pinMode(boton_derecha, INPUT); pinMode(boton_izquierda, INPUT); } void loop(){ if(digitalRead(boton_derecha) == HIGH && digitalRead(boton_izquierda) == LOW) giroDerecha(); else if(digitalRead(boton_izquierda) == HIGH && digitalRead(boton_derecha) == LOW) giroIzquierda(); else{ digitalWrite(a, LOW); digitalWrite(c, LOW); } } //############################################################ //Secuencia para girar a la derecha void giroDerecha(){ digitalWrite(a,1); digitalWrite(c,1); delay(retardo);



digitalWrite(a,1); digitalWrite(c,0); delay(retardo); digitalWrite(a,0); digitalWrite(c,0); delay(retardo); digitalWrite(a,0); digitalWrite(c,1); delay(retardo); } //Secuencia para girar a la izquierda void giroIzquierda(){ digitalWrite(a,0); digitalWrite(c,1); delay(retardo); digitalWrite(a,0); digitalWrite(c,0); delay(retardo); digitalWrite(a,1); digitalWrite(c,0); delay(retardo); digitalWrite(a,1); digitalWrite(c,1); delay(retardo); }

ASIGNACIÓN.

1. Número de pasos por vuelta: Es la cantidad de pasos que ha de efectuar el rotor para

realizar una revolución completa; y esta es: ⁄ donde NP es el número de

pasos y α el ángulo de paso del motor. Haga un programa que haga que un motor paso

bipolar o unipolar realice 3 vueltas completas.

2.

Documents

Arduino GUIA No 2