Source: http://xaviergp.blogspot.com.es/2014/02/
Timestamp: 2017-08-20 08:07:37+00:00

Document:
Fotografías panorámicas y otras cosillas: febrero 2014
Cuando adquirimos un motor del tipo paso a paso tiene una serie de características :
* Voltaje de alimentación de las bobinas.En mi experiencia , a veces me he vuelto loco si viene expresado en voltaje de la bobina . Hay que tener encuenta que el driver muchas veces lo que nos hace es dividir esta tensión y aplica +V/2 a una salida de bobina , mientras que en la otra aplica -V/2. Total, que la tension entre los dos bornes del bobinado es V, entonces cuando compro el motor , la característica que me dice el datasheet es tensión por fase , como yo utilizo fuentes de alimentación de unos 5v , elijo motores que tengan una tensión por fase cercana a 2.5v o algo superior.
* Intensidad maxima de las bobinas. Es otro factor a tener en cuenta, ya que el driver tiene que estar preparado para aguantar esta intensidad.
* Pasos del motor (por ejemplo 200). Este número representa el número de impulsos que hay que inyectarle para que de una vuelta entera. Con esto tenemos una resolución de 360º/200 impulsos que es lo mismo que 1.8 º/impulso.
Hoy voy a comentar el tema micropasos que es una manera de ganar resolución de giro del motor pero en su contra perdemos fuerza en el mismo, como siempre, hay que buscar el equilibrio y las necesidades.
Un motor paso a paso estandard se descompone en 4 movimientos tal y como vimos en los anteriores posts.
1010 HIGH LOW HIGH LOW
0110 LOW HIGH HIGH LOW
0101 LOW HIGH LOW HIGH
1001 HIGH LOW LOW HIGH
Esta rutina se repite hasta 50 veces en un motor de 200 pasos hasta completar toda la vuelta.
Como que se trata de salidas digitales que gestionamos por defecto en nuestro Arduino a través de la libreria Stepper, si modificamos esta podremos cambiar el comportamiento de nuestro motor.
Por ejemplo podemos crear los medios pasos siguiendo la siguiente lógica:
Si utilizamos salidas digitales podremos obtener el siguiente trazo (tendremos unos cambios de torque muy bestias (+41%) cuando utilizemos las dos bobinas a la vez :
Mientras que si nos tiramos por las salidas analógicas podemos obtener una esfera en su posicionamiento obteniendo un torque más regular:
Cambiando la libreria lograriamos convertir nuestro motor en 400 pasos y una resolución de 0.9º. Para ello tendremos que editar el archivo Stepper.cpp en la linea dónde dice
stepMotor(this->step_number % 4); hay que sustituirlo por stepMotor(this->step_number % 8); dónde este 8 significa el numero de "movimientos" posibles. Finalmente también hay que modificar la parte final de la libreria, en este caso debería cambiar en el caso de utilizar salidas digitales :
case 1: // 1010
case 4: //0100
case 5: //0101
case 6: //0001
En caso de querlo hacer con salidas analogicas , se deberia usar siguiendo instrucciones del siguiente tipo:
analogWrite(motor_pin_3, 255);
analogWrite(motor_pin_4, 0);
analogWrite(motor_pin_1, 180);
analogWrite(motor_pin_3, 180);
Y en nuestro programa de Arduino también deberemos modificar la linea dónde le definimos el número de pasos de nuestro motor (por ejemplo: #define motorSteps 800 )
Y a partir de aqui tenemos otra opción que es generar los micropasos, es decir 1/4 , 1/8, 1/16 , 1/32 de paso, para ello hay que modificar la libreria también. Llegados a este punto de resolución deberemos usar salidas analogicas en vez de digitales, para ello lo haremos con las marcadas como PWM (en realidad no dan una salida constante pero si una tensión media). Recomendable una lectura sobre como funcionan las señales PWM.
De momento tendremos de sustituir las expresiones digitalWrite por analogWrite y en vez de dar un valor alto o bajo (HIGH o LOW) pasará a ser un valor entre 0 y 254 que es el rango en que trabaja nuestro pequeño arduino.
Para ello podriamos utilizar las siguientes tablas:
Estas tablas basicamente resultan de dividir en fracciones la columna grados por 4 veces la inversa del numero de micropasos (en este caso 4 x inversa de 1/4 = 16 movimientos electricos). Entonces dividimos los 360º de una vuelta en 16 y nos da la columna GRADOS. A continuación aplicamos el Sinus y el Cosinus (columnas SIN y COS), este par de valores oscilan entre -1 y 1 y como que nosotros trabajamos con salidas analógicas que van de 0 a 255 lo único que hacemos es multiplicar el valor por 255. Finalmente nos vamos a las 4 columnas de sálidas PWM. En las dos primeras va el valor del sinus. Si es un valor positivo va a la primera columna, mientras que si es negativo lo pondremos en la segunda columna pero siempre en valor absoluto (sígno siempre positivo , nunca negativo - Como el Van Gal!-). Las columnas tercera y cuarta es lo mismo pero con los valores de Cosinus.
He aquí las tablas para 1/4 de paso (800 impulsos/vuelta y resolución de 0.45º).
1/8 de paso (1600 impulsos/vuelta y resolución de 0.225º). Esta por ejemplo la tengo yo modificada para trabajar con drivers de 4 entradas. Si alguién la quiere que contacte conmigo.
Os dejo el código enterito de la libreria (no os rayeis! hay que acabarlo de pulir , y también renombrar el archivo .h )
Based on Stepper.cpp - - Stepper library for Wiring/Arduino - Version 0.4
Drives a unipolar or bipolar stepper motor using 4 wires
#include "Stepper3.h"
Stepper3::Stepper3(int number_of_steps, int motor_pin_1, int motor_pin_2, int motor_pin_3, int motor_pin_4)
this->valorPWM = valorPWM; // NEW ********
void Stepper3::setSpeed(long whatSpeed)
void Stepper3::step(int steps_to_move)
stepMotor(this->step_number % 32);
void Stepper3::stepMotor(int thisStep)
analogWrite(motor_pin_1, 50);
analogWrite(motor_pin_3, 250);
analogWrite(motor_pin_1, 98);
analogWrite(motor_pin_3, 236);
analogWrite(motor_pin_1, 142);
analogWrite(motor_pin_3, 212);
analogWrite(motor_pin_1, 212);
analogWrite(motor_pin_3, 142);
analogWrite(motor_pin_1, 236);
analogWrite(motor_pin_3, 98);
analogWrite(motor_pin_1, 250);
analogWrite(motor_pin_3, 50);
analogWrite(motor_pin_1, 255);
analogWrite(motor_pin_3, 0);
analogWrite(motor_pin_4, 50);
analogWrite(motor_pin_4, 98);
analogWrite(motor_pin_4, 142);
analogWrite(motor_pin_4, 180);
case 13: //
analogWrite(motor_pin_4, 212);
analogWrite(motor_pin_4, 236);
analogWrite(motor_pin_4, 250);
analogWrite(motor_pin_4, 255);
analogWrite(motor_pin_2, 50);
analogWrite(motor_pin_2, 98);
analogWrite(motor_pin_2, 142);
analogWrite(motor_pin_2, 180);
case 21: //
analogWrite(motor_pin_2, 212);
case 22: //
analogWrite(motor_pin_2, 236);
analogWrite(motor_pin_2, 250);
case 24: //
analogWrite(motor_pin_2, 255);
case 26: //
case 27: //
case 28: //
case 29: //
case 30: //
case 31: //
int Stepper3::version(void)
1/16 de paso (3200 impulso/vuelta y resolución de 0.1125º)
Y finalmente 1/32 pasos:
Mi experiencia con motores tipo NEMA-17 es que pierden mucha fuerza (ya de por si son pequeñitos) cuando trabajamos con micropasos, pero puede ser una buena solución en algunos casos.
Para vuestra curiosidad os informo que hay unos drivers "Big Easy Driver" de SparkFun que haciendo unos simples puentes ya podemos seleccionar si queremos trabajar con micropasos y os evitais la currada de modificar la libreria... Eso si, estos drivers no funcionan con las mismas ordenes utilizadas hasta ahora tipo MyStepper Stepper (200); es otro cantar, pero si buscais informacion en san Google la encontrareis.
Con estos tres posts espero que entendais como funciona un motor paso a paso para que lo podais implementar en vuestros inventos fotográficos.
Publicado por XavierGP en jueves, febrero 20, 2014 No hay comentarios:
Etiquetas: arduino, diy, micropaso, microstep, nema-17, paso a paso, PWM, stepper, xaviergp
Publicado por XavierGP en sábado, febrero 01, 2014 No hay comentarios:

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución