Programando una librería para Arduino

He programado dos librerías para el control del miniskybot, o cualquier robot con ruedas motrices.

La primera librería simplifica el uso de los servos de tracción para controlar el motor. Con la librería se incluye un ejemplo documentado

La segunda librería crea un objeto tipo robot, en el que se le indica los motores que se dispone y su configuración, se simplifican las órdenes para poder manejar el robot.

Enlace:

Librería Rueda

Librería Robot

Documentación librerias 

[Processing] Controlando servos desde processing

Como dije en la entrada anterior, processing es un mundo a descubrir. Cacharreando menos de una hora, he conseguido hacer el programa para controlar la velocidad de giro de un servo.
El programa en processing es muy simple, se trata de un control slide que varía de -100 a 100 y esta información se la manda al arduino.

 

Lo bueno de processing es que esta aplicación se puede exportar a cualquier entorno, desde linux, windows a mac.

He subido los ficheros a mi repositorio, aquí tienes el programa para processing y aquí el de arduino.

 

 

Me queda por investigar mucho sobre esto, y poder controlar más variables desde processing hacía arduino, pero bueno para haber estado una hora escasa no está nada mal.

Generando nombres aleatorios desde terminal

Hace años, cuando usaba linux, me hice un script para generar nombres-palabras, hoy lo he estado buscando para ponerle nombre al movil, y como es lógico ese script se perdió. Así que he decidido volver a hacerlo por que nunca está de más tenerlo, y lo publico aquí para quien lo quiera.

#!/usr/bin/env bash
###########################
#Modo de ejecutar el script:
# ./names.sh 'TIPO' 'LETRAS'
# TIPO= nombres, palabras
# LETRAS:
# Palabras que empiecen por s : ^s
# Palabras que contengan s, w, b : s.w.b
# Ejemplo:
# Nombres que empiecen por 's' y contenga 't' y 'u'
# $./names.sh nombres ^s.t.u
# Palabras que empiecen por 'w' y contenga 'b' y 'l'
# sh names.sh palabras ^w.b.l
#––––––––––––––––––––––––––––
#############################
#Diccionarios
# Diccionarios por defecto en el directorio /usr/share/dict
# se encuentra en los sistemas unix.
# puedes poner la ruta de tus propios diccionarios
# Nombres propios
NOMBRES="/usr/share/dict/propernames"
# Palabras
PALABRAS="/usr/share/dict/words"
#––––––––––––––––––––––––––––
if [[ $1 == nombres ]]; then
echo "Diccionario Nombres propios: " $NOMBRES
cat $NOMBRES | tr '[A-Z]' '[a-z]'|grep -i $2
elif [[ $1 == palabras ]]; then
echo "Diccionario Palabras: " $PALABRAS
cat $PALABRAS | tr '[A-Z]' '[a-z]'|grep -i $2
fi

Considero que el script está bien comentado, si alguien tiene alguna duda que me escriba un comentario!

Moviendo ficheros con automator

Una de las herramientas que tiene Os X y está algo escondida,son las acciones de carpeta. Con las acciones de carpeta podemos asignar scripts y tareas automatizadas cada vez que en una carpeta se añada un fichero nuevo.
Yo tengo una acción de carpeta, para que todos los ficheros .torrent que descargo en la carpeta Descargas se me muevan a la carpeta en la que transmission añade automáticamente los torrent que se añadan a ella.
Para hacer la acción de carpeta, ejecutamos Automator y creamos una nueva Acción de carpeta.
Añadimos las acciones Buscar Items del finder y Trasladar items del finder. Nuestra acción debe tener el siguiente aspecto:

Captura de pantalla 2011 07 23 a las 16 11 52

en Buscar items del finder, pondremos la carpeta Descargas que es la que queremos observar para copiar los ficheros,y en trasladas items del finder pondremos la carpeta destino.

Una vez que lo tenemos, guardamos la acción de carpeta, y cada vez que haya un fichero torrent en la carpeta descargas la moverá a la que le hayamos indicado.

Programar Arduino desde consola

Siguiendo con los post de programación sobre arduino, hoy voy a explicar como programar arduino desde la linea de comandos.
El IDE de arduino es bastante básico y en algunos casos los editores de texto que usamos, ya puede ser VIM, Textmate o similares, son mejores a la hora de programar.

Para escribir este artículo, me he basado en el que escribió Syvic que explicaba cómo usar arduino desde un sistema linux. Prácticamente es lo mismo, lo único que cambia es la manera de instalar los programas que necesitamos.

Requisitos

1. pyserial
Módulo que añade comunicaciones con el puerto serie para python. Para instalarlo, lo descargamos nos vamos al directorio donde lo hayamos descomprimido y desde consola ejecutamos

sudo python setup.py install

2. scons
Son unas herramientas para compilar programas. Para instalarlo actuamos igual que con pyserial. Descargamos, descomprimimos y desde el directorio en el terminal ejecutamos

sudo python setup.py install

3. arcsons
Para terminar nos tendremos que descargar el fichero SConstruct. Este fichero lo tendremos que tener siempre a mano. Es necesario que lo pongamos siempre en el directorio donde tengamos el fichero .pde del programa.
Este fichero necesitamos editarlo para indicarle qué arduino tenemos. Para ello lo abrimos y en la linea 62

ARDUINO_BOARD = ARGUMENTS.get(‘ARDUINO_BOARD’, ‘atmega328’)

le indicaremos que placa tenemos, escribiendo alguno de los siguientes modelos: pro328 mini pro5v328 mega atmega328 bt328 atmega8 atmega168 pro diecimila lilypad pro5v lilypad328 uno bt fio y mega2560

Creando el proyecto
Una vez que tengamos los programas instalados, es hora de crear el primer proyecto. Para ello creamos el directorio donde guardaremos el fichero .pde y el SConstruct.

$mkdir Blink

y creamos el fichero PDE dentro de ese directorio. Es necesario que la carpeta y el fichero pde se llamen de igual forma.

$mate Blink/blink.pde

NOTA: yo uso textmate si usas otro editor como por ejemplo vim, en el comando anterior se sustituye ‘mate’ por ‘vim’ o el comando que uses habitualmente.

Escribimos en el fichero el programa que queramos cargar al arduino y guardamos los cambios.
Una vez que ya tenemos el fichero preparado copiamos el fichero SConstruct en el directorio actual, y ejecutamos scons

$scons

En este momento scons, compila el fichero .pde en un fichero .hex listo para ser cargado en arduino.Al terminar nos devolverá el siguiente mensaje:

scons: done building targets.

El paso siguiente será cargar el fichero .hex en el arduino.

$scons upload

Cuando termine, scons devolverá el mismo mensaje que antes.
Si en nuestro programa estamos trabajando, mandando información al puerto serie, para leelar en el ordenador, podemos verla en consola con el comando:

$screen /dev/tty.usbserial*

Intercambiando información con Arduino

Después de mucho tiempo, retomo el tema de programación de arduino en mac. Os voy a explicar como intercambiar información entre arduino y un ordenador.
Las posibilidades de arduino por si solo son inumerables, pero si le añadimos la capacidad de interaccionar con un ordenador, abrimos la puerta a muchos más proyectos, o funcionalidades nuevas para nuestros proyectos.

Mandar información desde arduino

Lo primero que vamos a ver es cómo mandar información por el puerto serie por arduino, voy a basarme en el ejemplo ‘Blink’ para mostrarlo:

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

This example code is in the public domain.
*/
void setup() {
// initialize the digital pin as an output:
Serial.begin(9600);
pinMode(13, OUTPUT);
}

void loop() {
digitalWrite(13, HIGH); // set the LED on
Serial.println(“Encendido”);
delay(1000); // wait for a second
digitalWrite(13, LOW); // set the LED off
Serial.println(“Apagado”);
delay(1000); // wait for a second
}

Lo primero de todo es añadir en el Void Setup, la instrucción Serial.begin(9600) de este modo inicializamos la utilización del puerto serie. Lo siguiente será, a lo largo de nuestro código, mandar la información que nosotros queramos mediante Serial.println(“Encendido”) en este caso estamos mandando la palabra on. Aquí podríamos poner lo que quisieramos, incluso una variable para que mandara su valor.

El siguiente paso será recibir esa información en el ordenador, al estar en el puerto USB, tendremos muchas formas de leerlo.

Serial Monitor Arduino

Lo más sencillo es usar el Serial Monitor del propio IDE de arduino. Este sistema es únicamente de revisión del código, es decir, seguir por dónde va el programa. En caso de que estemos probando una función y no queramos activar una salida podemos mandar información por el puerto serie y ver que funciona correctamente.

Captura de pantalla 2011 03 19 a las 18 41 31
Captura de pantalla 2011 03 19 a las 18 42 59

Python

Lo siguiente y un poco más potente es a través de un lenguaje de programación como pueda ser Python. Gracias a esto podemos tomar decisiones en nuestro programa con lo que pase en la placa arduino. El código es el siguiente:

import serial
ser = serial.Serial(‘/dev/tty.usbserial-A8008qpV’, 9600)
dato = ser.readline()
if dato == ‘on\r\n’ :
print(“encendido”)
if dato == ‘off\r\n’ :
print(“apagado”)

Lo primero es importar la librería serial para trabajar con la lectura del puerto serie, en el siguiente comando configuramos el puerto. Con el comando ser.readline() lo que hacemos es leer la información del puerto serie, y posteriormente trabajar con ese valor en nuestro programa.

En este ejemplo, en el programa de arduino mandamos las palabras ‘Encendido’ y ‘Apagado’ pero con el comando Serial.println, que añade un retorno de línea a la cadena, es por ello que debemos hacer la comparación en python con ‘Encendido\r\n’ y ‘Apagado\r\n’ que es realmente lo que está mandando por el puerto arduino

En el siguiente post, explicaré, cómo mandar información del ordenador a arduino para por ejemplo, encender un led. Pero la estructura del programa es bastante similar.

Vía:
Página arduino
Página Python

Arduino en mac

Os voy a explicar como trabajar con la placa de Arduino en nuestro mac.
Yo compré arduino por internet en una tienda de electrónica americana, al cambio me salió el cacharro por 24€ con gastos de envío cuando en la mayoría de las tiendas electrónicas lo venden por 20€ más gasto de envío que suelen rondar los 10€ y tardaron 15 días.
Una vez que tenemos el Arduino lo primero que debemos hacer antes que nada es instalar los Drivers FTDIUSB para Snow Leopard, la versión que yo tengo instalada es la v2_2_14 hay una versión que en Snow Leopard no me los reconocía, con esto podremos comunicarnos con arduino, tanto a la hora de subir el programa como por comunicación serie.
Una vez instalado los drivers y reiniciado el sistema, instalamos y ejecutamos el entorno de desarrollo de arduino(ahora en adelante IDE), a día de hoy van por la versión 017, comentar que el IDE por defecto nos creará una carpeta en Documentos, donde se guardaran todos los programas que vayamos haciendo.

El entorno es muy sencillo, a simple vista un editor de texto más con resaltado de sintaxis. Lo primero que debemos hacer es decirle qué placa de Arduino tenemos.

Captura de pantalla 2009-10-27 a las 20.45.08

Ahora conectamos la placa al mac y le indicamos el puerto por el que debemos de comunicarnos.

Captura de pantalla 2009-10-27 a las 20.45.23

Tenemos que elegir la opción que sea parecida a /dev/tty.usbserl-XXXXXXX, si no aparece ninguna opción, es o bien no hemos conectado la placa al mac, o los drivers no están bien instalados.

Y ya lo siguiente es hacer nuestro primer programa, comentar que dentro del propio IDE tenemos muchos ejemplos de código, en el menú (File>Examples)
Una vez que tenemos el programa

Captura de pantalla 2009-10-27 a las 20.47.56

Compilamos el programa (Sketch>Verify/Compile) y luego transferimos al Arduino (File>Upload to I/O Board) o bien usar los botones de acceso directo que están en la ventana del entorno.

Captura de pantalla 2009-10-27 a las 20.48.08

Y con esto ya tenemos nuestro Arduino preparado para funcionar con nuestro mac. En el siguiente post, veremos cómo intercambiar información entre el mac y el Arduino, para por ejemplo, conectar un led conectado al arduino desde el mac.

Hay mucha información de arduino en internet, pero voy a intentar recopilar aquí algunos ejemplos para trabajar con el mac.

Vías:

COMO comprimir fotos automaticamente

Cuantas veces nos han mandado un fichero que ocupaba 80 mb con 20 fotos, de las cuales cada una ocupaba 1.5mb?? a mi realmente más de las que desearía 🙂

En windows creo que hay algunas utilidades que te comprimen automáticamente las imágenes a la calidad que les indiques, el propio photoshop, le puedes "programar" para que lo haga, pero verdaderamanete es un proceso algo engorroso.

Bien, en linux no conozco de ninguna utilidad que haga esto mismo, seguramente the gimp! pueda hacerlo, pero, ¿para que buscar, si te puedes hacer tu mismo ese programa? pasemos a lo interesante

En linux hay un paquete de utilidades para tratamiento de imágenes que se llama ImageMagick ($sudo aptitude install imagemagick), con ellas, puedes editar cualquier aspecto de la imagen, resolución, brillo, contraste, cambiar a formatos png<>jpg… vamos una maravilla. Bien pensando un poco como hacer uso de esas utilidades primero pensé en hacer un

$convert -quality 50 *.jpg

en el directorio donde tengo las fotos, pero al hacer eso, el ordenador se me ha quedao tostado y no me ha hecho nada, luego he pensado en hacer un pequeño script en bash que vaya recorriendo todos los ficheros de un directorio y automáticamente lo comprima, pues bien eso se hace de la siguiente manera, en un fichero escribimos lo siguiente:
Apunte: Gracias a Juanjo por el apunte, en el for nos podemos ahorar el crear un proceso poniendo *.jpg, para que sólo pille las fotos es decir quedaria así

for i in *.jpg; do

convert -quality 50 $i com$i;

done
hacemos que recorra todos los archivos de un directorio, y lo almacene en la variable i luego en el programa convert le damos como parámetros -quality 50 (puede ser un rango de entre 0-100), a continuación el nombre del fichero que queremos comprimir y por último el nombre del fichero destino

Y con eso todas las fotos del directorio en el que ejecutemos el script, verán su tamaño reducido a la mitad, conservando más o menos la misma calidad de imagen. Y todo de una bastante rápida y aunque pueda parecer una tontería lo hemos hecho nosotros mismos.

Apagar el ordenador automaticamente.

Una de las cosas que más le faltaba a un amigo cuando empezó a usar ubuntu era un programa que se llamaba swhitch of (o similiar) consisitia en una aplicación en la cual tú le indicabas una hora, y a esa hora el ordenador se apagaba.

Buscaba un programa similar que hiciera lo mismo en ubuntu, buscó buscó y no encontro nada. Yo buscando por internet he dado con la solución cron. Siempre he sabido que estaba ahi, y para que servia (ejecutar tareas programadas), pero nunca lo he tenido que usar hasta hoy.

Bien pues digamos que el problema que tenía mi amigo (apagar el ordenador todos los dias a una cierta hora) se ha solucionado, tan sencillo como hacer lo siguiente:

$sudo vim /etc/crontaby añadir al final del fichero lo siguiente

00 00 * * * root shutdown -h -time now

Bien, la linea tiene el siguiente formato

#minute hour mday month wday who command

Es decir se podria editar esa linea para que sólo se ejecutase el comando un día determinado de un més determinado, la verdad que nunca lo habia usado, más que nada porque creia que iba a ser más dificil el programarlo, pero me había olvidado que en linux todo es muuuy facil!

Una segunda versión del programa se podría hacer, creando un sencillisimo script tal como

$ echo sudo shutdown -h -time hh:mm > hora.sh

Habría que cambiar hh:mm por la hora y los minutos de apagado y darle permisos de ejecucion:

$ chmod +x hora.sh

Despues con ejecutarlo bastaría para que se apagara solo.