PROLOGO.
Esta documentación, pretende ser una aproximación práctica a las formas de control de motores paso a paso, también conocidos en la terminología inglesa como, stepper’s. Hemos de distinguir entre dos tipos de motores paso a paso, podemos encontrar motores bipolares y motores unipolares. Este, es el que vamos a tratar en este artículo, los motores unipolares.
Fig. 1
En este sitio, puede encontrar un artículo mío, de hace algunos años que, trata extensamente sobre los motores paso a paso, donde puede disipar cualquier duda sobre los mismos. En ese documento, se hace un análisis de los tipos de motores paso a paso, su constitución, su lógica y además se presentan algunos ejemplo, con el uso del puerto paralelo del PC. La característica principal de los motores paso a paso, es el hecho de poder moverlos un paso con cada impulso aplicado. Los pasos necesarios para dar un giro de 360º, depende de la constitución de cada motor, pueden variar desde 90º cada paso, a pasos de 1’8 grados por pulso.
Doy por sentado que el lector tiene conocimientos básicos sobre los motores paso a paso. En esta ocasión, vamos a abordar el tema desde la perspectiva práctica en la que se propone la puesta en servicio de un control para un motor paso a paso del tipo unipolar.
Motor Unipolar.
Esta sería, una descripción muy acertada sobre los motores paso a paso, podemos considerar que son una serie de electroimanes que rodean una armadura, formada por un imán. Piense en una brújula con un eje conectado al centro de la aguja. La aguja se convierte en el rotor del motor. Para girar el rotor, se encienden y se apagan los electroimanes, por la parte exterior de la brújula, haciendo que la aguja de un «paso» (o punto) de un electroimán al siguiente. Esta imagen mental, puede ayudar a ilustrar el movimiento dentro de un motor paso a paso.
Los motores paso a paso unipolares, básicamente, se componen de dos bobinas, cada una con una derivación en el centro. Las derivaciones del centro son llevadas fuera del motor como dos cables separados (como se muestra en la Figura 2) o conectados entre sí internamente y llevados fuera del motor como uno de los cables. Como resultado, los motores unipolares tienen 5 o 6 cables. Independientemente del número de cables, los motores unipolares son manejados de la misma manera. El cable de toma central (s) está ligado a una fuente de alimentación y los extremos de las bobinas son llevados alternativamente a tierra.
Los motores unipolares paso a paso, como todos los motores de imán permanente e híbridos, funcionan de manera diferente de los motores de reluctancia variable. En lugar de funcionar, minimizando la longitud de la trayectoria del flujo entre los polos del estator y los dientes del rotor, en la dirección del flujo de corriente a través de los bobinados del estator, es irrelevante, estos motores funcionan mediante la atracción de los polos norte o sur permanentemente el rotor magnetizando a la polos del estator.
Así, en estos motores, la dirección de la corriente a través de las bobinas del estator, determina que polos del rotor se sentirán atraídos por los polos del estator. La orientación de corriente en los motores unipolares, depende de que mitad de una bobina se energiza. Físicamente, las dos mitades de las bobinas se enrollan paralelas entre sí. Por lo tanto, una de las partes o devanado, ya sea polo norte o sur, dependiendo de cual es la mitad que se alimenta.
La figura que sigue, muestra la sección transversal de un motor paso a paso unipolar de 30 grados. El bobinado número 1 del motor se distribuye entre los polos, parte superior e inferior del estator, mientras que la bobina número 2 del motor, se distribuye entre los polos izquierdo y derecho del motor. El rotor es un imán permanente con seis polos, tres al norte y tres al sur, como se muestra en la figura.
Fig. 2 Motor básico unipolar
La diferencia entre un motor paso a paso de imán permanente y un motor paso a paso híbrido, radica en cómo se construyen el rotor multipolar y estator multipolar. Esta sería una secuencia de 12 pasos para mover el motor.
Ejemplo secuencia 1
Devanado 1a: 100010001000
Devanado 1b: 001000100010
Devanado 2a: 010001000100
Devanado 2b: 000100010001
Nota: Sólo la mitad de cada bobina se activa en un tiempo en la secuencia anterior. Como antes, la siguiente secuencia girará el motor hacia la derecha 12 pasos o una revolución.
Ejemplo secuencia 2
Devanado 1a: 110011001100
Devanado 1b: 001100110011
Devanado 2a: 011001100110
Devanado 2b: 100110011001
A diferencia de la primera secuencia descrita, en la segunda secuencia, dos mitades de la bobina se energizan al mismo tiempo. Esto le da al motor más par motor, pero también aumenta el consumo de energía del motor. Cada una de las secuencias anteriores describe pasos simples o paso nominal en su tamaño paso a paso del motor (en este caso 30 grados). La combinación de estas dos secuencias permite la mitad del paso del motor paso a paso. La secuencia combinada se muestra en el ejemplo 3 (24 pasos por vuelta).
Este método mueve el motor en pasos que son la mitad de su tamaño de paso nominal. Es importante tener en cuenta que el par generado por el motor durante esta secuencia no es constante, como medidas alternas tienen mitad de uno y dos de un bobinado energizado, respectivamente.
Ejemplo secuencia 3
Devanado 1a: 11000001110000011100000111
Devanado 1b: 00011100000111000001110000
Devanado 2a: 01110000011100000111000001
Devanado 2b: 00000111000001110000011100
La figura anterior, muestra el motor unipolar más básico. Para mayor resolución angular, el rotor debe tener más polos. Se han hecho rotores de imanes permanentes con 100 polos y esa cifra de polos es comúnmente logrado para los rotores híbridos, usando dientes de tapas finales en un simple imán permanente bipolar. Cuando el rotor tiene un recuento alto de polos, los polos del estator son siempre dentados de modo que cada bobina del estator va en contra de un gran número de polos rotor.
Para hacer girar un motor unipolar, se aplican impulsos en secuencia a sus devanados, la secuencia de estos impulsos, se aplican con un controlador electrónico externo. Los controladores se diseñan de manera que el motor se pueda mantener en una posición fija y también para que se le pueda hacer girar en ambos sentidos. Los motores unipolares, se pueden hacer avanzar a frecuencias de audio, lo que les permite girar muy velozmente. Este es el motivo por que se suele decir que un motor «canta», debido a la frecuencia a la que se produce la conmutación. Con un controlador apropiado, se les puede hacer arrancar y detenerse en cualquier instante y en una posición determinada. Este es en teoría, el símbolo de un motor unipolar.
Haré hincapié en este punto, el punto decisorio para mover un motor unipolar, estriba en la secuencia que se aplica a los devanados del mismo.
Como ya se ha comentado, estos motores, tienen varios bobinados que, para producir el avance de un paso, deben ser alimentados en una secuencia adecuada. Al invertir el orden de esta secuencia, se logra que el motor gire en sentido opuesto. El torque de detención hace que, un motor unipolar con tensión, se mantenga firme en su posición cuando no está girando.
Si adquirimos un motor paso a paso, es bastante sencillo conocer las características del motor, sin embargo, lo más común es que nos encontremos ante un motor de desguace. Cómo distinguir ante que motor nos encontramos; el procedimiento es bastante sencillo, el primer paso es mirar en el cuerpo del motor si permanece alguna leyenda que nos pueda servir de orientación como puede ser, el fabricante, modelo, la tensión o alguna otra pista que nos indique las características más inmediatas.
Si no se dispusiera de dichas indicaciones, generalmente presentan varios cables de conexión. Los motores paso a paso unipolar generalmente con seis cables, en dos tríos, cada trío alimenta una bobina con toma central. En ocasiones, encontraremos un motor unipolar con sólo cinco cables, aquí los dos «comunes» se han unidos internamente.
Identificar los bobinados, es bastante fácil la identificación, cada uno usa su propio método, uno puede ser este, aplicando una tensión entre dos terminales, se pueden identificar los correspondientes a cada bobinado, teniendo en cuenta que hay un común para cada bobina, según se muestra en la figura que sigue. La nomenclatura de los cables (A, B, C, D) es totalmente arbitraria.
Fig. 3
Otra forma de identificación es mediante un Ohmetro, comparando la resistencia entre pares de cables, teniendo en cuenta que cada devanado tiene una toma intermedia. Debido a que estos motores, disponen de un imán permanente, con la aplicación de una tensión entre los terminales de una bobina, el flujo de corriente a través de la bobina, hará mover el eje en una dirección, observando el siguiente movimiento en la misma dirección, nos indicará los pasos de la secuencia, siga probando con la bobina del otro devanado hasta completar la secuencia de los cuatro pasos necesarios. Cuando tenga los cuatro pasos, dispondrá de la secuencia para girar en esa dirección.
Fig. 4
Como ya se ha comentado, hay tres tipos de secuencias posibles para manejar motores unipolares. Siguiendo dicha secuencia, el motor avanzará en un sentido hasta llegar al cuarto u octavo paso. Para invertir el sentido de giro, simplemente se deben ejecutar las secuencias en modo inverso.
La configuración de los motores unipolares, requiere que las bobinas reciban corriente de encendido-apagado en secuencia y no como los motores bipolares, que reciben corriente en ambos sentidos. Un motor unipolar, requiere menos componentes que conectar y para no utilizar un controlador (L293 o ULN2003), utilizaremos algunos transistores universales NPN para proporcionar la corriente necesaria a los devanados.
SECUENCIA SIMPLE.
En esta secuencia, se activa solo una bobina a la vez. En algunos motores, esto brinda un funcionamiento mas suave. La contrapartida es que al estar solo una bobina activada, el torque de paso y retención es menor.
En esta secuencia se alimenta sólo una bobina a la vez, lo que proporciona un menor par motor y una menor potencia de entrada. Al mover un paso en la secuencia a la siguiente, hace mover el motor un paso. Si vamos hacia adelante en la secuencia, el motor se mueve hacia adelante un paso y si lo hacemos al revés, el motor se mueve un paso atrás.
Fig. 5
Es momento de realizar algún ejercicio que ilustre tanta teoría. Empezaremos por presentar un código que ya esta en la red, cuya autoría queda reflejada en el propio código. Creo que es suficiente como ejemplo y está probado.
Control Motor Unipolar.
Secuencia simple.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
/* Motor paso a paso * --------------------------- * * Programa para manejar un motor paso a paso unipolar extraído de una * unidad de disquete de 5'25. De acuerdo a la documentación que * he encontrado, este: "[...] motor paso a paso fabricado por * Copal Electronics, con 1,8 grados por paso y 96 ohmios por cada * vuelta (de la bobina), con una etapa central conectada a diferentes * cables [...]" * [http://www.cs.uiowa.edu/~jones/step/example.html] * * Es un motor paso a paso unipolar con cinco cables: * * El color de los cables puede ser diferente * - rojo: conector de alimentación, lo tengo a 5V y funciona bien * - naranja y negro: bobina 1 * - marrón y amarillo: bobina 2 * * (cleft) 2005 DojoDave for K3 * http://www.0j0.org | http://arduino.berlios.de * * @author: David Cuartielles * @date: 20 Oct. 2005 */ int motorPin1 = 8; // PIN-es del Motor int motorPin2 = 9; int motorPin3 = 10; int motorPin4 = 11; int delayTime = 500; // Delay que determina la velocidad de giro void setup() { pinMode(motorPin1, OUTPUT); // Configuración de los PIN-es como salida digital pinMode(motorPin2, OUTPUT); pinMode(motorPin3, OUTPUT); pinMode(motorPin4, OUTPUT); } void loop() { // Los pines se activan en secuencia digitalWrite(motorPin1, HIGH); // Primer paso digitalWrite(motorPin2, LOW); digitalWrite(motorPin3, LOW); digitalWrite(motorPin4, LOW); delay(delayTime); digitalWrite(motorPin1, LOW); // Segundo paso digitalWrite(motorPin2, HIGH); digitalWrite(motorPin3, LOW); digitalWrite(motorPin4, LOW); delay(delayTime); digitalWrite(motorPin1, LOW); // Tercer paso digitalWrite(motorPin2, LOW); digitalWrite(motorPin3, HIGH); digitalWrite(motorPin4, LOW); delay(delayTime); digitalWrite(motorPin1, LOW); // Cuarto paso digitalWrite(motorPin2, LOW); digitalWrite(motorPin3, LOW); digitalWrite(motorPin4, HIGH); delay(delayTime); } |
Como es de costumbre, puede copiar dicho código y probar su efectividad, pulse sobre «Seleccionar todo» y proceda como viene haciendo en anteriores casos.
SECUENCIA EN ONDA.
Esta es la secuencia que generalmente recomienda el fabricante. Con esta secuencia el motor avanza un paso por impulso y debido a que siempre hay al menos dos bobinas activadas, se obtiene un alto torque de paso y retención, es la secuencia más usada.
Fig. 6
En esta segunda secuencia, se alimentan dos bobinas a la vez y produce un par motor de aproximadamente un 40% mayor que el de la secuencia anterior, mientras que también, consume el doble de energía, ver la tabla anterior.
Stepper Unipolar avanzado.
Secuencia en onda.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
/* Stepper Unipolar Advanced * ------------------------- * * Program to drive a stepper motor coming from a 5'25 disk drive * according to the documentation I found, this stepper: "[...] * * Se trata de un motor paso a paso unipolar con cinco cables: * It is a unipolar stepper motor with 5 wires: * * Los colores de los cables puede variar * - red: power connector, I have it at 5V and works fine * - orange and black: coil 1 * - brown and yellow: coil 2 * * (cleft) 2005 DojoDave for K3 * http://www.0j0.org | http://arduino.berlios.de * * @author: David Cuartielles * @date: 20 Oct. 2005 */ int motorPins[] = {8, 9, 10, 11}; // declara matriz pines int count = 0; int count2 = 0; int delayTime = 500; int val = 0; void setup() { for (count = 0; count < 4; count++) { // declara matriz 4 pines de salida pinMode(motorPins[count], OUTPUT); } } void moveForward() { // giro de avance if ((count2 == 0) || (count2 == 1)) { count2 = 16; } count2>>=1; for (count = 3; count >= 0; count--) { digitalWrite(motorPins[count], count2>>count&0x01); } delay(delayTime); } void moveBackward() { // giro de retroceso if ((count2 == 0) || (count2 == 1)) { count2 = 16; } count2>>=1; for (count = 3; count >= 0; count--) { digitalWrite(motorPins[3 - count], count2>>count&0x01); } delay(delayTime); } void loop() { val = analogRead(0); // pin analogico 0, al pot. if (val > 540) { // se mueve más rápido cuanto mayor sea el valor del potenciómetro delayTime = 2048 - 1024 * val / 512 + 1; moveForward(); } else if (val < 480) { // se mueve más rápido cuanto menor sea el valor del potenciómetro delayTime = 1024 * val / 512 + 1; moveBackward(); } else { delayTime = 1024; } } |
En esta ocasión, el código a utilizar contiene unas funciones que, conviene tener en cuenta en nuestros propios códigos. Este código, también hace referencia al autor al que pertenece.
Quiero destacar, algunos aspectos que se aportan en este código, por ejemplo: en la declaración de pines de salida para el motor, se ha empleado una matriz (array) de cuatro elementos y esta es la forma que tiene:
int motorPins[] = {8, 9, 10, 11};
Otro aspecto a destacar, se refiere al uso de los bucles for , como vemos en esta secuencia del código:
for (count = 0; count < 4; count++) {
pinMode(motorPins[count], OUTPUT);
}
y los if, como en este caso:
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
Deben entenderse bien estos procedimientos, para poder utilizarlos en nuestros códigos, esto, los hará más compactos y cortos, si bien no los utilizo a menudo, para dar una mayor claridad a quien la necesite.
SECUENCIA DE MEDIO-PASO.
Esta secuencia es, la resultante de añadir a cada paso de la secuencia anterior, un paso, en otras palabras, es la suma de las dos secuencias anteriores. Esto significa que esta secuencia, consta de ocho paso, justo el doble que cada una de las dos anteriores, veamos la tabla.
Fig. 7
Esto, se traduce en un giro más suave y preciso de modo que, el avance dependerá de la frecuencia en que se aplican los pulsos. Dicho esto, es conveniente no olvidar la inercia que presentan estos motores, por lo que, hay tener en cuenta el tiempo del impulso y la frecuencia de los pulsos. Si no se pone cuidado en la frecuencia de los pulsos, el motor puede reaccionar de modo inesperado, tal que no gire o que gire de modo arbitrario.
La frecuencia de los pulsos a aplicar, depende de factores como; la inercia del rotor, la tensión de trabajo y sobre todo el ancho del pulso, esto se puede obtener mediante, ensayo/prueba/error. Para obtener un arranque suave y preciso, conviene comenzar con una frecuencia de pulso baja e ir aumentándola gradualmente hasta alcanzar la velocidad deseada, sin superar la máxima tolerada por el motor. El cambio de dirección de giro, debe realizarse primero, bajando la velocidad de giro y luego cambiar el sentido de rotación.
CONEXIONADO DE UN MOTOR UNIPOLAR.
Se puede mover un motor unipolar, de distintas formas, en algunos casos lo podemos hacer utilizando cuatro salidas del micro, en otros casos, debido a tener limitadas las salidas, debemos utilizar sólo dos y en este caso, debemos cumplimentar de algún modo las dos bobinas que quedan libres. Como de costumbre, unos pequeños ejemplos ilustrarán mejor lo descrito.
CONTROL CON CUATRO CABLES.
Fig. 8 Unipolar con 4 hilos y ULN2003
En este ejemplo el código es muy sencillo y descriptivo, en primer lugar, se definen los pasos necesarios para girar 360º, sigue la configuración de los pines a utilizar del motor y el resto del corto código, para que gire en ambos sentidos, separado por una pequeña pausa.
Motor con cuatro cables.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <Stepper.h> // lib. Stepper.h #define STEPS 400 //360° divided by step angle Stepper stepper(STEPS, 8, 9, 10, 11); void setup(){ stepper.setSpeed(30); //RPMs } void loop(){ stepper.step(100); delay(100); stepper.step(-100); delay(100); } |
La sencillez del código es debido principalmente al uso de la librería <Stepper.h> que, nos facilita el trabajo. Aunque es cierto que esta librería es muy básica, queda claro que es suficiente para este caso.
CONTROL CON DOS CABLES.
Fig. 9 Unipolar con 2 hilos y ULN2003
En este segundo ejemplo, el código es igual de sencillo. La diferencia estriba en lo que en la propia librería llaman construcción del motor (se refiere a la definición de los pines utilizados como salidas para el motor), he coloreado en el código, la línea que corresponde a dicha definición.
Motor con dos cables.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <Stepper.h> // lib. Stepper.h #define STEPS 400 //360° divided by step angle Stepper stepper(STEPS, 8, 9); void setup(){ stepper.setSpeed(30); //RPMs } void loop(){ stepper.step(100); delay(100); stepper.step(-100); delay(100); } |
Como se puede comprobar he utilizado el mismo código. El cambio reside en la declaración de lo que se ha dado en llamar constructor del motor. Si revisamos la mencionada librería Stepper.h, podemos observar que dispone de dos tipos de constructores de motor:
// constructors:
Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2);
Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int motor_pin_3, int motor_pin_4);
Es bastante explicito. Veamos ahora un caso más sofisticado.
CONTROL DE DIRECCIÓN Y VELOCIDAD.
El siguiente esquema, representa el esquemático que voy a utilizar, en esta ocasión para controlar el avance o retroceso del giro de un motor unipolar. Dispondré de dos pulsadores, para iniciar los sentidos de giro y mediante el potenciómetro, modificaré la velocidad a voluntad en cada momento. He utilizado la rutina «parar todo» para hacer una parada antes de iniciar cada modo de giro, tiempo suficiente para vencer la inercia adquirida por el motor.
Fig. 10
He aquí un pequeño ejemplo de conexión del uso de la plataforma Arduino, para controlar las cosas en el mundo real, sin necesidad de utilizar las librerías «Stepper.h». Sigue, el listado del código que se encarga de generar los ocho pasos de la secuencia, descritos en los párrafos anteriores.
Motor Unipolar con pot.
Secuencia de medio-paso.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
/* stepperunipolar1.pde http://www.bristolwatch.com/arduino/arduino_unipolar_stepper.htm Dependiendo del tipo de motor intercambiar los cuatro números de abajo (8-11) hasta que funcione el motor. Disponemos dos pulsadores para girar en dos sentidos y un pot. para variar la velocidad de giro. La secuencia que sigue, procede a través de la experimentación con este motor unipolar. Puede ser diferente para otro motor. La velocidad se controla por un retardo entre cada paso. A mayor retardo, velocidad mas lenta. Para mayor velocidad cambiar el 10 por 2. Esta se calcula entre cada paso para variar la velocidad, mientras que se mueve. El valor del retardo se obtiene de la lectura y conversión analogico-a-digital (AD0 en este caso), entregando un valor entre 0 y 1023. Los valores son divididos por 4 y se suma 10 para el retardo en milisegundos: delay(analogRead(0)/4 +10) Modificado y actualizado: 05.05.2011 por: V. Garcia Los siguientes comandos serán compilados en código de máquina y cargados en el microcontrolador. Tamaño compilado con IDE Arduino v0013: 3154 bytes. */ #define Motorpin1 8 // D1, devanado 1 del motor, pin 8 #define Motorpin2 9 // D2, devanado 2 del motor, pin 9 #define Motorpin3 10 // D3, devanado 3 del motor, pin 10 #define Motorpin4 11 // D4, devanado 4 del motor, pin 11 #define CW 3 // SW0 pulsador, pin 3 #define CCW 4 //SW1 pulsador, pin 4 // Entrada analógica potenciómetro en pin 0. #define ledPin 13 int v = 2 ; // variar velocidad void setup() { pinMode(CW, INPUT); pinMode(CCW, INPUT); digitalWrite(CW, 1); // activa la RPA, pull up on digitalWrite(CCW,1); // activa la RPA, pull up on pinMode(Motorpin1, OUTPUT); pinMode(Motorpin2, OUTPUT); pinMode(Motorpin3, OUTPUT); pinMode(Motorpin4, OUTPUT); // inicia con todas las bobinas apagadas digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); // set up the LED pin: indicador pinMode(ledPin, OUTPUT); // blink the LED: blink(3); } void loop() { all_coils_off(); // apaga bobinas, rueda libre. Comentar para bloquear if (!digitalRead(CW)) { // espera que se presione pulsador avance forward(20000); // pasos que avanza blink(3); // parpadea LED } if (!digitalRead(CCW)) { // espera que se presione pulsado reverso reverse(20000); // pasos que retrocede blink(3); // parpadea LED } } // final del lazo (loop) void all_coils_off(void) { // apaga bobinas digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); } void forward(int i) { // gira como el reloj while (1) { // i = 20000 // 1 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); // pin analógico 0, entrada pot. i--; if (i < 1) break; // 13 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 3 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 32 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 2 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 24 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 4 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 14 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; } } void reverse(int i) { // gira contra el reloj while (1) { // 14 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 4 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 24 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 1); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 2 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 23 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 1); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 3 digitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 13 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 1); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; // 1 digitalWrite(Motorpin1, 1); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); delay(analogRead(0)/4 + v); i--; if (i < 1) break; } } // Blink el indicador LED: void blink(int howManyTimes) { int i; for (i=0; i< howManyTimes; i++) { digitalWrite(ledPin, HIGH); delay(200); digitalWrite(ledPin, LOW); delay(200); } } |
En este ejemplo, he utilizado la opción de aplicar una salida de Arduino, a cada uno los cuatro drivers del ULN2003 y sus salidas a cada devanado del motor unipolar. El terminal común, como se ve, se aplica al positivo de la tensión que necesita el motor, en mi caso, al positivo +12V, recordar que sólo los negativos de ambas alimentaciones deben estar unidos.
Fig. 11
Con este método, no se requiere la librería que habitualmente se utiliza para controlar el motor unipolar.
UNIPOLAR FRENTE BIPOLAR.
Imán permanente y los motores paso a paso híbridos están disponibles con bobinas unipolar, bipolar o bifilar, esta última se puede utilizar en configuraciones unipolar o bipolar. La elección entre el uso de un sistema de accionamiento unipolar o bipolar se basa en cuestiones de la simplicidad y la unidad de potencia / peso.
Motores bipolares tienen aproximadamente un 30% más de par que un motor equivalente unipolar del mismo volumen. La razón de esto es que sólo la mitad de una bobina es energizada en un momento dado en un motor unipolar. Un motor bipolar utiliza la totalidad de una bobina cuando está energizado.
El par más alto generado por un motor bipolar se no obtiene sin un precio. Los motores bipolares requieren circuitos de control más complejo que los motores unipolares. Esto tendrá un impacto en el costo de una aplicación. En caso de duda, un motor unipolar o el motor bifilar son buenas opciones. Estos motores se puede configurar como un motor unipolar o bipolar y la aplicación de pruebas con los motores que operan en cualquiera de los modos.
PAR NOMINAL O TORQUE.
El torque es una consideración crítica al elegir una motor paso a paso. Los motores paso a paso tienen diferentes tipos de par nominal. Estos están en:
- Par de bloqueo – Al torque requerido para girar el eje del motor a la vez que las bobinas se energizan.
- Par de palanca – El par contra el que un motor puede acelerar desde cero sin perder ningún paso, cuando se maneja a una velocidad constante paso a paso.
- Par Extraíble – A la carga que un motor puede mover cuando está en velocidad de funcionamiento.
- Par de Retén – Al torque requerido para girar el eje del motor, mientras que las bobinas no están energizados.
Los fabricantes de motor paso a paso, especifican varios o todos de estos momentos de torsión en sus hojas de datos para sus motores.
MOTORES HÍBRIDOS.
Los motores híbridos comparten los principios de funcionamiento de ambos motores paso a paso, imán permanente y de reluctancia variable. El rotor de un motor paso a paso híbrido es la cabeza de arranque múltiple, como el motor de reluctancia variable y contiene un imán magnetizado axialmente concéntrico alrededor de su eje. Los dientes en el rotor proporcionan una camino que ayuda a guiar el flujo magnético a lugares preferidos del entrehierro…
Bueno, esto ya se sale del cometido de este tutorial. Si está interesado en el tema, le aconsejo que lea la nota de aplicación AN907 (Stepper).
Este, ha sido un artículo en el que se ha intentado presentar, distintas formas de controlar el movimiento de un motor paso a paso unipolar. En los códigos, se presenta tres formas de activar las bobinas y de alguna forma los rendimientos de cada uno de los códigos.
Como es de costumbre, puede copiar dicho código y probar su efectividad, y proceda como viene haciendo en anteriores casos.
Esto es todo, por este simple tutorial.
Hola esta fenomenal, tu explicación, yo tengo un motor unipolar de 4,6 V y 3,1 Amp. de la marca SLO-SYN MOTOR Modelo X250-1030 U ¿se podría utilizar este mismo circuito? gracias
Saludos: Juan