viernes, 18 de noviembre de 2011

MANUAL RAPIDO MPLAB


Introducción.

En los proyectos que se describen en estas páginas utilizaremos el software de uso libre como es el MPLAB, si por alguna razón el lector quiere usar la versión que he manejado en estos artículos puede bajarse la versión 5 (¡ojo! pesa 11MBytes y si su conexión no es rápida puede tardar algo de tiempo) El motivo es que hemos de entender y aprender a utilizarlo para ensamblar nuestros proyectos, hacerlo fácil y esto es lo que vamos a describir aquí.
Si no se dispone de esta herramienta recomendamos se obtenga es gratis, para poder seguir nuestros pasos. En programación como ya se ha dicho en estas páginas, existen unas directivas generales que se utilizan de forma repetida y por ese motivo se ha descrito una plantilla del programador que encontrará en estás páginas, como herramienta menor de ayuda.
El entorno de trabajo MPLAB vers5, necesita de una configuración de las instrucciones para ‘que vaya como la seda’, ya hemos documentado este apartado en otras ocasiones y lo vamos a repetir aquí. Para empezar, se debe documentar todo nuestro trabajo, esto significa que los comentarios aclaratorios necesarios son: Nombre del AutorArchivo,Fecha y Descripción de qué hace el programa y para este fin el MPLAB dice que detrás de “; ” todo se considera comentario y no se tendrá en cuenta al compilar el listado.
Podemos hacer una primera incursión en el MPLAB para tener una visión general de cómo proceder a compilar un listado que tengamos en formato .asm, después entraremos en detalles más extensos. Estos son los pasos:
  1. Ejecutar el programa MPLAB. Hay disponibles cuatro menús de iconos, como muestra la figura de abajo. Elegir el segundo menú para empezar un proyecto y el primero, para ejecutar distintas acciones de análisis.
  2. Menú File-New, mostrará un cuadro de dialogo que dice: ‘A project is not currently opened’ o sea, que no hay un proyecto disponible, ‘desea crear uno’, pulsamos sobre la opción Yes para empezar. Si ya lo hemos usado con un proyecto y al salir lo guardamos, ahora nos propondrá si queremos abrirlo, pulsamos sobre la opción Yes para continuar con el proyecto.
  3. Mostrará una ventana ‘New Project‘ en la celda correspondiente daremos un nombre a nuestro proyecto y se puede elegir el directorio en el que guardarlo y pulsamos OK.
  4. Empezaremos a crear nuestro proyecto en la ventana ‘Edit Proyect‘ como se ve en la imagen de abajo a la izquierda.
  5.  En esta ventana hay cinco celdas en las que debemos introducir datos: En la primera, ‘Target Proyect’ aparecerá el nombre de nuestro proyecto. ‘Include Path‘, ‘Library Path‘ y ‘Linker …‘, se dejan como están. En ‘Development Mode‘ nos aseguramos que el sistema de desarrollo es el correcto ‘MPLAB SIM PIC16F84′ y en la cleda de abajo en ‘Language Tool Suite‘, se encuentra Microchip.
    Ahora viene la parte más compleja si se quiere, en el menú ‘Project’ la opción ‘Edit Project’ oCRTL+F3, abre un cuadro de dialogo, en la parte de abajo en ‘Project Files‘ aparecerá el nombre del archivo que vamos a producir con la extensión [.hex], al seleccionarlo, a su derecha se activará el botón ‘Node Properties…‘, lo pulsamos, aparecerá una nueva ventan con cuatro zonas diferenciadas, como se aprecia en la imagen de abajo, en la parte de arriba aparece la celda ‘Node‘ con el nombre del proyecto y la extensión hex, a su derecha la celda ‘Language Tool‘ que normalmente no se toca.
    En la zona central, se encuentra una cuadricula ‘Options‘ con seis columnas y distintas descripciones, observar que algunas no están activas, en definitiva y para acortar, deben estar activadas, en ‘On‘ las siguientes: ‘Hex Format‘, ‘Error File‘, ‘List File‘, ‘Case Sensitivity‘ y ‘Default radix‘ y activada en ‘Off‘ la de ‘Cross-reference File‘. Ya se describirán más adelante estos criterios, ver esto en la imagen que sigue.
    Debajo, en la zona ‘Command Line‘, se muestran las ordenes que se han generado en según lo asignado en el apartado anterior. En la última zona ‘Additional Command Line Options‘ estará en blanco. Y para cerrar pulsamos OK.
  6. Se mostrará la ventana en blanco, de título Untitle1, donde se debe escribir nuestro programa (código fuente). Sin embargo como ya se ha dicho, en muchas ocasiones ya lo dispondremos de nuestro editor más habitual, podemos traer el código fuente hasta la carpeta donde tenemos el proyecto con la extensión .prj . Entonces con el ‘Edit Project‘ pulsamos el botón ‘Add Mode…‘ y nos abrirá una ventana para seleccionar la carpeta en la que localizamos la que contiene el archivo con la extensión .asm que ya tenemos guardado y luego pulsamos ‘Aceptar‘. Ahora el archivo ‘puntoasm’  se muestra debajo del anterior y para cerrar pulsamos ‘OK‘.
  7. Digamos que, ya está en el simulador MPLAB el listado, por fin podremos compilar el programa.
  8. Es el momento de acceder al ‘Menú-Project‘ y ‘Make Project‘ o simplemente pulsamos la tecla F10. Esto abrirá una nueva ventana como la de la derecha, en la que se mostrará una barra de progreso de color verde e inmediatamente debajo, unos indicadores con los Errores, Warnings, Menssages, etc. si es que los hay, aunque no siempre hay errores.
Normalmente si hay errores, presentará una ventana como la mostrada debajo que, nos indicará todos los errores producidos y su localización el número de línea en la que se encuentra cada uno. Para corregir los errores, haremos doble clic en uno de ellos, el puntero se desplaza hasta la línea del listado de código que contiene el error, para que así lo modifiquemos. Revisamos las instrucciones que hayamos puesto, para corregir los fallos.
Una vez rectificados los errores, volveremos al paso 7 y procederemos a la nueva compilación del programa, verificaremos que no se hayan producido errores o los rectificaremos hasta lograr la depuración del programa. Recuerde que nadie es perfecto y aprenda de sus errores.
El caso más común es que después de ciertas correcciones no presente errores, quizás una atención (warning) y obtendremos el listado en hexadecimal que se ha creado en la misma carpeta donde está el proyecto, éste es el que tenemos que usar con el‘quemador’de chips descrito en otro artículo de la serie, para comprobar si nuestro proyecto refleja nuestros deseos, en caso de no ser así, debemos realizar los cambios necesarios en el programa y volver a empezar el proceso de compilar de nuevo hasta lograr nuestro propósito y luego a por otro proyecto.

Como estimular al MPLAB.

Esta bien, cuando hemos terminado de ensamblar un listado .asm y antes de quemar el chip con el código generado por este, es conveniente en muchas ocasiones, proceder a simular la ejecución del archivo hexadecimal generado para mayor seguridad y para esto el MPLAB incorpora una herramienta que nos permite realizar dicha simulación. Hasta aquí, todo es normal, en el caso especial de necesitar estimular una línea, es decir, como por ejemplo, simular que se ha presionado un pulsador en un momento de la simulación, aquí es donde se necesita dominar esta herramienta.
En menú Window, disponemos de las ventanas que más nos servirán para seguir con detalle la evolución de la simulación, también están los iconos propios en las barras de menú que se menciona al principio de este artículo. Destaca la ventana del stack o pila, aquí se verán en acción la pila con sus 8 niveles y que el último en ingresar es el primero en salir, para eso tiene que estar la simulación en activo.
La ventana que mayor importancia le doy, en la de ‘Special Function Register‘, o registros de función especial de la izquierda, en esta se aprecia la evolución de los distintos registros con sus valores cambiantes según el valor resultante de la ejecución de cada instrucción. Todo esto es posible examinarse mediante la ejecución del programa en el modo, paso a paso (step to step) o animado (animate).
Es conveniente que el interesado haga su propia simulación en ambos modos y compruebe lo que ocurre en cada momento.
Otra ventana es la de ‘Program Memory‘ a la derecha que, nos muestra la evolución del programa instrucción a instrucción, obsérvese las columnas que empiezan por 0000, corresponde a la localización en memoria y a su derecha con 4 dígitos, corresponde al código de la instrucción de esa línea, las siguientes columnas se refieren a la etiqueta, a la instrucción propiamente y a sus valores.
En Modify, podemos modificar el valor de un registro en un momento dado, para no tener que esperar tanto tiempo de ejecución como ocurre con un retardo. Sigamos con la simulación.
En el menú Debug/Simulator Stimulus…/Asincronus Stimulus tenemos la ventana donde se pueden configurar las señales que deben influir en la simulación como son, pulsadores, señales de reloj, etc. Al abrir esta ventana, muestra 12 botones que, en principio indican Stim 1(P), Stim 2(P), etc. Con el botón d erecho del ratón sobre uno de ellos, mostr ará una ventana para seleccionar distintas opciones. En nuestra simulación se trata de sendos pulsadores en el puerto de entrada, por ej. RA2, RA3 y RA4.
En el mencionado menú emergente, se selecciona Assign pin… RA0, ahora es RA0 (P), nuevamente haremos click con el botón derecho sobre el mismo botón pero esta vez seleccionamos Toggle aquí significa pulsador, con RA3 y RA4 se procede del mismo modo.
Una vez configurados estos botones, debemos iniciar el generador de tiempos que, como un generador de reloj, se encarga de enviar los pulsos a los terminales de puerto, indicados por los botones de estimulo anteriores, en la secuencia prevista.
Ahora, en Debug/Simulator Stimulus…/Clock Stimulus, en la celda Stimulus pin, elegimos RA2. En la secuencia de reloj High y Low anotamos 4 que, es la marca espacio de la señal o sea, el ancho del pulso H y L. Si fuera necesario, añadir los demás botones de tiempos pulsando Add..y para aplicar todo esto, pulsamos sobre Apply. Por fin están configurados los estímulos.
Antes de empezar la simulación, se debe hacer un Reset de la simulación, imagen de la derecha.
Al pulsar el Reset, la simulación se inicializa y los valores de los registros empiezan a moverse según se ejecutan las instrucciones. En este momento debemos disponer cinco ventanas en pantalla; la deproyecto, para seguir el programa; la de registros, para ver la evolución de los mismos; la dememoria que, permite ver los valores de memoria en uso y la de tiempos y estímulos, ver posición en la figura para su mejor apreciación.

LA SIMULACIÓN.

Es el momento de iniciar la simulación, en menú Debug/Run/Step se inicia el simulador en modo paso a paso, este modo nos permite apreciar el trasvase de información entre los registros que intervienen al ejecutar una instrucción, una vez iniciado y dependiendo del programa a simular, podemos optar por la opción de ejecución animada medianteDebug/Run/Animate o usar Ctrl+F9, que empezará desde el punto en el que se encuentre en ese momento hasta el final del programa. Si hubiera algún error, se produce una parada que muestra una ventan emergente indicando el motivo, para poder corregir el error.
El proceso de simulación podemos pararlo con una pulsación en el icono semáforo rojo, para seguir sólo pulsamos Ctrl+F9 y seguimos la tarea, debe seguirse el proceso para entender lo que ocurre con nuestro programa. En alguna ocasión el programa nos pide que se presione un pulsador o requiere una señal de entrada por una línea de un puerto, esto puede parecer un problema de, como interactuar con el programa.
Supongamos que el programa trata de un temporizador que, se pone en marcha cuando se aprieta el pulsador A que está en RA1, iniciando el retardo de 1 minuto, al termino del mismo se activa un LED indicando que ha transcurrido el minuto. En ese caso al simular el programa, se ejecutará hasta la instrucción del lazo de espera a que se presione el pulsador y no avanzará hasta que le llegue esa señal. Para interactuar, usamos una herramienta que genera ese pulso en RA1 y podremos seguir. Estamos en el lazo.
Entonces abrimos la ventana Asincronus Stimulus y le ponemos RA1 en el primer botón y la opción Toggle, a continuación en la venta Clock Stimulus, ponemos lo que se indica en su apartado anterior que lo describe muy bien. Con esto, ya podemos seguir la simulación, las señales necesarias se producirán en el momento adecuado y se apreciará su efecto. Sin embargo, justo en nuestro programa se produce un retardo que para la simulación puede ser tedioso su seguimiento, no hay problema, está todo previsto en el MPLAB, en el menú Debug/Execute/Execute An Opcode…, elegimos la opción returny pulsamos Execute, en ese mismo momento habremos salido del lazo de retardo que nos retenía y seguirá la simulación si no hay otra condicionante.

OTRO MÉTODO.

Cuando haga la simulación de un retardo, como ya se ha comentado o ha de emplear largo tiempo en decrementar un registro, es interesante conocer esta posibilidad de Modificar que nos brinda el MPLAB.
Por ej. Estamos simulando un programa que crea una señal cuadrada a la salida RB0, para ello utiliza el TMR0 y la interrupción por desbordamiento del mismo, asignando el prescaler con un factor de división de 1/2. De esta forma las interrupciones saltarán a intervalos fijos de tiempo. Invirtiendo el estado de RB0 durante las interrupciones se conseguirá una onda cuadrada perfecta.
Cuando estemos ejecutando el código y lleguemos a la rutina ‘hacer nada’, nos detenemos y debemos acceder a File Registers Window , en el menúWindow/File Registers, se verá el cuadro Ventana Registros. Si nos fijamos en el código, el registro PCL está aumentando con cada instrucción, cuando llega a la rutina ‘hacer nada’, el valor es 08 como muestra la imagen, al detenernos el registro mantiene el valor, ahora vamos a modificar el valor de este registro, para reducir el tiempo de espera.
Con el botón derecho del ratón, hacemos un click justo sobre 08 y luego en File Register(s) como se aprecia en la imagen de la derecha y nos muestra un cuadro de diálogo Modify (ver debajo).
1) En él seleccionar en Address, el registro que vamos a modificar, en este caso 01 
2)
 en Data/Opcode el nuevo valor para ese registro en este caso ff (este valor hace que llegue al máximo de la cuenta), tal como se ve en esta imagen.  Y
3)
 Luego le damos a Write (escribir) y se habrá modificado el valor del registro 0×01, para seguir la simulación.
Ahora si, le damos a F7 para ver que el registro adquiere el nuevo valor, con la siguiente F7, el registro se desborda y hace que el programa avance en su ejecución saliendo del lazo y saltando a la subrutina de servicio de interrupción (RSI) BCF INTCON,2 en la simulación, esto quiere decir que todo va correctamente y nos ahorramos una larga espera.
Que podemos decir de una temporización de 50 segundos, lo que hacemos allí es verificar que los respectivos registros (19h,1Ah, 1Bh, 1Ch y 1Dh) se decrementan con cada iteración del programa, de modo que, nuevamente nos encontramos ante un prolongado tiempo de espera para verificar una rutina que ha entrado en un lazo de retardo y ya conocemos su funcionamiento.
Con este ejemplo puede darse por aclarado el uso de algunas de las opciones que nos ofrece esta herramienta que es el MPLAB.

DESENSAMBLADOR.

En alguna ocasión cuando por motivos extraños, se pierde un listado en asambler (.asm) y solo dispones del listado en hexadecimal. La mejor forma de proceder para disponer del listado es usar un desensamblador, personalmente recomiendo el que viene integrado en el MPLAB.
El procedimiento es el siguiente:
  • En el menú File, ir a Import y elegir el archivo en hexadecimal (.HEX)
  • En el menú View, ir a Program Memory; dispone de tres opciones:
    OPCODE HEX, MACHINE y SYMBOLIC.
  • Sobre la pantalla, botón derecho pulsar ‘Output to file’ para terminar.
“Vaya a FILE, IMPORT y elija el archivo .HEX que desee desensamblar. Luego vaya a VIEW, PROGRAM MEMORY y fíjese que abajo tiene 3 opciones. OPCODE HEX,  MACHINE , SYMBOLIC. Luego botón derecho sobre la pantalla ‘… Output to file’ y listo ya puede tener un .asm del archivo elegido. Eso sí, luego será trabajo suyo determinar que es variable y que no lo es, etc.”

MOTORES


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 unipolar
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
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.
Motor unipolar
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.
Posición de los devanados
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
ACBD
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 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.
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
ACBD
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;
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&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);
}
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.
Secuencia medio-paso
Bobinas
ACBD
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
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 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.

Unipolar con 2 hilos
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 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í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.
Esquema3
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.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() {
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, 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;
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&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);
}
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;
}
}
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í.