Recent Posts

Comandos por BLE – (Parte 2 de 2) – El Transmisor (TX)

22 Jul , 2017,
Jose Nunez
, , , , , ,
No Comments

Como lo prometido es deuda, acá está la 2da entrega referente a controlar cosas con telefonos celulares mediante Bluetooth Low Energy (BLE) usando IONIC 3.

En esta segunda parte, implementaremos una App (Android y IOS) usando IONIC 3 que le envía comandos al micro-controlador mediante el sistema BLE del teléfono.

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

Programando el App

En resumen:

  1. IONIC 3 es un sistema para crear aplicaciones móviles usando tecnologías híbridas (cordova, angularjs 4, typescript, html, css, etc.)
  2. Necesitaremos configurar IONIC3 en nuestro computador; esto incluye NodeJS, NVM, NPM y IONIC.
  3. También necesitaremos un muy buen editor de código para TypeScript. Puedo recomendarles Visual Studio Code o Atom.
  4. Descargamos el código del app de ejemplo de mi repositorio de Github y lo abrimos con el IDE de ARDUINO.git clone https://github.com/janunezc/robotics.gitEl código se ubica en ~/robotics/intel_curie/ble_command_app/
  5. En el celular podemos utilizar el sistema Ionic View (descargado del App Store o Google Play) y previsualizar el app 03B50F88Las siguientes imágenes muestran la operación del app

 

Seguidamente mostramos las partes más importantes del código original del programa con los comentarios detallados sobre su funcionamiento. Es realmente sencillo; podemos resumirlo en:

  1. El tab “SCAN” implementa un proceso básico de búsqueda de dispositivos Bluetooth. No vamos a detallar mucho en este tutorial sobre ese tab.
  2. El tab “LED” implementa la búsqueda de un dispositivo específico y una vez que lo encuentra permite interactuar con el LED para encenderlo y apagarlo.
    1. Los componentes (tabs) de la aplicación IONIC3 se dividen en 3 elementos principales: una vista o view (led.html), un controlador (led.ts) y un modelo que corresponde a los datos que va a manejar la aplicación y que se ubican en el objeto this y sus propiedades públicas.
    2. El archivo led.html es realmente simple. Aparte de los párrafos de texto expicativo y títulos, posee un botón que tiene algunas características importantes de AngularJS como lo son el atributo [disabled] ligado a una variable del modelo denominada “ejecutandoComando”. Cuando la variable tiene un valor verdadero (true) el atributo disabled se activa y el botón se deshabilita. A su vez tiene una directiva (click) que ejecuta la función “Command()” del controlador.
    3. Una parte importante del archivo led.html es el último párrafo en la línea 11. Este utiliza una directiva *ngFor para iterar sobre la variable “messages” y mostrar cada mensaje como un párrafo ( <p> ) individual. Esto nos permite mostrar mensajes de aclaración conforme se ejecutan los procesos en el controlador.
  3. Exploremos ahora el archivo led.ts. Se trata de un script escrito en TypeScript. Un pseudo-lenguaje basado en JavaScript que permite una orientación a objetos más elaborada.
    1. Lo primero que se realiza en led.ts es importar las librerías necesarias. Dos de las más notorias serán BLE y ApplicationRef. La primera permite comunicación BLE, y la segunda permite manipular el framework de Angular para refrescar la pantalla cuando sea necesario.
    2. La siguiente parte super importante es el constructor, el cual implementa una serie de inyecciones de dependencia que vale la pena mencionar.
    3. Nótese la forma en que se inyectan en el constructor tanto la librería BLE como la librería de Angular ApplicationRef. En el constructor también se inicializan variables importantes tales como el ID de servicio y el ID de Característica que se van a manipular.
    4. Las funciones más interesantes en este archivo son:
      1. findDevice() que busca un dispositivo particular y una vez que lo encuentra cambia el modo de comandos para encender o apagar un LED. Para esto usa la funcion de BLE nativo denominada ble.scan()
      2. txData() que utiliza ble.connect y ble.write para conectarse al dispositivo y hacerle llegar un mensaje.
      3. SetMessage() tambien merece ser mecionado como la forma que tenemos de agregar mensajes de control que nos permitan entender cómo se está ejectuando el programa.

Espero que este artículo les sea de utilidad junto con el anterior para aprender a enviar comandos a un dispositivo BLE basado en Intel Curie, mediante el teléfono celular.

Los dejo con estos enlaces de utilidad:

  1. Aprender TypeScript: https://www.typescriptlang.org/docs/home.html
  2. Aprender Ionic 3: https://ionicframework.com/
  3. Aprender Angular 4: https://www.youtube.com/watch?v=kFTmoLm9Jwg

Que estén bien!


led.html

<ion-header>
   <ion-navbar>
   <ion-title>LED</ion-title>
   <p>Acá podemos operar el LED que está implementado en TinyTILE</p>
   <button ion-button [disabled]="ejecutandoComando" (click)="Command()">{{ComandoTXT}}</button>
</ion-navbar>
</ion-header>
<ion-content padding>
   <p>Histórico de Ejecución: ({{myCount}} | {{test}})</p>
   <hr />
   <p *ngFor="let message of messages">{{message}}</p>
</ion-content>

led.ts

import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';
import { BLE } from '@ionic-native/ble';
import { ApplicationRef } from '@angular/core';

@Component({
  selector: 'page-led',
  templateUrl: 'led.html'
})

export class LEDPage {

  public messages = []; //Histórico de ejecución
  public ejecutandoComando = false;
  public BLE;
  public ComandoTXT = "";
  public Value = "";
  public TargetDevice;
  private appRef;

  /**
   * CONSTANTES que serán usadas a lo largo del controlador
   */
  public constants  = {
      DEVICE_NAME: "COMANDO LED",
      CMD_FIND_DEVICE:"FIND DEVICE",
      CMD_STOP_SCAN:"Escaneando... (Clic para parar)",
      CMD_TOGGLE_LED:"CAMBIAR LED",
      ON:"ON",
      OFF:"OFF"
    };

  /**
   * Constructor para el controlador. Todo comienza acá...
   */
  constructor(public navCtrl: NavController, private ble: BLE /*Librería BLE nativa*/, private applicationRef : ApplicationRef /*Librería ApplicationRef de Angular*/ ) {
    this.appRef = applicationRef; //Referencia a la aplicación ANGULAR
    this.SetMessage("Constructor: Iniciado!");
    this.BLE = ble; //Acceso a la librería BLE Nativa
    this.ComandoTXT = this.constants.CMD_FIND_DEVICE;
    this.Value = "ON"; //VALOR PARA ENVIAR
    this.TargetDevice = {}; //Dispositivo al cual conectarse. Inicialmente vacío... se llenará cuando se encuentre el dispositivo en el escaneo.
    this['service_id'] = "db938b80-f010-44b6-8aa9-1835adf9419a"; //Identificador del servicio BLE a conectarse
    this['characteristic_id'] = "9906064e-9bbe-4eba-b415-bbd223f7d3d9"; //Identificador de la característica BLE a conectarse
    this.SetMessage("Constructor: Finalizado!");
  }

  /**
   * This is triggered when the button is clicked.
   */
  public Command(){
    this.ejecutandoComando = true;
    this.SetMessage("Command() - Comando recibido!");
    this.SetMessage(this["ComandoTXT"]);
    this.SetMessage("Interpretando comando...");

    if(this['ComandoTXT']===this.constants.CMD_FIND_DEVICE) {
      this.SetMessage("Ejecutando Comando: FIND DEVICE");
      this['ComandoTXT'] = this.constants.CMD_STOP_SCAN;
      this.findDevice();

    } else if (this['ComandoTXT']===this.constants.CMD_STOP_SCAN) {
      this.SetMessage("Ejecutando Comando: STOP SCAN");
      clearInterval(this['intervalHandle']);
      this['ComandoTXT'] = this.constants.CMD_FIND_DEVICE;
      this.ejecutandoComando = false;

    } else if(this['ComandoTXT']=== this.constants.CMD_TOGGLE_LED){
      this.SetMessage("Ejecutando Comando: TOGGLE LED: " + this.Value);
      this.SetMessage("Acá es donde enviamos un valor al dispositivo BLE");
      this.txData();
    }
  }

  /**
   * This searches for DEVICE in the AIR using SCAN technique.
   */
  private findDevice(){
      this.SetMessage("FindDevice() - INICIO!");
      let  ble = this.BLE;

      this.SetMessage("FindDevice() - ENABLE!");
      ble.enable();

      this.SetMessage("FindDevice() - SET INTERVAL!");
      this['intervalHandle'] = setInterval(() => { // PROGRAMAR UN TIMER DE 2.1 SEGUNDOS
        this.SetMessage("INTERVAL: INICIO! LLAMANDO A BLE SCAN...");
        ble.scan([], 2 /*seconds (0) */).subscribe( data => { //REALIZAR SCAN BLE POR 2 SEGUNDOS
          this.SetMessage("BLE SCAN CALLBACK: " + data['id'] + ' | ' + data['name'] + ' | ' + data['rssi']);
          if(data['name']==this.constants.DEVICE_NAME){
            this.SetMessage(this.constants.DEVICE_NAME + " HA SIDO ENCONTRADO!!");
            clearInterval(this["intervalHandle"]);
            this.TargetDevice = data;
            this["ComandoTXT"] = this.constants.CMD_TOGGLE_LED;
            this.ejecutandoComando = false;
          }
          this.appRef.tick();
        });
      },2100);//FIN DE LA DEFINICIÓN DEL TIMER
      this.ejecutandoComando = false;
    }

  /**
   * Transmitir datos al dispositivo BLE
   */
  private txData(){
    this.SetMessage("txData(): INICIO! Llamando a BLE CONNECT...");

    let id = this.TargetDevice.id;
    this.SetMessage("ID DE DISPOSITIVO: " + id);

    this.ble.connect(id).subscribe(datos=>{
      this.SetMessage("BLE CONNECT CALLBACK: INICIO!. Llamando a BLE WRITE..." + this.Value);

      this.ble.write(this.TargetDevice.id, this['service_id'],this['characteristic_id'], this.StringToBytes(this.Value) ).then(()=>{
        this.SetMessage("BLE WRITE CALLBACK: INICIO! Cambiando valor... " + this.Value);
        if(this.Value==this.constants.ON){
          this.Value = this.constants.OFF;
        } else {
          this.Value = this.constants.ON;
        }
        this.SetMessage("Nuevo valor... " + this.Value);

        this.SetMessage("Llamando a BLE DISCONNECT...");
        this.ble.disconnect(id);
        this.ejecutandoComando = false;
        this.appRef.tick();
      },(error)=>{
        this.SetMessage("BLE Write ERROR!");
        this.SetMessage(error);
        this.SetMessage("Llamando a BLE DISCONNECT...");
        this.ble.disconnect(id);
        this.ejecutandoComando = false;
        this.appRef.tick();
      });
    },error=>{
      this.SetMessage("BLE Connect ERROR!");
      this.SetMessage(error.message);
      this.ejecutandoComando = false;
      this.appRef.tick();
    });
  }

  /**
   * Agrega mensajes de ejecución al histórico
   */
  public SetMessage(message){
    var count = this['messages'].length;
    message = count + ':' + message;
    this['messages'].unshift(message);

    /*
      ESTA LINEA ES IMPORTANTE PARA REFRESCAR LA PANTALLA CUANDO SE GENERAN EVENTOS
      FUERA DEL CONTROL DE ANGULAR. POR EJEMPLO CUANDO SE LLAMA A UN CALLBACK EN
      UN PROCESO DE BLE SCAN.
    */
    this.appRef.tick();
  }

  // ASCII only. Convierte el valor a escribir a un arreglo de BYTES
  public StringToBytes(string) {
     let array = new Uint8Array(string.length);
     for (let i = 0, l = string.length; i < l; i++) {
         array[i] = string.charCodeAt(i);
      }
      return array.buffer;
  }

  // ASCII only
  public BytesToString(buffer) {
      return String.fromCharCode.apply(null, new Uint8Array(buffer));
  }
}

Repetier Software para Printrbot Simple Metal

Jul , 2017,
Luis Diego Jimenez Sanchez
, , ,
No Comments

Que es Repetier?

Repetier es un software de impresion 3D gratuito que incluye algunos motores de slicing como Cura, Slic3r y Skeinforge.  Hasta el momento, llevo un mes usando Repetier para impresiones y me ha gustado bastante mas que Cura por los siguientes motivos:

Primer motivo: tengo control de la temperatura del extrusor en tiempo real durante la impresion.  En una impresión que estaba realizando de prueba, era una estructura tipo domo, a medida que la estructura iba avanzando hacia arriba, la impresión estaba saliendo “lagrimosa” o derretida y esto causaba que las paredes no se solidificaban bien.  Con Repetier, hicimos una disminución en tiempo real de la temperatura del extrusor de 210C a 204C y esto termino de solucionar el problema.

Segundo motivo: también se pueden controlar otros parametros como el abanico y temperatura de cama caliente.

Tercer motivo: cuando se esta imprimiendo, la interfaz de Repetier demuestra el tiempo que falta para terminar la impresión.

Finalmente, se permite programar diferentes scripts de codigo G, ya sea al inicio de la impresón o al final, una cuestión que permite personalizar cada impresion.  Hay un par de aspectos que aun me faltan explorar, como vigilar impresiones mediante el celular o establecer un host wifi con un raspberry pi por ejemplo.

Instalar Repetier y configuracion para Printrbot Simple Metal.

Repetier Host se puede descargar en el siguiente enlace.

Download now

El ajuste de los parametros que se establece en este artículo es para la versión de Repetier Host V2.0.1.

Una vez que se tenga, se puede configurar para muchas impresoras 3D, en este caso se muestra a continuación los parametros que hay que configurar para usar la Printrbot Simple Metal.

  1. Pagina de Inicio de Repetier.

La primera vez que se abra Repetier Host, se va ensenar la pantalla anterior.  El primer ajuste que se hará es donde dice “Printer Settings” en el lado derecho superior.  Se abre lo siguiente y se debe ajustar los parametros de acuerdo a las imagenes.  Conforme se vaya avanzando en el uso del software, se puede ir ajustando los parametros segun el criterio de cada uno.

2. Connection Settings (Ajustes de Conexion)

Aqui los primeros parametros que se ajustarán son los de la conexión de la impresora a la computadora.  El puerto puede variar segun la computadora.

3. Printer Settings. (Ajustes de Impresora)

Como se ha mencionado anteriormente, muchos de estos ajustes son recomendaciones generales para la Printrbot Simple Metal, pero segun la impresión y el criterio de la persona, se pueden cambiar.

4. Extruder Settings. (Ajustes de extrusor)

5. Printer Shape Settings. (Ajustes de tamano de impresora)

Después de los ajustes de la impresora, se sigue con los ajustes de configuración del Slicer, Cura en este caso.

6. Slicer Configuration.

7. Slicer Configuration. Parte 2: Perfiles de Impresión.

En la parte baja de la imagen en el paso 6 se llega al ajuste del paso 7, en esta instancia se pueden poner valores de las impresiones para la calidad de la impresión.

8.  Slicer Configuration. Parte 3: Perfiles de Estructura

9. Slicer Configuration. Parte 3: Perfiles de Estructura contd. 

10. Slicer Configuration. Parte 3: Perfiles de Estructura contd.

Una vez que se hayan hecho los ajustes anteriores, le daremos al software los scripts de inicio y fin de la impresion.  Destaco que los siguientes scripts fueron hechos por un amigo y fanatico de la impresion 3D, Luis Diego Maroto.  A continuación los scripts y como insertarlos en el software.

En la imagen del paso 6, hay un tab bajo Slicer Configuration que se llama G Codes.  Esta sección es donde se pueden personalizar lineas de código G para que a la hora de iniciar o terminar la impresión se haga algo según el usuario.  Para el caso de Start G Codes, se inserta el siguiente código de la manera como se observa en la imagen.

; Codigo de inicio de impresión
;
M107 ; Apagar el abanico del hotend.
M109 T0 S180; Precalentar el hotend hasta 180C.
G28 X0 Y0; Mover el hotend a XY Home.
G28 Z0; Mover el hotend a Z Home.

; G1 Z15 F{Z_TRAVEL_SPEED}
G90 ; Absolute positioning
M82 ; Extruder in absolute mode
G92 E0 ; Reset extruder position

G29; Calibrar la cama

; Wait for all used extruders to reach temperature

{IF_EXT0}M109 T0 S{TEMP0}

De la misma manera se inserta el codigo para la End G-Code.


; Default end code
G1 X0 Y0 ; Get extruder out of way. Uncomment to use!
M107 ; Turn off fan
; Disable all extruder
G91 ; Relative positioning
{IF_EXT0}T0
{IF_EXT0}G1 E-1 ; Reduce filament pressure
M104 T0 S0
G90 ; Absolute positioning
G92 E0 ; Reset extruder position
;M140 S0 ; Disable heated bed
M84 ; Turn steppers off

Para entender o personalizar scripts de G Code para las impresiones, se puede referenciar al siguiente enlace donde se encuentran comandos y significados de este lenguaje.

http://reprap.org/wiki/G-code/es

Hasta aqui es sólo el inicio de muchas posibilidades de configuraciones en Repetier. Esperamos que les haya sido de utilidad.

 

 

 

Comandos por BLE – (Parte 1 de 2) – El Receptor

21 Jul , 2017,
Jose Nunez
, ,
No Comments

Para continuar la exploración de la tecnología BLE que comenzó nuestra compañera Rebeca Rodriguez Tencio acá, les presentamos este primer tutorial de dos relacionados. La idea es poder implementar una forma de enviar comandos a una tarjeta de prototipado via Bluetooth Low Energy (BLE) desde una App de un teléfono Móvil.

En esta primera parte implementaremos un servicio “Comando LED” en un microcontrolador compatible con Arduino 101 llamado TinyTILE (basado en el chip Curie de Intel)

En la segunda parte, implementaremos una App (Android y IOS) usando IONIC 3 que le envía comandos al micro-controlador mediante el sistema BLE del teléfono.

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

Primero: Programemos el Curie

En resumen:

  1. Necesitaremos un protoboard, un LED, una resistencia de 150 Ohm, un TinyTILE y un cable USB a micro-USB y una PC
  2. El circuito es muy sencillo:


  3. En la PC instalamos los controladores de placa “Arduino/Genuino 101” en el IDE de ARDUINO (V.1.8.2)
    • Menu: Tools >  Board > Board Manager > Search “Curie” > Instalar V 2.0.2 o superior.
  4. Descargamos el programa (sketch) de ejemplo de mi repositorio de Github y lo abrimos con el IDE de ARDUINO.
  5. Instalamos el boceto de ejemplo en la placa
    • Menu: Sketch > Upload
  6. Usamos una app para pruebas BLE denominada “BLE Scanner” para enviar comandos “ON” y “OFF”
  7. Nótese que hemos implementado una función “parpadear” que nos permite ver si el sketch arrancó adecuadamente.

Las siguientes imágenes ilustran el uso de BLE Scanner para enviar los comandos.

Seguidamente mostramos el código original del programa con los comentarios detallados sobre su funcionamiento. Es realmente sencillo; podemos resumirlo en:

  1. Definir un servicio BLE “ServicioBLE_Comando” (línea 5)
  2. Deinir una característica BLE “CaracteristiciaBLE_Comando” de tipo genérica, de lectura y escritura con mensajes de 20 bytes (línea 8)
  3. Darle un nombre al dispositivo “COMANDO LED” e inicializarlo, agregando el servicio y la característica (línea 19)
  4. Publicitamos el servicio (línea 23)
  5. Leemos eventos BLE en la característica (nuevos comandos) que luego son interpretados y ejecutados (líneas 31,33,57,61)
  6. Para esto convertimos el valor recibido a un String (línea 63)

 


#include <CurieBLE.h>
#define ledPin 13

//Definimos un servicio BLE
BLEService servicioBLE_Comandos("db938b80-f010-44b6-8aa9-1835adf9419a"); // create service

//Definimos una característica que pueda ser leida o escrita desde una central BLE, con capacidad de 20 bytes por mensaje.
BLECharacteristic caracteristicaBLE_Comandos("9906064e-9bbe-4eba-b415-bbd223f7d3d9", BLERead | BLEWrite, 20);

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT); 
  delay(500); //Esperamos un poco de tiempo (500ms) por si se puede habilitar la terminal serial.
  parpadear(5,200);//Señalizamos con el LED que estamos iniciando el sketch
  
  BLE.begin(); //Inicializamos el sistema Bluetooth Low Energy (BLE) del Curie
  parpadear(2 ,100);//Señal de aviso de que la operación anterior fue exitosa
  
  BLE.setLocalName("COMANDO LED"); //Definimos un nombre para publicitar nuestro dispositivo
  BLE.setAdvertisedService(servicioBLE_Comandos);//Definimos el servicio que se va a publicitar
  servicioBLE_Comandos.addCharacteristic(caracteristicaBLE_Comandos); //Agregamos la característica al servicio
  BLE.addService(servicioBLE_Comandos); //Agregamos el servicio al dispositivo  
  BLE.advertise(); // Publicitamos el dispositivo
  parpadear(3 ,100);//Señal de aviso de que la operación anterior fue exitosa

  Serial.println("En este punto el dispositivo queda listo, publicitado y esperando conexiones...");
  parpadear(10,50);//Señal de aviso de que SETUP se concluyó satisfactoriamente
}

void loop() {
  BLE.poll(); // Obtenemos cualquier evento BLE que haya sido enviado al dispositivo

  if (caracteristicaBLE_Comandos.written()) { //Si hay datos, ejecutamos el comando
    leerYEjecutarComado();
  } // ... caso contrario simplemente se termina el flujo de loop()
}

/**
 * Este método lee el comando registrado en la característica BLE y lo ejecuta.
 */
void leerYEjecutarComado(){
    String valorDelComando = obtenerValorDelComando();

    if (valorDelComando.startsWith("ON")) {
      Serial.println("LED on");
      digitalWrite(ledPin, HIGH);
    } else {
      Serial.println("LED off");
      digitalWrite(ledPin, LOW);
    }
}

/**
 * Extraer el valor del comando en formato String
 */
String obtenerValorDelComando(){
    int longitudDelComando = caracteristicaBLE_Comandos.valueLength();
    Serial.print("Longitud: ");
    Serial.println(longitudDelComando);
      
    const byte* val = caracteristicaBLE_Comandos.value();
    
    String strValor = String((const char *)val).substring(0, longitudDelComando);
    Serial.println("|" + strValor + "|");

    return strValor;
}

void parpadear(int times, int milliseconds){
  for(int i=0; i<times; i++){
    digitalWrite(ledPin, HIGH);
    delay(milliseconds);
    digitalWrite(ledPin, LOW);
    delay(milliseconds);
  }
}

 

 

Fundamentos y Experimentación con Bluetooth Low Energy

1 Jul , 2017,
Rebeca Rodriguez Tencio
, , , , ,
No Comments

Resumen: En esta publicación, Rebeca Rodiguez nos da una importante lección sobre la importancia de profundizar un poco en los fundamentos de las tecnologías que usamos, y a su vez nos propone un experimento muy interesante para aplicar estos conocimientos en una aplicación que permite controlar una luz (LED) de manera remota desde un teléfono celular.

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

¿Conocen lo que es el Bluetooth de Baja Energía?

Saber de una tecnología va más allá de solo leer artículos informativos acerca de ella, antes de empezar a experimentar con BLE pensé que se me facilitaría desarrollar con está herramienta, no obstante descubrí que los conocimientos con los que contaba eran mínimos, y necesitaba aprender más para poder trabajar en uno de los proyectos actuales del Centro de Innovación, por lo que con el apoyo de Jose Núñez, uno de los ingenieros y colaboradores del centro, empecé la aventura de investigar y experimentar el mundo del Bluetooth de Baja Energía.

En muchos casos es muy fácil poder hacer aplicaciones funcionales e interesantes porque ya alguien más se tomó la molestia de hacer frameworks, librerías y tutoriales que nos facilitan la complejidad que conlleva realizar algo desde cero; probablemente si te gusta el mundo maker o estudias algo relacionado a la tecnología te has encontrado con proyectos que incluyan bluetooth como parte de las aplicaciones, sin embargo ¿te has preguntado la historia o cómo funciona toda la comunicación que hay detrás de esa tecnología o solamente has seguido los pasos de un tutorial e instalado las librerías respectivas copiando y pegando código y nos conformamos con que funcione a la primera?

PD: no importa si agarramos código de internet o nos basamos en algo ya existente para realizar un proyecto o aprender, existe mucha información y hay que sacarle el mayor provecho, pero es importante entender cómo funciona lo que estamos programando, la historia que hay detrás de  la comunicación entre los dispositivos y los términos empleados.

Resultado de imagen para BLUETOOTH low energy

El BLE es la versión ligera y mejorada del Bluetooth 4.0 clásico, está diseñado para abordar las necesidades de eficiencia energética y la simplicidad en el diseño de los productos, convirtiendose en una solución inalámbrica ULP (Ultra Low Power, Ultra Bajo Consumo); esta tecnología opera en la banda mundial de 2.4GHz, cuenta con una banda de bits de capa física de 1Mbps en un rango de 15metros.

El Bluetooth de Baja Energía fue desarrollado por Nordic Semiconductor, fue uno de los primeros miembros de “Wibree Alliance” la organización que inicio el desarrollo estándar de la ULP (Ultra Low Power), sin embargo después fue adoptado por el SIG (Special Interest Group, Grupo con Especial Interés), que fue conformado por cinco compañías (Ericsson, Nokia, Toshiba, IBM e INTEL). Nordic ha jugado un papel importante en el desarrollo de BLE, y continua desempeñando un papel clave a través del trabajo realizado como miembro asociado de Bluetooth SIG.

Lo interesante al usar BLE es que ha sido implementado en la gran mayoría de plataformas móviles modernas, sea iOS, Android, móviles con Windows, entre otros.

Hay conceptos indispensables con los que se van a encontrar siempre que empiecen a investigar acerca del BLE, por lo que conocer el significado o familiarizarse con los términos es importante.

Comenzamos hablando de perfiles y protocolos: el primer concepto es la subcategoría GAP (Generic Access Profile, Perfil de Acceso Genérico). El GAP es el encargado de permitir que el dispositivo sea público al exterior y por lo tanto define la forma de interacción entre los dispositivos. El GAP tiene dos roles importantes de conexión:  (1) los dispositivos centrales – de ahí el término BLE Central – (que corresponde a los móviles, tablet o dispositivos con capacidad de procesamiento mayor que inician la conexión con los periféricos) y (2) los periféricos (dispositivos pequeños de baja potencia y consumo) a los que se pueden conectar los dispositivos centrales.

Una vez que se establece la conexión entre los dispositivos centrales y los dispositivos periféricos entra al juego el GATT (Generic Attribute Profile, Perfil Genérico de Atributos) permitiendo la comunicación en ambas direcciones, a través del protocolo ATT que se usa para almacenar los servicios, los datos y las características propias de cada dispositivo utilizado; es importante destacar que un periférico BLE solo puede ser conectado a un dispositivo central a la vez, ya que tan pronto como el periférico es conectado al dispositivo central dejara de ser visible para otros dispositivos, sin embargo un dispositivo central (celulares, tablets…) si puede ser conectado a varios periféricos.

Al igual que en el GAP, el GATT también tiene roles de interacción que es importante conocer, como por ejemplo: el servidor que contiene las características de la búsqueda ATT asi como las definiciones del servicio y las características, el otro concepto es el cliente GATT que es el encargado de enviar las solicitudes. Todas las transacciones de comunicación entre los dispositivos son iniciadas por el GATT cliente (central) que recibe la respuesta del dispositivo esclavo, el GATT servidor (periférico).

Existen muchas aplicaciones para poder escanear periféricos BLE desde un dispositivo móvil, sin embargo hay una de ellas que me gustó mucho al momento de utilizarla. Se trata de nRF Connect for Mobile (Que antes se llamaba nRF Master Control Panel) es un app muy útil para experimentar y entender los conceptos de comunicación BLE.

Hay un ejemplo que encontré y quiero compartir porque está interesante ya que permite controlar un LED desde el celular, es decir podemos controlar un TinyTILE de Intel o una placa de Arduino 101 a través de un dispositivo central.

NOTA: Antes de iniciar el ejercicio es importante repasar qué es Intel Curie, esto para tener más claro el funcionamiento de los dispositvos perifericos utilizados, pueden guiarse con el siguiente enlace: https://costaricamakers.com/?s=curie

EJERCICIO PROPUESTO

Materiales:

  • 1LED
  • 1 Protoboard
  • Cable para prototipar
  • 1 tiny tile o placa arduino 101
  • 1 resistencia de 220Ω
  • Instalar el app de nRF Master Control Panel

Pasos a seguir:


PASO 1: Prototipar según la imagen del diagrama, que se obtuvo de: https://cdn.sparkfun.com/assets/learn_tutorials/4/9/2/Exp_1_Blink_bb.png

 

 

 

 

 

 

 


PASO 2: Conectar el periférico utilizado (Arduino 101 o TinyTILE), abrir el Arduino IDE y cargarle el código de ejemplo:

#include 
BLEPeripheral blePeripheral;
BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // BLE LED servicio app

//BLE caracteristicas asigandas
BLEUnsignedCharCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

const int ledPin = 13; // pin asignado al LED

void setup() {
    pinMode(ledPin, OUTPUT);

    blePeripheral.setLocalName("TINYTILE BLE"); //Nombre que se le asigna al periferico para ser encontrado
    blePeripheral.setAdvertisedServiceUuid(ledService.uuid());

    blePeripheral.addAttribute(ledService); //caracteristicas del servicio
    blePeripheral.addAttribute(switchCharacteristic);

    switchCharacteristic.setValue(0);

    blePeripheral.begin();
}

void loop() {
    // Escucha los perifericos BLE para conectarse:
    BLECentral central = blePeripheral.central();

    // Si el central es conectado al periferico:
    if (central) {
        // Mientras la central siga conectada al periferico:
        while (central.connected()) {
            // Si el dispositivo remoto escribió a la característica,
            // usar un valor para encender el LED
            if (switchCharacteristic.written()) {
                // Cualquier valor a diferencia de 0 encendera el LED
                if (switchCharacteristic.value()) {
                    digitalWrite(ledPin, HIGH);
                }
                else {
                    digitalWrite(ledPin, LOW);
                }
            }
        }
    }
}

PASO 3: Abrir el app y hacer escaner de los dispositivos periféricos, conectar en este caso con el “TINYTILE BLE” como se muestra en la siguiente imagen. Una vez que se selecciona la opción de “CONNECT”, hay que hacer click en “Unknown Service” van aparecer unas flechas, haga click en la  flecha que tiene direción hacia abajo.

 


PASO 4: Se abrirá una pantalla o cuadro de dialogo, donde debemos seleccionar la opción de “UNIT 8” e introducir un número distinto de 0 para encencer el LED y haga click en enviar o “SEND”.

¡El LED debe encenderse! para volver apagarlo, debe abrir el mismo cuadro de diálogo e ingresar el número 0 y hacer nuevamente click en enviar y el LED debe apagarse.

Gracias por leer este artículo. Nos será de mucho valor que nos digas en comentarios si te fue de utilidad, si trataste de hacer el experimento y si realizaste cambios al mismo.

IoT para Hogares Inteligentes

26 Jun , 2017,
Luis Diego Jimenez Sanchez

No Comments

Que significa Iot para Hogares Inteligentes?:

Para ir tomando los primeros pasos en la tecnología de IoT (Internet de las cosas) enfocado hacia el tema de los hogares inteligentes, es necesario primero investigar sobre cuales tecnologías hay disponibles.  Hogares inteligentes y el Internet de las cosas, que de ahora en adelante solo lo mencionare como IoT, se refiere a varios conceptos como inteligencia, automatización, comunicación, seguridad y eficiencia energética todo enfocado a intentar mejorar la calidad de vida de la persona y su hogar.  Algunos de los objetivos de lo que se intenta con IoT para hogares inteligentes es:

  • Control y automatización de luces.
  • Dispositivos de entretenimiento como equipos de sonido, televisores, etc.
  • Sistemas de alarma y sensores de seguridad.
  • Sistemas de control de temperatura.

Arquitectura del sistema

La arquitectura de un sistema de IoT para hogares inteligentes se reduce a los siguientes componentes:

  • Sensores y actuadores: reciben las señales y ejecutan comandos en el hogar tan sencillo como apagar una luz.
  • Cliente de control remoto: Puede ser desde un navegador web o una aplicación celular, pero desde este punto el usuario envía el comando a ejecutar por el actuador o en el caso del sensor, es aquí donde se recibe la información.
  • Servicio de nube o base de datos: Es el intermediario entre el usuario (cliente de control remoto) y los sensores y actuadores.

A continuación se explica de manera sencilla el funcionamiento de un sistema de IoT Smart Homes:

Figura 1: Diagrama de un sistema IoT para hogares

El hogar primero que todo debe tener los dispositivos en el hogar con el hardware necesario para el hardware en estudio.  Ejemplo básico, un switch o apagador de luces, debe tener el hardware que le permita la comunicación con el dispositivo que le vaya a mandar los comandos.  El HUB o la computadora que permita la comunicación con los dispositivos, aunque esto se puede reemplazar por un protocolo que permita la conexión directa.  Ahora para enviar los comandos desde una aplicación de celular hacia mi computadora o HUB en la casa para activar los dispositivos, esta información debe pasar por una nube de almacenamiento para la conexión.  A la vez, nos permite almacenar información de eficiencia energética para optimización de recursos.   Esto en cuanto a los protocolos de comunicación, se listan algunos a continuación.

  1. Wifi.
  2. Bluetooth.
  3. Radiofrecuencia.
    1. Z-Wave.
    2. Zigbee.
    3. BidCos.

Seguridad: 

Ahora, sabiendo el hardware existente para una posible construccion de un smart home, algo muy importante que no se puede olvidar es la seguridad.  Sin tener un protocolo con la debida incriptacion de datos, cualquier persona con un conocimiento tecnico en el area, podria eventualmente hackear las senales y manipular el hardware.  Para evitar esto es necesario siempre revisar la encriptacion que pueda tener los dispositivos que se utilicen.  En el caso de los dispositivos de radiofecuencia tales como Z-Wave, estos protocolos ya venden productos con certificados de seguridad.  En el caso de usar un dispositivo para comunicacion por WiFi, es necesario encriptar los datos.

Ahora, ya teniendo esta introduccion la idea es montar un prototipo usando los protocolos anteriores, estableciendo una conexion segura entre el usuario y los actuadores.

Se despide,

Luis Diego Jimenez Sanchez

 

 

 

Soporte del Intel Realsense para Ubuntu

19 Jun , 2017,
Luis Ramirez
No Comments

http://reconstructme.net/wp-content/uploads/2015/11/r200.jpg

¿Realsense? ¿Que tiene de especial esta cámara?

Pués, la cámara Intel Realsense R200 posee 3 cámaras, las cuales en conjunto con sensores integrados permite generar ambientes en 3 Dimensiones hasta distancias de 5 a 10 metros. 1 cámara brinda imágenes RGB, y las otras 2 brindan imágenes infrarrojas (IR) para reproducir la profundidad. Hace uso de un proyector láser para realizar un escaneo de 3D para percepción de escenas y fotografías mejoradas.

Al permitir hacer escaneo en 3D de habitaciones puede detectar movimientos de manos, cabezas, cuerpos y mucho más.

¡Y algo muy importante! ¡Se puede utilizar con el Intel Joule!https://communities.intel.com/community/image/2729/2.png?a=97855

¿Cómo instalar el soporte para sistemas basados en Linux, como Ubuntu?

 

Primero debemos de asegurarnos que el sistema se encuentra actualizado a la última versión.

sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade

Lo segundo es verificar la versión del Kernel de Linux que estamos utilizando

uname -r

El valor que nos imprime debe ser mayor o igual que 4.4.0-50

Luego debemos de instalar algunas dependencias para Librealsense

sudo apt-get install libusb-1.0-0-dev pkg-config

sudo apt-get install libglfw3-dev

 

Posteriormente ocupamos clonar el siguiente repositorio, se puede descargar por medio de la interfaz web en https://github.com/IntelRealSense/librealsense o con el siguiente comando

git clone https://github.com/IntelRealSense/librealsense

Una vez clonado el repositorio nos dirigimos al directorio y ejecutamos el los siguientes comandos

mkdir build && cd build

cmake ../ -DBUILD_EXAMPLES=true

La bandera “DBUILD_EXAMPLES” es para que se compilen los ejemplos con los que podemos probar el funcionamiento de la cámara. El último comando puede tomar bastante tiempo, una vez finalizado ejecutamos lo siguiente

make && sudo make install

Una vez concluido el paso anterior la biblioteca se encontrará instalada en /usr/local/lib y los encabezados se ubican en /usr/local/include Además como compilamos los ejemplos los vamos a poder encontrar en /usr/local/bin

 

https://www.intel.es/content/dam/www/public/us/en/images/photography-abstract/realsense-static-promo-rwd.png.rendition.intel.web.416.234.png

Como instalar OpenCV en Ubuntu

Jun , 2017,
Luis Ramirez
No Comments

https://blog.desdelinux.net/wp-content/uploads/2016/04/ubuntu.png

OpenCV es una biblioteca para manipulación de imágenes bastante potente y gratis tanto para propósitos académicos como comerciales. Posee extensiones en C++, C, Python y Java y soporta gran variedad de Sistemas Operativos, como Windows, Linux, Mac OS, iOS y Android.

En esta publicación se explicará la manera de instalar OpenCV para Python en Ubuntu.

http://www.akirasan.net/content/images/2016/06/opencv-python.png

Existen múltiples maneras de lograr este propósito, a continuación explicaremos las 2 principales.

1- La primera opción nos instalará la versión más actualizada de OpenCV 2.

  1. sudo apt-get install libopencv-dev python-opencv

2- La segunda opción nos instalará la última versión que existe (version 3.2.0 actualmente) de OpenCV 3, la cual incluye mejoras y optimizaciones sobre la versión 2. Por lo lo primero debemos descargar el siguiente script https://github.com/milq/milq/blob/master/scripts/bash/install-opencv.sh

Una vez descargado el script, nos dirigimos hacia el directorio en el que se encuentra y ejecutamos el siguiente comando

bash install-opencv.sh

Nos pedirá la contraseña y comenzará la instalación.

 

Si deseamos verificar la versión que tenemos instalada de OpenCV, se puede crear un sencillo script de Python con las siguientes líneas

import cv2
print(cv2.__version__)

 

Así de simple tenemos OpenCV en nuestro sistema.

¿Que cosas se pueden hacer con OpenCV?

  • Reconocimiento de vehículos en tiempo real.

 

  • Reconocimiento de rostros

http://docs.opencv.org/3.2.0/faceDetection.png

  • Manipulación de videos

http://www.pyimagesearch.com/wp-content/uploads/2016/02/writing_to_video_quicktime.jpg

 

Y gran variedad de cosas mas.

 

La manera más sencilla de comenzar a desarrollar programas con OpenCV es visitando el siguiente enlace en el que existen pequeños tutoriales que brindan las bases suficientes para hacer lo que se nos ocurra http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_tutorials.html

 

 

Prototipos de Software con Computadoras Virtuales c9.io

11 Jun , 2017,
Jose Nunez
, , , ,
No Comments

Este es un post realmente corto.

Cuando uno está experimentando o desarrollando con tecnologías de software para cosas como desarrollo web y de aplicaciones móviles, sistemas como NodeJS o Python, visión computarizada, etc… usualmente requerimos instalar en nuestros computadores una cantidad importante de bibliotecas y paquetes para realizar pruebas con dichas tecnologías.

C9.io es un servicio comercial de máquinas virtuales en la web.

La verdad me ha parecido muy sencillo y completo.

https://c9.io

Todo es cuestión de crear una cuenta de usuario, ojalá enlazada con nuestra cuenta de usuario de github.com (si la tuvieramos) y vualá, podemos crear nuevas máquinas virtuales, clonar las existentes, y operarlas para instalar y desinstalar cosas a nuestro antojo casi ilimitado.

Una cuenta gratuita nos permitirá generar nuevas máquinas virtuales con ciertas limitaciones de capacidad de procesador, memoria RAM (512MB) y almacenamiento (2GB) que por lo general son suficientes para realizar pruebas de concepto o experimentación.

En próximas entregas estaré discutiendo un poco cómo realizar pruebas en C9.io para desarrollo de apps en ionic, nodejs, python-opencv entre otros.

Ubuntu Desktop para Intel Joule

7 Jun , 2017,
Luis Ramirez
No Comments

https://www.shoplinuxonline.com/media/catalog/product/cache/8/image/650x/040ec09b1e35df139433887a97daa66f/u/b/ubuntulogo.png

https://simplecore.intel.com/newsroom/wp-content/uploads/sites/11/2016/08/intel-joule-1-2x1.jpg

Ubuntu Desktop es una opción viable para trabajar con el Joule, ya que al integrar la interfaz gráfica permite una interacción más amigable para los usuarios, además de brindar todas las bondades que provee un sistema basado en Linux. Ya que muchos evitan el tener que trabajar directamente en consola o terminal, debido a que les resulta poco intuitivo y hasta cierto punto complejo.

Esta guía se desarrolló para explicar como se puede instalar este Sistema Operativo en el Intel Joule y todos los pasos fueron desarrollados de la misma manera que se describen a continuación.

 

Actualizar el BIOS del Joule

Para comenzar es necesario tener el BIOS actualizado, cuando se realizaron las pruebas se tuvo disponible la siguiente imagen para el BIOS version #174 en el siguiente enlace https://downloadmirror.intel.com/26206/eng/Joule-Firmware-2016-12-18-174-Public.zip.

Al momento de leer este artículo podría existir una versión más actualizada, se puede verificar en https://developer.ubuntu.com/core/get-started/intel-joule#alternative-install:-ubuntu-desktop-16.04-lts

El procedimiento detallado para actualizar el BIOS se puede seguir en el siguiente enlace https://software.intel.com/en-us/flashing-the-bios-on-joule

 

Descarga de Ubuntu Desktop

La imagen de Ubuntu que se probó en esta guía se puede obtener del siguiente enlace http://people.canonical.com/~platform/snappy/tuchuck/desktop-beta4/tuchuck-xenial-desktop-iso-20170109-0.iso

Se puede verificar la integridad del archivo con el siguiente MD5SUM: 097b4d7f4b828e307f290f31e24a686d

Al momento de leer este artículo podría existir una versión más actualizada, se puede verificar en https://developer.ubuntu.com/core/get-started/intel-joule#alternative-install:-ubuntu-desktop-16.04-lts

 

Crear un dispositivo Booteable

Debido a que el archivo descargado tiene un formato ISO se puede crear un dispositivo booteable haciendo uso de un USB. Dependiendo del Sistema Operativo que utilice se pueden seguir los pasos:

Ubuntu: https://www.ubuntu.com/download/desktop/create-a-usb-stick-on-ubuntu

Windows: https://www.ubuntu.com/download/desktop/create-a-usb-stick-on-windows

MacOS: https://www.ubuntu.com/download/desktop/create-a-usb-stick-on-macos

 

https://shop-media.intel.com/api/v2/helperservice/getimage?url=http://images.icecat.biz/img/gallery/33124942_0200197756.jpg&height=550&width=550

Proceso de Instalación

  1. Iniciar el sistema desde el dispositivo USB que creamos en el paso anterior.
  2. El sistema comenzará la instalación automáticamente, incluyendo el particionado e instalación en la memoria integrada eMMC.
  3. Cuando la instalación termina, un mensaje aparecerá y se requerirá reiniciar el sistema.
  4. Inicie el sistema de la memoria eMMC (integrada) para completar el proceso de instalación.
  5. Siga las instrucciones de configuración del sistema, selección de idioma, red inalámbrica, zona horaria y distribución de teclado.
  6. Escoja el nombre del sistema, un usuario y contraseña.
  7. Espere a que termine la configuración, si se escuentra conectado a internet tomará unos minutos adicionales para la instalación automática de actualizaciones.
  8. La instalación ha terminado, ya puede usar el sistema.

 

Recomendaciones

  • El sistema Joule posee una memoria integrada eMMC de 16 GB, se puede agregar una memoria SD y se puede agregar almacenamiento adicional a través alguna memoria USB. Durante un tiempo se probó cambiar la dirección de /home hacia la memoria SD, esto implicó una reducción en el rendimiento del sistema. Por lo que se recomienda mantener la memoria SWAP y el almacenamiento del sistema ligado a la memoria eMMC y hacer uso de la memoria SD y cualquier adicional por USB para almacenamiento masivo con el fin de obtener el mejor rendimiento de la plataforma.
  • Es de utilidad hacer uso de un USB hub, alimentado externamente de corriente, de manera que se pueden extender las capacidades del sistema aún más. Posiblemente incluir mouse y teclado (si no se tienen bluetooth), una cámara Realsense de Intel y posiblemente algún almacenamiento externo adicional; teniendo en cuenta que se posee un puerto adicional libre Tipo-C.

 

Enlace de referencia: https://developer.ubuntu.com/core/get-started/intel-joule#alternative-install:-ubuntu-desktop-16.04-lts

 

Mis primeros pasos con ionic

5 Jun , 2017,
Jose Nunez
, , , ,
No Comments

Bueno, como nos pasa a todos, un día desperté con esa imperiosa necesidad de crear una app para teléfonos inteligentes; y pues, comenzar no es fácil si tomamos en cuenta que las principales plataformas de desarrollo (IOS y Android) tienen sus costos y complejidades.

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

Afortunadamente, mis compañeros del centro de innovación habían estado realizando una investigación sobre algo similar, y me hablaron del Ionic Framework, un sistema para desarrollar aplicaciones móviles usando tecnologías web (HTML, CSS, JS/TS, ANGULARJS) etc que luego pueden implementarse tanto en Android como IOS.

Dentro de las bondades de Ionic podemos listar las siguientes:

  1. Manejo de plantillas de proyecto predefinidas
  2. Acceso a características específicas de hardware (bluetooth, gps, camara, etc)
  3. Pre-visualizacion de las apps usando IonicView directamente en los dispositivos móviles tanto para Android como para IOS

Pero bueno, he querido comenzar con el pie derecho, configurando una estación de trabajo LINUX UBUNTU 16.04 así que aquí van algunos lineamientos básicos para comenzar:


#1 – NodeJS

Es necesario instalar nodeJS y npm. Para Ubuntuo 16.04 he encontrado esta guía que me ha parecido muy completa. En ella se discuten diferentes métodos. Yo elegí usar el método de nvm (node version manager) que se puede resumir en los siguientes comandos uno por uno.

Antes de iniciar vaya a https://nodejs.org/en/download/ y determine cual es la versión LTS (en nuestro caso es la 6.11)

cd
sudo apt-get update
sudo apt-get install build-essential libssl-dev
curl -sL https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh -o install_nvm.sh
bash install_nvm.sh
source ~/.profile
Opcionalmente: nvm ls-remote | grep Latest
nvm install  6.11
node -v
npm -v

#2 – Instalación de IONIC

Ahora, de acuerdo con la guía de inicio de IONIC procedemos con el siguiente comando:

npm install -g cordova ionic

Luego de unos minutos (como 15 con mi conexion 3G) y de mucho texto en la consola, podemos usar el comando ionic -v para determinar la versión que hemos instalado.

En este punto es importante crear una cuenta personal en https://apps.ionic.io/signup para poder visualizar las aplicaciones con Ionic View. Una vez creada la cuenta podemos usar el siguiente comando para que nuestra instalación de ionic quede conectada a nuestra cuenta.

ionic login

#3 Creación de un nuevo proyecto

(!) Antes de crear un nuevo proyecto, es importante asegurarse que su GIT local esté instalado y configurado.

Al momento de escribir este artículo, la guía de inicio hace mención de 3 tipos de proyecto: blank, tabs y sidemenu (aunque hay todo un mercado de tipos de proyecto en la red). La verdad nos gustó más el de tabs, así que usamos estos comandos:

cd
mkdir myIonicTests
cd myIonicTests
ionic start myApp tabs

Dado que ya habíamos hecho login en el paso anterior, podemos decirle que si (Y) a la pregunta de la terminal “Link this app to your Ionic Dashboard to use tools like Ionic View? (Y/n)“. Al decir que sí el sistema termina de crear el app y nos lleva al navegador de Internet a la página de ionic para crear nuevas apps para el visor. Más tarde será necesario utilizar el comando ionic link para conectar el código de nuestra app local con su correspondiente entrada en Ionic View.

(!) Notas: Algo importante de resaltar es que este template de una vez crea el proyecto como un repositorio GIT. Reconectar un repositorio GIT a nuestra cuenta GIT de preferencia es una tarea importante a  futuro, pero eso lo dejaremos para otro artículo.
Otra cosa importante es que el comando start de ionic necesitará una conexión a Internet estable para poder descargar todos los archivos, bibliotecas y dependencias necesarias.

En este punto ya podemos ejecutar el comando ionic serve para pre-visualizar el app en nuestro navegador local.


#4 Ejecutar la aplicación en un celular

Nótese que al crear la aplicación en el sitio web de ionic, se generó un código de identificación de la app. En la aplicación IonicViewer de Android o IOS se puede acceder con sus credenciales de ionic, o usando el código de identificación de la aplicación.

Antes de subir el código a Ionic View, necesitamos enlazarlo con nuestra nueva app; usando el comando ionic link. Se usan las flechas arriba y abajo del teclado para seleccionar el app.

Para subir el código más reciente utilizamos el comando ionic upload; luego en la aplicacion de celular Ionic View usamos la opción “Clear App Data” y luego “View App”

En una próxima entrada estaremos discutiendo cómo modificar el código.