Archivo de la categoría: Tech

Motores paso a paso con Arduino

Un motor común de corriente continua gira libremente y a gran velocidad. Básicamente se compone de dos partes, el estator que es la parte mecánica que contiene los imanes fijos y el rotor que es un eje rotatorio electromagnético. El motor gira gracias a la repulsión que ejercen los imanes del estator cuando interactúan con los polos del electroimán del rotor.

PMDC-3

En estos motores es casi imposible (sobre todo con precisión) conseguir que giren una cantidad concreta, por ejemplo de grados o vueltas, y su velocidad también es variable debido a que tienen un tiempo de arranque y unas inercias a la hora de parar.

Un motor paso a paso funciona justo al contrario. El rotor contiene los imanes fijos en el rotor y es en el estator (la parte fija) donde se encuentran los electroimanes. No giran libremente sobre si mismos sino que a través de un controlador electrónico se estimulan los electroimanes necesarios para que el motor rote un número de grados concretos sobre su eje.

step

Dentro de los tipos de motores paso a paso vamos a centrarnos en los de imanes permanentes y unipolares, que son los más comunes y sencillos.

Sus características principales son:

  • Voltaje. Tensión eléctrica de trabajo expresada en voltios (v). Lo normal es que sean de 5v o de 12v. Para trabajar con Arduino buscaremos uno de 5v o vamos a tener que alimentarlo de manera autónoma.
  • Resistencia eléctrica. Indica el consumo del motor y viene expresada en omnios (Ω). Importante si vamos a tirar de baterías en nuestro proyecto y no de la red eléctrica.
  • Fases. Número de bobinas que podemos excitar para actuar sobre los electroimanes del estator. Lo habitual en este tipo de motores es 4.
  • Grados por paso. Indica la cantidad de grados de circunferencia que mueve el motor por paso. Suele venir indicado en grados dividido por la reducción mecánica. Dividiendo 360º entre los grados por paso no dará el número aprox de pasos para una vuelta completa.
  • Frecuencia o pulse rate.  Cantidad de pulsos por segundo que puede realizar el motor óptimamente. Se suele medir en pulsos por segundo (pps).
  • Frecuencia de arranque-parada (pull-in). Es la velocidad (frecuencia de pulsos expresada en hercios Hz) máxima que puedes enviar desde la posición de reposo a un motor paso a paso sin que estos se pierdan.
  • Frecuencia máxima (pull-out). Es la velocidad (frecuencia de pulsos expresada en hercios Hz) máxima que puedes enviar a un motor paso a paso que ya está en movimiento sin que estos se pierdan.
  • Torque de detención. Es el que mantiene quieto el eje cuando no está girando. Suele venir expresado en milinewtons por metro (mN m).
  • Pull-in torque. La carga que puede mover o parar un motor sin perder pasos cuando trabaja a una frecuencia de pulsos constante. Suele venir expresado en milinewtons por metro (mN m).
  • Pull-out torque. Carga que puede mover un motor cuando gira a velocidad operativa. Suele ser sustancialmente mayor que el pull-in. Suele venir expresado en milinewtons por metro (mN m).

La gracia de estos motores por tanto está en que pueda dar los pasos más pequeños ejerciendo la máxima fuerza posible.

Excitando las bobinas del estator en una secuencia determinada es como conseguimos que el motor paso a paso se mueva. Terminada la secuencia de excitación se comienza con el paso 1 de la secuencia y así sucesivamente. Existen tres secuencias posibles en este tipo de motores:

  • Secuencia full step. Se excitan las bobinas de dos en dos lo que nos da el máximo torque.

normal

  • Secuencia wave drive. Se excita una sola bobina obteniendo un torque menor que en el full step y la misma precisión.

wave

  • Secuencia de medio paso (half step). El torque obtenido es intermedio pero se consigue una mayor precisión.

half

Estas secuencias se traducen perfectamente a unos y ceros (lo haremos en el código de ejemplo también) y tienen este aspecto:

 

 Full step A B C D
Paso 1 1 0 0 1
Paso 2 1 1 0 0
Paso 3 0 1 1 0
Paso 4 0 0 1 1
 Wave drive A B C D
Paso 1 1 0 0 0
Paso 2 0 1 0 0
Paso 3 0 0 1 0
Paso 4 0 0 0 1
 Half step A B C D
Paso 1 1 0 0 0
Paso 2 1 1 0 0
Paso 3 0 1 0 0
Paso 4 0 1 1 0
Paso 5 0 0 1 0
Paso 6 0 0 1 1
Paso 7 0 0 0 1
Paso 8 1 0 0 1

El motor más usado para prototipos con Arduino es el 28BYJ-48 que además viene con su controlador ULN2003A y no puede ser más barato. Es un motor unipolar de 4 fases que se puede encontrar en cualquier tienda de electrónica, tanto física como web.

stepper01
Motor paso a paso 28BYJ-48 con controlador ULN2003

 

La librería de control de motores paso a paso que podemos encontrar en Arduino no está mal, sobre todo porque  la pausa entre pasos para controlar la velocidad está hecha de forma que no para la ejecución del  código (https://www.arduino.cc/en/Reference/Stepper) pero no permite elegir la secuencia de excitación de las bobinas. No la vamos a utilizar ya que queremos probar las tres secuencias explicadas arriba.

El tema en concreto que quería comentaros hoy además de la introducción  es algo muy importante en los motores paso a paso: la resonancia. Estos motores funcionan por pulsos que hacen avanzar un paso cada vez. En cada paso el motor acelera y después frena para quedarse en la posición adecuada. Esto provoca vibraciones y oscilaciones. A determinadas frecuencias de trabajo el motor entrará en resonancia y dejará de funcionar correctamente (puede moverse erráticamente o simplemente no moverse). Cambiando la frecuencia de trabajo se soluciona perfectamente, pero debemos tener en cuenta que nuestro código aumenta o disminuye la frecuencia de trabajo cuanto más o menos código tenga que ejecutarse en cada iteración, incluso activar o no la salida por consola de información varía el tiempo entre pulsos. Por tanto es un tema a revisar una vez terminado nuestro código, de forma que nos aseguremos que en ningún momento entra en resonancia. Una manera muy práctica de controlar esto es añadir una pequeña pausa en cada paso, de forma que podamos controlar su duración en función de lo que sabemos que está haciendo nuestro arduino en ese momento. De esto va el ejemplo que os quiero mostrar.

Vamos a montar primero un sencillo prototipo con este aspecto:

stepperResonance_bb

El fichero fritzing y el fichero ino os lo podéis bajar de mi github: https://github.com/rebeco/StepperExample

El código hace que el motor gire indefinidamente y con los botones aumentamos o disminuimos la pausa entre pasos. Podemos ver en el terminal el valor en milisegundos que tiene en cada momento la pausa.

Para usar una secuencia distinta a la por defecto basta con comentar el array de la que está activa y descomentar la que queremos utilizar.

La variable “Step” es la que marca en todo momento en que paso de la secuencia estamos, pasando del último paso al primero cuando llegamos al final.

int sizeOfSequence = sizeof(Sequence)/8;

En esta línea determinamos el número de elementos que tiene el array de la secuencia. Este dato nos ayuda a saber si nuestra secuencia es de 4 pasos o de 8.

Step = ( Step + sizeOfSequence) % sizeOfSequence;

En la función “stepper” después de ejecutar un paso calculamos cual será el siguiente. Lo hacemos con la línea de arriba, que me parece particularmente elegante. Aquí es donde hacemos uso del tamaño de la secuencia que calculamos arriba.

Por último explicaros que me he complicado un poco para hacer el println con la espera para que no esté enviando constantemente al terminal la información. Esto afectaba bastante al motor así que lo he hecho de forma que lo manda cada medio segundo.

Jugad con el código y con las combinaciones de espera y secuencia, veréis que el motor se comporta de manera distinta. Con la información que obtengamos de nuestro motor podremos afinar su funcionamiento en un proto con mas chicha.

Es esta entrada sólo hemos introducido algunos conceptos sobre los motores paso a paso que es un tema muy interesante y extenso. Espero que por lo menos sirva para resolver dudas iniciales a quién sienta curiosidad sobre el tema y no tenga conocimientos previos. Pronto publicaré alguna cosa más sobre ellos, tengo en mente un par de proyectos en los que tendré que utilizarlos. 🙂

Páginas interesantes sobre los temas tratados:

Visibilidad entre máquinas virtualbox

oracle_virtualbox

No se si os ha pasado alguna vez, pero cuando estás montando un entorno para probar algo o para desarrollar y utilizas máquinas virtuales con VirtualBox. Por defecto solo puedes acceder a una máquina Virtualbox a través de su propia consola o redirigiendo puertos del anfitrión al huesped (por ejemplo para acceder vía ssh o http). El caso es que es muy interesante que, cuando montas más de una para el mismo proyecto, se vean entre ellas. En realidad es algo muy sencillo pero quería compartir aquí esta pequeña receta al respecto.

Para empezar hay que activar un adaptador adicional en la configuración de las máquinas virtuales (en mi caso será el adaptador 2 que corresponde a eth1). En el parámetro “Conectado a:” debemos seleccionar “Red interna”.  Por aquí no tenemos que configurar nada más.

Arrancamos la máquina y nos vamos a configurar el nuevo adaptador. En mi caso estoy usando máquinas Ubuntu server 14.04 y el fichero que tengo que editar es /etc/network/interfaces. Allí encontraremos normalmente la configuración del adaptador por defecto con dhcp. Nos vamos al final del fichero y añadimos lo siguiente:

auto eth1
iface eth1 inet static
address 10.0.0.201
netmask 255.255.255.0

Esto configura el nuevo adaptador (eth1) con una ip estática. En mi caso todas las voy a añadir en una subred 10.0.0.2xx, por eso le he puesto esa en concreto.

En Centos 6.5 hay que  editar el fichero “/etc/sysconfig/network-scritps/ifcfg-eth1” o el correspondiente al dispositivo que vamos a usar para la red interna y añadir estos datos (la MAC la de vuestro dispositivo, obviamente):

DEVICE="eth1"
HWADDR="00:1C:C0:5E:DA:7B"
NM_CONTROLLED="yes"
ONBOOT="yes"
BOOTPROTO="static"

IPADDR=10.0.0.201
NETMASK=255.255.255.0
TYPE=Ethernet

No hay que añadir nada más. Para que la configuración sea efectiva sin reiniciar sólo debemos levantar el nuevo interfaz:

sudo ifup eth1

Si hacemos esto en todas las máquinas configurando ips distintas para cada una (del mismo rango), se verán entre ellas por esas ip.

Como veis es muy fácil y la mayoría de vosotros ya sabréis hacerlo, pero seguro que a alguien le sirve. 😉

Receta para crear un servidor git

Trasteando para montar mi propio servidor GIT, he creado esta receta, enfocada a mi necesidad pero que espero que le sirva a alguien más. Me he basado principalmente en un tutorial que encontré en internet, cuya referencia tenéis en los enlaces adjuntos. Lo he probado en Debian y no veo nada que impida que funcione también en Ubuntu. Aquí va:

Primero instalamos los paquetes necesarios…

sudo apt-get install apache2 git-core gitweb openssh-server

Después creamos el directorio servido por apache que contendrá lo necesario para gitweb.cgi. En caso de no existir, también crearemos el directorio del propio repositorio en /var/cache/git

sudo mkdir /var/www/git
[ -d "/var/cache/git" ] || sudo mkdir /var/cache/git

A continuación se crea el fichero para la configuración del virtualhost de git en /etc/apache2/sites-available/git

<VirtualHost git.rebeco.org>
        ServerAdmin rebeco@gmail.com
        DocumentRoot /var/www/git
        <Directory /var/www/git>
                Allow from all
                AllowOverride all
                Order allow,deny
                Options ExecCGI
                <Files gitweb.cgi>
                        SetHandler cgi-script
                </Files>
        </Directory>
        DirectoryIndex gitweb.cgi
        SetEnv GITWEB_CONFIG /etc/gitweb.conf
</VirtualHost>

Se añade el virtualhost a la configuración de arranque de apache…

sudo a2ensite git

Se copian los ficheros de gitweb al directorio del virtualhost…

sudo cp /usr/share/gitweb/* /var/www/git
sudo cp /usr/lib/cgi-bin/gitweb.cgi /var/www/git

Como hemos configurado git en el raíz de un subdominio no tenemos que tocar los path del fichero /etc/gitweb.conf Si se instala como directorio de un dominio existente se tendrían que cambiar para adaptarlos a la nueva ruta. Se reinicia apache para que los cambios sean efectivos.

sudo /etc/init.d/apache2 restart

Con esto ya tenemos montado el servidor git con vista vía apache (que podemos restringir en el mismo apache si es necesario). Ahora vamos a crear un repositorio de prueba para ver que funciona todo. Creamos primero su directorio.

cd /var/cache/git/
sudo mkdir prueba
sudo chown usuario.usuario prueba
cd prueba

Inicializamos el repositorio. En mi caso con la opción –bare ya que lo que estoy montando es un repositorio “central” donde hacer tanto push como pull remoto, no uno de trabajo local.

git init --bare
echo "Descripción del proyecto" > description
git config --global user.name "Pedro León"
git config --global user.email "rebeco@gmail.com"
git commit -a

Y con esto el servidor git ya está disponible vía ssh, que es como yo quiero usarlo. Se puede probar desde otra máquina con:

git clone usuario@git.rebeco.org:/var/cache/git/prueba

Para configurar el server por protocolo git es mejor que mires la documentación u otro tutorial, como por ejemplo en el que me he basado yo.

Tutorial en el que he basado el mío

Web oficial de GIT