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.
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 estátor y los dientes del rotor, en la dirección del flujo de corriente a través de los bobinados del estátor, es irrelevante, estos motores funcionan mediante la atracción de los polos norte o sur permanentemente el rotor magnetizando a la polos del estátor.
Así, en estos motores, la dirección de la corriente a través de las bobinas del estátor determina que, los polos del rotor se sentirán atraídos por los polos del estátor. La orientación de corriente en los motores unipolares, depende de que la 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 estátor, 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 esta figura.
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 estátor multipolar. Esta sería una secuencia de 12 pasos para mover el motor.
Ejemplo secuencia 1
Winding 1a: 100010001000
Winding 1b: 001000100010
Winding 2a: 010001000100
Winding 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á del motor hacia la derecha 12 pasos o una revolución.
Ejemplo secuencia 2
Winding 1a: 110011001100
Winding 1b: 001100110011
Winding 2a: 011001100110
Winding 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 motor paso a paso. La secuencia combinada se muestra en el ejemplo 4 (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 mitades de uno y dos de un bobinado energizado, respectivamente.
Ejemplo secuencia 3
Winding 1a: 11000001110000011100000111
Winding 1b: 00011100000111000001110000
Winding 2a: 01110000011100000111000001
Winding 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 estátor son siempre dentados de modo que cada bobina del estátor 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.
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.
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.
| Secuencia simple | ||||||
| Bobinas | ||||||
| A | C | B | D | |||
| Paso1 | + | – | – | – | ||
| Paso2 | – | + | – | – | ||
| Paso3 | – | – | + | – | ||
| Paso4 | – | – | – | + | ||
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.
|
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 |
/* 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 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 «Ver código» 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.
| Secuencia en onda | ||||||
| Bobinas | ||||||
| A | C | B | D | |||
| Paso1 | + | + | – | – | ||
| Paso2 | – | + | + | – | ||
| Paso3 | – | – | + | + | ||
| Paso4 | + | – | – | + | ||
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.
|
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 |
/* 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:
|
1 |
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.
|
Secuencia medio-paso |
||||||
| Bobinas | ||||||
| A | C | B | D | |||
| Paso1 | + | – | – | – | ||
| Paso2 | + | – | + | – | ||
| Paso3 | – | – | + | – | ||
| Paso4 | – | + | + | – | ||
| Paso5 | – | + | 0 | – | ||
| Paso6 | – | + | – | + | ||
| Paso7 | – | – | – | + | ||
| Paso8 | + | – | – | + | ||
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.
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#include "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.
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 la línea que corresponde a dicha definición.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include "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.
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.
|
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 analógico-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. García 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() { // Comentar para bloquear, línea que sigue all_coils_off(); // apaga bobinas, rueda libre. 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, 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. 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 energía 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, pulse sobre «CODIGO: Seleccionar todo» y proceda como viene haciendo en anteriores casos.
I wanted to spend a mnitue to thank you for this.
Hola, primero que nada agradecerte este articulo, muy ilustrativo y completo.
Hace poco compre mi primer arduino y me lance a controlar un motor paso-paso unipolar de una vieja impresora. Para ello use el mismo driver uln2308a. 0 exito. El arduino, al cual conecte unos leds para ver la secuencia, daba las señares perfectamente. el motor es bastante gordo de una HP, segun vi en las especificaciones de un motor parecido es de 24 voltios. Asi que pense que los 5 voltios de Arduino no eran suficientes: hacia falta mas madera. conecte un transformador que da 15 voltios y 1A. Como 15<24 todo bien (lease, mis conocimientos de electronica son escasos). El resultado fue que queme el driver. un chasquidito y adios.
Entonces adverti el diodo Zener, que parece ser que protege al ULN2308, solo tengo unos de 8.5 voltios (que tampoco tengo muy claro la diferencia con uno normal), pero quiero mover mi motor de 24 voltios con mi transformador de 15 voltios 1 un amperio. Como puedo enchufar el escenario? puedo juntar varios diodos Zener? Si uno (solo) las masas de mi arduino y mi transformador no pasa nada o debo proteger mi arduino de alguna manera. Y si el motor fuera de 48 voltios y el transformador fuera de 48 voltios, como se harian los calculos? usando el mismo driver uln2308A
Muchas Gracias, Daniel.
Hola Daniel.
Por motivos de tiempo no pude responder antes.
Para poder mover tu motor HP que comentas, necesitas disponer de 24V. El zener tiene una función de seguridad, lo que hace es, derivar tensiones.
Ten en cuenta que cuando intercalas un dispositivo (diodo, resistencia, LED, zener) a una tensión, siempre produce una reducción de aquella, puesto que pone su carga en dicha tensión y algo consume. Se deduce que nunca puede aumentar la tensión.
Así pues, necesitas una tensión de 24V o te buscas un motor de menor tensión de trabajo, los hay de impresora de 5V, de 12V, etc.
Espero te aclare las dudas.
Saludos.
hola Vicente, saludos, seria posoble que me dieras una asesoria mas amplia al respecto, solo tengo los conocimientos basicos de electronica y te comento que necesito hacer un proyecto en el que el motor gire un cartel 90° en ambos sentidos, permaneciendo estatico 4 segundos de paro antes de regresar y girar al lado contrario, esto es para mover un cartel que iniciaria de canto (sin presentar visivilidad) y la idea del giro es mostrar lo que se encuentra en cada cara, no se si nos pudieramos poner de acuerdo y vernos o por este medio… te lo agradeceria o que me envies tu correo y poderme comunicar contico… gracias
Me pongo en contacto contigo, ya que no comentas nada sobre las dimensiones del cartel, si estará en el exterior (supongo que sí), cuanto pesa, que mecanismo tienes pensado utilizar para moverlo.
Te paso un mensaje privado.
Saludos Vicente.
Hola vicente muy buena toda tu explicacion preo saber me gustaria controlar 2 motores p.a.p. con sus potenciometros y sus switch de giro me podrias ayudar por favor tanto con el codigo como para el circuito de coneccion ( es para controlar una camara de video) muchas gracias.
Hola muy buena la explicacion, tengo la ultima compilacion de Arduino, pero al parecer no reconoce la entidad
<como podria escribirse la misma linea ya que para que pueda compilar necesita una comparacion… la compilacion se llama nigthly y el compilador se detiene y queda en donde encuentra la primer linea de < (less than)… gracias por lo que pudieras ayudarmeConsulta: Estoy controlando dos PAP 28BYI 48 con Arduino Uno y Placa Shield, y como no puedo modificar la mecanica, preciso saber, como hago para que dada una informacion desde Stellarium (GOTO telescopio), al motor llegue una fraccion de pasos, con lo que conseguiria que el desplazamiento angular sea menor. Que no se entienda con la funcion Simple/Double/….
Muchas gracias.
Angel Labombarda, lamento no poder responder con una solución, ya que no conozco este motor 28BYJ 48.
Trata de modificar un poco la cantidad de pasos, sin llegar a producir saltos, se me ocurre otra forma que trataría de crear un mapa del recorrido del motor, como si fuera un servo, por probar algo diferente.
Saludos y Feliz Año Nuevo.
Hermos y claro artículo .Gracias y felicito su generosidad !
Hola Alfredo Gaggero.
Gracias por tus palabras.
Muchas gracias por la explicación! Sumamente clara…
Yo algo de experiencia tengo en electrónica, pero «CERO» en automatización y control.
Tengo 3 motores unipolares Vexta PH2610-01, unipolares, y quisiera usarlos para armar una fresadora CNC con Arduino. Escuche que puedo conectarlos como Bipolares no usando los puntos medios, pero pierden potencia dijeron. No se cuanto pierden, pero los motores originalmente son de 106 N/CM. La otra opción es usar el controlador que usó en esta explicación, pero son 3, y no sé como conectarlos al Arduino 1. No encontré nada en la Web haciendo lo que necesito. Es posible?
Alternativamente, cuanta potencia perdería si lo conecto en modo «Bipolar» con controladoras A4988? Si es que esto tambien es posible.
Desde ya, agradezco la ayuda que pueda darme con esto. Saludos cordiales!
Gracias por compartir sus conocimientos, muy buena explicación e información y por tomarse el tiempo de publicarlo, la mejor publicación que he encontrado sobre el tema. Me ayudó mucho a entender el problema que estaba teniendo con un motor unipolar, y resolverlo.
Muchas gracias, felicidades por tan buena aportación.
Saludos desde Yucatán, México.
Hola Julio Lugo.
Gracias por tus palabras.
Sobre todo me alegra que te haya servido para mejorar tus conocimientos sobre los motores unipolares y demás.
Saludos y cuídate.