Category Archives: Conceptos

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

 

IMG_20160315_120952~3

¿Cuándo creamos conocimiento?

15 Mar , 2016,
Jose Nunez
, ,
No Comments

Cuando aprendemos algo nuevo y lo podemos reproducir; lo que implica que lo hemos documentado; y lo hemos publicado/compartido con otros y ellos pueden reproducirlo también.

Crear conocimiento involucra la capacidad de mejorar algo existente.

admin_expr

El último punto funcional reproducible

14 Mar , 2016,
José Núñez
, ,
No Comments

admin_exprMucho del quehacer maker está relacionado con procesos de experimentación, de aprendizaje y con la creación de nuevo conocimiento.

Durante este tipo de procesos de experimentación “ad-hoc” es fácil caer en una parálisis en la cual “giramos en círculo” con partes de experimentos que a veces son éxitosas y a veces no, sin que podamos comprender la causa de estos resultados divirgentes; especialmente cuando no tenemos una forma estructurada de administrar las incertidumbres y los aciertos resultantes de nuestros experimentos.

Recientemente vivimos esto durante nuestra experimentación para grabar sonido usando Intel Edison, donde a ratos teníamos pruebas exitosas y a ratos “las mismas pruebas” fallaban.

Este tipo de parálisis puede resultarnos costosas, no solo a nivel de tiempo y recursos, sino también en lo referente a la motivación del equipo, al verse desvanecer los éxitos del trabajo sin una razón aparente.

Es por esto que compartimos en este artículo algunas medidas que nos permiten asegurar el éxito progresivo alcanzado en diversos experimentos y avanzar con un paso más seguro, evitando parálisis de análisis.

  1. Planee sus experimentos de manera individual y documente el plan
  2. Documente los pasos a realizar en cada experimento. Mantenga una política de “Un cambio a la vez”
  3. Documente los resultados obtenidos y las desviaciones del plan realizadas durante cada experimento
  4. Una vez obtenido el éxito en cada etapa, verifique la repetibilidad del éxito en cada experimento.
  5. Haga una revisión retrospectiva del plan de experimentación luego de terminar cada experimento.
  6. Una vez alcanzado un nivel de éxito aceptable en diversos experimentos, documente y publique los pasos para alcanzar dicho éxito.
  7. Verifique la reptibilidad antes de publicar sus resultados; y lleve seguimiento de cada “punto funcional reproducible

¿Y qué significa el término “punto funcional reproducible” (PFR)?

Básicamente es el conjunto de pasos que hemos verificado que funciona para llevarnos a una conclusión.

Llevar seguimiento de cada PFR significa ponerle un nombre, una identificación que nos permita referirnos a cada PFR y que nuestros nuevos procedimientos se basen en el PFR más reciente, donde se concentra el conocimiento acumulado más reciente.

En el ejemplo, terminamos documentando los pasos de un proceso de grabación con Intel Edison que pudimos constatar como repetibles; de forma que nuestros siguientes experimentos puedan tomar este PFR como su punto de partida.

metodo_cientifico

La cultura Maker es también una cultura de Investigación

28 Feb , 2016,
José Núñez
No Comments

Cuametodo_cientificondo se trata de cultura Maker, la investigación es esencial.

Y no me refiero a la “investigación” esa de simplemente googlear algo que necesitamos aprender.

Me refiero a la adquisición de conocimiento y su respectiva mejora y creación de nuevo conocimiento; a muchas horas practicando, aprendiendo, documentando y publicando.

Algo que hemos estado aprendiendo sobre la marcha de diversos proyectos y colegas; como es el caso de nuestros colegas de UNED-LiiT (http://investiga.uned.ac.cr/)

Wikipedia: Investigación

Wikipedia: Ciclo de la Investigación Científica

Wikipedia: Protocolo de Investigación

 

IMG_20160226_120519

Los grandes científicos tienen grandes publicaciones… los grandes “makers” también

26 Feb , 2016,
José Núñez
No Comments

Los grandes científicos tienen grandes publicaciones… los grandes “makers” también.

Ejemplos:

  1. Blogs
  2. Facebook Updates
  3. Tutroriales
  4. Instructables
  5. Evaluaciones de Productos/Dispositivos
  6. Publicaciones Formales en Revistas Científicas
  7. Libros

¡Recuerdenlo!

edison_serial

Guía de Publicación de Tutoriales/Proyectos

Feb , 2016,
José Núñez
No Comments

Para nosotros es muy importante la calidad en el material que publicamos. Queremos que los tutoriales o proyectos que se publiquen tengan un formato sencillo de leer, y que aporte valor a la tarea de seguirlos.

Seguidamente se explican las diferentes secciones de nuestros tutoriales.

1. Descripción

En esta sección describimos de qué se trata el tutorial, las tecnologías utilizadas y el objetivo o resultado esperado de ejecutar el tutorial y la duración esperada para el tutorial.

2. Referencias Externas

En esta sección listamos las referencias a documentacion en Internet que utilizamos para adquirir conocimientos sobre el tutorial.

3. Disclaimer sobre Intención y Responsabilidad

Aquí colocamos un enlace a nuestra página donde se explique que estas instrucciones se brindan de buena fe, sin ninguna garantía de funcionamiento; y que no asumimos responsabilidades (Salvo lo que indique la ley) sobre daños o perjucios realizados durante la ejecución del tutorial.

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

4. Resumen

Aquí escribmos un resumen de los pasos a seguir para la persona que ya tiene conocimento sobre cómo realizarlos. Cada paso debe ser de un párrafo máximo y sin mayores explicaciones gráficas.

5. Lista de Materiales

En esta sección especificamos los materiales recomendados y agregamos en la medida de lo posible, enlaces a tiendas en línea donde comprar los materiales.

6. Pasos Detallados

En esta sección describimos los pasos del proyecto y opcionalmente, la duración esperada de cada uno, se incluyen diagramas, imágenes y listas de comandos en detalle.

7. Agradecimientos

Aquí reconocemos (listamos) a las personas y organizaciones que hacen posible este tutorial.