Category Archives: Conceptos

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

Ya Contamos Personas… Ahora hagamos algo con Python

20 Abr , 2017,
Jose Nunez
, , , , ,
No 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…
microsoft-augmented-reality1-1050x580

Una Introducción a la tecnología de Realidad Aumentada (AR)

9 Mar , 2017,
Luis Diego Jimenez Sanchez
, ,
No Comments

El 6 de Julio del 2016 salió Pokemon GO, uno de los actuales juegos pioneros en el mundo de la realidad aumentada y un despertar al mundo del interés sobre AR.  Quizás hayan escuchado sobre realidad virtual y realidad aumentada, así que, que las diferencia?  Realidad virtual, o conocido por sus siglas en inglés como VR, es la aplicación de un entorno o ambiente digital o virtual, que detecta diferentes caracteristicas de tiempo real del usuario y reacciona de manera que este siente que es real.  Realidad aumentada, es la ampliación de imágenes reales mediante el uso de algún dispositivo, de manera que agrega imágenes virtuales a lo que el usuario está observando.

Para empezar la investigación y aprendizaje de la realidad aumentada, un área totalmente desconocida para mí, el plan era iniciar con los Google Glass debido a su fama como empresa, esto antes de darme cuenta que el proyecto había sido descontinuado desde el 2015.  A partir de aquí, lo único que quedaba era iniciar búsqueda de  los productos que hay en el mercado.  Son 5 los que más me llamaron la atención, esto según los siguientes parámetros; precio, quien los produce y a que mercado se dirige el producto y como empezar a usarlos.   Después de investigar en internet por dispositivos de la naturaleza de AR, construí una lista de los dispositivos que mejor se acomodan a mi necesidad de entender el funcionamiento y alcance de estos.  Los dispositivos son los siguientes:

VUZIX M3000 Smart Glasses:

               Producido por la empresa VUZIX, la cual se dedica a la fabricación de lentes de VR y AR, los lentes M3000 tienen fecha de lanzamiento este verano de 2017, con precio que ronda los 900$.  Este producto tiene las capacidades de un teléfono inteligente con capacidad de conectarse a redes WIFI, basada en Android y se puede considerar una mini computadora.  Los M3000 se pueden personalizar, son más dirigidas a empresas de manera que se usen para entrenamientos, registros de procedimiento y data, y otros aspectos de la industria.  A continuación un link con demo de estos Smart glasses, https://www.youtube.com/watch?v=y6SGlOLVpg8.

VUZIX M3000

Imagen 1. VIZUX M3000 Smart Glasses

Microsoft HoloLens:

               El kit de desarrollo de HoloLens se puede encontrar por unos $3000 en la página,  https://www.microsoft.com/microsoft-hololens/en-us/buy.  Producido por los gigantes en la industria, Microsoft, tiene versiones comerciales desarrolladas para casos específicas.  Un ejemplo es para Case Western Reserve University tiene un programa de Anatomía Humana con el uso de hologramas.  Otras empresas que utilizan HoloLens para mejorar aspectos en su performance son Lowes, Volkswagen y Airbus.  Para el interés de desarrollar, el kit viene con su SDK respectivo, hay versión de SDK en Unity Engine donde se pueden crear objetos, escenas y usar comandos para reconocimientos de gestos.

hololens

Imagen 2. Microsoft HoloLens

Sony SmartEye Glass:

               Sony SmartEye Glass, no se puede comprar directamente en Costa Rica ni America Central, sino que es por pedido especial en Estados Unidos y algunos otros países en Europa.  El precio en la siguiente página es de $900.  Al igual que los otros lentes de realidad aumentada, estos también son Developer Kits por lo cual se permite al usuario darle el uso según las capacidades de lo que podas desarrollar.  Sony es la empresa que las produce y una diferencia de las demás es que esta trae un control cableado a los lentes, es pequeño por lo cual no produce incomodidad en el usuario.

sony smarteye glass

Imagen 3. Sony SmartEye Glass

Lenovo Phab Pro 2:

               Este teléfono, Lenovo Phab Pro 2 vale alrededor de $499.99 si se compra directamente de la página de Lenovo.  A mi opinión, no es un kit de desarrollo ni nada por el estilo.  Está destinado más hacia el uso de apps que incluyan AR, juegos por ejemplo ya se encuentran en el mercado.  La aplicación más interesante que encontré es roOomy Reality, esta permite mostrarle al usuario como se vería una nueva pieza de mueblería en algún determinado cuarto de su hogar.  Parece arropar la idea de la realidad aumentada al facilitar una tarea de la vida real mediante el uso de imágenes digitales.

lenovo phab pro 2

Imagen 4. Lenovo Phab Pro 2 celular

Intel RealSense:

              Aunque Real Sense no es una tecnología directamente relacionada con realidad aumentada en lo referente a proyeccion de elementos visuales a la vista del usuario, si permiten un acercamiento a esta mediante la comprensión experimental de las librerías y tecnologías adyacentes tales como captura, análisis y manipulación de imágenes y video.  Real Sense es un producto de un concepto tecnológico denominado “Perceptual Computing” que tiene que ver como los dispositivos computacionales pueden percibir mensajes del usuario diferentes al teclado/mouse tales como los gestos que vas a experimentar. Augmented Reality tiene que ver más con anteponer contenido a las imágenes que se le presentan al usuario; sin embargo en efecto las tecnologías y conceptos se traslapan.

La tecnología Intel RealSense, ofrece varios dispositivos y kits de desarollo, en precios que van desde los $99 para una cámara R200 hasta los $349 para un kit de desarrollo con cámara R200 y sistema computacional UP Board.

real sense

Imagen 5. Intel RealSense camera F200

Las cámaras, cuentan con la capacidad para hacer escaneos en 3D, reconocimiento facial y puede generar imágenes basándose en distancias de cuerpos u objetos de las cámaras.  Los SDK, kits de desarrollo de software, de Intel, en mi opinión es la mejor opción para empezar a trabajar con realidad aumentada y en siguiente mis razones:

  • Precio: es el producto más accesible, siendo el de $349 el kit más costoso. A pesar de que no se pueden comparar estos productos directamente debido a que sus objetivos y alcances son muy distintos, si los puedo comparar al tratarse de un primer acercamiento a esta tecnología.
  • Aplicación del hardware:  Para efectos de aprendizaje, tales como los mios, en el cual es necesario entender el alcance de registrar data a partir de entradas por camara, me parece mejor opcion usar el RealSense debido a las librerias que trae como reconocimiento facial o de gestos.

Mi primer experimento será con Intel RealSense, probablemente algún carro o robot al que pueda darle direcciones con gestos de mis manos.

Capture

EL ARTE TEXTIL EN FUSIÓN CON LA TECNOLOGÍA

7 Mar , 2017,
Rebeca Rodriguez Tencio
,
No Comments

Electrotextil es el nombre que se le da a la idea “mágica” de combinar la industria textil con la electrónica, creando un nuevo concepto de diseño que no solo es “fashion”, sino un impulso a la innovación.

Las prendas o accesorios que normalmente se utilizan no contienen elementos electrónicos, sin embargo dentro de 10 años es factible que cada tipo de ropa o accesorio tenga incorporado distintos componentes con funciones tecnológicas que contribuyan a la comodidad, salud y bienestar de los usuarios.

Actualmente los e-textiles presentan varios retos fundamentales para el progreso en el uso de esta tecnología, ya que un textil electrónico debe ser flexible, discreto, lavable y estéticamente aceptable, lo que provoca un desafío en la construcción del diseño y conectividad confiable.

Acá les comparto unos enlaces muy interesantes donde pueden sacar ideas para empezar a involucrase en el mundo wearable:

Espero sus comentarios acerca del tema :o). En el próximo artículo vamos a empezar a experimentar y crear un proyecto con diferentes componentes wearables paso a paso.

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

IMG_20160713_154251

Robot de dos llantas y un micro-controlador S4A-EDU

13 Jul , 2016,
Jose Nunez
, , , ,
one comments

Descripción

En este experimento vamos a montar un pequeño robot de dos ruedas que controla su trayectoria mediante la diferencia de velocidad de cada rueda. Para esto utilizaremos un micro-controlador denominado S4A-EDU (Sketch 4 Arduino EDUCATION). El cual implementa la circuitería necesaria para controlar dos motores DC incluyendo la implementación de dos circuitos de “Puente H” que se utilizan para controlar la dirección en la que gira cada motor manipulando la polaridad a la que son expuestos.

Este es un experimento resumido que require un nivel de conocimiento medio en Arduino y Electrónica.


Referencias Externas

  1. Manual Introductorio del Microcontrolador (en inglés): S4AIntroduction
  2. Sketch for Arduino: http://s4a.cat

Advertencia y Condiciones de Uso

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


Materiales


Pasos Resumidos

A. Montaje y Prueba Inicial

  1. Ensamble el chasis con las ruedas y los motores (siguiendo las instrucciones del fabricante)
  2. Agregue  el microcontrolador S4A-EDU al chasis
  3. Asegúrese de que el interruptor on/off del micro-controlador S4A-EDU está colocado en la posición de OFF
  4. Conecte el micro-controlador S4A-EDU al computador usando un cable de USB a Mini-USB
  5. Windows:
    1. Instale el “controlador de windows” para el puerto USB del microcontrolador CP210x (nosotros lo descargamos de este enlace)
  6. Arduino IDE:
    1. Instale y seleccione la tarjeta “Amtel atmega328p xplained mini“. La encontramos buscando “328p” en Tools > Boards > Boards Manager
    2. Configure  el puerto correspondiente. Para nuestro caso aparece  en el “Device Manager” como “Silicon Labs CP210x USB to UART Bridge en COMxx
    3. Abra el ejemplo  “Blink” (File > Examples > 01.Basics > Blink) y subirlo al microcontrolador.
    4. En este punto la luz (azul en nuestro caso) del S4A-EDU parpadea cada segundo. Nótese que el interruptor on/off del micro-controlador está todavía en la posición OFF.
    5. (!) En este punto tenemos un chasis de robot con dos ruedas, con un micro-controlador S4A-EDU montado sobre el chasis el cual podemos programar utilizando el ARDUINO IDE.

B. Trabajando en los motores

En esta etapa vamos a conectar los motores al micro-controlador S4A-EDU y vamos a utilizar un programa básico para hacer que el robot “gire sobre su propio eje”. Esto es, hacer que una de las llantas se mueva en una dirección y la otra llanta en la dirección opuesta, ambas a la misma velocidad.

  1. Conexiones:
    1. Asegúrese de que el interruptor on/off del micro-controlador S4A-EDU está colocado en la posición de OFF
    2. Conecte el positivo de cada motor (cable rojo) y el negativo (cable negro) de cada motor según se indica en la parte inferior derecha de la siguente imagen.robot_rotate
    3. En nuestro caso, vamos a alimentar el sistema mediante una batería LIPO 3.7V de 2500MAh.  (!) Nótese que el circuito funciona con 6-9V según las especificaciones. Nosotros en este experimento usamos un convertidor de 3V a 5V el cual parece funcionar perfectamente.
  2. Arduino IDE:
    1. Abra un nuevo programa en el ARDUINO IDE, y pegue en él el código de este archivo: https://github.com/janunezc/robotics/blob/master/_02_s4a_edu_rotate/_02_s4a_edu_rotate.ino
    2. Cárguelo al S4A EDU
  3. Funcionamiento del Programa:
    1. En la función “setup()” se definen los pines del controlador utilizados para manipular los motores junto con el pin 13 que se utiliza para ilumnar el LED integrado en el micro-controlador S4A-EDU; que nos va a servir de medio para ver la ejecución del programa.
    2. Una vez definidos los pines de salida se hace una llamada a la función doBlink la cual hace parpadear rápidamente el LED integrado como indicativo del que el Setup está completado.
    3. Seguidamente se configuran la velocidad y dirección de cada motor. Es en este momento que el robot comienza a girar.
    4. La función loop() permanece vacía en este caso.
    5. La función setMotor() se encarga de manipular los pines de velocidad y dirección para el motor solicitado.
    6. La función doBlink() se encarga de hacer parpadear el LED del micro-controlador un numero de veces determinado con una espera entre transiciones tambien determinado en los parámetros.
  4. (!) En este punto. Al desconectar el cable USB del micro-controlador S4A-EDU y poner el interruptor a la posición ON, el sistema parpadea 10 veces el LED indicador y comienza a girar sobre su propio eje.

Agradecimientos

Queremos expresar nuestro agradecimiento a nuestro colega Gerardo Mora y al estudiante Jean Paul Jimenez por acompañarnos en esta aventura de descubrir el funcionamiento de los diferentes componentes de este robot.

IMG_20160315_120952~3

Guía para el ProfesionaI de T.I. de una PYME

27 May , 2016,
Jose Nunez
No Comments

En no pocas ocasiones, las PYMEs enfrentan el reto de asegurar la adecuada operación de sus tecnologías de información mediante modelos de servicios que en lugar de mantener un departamento de Tecnologías de Información o de Tercerizar los servicios, tiene más sentido contratar un solo profesional para administrar esta importante área y a la vez tercerizar algunos aspectos como la creación y modificación de los sistemas empresariales.

En esta guía rápida se discute los diferentes aspectos en los que el profesional de informática de una PYME puede enfocarse para asegurar la operación adecuada y contínua de dichas tecnologías.

  1. Portafolio de Servicios (Internos y Tercerizados)
  2. Continuidad de los Servicios
  3. Seguridad de la Información
  4. Inventario de Redes y Equipos
  5. Perfiles de Configuración
  6. Inventario de Software y Licencias
  7. Registro, Programación y Seguimiento de Incidentes y Solicitudes de Servicio

1. Portafolio de Servicios Internos y Tercerizados

Un primer aspecto que el profesional de T.I. de una PYME debe administrar es conocer los servicios de tecnologías de información y comunicaciones que se brindan, cuales son internos y cuales proveidos por un tercero.

No se trata de una lista de servicios (email, povisión de PC’s, servicio de Internet…) sino un perfil que incluya datos como principales contactos, costos esperados de operación y de mantenimiento tanto preventivo como correctivo, principales oferentes del servicio tercerizado, tiempos esperados de respuesta, procesos de recuperación de desastres, respaldos, etc. A su vez es importante definir el valor de negocio de cada servicio y el tiempo máximo que puede operar la empresa sin ese servicio, así como las medidas alternas en caso de ausencia del servicio. Por ejemplo: ¿Qué sucede si falla el servicio de correo electrónico? ¿cuanto tiempo puede mantenerse la empresa operando sin dicho servicio? ¿hay medidas alternas que se puedan tomar para paliar la falta de dicho servicio?

2. Continuidad de los Servicios

Una vez identificados los servicios que definen las tecnologías de información, es importante definir las actividades que aseguran el correcto funcionamiento de los servicios en el tiempo. Por ejemplo, ¿se cuenta con PC’s de contingencia para cuando se daña la PC de uno de los vendedores? ¿Existe respaldo de los datos de los usuarios? ¿Qué tan rápido se puede disponer de esos datos en caso de pérdida del medio de almacenamiento principal?

3. Seguridad de la Información

Este es un aspecto medular para toda organización que haga uso de las tecnologías de información. No se trata simplemente de “tener el antivirus actualizado”; se trata de asegurar que se tomen medidas razaonables y efectivas para resguardar la integridad, la confidencialidad y privacidad y la disponibilidad tanto de datos y servicios relacionados conm las tecnologías de información; contra el acceso por parte de personas no autorizadas.

De nuevo, no se trata de instalar el antivirus más reciente. Involucra el aseguramiento físico de los servidores, la configuración adecuada de puertos de red en los computadores, el desecho adecuado de documentos confidenciales que, de ser desechados en la basura ordinaria ponen en riesgo la seguridad de la información de la empresa.

Tambien involucra este aspecto un adecuado manejo de las identidades de usuario, de las políticas referentes a contraseñas que conllevan la responsabilidad de que las actividades registradas en un sistema informático por un usuario determinado hacen a este usuario responsable de dichas actividades.

4. Inventario de Redes y Equipos

Este es otro aspecto fundamental de la administración de tecnologías de información. Conocer los equipos que brindan servicio a la organización, no solo PC’s sino tambien teléfonos móviles, servidores, enrutadores, centrales telefónicas. Esto también incluye conocer el estado de los equipos, sus características, su historial de reparaciones e historial de cambios, etc.

5. Perfiles de Configuración

Un aspecto que frecuentemente se deja de lado es la administración de la configuración de los equipos. Es decir, poder contar con perfiles que nos permitan entender cómo se configura de manera efectiva tal o cual equipo. Por ejemplo, es importante mantener un registro de cómo está configurado el enrutador de red; y encaso de que sea necesario reemplazarlo, poder entender cómo configurar el reemplazo para que se desempeñe de manera correcta. Esto aplica tambien para las PC’s, tener un registro del punto de partida de la configuración de las PC’s, qué software deben tener instalado, y qué software no; cual es el desempeño esperado en determinadas actividades, etc.

6. Inventario de Software y Licencias

Es imprescindible tener un inventario de Licencias de Software, y de paquetes instalados de manera oficial en cada PC de la organización; de nuevo, no solo a razón de confeccionar una lista, sino de entender el costo a través del tiempo, de entender la obsolescencia de los paquetes, contratos de licenciamiento, qué sucede si se reemplaza una PC, la licencia se mantiene en la nueva PC (lo cual es poco frecuente) o es necesario pagar una licencia nueva.

7. Registro, Programación y Seguimiento de Incidentes y Solicitudes de Servicio

Finalmente, pero no por ello de menor importancia está el seguimiento, programación y registro de incidentes y solicitudes de servicio. Cuando se contrata un servicio tercerizado por ejemplo, el profesional de T.I. es la persona que está en mejor capacidad de entender de qué se trató el servicio, qué costos adicionales involucra y si el servicio se entregó a cabalidad con las expectativas; si se cuenta con una garantía y en qué consiste esta garantía.

Este aspecto también involucra el seguimiento de las necesidades de servicio de los usuarios. Desde “necesito que me instalen Office en mi nueva PC” hasta “no puedo usar la impresora”.


Esperamos que este artículo les sea de utilidad. En una próxima entrega estaremos discutiendo sobre técnicas prácticas para proveer una administración adecuada a cada uno de estos aspectos.

hash_3b

Cifrado de contraseñas

28 Abr , 2016,
Jose Nunez
, , ,
No Comments

El tema de seguridad informática adquiere una relevancia exponencial en el advenimiento de la Internet de las Cosas, y de la cultura Maker; especialmente conforme comenzamos a desarrollar sistemas que realizan actividades más y más relevantes para el bienestar humano.

No son pocas las referencias de incidentes de seguridad de empresas de alto nivel tales como Sony, Linkedin y otros, que han sido víctimas del robo de datos de credenciales de usuarios; con el agravante de que, en numerosas ocasiones esas credenciales son utilizadas por los usuarios en multiples dominios; por ejemplo, el uso de una misma clave para varios sistemas (Facebook, Email, etc)

Este artículo tiene como objetivo explicar algunos procedimientos de uso común para el almacenamiento de contraseñas afin de reducir el riesgo de robo de credenciales para sus usuarios en sus aplicaciones IoT.

1. Teoría de “Hashing”

La palabra del Inglés “Hash” se traduce en español como “Picadillo”.

Este es el nombre de un procedimiento ampliamente usado para cifrar contraseñas que se deban almacenarse en los sistemas. Consiste en ejecutar un algoritmo matemático para convertir una contraseña (o cualquier texto legible) en otro cifrado que sea prácticamente único para esa contraseña.

Dentro de los algoritmos más confiables en la actualidad están el SHA1 o el SHA256. La característica principal de estos algoritmos es que para un texto legible dado (por ejemplo “mi contraseña”) al ejecutar el algoritmo para dicho texto, siempre va a resultar en un mismo texto cifrado, y que la mínima modificación del texto origen (por ejemplo “mi contrasena”) el resultado del algoritmo es extremadamente diferente. La otra caracterísitca importante es que el algoritmo descompone el texto legible inicial de forma tal que no hay forma matemática para re-componer el texto legible a partir del hash resultante.

Ejemplo:

SHA1("mi contraseña") ==> "823b57eb35f4e42e06a365d2af3cb6ebd6f9e89e"
SHA1("mi contrasena") ==> "6347b04dd43af8911075fc585d72f2fed320b264"

La forma en que se utiliza un mecanismo de hashing para almacenar contraseñas es que, en el sistema no se almacena la contraseña legible, sino su versión “hash”, y a la hora de autenticar un usuario, se toma la contraseña legible que este usuario suministra y se hace pasar por el proceso de hashing, luego se compara el hash almacenado con el hash de la contraseña suministrada para decidir si el usuario ingresó la contraseña correcta.

1.1 Debilidades

Si bien se ha mencionado que no existe forma matemática de re-componer un texto legible a partir de un hash, sí existen formas de conseguir:

(Caso a) el valor de la contraseña original si esta es demasiado simple, o

(Caso b) un valor que, pasado por el proceso de hashing, dé como resultado un valor hash predeterminado. A este proceso (caso b) se le llama “Colisión de hash” o “Hash Collision” que consiste en qué tan facil es encontrar dos valores que den como resultado un valor hash predeterminado. Para contrarrestar la debilidad  se debe utilizar un algoritmo de hashing suficientemente robusto respecto de la capacidad computacional actual. Por ejemplo, el algoritmo MD5 no se considera seguro por que es relativamente fácil con la capacidad computacional actual, encontrar colisiones para valores predeterminados de hash.

Cuando una contraseña es demasiado simple o predecible (caso a), puede encontrarse su valor de hash en tablas que se conocen como “rainbow tables”. A manera de ejemplo, basta con buscar en google el hash “7110eda4d09e062aa5e4a390b0a572ac0d2c0220” para ver los numerosos sitios de Internet que son capaces de determinar que corresponde a la clave “1234” usando el algoritmo SHA1

La siguiente figura explica el proceso de creacion de un hash.

hash_1b

2. Agregando algo de Sal

Para contrarrestar la existencia de tablas “rainbow” descritas anteriormente (caso a) se utiliza un mecanismo de seguridad adicional que se llama adición de sal  que consiste en agregar un valor aleatorio para cada contraseña a fin de que el valor hash resultante no coincida con ninguno en una tabla “rainbow”

En la siguiente sección explicamos el proceso de almacenamiento de “hash salados” y el proceso de comparación de una contraseña legible con estos hash a fin de determinar si la contraseña es correcta.

2.1 Almacenando contraseñas con hash salados

En el anterior apartado titulado “Teoría de Hashing” explicamos como el uso de una funcion SHA1 (u otro algoritmo de hashing) puede ser utilizado para generar códigos hash a partir de contraseñas legibles que se puedan almacenar, con ciertas limitaciones o debilidades inherentes a contraseñas demasiado sencillas o algoritmos demasiado fáciles de “hackear”.

El procedimiento de crear un “hash salado” a partir de una contraseña legible se puede enumerar en los siguientes pasos:

  1. Crear un hash simple a partir de la contraseña legible (   hash = sha1("1234");   )
  2. Generar un código aleatorio (sal) apto para criptografía*  (   sal = random_int(100000,999999);   )
  3. Concatenar la sal con el hash simple (  codigoSalado = sal + hash; )
  4. Generar un hash con base en los valores concatenados (   hashRobusto = sha1(codigoSalado);   )
  5. Concatenar nuevamente la sal con el nuevo hash para ser almacenado (   codigoParaAlmacenar = sal + hashRobusto; )
  6. Almacenar el valor del hash robusto con la sal  (   guardar (hashParaAlmacenar);

En la siguiente figura se ilustra el flujo de datos y procesos relacionados con el almacenamiento de contraseñas a través de hash salados.

hash_2d

2.2 Autenticación, comparando contraseñas legibles on hash salados almacenados

El procedimiento para autenticar un usuario respecto de una contraseña almacenada en la forma de un hash salado se puede describir como sigue:

  1. Generar un hash simple a partir de la contraseña suministrada  (   hash = sha1(contraseña);   )
  2. Obtener de la base de datos el hashRobusto y la sal correspondientes (   hashGuardado = obtenerHash (usuario);   )
  3. Descomponer la sal del hash robusto  (   sal = substr(hashGuardado, 0, 6);   hashRobustoAlmacenado = substr(hashGuardado,6);   )
  4. Concatenar la sal junto con el hash simple generado a partir de la contraseña suministrsada (   salYHash = sal + hash;   )
  5. Generar un hash robusto para la comparacion a partir de la concatenacion anterior (   hashParaComparar = sha1(salYHash);   )
  6. Realizar la comparacion de hashes (contraseñaValida =  hashParaComparar == hashRobustoAlmacenado; //comparación veradero/falso )

En la siguiente figura se ilustra el flujo de datos y procesos para la comparacion de contraseñas en un proceso de autenticación.

hash_2e

Conclusiones

Es imperativo no almacenar contraseñas legibles en los sistemas de informáticos, incluyendo IoT.

El uso de hash salados en el almacenamiento de contraseñas es una técnica ampliamente utilizada para minimizar los riesgos de robo de credenciales, el procedimiento es extremadamente sencillo y permite incrementar de manera significativa la seguridad de los sistemas.

¡No hay razón para hacerlo mal!


(*) Un valor aleatorio apto para criptografía es un número dificil de predecir. En general los números aleatorios generados por software se basan en listas predefinidas, que pueden ser más o menos predecibles.

arduino101b

Arduino 101 – Tutorial

2 Abr , 2016,
Jose Nunez
, , , , , , ,
No Comments

Bienvenido al tutorial introductorio de la placa Arduino 101; sin duda una tarjeta especial para aprender y para prototipar usando conceptos de movimiento (aceleración, rotación) y sistemas de comunicación de red de área personal (PAN) para el desarrollo de ideas de tecnología vestible.

Al momento de escribir este tutorial, el Arduino 101 tenia un costo de $30, mientras que el Arduino UNO convencional un costo de $25.


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


Contenido:

  1. ¿Qué es el Arduino 101 y qué es Intel Curie?
  2. Ejercicios:
    1. Acelerómetro y Giroscopio
    2. Acelerómetro y BLE: Contador de Pasos
    3. Bluetooth Low Energy (BLE): Monitor de Batería
    4. RTC / EEPROM
  3. ¿Dónde encontrar más información?

¿Qué es un Arduino 101 y qué es un Intel Curie?

El Arduino 101 es una de las más recientes creaciones de la familia de placas Arduino. Es una placa para prototipado y aprendizaje que implementa el nuevo chip SoC (Sistema en un solo chip) de Intel denominado Intel Curie(r)

¿Intel Curie?

Se trata del sistema en un solo chip más reciente de Intel, orientado al “mercado maker” que tiene como objetivo traer mayores capacidades computacionales y de sensado y comunicación al mundo maker y el mercado de la computación vestible y embebida.

Dentro de las especificaciones y funcionalidades de Intel Curie encontramos:

  • Voltaje de operación de 3.3V
  • Memoria Flash (no volatil) de 384Kb
  • Memoria SRAM (volatil) de 80Kb
  • Sistema on-chip QUARK-SE
  • Capacidad de comunicación Bluetooth Low Energy (BLE)
  • Combo integrado de sensores: acelerómetro + giroscópio 6 ejes.

Al implementar Intel Curie, el Arduino 101 presenta las siguientes ventajas comparativas con respecto del Arduino UNO

  • 196 Kb de memoria no volatil (flash). 6 veces más memoria que el Arduino UNO que trae 32Kb.
  • 24 Kb de memoria volatil (SRAM). 12 veces más memoria que el Arduino UNO que trae 2Kb.
  • 32MHz de velocidad de reloj; lo que representa el doble de los 16MHz del Arduino UNO
  • Alimentación (barril) de 7-12V
  • Sistema Operativo de Tiempo Real (RTOS) instalado en el Curie
  • Reloj de tiempo real (RTC)
  • Corriente por pin: 20mA
  • Sensores de Movimiento de 6 ejes: Acelerómetro (x,y,z) y giroscopio (roll, jaw, pitch)

La siguiente imagen ilustra los 6 ejes de movimiento sensables:

ejes_acc_gyro

Figura 1 – Ejes detectables de movimiento.


EJERCICIOS

En estos cuatro ejercicios exploraremos las diferentes funciones del Arduino 101, en lo referente a sensores de movimiento, comunicación Bluetooth BLE y uso de la memoria no volatil del sistema.

Para todos los ejercicios utilizaremos este programa base:

/*
 Copyright (c) 2015 Intel Corporation. All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 Modified by Jose Nunez @ intel corporation on April 2 2016

 https://www.arduino.cc/en/Tutorial/Genuino101CurieBLEHeartRateMonitor
 
*/

/*
 This sketch example demonstrates how the BMI160 on the
 Intel(R) Curie(TM) module can be used to read accelerometer data
*/

#include "CurieIMU.h"
#include <CurieBLE.h>

int EXERCISE = 1;


/****************** BLE HEARTRATE GLOBALS **************************/
BLEPeripheral blePeripheral; // BLE Peripheral Device (the board you're programming)
BLEService heartRateService("180D"); // BLE Heart Rate Service

// BLE Heart Rate Measurement Characteristic"
BLECharacteristic heartRateChar("2A37", // standard 16-bit characteristic UUID
 BLERead | BLENotify, 2); // remote clients will be able to get notifications if this characteristic changes
 // the characteristic is 2 bytes long as the first field needs to be "Flags" as per BLE specifications
 // https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.heart_rate_measurement.xml

int oldHeartRate = 0; // last heart rate reading from analog input
long previousMillis = 0; // last time the heart rate was checked, in ms
/****************** END OF BLE HEARTRATE GLOBALS **************************/

void setup() {
 delay(3000);
 Serial.begin(9600); // initialize Serial communication
 pinMode(13, OUTPUT); // initialize the LED on pin 13 to indicate when a central is connected
 while (!Serial); // wait for the serial port to open
 Serial.println("SETUP...");
 // initialize device
 Serial.println("Initializing IMU device...");
 CurieIMU.begin();

 // Set the accelerometer range to 2G
 CurieIMU.setAccelerometerRange(2);

/****************** BLE HEARTRATE SETUP **************************/
 /* Set a local name for the BLE device
 This name will appear in advertising packets
 and can be used by remote devices to identify this BLE device
 The name can be changed but maybe be truncated based on space left in advertisement packet */
 blePeripheral.setLocalName("HeartRateSketch");
 blePeripheral.setAdvertisedServiceUuid(heartRateService.uuid()); // add the service UUID
 blePeripheral.addAttribute(heartRateService); // Add the BLE Heart Rate service
 blePeripheral.addAttribute(heartRateChar); // add the Heart Rate Measurement characteristic

 /* Now activate the BLE device. It will start continuously transmitting BLE
 advertising packets and will be visible to remote BLE central devices
 until it receives a new connection */
 blePeripheral.begin();
 Serial.println("Bluetooth device active, waiting for connections...");
/****************** END OF BLE HEARTRATE SETUP **************************/

 Serial.println("SETUP COMPLETE");
 
}

void loop() {
 switch(EXERCISE){
 case 1: 
 readAndReportAccelerometer();
 break;
 case 2:
 readAndReportGyroscope();
 break;
 case 3:
 monitorHeartRate();
 break;
 }
}

float pax, pay, paz, dax, dayy, daz;
void readAndReportAccelerometer(){
 int axRaw, ayRaw, azRaw; // raw accelerometer values
 float ax, ay, az;

 // read raw accelerometer measurements from device
 CurieIMU.readAccelerometer(axRaw, ayRaw, azRaw);

 // convert the raw accelerometer data to G's
 ax = convertRawAcceleration(axRaw);
 ay = convertRawAcceleration(ayRaw);
 az = convertRawAcceleration(azRaw);

 dax = abs(ax-pax);
 dayy = abs(ay-pay);
 daz = abs(az-paz);
 
 if(dax>0.02 || dayy>0.02 || daz>0.02){

 // display tab-separated accelerometer x/y/z values
 Serial.print("a:\t");
 Serial.print(ax);
 Serial.print("\t");
 Serial.print(ay);
 Serial.print("\t");
 Serial.print(az);
 Serial.println();

 pax = ax;
 pay = ay;
 paz = az;
 } 
}

float prev_gx, prev_gy, prev_gz, diff_gx, diff_gy, diff_gz;
float relevancyTrigger = 0.3;
void readAndReportGyroscope() {
 int gxRaw, gyRaw, gzRaw; // raw gyro values
 float gx, gy, gz;

 // read raw gyro measurements from device
 CurieIMU.readGyro(gxRaw, gyRaw, gzRaw);

 // convert the raw gyro data to degrees/second
 gx = convertRawGyro(gxRaw);
 gy = convertRawGyro(gyRaw);
 gz = convertRawGyro(gzRaw);

 diff_gx = abs(prev_gx-gx);
 diff_gy = abs(prev_gy-gy);
 diff_gz = abs(prev_gz-gz);

 if(diff_gx>relevancyTrigger || diff_gy>relevancyTrigger || diff_gz>relevancyTrigger){

 // display tab-separated gyro x/y/z values
 Serial.print("g: \t");
 Serial.print(gx);
 Serial.print("\t");
 Serial.print(gy);
 Serial.print("\t");
 Serial.print(gz);
 Serial.println( "");

 prev_gx = gx;
 prev_gy = gy;
 prev_gz = gz;
 }

}

void monitorHeartRate(){
 // listen for BLE peripherals to connect:
 BLECentral central = blePeripheral.central();

 // if a central is connected to peripheral:
 if (central) {
 Serial.print("Connected to central: ");
 // print the central's MAC address:
 Serial.println(central.address());
 // turn on the LED to indicate the connection:
 digitalWrite(13, HIGH);

 // check the heart rate measurement every 200ms
 // as long as the central is still connected:
 while (central.connected()) {
 long currentMillis = millis();
 // if 200ms have passed, check the heart rate measurement:
 if (currentMillis - previousMillis >= 200) {
 previousMillis = currentMillis;
 updateHeartRate();
 }
 }
 // when the central disconnects, turn off the LED:
 digitalWrite(13, LOW);
 Serial.print("Disconnected from central: ");
 Serial.println(central.address());
 }
}

void updateHeartRate() {
 /* Read the current voltage level on the A0 analog input pin.
 This is used here to simulate the heart rate's measurement.
 */
 int heartRateMeasurement = analogRead(A0);
 int heartRate = map(heartRateMeasurement, 0, 1023, 0, 100);
 if (heartRate != oldHeartRate) { // if the heart rate has changed
 Serial.print("Heart Rate is now: "); // print it
 Serial.println(heartRate);
 const unsigned char heartRateCharArray[2] = { 0, (char)heartRate };
 heartRateChar.setValue(heartRateCharArray, 2); // and update the heart rate measurement characteristic
 oldHeartRate = heartRate; // save the level for next comparison
 }
}

float convertRawAcceleration(int aRaw) {
 // since we are using 2G range
 // -2g maps to a raw value of -32768
 // +2g maps to a raw value of 32767
 
 float a = (aRaw * 2.0) / 32768.0;

 return a;
}

float convertRawGyro(int gRaw) {
 // since we are using 250 degrees/seconds range
 // -250 maps to a raw value of -32768
 // +250 maps to a raw value of 32767
 
 float g = (gRaw * 250.0) / 32768.0;

 return g;
}

 

EJERCICIOS #1 y 2 – ACELERÓMETRO Y GIROSCOPIO

En este ejercicio realizaremos lecturas del acelerómetro y del giroscopio y mostraremos el resultado en el monitor serial.

A su vez, implementamos una lógica de detección de cambios relevantes que nos permitirá observar con mayor claridad los cambios ocurridos en las medidas de los sensores.

PASO 1 – Cargue el programa del tutorial en su Arduino 101

PASO 2 – Utilizando la Figura 1 como guía, verifique en el Monitor Serial del IDE ARDUINO si los ejes mencionados son correctos para el acelerómetro (x,y,z)

PASO 3 – Modifique el programa, comentando la línea 32 para darle el valor de 2 a la variable EXERCISE.

ex02

PASO 4 – Cargue el programa modificado al Arduino 101 y verifique  los ejes de giro tal y como se ilustran en la Figura 1

PASO 5 – Preste atención a las líneas de la 110 a la 114; esta es la lógica de detección de cambios relevantes. Trate de explicarla.

110-114

PASO 6 – Ahora preste atención a las líneas de la 145 a la 149, es una implementación más limpia / autoexplicable de la lógica de detección de cambios relevantes. Trate de explicarla.

145-149

PASO 7 – Reto: Modifique la lógica de detección de  cambios relevantes para que detecte cualquier cambio.


EJERCICIO #3 – SIMULACION DE BLE HEARTBEAT SERVICE

En este ejercicio vamos a utilizar la comunicación Bluetooth/BLE para simular un mecanismo de detección de ritmo cardiaco y graficarlo en el celular.

Para esto necesitaremos un celular con capacidad BLE. En este descargaremos una aplicación llamada “nRF Toolbox” la cual hace una implementación de varios esquemas de servicio BLE. Utilizaremos entonces el servicio “HRM” (Heart Rate Monitor) para graficar datos provenientes del Arduino 101.

PASO 1 – Instale nRF Toolbox en su celular

PASO 2 – Re-configure el sketch base de este tutorial para ejecutar el ejercicio 3. En la línea 32 modifique la variable EXERCISE para que tenga un valor de 3.

arduino101_ex3

 

PASO 3 – Descargue el programa hacia la placa Arduino 101

PASO 4 – Abra el Monitor Serial (SHIFT + CTRL + M)

PASO 5 – En su celular, abra la aplicación “nRF Toolbox” y abra el servicio HRM. Allí pulse el botón “Connect” y elija “HeartRateSketch”

4 screens

PASO 6 – Observe cómo se grafican los datos

PASO 7 – Explicación

Esta simulación toma el valor de uno de los puertos analógicos del Arduino 101 (A0) y envia los datos a través de un servicio BLE estandard de tipo “Heart Rate Service”. Si se deja el pin A0 de la placa sin conexion, este tendrá valores “aleatorios” que serán graficados igual.

 


Recursos Adicionales

https://www.arduino.cc/en/Guide/Arduino101

http://www.intel.com/content/www/us/en/wearables/wearable-soc.html