Category Archives: Proyecto Corto (1-2 hrs)

IMG_0730

Creando una cámara de fermentación con BrewPi

20 Abr , 2017,
Allan R Cascante Valverde
No Comments

1. Descripción

Hoy vamos a realizar la instalación y la conexión de Brewpi; para tener nuestra propia cámara de fermentación para cervezas caseras.

2. Referencias Externas

http://www.homebrewtalk.com/showthread.php?t=466106

3. Disclaimer sobre Intención y Responsabilidad

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.

4. Resumen

Brewpi es una solución completa para crear nuestra propia cámara de fermentación; para los que nos gusta la cerveza y en particular hace nuestra propia cerveza; un reto interesante es el control de la temperatura del proceso de fermentación; muchos de los sabores en la cerveza (apropiados o inapropiados) para un tipo particular están relacionados directamente con la temperatura en la que se encontraba la levadura en el momento de la fermentación.

En esta guía vamos conectar y configurar todas las partes necesarias para echar a andar brew pi de manera de que podamos conectar cualquier refrigerador a este para que este funcione como nuestra cámara de fermentación.

5. Lista de Materiales

  • Arduino 101
  • Relay board
  • 2 DS1B820
  • Enchufe y Toma corriente
  • Conectores macho/hembra x 4
  • Conectores macho x 3
  • Cable eléctrico 14-16
  • Resistencia 4.7 Oms
  • Cinta Aislante Eléctrica
  • Una regleta para conexiones
  • RaspberryPI con Raspbian instalado (para monitorear el sistema)

6. Pasos Detallados

En el caso de este proyecto encontré varias guías en inglés; en particular la que coloque en las referencias externas fue la que me pareció más util.  De esa guía solo es necesario seguir este diagrama para hacer el cableado de las partes:

Con respecto al diagrama anterior y la siguiente fotografía (que corresponde a mi propia instalación) pueden notar algunas diferencias.

IMG_0730

Los colores de los cable son las diferencias más notables; para construir esto solo ocupe la guía anterior; estos son los pasos que seguí:

  1. Conecte las terminales de los “termómetros” (DS1B820) a la regleta conectado las lineas de datos, voltaje y tierra, cada color se conecta a la misma terminal; hay que revisar los colores de estos cada fabricante es distinto (si no da lecturas hay que hacer algo de prueba y error).
  2. Luego de esto conecte los terminales macho como se muestra en el diagram, la tierra, la linea de voltaje y la linea de datos en A4 del arduino y se coloca la resistencia entre la linea de datos y la linea de voltaje.
  3. Luego conecte la tierra y el voltaje al relay board, tal como se muestra en el diagrama.
  4. Se conecta las lineas digitales 4 y 5 al relay board.

Con lo anterior ya se puede probar la instalación, aún cuando no se a conectado la alimentación eléctrica al relay board. Para instalar brewpi seguí esta guía:

Instalación Brewpi

Solo se ocupa bajar un script de shell y correrlo; para mi instalación si hay una limitante; que al utilizar un arduino la version soportada es la legacy (mas sobre como cambiar esto mas adelante)

Estos son los comandos:

git clone https://github.com/BrewPi/brewpi-tools.git ~/brewpi-tools
sudo ~/brewpi-tools/install.sh

Luego de esto se ejecuta el siguiente comando para seleccionar la version que se desea instalar:

sudo ~/brewpi-tools/updater.py –ask

En mi caso seleccione legacy para que funcione mi arduino.

Luego de esto conseguí la dirección ip del arduino con un comando ifconfig y la puse en un browser esto debe mostrar la interfaz web del brewpi. Ahí tenemos que ir al Maintenance Panel y hacer las configuraciones de los dispositivos detectados; si todo esta bien conectado debería aparece tanto los termómetros como el relay board, ahi se selecciona la función de cada uno; en mi caso seleccione fridge temp and beer temp y prove que así fuera (enfriando y calentando cada uno por aparte para ver los valores que se desplegaban y así reconocer cual es cual. Lo mismo con los relays se puede ver cual corresponde a cual.

Luego de estos ajustes en la configuración realice la conexión del relay board y el cableado restante tal como se ve en la diagrama mas arriba.

7. Agradecimientos

A José Nuñez quien me facilito algunas de las piezas necesarias para este proyecto.

 

e9f84349-2e02-4c69-88c7-24451e792023

Ya Contamos Personas… Ahora hagamos algo con Python

Abr , 2017,
Jose Nunez
, , , , ,
one comments

Muchas personas piensan que la visión computarizada es un área de la tecnología reservada para genios matemáticos japoneses.

Nada más lejos de la realidad.

Mientras que en efecto se hace uso intensivo de matemática muy avanzada, y de sistemas computacionales de última generación; la realidad es que, gracias al código abierto, existen bibliotecas y frameworks  que hace accesible estas tecnologías a todas las personas que, con una dosis adecuada de interés quieran adentrarse en este mundo tan fascinante y a la vez de vital importancia para nuestra sociedad moderna.

En esta entrega les mostramos una extensión de nuestro artículo anterior sobre “Visión Computarizada: Contando Gente con OpenCV, ROS,..” donde exploramos la creación un programa básico en lenguaje Python que haga uso modesto de los datos generados por el contador de personas.

Recordemos que ROS (Robot Operating System) es un meta-sistema operativo de tipo publicador/suscriptor que facilita la comunicacion entre diversos nodos computacionales; y que está orientado a sistemas robóticos.

Como dijimos, en el artículo anterior exploramos cómo configurar un sistema Up-Board con Ubuntu Linux, para utilizar los datos provenientes de una cámara para analizar las imagenes en tiempo real y detectar personas. Fascinante.

Ahora, basados en el tutorial básico de ROS para creación de programas Python de publicación y escucha, acá listamos los pasos básicos para la creación de publicadores y escuchadores que funcionen con ROS.

(!) Antes, tengamos en cuenta que la detección de personas que viene con opencv_apps de ROS lo que hace es buscar en las imágenes patrones que coincidan con cierta geometría rectangular alta. Por eso en la imagen destacada de este artículo vemos marcas de rectángulos donde no hay personas. Al final de este artículo hablamos del comando rosrun rqt_reconfigure rqt_reconfigure que permite ajustar parámetros “en caliente” para mejorar la precisión.

También, antes de ejecutar estos procedimientos, es probable que necesite ejecutar las instrucciones de algunos artículos anteriores que se listan en esta página: http://costaricamakers.com/?p=914 a partir del punto 4.

En caso de duda o si algo no funciona, les agradezco nos lo hagan saber en los comentarios.


PASO 1 – Primeramente creamos un espacio de trabajo de tipo catkin. Es decir la estructura básica de archivos y herramientas de un espacio de trabajo para ROS usando el sistema de construcción Catkin.

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
cd ~/catkin_ws/
catkin_make
source devel/setup.bash

PASO 2 – Seguidamente crearemos un paquete de ROS al que llamaremos “beginner_tutorials”que no es otra cosa que un conjunto de programas que se pueden manipular mediante ROS.

cd ~/catkin_ws/src
catkin_create_pkg beginner_tutorials std_msgs rospy roscpp
cd ~/catkin_ws
catkin_make
. ~/catkin_ws/devel/setup.bash

De nuevo, para más información sobre la creación de paquetes puede visitar el tutorial oficial en http://wiki.ros.org/ROS/Tutorials/CreatingPackage


PASO 3 – Ahora escribiremos los programas básicos de publicación y escucha.

roscd beginner_tutorials
mkdir scripts
cd scripts
wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/talker.py
chmod +x talker.py

El comando wget de la linea 4 arriba se encargará de descargar nuestro programa de python llamado “talker.py” que se encarga de publicar mensajes en un nodo denominado “chatter” que luego serán leidos desde el programa de escucha o suscriptor.

Para crear el programa de escucha usamos los siguientes comandos:

roscd beginner_tutorials/scripts/
wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/listener.py
chmod +x listener.py

Con esto se descarga el programa “listener.py” en nuestra carpeta scripts para programas de python.

Este programa escuchará datos publicados al nodo “chatter” y los mostrará en la pantalla.


PASO 4 – Pongamos a prueba estos programas.

Para esto primero compilaremos el paquete usando los siguientes comandos

cd ~/catkin_ws
catkin_make

y luego ejecutaremos ambos scripts en terminales diferentes:

rosrun beginner_tutorials listener.py
rosrun beginner_tutorials talker.py

Al ejecutarse se puede apreciar como, el listener.py no hace nada, hasta que el talker.py es ejecutado. El programa talker.py envia mensajes con un numero al tópico chatter; estos mensajes son entonces escuchados por el programa listener.py el cual los muestra en la pantalla al recibirlos. Es una dinámica muy simple.


PASO 5 – Modifiquemos el listener.py

Ahora modificaremos el programa listener.py para que en lugar de escuchar el tópico ‘chatter’ publicado por talker.py, escuche un tópico un tanto más avanzado: la cuenta de personas de nuestra cámara.

Usando el siguiente comando abrimos listener.py usando el editor gedit que viene con Ubuntu.

cd ~/catkin_ws
sudo gedit src/beginner_tutorials/scripts/listener.py

Luego reemplazamos el contenido del script con el siguiente:

#!/usr/bin/env python
# Software License Agreement (BSD License)
#
# Copyright (c) 2008, Willow Garage, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above
#    copyright notice, this list of conditions and the following
#    disclaimer in the documentation and/or other materials provided
#    with the distribution.
#  * Neither the name of Willow Garage, Inc. nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# Revision $Id$

## Simple talker demo that listens to std_msgs/Strings published 
## to the 'chatter' topic

import rospy
from std_msgs.msg import String
from opencv_apps.msg import RectArrayStamped

def callback(data):
    rospy.loginfo(rospy.get_caller_id() + 'I AAAA  heard %s', data)

def listener():

    # In ROS, nodes are uniquely named. If two nodes with the same
    # name are launched, the previous one is kicked off. The
    # anonymous=True flag means that rospy will choose a unique
    # name for our 'listener' node so that multiple listeners can
    # run simultaneously.
    rospy.init_node('listener', anonymous=True)

    rospy.Subscriber('people_detect/found', RectArrayStamped, callback)

    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()

if __name__ == '__main__':
    listener()

Podemos observar las partes clave del programa:

  1. Linea 41: Importamos de la librería opencv_apps.msg el tipo de datos RectArrayStamped, que es el tipo de datos con que se publican las personas encontradas .
  2. Linea 44: Se muestra en consola los datos recibidos por el suscriptor. Nótese que donde dice data, podríamos poner data.rects para obtener unicamente el arreglo de rectángulos que representa a cada persona.
  3. Linea 55: Se define un suscriptor para el tópico peopledetect/found con un tipo de dato RectArrayStamped que al escuchar datos llamatrá la función callback. Esta función se define en la línea 43 y 44.

Para ejecutar este script usariamos el siguiente comando que nos mostrará los datos escuchados.

rosrun beginner_tutorials listener.py

Otros comandos que suelen ser útiles:
Para listar todos los tópicos que están manejando en la instancia de ROS: rostopic list

Para ver la información de un tópico particular: rostopic echo people_detect/found

Para configurar los tópicos activos mediante un utilitario GUI: rosrun rqt_reconfigure rqt_reconfigure


Read More…
896a8b69-9451-4bbd-be2e-ff0ff114fe4a

Visión Computarizada: Contando Gente con OpenCV, ROS, UP Board y una cámara Real Sense

7 Abr , 2017,
Jose Nunez
, , , ,
No Comments

En artículos anteriores hemos tocado el tema del kit de robótica de Intel con RealSense y UPBoard.

Como seguimiento a las instrucciones de inicio del Up Board les compartimos acá algunos comandos de ROS / LINUX para hacer uso de algunos de los ejemplos para aplicaciones de visión computarizada.


PASO 1 – Paquete OpenCV Apps

El primer paso sería la instalación de un paquete de ROS denominado “opencv_apps” mediante el siguiente procedimiento:

cd /opt
sudo apt-get install ros-kinetic-opencv-apps

PASO 2  – Ejemplo de la aplicación de detección de personas

El paquete OpenCV Apps de ROS contiene archivos de lanzamiento (.launch files) con ejemplos muy concretos sobre aplicaciones de visión computarizada.

Mediante el siguiente comando de ROS, la consola de LINUX se ubica en la ubicación del paquete OpenCV Apps:

roscd opencv_apps

Una vez en este directorio, echaremos un vistazo a la lista de archivos de lanzamiento:

cd launch
ls

El comando ls anterior lista en la consola todos los archivos .launch.

Uno de estos archivos es el denominado “people_detect.launch” el cual contiene las definiciones de ROS (en formato XML) que definen cómo tomar imágenes de una fuente (una cámara por ejemplo) y aplicar los métodos de detección de personas de OpenCV.

Para que este archivo funcione con las cámaras Real Sense, será necesario modificar este archivo “people_detect.launch” de la siguiente manera:

(!) Nota: Este procedimiento será necesario solamente una vez para una misma versión del paquete de ROS OpenCV Apps. Solo será necesario ejecutarlo nuevamente si se actualiza la versión del paquete de ROS OpenCV Apps.

Ejecute el comando gedit para editar el archivo:

sudo gedit people_detect.launch

Ubique las siguientes líneas en el archivo ver (estado inicial) y cámbielas para que luzcan como se especifica en (estado editado)

(estado inicial)

<arg name="image" default="image" doc="The image topic. Should be remapped to the name of the real image topic." />

<arg name="debug_view" default="true" doc="Specify whether the node displays a window to show edge image" />

(estado editado)

<arg name="image" default="camera/color/image_raw" doc="The image topic. Should be remapped to the name of the real image topic." /> 

<arg name="debug_view" default="false" doc="Specify whether the node displays a window to show edge image" />

PASO 3 –  Ejecución del ejemplo ROS para detección de personas

Ejecute los siguientes comandos de consola de manera individual, preferiblemente en una pestaña nueva de terminal (SHIFT CTRL  T)

1. Iniciar el nodo maestro de ROS

roscore &

2. Ubicarse en el directorio de ROS referente a la cámara Real Sense

roscd realsense_camera/

3. Lanzar (ejecutar) el procesador ROS de la cámara Real Sense

* Para una R200 use el siguiente comando: roslaunch realsense_camera r200_nodelet_default.launch &

* Para una SR300 use el siguiente comando: roslaunch realsense_camera sr300_nodelet_default.launch &

4. Ejecutar el procesador ROS para el proceso de detección de personas

roslaunch opencv_apps people_detect.launch

5. Carguemos ahora el visor de imágenes de ROS

rqt_image_view

* Este comando abre una ventana que tiene una caja de selección donde podemos elegir el canal que queremos visualizar.

 

ttpile

El Tiny Tile con tecnología Intel

31 Mar , 2017,
Rebeca Rodriguez Tencio
, ,
No Comments

Hoy quiero presentarles nuestra primera impresión del TinyTILE de Element14. Se trata de una versión miniatura de la famosa placa Arduino/Genuino 101 (https://costaricamakers.com/?p=580), mide aproximadamente 35x26mm y de igual manera está basada en Intel Curie y es compatible con el software de Arduino. El TinyTILE tiene un costo de $39.00 al momento de escribir este tutorial y lo pueden conseguir en: la tienda de Element14

El tinyTILE posee 32bits, con una SRAM de 80kB y una memoria flash de 384kB, tiene instalado un sensor DSP (Procesador Digital de Señales ) de baja potencia, además de la opción BLE para el bluetooth, tiene los sensores del acelerómetro y giroscopio con 6 grados de libertad, posee un botón de “master reset” y un led que indica el estado de la alimentación (on\off), con una salida de voltaje de 3.3V.

Acá les dejo una guía muy sencilla de como iniciar y aprender más acerca del TinyTILE:

  1. Es importante tener instalado el software con el cual queremos empezar a experimentar con el tinyTILE, puede ser el muy conocido ARDUINO IDE (https://www.arduino.cc/en/Main/Software) o Intel Curie Open Developer Kit (https://software.intel.com/en-us/node/674972#). En este caso para el tutorial usaremos el software de Arduino.
  2. Hay que instalar las bibliotecas de Intel Curie y seleccionar la placa que es de tipo Arduino/Genuino 101

101

Nota: Es importante revisar que en el Administrador de Dispositivos, tenga el puerto correcto y haya detectado la placa utilizada.

101 error

 

devicemanager

EJERCICIOS:

En este caso se pueden utilizar los mismos ejercicios de práctica realizados por Jose Núñez en el blog de aprendizaje Arduino 101 (https://costaricamakers.com/?p=580 ) los ejercicios funcionan a la perfección con el TinyTILE de Intel.

En el caso que ya hayan realizado los ejercicios y quieran probar con algo diferente, pueden intentar con estos recursos adicionales:

TinyTILE – Getting Started Guide: https://www.element14.com/community/servlet/JiveServlet/previewBody/84364-102-1-362023/tinytile-GettingStartedGuide.pdf

TinyTILE – Pin Mapping: https://www.element14.com/community/servlet/JiveServlet/previewBody/84365-102-1-362024/tinytile-Pin-Mapping.pdf

IMG_20170304_142007

SimpleCV Hello World ++ en otros 5 minutos (Linux MINT 18)

4 Mar , 2017,
Jose Nunez
, , , , , ,
No Comments

Siguiendo nuestra serie sobre SimpleCV y como una motivación personal para aprender Python. Acá les presento un par de scripts basados en el ejemplo “Hello World” de SimpleCV.

El primero toma constantemente  una foto de una cámara y la “binariza”; es decir, la convierte cada pixel de la foto en negro o blanco dependiendo de su “posición estadística” respecto de los demás pixeles y muestra el resultado en pantalla.

El segundo toma la fotografía original, sin ser “binarizada” y la muestra en pantalla.

Al correr los scripts de manera simultánea podemos apreciar de mejor manera este filtro de binarización de la imagen.


PASO 1 – simplecv_helloworld.py

Usando un editor de texto como “xed” copiamos el siguiente programa y guardamos el archivo como “simplecv_helloworld.py”

from SimpleCV import Camera
# Initialize the camera
cam = Camera()
# Loop to continuously get images
while True:
    # Get Image from camera
    img = cam.getImage()
    img.save('/home/toruk-makto/imageport.jpg')
    # Make image black and white
    img = img.binarize()
    # Draw the text "Hello World" on image
    img.drawText("Hello World!")
    # Show the image
    img.show()

PASO 2 – simplecv_helloworld2.py

De nuevo, mediante el editor de texto copiamos el siguiente programa y guardamos el archivo como “simplecv_helloworld2.py”

from SimpleCV import Image

# Loop to continuously get images
while True:
    # Get Image from camera
    try:
        img = Image('/home/toruk-makto/imageport.jpg')
        # Draw the text "Hello World" on image
        img.drawText("Hello World!")
        # Show the image
        img.show()
    except:
        print "skip!"

PASO 3 – Ejecutar ambos scripts

En una terminal ejecutemos los siguientes dos commandos:



python simplecv_helloworld.py &

python simplecv_helloworld2.py &


Vemos como se muestran ambas imágenes “en tiempo real”

Para detener los scripts podemos digitar el comando fg(que trae el comando al “foreground de ejecución”) y luego usar las teclas CTRL C; o ejecutamos el comando sudo kill #### donde “####” corresponde al número del proceso que queremos detener; o simplemente cerramos la terminal.

 

 

IMG_20170304_130620

Iniciemos con SimpleCV en 5 minutos en Linux MINT 18 (Ubuntu 16.04)

Mar , 2017,
Jose Nunez
, , , ,
No Comments

Como les mencioné en mi publicación anterior, estamos investigando un poco sobre Vision Computarizada, y en eso nos tropezamos con SimpleCV como una propuesta práctica para adentrarnos en este mundo.

Me tomó cerca de 30 minutos (quizas por culpa de mi propio déficit atencional) instalar SimpleCV, así que aquí va un resumen para echar a andar esto en 5 minutos:


PASO 1 – Instalar dependencias de Python Support

wget http://launchpadlibrarian.net/109052632/python-support_1.0.15_all.deb
sudo dpkg -i python-support_1.0.15_all.deb

(tomado de http://askubuntu.com/questions/766169/why-no-more-python-support-in-16-04)


PASO 2 – Descargar SimpleCV de SourceForge.net

  1. Página Principal en SourceForge: http://simplecv.sourceforge.net/
  2. Página oficial: http://simplecv.org/
  3. Paquete que yo descargué: Paquete SimpleCV-1.3.deb (versión 1.3-1)

PASO 3 – Instalación

  1. Puede usar el comando sudo dpkg -i ~/Downloads/SimpleCV-1.3.deb
  2. También puede instalarse mediante la interfaz gráfica, haciendo clic derecho sobre el archivo SimpleCV-1.3.deb ubicado en la carpeta de descargas (Downloads), selecciona “Open with GDebi package installer” y hacer clic en el botón “Install Package

PASO 4 – Algo antes del Hello World…

  1. En la terminal, ejecutar el comando simplecv. Esto abre una consola simplecv
  2. En la consola simplecv, ejecute los siguientes comandos uno por uno:
    cam = Camera() #Esto genera una instancia de la cámara principal en una variable llamada cam
    img = cam.getImage() #Esto captura una foto de la cámara accesible desde la variable img
    d = img.show() #Esto abre una ventana que muestra la foto de la variable img. La variable d se usa para maniuplar esa ventana.
    d.quit() #Esto cierra la ventana de visualización.
    

Listo… para más información hay tutoriales en la página oficial. También la consola simplecv tiene tutoriales que uno puede llevar digitando el comando tutorial dentro de la consola simplecv. En mi caso, los tutoriales fallaban en algunas tareas. Pero si me sirvieron para obtener una idea de por dónde empezar.

 

IMG_20170216_190038

Intel Realsense Robotic Kit con Upboard + ROS

17 Feb , 2017,
Jose Nunez
, , , , ,
No Comments

IMG_20170216_190038Recientemente publicamos un primer artículo sobre el kit de robótica de Intel que trae una cámara Real Sense y un Upboard.

Aunque esta segunda entrega es bastante corta, esperamos que abra las perspectivas de nuestros lectores sobre lo que se puede llegar a hacer con uno de estos kits y los sistemas de robótica ROS y las facilidades que tiene para el manejo de cámaras Real Sense.

Paso 1 (30 min)

Comenzaremos diciendo que instalar Ubuntu y ROS en el Upboard es una tarea súperfacil siguiendo las instrucciones en este enlace:

https://software.intel.com/realsense/robotic-devkit-quickstart

Esto incluye

  1. Una revisión de materiales incluidos en el kit
    (!) Van a necesitar un cable HDMI estándar para conectar el video del UP Board a un monitor, un teclado, un ratón y un adaptador WIFI USB.
  2. La descarga de Ubuntu 16.04.1 LTS
    (!) Hoy (FEB18) gracias a las pruebas que está haciendo el profesor Tomás de Camino, vimos que ya la versión de Ubuntu 16.04.1 no está disponible en el enlace oficial que trae la guía de quick start de Intel, sino que fue reemplazada por la 16.04.2. Aunque en la buena teoría deben funcionar igual, en caso de experimientar algun problema con el setup acá les dejamos el enlace oficial a esa versión: 
    http://old-releases.ubuntu.com/releases/xenial/ubuntu-16.04.1-desktop-amd64.iso
  3. La creación de un USB Stick de instalación
  4. La instalación del Ubuntu en el UP Board
  5. La actualización del sistema operativo incluyendo el KERNEL de linux optimizado para el Upboard
    (!) En este paso puede que se necesite configurar los servidores APT de Ubuntu para que use los servidores en Estados Unidos (no en Costa Rica) ya que en CR no están los paquetes de ROS. Para esto se abre el menú de búsqueda de Ubuntu y se digita “Software Updates” y en la casilla “Download From” se selecciona “Server from United States”image
  6. La actualización del software de Real Sense
  7. La instalación del sistema ROS en su versión Kinetic
    (!) ROS es un “meta-sistema operativo” de código abierto para robots, desarrollado por la fundación de robótica de código abierto. Para aprender más sobre ROS pueden seguir este enlace http://wiki.ros.org/ROS/Introduction
  8. Ejecución de un “Nodelet” de ROS para la cámara Realsense R200
  9. La ejecución del programa “RVIZ” para visualización 3D
  10. ¡a celebrar carajo!

Si, eso es todo por ahora.

foto1s

Cámara de Seguridad Diferencial RASPBERRY PI 3 – Parte I

3 Feb , 2017,
Jose Nunez
, , ,
No Comments

En este pequeño tutorial vamos a explorar la forma de crear una cámara de seguridad diferencial. Es decir una cámara que reacciona al comparar matemáticamente dos fotografías constantemente.

Suena complejo, pero gracias a nuestros amigos de ImageMagick en Linux, termina siendo realmente sencillo.

Básicamente queremos tomar una foto como base, luego tomar otra, si esta segunda foto es diferente de la anterior, entonces algo se movió así que guardamos esa segunda foto y reportamos el hallazgo, usamos esta ultima foto como base y repetimos el proceso.

Para lograr esto en una Raspberry PI 3 (desde la cual escribo y programo hoy) vamos a utilizar dos utilitarios:

  1. raspistill: Utilitario de Raspbian que adquiere una foto de una cámara compatible con el puerto para cámara del Raspberry PI.
  2. compare: Utilitario del paquete ImageMagick de Linux que compara dos fotografías para determinar la diferencia matemática entre ellas.

(!) Antes de instalar paquetes adicionales, es importante recordar mantener al dia el sistema operativo mediante los comandos sudo apt update seguido de  sudo apt upgrade

Para instalar imagemagick usaremos: sudo apt install imagemagick

Para tomar una fotografía hay que tener en cuenta lo siguiente:

  1. Si no está habilitada, es necesario habilitar la cámara del Raspberry PI. Para esto se puede usar el Menu de Raspbian > Preferences > Raspberry PI Configuration
    Una vez en la pantalla de configuración, buscamos la pestaña “Interfaces” y nos aseguramos de que la cámara esté en posición “Enabled” y hacemos clic en “OK”
    (!) Es probable que necesite rebootear el Raspberry PI si la cámara estaba deshabilitada.
  2. El comando básico para tomar una foto es este: raspistill -o test.jpeg
  3. Una variante que usaremos más adelante para tomar una foto sin una pantalla de preview es esta: raspistill -nopreview -o test.jpeg

Para comparar dos fotografías usamos el siguiente comando: compare -metric RMSE foto1.jpeg foto2.jpeg NULL:

Así las cosas, el siguiente ejercicio tomaremos dos fotos, y las compararemos.

  1. Tomamos una primera foto: raspistill -o foto1.jpeg
  2. Sin variar la cámara ni la escena, tomamos una segunda foto: raspistill -o foto2.jpeg
  3. Variamos la escena, moviendo un objeto ligermanete y tomamos una tercera foto: raspistill -o foto3.jpeg
  4. Comparamos el resultado de una misma escena: compare -metric RMSE foto1.jpeg foto2.jpeg NULL:
    Esto nos devuelve un valor parecido a este : "2433.9 (0.0371389)".
  5. Ahora comparamos el resultado de la escena movida: compare -metric RMSE foto1.jpeg foto2.jpeg NULL:
    En este caso vemos que la diferencia matemática aumenta: "4396.62 (0.067088)"

Abajo dejo las fotos 1,2 y 3 en orden a manera de ilustración.

En nuestra próxima entrega vamos a estudiar la forma de automatizar este proceso con nodejs.

FIN!


Foto 1 – Base

foto1s


Foto 2 – Misma escena

foto2s


Foto 3 – Escena con variaciones

foto3s

 

 

 

 

IMG_20170120_183547

Intel Edison – Análisis de Datos con Lenguaje “R” mediante UBILINUX (nota rápida)

21 Ene , 2017,
Jose Nunez
, , , , , , , , , , , ,
No Comments

IMG_20170120_183547Durante 2016 hicimos varios proyectos interesantes con Intel Edison.

Uno de ellos fue un proyecto de colaboración con nuestros colegas de UNED en la investigación de sonido ambiente mediante tecnologías IoT.

Una de las cosas más interesantes que pudimos experimentar fue esta idea de hacer análisis de grabaciones de sonido mediante la plataforma Intel Edison y el lenguaje de “Machine Learning” llamado “R”

Esperamos detallar más aun el proceso en próximas entregas. Por lo pronto les dejamos con un tutorial de Sparkfun sobre cómo instalar UBULINUX, una versión de LINUX para IoT basada en DEBIAN en el Edison. La ventaja de esto es que se puede usar el sistema de paquetes APT-GET para instalar el lenguaje “R”

https://learn.sparkfun.com/tutorials/loading-debian-ubilinux-on-the-edison

Pese a que los desarrolladores de UBILINUX se lamentan de no tener soporte suficiente para esta herramienta; creo que vale la pena probar y ayudar un poco a generar ese ecosistema.

___fadd2efe-349e-4ec3-b03e-b6fbd6b6ebfe-imageId=0a6ed59a-7a19-4839-b801-9691e0c0ae4a (1)

Intel Joule – Primeros Pasos

20 Ene , 2017,
Jose Nunez
, , ,
No Comments

___fadd2efe-349e-4ec3-b03e-b6fbd6b6ebfe-imageId=0a6ed59a-7a19-4839-b801-9691e0c0ae4a (1)En nuestra publicación anterior hicimos un breve recorrido sobre las especificaciones del Joule de Intel, una tarjeta de desarrollo pensada para adentrarnos en el mundo de las aplicaciones de alta demanda computacional en dispositivos pequeños, ya sea vestibles o de tamaño reducido; especialmente sistemas de análisis de imágenes 3D de cámaras Intel Real Sense.

En esta ocasión iremos paso a paso por los tutoriales de Intel sobre cómo empezar a desarrollar soluciones en esta magnífica plataforma.

Para esto nos basaremos en la guía de usuario suministrada por el fabricante mientras tratamos de resumir y enfocarnos en los aspectos más importantes.


1 Materiales Requeridos

Comencemos por los diferentes materiales que serán necesarios para nuestro primera incursión funcional.

  1. Una Plataforma de Desarrollo Intel Joule 570x (enlace)
  2. Un disipador de calor (suministrado con la plataforma)
  3. Fuente de poder 12V, 3A (En este tutorial nosotros usamos una de 12V, 2A) conector de barril de 5mm con centro positivo de 2.1mm
  4. Cable micro-USB tipo B para la comunicación serial con el dispositivo (cable no incluido en el kit). Es el tipo de cable con que actualmente cargamos los telefonos Andriod.
  5. Teclado USB. Nosotros utilizamos un teclado inalámbrico con ratón marca Microsoft sin mayor problema.
  6. Cable HDMI macho estándar a macho conector micro
  7. USB Hub: Opcionalmente un concentrador USB (hub) con suministro eléctrico independiente (en caso de querer conectar dispositivos que demanden más de 900mA)
  8. Bluetooth: Opcionalmente también se pueden conectar dispositivos de teclado y ratón vía Bluetooth.
  9. Computador Anfitrión: Se necesitará un computador para programar el Joule.
    • Para actualizar el BIOS del Joule será necesario un computador anfitrión con sistema operativo Windows 8, 8.1 o Windows 10.
    • El sistema operativo que se vaya a utilizar en el Joule introduce algunas dependencias en el computador anfitrión que se use para programarlo. Así, si se utiliza LINUX de referencia que provee Intel o si se utiliza Ubuntu para IoT, se puede usar un computador anfitrión con sistema operativo Windows, Linux o Mac. Pero si el sistema operativo del Joule es Windows IoT, el computador anfitrión deberá estar equipado con sistema operativo Windows 10 y demás especificaciones de Microsoft descritas acá.

2 Ambientes de Desarrollo de Intel

El Intel Joule se puede programar de muy diversas formas. Intel recomienda usar alguno de los siguientes sistemas para programara la plataforma:

  1. Intel System Studio IoT Edition para Windows, Mac, o Linux en  caso de querer programar la plataforma mediante lenguajes como C/C++ o Java. Nótese Intel System Studio para Linux requiere Ubuntu 16.04 LTS como sistema operativo anfitrión en 64bit.
  2. Intel XDK tambien para Windows, Mac o Linux, en caso de querer programar la plataforma con NodeJS

(!) En esta publicación utilizaremos Intel XDK tanto en un anfitrión Linux (Mint 18) como en Windows 10.


3 Requisitos para Instalación del Sistema Operativo del Joule

La plataforma Intel Joule trae de fábrica una versión optimizada del sistema operativo LINUX. Se recomienda actualizarla ya sea a la imagen más reciente o a alguna versión de Ubuntu Desktop o de Windows for IoT.

Dicha actualización requiere:

  1. Flash Drive de tipo USB 3.0 con 16GB de capacidad conectado a un USB HUB con alimentación independiente. Puede ser USB 2.0 pero la transferecia de datos tendrá una tardanza notoria.
  2. Tarjeta MicroSD de 16GB (puede usarse un Flash Drive adicional si se trata del LINUX de referencia)
  3. El computador anfitrión deberá tener capacidad de leer la tarjeta del punto #2 anterior.
  4. Instrucciones (En inglés) para la actualización del sistema operativo

4 Ensamblando la Plataforma de Desarrollo

Este enlace provee instrucciones muy completas y sencillas sobre cómo preparar / ensamblar los diferentes elementos de la plataforma desarrollo. Se incluyen en dicho enlace pasos importantes como:

  1. Instalación del disipador de calor
  2. Antenas
  3. Instalación de espaciadores

5 Sobre el sistema operativo de la plataforma

En este enlace se describe en detalle las principales opciones de sistema operativo las cuales incluyen:

  1. Ubuntu Desktop 16.04 LTS
  2. Ubuntu Core 16.04 LTS
  3. Windows 10 IoT Edition
  4. Linux de referencia para IoT

6. Actualizando el BIOS

Un primer paso importante en el uso de Joule consiste en actualizar el BIOS. Es el software que orquesta ya carga del sistema operativo y otras funciones de entrada/salida.

El procedimiento es realmente sencillo, nos ha tomado unos 20 minutos en realizarlo. Se describe en este enlace:

https://software.intel.com/en-us/flashing-the-bios-on-joule


7. ¿Qué sigue?

En nuestra siguiente entrega estaremos explorando la instalación de Windows 10 for IoT en el Joule.