INSTITUTO TECNOLÓGICO SUPERIOR

DE LA REGIÓN DE LOS LLANOS

INGENIERÍA MECATRÓNICA

INSTRUMENTACIÓN VIRTUAL
M.C. Jesús Manuel Blanco Berumen
Unidad III:

DESCRIPCIÓN DE LA PRÁCTICA DE CONTROL DE UN MOTOR A

PASOS

Responsable:
16B100264 Leonardo Campos Vázquez

8° U

Guadalupe Victoria, Dgo., 17 – 05 – 2020

El siguiente programa a mostrar realizado en LabVIEW, tiene el fin de controlar un
motor a pasos a través de la tarjeta de desarrollo Arduino Uno usando el
complemento LINX de Makerhub. El control de un motor paso a paso se reduce a
dos funciones: calcular la secuencia de salida (es decir la activación de los
interruptores del driver), y posteriormente, escribir el resultado por la interfaz
(Arduino Uno) entre la computadora y el driver, con el fin de actuar sobre los
interruptores que impiden o dejan pasar la corriente hasta las bobinas del motor. En
la figura 1 está ilustrado este proceso.

Figura 1 (Control por software del driver de un motor paso a paso)

La interfaz que se usará entre los interruptores y la computadora es, como ya se

dijo, el Arduino Uno. El driver utilizado fue un ULN2003, mientras que el motor a
pasos utilizado fue el 28BYJ-48. También fue usado un módulo de fuente de energía
para alimentar al driver y, por ende, al motor. En la figura 2, se muestra un esquema
de la conexión de estos componentes.

Una vez aclarado esto, hay que pasar a la parte del programa, que basados en el
diagrama de la figura 1, hace la función del control, al realizar el cálculo de la
secuencia de interruptores en base a lo que el usuario desee, es decir si quiere que
el motor gire en sentido horario, antihorario, rote a medios pasos o a pasos
completos, etc. Y también realiza la acción de escribir esta salida por el Arduino.

En la figura 3, se tiene una captura de la interfaz propuesta para este programa, al

mismo tiempo se presenta en la figura 4 y 5, el diagrama de bloques
correspondiente.
Figura 2 (Diagrama de conexión del Arduino Uno con el motor a pasos y el driver)

Figura 3 (Front panel del VI para el control de un motor a pasos)

Figura 4 (Diagrama de bloques del VI para el control de un motor a pasos, cuando el case es
‘false’)

Figura 5 (Diagrama de bloques del VI para el control de un motor a pasos, cuando el case es
‘true’)
Para la explicación del programa, se dividirá el proceso en tres partes; la graficación
de la posición en grados del motor en tiempo real en el front panel, el cálculo de la
secuencia a usar en base a la selección del usuario, y por último la escritura de esta
secuencia al Arduino Uno. La primera parte referente a graficar la posición no es
esencial, pues no afecta a la función principal del programa, pero si resulta
interesante conocer la posición del motor a pasos desde el momento que se le dio
arranque. Entonces, dentro del ciclo while en la parte superior (figura 6)

Figura 5 (Visualización de la posición del motor pt1)

Se tiene que cada iteración durará lo que dicte el usuario utilizando la barra de
control de la interfaz, hay que aclarar que mientras más grande el tiempo de
iteración más lento rotará el motor, esto dependiendo de su resolución claro, y de la
velocidad nominal en RPM que pueda alcanzar. Para este caso particular, el motor
utilizado alcanza hasta 17 RPM de velocidad. Considerando que, a medios pasos,
necesitar dar 4076 de estos para completar una vuelta de 360°, entonces la
resolución del actuador es de 0.088 aproximadamente, a medios pasos cabe
aclarar. Por lo que para obtener la resolución a ‘full step’, simplemente se multiplicó
este número por 2, y se tiene una resolución de 0.176 aproximadamente. Este
número es importante para llenar el campo de ‘resolución’ ubicado en el front panel,
de poner otro diferente, la gráfica estará desfasada en velocidad con respecto a la
del motor, independientemente de que el tiempo en la barra selectora de velocidad
sea el adecuado, pero esto lleva a preguntar ¿cuál es el tiempo adecuado? Se dijo
que el motor alcanza 17 RPM de velocidad nominal, y que le toma dar 4076 pasos
para completar una vuelta. Si se multiplica 17 por 4076, se tiene el número de pasos
que el motor da en un minuto (69,292), a esa velocidad, por lo que si se divide
69,292 entre 60 (segundos en un minuto), se tiene el número de pasos (iteraciones)
de cada segundo a máxima velocidad, ahora al dividir uno entre el valor obtenido,
se llega a la conclusión que para que el motor a pasos alcance la velocidad nominal,
cada iteración debe dura 0.860 ms. Siguiendo el mismo procedimiento, la iteración
deberá durar hasta 14 ms, para que el motor dé una vuelta cada minuto (1 RPM).

Así pues, el rango de tiempo admisible, es de 0.86 ms hasta 14 ms., teniendo esto
en consideración y la resolución (que es inmutable) de 0.176, la visualización de la
posición del motor usando la gráfica polar de LabVIEW será la correcta, aunque
pueden existir pequeñas variaciones debido a retrasos por parte del tiempo de
ejecución del programa con relación al tiempo real, pero son variaciones pequeñas.

Se utiliza un contador para saber cuantos grados a avanzado el servo motor, este
contador incrementa en cada iteración, sin embargo no incrementa un valor
constante, esto depende de la resolución del motor, pues el valor del contador, al
principio inicia en cero, pero si se selecciona que el sentido del giro sea antihorario,
se multiplica un ‘uno’ positivo por la resolución y este es el valor que incrementa, en
cambio, si se seleccionó un giro en sentido horario, se multiplicará un ‘uno’ negativo.

También si se trata de un giro en ‘full step’ el valor +1 o -1 pasará directamente a

ser multiplicado por el controlador, pero si se trata de un ‘half step’ este valor es
dividido entre dos (esto se verá más adelante)

Como se ve en la figura 5, se tienen varios selectores para que una vez que el
conteo de grados (definido su velocidad tanto por la resolución como la duración de
las iteraciones) alcance los 360, este se reinicie a cero nuevamente, que significa
que ya se completó una vuelta más, al igual que todos los números negativos del
contador que puedan surgir, se igualan a cero, de no tener estos comparadores y
selectores, habría errores en la graficación pues saldrían valores por encima de 360
grados o números negativos incluso.
Para mandar a imprimir la gráfica, en base a este contador de iteración, se usa un
bloque llamado ‘Polar Plot with Point Options VI’. Este bloque consta de varias
entradas, pero en este programa solo se usa la de ‘data array’ y la de ‘dimensions’
(figura 6)

Figura 6 (Visualización de la posición del motor pt2)

En la entrada ‘data array’ se deben ingresar dos puntos para trazar un vector de
magnitud 4, este vector indica los ángulos, por lo que se traza desde el origen (por
eso entra un punto en 0,0) hasta un punto determinado por (4, y), donde ‘y’ es el
valor actual del contador, de esta forma el vector rota mostrando la posición del
motor en base al contador. La otra entrada usada del bloque es ‘dimensions’ es solo
para especificar el tamaño de la gráfica, donde se dejó por defecto que tomará el
área total del elemento.

Ahora falta hablar de la segunda parte, la de la programación contenida dentro del

‘case’, si bien la anterior parte es útil para ver la posición del actuador, no influye en
el funcionamiento del mismo, caso diferente a esta parte pues es la que calcula la
secuencia de conmutaciones que serán escritas en la interfaz para enviarlas al
driver del motor.

Si se observa la figura 7, se ven dos vectores, el primero (en azul), contiene la

secuencia de activación para los medios pasos del motor. Minetras que el de abajo
(en verde), es para la secuencia de activación para ‘full step’ del motor.
 Figura 7 (Arrays de secuencia de activación)

Ambos se unen con un cluster para ser ingresados a la estructura ‘case’ dentro del
ciclo ‘while’. Esta estructura, tiene dos eventos, verdadero y falso. Estos eventos
dependen de la selección en el front panel del switch ’Paso’ que puede ser medio
(switch arriba = verdadero) o entero (switch abajo = negativo).

Primero se pasará a explicar el evento ’True’ (figura 8) es decir cuando el switch

esta arriba, con la opción de medio paso seleccionada

Figura 8 (Case ‘True’)

Ambos vectores con ambas secuencias de interruptores entran al case, sin
embargo, en el case ‘true’ solo se usa la secuencia medio paso. Este vector se
ingresa a una función de rotación de ‘arrays’. Esta función necesita que se le
especifique el número de posiciones que rotara un vector en cada iteración, en este
caso solo se desea que rote una vez, por ello le entra el valor resultado del selector
que se ve en la parte superior de la figura 8, donde si el switch de ‘Sentido’ está
arriba que es ‘true’ el número que pasará será el ‘-1’, si el switch está abajo que es
‘false’ el número que pasará será ‘1’, es decir el vector rotará hacia la izquierda o
derecha según el tipo de giro que especifique el usuario. Con estas rotaciones, es
como sucede la secuencia de activación seleccionada, con ayuda de los shift
registers, se actualiza en cada iteración el corrimiento del vector, y a su vez en cada
bucle, se toma desde el primer elemento de este vector y se convierte a booleano
para ser escrito en la interfaz (Arduino Uno). Esto se verá en la tercera parte del
programa. El vector ya convertido a booleano también es metido a un ‘subarray’
para que se tomen solo cuatro elementos de este, y pueda ser enviado a un vector
de leds, (llamado señales) que indicaran el estado de la conmutación.

Ahora el explicar el evento ‘False’, (figura 9) es mucho más simple. Ahora se toma
al vector que contiene la secuencia de activación de paso completo, se ingresa a la
función de ‘rotation array’, donde el vector rotará bajo las mismas condiciones que
en el evento ‘true’ con el ‘array’ de medio paso. En esta ocasión como el vector ya
es booleano, no hace alta convertirlo, por lo que directamente se manda a escribir
a la interfaz, y a mostrarlo en el ‘array’ de ‘Señales’ que es el conjunto de leds
visualizados en el ‘front panel’.
 Figura 9 (Case ‘False’)

Por último, solo resta comentar acerca de la última parte del programa, la de
escritura (figura 10).

Figura 10 (Escritura de la secuencia correspondiente a la selección del usuario)

Se usó el complemento LINX para comunicar LabVIEW con el Arduino Uno. Primero
se abrió el puerto serie, este será seleccionado por el usuario desde el front panel,
así podrá conectar la tarjeta desde cualquier puerto disponible de la PC. Una vez
abierto el puerto, se escribe el vector que corresponda a través de múltiples canales.
Siguiendo el diagrama de conexión de la figura 2, se especificaron como constantes
los canales en los cuales se escribirán las señales digitales, interpretadas a partir
de los vectores provenientes del ‘case’. Tras ello, se enciende un led rojo en caso
de existir un error de comunicación, y finalmente fuera del ciclo ‘while’ es decir, una
vez que se detenga la ejecución del programa con el botón de ‘Stop’, se cerrará el
puerto serie.

A continuación, se muestran algunas fotos y capturas del programa en ejecución

junto con su implementación física, también se anexa un enlace a un video en
YouTube donde se podrá ver el funcionamiento de la actividad. No sin antes mostrar
la manera en que se cargó el firmware para poder comunicar LabVIEW con el
arduino, para ello, en la barra de menú se selecciona la pestaña tool, luego
Makerhub, seguido de LINX y por último LINX Firmware Wizard en las figuras 11,
12, 13 y 14, se encuentran unas capturas de la subida del Firmware a la placa. En
caso que este paso no sea efectuado, el programa no podrá comunicarse con la
placa y por ende no enviará información alguna al driver.

Figura 11 (Selección de la placa a utilizar)

Figura 12 (Selección del puerto donde se conectó la placa)

Figura 13 (Cargando el firmware a la placa)

 Figura 14 (Firmware cargado con éxito a la placa)

Figura 15 (Implementación física del control del motor)

Figura 16 (Front panel del programa en ejecución)

Figura 17 (Captura del video demostrativo)

[Link]