Contenido


Desarrolle una aplicación IoT en Bluemix con Arduino y Rails

Comments

En este tutorial, le mostramos la forma de desarrollar una aplicación que usa tecnologías aplicables a Internet of Things (IoT). Nuestra aplicación recopila datos de un acelerómetro, los guarda en un servidor de web y después despliega el resultado en tiempo real en una página web .

Lo que necesitará para construir su aplicación

Para la Parte 1, usted necesita:

  • Una cuenta IBM Bluemix
  • Ruby 1.8.7-2.0.0 (la versión soportada de Bluemix)
  • Rails framework 3.2.13 (La versión soportada de Bluemix e ibm_db gem)
  • ibm_db gem

Para la Parte 2, usted necesitará:

  • Un Arduino Uno u otra tarjeta compatible con Arduino-
  • Opcional: Arduino Ethernet Shield
  • Un acelerómetro (específicamente, el GY-521)
  • Algunos cables conectores macho-hembra
  • Python 2.7.x

Se requiere cierta familiaridad con Python y Ruby en Rails pero no es estrictamente necesario. También, no tiene que tener experiencia en el uso de Arduino o en cualquier otro tipo de micro controlador para continuar .

Corra la aplicaciónObtenga el código

Desarrolle su aplicación

En esta parte del artículo explicaremos los componentes de software requeridos para recopilar, guardar y analizar datos.

Paso 1. Cree una aplicación Rails

  1. Creamos nuestra aplicación Rails localmente en nuestra computadora primero. A partir de un indicador de comando, corra $ rails new AnalyzeVibration, donde AnalyzeVibration es el nombre de nuestra aplicación. Se creará una nueva carpeta de aplicación con este nombre en el directorio en el que está.
  2. Para esta aplicación, necesitaremos lo siguiente. Partes MVC:
    • Modelos— Lectura
    • Vistas— Índice (en páginas)
    • Controladores— Páginas, lecturas, solicitudes de servidor

    Para generar la arquitectura MVC, corra:

     $ cd AnalyzeVibration $ rails generate model Reading $ rails generate controller Pages $ rails generate controller Readings $ rails generate controller ServerRequests

    Se generarán los siguientes archivos.

    Image shows model Reading
    Image shows model Reading
    Image shows Pages
    Image shows Pages
    Image shows Readings
    Image shows Readings
    Image shows ServerRequests
    Image shows ServerRequests
  3. Ahora editaremos el archivo de migración, creando los campos de nuestro modelo, que se usará para crear las tablas en la base de datos.
     class CreateReadings < ActiveRecord::Migration
    # axis_x - Measurement of Axis X from Accelerometer
    # axis_y - Measurement of Axis Y from Accelerometer
    # axis_z - Measurement of Axis Z from Accelerometer
    def change
    create_table :readings do |t|
    t.float :axis_x
    t.float :axis_y
    t.float :axis_z
    t.timestamps

    end
    end
    end
  4. Después de editar el archivo de migración, corra $ rake db:migrate para crear la tabla en la base de datos de desarrollo. En nuestro ambiente de desarrollo local, estamos usando la base de datos SQLite (que se incluye con Rails de manera predeterminada).
  5. Inicie el servidor usando $ rails s. Para ver la aplicación corriendo abra un navegador y apunte a http://localhost:3000. Para detener el servidor, puede usar Ctrl+C en su ventana de terminal.
  6. Edite los controladores con Pages controller (pages_controller.rb). Este controlador será responsable de entregar la página básica de la aplicación.
     class PagesController < ApplicationController
    def index

    end
    end
  7. El controlador de Solicitudes de Servidor (server_requests_controller.rb) será responsable de recibir las solicitudes POST con las lecturas (ejes x,y,x) recopiladas por Arduino y de guardarlas en la base de datos.
     class ServerRequestsController < ApplicationController
    def server_post
    if params[:reading].present? && !params[:reading].nil?
    readings = params[:reading]
    readings = readings.split(",")

    readings.each { |e|
    axis = e.split(" ").map{|t| t.to_f}
    new_reading = Reading.new
    new_reading.axis_x = axis[0]
    new_reading.axis_y = axis[1]
    new_reading.axis_z = axis[2]
    new_reading.save

    }
    end

    render nothing: true
    end
    end
  8. El controlador de lecturas (readings_controller.rb) será responsable de devolver un documento JSON con un número determinado de lecturas de aceleración guardadas en la base de datos. Los datos se generarán en un formato aceptado por el API de Google Charts.
     class ReadingsController < ApplicationController
    def getreadings
    axis = params[:axis]
    number = params[:number].to_i

    if axis == "x"
    readings = Hash[*Reading.last(number).collect{|it| [it.id, it.axis_x]}.flatten]
    elsif axis == "y"
    readings = Hash[*Reading.last(number).collect{|it| [it.id, it.axis_y]}.flatten]
    elsif axis == "z"
    readings = Hash[*Reading.last(number).collect{|it| [it.id, it.axis_z]}.flatten]
    end

    part1 = '{ "cols":[ {"id":"","label":"","pattern":"","type":"string"},
    {"id":"","label":"Measurement","pattern":"","type":"number"}], "rows":['
    part2 = readings.map{|k,v| '{"c":[{"v":"Id-' + k.to_s + '"},{"v":"' + v.to_s + '"}]}' }.join(',')
    part3 = ']}'
    readings_google_charts_format = part1 + part2 + part3
    @readings_json = JSON.parse(readings_google_charts_format)

    render json: @readings_json

    end
    end
  9. Para crear la vista del Índice, cree un archivo denominado index.html.erb en el directorio app/views/pages/. Esta vista contendrá el código HTML para la página básica.
     <div id="main">
    <section class="sectionleft">
    <h2>X-Axis Measurements</h2>
    <div id="x_readings_chart" class="readings_chart"></div>
    <h2>Y-Axis Measurements</h2>
    <div id="y_readings_chart" class="readings_chart"></div>
    <h2>Z-Axis Measurements</h2>
    <div id="z_readings_chart" class="readings_chart"></div>
    </section>

    <section class="sectionright">
    </section>

    </div>
  10. Para cambiar la página Home y crear rutas, edite el archivo config/routes.rb agregando el siguiente código.
     root :to => "pages#index"

    match '/server_post', :to => 'server_requests#server_post', :via => 'post'
    match '/getreadings/:axis/:number', :to => 'readings#getreadings', :via => 'get'

    En el directorio de su aplicación (AnalyzeVibration), vaya a public/ y renombre el archivo index.html a algo más (e.g., index2.html).

    Image shows renaming index file
  11. Agregue activos a la aplicación (archivos CSS y JavaScript). Le sugerimos que copie todo el código/archivos de su repositorio, tales como: layout.css.scss, pages.css.scss, charts.js, application.js. Image shows adding assets to the app
    Image shows adding assets to the app

    El archivo charts.js, por ejemplo, será responsable de entregar Google Charts usando las lecturas de aceleración almacenadas en la base de datos.

Paso 2. Prepare el ambiente Bluemix

  1. Cree una aplicación en Bluemix. Después de registrarse a su cuenta Bluemix, vaya a su Tablero/Aplicaciones y haga clic en Crear una aplicación.
  2. Bajo la categoría Runtime, elija el tiempo de ejecución Ruby en Rails, introduzca un nombre (el nombre del host debe ser único) y haga clic en Create. En nuestro caso el nombre de la aplicación es myrailsapplication. Image shows selecting runtime
    Image shows selecting runtime

    Después de crear la aplicación, puede acceder a ella a través del URL/vínculo suministrado por Bluemix (después de que se inicia la aplicación). Espere hasta que su aplicación esté corriendo antes de agregar un servicio para evitar errores al crear/vincular el servicio de base de datos.

  3. Cree un servicio de base de datos yendo a su Tablero/Servicios y haciendo clic en Add a service.
  4. Bajo la categoría Database Management, haga clic en SQL Database Service y vincule este servicio a la aplicación Rails que usted creó eligiendo su nombre (myrailsapplication) en el campo App. Escriba un nombre para su servicio; en nuestro caso, usamos mydatabaseservice. Entonces haga clic en Create. Image shows adding database service
    Image shows adding database service

    Ahora su ambiente Bluemix está listo para que se despliegue su aplicación Analyze Vibration.

Paso 3. Prepare la aplicación para el despliegue (aplicación local)

  1. Instalemos el adaptador ibm_db. Dado que usaremos el SQL Database Service en Bluemix (con la tecnología IBM DB2®), necesitamos instalar una biblioteca (Ruby gem), que le permitirá a la aplicación conectarse a la base de datos. Agregue gem 'ibm_db' en gemfile. Comente la línea para gem 'sqlite3' dado que no lo usaremos. También especifique la versión Ruby agregando una línea con la versión que esté usando (por ejemplo, ruby '1.9.3'). Image shows preparing to install the adapter
    Image shows preparing to install the adapter
  2. Corra $ bundle install para instalar gem/adapter.

    Nota: Después de instalar ibm_db gem, no podremos probar la aplicación en nuestro host local a no ser que instalemos DB2 en su computadora. También, el conectar el archivo database.yml para conectarse a una base de datos es un paso importante al desplegar la aplicación Rails. Sin embargo, el buildpack que usaremos para desplegar su aplicación en Bluemix reescribe este archivo y establece la conexión para nosotros automáticamente.

  3. Ahora cambiemos la configuración del ambiente de producción. Vaya a config/environments/production.rb y establezca dos parámetros relacionados con la configuración de activos a verdadero: config.serve_static_assets = trueconfig.assets.compile = trueImage shows changing the settings
    Image shows changing the settings
  4. Agregue (copia del repositorio) el archivo manifest.yml a la ruta principal de la aplicación creada por Rails (en nuestro caso, AnalyzeVibration). Image shows copying manifest.yml
    Image shows copying manifest.yml

    Este archivo se usará al desplegar la aplicación e incluye información sobre la aplicación tal como servicio, buildpack, memoria, etc.

  5. Editemos el archivo y agreguemos la información sobre la aplicación y el servicio que creamos previamente. Image shows editing the file
    Image shows editing the file

    El tiempo de ejecución base de Ruby dentro de Bluemix no viene con el controlador DB2 previamente instalado requerido para acceder el servicio SQL Database. En vez de ello, puede usar un buildpack personalizado hospedado en GitHub.com.

    Note que en el mismo archivo (manifest.yml), también podemos especificar a disk_quota, el número de instancias, memoria, etc.

    Ahora la aplicación está lista para el despliegue.

Paso 4. Despliegue la aplicación a Bluemix

Antes de desplegar la aplicación, deberá tener instalada la interfaz de línea de comando Cloud Foundry (CLI).

  1. Abra un indicador de comando, vaya dentro del directorio de la aplicación (AnalyzeVibration) y corra los comandos cf abajo:
    1. Conéctese a Bluemix: $ cf api https://api.ng.bluemix.net.
    2. Regístrese a Bluemix (escriba un correo electrónico y clave de acceso cuando se le solicite): $ cf login.
    3. Corra las migraciones: $ cf push <appname> -c "bundle exec rake db:migrate".

      El comando cf push mandará la aplicación al servidor Bluemix y hará que se corran las migraciones (cree tablas en la base de datos). Después correrá la aplicación, que tratará de conectarlo al servidor. Esperemos que esta segunda parte falle dado que aún no hemos iniciado la aplicación Bluemix, para que pueda cancelar la operación.

      Consejo: Al desplegar una aplicación usando la herramienta cf, abra otro indicador de comando y cree respaldos tipo tail logs usando $ cf logs <appname>.

  2. Mande la aplicación de nuevo e iníciela con $ cf push <appname> -c "null". La herramienta cf guarda el último comando pasado, para que el comando arriba empuje la aplicación y use "null" para liberar el último comando y usar el comando predeterminado de buildpack para iniciar el servidor.

¡Felicidades! Su aplicación Rails ahora deberá correr en Bluemix.

Construya su dispositivo

En esta parte del tutorial, explicamos los componentes de hardware requeridos para crear un dispositivo que genere los datos deseados.

Paso 1. Configure el hardware

En esta sección, explicamos la forma de trabajar con Arduino, el acelerómetro y el shield Ethernet. Construiremos un dispositivo que genere los datos enviados a la aplicación Rails que acabamos de crear.

  1. Conecte el shield de Ethernet a Arduino.
  2. Conecte el acelerómetro a los pins derechos del shield de Ethernet como se muestra abajo: Image shows pinning the Ethernet shield
    Image shows pinning the Ethernet shield

Si no se tiene un shield Ethernet, no se preocupe. Aún puede enviar los datos de su Arduino al servidor de web si lo conecta a su computadora usando un cable USB. Todo el proceso se describirá al detalle en los siguientes pasos.

Paso 2. Pruebe el acelerómetro

Ahora que el hardware está configurado, tiene que instalar algunas bibliotecas en su ambiente Arduino para asegurar que nuestro código muestra funcione bien. Puede encontrar los archivos requeridos en I2Cdev library. Después de descargar i2cdevlib y extraerlo, instale las bibliotecas requeridas en Arduino IDE:

  1. Sketch > Import Library > Add Library
  2. Seleccione la siguiente carpeta dentro de la carpeta extraída: Arduino/MPU6050
  3. Haga el mismo proceso para esta otra carpeta (Arduino/I2Cdev

Ahora que tiene todas las bibliotecas necesita correr la aplicación del ejemplo y verificar que su acelerómetro está trabajando bien. Para cargar la aplicación del ejemplo, vaya a File > Examples > MPU6050 > Examples > MPU6050_raw. Para probar que todo funcionó bien, suba el código y abra el monitor serial.

Image shows testing the app so far
Image shows testing the app so far

Si ve algo como lo que se muestra abajo, su acelerómetro está trabajando perfectamente. ¡Felicidades!

Image shows accelerometer success
Image shows accelerometer success

Nota: La velocidad (baud rate) se establece a 38400 de manera predeterminada en la aplicación muestra. Si ve que se despliegan caracteres raros, verifique que el monitor serial está trabajando con la misma velocidad (baud rate) que en su código.

Paso 3. Use Python para recopilar los datos de aceleración a través del USB

Si no tiene un shield Ethernet para su Arduino (o si no tiene un cable Ethernet fácilmente accesible), puede conectar Arduino a una PC vía USB y enviar los datos recopilados a un servidor de web usando un simple código escrito en Python.

Primero, asegúrese que el resultado de Arduino es legible para su código Python. Para hacer esto, tenemos que quitar algunos mensajes de inicialización y cambiar las tabulaciones a los espacios. Estos son sólo unos cuantos ajustes sobre el código original.

Image shows downloading
Image shows downloading

Probemos la conexión serial. Leeremos los datos enviados desde Arduino y lo desplegaremos en la terminal. Tiene que instalar el módulo pySerial. Si tiene instalado pip será bastante fácil. Simplemente use este comando: $ pip install pyserial.

Si no sabe que pip es (o no lo tiene instalado), no se preocupe. Lo puede instalar en menos de 2 minutos siguiendo las instrucciones de Instrucciones de Soporte Python y OS.

Ahora que tiene instalado un pySerial, puede obtener el código en su repositorio.

Image shows getting the code
Image shows getting the code

Establezca el puerto serial correcto donde se conecta su Arduino. Si no está seguro puede definir muchos puertos que se probarán.

Image shows defining ports to test
Image shows defining ports to test

¡Momento para correr su código! Deberá ver algo como esto.

Image shows running the code
Image shows running the code

Paso 4. Envíe los datos recopilados usando las solicitudes HTTP

Después de recopilar los datos y desplegarlos, es el momento de hacer algo más útil. Enviemos los datos recopilados al servidor web que se creó con anterioridad. Primero tiene que instalar otra biblioteca Python: $ pip install httplib. Esto le permitirá enviar los datos recopilados usando solicitudes HTTP. Ahora hagamos unos pequeños ajustes a nuestro código existente para enviar los datos que queremos.

  1. Agregue httplib a los módulos importados y cree esta función sendRequest. Asegúrese de cambiar el URL que se muestra abajo (myapp.mybluemix.net) a la que usted elija para su aplicación. Image shows changing myapp.mybluemix.net
    Image shows changing myapp.mybluemix.net
  2. En lugar de imprimir los datos a la terminal, lo enviaremos al servidor de web. Cambie la línea que se muestra abajo. Image shows sending data to web server
    Image shows sending data to web server

    A esto:

    Image shows what to change it to
    Image shows what to change it to

El código modificado está disponible aquí:

Image shows modified code
Image shows modified code

Si tiene un shield Ethernet y un cable Ethernet, puede enviar las solicitudes de HTTP directamente de su Arduino. Para hacer eso use el código que se muestra abajo.

Image shows Ethernet-alternative code
Image shows Ethernet-alternative code

Para correr este código en su Arduino, súbalo y conéctelo a un cable Ethernet.

Nota: No olvide cambiar la dirección del servidor de web (myapp.mybluemix.net) al URL que usted elija para su aplicación.

Conclusión

Este tutorial provee un framework que puede usar para desarrollar muchas aplicaciones IoT. Aquí, utilizamos un acelerómetro conectado a un Arduino, enviando los datos al servidor de web y mostrando esos datos en tiempo real. Aunque esto es un ejemplo específico de lo que puede hacer con Bluemix y Arduino, este artículo muestra los principios que usted puede usar para crear muchas otras aplicaciones.


Recursos para Descargar


Comentarios

Inicie Sesión o Regístrese para agregar comentarios.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Internet of Things
ArticleID=988938
ArticleTitle=Desarrolle una aplicación IoT en Bluemix con Arduino y Rails
publish-date=08282014