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.
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 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
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
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
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.
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.
| 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.
/* 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 girovoid 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.
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 | |||||
| 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.
/* 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;
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);
}
}
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&0×01);
}
delay(delayTime);
}
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
count2>>=1;
for (count = 3; count >= 0; count–) {
digitalWrite(motorPins[count], count2>>count&0×01);
}
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&0×01);
}
delay(delayTime);
}
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
count2>>=1;
for (count = 3; count >= 0; count–) {
digitalWrite(motorPins[3 - count], count2>>count&0×01);
}
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;
}
}
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);
}
pinMode(motorPins[count], OUTPUT);
}
y los if, como en este caso:
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
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.
Unipolar con 4 hilos
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.
#include <Stepper.h> #define STEPS 400 //360° divided by step angleStepper 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.
Unipolar con 2 hilos
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.
#include <Stepper.h> #define STEPS 400 //360° divided by step angleStepper 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íaStepper.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.
/*stepperunipolar1.pdehttp://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íaLos 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 13int v = 2 ; // variar velocidadvoid 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 bobinasdigitalWrite(Motorpin1, 0); digitalWrite(Motorpin2, 0); digitalWrite(Motorpin3, 0); digitalWrite(Motorpin4, 0); }void forward(int i) { // gira como el relojwhile (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 relojwhile (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.
/* 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;
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);
}
}
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&0×01);
}
delay(delayTime);
}
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
count2>>=1;
for (count = 3; count >= 0; count–) {
digitalWrite(motorPins[count], count2>>count&0×01);
}
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&0×01);
}
delay(delayTime);
}
if ((count2 == 0) || (count2 == 1)) {
count2 = 16;
}
count2>>=1;
for (count = 3; count >= 0; count–) {
digitalWrite(motorPins[3 - count], count2>>count&0×01);
}
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;
}
}
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;
}
}
Quitar publicidad a este blog: hosting wordpress
Prologo.
He querido poner en este sitio una versión personal, sobre la forma de trucar el giro de un servo, aunque primero diré que, un servo, también conocido por servo-motor, es un pequeño dispositivo que está dotado de un pequeño motor DC, con una caja reductora de velocidad y un circuito electrónico, mediante el cual, podemos situar el eje, en la posición deseada. Los servos, tiene tres cables para su control:
- Rojo, para positivo de alimentación (depende del modelo 4V a 6V).
- Negro, para el negativo o masa.
- Blanco o naranja, para la señal PWM de control.
El objetivo es mostrar la forma de trucar un servo S3003, para que se comporte como un motor DC, aquí, se muestra un trabajo propio, con datos propios. Los servos (Futaba S3003 y algunos otros), tienen la caja reductora que multiplica su par (fuerza de torsión) a cambio de la velocidad, mientras están alimentados, su fuerza de retención es su mejor cualidad, sin embargo, tienen un tope que les limita la excursión de giro, aproximadamente a 180º. En muchas ocasiones, nos gustaría que no tuviera esta limitación y aquí, es donde vamos a incidir.
La característica diferencial de un servo, se basa en el cable (blanco) de control. Se le aplica tren de pulsos de una determinada frecuencia, para posicionar el eje. En los Futaba, esta frecuencia tiene un período que está comprendido entre 0′9 ms y 2′1 ms, por lo que, como veremos, si aplicamos un período de 1′3 ms debemos obtener la posición central del giro primario del servo. Digo esto por que una vez terminemos de trucar el servo, éste, podrá girar en ambos sentidos y debe parar en el punto determinado por los 1′3 ms.
Existen dos formas de conseguir este cometido. Uno, consiste en eliminar toda la parte electrónica de control, pasando de disponer tres hilos (positivo, control y negativo o masa) a sólo dos (positivo y negativo). Y la otra forma es algo más sofisticada y se puede realizar de dos formas, cambiando el potenciómetro de control por uno multivuelta o modificando el potenciómetro de control, para que después de eliminar el tope mecánico, el control electrónico nos permita el ajuste al punto 0º (cero grados).
Pasos a seguir.
Debemos desmontar el sistema actual, por lo que tenemos que quitar los cuatro tornillos que sujetan la tapa inferior del conjunto servo y sacaremos con cuidado la tapa superior del servo que, contiene el reductor de velocidad, en ningún momento se debe forzar ninguna pieza, todas se desmontan sin esfuerzo.
Pondremos especial atención a la posición de cada uno de los engranajes, ya que posteriormente los deberemos recolocar. A continuación extraeremos el engranaje de salida del servo, en la imagen de abajo, tenemos una foto que nos ayudará a recolocar más tarde los engranajes en la posición correcta.
La parte mecánica del engranaje de salida, consistirá en cortar o limar el tope plástico del engranaje, de manera que no quede ninguna rebaba ni deformar los dientes del engranaje, en la imagen de abajo, un detalle comparativo de cómo deberá quedar el engranaje. Esto es todo por este apartado.
La parte que sigue es algo delicada, hay que extraer con cuidado, el bloque compuesto por el circuito impreso al que está soldado el motor y el resto del control de velocidad. Aprovechando los huecos de los tornillos que hemos quitado de las cuatro esquinas, haremos palanca con un destornillador adecuado y alternando los lados, para no causar problemas.
A partir de este punto, podemos elegir entre, eliminar toda la parte de control electrónico o mantener dicho sistema.
Caso 1.
En caso de no emplear la parte electrónica del control, se debe tener en cuenta la necesidad de utilizar según el caso un puente H o bien realizar un driver con transistores.
Lo que hacemos es simplemente desoldar el motor DC que está soldado a la placa, las líneas rojas de la imagen muestran los puntos de soldadura que hay que desoldar. Los cablecillos rojo y negro del conector, se pueden aprovechar, soldando cada uno en un contacto del motor.
Como se ve en la imagen anterior lo que queda ahora es soldar unos cables directamente al motor para controlarlo como un motor DC común. También es conveniente no olvidar, soldar una pequeña capacidad de 0′1nf en los mismos bornes del motor, para evitar interferencias.
Para terminar, como se aprecia en la foto, volveremos a introducir el motor en la caja del servo y cerraremos la caja colocando los engranajes tal y como estaban inicialmente.
Si utiliza los cables originales, se puede dejar el cable blanco en su sitio y mantenerlo como referencia de conexionado.
Caso 2
Para proyectos sencillos que utilicen motores en rotación continua, se pueden utilizar servos modificados con giro continuo, manteniendo su electrónica. El motivo principal es que sólo se necesita una salida digital para controlar velocidad y sentido de giro de dicho motor, por otra parte, al diseñar la electrónica, ésta se simplifica, no hace falta el puente en H, el sistema interno del servo ya lo dispone, además, este motor se gobierna como un servo sin trucar.
Si se puede, utilizar los potenciómetros multivuelta, sería la forma más cómoda ya que se sustituye el potenciómetro del eje por un multivuelta del mismo valor. El inconveniente es que hay que hacerle un taladro al chasis del servo para poder ajustar el “paro” del motor, con el ajuste del potenciómetro.
Taladro en la carcasa para acceso al ajuste del pot.En caso contrario, el potenciómetro se debe sustituir por la unión de dos resistencias del mismo valor, con una tolerancia del 1%, se pueden encontrar del valor de 2K5, los tres terminales, ocuparán los propios del potenciómetro.
Teniendo en cuenta que la frecuencia de la señal de control del servo es siempre de 50hz , lo que permite modificar el ángulo de giro es el tiempo que la señal está en alto. El tiempo en alto oscila entre los 0,9ms y los 2,1ms aproximadamente para las posiciones -90º y +90º respectivamente. La parada del motor, en este caso se hace por software, con un ancho de pulso sobre los 1,3 ms.
Vista del conjunto de piezas que componen el servomotor, antes de volver a montar en su sitio.
Realmente ha sido sencillo y ha servido para que hagan un ejercicio que les puede ayudar a comprender otros servos. Cualquier sugerencia será bien recibida.
Una versión en PDF la puede encontrar aquí.
No hay comentarios:
Publicar un comentario