RaPi - Acceso remoto

Para poder sacar un poco de cables del medio y liberar la televisión del cuarto donde tengo conectada la RaPi por HDMI, decidí configurar el acceso remoto, para poder manejarla directamente desde la notebook.

No es lo mas rápido del mundo y tengo alguna incompatibilidad de teclados que hace que ciertos simbolos se me compliquen, pero permite ver un poco de tele mientras tanto...

De paso también instalé el samba que me permite compartir archivos desde la computadora a la Raspberry Pi y viceversa lo que es muy útil por ejemplo para chequear los archivos de configuración del openHab con el Designer que tengo instalado en mi computadora con Windows.

Configurar acceso remoto

El primer paso es chequear desde la configuración de la RaPi el nombre del host (por defecto es raspberrypi)

Desde la RaPi también, pasar a instalar los siguientes componentes:

sudo apt install -y tightvncserver
 * la opcion -y contestará sí a todas las preguntas, si se prefiere mas control se puede obviar
sudo apt install -y xrdp


Una vez instalados los tres, probar la conexión desde Windows haciendo un ping raspberrypi (o el nombre que tenga la Raspberry).

Abrir el programa Remote Desktop Connection. Seleccionar el nombre de la raspberry y al abrir la conexión ingresar nombre de usuario y password (por defecto pi y raspberry)

Así ya podemos usar la Raspberry desde una computadora con Windows conectada a la misma red, sin necesidad de conectarle monitor, teclado ni mouse.

Para crear un directorio compartido:

Desde la Rapi, instalar samba:
   sudo apt install -y samba
Crear carpeta llamada share:
   mkdir ~/share
Configurar samba, modificando el archivo smb.conf :
 sudo nano /etc/samba/smb.conf
y agregar lo siguiente:

 [PiShare]

   comment=Raspi Share

   path=/home/pi/share

   browseable=Yes

   writeable=Yes

   only guest=No

   create mask=0740

   directory mask=0750

   public=no

Crear un usuario pi para acceder desde windows:

$ sudo smbpasswd -a pi

Solicitara ingresar y confirmar una password.

Nota: el mismo comando puede usarse para cambiar la password en caso de que, por ejemplo... se olvide :)

Acceder desde Windows al directorio compartido

TeclaWindows+R para abrir nueva ventana
//raspberry
usuario: raspberrypi\pi
contraseña: la que se creo recien

Listo! No solo puedo acceder a la Rapi en forma remota sino que puedo intercambiar archivos a través de un directorio/carpeta compartida.

Próximos pasos

Para ir juntando todo, los próximos pasos son:

- Configurar el Esp8266 para que publique mensajes MQTT
- Agregarle un sensor de temperatura y que publique esa informacion por MQTT cada x tiempo
(Probar el circuito completo con openHab como se configuró aca)
- Encontrar como dar energía autonoma al esp8266
- Hacer unas pruebas con el esp8266 07 que tiene mas pines disponibles para hacer un sensor autónomo mas potente
- Hacer el post explicando como funciona el binding del clima en openHab

- Hacer una prueba con un relay para encender algo a traves de openHab
- Configurar el binding que permita manejar el openHab a traves de comandos de voz de Siri

Así que hay trabajo de sobra...

Arduino - Cargando un programa en el esp8266

Una de las características del módulo esp8266 es que además de poder usarlo para conectar por WiFi un Arduino, se le puede agregar un programa directamente al módulo que realice alguna función directamente.

La buena noticia es que para pasar un programa al esp8266 se puede usar el IDE de Arduino directamente!

Para instalar el soporte para módulo ESP8266:
  - Agregar la siguiente dirección en "File -> Preferences -> Additional Boards Manager URLs":
       http://arduino.esp8266.com/stable/package_esp8266com_index.json
  - Abrir "Tools -> Board -> Board Manager" y clickear en install en el ESP8266

Solo hay que tener cuidado con las conexiones y entender que los módulos ESP8266 tienen dos modos, un modo que permite cargarles programas y un modo que los ejecuta. Para setear en que modo queremos trabajar podemos usar un programa de Arduino.

El modelo que tengo yo es el ESP01, para el cual hay que poner el pin GPIO en low y resetear para entrar al modo flash y cree un sketch que permite ponerlo en un modo u otro, encendiendo un led azul cuando esta en modo flash.

//sketch para cargar firmware a ESP8266 por medio de Arduino
int ch_pd = 3;
int io0 = 2;
// Seteo de otros pines ESP8266-> Arduino
// VCC -> 3,3 Arduino
// TX -> TX (1) Arduino
// RX -> RX (0) Arduino
// GND -> GND Arduino

void setup() {
  pinMode(ch_pd, OUTPUT);
  pinMode(io0, OUTPUT);
  pinMode(8, OUTPUT);
  digitalWrite(io0, LOW); //-> Manda 0 al GPIO0 para poner en modo Flasheo
  //digitalWrite(io0, HIGH);   //-> Manda 1 al GPIO0 para sacar el modo Flasheo
  digitalWrite(ch_pd, LOW);
  delay(1000);
  digitalWrite(ch_pd, HIGH);
  if (digitalRead(io0)==LOW){
    //Modo Flash
    digitalWrite(8,HIGH);
    } else {
    digitalWrite(8,LOW);
    }
}

void loop()
{

}

Este sketch se carga primero asi como está seleccionando como Board en mi caso Arduino Uno.

Una vez que está cargado (el led en el pin 8 se prende), se puede cargar un sketch para el ESP8266, como este básico de blink que viene como ejemplo (aparece al seleccionar el esp8266 como Board) que hace parpadear la luz azul del esp8266) pero seleccionando Generic ESP8266 Module como Board.

Hay que tener en cuenta que para que funcione hay que sacar el modo flash, para lo cual se puede usar el mismo sketch de modo flasheo pero modificando la siguiente linea. Hay que recordar volver a setear el board como Arduino Uno, porque sino se estaría intentando enviar el programa al ESP8266 en vez de setear los pines.
digitalWrite(io0, HIGH);   //-> Manda 1 al GPIO0 para sacar el modo Flasheo

Si todo funciona bien la luz azul del esp8266 debería empezar a parpadear y ya estamos listos para seguir!

Aclaración: en muchos lados lei que el Arduino Uno no alcanza para proveer la energía que necesita el esp8266 pero la verdad por ahora no tuve problemas en hacerlo arrancar y cargarle programas solamente con el Arduino Uno conectado por el USB a la computadora. 

RaPi - Instalando y probando el binding MQTT

El objetivo era instalar, configurar y probar el binding MQTT que va a permitir que cada sensor o grupo de sensores envie su estado al openHab. Para probar voy a configurar un item simulando la información que enviaría un sensor de temperatura ubicado en la cocina. Básicamente los pasos son los mismos para configurar cualquier binding.

Paso 1: Instalar binding

El primer paso consiste en instalar el binding de MQTT en openHab. Lo que yo hice fue mover el archivo org.openhab.binding.mqtt-1.8.3.jar a mi carpeta de addons (/opt/openhab/addons) desde la carpeta alladdons donde tengo todos guardados.

Paso 2: Configurar openHab

El segundo paso es configurar en openhab.cfg la direccion del broker. En mi caso como mosquitto corre en la misma raspberry y por ahora no tiene nada de seguridad, fue fácil:

 mqtt:broker:url=tcp://localhost:1883

* para abrir el archivo de configuración desde la Rapi, hay que pararse en el directorio donde esta guardado y usar sudo nano
   cd /opt/openhab/configurations
   sudo nano openhab.cfg
Para guardar los cambios se usa Ctrl+O y para cerrar la ventan Ctrl+X

Paso 3: Agregar items

Una vez cambiada la configuración hay que agregar los items necesarios en el archivo de items el que recibe la información especificando:

direction: < para recibir mensajes
broker: alias del broker especificado en la configuracion
topic: topico al que se suscribe
type: tipo de mensaje que se recibe, puede ser
state : actualización de estado
command: comando
transformation: regla que define como transformar el mensaje en algo que openHab reconozca.
default
transformation name > cualquiera de los definidos en org.openhab.core.transform.bundle
regex_filter: texto que representa una expresión regular para filtrar mensajes

Item myItem {mqtt="<direction>[<broker>:<topic>:<type>:<transformer>:<regex_filter>], <direction>[<broker>:<topic>:<type>:<transformation>], ..."}

En mi caso solo configuré un item de prueba:

Number MQTT_Tempe "Temperatura Cocina [%.1f °C]" <temperature> {mqtt="<[broker:tempe/cocina:state:default]"}

Para más información hay ejemplos de salida y entrada en la wiki del binding

* para abrir el archivo de items, se usa también sudo nano pero desde la carpeta /opt/openhab/configurations/items

Paso 4: Ajustar sitemap

El cuarto paso consiste en agregar ese item en el sitemap, yo lo agregué en uno casi vacío que se llama casa (tengo ese y el demo), donde configuré también el binding de weather.

Simplemente agregué en /opt/openhab/configurations/sitemaps/casa.sitemap la siguiente línea:

    Text item=MQTT_Tempe

Recuerden chequear que las mayusculas y minúsculas esten iguales... les puede pasar que pongan MQTT_tempe en un lado y MQTT_tempe en otro y no funcione...

Paso 5: Probar!

Con esto configurado, y con openhab y mosquitto corriendo en la Raspberry, solo quedaba probar a publicar un mensaje al tópico tempe/cocina del broker (desde la aplicación MQTTool) y ver si lo recibía...


Funcionó! Desde la ventana de openHab en la RaPi se puede ver la siguiente información:

2016-10-26 09:47:30:182 [INFO ] [runtime.busevents   ] - MQTT_Tempe state updated to 32  

Arduino - Conectando y probando el ESP8266

El desafío de la semana consistió en lograr hacer arrancar exitosamente el módulo ESP8266 (que permite conectarse  a redes WiFi) conectado a un Arduino Uno, cosa que hace un tiempo al momento de comprarlo no había resultado... A veces es bueno tomarse un tiempo y volver a armarlo porque ves cosas que no habías visto antes!

Arranqué conectando el módulo al Arduino Uno de esta forma:



El GND del ESP8266 a un pin GND del Arduino
El TX del ESP  al pin 2 del Arduino
El RX del ESP al pin 3 del Arduino
EL RST y el VCC al 3,3v del Arduino

Cargué un sketch básico para lograr la comunicación y probar los primeros comandos AT:

#include <SoftwareSerial.h>

SoftwareSerial ESP8266(3, 2); // RX | TX

void setup()

{  Serial.begin(9600);

     ESP8266.begin(9600);

  }

void loop()

  {  

     if (ESP8266.available())

         { char e = ESP8266.read() ;  // lee lo recibido del modulo ESP

           Serial.print(e);           // lo escribe en el monitor 

         }

     if (Serial.available())

         {  char s = Serial.read();   // lee lo escrito en el monitor

            ESP8266.print(s);         // lo manda al módulo ESP

         }

   }

Una vez cargado abrí el Serial Monitor, configurado a 9600... y nada... Siguiendo varias recomendaciones de soluciones de problemas, desconecté y volví a conectar la alimentación del módulo (lo que sale del 3,3v del Arduino) pero a lo sumo conseguí ver caracteres extraños.

Seguí investigando y encontré que de acuerdo al modulo puede variar la velocidad a la que trabaja. Probé cambiando la velocidad del Serial Monitor pero no hubo ninguna mejora... Hasta que me di cuenta que lo que tenía que hacer es cambiar la velocidad en el sketch!

#include <SoftwareSerial.h>                                                                                 
SoftwareSerial ESP8266(3, 2); // RX | TX                                 
void setup() {                                                            
 Serial.begin(115200);                                                    
 ESP8266.begin(115200);                                                   
}                                                                        
void loop()   {                                                                                                 
 if (ESP8266.available())          {                                      
  char e = ESP8266.read() ;  // lee lo recibido del modulo ESP            
  Serial.print(e);           // lo escribe en el monitor                  
 }                                                                        
 if (Serial.available())          {                                       
  char s = Serial.read();   // lee lo escrito en el monitor               
  ESP8266.print(s);         // lo manda al módulo ESP                     
 }                                                                        
}                                                                         

Con eso logré que finalmente se conecte el "modulito", aunque no recibi el ready que esperaba sino un ioavailable.

A partir de eso, desde el Serial Monitor, empecé a pasarle distintos comandos AT.

Para empezar AT para testear que funcione el sistema AT, recibo como respuesta OK, asi que seguimos...

Básicamente los comandos AT pueden tener 4 variantes (no todas aplican a todas):

Setea	Consulta	Testea modos posibles	Ejecuta
AT+<x>=<…>	AT+<x>?	AT+<x>=?	AT+<x>

Las que yo utilicé son:

AT+GMR -> devuelve la version del firmware del módulo
AT+CWLAP -> lista las conexiones de WiFi disponibles
AT+CQJAP="ssid","password" -> se conecta a la red ssid con la contraseña password
AT+CIPMUX=1 -> habilita conexiones multiples
AT+CIPSERVER=1,80 -> activa un servidor web en el puerto 80
AT+CIPSTA? -> devuelve la dirección IP del módulo

Una vez obtenida la dirección IP se puede conectar a la misma a través de cualquier explorador de internet (de una maquina conectada a la misma red). Se observará en el monitor serial que se reciben datos de la conexión que después se podrían parsear para recibir comandos.

Pero eso lo dejamos para la próxima!

RaPi - Instalando y testeando el broker MQTT

Investigando un poco sobre las formas de transmitir información de la forma mas liviana y simple posible en mi futuro sistema domótico, me encontré con el protocolo MQTT. Este protocolo de comunicación o transmisión de mensajes maquina a maquina permite el intercambio de mensajes que tienen poco peso mediante un sistema de suscripción a tópicos.

Un sistema de comunicación MQTT cuenta con un broker o server que es el que recibe los mensajes y los retransmite a quienes se hayan suscripto al tópico que se referencie. Además existen clientes que o publican mensajes con un determinado tópico o se suscriben para recibir mensajes de uno o mas tópico.

Mas adelante trataremos de configurar openHab como cliente para publicar o suscribirse a determinados tópicos pero para empezar, y en lugar de utilizar un servidor MQTT web (hay pagos y gratuitos) vamos a instalar y configurar Mosquitto en la misma Raspberry Pi.

Los primeros pasos son necesarios para poder bajar la ultima versión disponible en mosquitto.org:

wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
sudo apt-key add mosquitto-repo.gpg.key
cd /etc/apt/sources.list.d/
sudo wget http://repo.mosquitto.org/debian/mosquitto-wheezy.list
sudo apt-get install mosquitto

Solamente con esto ya tenemos el servidor MQTT corriendo en nuestro puerto 1883.

Para probarlo usé la herramienta gratuita MQTTool:

Configuracion de los datos de IP de la Rapi y puerto

Una vez conectada, me suscribi desde la pestaña Subscribe al tópico tempe/+, que es suscribirte a cualquier tópico que este bajo la jerarquía de tempe. Desde la pantalla de Publish, publiqué un mensaje en el tópico tempe/cocina y se puede ver en la última captura como lo recupero!

Publicar mensaje en tempe/cocina

Recibir todos los mensajes bajo tempe

Cuando quise hacer otra prueba otro día, no lo logré hasta que descubrí que la IP de la Raspberry había cambiado, así que voy a investigar si es posible usar el nombre en lugar de la IP para no tener esos problemas...

Próximo paso: configurar el binding MQTT en openHab para que recupere información publicada en ciertos tópicos.

RaPi - Instalando OpenHab

El principal objetivo para la Raspberry Pi va a ser usarla como servidor openHab por lo que una vez actualizada, el paso siguiente iba a ser efectivamente bajarlo e instalarlo.

Antes de instalarlo, cree una carpeta donde guardar el archivo .zip usando el comando

sudo mkdir /opt/openhab

y bajé a esa carpeta la ultima version del runtime de la pagina de openHab, con el comando wget, la que luego extraje ahí mismo con unzip y procedí a borrar el zip original usando rm.

(ojo que el atajo para hacer el paste del link copiado de internet en la Rapi es Shift+Ctrl+V)

En mi caso, como la última versión estable disponible era la 1.8.3, fue:

cd /opt/openhab

sudo wget https://bintray.com/artifact/download/openhab/bin/distribution-1.8.3-runtime.zip

sudo unzip distribution-1.8.3-runtime.zip

sudo rm distribution-1.8.3-runtime.zip

Esto terminó de instalar openHab pero para que realmente funcione hay que instalar lo que se llama Bindings o paquetes opcionales que permiten conexiones a distintos tipos de artefactos o extender la funcionalidad de openHab, en el directorio addons (que se crea durante la instalación). De nuevo hay que copiar la dirección de la última versión del sitio de openHab.

cd addons

sudo wget https://bintray.com/artifact/download/openhab/bin/distribution-1.8.3-addons.zip

Por ahora no voy a extraer los addons porque para hacer la primera prueba voy a instalar la demo de openHab que incluye los addons necesarios.

Primero, siguiendo las instrucciones del sitio de openhab, hay que crear una copia del archivo de configuración que viene por default.

cd /opt/openhab
sudo cp configurations/openhab_default.cfg configurations/openhab.cfg

En ese mismo directorio de openhab voy a  instalar la demo

sudo wget https://bintray.com/artifact/download/openhab/bin/distribution-1.8.3-demo.zip
sudo unzip distribution-1.8.3-addons.zip

Ahi me pregunta si quiero reemplazar algunos archivos y contesto que sí a todos (A). Una vez extraídos todos los archivos, borro el zip.

sudo rm distribution-1.8.3-addons.zip

Y ahora sí, listo para ejecutar openhab, desde el directorio opt/openhab/ ejecuto el script start.sh

sudo ./start.sh

Para ver la demo dede la Rapi, abrir una ventana del explorador y acceder a:

localhost:8080/openhab.app?sitemap=demo

Demo vista desde el navegador de la Rapi

Para verlo desde otra computadora o celular, de la red, conociendo la ip de la Raspberry (se puede obtener con el comando hostname -I)

http://192.168.0.14:8080/openhab.app?sitemap=demo

Demo vista desde el celular