Llevo un par de semanas trasteando con un microcontrolador Arduino YUN. Los microcontroladores Arduino son baratos y muy fáciles de utilizar incluso sin grandes conocimientos de electrónica.

Para familiarizarme con la plataforma, mi “Hola Mundo” con Arduino será encender y apagar una bombilla. No es nada del otro mundo, de hecho ya hay artículos muy buenos Internet que explican como hacerlo.

Por ello me centraré más en la parte informática, y para darle un poco más de profundidad y dejar la puerta abierta a futuras aplicaciones más complejas, desarrollaremos una pequeña aplicación Android para que la bombilla pueda encenderse y apagarse desde nuestro móvil.

Arduino YUN.

A fecha de Noviembre de 2013 Arduino Yun es toda una novedad en el mundo de los microcontroladores Arduino, y la principal novedad es que, en la misma placa que el microcontrolador Arduino han montado un procesador que ejecuta una distribución de Linux llamada Linino. Además de ello, han desarrollado una serie de librerías para que desde los sketchs de arduino podamos usar los recursos del sistema operativo linux, y viceversa, para que desde linux podamos consultar el estado de las entradas y salidas del arduino.

Si a esto le unimos que de serie tiene una conexión Ethernet y una conexión WIFI, el salto con respecto a sus antecesores es notable, y facilita mucho el trabajo para principiantes en la electrónica, ya que no tenemos que comprar aparte un shield ethernet, etc.

Por lo tanto, para este ejemplo (encender y apagar una bombilla), necesitamos lo siguiente:

Hardware:
Un Arduino Yun.
Un relé de 5V
Cables macho-hembra para conectar el relé a nuestro arduino.
Un cable micro usb para transferir el sketch y darle corriente al Yun.
Una bombilla.
Un dispositivo Android (teléfono, tablet) para programar.
Una red local (nuestra red doméstica sirve) con posibilidad de conexión Wifi.

Software:
Arduino IDE para el sketch.
Eclipse o Android Studio para la app.
Un navegador para configurar nuestro Yun.

Conocimientos:
Conocimientos básicos de C para comprender el funcionamiento del sketch.
Conocimientos medios de Java y de desarrollo para la plataforma Android.
Sentido común, para no electrocutarnos cuando conectemos la bombilla a la corriente.

Configurando el YUN.

Lo primero es configurar nuestro Yun, y conectarlo a nuestra Wifi doméstica. Para ello nada mejor que seguír la guía de primeros pasos de la web de arduino.

Nuestro Yun puede configurarse y personalizarse a gusto, no tenemos que olvidar que incorpora un mini pc con Linux, con una capacidad y potencia que supera a los ordenadores de hace una década. En cualquier caso, solo dos detalles son importantes:
Quitarle la contraseña a los servicios Rest.
Ponerle una IP fija en nuestra red doméstica.
Transferir el sketch de ejemplo “Bridge”.

Servicios REST.

En la pantalla de administración básica de Yun, donde podemos unirlo a una red Wifi y cambiarle el nombre o la contraseña, es importante que aprovechemos el momento de unirlo a una wifi y marquemos los servicios rest como “open”. La interfaz de esta pantalla no esta muy lograda, y si queremos cambiar más adelante solamente la configuración de la Api rest, tendremos que volver unirlo a nuestra red Wifi.Recuerda quitarle la contraseña a los servicios rest cuando lo unas a la wifi, así te ahorrarás trabajo más tarde.

IP Fija.

Para poner una IP Fija debemos acceder al panel web de configuración de Yun, en concreto, al panel avanzado, llamado Luci. Una vez en el panel, y suponiendo que ya tenemos a Yun conectado a nuestra Wifi doméstica con una ip dinámica, nos dirigimos a Network->Interfaces y buscamos nuestra red Wifi. Pulsamos en Edit, y en esa pantalla podremos asignarle una ip estática. A partir del momento que grabemos nuestra nueva configuración, recordad que para volver al panel de control tendreis que usar la ip que le habeis puesto.

(Nota: creo que no es imprescindible ponerle una ip fija, ya que cuando invoquemos el servicio rest podemos usar la nomenclatura del tipo http://nombre_arduino.local/… Aunque a mi me ha dado problemas, por eso prefiero una estática a una dinamica).

Transferir el Sketch “Bridge” a Arduino Yun.

Dando por hecho de que ya hemos instalado eI ide de Arduino y nos hemos familizarizado con el proceso de transferir un sketch , es la hora de transferir el sketch de ejemplo Bridge. Podrás encontrarlo en la sección de sketchs de ejemplo del IDE:Instalando el ejemplo Bridge

Aviso: si os adelantáis a estas instrucciones y transferís el sketch con el relé ya conectado al pin 13, veréis que parece que se vuelve loco. Esto es debido a que el pin 13 se utiliza durante la transferencia de sketchs como monitor de actividad, así que ya sabéis, no conectéis el relé hasta haber transferido el sketch,

El ejemplo Bridge

Este sketch de ejemplo es muy interesante, ya que convierte a nuestro Arduino Yun en un servidor web capaz de ofrecer servicios Rest. Para ello trabaja de manera coordinada con el “lado Linino”, es decir, el procesador que está ejecutando el sistema operativo Linux.

Cualquier petición http que hagamos, es atendida por el servidor web de Linino (por ello podemos acceder al panel de configuración, por ejemplo). Sin embargo si la petición tiene a siguiente nomenclatura:

http://ip_de_mi_yun/arduino

es atendida por el servidor web de Linino, y como detecta el sufijo “/arduino”, se envía al procesador arduino 32u4. Básicamente, que le pasa la llamada al sketch que tengamos ejecutando en ese momento en nuestro arduino.

Vamos a analizar el código fuente del sketch Bridge un poco más de cerca.

En la sección de imports del sketch tenemos información muy importante. Como vemos, este sketch utiliza tres librerias:#include #include #include // Listen on default port 5555, the webserver on the Yun // will forward there all the HTTP requests for us. YunServer server;


La librería bridge, como su nombre indica, es el puente que nos permite establecer una comunicación entre los dos procesadores de la placa del arduino yun. La wifi, la conexión ethernet, el conector usb y la tarjeta sd están conectadas del “lado Linino”, y para acceder a estos recursos necesitamos la librería Bridge.

La libreria YunServer, hace posible al Yun a escuchar las conexiones de clientes. Como dice el comentario, escucha en el puerto 5555. Todas las peticiones http que lleguen al puerto 80 del “lado Linino”, y que lleven la nomenclatura adecuada, son reenviadas al puerto 5555 y recibidas en nuestro sketch.void setup() { // Bridge startup pinMode(13,OUTPUT); digitalWrite(13, LOW); Bridge.begin(); digitalWrite(13, HIGH); // Listen for incoming connection only from localhost // (no one from the external network could connect) server.listenOnLocalhost(); server.begin(); }


El setup de un sketch, es un trozo de código que se ejecuta solo una vez, cuando se enciende nuestro arduino. Por lo tanto es el lugar adecuado para inicializar librerías y todo tipo de recursos que necesitemos. En este caso observamos que que se inicializa la librería Bridge (lo cual tarda un par de segundos), y para tener algún tipo de retroalimentación, hace parpadear el LED 13 durante la operación (lo apaga al empezar, y lo enciende al terminar). Cuando el setup ha terminado, deberíamos tener el LED 13 encendido de color rojo.


La llamada al procedimiento pinMode() es importante. Configura el pin indicado para comportarse como una salida. Os recomiendo que este documento que explica los dos modos de comportamiento de los pines de arduino, y la diferencia entre que un pin este configurado como de entrada o de salida.

Necesitamos que el pin 13 este en modo Output o de baja impedancia, porque tenemos que suministrarle corriente a nuestro relé para poder operar.void loop() { // Get clients coming from server YunClient client = server.accept(); // There is a new client? if (client) { // Process request process(client); // Close connection and free resources. client.stop(); } delay(50); // Poll every 50ms }


El código que esta en el procedimiento loop, como su nombre indica, se ejecuta en un bucle infinito hasta que apaguemos nuestro arduino. En este caso, entre cada ejecución hay un delay de 50ms, asi que resumiendo, el sketch comprueba cada 50ms si ha llegado alguna petición del “lado Linino”. En caso afirmativo la procesa.

A partir de aquí, la cosa no tiene demasiada ciencia. Cuando se recibe una petición, se parsea la cadena, y en función de su estructura se hacen diferentes operaciones, tales como actuar sobre los pines digitales, los analógicos, etc.

Para nuestra app de Android, las peticiones http que utilizaremos son las siguientes:

http://ip_arduinoarduino/digital/13 —> pide el estado del pin 13.

http://ip_arduinoarduino/digital/13/0 —> pone el pin 13 a cero (en nuestro caso, abre el relé y apaga la bombilla).

http://ip_arduinoarduino/digital/13/1 —> pone el pin 13 a uno (cierra el relé y enciende la bombilla).

Ya tenemos el sketch Bridge instalado y funcionando en nuestro YUN. Ahora vamos a ver como conectar el relé a la placa, y la bombilla al relé.

Conexión del relé y la bombilla.Los tres componentes del proyecto: la placa Arduino Yun, un relé de 5V y una bombilla conectada a la corriente de 220V

Lo primero es darle corriente al relé, para ello tenemos que conectarlo al pin marcado como 5V en el arduino, y también la toma de tierra:
Cable rojo: conecta el pin de 5V de arduino yun con el pin VCC del relé.
Cable naranja: conecta el pin GND del yun con el pin GND del rele.
Cable blanco: conecta el pin digital 13 con el pin IN2 de nuestra placa de relés.

Nuestra placa de relés tiene realmente dos, pero solo necesitamos uno. El otro podría usarse para encender y apagar otra cosa, en cualquier caso, al precio que están los relés de dos canales comparado con los de uno, no merece la pena comprar uno de un canal a menos que nuestro proyecto tenga limitaciones de espacio.Detalle de la alimentación del reléDetalle de la conexion al pin digital 13

Ya solo nos falta conectar la bombilla al relé. Tened la precaución de hacerlo con la bombilla desenchufada, por lo que pueda pasar. Lo que haremos será conectar uno de los cables que llevan la corriente a la bombilla a NO2 (normally open) y sacando un cable mas pequeño del relé de la conexion COM2 al portabombillas.
cable negro: a la conexión NO2 del relé.
cable azul: de la conexión COM2 del relé al portabombillas.Detalle de la conexión de la bombilla al relé

Llegados a este punto, nuestro proyecto ya está operativo. Si enchufas la bombilla a la corriente y enciendes el Yun, cuando termine su proceso de inicio y se ejecute el sketch, pondrá el pin 13 en HIGH, y la bombilla se encenderá.

Dale un ratito más para que se inicie el servidor web de Linino (tarda un poco más que el sketch), y haz la siguiente petición en un navegador:

http://ip_arduino/arduino/digital/13

Obtendrás la siguiente información: Pin D13 set to 1.

Si ahora en el navegador haces la petición:

http://ip_arduino/arduino/digital/13/0

la bombilla deberia apagarse.

Ya podemos encender una lampara desde un navegador web. El siguiente paso es hacer una pequeña aplicación de Android que nos permita hacerlo desde nuestro teléfono móvil.

La Aplicación Android.

Vamos a crear una aplicación de android muy sencilla, que consistirá en una Actividad que contendrá un ToggleButton. Al crear la actividad, comprobaremos en que estado está el pin 13, y en función de ello estableceremos el estado de nuestro ToggleButton en on o en off.

Cuando el usuario pulse el botón, enviaremos una petición rest a nuestro Yun, indicándole que encienda o apague.

Aquí teneis la actividad principal:

package com.hell_desk.ejemployunrest;

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ToggleButton;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import java.io.ByteArrayOutputStream;

public class Inicio extends Activity {

public static final String TAG = "Inicio";
 private String web_service = "http://pon_aqui_tu_ip/arduino/digital/13";
 private ToggleButton tb_on_off;
 private boolean rele_on = false;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_inicio);
 tb_on_off = (ToggleButton) findViewById(R.id.toggleButton_on_off);

/*Interrogamos a yun por el estado del pin13, para saber
 si la bombilla esta encendida o no. La unica dificultad en este caso
 es que una tarea que implique acceso a red no puede hacerse desde el hilo principal,
 asi que tenemos que hacerlo con una tarea asíncrona
*/
 new AsyncTask() {

@Override
 protected Void doInBackground(Void... params) {
 HttpClient httpclient = new DefaultHttpClient();
 try {
 HttpResponse response = httpclient.execute(new HttpGet(web_service));
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 response.getEntity().writeTo(out);
 out.close();

String respuesta = out.toString();
 //Si todo ha ido bien, recibiremos una respuesta del tipo "Pin D13 set to X\r\n"
 //donde X será 0 o 1

if (respuesta.endsWith("0\r\n")) {
 rele_on = false;
 } else {
 rele_on = true;
 }

} catch (Exception e) {
 e.printStackTrace();
 }

return null;
 }

@Override
 protected void onPostExecute(Void aVoid) {

actualizaEstadoBoton();
 }
 }.execute();
 }

private void actualizaEstadoBoton() {
 if (rele_on) {
 tb_on_off.setChecked(true);
 } else {
 tb_on_off.setChecked(false);
 }
 }

public void click(View v) {
 /*Cuando el usuario hace click en el boton, hacemos una
 rele_on, añadimos el sufijo /0 o /1 segun tengamos que encenderlo
 o apagarlo
 */

new AsyncTask() {

@Override
 protected Void doInBackground(Void... params) {
 HttpClient httpClient = new DefaultHttpClient();
 rele_on = !rele_on;

String aux = (rele_on) ? "1" : "0";
 aux = web_service + "/" + aux;
 HttpGet httpget = new HttpGet(aux);
 Log.i(TAG, aux);

try {
 httpClient.execute(httpget);
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 }.execute();
 }

}