K.

CASTRO, 2015058131
V. CHAVARRÍA, 2016131679

PROF. ING A. MORERA

Laboratorio 3 Circuito Digital para Control de Motor a Pasos y Servomotor

Laboratorio de Control Eléctrico MI-4210

Grupo 03

Escuela de Ingeniería Electromecánica

Carrera de Ingeniería en Mantenimiento Industrial.

Canadian Engineering Accreditation Board

Bureau canadien d’accréditation des programmes Carrera evaluada y acreditada por:

CEAB
d’ingénierie

Índice de contenido  

1
1. Objetivos.............................................................................................................3
2. Materiales y equipo.............................................................................................3
3. Procedimiento.....................................................................................................3
4. Resultados teóricos y experimentales................................................................5
5. Discusión de resultados......................................................................................6
6. Conclusiones.......................................................................................................7
7. Bibliografía..........................................................................................................7
8. Anexos................................................................................................................8

Índice de figuras
Figura 4.1 Posición inicial del SCARA.......................................................................5

2
1. Objetivos
1. Diseñar del circuito de control para un motor a pasos a partir de un
desplazador de registros bidireccional.
2. Diseñar la interface de potencia entre el control y el motor.
3. Diseñar la interface de potencia utilizando relés de 5 V.
4. Implementar con puentes H.
5. Diseñar el control de un servomotor

2. Materiales y equipo
Entre los materiales y equipos requeridos para el laboratorio está una
fuente de 5V, una ProtoBoard, un CI 555, un desplazador de registros
(CIxx74xx194) o cualquier otro driver, dos Flip-Flop JK (CI 7476), cuatro
transistores, relés de 5V, un motor a pasos, un servomotor, resistencias de
270, 330 y 1000Ω, diodos led, dos capacitores de 1μF, un servomotor, y
demás elementos necesarios para el control del servomotor.

3. Procedimiento
Se analizó el siguiente problema:

“Se desea automatizar un sistema, el cual permite taladrar piezas

colocadas en puntos estratégicos, según las figuras abajo indicadas. Se
utilizará un robot SCARA, para los efectos del laboratorio solo se usarán
dos movimientos, el efector que baja y sube no se incluye en esta práctica.
El movimiento lo realizan dos motores paso a paso, los cuales deben de
moverse en la siguiente secuencia.

a. Al dar la señal de inicio se debe colocar en la parte derecha.

b. Una vez ahí se espera 4 segundos que es el tiempo que dura el
taladrado.
c. Transcurrido el tiempo se mueve al punto marcado como A y
espera 2 segundos.

3
 d. Luego va al punto donde está la pieza de la izquierda y espera 4
segundos para taladrar la otra pieza.
e. Luego de este tiempo se mueve hasta el punto a la derecha para
taladrar otra pieza
Además, se debe poder controlar de la velocidad del motor. “ [ CITATION
Mor18 \l 5130 ]
Por otro lado, también fue necesaria la implementación y diseño de un
circuito de control para un servomotor, en el cual pudiese controlar la dirección
del giro por medio de una serie de botoneras. Fue necesario implementar un
botón que controlara el arranque y pare de este servomotor.
Primeramente, se decidió realizar la programación para controlar el
robot SCARA mediante un Arduino, así como para el control del servomotor.
La programación del control de los brazos del robot se realizó de
manera que primero se pudiera mover manualmente a su posición inicial por
medio de 4 botoneras, las cuales controlaban el movimiento a la izquierda y
derecha de los dos motores de los brazos. Luego, se indicó en la
programación, que al presionar dos botones empezara la secuencia
automática planteada en el problema.
El SCARA ya estaba previamente armado en el laboratorio, por lo cual,
solo se debió conectar el Arduino a la protoboard proporcionada en la
estructura del robot y subir el programa realizado al Arduino.
Por otra parte, el programa del servomotor consistió en la definición de
3 botones, giro horario, giro antihorario y pare. Para esta parte, se tuvo que
importar la librería Servo en la programación e investigar acerca de cómo
utilizarla para el control de un servomotor.

4
4. Resultados teóricos y experimentales
Primero, se subió el programa de control del robot SCARA al arduino. Al
presionar una combinación de botoneras, se llevó al robot a su posición inicial
de forma manual.

Figura 4.1 Posición inicial del SCARA.

Fuente: Manual de Laboratorio de Control Eléctrico

Después de esto, se presionaron las dos botoneras del centro al mismo

tiempo y esta acción empezó a correr la parte automática del programa de
control realizado. Este empezaba con un delay de 4 segundos en el punto B,
luego se movía al punto A y allí tenía un delay de 2 segundos. Después de
esto, se movía a la posición C y esperaba 4 segundos. Finalmente, se movía al
punto B de nuevo para dar inicio de nuevo a la secuencia. En la sección A de
anexos podemos apreciar la programación implementada para el control del
robot SCARA.

Para el control de velocidad, tanto en el modo manual como en el

automático, se implementó un potenciómetro, el cual su valor era interpretado
por el arduino. Hecho esto, se vio que al variar el potenciómetro se variaba la
velocidad a la que se movían los brazos del robot.

En la segunda parte del laboratorio, la programación realizada al

servomotor SG90 TowerPro, permitió que, al presionar un botón, este se
moviera 180° en sentido antihorario, y al presionar otro, se moviera 180° en
5
sentido horario. Además, con la implementación del tercer botón, se ejercía la
acción de parar el movimiento del servomotor en cualquier momento del
proceso. La programación implementada para el control del servomotor se
puede observar en la sección B de los anexos

5. Discusión de resultados
Para el control del robot SCARA fue muy importante una implementación de
una programación que se encargara de enviar las ordenes y señales a los
diferentes drivers de los motores en conjunto con un circuito físico que se
encargara de enviar las señales según se le brindaran por el operador del
equipo. Una vez que ambos sistemas estuvieron correctamente implementados
los movimientos del robot fueron acordes a los esperados ya que, en su forma
automática, logró cumplir con el problema planteado.

Es importante recalcar que el potenciómetro tiene una resolución de 10 bits,

lo cual implica que podíamos obtener hasta 1024 valores diferentes con este.
Estos al enviarlos a las entradas analógicas del Arduino y realizando su
respectiva programación fue posible controlar las variaciones de velocidad
tanto del movimiento automático como del movimiento manual.

Por otra parte, para el control del servomotor, se destaca la importancia del
software de programación del Arduino, el cual facilitó el modo de
programación. También, la implementación del botón de pare complicó el
programa pues se tuvieron que crear dos variables más que guardaran el
movimiento. A pesar de esto, también se lograron obtener los resultados
esperados.

La implementación del tanto del circuito de control como de la programación

del servomotor fueron más sencillas que los del robot SCARA, esto debido a
que los procesos que habían que implementar con este eran muy reducidos y
de mucha menor complejidad.

6
 6. Conclusiones
En esta práctica, se logró diseñar e implementar, eficazmente, un proceso
de control del robot SCARA, el cual por medio un circuito de control realizado
en Arduino logró realizar las acciones planteadas en el problema. Con esto se
logró determinar la versatilidad que pueden presentar las programaciones en
Arduino, las cuales, permiten un gran desarrollo de diversas aplicaciones. En
este caso, permitió una completa manipulación de las funciones del robot.

Por otro lado, se logró implementar el control de un servomotor, el cual, al

igual el SCARA, se logró por medio de una programación y un circuito de
control en Arduino.

7. Bibliografía
Morera B., A. L. (s.f.). Control Eléctrico. Cartago.
Morera, A. L., & Murillo, L. D. (2019). Manual de Laboratorios. Laboratorio de
Control Eléctrico. Cartago.

7
 8. Anexos
a) Programación del SCARA
// Definicion de variables
const int bDerecha1 = 4;
//Pin giro derecho motor 1
const int bIzquierda1 = 3;
//Pin giro izquierdo motor 1
const int bDerecha2 = 6;
//Pin giro derecho motor 2
const int bIzquierda2 = 5;
//Pin giro izquierdo motor 2
const int Motor1 = 9;
//Pin de salida a Step motor 1
const int Motor2 = 8;
//Pin de salida a Step motor 2
const int MovM1 = 2;
//Pin de salida a direccion
motor 1
const int MovM2 = 7;
//Pin de salida a direccion
motor 2
const int pot =
A0; //Lectura Pot
int P,Vel,
GiroIzqM1,GiroDerM1,
GiroIzqM2, GiroDerM2, i;
void setup() {
//Definicion de variables como
entradas o salidas digitales
pinMode(bIzquierda1,INPUT);
pinMode(bDerecha1,INPUT);
pinMode(bIzquierda2,INPUT);
pinMode(bDerecha2,INPUT);
pinMode(pot,INPUT);
pinMode(Motor1,OUTPUT);
pinMode(Motor2,OUTPUT);
pinMode(MovM1,OUTPUT); if (GiroIzqM1==LOW &&
GiroDerM1==HIGH){
pinMode(MovM2,OUTPUT); //Giro a la derecha motor 1
} digitalWrite(MovM1,LOW);
void loop() {
for (i=0;i<1;i++){
P = analogRead(pot); //Pulsos
//lectura potenciometro
digitalWrite(Motor1,HIGH);
Vel= delay(Vel);
map(P,0,1023,2,50);
//Convierte lectura analogica digitalWrite(Motor1,LOW);
de voltaje en pot a un valor
entre 2 y 50 us delay(Vel);
delayMicroseconds (Vel); }
//Frecuencia }
GiroIzqM1 = if (GiroIzqM2==HIGH &&
digitalRead(bIzquierda1); GiroDerM2==LOW){
GiroDerM1 = //Giro a la izquierda motor 2
digitalRead(bDerecha1); digitalWrite(MovM2,HIGH);
GiroIzqM2 = for (i=0;i<1;i++){
digitalRead(bIzquierda2); //Pulsos
GiroDerM2 = digitalWrite(Motor2,HIGH);
digitalRead(bDerecha2);
delay(Vel);
if (GiroIzqM1==HIGH &&
GiroDerM1==LOW){ digitalWrite(Motor2,LOW);
//Giro a la izquierda motor 1
delay(Vel);
digitalWrite(MovM1,HIGH);
}
for (i=0;i<1;i++){
}
//Pulsos
if (GiroIzqM2==LOW &&
digitalWrite(Motor1,HIGH);
GiroDerM2==HIGH){
delay(Vel); //Giro a la derecha del motor 2
digitalWrite(Motor1,LOW); digitalWrite(MovM2,LOW);
delay(Vel); for (i=0;i<1;i++){
//Pulsos
}
digitalWrite(Motor2,HIGH);
}
delay(Vel);
8
 digitalWrite(Motor2,LOW);
delay(Vel);
} //Giro a la derecha motor 1
} de 2s
if (GiroIzqM2==HIGH &&
GiroDerM2==HIGH){
//Empieza el automatico al
presionar los 2 botones de
giro del segundo motor
delay (4000); //Inicia la
secuencia con una espera de
4s
digitalWrite(MovM1,HIGH);
//Giro a la izquierda motor 1
for (i=0;i<250;i++){
//Pulsos
digitalWrite(Motor1,HIGH);
delay(map(analogRead(pot),0,
1023,2,50));
digitalWrite(Motor1,LOW);
delay(map(analogRead(pot),0,
1023,2,50));
} digitalWrite(Motor2,HIGH);
delay (100); //retardo
para que se mueva el motor 2
digitalWrite(MovM2,HIGH);
//Giro a la izquierda motor 2
for (i=0;i<250;i++){//Pulsos
digitalWrite(Motor2,HIGH);
delay(map(analogRead(pot),0,
1023,2,50));
digitalWrite(Motor2,LOW);
delay(map(analogRead(pot),0, delay(4000); //tiempo de
1023,2,50)); espera de 4s
} digitalWrite(MovM1,LOW);
delay (2000); //espera
for (i=0;i<500;i++){
//Pulsos
digitalWrite(MovM1,HIGH);
//Giro a la izquierda motor 1
digitalWrite(Motor1,HIGH);
for (i=0;i<250;i++){
//Pulsos
delay(map(analogRead(pot),0,
1023,2,50));
digitalWrite(Motor1,HIGH);
delay(map(analogRead(pot),0,
1023,2,50)); digitalWrite(Motor1,LOW);
delay(map(analogRead(pot),0,
1023,2,50));
digitalWrite(Motor1,LOW);
}
delay(map(analogRead(pot),0,
1023,2,50)); delay (100); //retardo para
que se mueva el motor 2
digitalWrite(MovM2,LOW);
delay (100); //retardo //Giro a la derecha del motor 2
para que se mueva el motor 2
for (i=0;i<500;i++){
digitalWrite(MovM2,HIGH); //Pulsos
//Giro a la izquierda motor 2
for (i=0;i<250;i++){
//Pulsos
delay(map(analogRead(pot),0,
digitalWrite(Motor2,HIGH);
1023,2,50));
delay(map(analogRead(pot),0,
1023,2,50));
digitalWrite(Motor2,LOW);
digitalWrite(Motor2,LOW);
delay(map(analogRead(pot),0,
delay(map(analogRead(pot),0, 1023,2,50));
1023,2,50));
}
}
}
}
9
 b) Programación del servomotor

#include <Servo.h> EGiroAntihorario =

digitalRead(GiroAntihorario);
Servo servo;
EPare = digitalRead(Pare);
int GiroHorario = 12; //pin giro horario
if (EGiroHorario == HIGH or M1 == HIGH){
int GiroAntihorario = 13; //pin giro AH
M1 = 1;
int angulo = 0; //Angulo de giro
M2 = 0;
int Pare = 6; // pin pare
angulo += 5;

// restriccion();
int EGiroHorario = 1; //Estado giro H
servo.write(angulo);
int EGiroAntihorario = 1; //estado AH
}
int EPare = 0; // estado pare
if (EGiroAntihorario == HIGH or M2 ==
int M1 = 0; // movimiento horario HIGH){
int M2 = 0; // movimiento antihorario M1 = 0;

M2 = 1;
void setup() { angulo -= 5;
pinMode (GiroHorario,INPUT); // restriccion();
pinMode (GiroAntihorario,INPUT); servo.write(angulo);
pinMode (Pare,INPUT); }
servo.attach(11); if (EPare == HIGH){
servo.write(0); M1 = 0;
Serial.begin(9600); M2 = 0;
} // restriccion();

servo.write(angulo);
void loop() { }
EGiroHorario = digitalRead(GiroHorario); delay(25);

10