Arduino 101 – Tutorial

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

 

[SOLUCIONADO] Intel Edison – Carga automática de sketch ARDUINO falla en versión 159 del firmware

A esta fecha (31-MAR-2016) nos topamos con la sorpresa de que al actualizar la versión del Firmware de Intel Edison a la #159.devkit (o simplemente 159) deja de funcionar adecuadamente la ejecución de sketches de Arduino al momento de reiniciar el dispositivo.

Todavía más sorprendente el hecho de que las nuevas tarjetas Intel Edison que compramos esta semana vienen con la versión 159 pre-instalada… y con el defecto.

Buscando resolver el problema, nos encontramos una entrada en el foro de Intel donde se explica una solución temporal, que consiste obtener los archivos de la versión 146 y copiarlos a la versión 159.

(!) Para facilitar el proceso hicimos una copia de los archivos en GITHUB. Seguidamente mostramos los pasos simplificados usando esta copia. 


PASO 1: Sobre-escribir los cuatro archivos contenidos en /opt/edison/ con los de la versión anterior (146) o usando los archivos en github

Para descargar los archivos al Edison se pueden usar varios métodos, uno es mediante un cliente SCP/SFTP como WinSCP; otro sería utilizando el comando wget desde el Edison si este está conectado a la Internet via WiFi así:

rm /opt/edison/* -rf

wget -O /opt/edison/clloader https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/clloader?raw=true

wget -O /opt/edison/launcher.sh https://raw.githubusercontent.com/janunezc/edison_workshop/master/159_fix/edison/launcher.sh

wget -O /opt/edison/sketch_reset https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/sketch_reset?raw=true

wget -O /opt/edison/sketch_reset.sh https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/sketch_reset.sh

PASO 2: Darle permiso de ejecución a los programas necesarios con el comando

  • chmod +x /opt/edison/clloader
  • chmod +x /opt/edison/launcher.sh
  • chmod +x /opt/edison/sketch_reset
  • chmod +x /opt/edison/sketch_reset.sh

PASO 3: Ejecutar los comandos de configuración para la auto-carga de sketches de Arduino

  • cd /opt/edison
  • systemctl enable clloader
  • systemctl start clloader

PASO 4: Rebootear de manera segura el Edison con el comando shutdown now


PASO 5: Cargar un sketch de Arduino en el Edison (por ejemplo Blink) y rebootearlo de manera segura con el comando reboot now.


PASO 6: Verifique que el sketch carga luego de apagar completamente el Edison y volverlo a encender.


FIN

Comunicación Inalámbrica usando dos NRF24L01 de bajo costo

Descripción

En este tutorial utilizaremos la librería denominada “RF24 by TMRh20” v.1.1.6 para ARDUINO IDE para comunicar dos dispositivos NRF24, uno como transmisor y otro como receptor, conectados a placas ARDUINO UNO y INTEL EDISON respectivamente.

Vamos a monitorear el resultado mediante los puertos seriales respectivos.

NIVEL INTERMEDIO

Referencias Externas

Un agradecimiento especial a terry@yourduino.com por su tutorial sobre los diferentes tipos de conexion para las multiples librerias disponibles para el NRF24.

Materiales

(*) Opcionalmente el Edison se puede reemplazar con otra tarjeta ARDUINO UNO

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

Pre-requisitos

  1. Realice la configuración previa del Intel Edison (controladores, firmware, software en general) para su PC. Existen varios tutoriales para esto. Por ejemplo este.
  2. Instale el IDE de ARDUINO de https://www.arduino.cc/en/Main/Software
  3. Instale la librería “RF24 by TMRh20” en el ARDUINO IDE (Menu: Sketch > Include Library > Manage Libraries > [Install] )

rf24 manage libraries

Figura 1 – Librería RF24 by TMRh20

 

Pasos Resumidos

  1. Conecte los módulos nRF24 a las placas EDISON y ARDUINO tal y como se describe en la figura 2 abajo.
  2. Abra el ejemplo “RF24 > Getting Started” y programe con él su tarjeta ARDUINO (transmisor)
  3. Modifique el programa de ejemplo para que la variable “radioNumber” tenga un valor de 1 (ver figura 5) y programe su tarjeta EDISON (receptor) con este programa modificado.
  4. Monitoree el transmisor usando una conexion serial (Serial Monitor del ARDUINO IDE o PuTTY a 115200 baudios) y presione la tecla “T”

Procedimiento Detallado

PASO 1 –  CONEXIONES

La siguiente imagen ilustra las conexiones desde los pines del NRF24 a las placas ARDUINO o EDISON.

nrf24 pin connections

Figura 2 – Conexiones


PASO 2 – PROGRAMANDO EL TRANSMISOR

Abra el ejemplo de la librería “RF24 by TMRh20” denominado “Getting Started” (Menu: File > Examples > RF24 > Getting Started)

La variable “radio Number” definida en la línea 14 determina el modo de operación, en este caso debe ser 0 (tal y como viene predeterminada) para el transmisor.

radionumber_0

Figura 3 – Variable Radio Number para Transmisor

Cargue el programa en su tarjeta ARDUINO.

El monitor serial del IDE de arduino debe estar configurado para operar a 115200 baudios (ver figura 4).

(!) En este punto la tarjeta ARDUINO estará lista para transmitir; esperando que se conecte un receptor a la red. Puede apagar el ARDUINO por el momento.

115200

Figura 4 – Configuración de la pantalla de monitor serial


PASO 3 – PROGRAMANDO EL RECEPTOR

Utilizando el mismo programa, modifique el valor de la variable “radioNumber” para que sea igual a 1 (ver figura 5) y programe su tarjeta EDISON con esta nueva versión del programa.

radionumber_1

Figura 5 – radioNumber = 1

(!) En este punto la tarjeta EDISON estará lista para recibir datos, esperando mensajes del transmisor. Al abrir el monitor serial (SHIFT + CTRL + M) no se observará ninguna reacción. Recuerde asegurarse de que la velocidad del monitor sea 115200 baudios.


PASO 4 – PRUEBAS FINALES

Encienda el ARDUINO UNO (transmisor) conectándolo a su computador y abra el monitor serial. Verá una imagen similar a la figura 4.

Encienda el EDISON (receptor) conectándolo a la fuente de poder y al computador. Abra una terminal “PuTTY” para ver el monitoreo serial del EDISON. Recuerde la usar el puerto “Intel Virtual COM Port (COM??)” a una velocidad de 115200  como se ilusrta en la figura 6.

PuTTY_VirtualCOMPort

Figura 6 – Configurando PuTTY para monitorear el EDISON

Vaya al Monitor Serial del ARDUINO IDE y presione la tecla T

En este momento veremos como se comunican los dos equipos de manera inalámbrica como se ilustra en la figura 7.

Test_Sending_Receiving

Figura 7 – Monitoreando Transmisor y Receptor

(!) Nótese que aquí utilizamos los términos TRANSMISOR para el ARDUINO UNO y RECEPTOR para el EDISON con cierta ligereza. Ambos dispositivos transmiten y reciben en distintos momentos. El ARDUINO UNO envia datos al EDISON, el cual los envia de vuelta al ARDUINO UNO.

Intel Edison – Cómo Grabar Sonido usando un adaptador USB

Descripción

Una de las capacidades de Intel Edison que me resultan más intersantes es la capacidad de manejar dispositivos USB compatibles con LINUX, incluyendo adaptadores para grabar y ejecutar Audio.

Este pequeño proyecto nos permitirá adentrarnos en esta capacidad. Vamos a conectar un adaptador de audio USB al Edison, y vamos a grabar sonido.

Fuente: Intel’s Edison Audio Setup Guide

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


En resumen:

  1. Se conecta el dispositivo de Audio al puerto USB colocando el switch de selección USB en posición “up”
  2. Se conecta el Edison a la laptop mediante el puerto serial para usar la terminal LINUX con software como putty (windows) o screen (linux)
  3. Se obtiene una lista de dispositivos de audio USB para determinar el numero de dispositivo a utilizar.
    • cat /proc/asound/pcm
  4. Se listan los puertos de audio disponibles para determinar el puerto de salida (out) y de entrada (mic).
    • pactl list | grep Name | grep usb
  5. Se configura los puertos predeterminados (sink y source)
    • pactl set-default-sink {output-device-name}
    • pactl set-default-source {input-device-name}
  6. Se ejecuta el comando arecord con los parámetros correspondientes para el adaptador en uso.
    • arecord -f cd -c 1 -d 10 -r 44100 -D hw:2,0 soundfile.wav
  7. La grabación es almacenada en un archivo soundfile.wav

Lista Recomendada de Materiales:


PASO #1 – Conectar el Edison

Para este proyecto necesitaremos conectar el Edison a un computador por medio del puerto serial USB. Esto para poder manipular la terminal linux del Edison. El purto USB Serial es el que se ubica en la parte inferior derecha. Se puede usar putty (en el caso de Windows) o screen (en el caso de Linux) para acceder a dicha terminal. En el Administrador de Dispositivos de Windows, el puerto aparece bajo el nombre “Ports (COM & LPT) > USB Serial COM Port (COMxx)


PASO #2 – Conectar el Adaptador de Audio USB edison_usb

Este proyecto se ha probado en diversos adaptadores de audio (Plantronics*, Pluggable*, SYBA*)

Se conecta el adaptador de audio USB al puerto USB principal del Edison. Nótese que el switch de selección de modo USB debe estar en posición “up” para activar el puerto USB. Esto desactiva el puerto dedicado a recibir los Sketch de ARDUINO.


PASO #3 – Listar los Dispositivos

Una vez conectado al Edison, el sistema operativo reconoce el dispositivo de audio USB. Se puede listar los dispositivos de audio conectados al Edison usando el siguiente comando. Puede ejecutarlo con el dispositivo de audio conectado y desconectado para ver la diferencia de resultado. Anote el número de dispositivo.

cat /proc/asound/pcm

cat_proc_asound_pcm


PASO #4 – Listar los Puertos de Audio

Seguidamente necesitaremos anotar el nombre de los puertos de audio, utilizando el siguiente comando.

pactl list | grep Name | grep usb

pactl_list_grep


PASO #5 – Configurar Los Dispositivo de entrada y salida de audio

Utilice los siguientes comandos para configurar los dispositivos predeterminados de entrada y de salida de audio.

pactl set-default-source {input-device-name}

pactl set-default-sink {output-device-name}

edison_set_default_audio

 


PASO #6 – EJECUTE ARECORD

El siguiente comando se usa para grabar audio del dispositivo 2,0 que anotamos en el paso #3 a un archivo “soundfile.wav”

Puede necesitar opciones diferentes de arecord dependiendo de su dispositivo de audio USB. Las opciones disponibles pueden encontrarse en este enlace.

En este ejemplo, estamos grabando 10 segundos de audio (-d 10) a un “rate” de 44100, para un dispositivo 2,0 (-D hw:2,0)

arecord -f cd -c 1 -d 10 -r 44100 -D hw:2,0 soundfile.wav


Disclaimer:

(*) Este artículo cita marcas registradas que son propiedad de sus respectivos dueños

Al momento de escribir este artículo, el autor fungía como empleado de Intel Corp

Este artículo se brinda “tal cual” y de buena fe como un método para compartir conocimientos. No se brinda garantía de funcionamiento de ningún tipo; no asumimos responsabilidad por daños o pérdidas causados al seguir estas instrucciones; salvo lo que indique la ley aplicable.

 

Un Agradecimiento especial para nuestros amigos del Laboratorio de Investigación e Innovación Tecnológics (LIIT) de UNED, con quienes hemos trabajado largas horas explorando estas tecnologías.

Comenzando con Intel Edison en UBUNTU

Descripción2112-00

Este procedimiento describe a groso modo cómo comenzar a utilizar la placa Intel Edison con tarjeta de expansión ARDUINO, programándola desde una Laptop  que corra UBUNTU LINUX.


Procedimiento

PASO 1 – Descargar el programa aquí
Descomprimir el archivo e instalar el script install_GUI.sh por medio de la terminal de Ubuntu. También instalar Intel Phone Flash Tool Lite, que viene incluido a la hora de instalar el programa (en el directorio del programa)

sudo ./install_GUI.sh

sudoinstalsh


PASO 2 – Conectar la placa Intel Edison mediante una conexion serial (Ej: usb). en este caso se utilizará la conexión que permite el uso de arduino, además de la placa conectada a una fuente de corriente. Se debe considerar: la pc en la mayoria de los casos no brinda suficiente corriente para alimentar la placa por lo que es mejor conectarlo a una fuente de energia estable.
Igualmente las conexiones que se utilizan para conectar al USB de la PC, la placa edison, son las conexiones micro USB, el mini switch en la placa debe seńalar hacia los puertos micro USB. estos puertos en la placa serán representados como a) y b) ya que tienen funciones diferentes. En todo caso se pueden conectar ambos micro usb simultaneamente a la PC.
a) A la hora de conectar cada micro USB se nota la diferencia en que uno, al conectarlo a la pc, aparecera como un dispositivo removible en esta, esta conexion sirve para subir funciones desde el programa de arduinos
b) En la otra conexion micro USB al conectarse a la PC no aparecera como un dispositivo removible, esta conexión es la que sirve para trabajar en la placa desde la terminal de Ubuntu.

  1. Para este paso se necesita screen shell en ubuntu en caso de no tenerlo utilizar el siguiente comando en la terminal
sudo apt-get install screen

Conectar el Edison desde la conexion micro usb b) (ver punto 2)
Para conectar la placa ingresar el siguiente comando (donde ttyUSB0 es el dispositivo)

sudo screen /dev/ttyUSB0 115200

Después de escribir este comando darle Enter, en algunas ocasiones se le debe dar enter 2 veces.
La terminal nos pedirá un login aqui, escribir ¨root¨ (sin comillas)
Se solicitará la contraseńa del sistema. Ingresarla y darle Enter
Debe quedar un mensaje similar a este:

terminal


PASO 3 –  Conectar la placa Intel Edison a internet mediante WI-FI utilizando el comando:

configure_edison --wifi

En caso de que ocurra el error en el que no se encuentra la Placa Edison (configure_edison: not found) se debe utilizar la aplicacion Intel Phone Flash Tool para preparar el dispositivo.     Aceptar y darle enter para continuar. Aparecera una lista con las conexiones WI-FI disponibles, cada una con un numero, el cual debemos ingresar para elegir la conexion a la cual se quiere accesar, ingresar los credenciales de la red. Aparecerá el mensaje ¨done¨ . La placa ya esta conectada a internet y se puede observar que aparece la dirección IP de esta en la terminal, se puede comprobar la conexión mediante el comando ¨ping¨ en la terminal.


PASO 4 – Completar el setup de la aplicación descargada para que se instalen los programas, se instalará el programa arduino e Intel Phone Flash Tool Lite.
En este caso se utilizó, como se dijo anteriormente el lenguaje Arduino como IDE en la aplicación instalada. Esta aplicación se corre como administrador mediante el comando:

sudo arduino

En este caso, se debe conectar al puerto micro USB a) para subir funciones a la placa


Notas *Recordar ejecutar el programa como administrador a la hora de abrirlo, de lo contrario el acceso será denegado

**Fijarse que el puerto seleccionado en la aplicación sea el adecuado, es decir que concuerde con el que se esta utilizando en la conexion serial y utilizar el correcto Addon para cada dispositivo que se este utilizando. En la aplicación donde dice ¨tools¨ revisar: Port que esté seleccionado el que se esta utilizando y Board que se esté utilizando el que concuerde con el dispositivo (En el caso del Edison, ya viene en la aplicación se selecciona Edison)

***Esta es una versión en espańol para comenzar a utilizar la placa Intel Edison. La versión original (en inglés) puede encontrarse en la siguiente dirección: https://software.intel.com/en-us/get-started-edison-linux-step1