Hijos del dios binario

Hacía tiempo que no escribía nada por aquí. He cambiado de trabajo y tengo bastante menos tiempo libre, así que todos mis hobbies se han resentido un poco. Además me enfrasqué leyendo en inglés “The man in the high castle”, pero el lenguaje de este libro es muy superior a mi nivel así que me tenía un poco desesperado. El poco tiempo que podía dedicarle se traducía en muy pocas páginas de avance y no terminaba de pillar muchas cosas. Al final me decidí a dejarlo y leerlo desde el principio en castellano.

Para quitarme el disgusto me dispuse a leer este otro del que os hablo en esta entrada. Se trata del segundo libro de David B. Gil. Del primero ya os conté maravillas en otro post, El Guerrero a la Sombra del Cerezo y con este segundo también he quedado muy satisfecho.

El cambio de temática es drástico y pasamos de un magnífico libro del Japón medieval a otro con tintes de cyberpunk y novela de aventuras.

Básicamente el libro cuenta la historia de una periodista española a la que llega una información que de publicarse destaparía más de una maniobra turbia de grandes corporaciones, que no dudarán en utilizar cualquier medio para defender sus intereses.

Es un libro de aventuras muy entretenido que te hace olvidar que el autor “sólo” ha publicado dos novelas. Está salpicado de algunas ideas magníficas que podrían dar para alguna continuación.

Sólo dos cosas no me han gustado que incluyo como spoiler protegido:

Spoiler

En fin, una más que recomendable lectura, aunque yo esperaría a comprarlo cuando baje un poco el precio. Lo pillé en preventa bastante más barato que los 10€ actuales de la versión digital.

[amazon asin=B01B3KMM24&template=add to cart]

 

Hijos del dios binario Book Cover Hijos del dios binario
David B. Gil
Suma
576

En un mundo que se vuelve cada vez más intangible, los poderosos, nostálgicos de un pasado que apenas conocieron, compiten por hacerse con cualquier icono de la era predigital. Daniel Adelbert, un «prospector» especializado en recuperar piezas del siglo XX, es contratado por el coleccionista Kenzô Inamura para encontrar no un objeto, sino a una persona: un hombre que se movió entre las sombras del pasado siglo e influyó de manera decisiva en su desarrollo.

En el otro extremo del mundo, la periodista Alicia Lagos recibe un extraño correo de su exnovio recientemente fallecido. El mensaje parece legarle una investigación inconclusa, poniéndola sobre la pista del misterio oculto tras los muros del orfanato irlandés de St. Martha.

Ambas investigaciones confluyen en una misma pregunta: ¿qué es el Proyecto Zeitgeist? La respuesta se halla bajo las piedras de la Ciudad Blanca de Tel Aviv, en los arrabales flotantes de Singapur y en el murmullo de la Red de datos. Responderla es desentrañar un secreto que ha costado la vida de muchos, un secreto silenciado durante décadas.

«Ni verjas ni alambradas, ningún resquicio permitía atisbar qué había al otro lado de los altos muros. Sobre la puerta cerrada, siguiendo el arco que formaban las dos hojas de hierro, unas letras indicaban el lugar al que se había llegado: "Bienvenido a St. Martha", se leía, recortado contra el cielo gris. Pero el visitante no podría sino recelar de aquella bienvenida. Sellada y silenciada como una vieja tumba, St. Martha no parecía saludar la llegada de nadie.»

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. 😉

Virgilómetro, el contador de tiempo para juegos de mesa con Arduino

Después de mucho tiempo trasteando con Arduino por fin he terminado mi primer proyecto. Se trata de un contador de tiempo para juegos de mesa. El nombre de Virgilómetro es en honor a mi amigo Virgilo, que es el que inspiró la necesidad de medir el tiempo que empleamos cada jugador en una partida para confirmar o desmentir que el que más AP (Análisis-Parálisis) tiene es él. 😀

El código del proyecto lo tenéis en mi github (Proyecto BGCounter en GitHub). Consta de una librería que he hecho para controlar displays de 7 segmentos, específicamente en este caso para un modelo de 4 dígitos y 12 pines. Tengo hechas librerías para otros tipos de displays por si a alguien le interesan. El otro fichero es el fichero ino con el código del proyecto en sí. Para ahorrar pines en el arduino utilizo un registro de desplazamiento, en concreto el más conocido y extendido, el 74HC595.

El prototipo para Fritzing os lo podéis descargar de aquí o ver justo abajo.

BGCounter

La gestión de interrupciones del Rotary Encoder (función updateEncoder()) la copié de este artículo que habla sobre su manejo “Rotary Encoder + Arduino”. Me encanta la forma tan elegante que tiene de solucionar el problema. En concreto estoy hablando de la función updateEncoder() de mi código. Cuidado con la configuración de pines del Rotary, deben coincidir con los pines 2 y 3 ya que utiliza las interrupciones 0 y 1.

Siguiendo con el ahorro de pines, los cinco botones para los jugadores están dispuestos de forma que en función de la resistencia por la que se les hace pasar devuelve valores distintos al pin analógico al que están pinchados.  En la función readAnalogButtons() es donde se leen esos valores y probablemente tengáis que mirar en el monitor del puerto serie los valores que os devuelven a vosotros las resistencias que elijáis para configurarlos.

El funcionamiento del proto es el siguiente:

  1. Elegimos entre los tres modos disponibles con la perilla del rotary encoder:
    1. Modo incremental.
    2. Modo decremental.
    3. Modo decremental con bonus.
  2. Elegimos con los botones de jugador los colores que van a participar en la partida.
  3. En el modo 2 y 3 debemos configurar el tiempo total del que disponen los jugadores (cada uno de ellos).
  4. En el modo 3 debemos configurar el tiempo que se sumará al tiempo restante del jugador cuando el testigo pase a otro distinto.

Cuando el modo correspondiente es configurado el reloj queda parpadeando esperando a que el primer jugador pulse su botón para empezar a contabilizar el tiempo.

En cualquier momento se puede pulsar el botón del rotary encoder para pausar la partida. Por defecto mostrará el tiempo total de partida y rotando muestra el tiempo de cada jugador.

Cuando el tiempo deja de medirse en minutos y segundos y pasa a horas y minutos se ilumina el punto del cuarto dígito.

En los modos 2 y 3 decrementales hay alarmas cuando quedan 10 minutos, 5 minutos y durante todo el último minuto (para agobiar :D).

Aquí tenéis un vídeo donde muestro todo esto en el prototipo final que he hecho con componentes un poco más resultones. 😉

Pues eso es todo, por lo demás sólo espero que el proyecto le sea útil a alguien. Yo lo estoy usando y la conclusión es que suelo ser yo el que más AP tiene. 😀

 

Curious as way of life

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.

ACEPTAR
Aviso de cookies