nanolec

Google Assistant en Orange Pi Zero

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 25 Nov 2018 21:48:00 +0100

Google Assistant en Orange Pi Zero (I)

En el artículo de hoy vamos a ver cómo utilizar nuestra Orange Pi Zero [casi] como un dispositivo Google Home por muy poco dinero.

Con la guerra abierta que hay a fecha de hoy con los llamados asistentes virtuales, las empresas competidoras como Amazon, Google, Apple y otras hacen lo posible por imponer su producto como un nuevo estándar en este campo.

En un intento de expandir al máximo su asistente (Google Assistant), Google ha puesto a disposición de la comunidad desarrolladora una serie de APIs y librerías que nos permiten poner en funcionamiento su asistente en cualquier plataforma que cumpla con estos requisitos básicos:

Un intérprete de Python.
Una conexión a internet.
Un altavoz.
Un micrófono.

Como experimento me planteo montar el asistente en una Orange Pi Zero, que gracias a su bajo precio y pequeño tamaño nos permitirá disponer de un dispositivo eficiente, pequeño y de bajo consumo.

Sin embargo, dados los requerimientos, este artículo se puede aplicar en principio a cualquier otra placa o dispositivo que cumpla con los requisitos especificados: un PC x86, una Raspberry, una Banana Pi, etc.

Básicamente, hay dos enfoques que podemos tomar para montar nuestro asistente, de menor a mayor funcionalidad. Es lo que veremos en los puntos 1 y 2.

Antes, veamos qué necesitamos comprar o tener de antemano:

Requisitos

Para este proyecto necesitaremos los siguientes requisitos:

Orange Pi Zero.
Obviamente, necesitaremos una placa de desarrollo. Yo he elegido la Orange Pi Zero por su buena relación potencia/precio y porque ya he usado otras para otros proyectos y me gusta. Hay dos versiones de esta placa: la de 256MB de RAM y la de 512MB. Es muy importante comprar la de 512MB porque la otra es insuficiente. Aún así, para el apartado Opción 2 como veremos en el siguiente artículo, tendremos problemas al tener sólo 512MB de memoria.
La placa nos podría valer tal cual, ya que dispone de una fila de terminales GPIO donde podríamos conectarle una salida y entrada de audio. No obstante yo recomiendo comprar, además de la placa, una tarjeta de expansión que lleva ya la salida de audio, un micrófono integrado, un receptor de infrarrojos y dos puertos USB adicionales entre otras cosas.

En China podemos encontrar la Orange Pi Zero principalmente en Banggood y en Aliexpress. A continuación pongo un par de enlaces con el paquete completo (placa principal de 512MB + tarjeta de expansión + caja), con los precios a 17/11/2018. Puntualmente se encuentran ofertas mejores, pudiendo salir el paquete completo por unos 14€:
- Banggood (20,53 €).
- Aliexpress (19,73 €).
En teoría, se pueden encontrar también por Amazon, pero el precio sube considerablemente.
Disipadores.
La Orange Pi Zero incorpora un procesador Allwinner H2+, y se calienta bastante (en condiciones normales se puede poner en 70ºC perfectamente). Es muy recomendable ponerle un disipador al menos al procesador (hay quien también se lo pone a la memoria).

Aconsejo comprar uno estos kits que traen 3 disipadores y son muy baratos. Hay que tener en cuenta que no es lo mismo tener la placa al aire que metida dentro de una caja tan pequeña. Los disipadores llevan un adhesivo de doble cara y simplemente se pegan sobre el procesador o la memoria, según su tamaño.
- Banggood (1,09€).
- Banggood (0,87€). Estos son para Raspberry, pero nos valen perfectamente.
- Aliexpress (1,54€). Es una sola unidad, en cerámica (supuestamente mayor disipación).
Micrófono USB.
Es verdad que, como he dicho antes, la placa de expansión lleva un micrófono integrado, pero al parecer es de muy poca calidad. Yo recomiendo comprar un pequeño micrófono USB que, si bien no es una maravilla, tiene bastante sensibilidad y funciona perfectamente. Además es muy barato:
- Aliexpress (1,75€)
Alimentación.
Finalmente, nos hará falta alimentar la placa. La toma de alimentación es microUSB, de manera que podremos hacerlo con cualquier alimentador de móvil o tablet más o menos potente. Lo recomendable es un alimentador de 2A o superior. De todos modos, yo tengo una Orange alimentada en un puerto USB de un router desde hace 2 años sin problemas…

Preparación del altavoz

Instalación del Sistema Operativo.

Lo primero que haremos es instalar un sistema operativo para la Orange Pi. Recomiendo encarecidamente que instaléis armbian. Se trata de una distribución Linux basada en debian para dispositivos ARM de todo tipo, con procesadores Allwinner, Rockchip, FreeScale, etc.

Descarga de armbian

La página de descarga, donde podéis buscar una distribución para vuestro dispositivo específico, es la siguiente:

https://www.armbian.com

Grabación en SD

Una vez descargada la imagen, la grabamos en una tarjeta microSD por medio del programa Etcher (si trabajamos desde WIndows). En caso de trabajar desde Linux podemos hacer lo mismo con las herramientas del sistema o por medio del comando dd.

Instalación del sistema

Con nuestra microSD grabada, la introducimos en la Orange y arrancamos. Ya que la Orange Pi Zero no tiene salida de vídeo HDMI, no podremos conectarle un teclado y empezar a teclear comandos. Yo lo que hago en estos casos es lo siguiente:

Le conecto un cable de red a la toma ethernet RJ45 para conectarla a la red.
En el móvil, utilizo la app Fing para comprobar qué dirección IP le ha asignado el router.
Una vez que tengo la IP, desde cualquier ordenador accedo mediante protocolo ssh con algún programa como putty o Xshell (gratuíto para usuarios domésticos y escolares).
El usuario a utilizar es root, y la contraseña 1234.

La primera vez que arranca, armbian nos pedirá que cambiemos la contraseña de root y nos pedirá los datos de un usuario normal (no root) que creará con privilegios de sudo.

Configuración básica

Una vez iniciado por primera vez el sistema, recomiendo configurar lo siguiente:

Conexión WIFI

Podemos tener un altavoz inteligente conectado a una toma de red, pero la mayoría de la gente normalmente querrá tenerlo conectado de forma inalámbrica a la WIFI. Por tanto, lo más fácil será ejecutar el comando:
```
nmtui
```
Elegiremos la opción “Activate a connection”

y después elegiremos la red a la que nos queremos conectar. Una vez seleccionada, nos pedirá la contraseña .
Personalización.
Finalmente, ejecutamos:
```
sudo armbian-config
```
entramos en la opción “Personal” y configuramos cosas básicas como:
- La zona horaria. Normalmente elegiríamos Europe/Madrid.
- Los locales. Normalmente añadiríamos aquí es_ES.utf8, fijándolo por defecto para que nos salgan los mensajes y otras cosas en español.
- La disposición del teclado. Elegimos uno con caracteres españoles.
- El hostname. Por defecto es orangepizero, podríamos cambiarlo por el que queramos.
Y ya está todo configurado.

Creación del proyecto de Google.

Una vez que tenemos la placa ya configurada, vamos a entrar en materia. Este tutorial está parcialmente basado en las guías que Google publica en su página para desarrolladores:

https://developers.google.com/assistant/sdk/

Lo primero que necesitaremos es crear un proyecto en la nube de Google Actions. Para ello, en nuestro navegador vamos a la siguiente dirección:

https://console.actions.google.com/

En esta página pulsamos “Add/import project“ y rellenamos el nombre del proyecto, el idioma (Spanish) y el país (Spain).

Una vez creado el proyecto, nos vamos a la parte inferior de la página y pulsamos el botón “Device Registration“.

Dejamos la página actual tal cual sin cerrar porque después tendremos que volver a ella.

Credenciales de acceso

Ahora abrimos otra pestaña en el navegador y nos vamos a la consola para desarrolladores de Google:

https://console.developers.google.com

En esta página, antes que nada, nos aseguraremos de que tenemos seleccionado el proyecto que hemos creado en Google Actions. Una vez seleccionado el proyecto, nos vamos a la opción Biblioteca (en la parte izquierda) y localizamos “Google Assistant API”. Nos aparecerá una página tal como esta:

En dicha página pulsaremos el botón Habilitar.

Una vez habilitada, hay que crear unas credenciales de acceso. Para ello, en la parte izquierda pulsamos en Credenciales y después en la pestaña “Pantalla de consentimiento de OAuth“.

En esta pantalla básicamente rellenaremos el nombre de la aplicación o proyecto y el email de contacto. Una vez rellenos estos datos guardamos la credencial pulsando el botón Guardar que está al final de la página.

Acceso a tu actividad

Para poder utilizar el asistente, es necesario que activemos la compartición de la actividad asociada a nuestra cuenta de Google. Para ello, nos vamos a la siguiente dirección:

https://myaccount.google.com/activitycontrols

e iniciamos sesión con nuestra cuenta de Google. En esta página nos aseguraremos de tener marcadas las siguientes opciones:

Actividad en la Web y en Aplicaciones.
Incluye el historial de Chrome y la actividad que se realiza en sitios web, aplicaciones y dispositivos que utilizan los servicios de Google.
Información del dispositivo.
Actividad de Voz y Audio.

Registro del dispositivo

Volvemos a la pestaña que dejamos abierta antes (la de Google Actions) y vamos a asociar un dispositivo al proyecto. Para ello pulsamos el botón Register Model.

En esta ventana, rellenaremos un nombre para el dispositivo, el fabricante (cualquiera vale) y el tipo de dispositivo. En mi caso, siempre elijo Speaker puesto que se trata de un altavoz.

Pulsamos de nuevo el botón Register Model y avanzamos a la siguiente ventana, donde deberemos pulsar el botón Download OAuth 2.0 credentials. Al pulsar dicho botón descargaremos un fichero en formato json con las credenciales del dispositivo que acabamos de registrar. Lo guardaremos a buen recaudo porque más tarde lo necesitaremos.

Finalmente, avanzamos y en la siguiente ventana pulsamos el botón Save Traits.

Con esto queda toda la preparación terminada.

En el siguiente artículo veremos cómo poner en marcha el asistente, con dos opciones en función de nuestras necesidades.

Acceso mediante SSH sin contraseña

noreply@blogger.com (Isidoro Aguilar Baeza) — Thu, 31 May 2018 22:45:00 +0200

Una de las cosas que más veces he tenido que hacer, dado que soy un forofo de la automatización, es poder entrar desde una máquina a otra de forma automática.

SSH

El protocolo SSH (Secure SHell) nos permite entrar en una máquina remota de forma segura (a diferencia de su hermano mayor, telnet) mediante una línea de comandos sobre una red no necesariamente segura.

Los datos que se envían y se reciben por medio de este protocolo se encriptan mediante un par de claves pública y privada, de manera que aunque alguien “esnife” nuestra red, no podrá interpretar qué comandos estamos lanzando ni qué resultados nos devuelve la máquina remota.

Para conectar desde una máquina A a otra máquina B, necesitamos en A un cliente de SSH y en B un servicio de servidor de SSH. Si nuestros sistemas no traen de serie estas utilidades, deberíamos poder instralarlas mediante el correspondiente sistema de paquetes (openssh-client y openssh-server respectivamente).

Normalmente, accederemos a la máquina remota de forma interactiva, tecleando un usuario y una contraseña, de la misma manera que lo haríamos si utilizásemos una consola local en dicha máquina. Para ello, lógicamente, deberemos utilizar las credenciales de un usuario existente.

Automatización

Pero ¿qué pasa si lo que queremos es entrar de forma “no interactiva” en la máquina remota?. SSH nos obliga siempre a teclear al menos una contraseña, aunque podemos evitar teclear el usuario de la siguiente forma:

$ ssh usuario@maquinaremota

La única solución viable que tenemos es utilizar claves criptográficas en lugar de usuarios para acceder. El principio es el siguiente:

En la máquina A nos creamos una pequeña infraestructura PKI con un par de claves: privada y pública.
Compartimos con la máquina B nuestra clave pública.
Accedemos de A a B encriptando ciertos datos por medio de nuestra clave privada.
La máquina B intenta desencriptar mediante la clave pública que le proporcionamos inicialmente los datos que acabamos de encriptar por medio de nuestra clave privada.
Si la desencriptación tiene éxito, se nos concede el acceso.

Secuencia

Esta forma de acceder mediante ssh está ampliamente documentada literalmente en miles de páginas de internet, pero de lo que se trata es de tener un pequeño “chuletario” rápido para tenerlo aquí para cuando nos haga falta.

La secuencia de comandos a utilizar, suponiendo que estamos en una máquina A y queremos acceder a otra máquina remota B, es la siguiente:

Generar una pareja de claves criptográficas.
En la máquina A generamos un par de claves con el siguiente comando:
```
$ ssh-keygen -t rsa
```
El comando tardará un rato en generar el par de claves y nos pedirá dos veces que especifiquemos una contraseña, que dejaremos en blanco (pulsando enter) ambas veces.
El parámetro -t especifica el tipo de encriptación que utilizaremos. Pueden ser otros como dsa, ecdsa, etc, pero lo más normal es utilizar rsa.
Este comando nos va a crear en el directorio home del usuario actual (/home/usuario en caso de un usuario normal o /root en caso del usuario superadministrador) un directorio oculto de nombre .ssh con el siguiente contenido:
```
id_rsa
id_rsa.pub
```
El primero es nuestra nueva clave privada, y el segundo la clave pública. Ambas claves criptográficas nos permiten cifrar con una y descifrar con la otra.
Copiar la clave pública.
Nuestra clave privada permanecerá siempre guardada en nuestra máquina A, pero la pública tenemos que trasladarla a la máquina de destino a la que querremos conectar.
Para ello, primero haremos lo siguiente:
```
$ ssh usuarioB@maquinaB
```
Con esto estamos accediendo a la máquina B con el usuario usuarioB de forma interactiva. Se nos pedirá la contraseña del usuarioB y a continuación nos aseguraremos de que tenemos un directorio .ssh en su home:
```
$ mkdir .ssh
$ chmod 700 .ssh
$ exit
```
Una vez creado el directorio (hemos vuelto a A con el exit), copiamos nuestra clave pública concatenándola con lo que haya en el fichero authorized_keys de dicho directorio de B:
```
$ cat id_rsa.pub | ssh usuarioB@maquinaB 'cat >> .ssh/authorized_keys'
```
Este fichero contendrá todas las claves públicas autorizadas a entrar en esta máquina y este usuario sin contraseña.
Entrar sin contraseña.
Una vez que hemos hecho lo anterior, ya podemos entrar desde A a B utilizando de nuevo el sigiuiente comando:
```
$ ssh usuarioB@maquinaB
```

A partir de ahora ya no nos pedirá contraseña.

Instalación de HomeAssistant mediante PyEnv

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 27 May 2018 21:53:00 +0200

Cuando uno empieza a entrar en el mundo de la domótica “casera” (nunca mejor dicho), no a base de utilizar productos comerciales sino haciéndolo todo uno mismo, lo primero que piensa es en la Raspberry Pi.

Yo, sin embargo, en mi afán de gastar lo mínimo posible comprando productos en China, decidí en un principio utilizar la Orange Pi Zero como mi controlador principal para HomeAssistant, como vimos en un artículo anterior.

Problemática

En realidad, uno puede instalar HomeAssistant en cualquier ordenador o controlador: un equipo Mac, Windows, Linux, un core I7 de última generación o un ARM con 256 MB de RAM, siempre y cuando sea posible instalarle Python.

Sin embargo, apartarse del estándar utilizado por la mayoría tiene su penalización.

Si tienes una Raspberry PI, basta con acudir a la página de HomeAssistant y bajarte una distribución de Linux especial personalizada (hass.io o hassbian) y grabarla en tu tarjeta SD para salir andando. Ambas distribuciones están pensadas para que el usuario trabaje lo mínimo, sea fácil actualizar, esté todo optimizado, etc.

Pero ¿qué pasa cuando tu distribución, que no es la estándar, se queda anticuada y los requerimientos de versiones de HomeAssistant van subiendo y no tienes posibilidad de actualizar?. De todos es sabido que las distribuciones de Linux tienen una gran ventaja que son los repositorios de software (debian, ubuntu, rpm, etc) desde los que el usuario siempre puede instalarse el software sin tener que buscar en ningún sitio más. Esta gran ventaja sin embargo se convierte en un gran inconveniente cuando los paquetes del repositorio se quedan antiguos y no se pueden actualizar más.

Tal es el caso de la Orange Pi Zero, para la cual disponemos de varias versiones (aquí y aquí) de Linux pero todas ellas basadas en un repositorio de Debian que no es el más nuevo.

Esto es un problema cuando los requerimientos de HomeAssistant subieron por ejemplo de Python 3.4 a Python 3.5.3. Este cambio que en principio puede parecer mínimo hace que por ejemplo en la versión de Ubuntu 16.04.04 LTS que es la que yo uso no pueda instalar versiones recientes de HomeAssistant puesto que la versión máxima de Python que hay en los repositorios es la 3.5.2. Lo mismo nos pasaría si tuviésemos un Debian Jessie que no podamos actualizar.

Por tanto, no podemos utilizar versiones “oficiales” de Python. ¿Qué soluciones nos quedan?

A bote pronto, se me ocurren tres:

Utilizar un repositorio PPA.
He consultado varios y o bien no contienen software para procesadores ARM o bien no funcionan con mi distribución.
Compilar Python 3.5. desde *código fuente.
Es una posibilidad, pero bastante engorrosa.
Utilizar PyEnv.
Este entorno nos permite tener múltiples instalaciones de Python en paralelo sin interferir con los paquetes “oficiales” del sistema.

Por tanto, elegiremos la tercera opción por ser la menos “invasiva” para no liarla con el sistema.

Guía de instalación

Esta guía está pensada para instalar la última versión de HomeAssistant desde cero, en un sistema (Debian Jessie, Ubuntu 16.04, etc) que no soporte de forma nativa la última versión de Python. En caso de tener ya un sistema con HomeAssistant instalado, habría que saltarse algunos pasos.

Crear el usuario homeassistant

Lo primero que necesitaremos (si no lo tenemos ya) es crear un usuario específico para ejecutar HomeAssistant. En los ejemplos de este artículo lo denominamos homeassistant, pero el nombre es lo de menos.

Para ello, seguiremos los siguientes pasos:

Entramos como root en el sistema y creamos un nuevo usuario:
```
# adduser homeassistant
```

Lo añadimos al grupo sudo:

# apt-get install sudo
# usermod -aG sudo homeassistant

Instalar PyEnv

PyEnv nos permite instalar (compilándola) cualquier versión de python de forma no intrusiva en el sistema,
y nos permite especificar con qué versión queremos trabajar de forma global para todo el sistema o para
una aplicación concreta.

Para instalarlo seguiremos los siguientes pasos:

Iniciamos sesión con el nuevo usuario homeassistant.
Descargamos pyenv desde su proyecto en GitHub, creando un directorio .pyenv en el home del usuario:
```
$ git clone https://github.com/pyenv/pyenv.git .pyenv
```

Lo hacemos accesible desde el login, añadiendo al fichero .bashrc las siguientes líneas:

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
if command -v pyenv 1>/dev/null 2>&1; then
 eval "$(pyenv init -)"
fi

Salimos del shell (logout o exit) e iniciamos sesión de nuevo con el usuario homeassistant para que se ejecuten los cambios.
Instalamos una serie dependencias necesarias. HomeAssistant requiere en principio compilar python con soporte para SQLite3:
```
$ sudo apt-get install libsqlite3-dev
```
Instalamos la versión requerida de Python. Lo que hace PyEnv es descargarse los fuentes de la versión requerida de Python y compilarla de forma transparente para el usuario. En este ejemplo instalaremos la versión 3.5.5:
```
$ pyenv install 3.5.5
```
Establecemos la versión global de python del sistema
Para ver qué versión de python utiliza el sistema, utilizaremos este comando:
```
$ pyenv global
```
Para ver qué versiones hay instaladas, utilizaremos este otro:
```
$ pyenv versions
```
Para establecer la versión 3.5.5 como global, utilizaremos este:
```
$pyenv global 3.5.5
```

Configurar entorno virtual

Una vez que tenemos nuevo python en la oficina, lo más apropiado sería crearnos un entorno virtual para la instalación y ejecución de HomeAssistant.

El entorno virtual nos permite independizar las librerías y ejecutables asociadas a un programa del resto del entorno de python del sistema. Una especie de “caja negra” en la que entraremos cada vez que queramos ejecutar la aplicación.

Para este cometido, existe un plugin para PyEnv que se denomina virtualenv:

Instalamos el plugin virtualenv:

$ git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv

Creamos un entorno virtual de python para HomeAssistant:
```
$ pyenv virtualenv 3.5.5 home-assistant
```
El entorno virtual residirá en el directorio /home/homeassistant/.pyenv/versions/home-assistant
Activamos el entorno recién creado:
```
$ pyenv activate home-assistant
```
Tras hacer esto, en el prompt se nos indica el entorno en el que estamos trabajando:
```
(home-assistant) homeassistant@mi-servidor:~$
```
Todos los comandos relativos a python que se ejecuten a partir de ahora sólo afectarán al entorno activo.

Instalar HomeAssistant

Para instalar HomeAssistant en el entorno virtual de Python activo hacemos lo siguiente:

Instalar paquetes adicionales:

Serán necesarios los siguientes paquetes antes de nada:

$ sudo apt-get install libssl-dev openssl libmariadb-dev
$ sudo apt-get install libncursesw5-dev libgdbm-devlibc6-dev
$ sudo apt-get install libffi-dev zlib1g-dev bzip2 libbz2-dev libreadline-de

Instalar librerías necesarias de forma manual. Estas dos librerías nos harán falta para ejecutar HomeAssistant:
```
$ pip3 install mysqlclient
$ pip3 install pyserial
```
Instalar el paquete:
```
$ pip3 install homeassistant
```
Instalar dependencias automáticas:
Una vez instalado el paquete, lanzaremos el ejecutable por primera vez para que se autoinstalen las dependencias de python adicionales necesarias. Este proceso puede tardar un rato y nos presenta el log por la salida estandar:
```
$ hass
```
Una vez que el proceso ha acabado, podemos probar que todo ha ido bien accediendo mediante un navegador a la siguiente URL:
http://[DIR_SERVIDOR]:8123

Instalar el servicio. Para facilitarnos la vida, vamos a crearnos un servicio para poder iniciar y detener a nuestra voluntad el HomeAssistant. Para ello:

Copiamos el siguiente texto en el fichero /etc/init.d/hass:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          hass
# Required-Start:    $local_fs $network $named $time $syslog
# Required-Stop:     $local_fs $network $named $time $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       Home\ Assistant
### END INIT INFO

# /etc/init.d Service Script for Home Assistant

RUN_AS="homeassistant"
export PYENV_ROOT="/home/$RUN_AS/.pyenv"
HASS_ROOT="$PYENV_ROOT/versions/home-assistant"
PRE_EXEC="$HASS_ROOT/bin/python3"
HASS_BIN="$HASS_ROOT/bin/hass"
PID_DIR="/tmp"
PID_FILE="$PID_DIR/hass.pid"
CONFIG_DIR="/var/lib/home-assistant"
LOG_DIR="/var/log"
LOG_FILE="$LOG_DIR/hass.log"
FLAGS="-v --config $CONFIG_DIR --pid-file $PID_FILE --log-file $LOG_FILE --daemon"

start() {
if [ -f $PID_FILE ] && kill -0 $(cat $PID_FILE) 2> /dev/null; then
  echo 'Service already running' >&2
  return 1
fi
echo -n 'Starting service' >&2
local CMD="$PRE_EXEC $HASS_BIN $FLAGS;"
su -s /bin/bash --preserve-environment -c "$CMD" $RUN_AS
if [ $? -ne 0 ]; then
  echo "Failed" >&2
else
  echo "Done" >&2
fi
}

stop() {
if [ ! -f "$PID_FILE" ] || ! kill -0 $(cat "$PID_FILE") 2> /dev/null; then
  echo 'Service not running' >&2
  return 1
fi
echo -n 'Stopping service' >&2
kill $(cat "$PID_FILE")
while ps -p $(cat "$PID_FILE") > /dev/null 2>&1; do sleep 1;done;
rm -f $PID_FILE
echo 'Done' >&2
}

install() {
echo "Installing Home Assistant Daemon (hass)"
update-rc.d hass defaults
mkdir -p $CONFIG_DIR
chown $RUN_AS $CONFIG_DIR
mkdir -p $LOG_DIR
chown $RUN_AS $LOG_DIR
}

uninstall() {
echo "Are you really sure you want to uninstall this service? The INIT script will"
echo -n "also be deleted! That cannot be undone. [yes|No] "
local SURE
read SURE
if [ "$SURE" = "yes" ]; then
  stop
  echo "Notice: The config directory has not been removed"
  echo $CONFIG_DIR
  echo "Notice: The log directory has not been removed"
  echo $LOG_DIR
  update-rc.d -f hass remove
  rm -fv "$0"
  echo "Home Assistant Daemon has been removed. Home Assistant is still installed."
fi
}

case "$1" in
start)
  start
  ;;
stop)
  stop
  ;;
install)
  install
  ;;
uninstall)
  uninstall
  ;;
restart)
  stop
  start
  ;;
*)
  echo "Usage: $0 {start|stop|restart|install|uninstall}"
esac

Le damos permisos de ejecución:
```
$ sudo chmod +x /etc/init.d/hass
```

Iniciamos el servicio, inicializando previamente el fichero de log:

$ sudo touch /var/log/hass.log
$ sudo chown homeassistant:homeassistant /var/log/hass.log
$ sudo service hass start

Una vez probado que funciona correctamente (ver el log en /var/log/hass.log), activamos el arranque automático del servicio, bien mediante la herramienta rcconf o bien mediante el propio servicio:
```
$ sudo service hass install
```

Configuración

La configuración y el directorio de trabajo configurados por defecto están en la ruta:

/home/homeassistant/.homeassistant

El fichero de configuración principal se denomina configuration.yaml.

Actualizaciones

Con este pequeño tutorial hemos instalado la última versión de HomeAssistant en nuestro sistema. En caso de que aparezcan nuevas versiones, siempre y cuando no aumente la versión requerida de Python, podremos actualizar nuestra instalación siempre de esta manera:

Iniciamos sesión con el usuario homeassistant.
Activamos el entorno virtual de python:
```
$ pyenv activate home-assistant
```
Actualizamos a la última versión, deteniendo previamente el servicio e iniciándolo después:
```
$ sudo service hass stop
$ pip3 install --upgrade homeassistant
$ sudo service hass start
```

Dispositivos SonOff en HomeAssistant

noreply@blogger.com (Isidoro Aguilar Baeza) — Tue, 29 Aug 2017 18:29:00 +0200

En este artículo veremos cómo podemos integrar algunos dispositivos SonOff en nuestro HomeAssistant.

Dispositivos SonOff

SonOff es una serie de dispositivos inteligentes fabricados por el fabricante chino Itead que nos permiten de una manera fácil y económica montar un sistema de domótica en nuestra casa.

Casi todos los componentes de esta serie están basados en el chip ESP8266(EX) y algunos de ellos en el más evolucionado ESP8265, y aunque Itead proporciona una aplicación móvil y una nube propia para la gestión de sus dispositivos, se da la circunstancia de que son dispositivos fácilmente modificables para adaptarlos a nuestras necesidades particulares.

¡ATENCIÓN! El simple hecho de cortar el sello de papel que traen los dispositivos para abrir su carcasa hace que invalidemos su garantía. Lógicamente, si cambiamos su firmware ya no podremos obtener ningún soporte del fabricante ni del vendedor.

Los componentes más conocidos y más baratos son los siguientes:

SonOff Basic

Este dispositivo es el más básico y barato de la serie. Se trata de un interruptor Wifi, que en principio sólo nos permite eso: encender y apagar un aparato conectado a él.

Está basado en el SoC ESP8266EX, es de reducido tamaño y dispone de un par de terminales de entrada (vivo y neutro) y otro par de salida, con un relé intermedio que se activa y desactiva por medio del ESP8266 mediante su conexión Wifi. Además tiene un pequeño pulsador que permite activar y desactivar manualmente la conexión del relé y un led que se activa cuando el relé está cerrado.

Pero sin duda, lo más interesante de este dispositivo es que dispone de unos pequeños agujeritos donde, soldando una regleta de 5 pines, podemos acceder a ciertas patillas del SoC pudiendo reprogramarlo a nuestro gusto y conectarle algunos periféricos extra. En la siguiente imagen vemos la disposición de estas conexiones:

Podemos observar las conexiones que tenemos disponibles:

4 conexiones (GND - TX - RX - VCC) que constituyen un puerto serie mediante el cual podemos programar el dispositivo.
1 puerto en la misma línea (GPIO14) en el que podríamos conectar cualquier dispositivo controlable por medio de un solo pin: sensores de temperatura, 1wire, etc.
El pulsador está conectado entre tierra y otro puerto (GPIO0). Si soldamos unos pequeños cables a estos terminales también podríamos hacer uso de este puerto

SonOff POW

Este otro dispositivo es algo más avanzado, permitiéndonos además de encender y apagar, controlar la potencia y el voltaje de la corriente que circula en todo momento por el dispositivo.

El empaquetado es bastante más robusto y es algo más grande. Existen además dos versiones: una de 10 Amperios que nos permite encender y apagar y controlar el consumo de aparatos de hasta 2200W (lámparas, estufas, etc) y otra de 16 Amperios que nos permite hacer lo mismo con aparatos de hasta 3500W (aires acondicionados, lavavajillas, lavadoras, etc).

Al igual que su hermano menor, dispone de una línea con agujeritos para soldar en este caso 4 pines que nos permitirán programar el dispositivo. En este modelo es muy peligroso conectar otros periféricos a las líneas de control porque la señal GND va conectada a uno de los terminales de la red (que puede ser el neutro pero también el vivo), con lo cual podríamos freir el sensor que le conectemos. Por tanto en principio no trae ningún GPIO fácilmente accesible.

Las conexiones serían las que se muestran en las siguientes imágenes:

Programación

Para reprogramar un dispositivo SonOff según nuestras necesidades necesitamos los siguientes elementos:

Un programador de Arduinos y otros controladores, como el FTDI FT232 o similar. Siempre nos tenemos que asegurar de que el programador funcione a 3.3V y no a 5V, si no queremos freír el controlador del SonOff.
Un entorno de programación preparado para ESP8266. A continuación veremos cómo preparar el entorno utilizando el IDE de Arduino, aunque se puede utilizar cualquier otra herramienta.
Un software (o firmware) para meterle al SonOff, que nos proporcione las funcionalidades que necesitamos.

A continuación veremos los pasos que necesitamos para configurar cada uno de los elementos:

Paso 1: Conectar el programador

Para conectar el programador, nos aseguraremos de que realizamos las siguientes conexiones entre el mismo y el SonOff:

Básicamente se trata de establecer un “null modem” entre ambos dispositivos, cruzando las líneas de recepción y transmisión y manteniendo las de alimentación y tierra. El resto de pines del programador se quedarán sin conectar.

De este modo, si conectamos el programador a nuestro ordenador, nos aparecerá un nuevo puerto serie (COMx) al que nos podemos conectar tanto para obtener la información que saque el dispositivo como para programarlo. Para esto último hay que entrar en modo programación como veremos más adelante.

Paso 2: Preparar el entorno

Para programar un dispositivo ESP8266 existe la posibilidad de utilizar el mismo lenguaje de Arduino (y su IDE), como vimos en este artículo, aunque existen otras posibilidades como LUA o MicroPython.

Nosotros vamos a utilizar Arduino como lenguaje de programación, para lo cual lo normal es utilizar su propio IDE (yo particularmente utilizo Eclipse que es mucho más potente, pero eso ya es otro cantar). Para ello tendremos que hacer lo siguiente:

Debemos disponer de una versión reciente del IDE (a partir de la 1.6.4). Se descarga en esta dirección. El IDE tal cual lo instalamos conoce muchas placas de hardware, como todos los modelos habidos y por haber de Arduino y otras muchas, pero en principio no conoce ningún dispositivo ESP8266.
Para ello, tendremos que instalar el soporte de ESP8266. Para ello, haremos lo siguiente:
- Arrancamos el IDE.
- Vamos a la opción preferencias dentro del menú Archivo.
- En la opción “Gestor de URLs Adicionales de Tarjetas”, especificamos la siguiente dirección: http://arduino.esp8266.com/stable/package_esp8266com_index.json y pulsamos Ok.
- Vamos al menú Herramientas -> Placa -> Gestor de Tarjetas.
- Seleccionamos ESP8266 Community y la instalamos.
- A partir de ese momento, ya tenemos disponible toda la familia de productos basados en ESP8266 en el menú Herramientas -> Placa.
Para poder programar correctamente nuestro dispositivo, en el menú Herramientas debemos seleccionar exactamente las siguientes opciones. En caso contrario no nos va a funcionar:
- Placa: Generic ESP8266 module.
- Flash Mode: DOUT.
- Flash Frequency: 40Mhz.
- CPU Frequency: 80Mhz.
- Flash Size: 1M (64K SPIFFS).
- Debug Port: Disabled.
- Debug Level: Ninguno.
- Reset Method: CK.
- Upload Speed: 115200.
En cuanto al puerto, lo podremos seleccionar cuando tengamos conectado el programador.

Paso 3: Elegir el software

A la hora de cambiar el funcionamiento de nuestros dispositivos SonOff, podemos elegir entre una gran cantidad de softwares, o firmwares, o como se les quiera llamar.

Unos tienen más características que otros, otros tienen un servidor web integrado, otros son más fácilmente configurables, etc. Yo voy a poner una lista de los más conocidos y el que yo he elegido concretamente. Todos ellos están programados en el lenguaje de Arduino y se pueden subir desde nuestro IDE ya preparado.

Tasmota.
Este software soporta todos los dispositivos SonOff, incluye un servidor web y permite configurarlo de forma interactiva, se conecta a servidores MQTT y permite conectarles una gran cantidad de sensores, es actualizable por OTA, etc.
Espurna.
Este software es español y tiene prácticamente las mismas características.
Homie.
Homie es una librería que podemos incluir en nuestro Sketch de Arduino y que nos provee de una funcionalidad básica: conexión a Wifi, a MQTT, etc.
SonOff-HomeAssistant.
Este software es muy básico: sólo nos permite encender y apagar los dispositivos y conectarles opcionalmente un sensor de temperatura y humedad. También es configurable mediante OTA, pero no tiene ninguna característica avanzada como configuración online, ni servidor web ni nada de eso.

En mi caso, me he quedado con esta última opción, ya que no necesito que un interruptor haga otra cosa: yo tengo de momento 3 SonOffs Basic funcionando: uno como interruptor simple, otro con un DHT22 que me mide la temperatura y la humedad (soportado directamente por el software) y un tercero con un sensor de temperatura DS18B20 mediante una modificación que he realizado en el código. Para mí es suficiente y es lo que voy a explicar.

Configuración

Para utilizar el software SonOff-HomeAssistant, nos iremos al repositorio y entraremos en el directorio arduino. Dentro de este directorio utilizaremos los siguientes programas:

ESPsonoff-v1.01pOTA, si vamos a utilizar un SonOff Basic sin ningún sensor conectado.
ESPsonoff-v1.01tOTA, si vamos a utilizar un SonOff Basic con un sensor de temperatura y humedad conectado (DHT11 ó DHT22).
ESPsonoff_POW-v1.0, si vamos a utilizar un SonOff POW.

Una vez descargado el software y abierto con el IDE de Arduino, deberemos ajustar los siguientes parámetros del código:

#define DHTTYPE         DHT22
// Aquí indicaremos DHT11 ó DHT22, según el modelo que tengamos

#define MQTT_CLIENT     "Sonoff_Living_Room_v1.01tOTA"
// Este parámetro indica el identificador que tiene este dispositivo de cara al MQTT.
// El identificador debe ser único para cada dispositivo

#define MQTT_SERVER     "192.168.0.100"                      
// Aquí indicamos la dirección IP del broker MQTT

#define MQTT_PORT       1883
// Puerto TCP del broker

#define MQTT_TOPIC      "home/sonoff/living_room/1"
// Tópico que utilizaremos para controlar este dispositivo, y en el que se 
// publicarán el estado del mismo y los valores de los sensores

#define MQTT_USER       "user"
// Usuario del broker MQTT

#define MQTT_PASS       "pass"
// Contraseña del mismo

#define WIFI_SSID       "homewifi"
// Nombre de la WIFI

#define WIFI_PASS "homepass"
// Contraseña de la WIFI

int kRetries = 10;
// Número de intentos a realizar para conectar a la Wifi.
// En mi caso tuve que aumentarlo a 50 porque tardaba en conectar.

Paso 4: Grabar el software

Una vez que tenemos el software descargado y configurado a nuestro gusto, tendremos que grabarlo en el dispositivo. Para ello tendremos que entrar en modo programación:

Con el programador desconectado del puerto USB, dejar pulsado el pulsador del SonOff.
Sin soltar el pulsador, conectar el programador a un puerto USB del ordenador.
Dejar pulsado el pulsador unos 3 ó 4 segundos.
Soltar el pulsador.

Desde este momento el controlador del SonOff, en lugar de ejecutar el software que tiene cargado, se queda a la espera de que le mandemos un nuevo software. Subiremos el software mediante la opción Programa -> Subir.

En caso de que nos dé un error de sincronización, podemos volver a intentarlo. En caso de que siga fallando, podríamos bajar la velocidad de flasheo de 115200 a 57600 o inferior. Si seguimos teniendo problemas, es posible que no hayamos entrado bien en el modo de programación: nos aseguraremos de que todos los parámetros están puestos tal y como se dice en el punto 2, desconectaremos y volveremos a entrar en modo programación.

Una vez que subamos el software, podemos desconectar el programador del ordenador y volver a conectarlo sin pulsar nada. Le daremos unos segundos y podemos comprobar si se conecta a la WIFI y que podamos encender y apagar el LED mediante el pulsador.

Paso 5: Modificaciones

En el caso del SonOff Basic, como ya se ha dicho, podemos conectarle cualquier sensor utilizando el GPIO 14 que tenemos disponible. Por ejemplo, siguiendo este esquema podríamos añadirle un sensor DHT11 o DHT22:

Si lo que tenemos es un sensor de temperatura Dallas DS18B20, utilizaríamos un esquema parecido, intercalando una resistencia de 4K7Ω entre la línea de datos y la de alimentación.

En lugar de utilizar la librería DHT.h, utilizaríamos:

OneWire.
DallasTemperature

Las modificaciones en el código serían muy simples:

Antes del método setup, añadiríamos:

OneWire one(PINDS18B20);
DallasTemperature sensorDallas(&one);

Dentro del método setup:

sensorDallas.begin();

Y finalmente, el método getTemp se quedaría así:

void getTemp() {
    Serial.print("DS18B20 read . . . . . . . . . . . . . . . . . ");
    char message_buff[60];

    // Lanzamos una petición para leer temperaturas...
    sensorDallas.requestTemperatures();

    // ... y obtenemos las del primero (y único, en principio)
    float temp = sensorDallas.getTempCByIndex(0);

    if (digitalRead(LED) == LOW) {
        blinkLED(LED, 100, 1);
    } else {
        blinkLED(LED, 100, 1);
        digitalWrite(LED, HIGH);
    }
    if (isnan(temp)) {
        mqttClient.publish(
                MQTT::Publish(MQTT_TOPIC"/debug", "\"DS18B20 Read Error\"").set_retain().set_qos(
                        1));
        Serial.println("ERROR");
        tempReport = false;
        return;
    }
    String pubString = "{\"Temp\": " + String(temp) + "}";
    pubString.toCharArray(message_buff, pubString.length() + 1);
    mqttClient.publish(
            MQTT::Publish(MQTT_TOPIC"/temp", message_buff).set_retain().set_qos(
                    1));
    Serial.println("OK");
    tempReport = false;
}

Integración en HomeAssistant

Finalmente, una vez que tenemos el software funcionando en nuestro dispositvo, tendremos que definirlo en nuestro HomeAssistant como interruptor o como luz. Para ello añadiremos a nuestro fichero configuration.yaml las siguientes líneas:

# Podríamos utilizarlo como interruptor (switch) o como luz (light)
switch:
  - platform: mqtt
    name: Interruptor 1
    state_topic: "micasa/sonoff/cocina/1/stat"
    command_topic: "micasa/sonoff/cocina/1"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    retain: true

Además, en el caso de que le hayamos conectado un sensor de temperatura, habría que definir los sensores:

sensor:
- platform: mqtt
  name: "Temperatura cocina"
  state_topic: "micasa/sonoff/cocina/1/temp"
  unit_of_measurement: "°C"
  value_template: '{{ value_json.Temp | default(0) }}'

- platform: mqtt
  name: "Humedad cocina"
  state_topic: "micasa/sonoff/cocina/1/temp"
  unit_of_measurement: "%"
  value_template: '{{ value_json.Humidity | default(0) }}'

Montaje físico

Como ejemplo, en la siguiente imagen se muestra cómo integrar un SonOff Basic modificado con un sensor de temperatura dentro de un ventilador:

Sensor de consumo eléctrico para HomeAssistant (y 3)

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 6 Aug 2017 17:30:00 +0200

En este artículo pretendo dar por zanjado el tema del sensor de consumo eléctrico doméstico. Venimos de esta entrada.

En la entrada anterior planteamos el circuito a utilizar para nuestro sensor e hicimos una serie de pruebas en nuestro protoboard.

Esta vez vamos a ver el montaje definitivo y cómo mandar los datos a HomeAssistant.

Montaje definitivo

En la imagen podemos ver el montaje definitivo que he hecho en una placa:

No sé si se ven bien los detalles, pero básicamente he montado el D1 mini en un zócalo para poder extraerlo fácilmente para reprogramarlo y le he conectado a la entrada de 5V una batería recargable de litio 18650 de 3.7V, con lo cual el regulador interno nos da los 3.3V estabilizados para el divisor de tensión.

He de decir que este es el segundo D1 mini que uso: el primero me lo cargué midiendo el consumo del dispositivo. Se ve que no le sentaron nada bien los microcortes de tensión que le metí cuando estaba probando a poner y quitar el amperímetro. Ahora le he puesto al circuito unos pines que me hacen de interruptor al estar conectados mediante un puente. No quiero cargarme más componentes con un pico al conectar y desconectar la batería (que no es nada fácil).

Aparte de esto, nada más que decir en cuanto al montaje físico.

Software

En cuanto al programa en sí para el lector de consumo, aparte de utilizar la librería EmonLib para lo que son las lecturas de corriente, necesitamos algo más para enviar los datos una vez que los tenemos.

Lo más lógico dado que vamos a utilizar HomeAssistant como centralizador es utilizar un cliente de MQTT.

MQTT

MQTT son las siglas de Message Queue Telemetry Transport, un protocolo ligero utilizado en dispositivos del Internet de las cosas que permite a múltples intermediarios intercambiar mensajes de la misma manera que funcionaría un chat: cada intermediario accede a lo que se denomina un tópico, que es el tema de la conversación, y cada uno puede publicar mensajes sobre ese tópico. Otros clientes pueden suscribirse a ese tópico y recibir una notificación cuando haya un mensaje nuevo.

Nos conectaremos a un servidor (o broker) de MQTT y publicaremos periódicamente en un tópico concreto los valores leídos de corriente y potencia efectivas. Para ello utilizaremos la librería PubSubClient.

El programa

A continuación, el código fuente del programa utilizado para el sensor de consumo:

/**
 * Lector de consumo energético con conexión Wifi a servidor MQTT
 * Isidoro Aguilar Baeza - Julio/Agosto 2017
 * Este script se ejecuta en dispositivos NodeMCU, no en Arduino
 *
 * Librerías utilizadas:
 *   - PubSubClient(MQTT): https://github.com/knolleary/pubsubclient
 *   - EmonLib: https://github.com/openenergymonitor/EmonLib
 */

#include "Arduino.h"
#include <ESP8266WiFi.h>
#include "lib/PubSubClient.h"
#include "lib/EmonLib.h"

// Configuración de pines
#define PIN_LED            2

// Configuración de WIFI
#define WIFI_SSID    "XXXXXX"               // Nombre del AP Wifi
#define WIFI_PWD    "XXXXXX"            // Contraseña para conectar
#define WIFI_BPS    9600                // Velocidad del interfaz WIFI

// Configuración de MQTT
#define MQTT_SERVIDOR    "X.X.X.X"        // Dirección IP del broker
#define MQTT_PUERTO        1883
#define MQTT_USUARIO    "XXXXXXXXXXXXX"    // Usuario de acceso
#define MQTT_PWD        "XXXXXXXXXXXXX"    // Contraseña
#define MQTT_CLIENTE    "sensorConsumo"    // Identificador de este cliente
#define MQTT_TOPICO        "micasa/potencia"    // Tópico en el que publicaremos

// Configuración eléctrica
#define RatioTC            2000    // Ratio del transformador
#define ResCarga        91        // Resistencia de carga
#define correccion        1.145    // Factor de corrección adicional. Calculado empíricamente
#define VoltajeLinea    220        // Voltaje típico de la línea
#define T_PAUSA            10        // Intervalo entre medidas, en segundos

// Inicializamos el cliente Wifi y el MQTT
WiFiClient clienteESP;
PubSubClient clienteMQTT(clienteESP);

// Declaramos un lector de consumo de la librería EmonLib
EnergyMonitor emon1;

// Declaramos la cadena que se enviará al servidor MQTT
char payloadMQTT[30];

/**
 * Conecta con el servidor de MQTT (Mosquitto)
 */
void conectarMQTT() {
    if (!clienteMQTT.connected()) {
        Serial.print("Conectando con el servidor MQTT en ");
        Serial.print(MQTT_SERVIDOR);

        boolean conectado = false;
        while (!conectado) {
            Serial.print(".");
            if (clienteMQTT.connect(MQTT_SERVIDOR, MQTT_USUARIO, MQTT_PWD)) {
                conectado = true;
                Serial.println();
                Serial.println("Conectado");
                //clienteMQTT.subscribe(MQTT_TOPICO);
            } else {
                delay(1000);
            }
        }
    }
}

/**
 * Configuración.
 * Se ejecuta sólo una vez, al iniciar el Arduino
 */
void setup() {
    // 1.- Inicializamos el puerto serie USB
    Serial.begin(9600);
    delay(100);
    Serial.println("");
    Serial.println("");
    Serial.println("Lector de consumo eléctrico");
    Serial.println();
    Serial.print("Conectando con ");
    Serial.print(WIFI_SSID);

    // 2.- Inicializamos el módulo WIFI y nos conectamos al AP
    WiFi.persistent(false);
    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PWD);

    // Establecemos un bucle de espera hasta que esté conectado...
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println();
    Serial.println("Conectado.");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());

    // 3.- Nos conectamos al servidor MQTT
    clienteMQTT.setServer(MQTT_SERVIDOR, MQTT_PUERTO);

    // 4.- Inicializamos el LED
    pinMode(PIN_LED, OUTPUT);
    digitalWrite(PIN_LED, LOW);

    // 5.- Indicamos dónde está conectado el sensor de corriente (pin analógico A0) y el factor de calibración.
    emon1.current(A0, RatioTC / ResCarga * correccion);

    Serial.print("Voltaje de alimentación: ");
    Serial.print((double) (emon1.readVcc() / 1000));
    Serial.println("V");

    // Hacemos una primera lectura que desechamos. La primera nunca es fiable
    emon1.calcIrms(14800);
}

/**
 * Bucle de ejecución
 * Se ejecuta una y otra vez hasta que se apague el NodeMCU
 */
void loop() {
    // 1.- Encendemos el LED antes de leer (extrañamente parece que los valores HIGH y LOW están invertidos en el esp8266)...
    digitalWrite(PIN_LED, LOW);

    if (!clienteMQTT.connected())
        conectarMQTT();

    clienteMQTT.loop();

    // 2.- Leemos la corriente efectiva y calculamos la potencia.
    double corriente = emon1.calcIrms(14800);
    double potencia = corriente * VoltajeLinea;

    Serial.print("Corriente: ");
    Serial.print(corriente);
    Serial.println(" A");

    Serial.print("Potencia: ");
    Serial.print(potencia);
    Serial.println(" W");

    // 3.- Lo mandamos al servidor de MQTT
    sprintf(payloadMQTT, "{\"corriente\" : %d.%03d,\"potencia\" : %d.%03d}",
            (int) corriente, (int) (corriente * 1000) % 1000, (int) potencia,
            (int) (potencia * 1000) % 1000);
    Serial.print("Payload: ");
    Serial.println(payloadMQTT);
    clienteMQTT.publish(MQTT_TOPICO, payloadMQTT);
    clienteMQTT.disconnect();

    // 4.- Volvemos a apagar el led hasta la próxima
    digitalWrite(PIN_LED, HIGH);

    // 5.- Esperamos un ratito
    delay(T_PAUSA * 1000);
}

Varias cosas que destacar en este código:

Los ejemplos de EmonLib para Arduino siempre utilizan un muestreo de 1480. Como yo estoy utilizando un ESP8266 que va a 80 Mhz (en lugar de los 8Mhz del Arduino Pro Mini), he multiplicado por 10 el tamaño de la muestra. Tarda más en obtener la corriente pero es bastante más estable que en el ejemplo que vimos en la entrada anterior.
Además, en mis experimentos he observado que cuando se comienzan a hacer lecturas mediante llamadas al método calcIrms, la primera vez da un valor extrañamente alto, aún sin carga. Por tanto, he hecho una primera llamada en la función setup que simplemente descarto.
Para el parámetro de calibración, además del ratio del transformador y el valor de la resistencia de carga, he utilizado un factor de corrección basándome en la comparación de las lecturas obtenidas al medir el consumo de una lámpara de 300W. Lo he corregido para que las lecturas se acerquen en lo posible a dicho valor, aunque quizá no sea buena idea. Lo ideal es medir con una pinza amperimétrica profesional y comparar con nuestras lecturas, aplicando entonces la corrección necesaria.
Otro parámetro a tener en cuenta es el voltaje de la línea. Debemos utilizar un valor medio, aún cuando sabemos que el voltaje no es algo estable en una instalación. En mi casa oscila entre los 208V y los 234V, con lo cual he elegido 220V como el valor medio. Lo ideal sería leer el voltaje instantáneo, pero para eso necesitaríamos otro tipo de sensor.
La conexión con la Wifi y con el servidor de MQTT entrarán en un bucle infinito en caso de no poder conectarse, con lo cual quizá hubiera que optimizar algo aquí.

Optimizaciones

Este es el código estándar que se utilizaría en un Arduino: una función setup que se encarga de las inicializaciones, y otra función loop que se repite de forma infinita hasta que el dispositivo se apaga. Las lecturas en este caso se hacen en dicha función y se espacian unos 10 segundos (más el tiempo de lectura). En esta configuración, el código funciona bastante bien, pero el consumo es algo alto si vamos a funcionar con una batería.

Siendo optimista, una batería 18650 de las que he comprado (en Amazon) podría tener unos 2700 mAh de capacidad, aunque estén marcados como de 3000.

He medido el consumo del circuito (aquí es donde me cargué el primer D1 mini) y, mientras está muestreando, el consumo es de unos 70-74 mA. Cuando el programa pasa a la espera, el consumo baja a unos 18-20 mA. Si hacemos la media, nos sale un consumo medio de unos 38 mA. Esto quiere decir que una batería nos duraría:

2700 mAh / 38 mA = 71 h = 2,9 días

Esto está muy bien para una prueba, pero no me veo cambiando la batería del lector cada 3 días. Así que habrá que hacer algo: algo que se llama deep sleep (sueño profundo).

El ESP8266 tiene este modo de funcionamiento que es prácticamente “catatónico“: toda la electrónica se apaga excepto un pequeño temporizador establecido por el programa. El truco consiste en que, al iniciar el temporizador, se le indica al ESP que active un puerto concreto, normalmente el D0. Si el D0 lo conectamos al pin de RESET, el resultado es que al terminar el temporizador, el ESP se reinicia y ejecuta de nuevo la función setup.

Por tanto, habría que modificar el programa para que toda la lógica transcurra en el setup y no en el loop. Una vez que tengamos una lectura válida y la hayamos enviado al servidor MQTT, nos echaremos a dormir un ratito en modo deep sleep.

En este modo el consumo baja drásticamente. En teoría, en un dispositivo puro sin electrónica añadida debería bajar al orden de microAmperios en vez de miliAmperios. Lógicamente, la unidad que estamos usando (D1 mini) tiene electrónica para el puerto USB, para el regulador de tensión, etc. Aún así, modifiquemos el código y veamos qué tal el consumo:

/**
 * Lector de consumo energético con conexión Wifi a servidor MQTT
 * Isidoro Aguilar Baeza - Julio/Agosto 2017
 * Este script se ejecuta en dispositivos NodeMCU, no en Arduino
 *
 * Librerías utilizadas:
 *   - PubSubClient(MQTT): https://github.com/knolleary/pubsubclient
 *   - EmonLib: https://github.com/openenergymonitor/EmonLib
 */

#include "Arduino.h"
#include <ESP8266WiFi.h>
#include "lib/PubSubClient.h"
#include "lib/EmonLib.h"

// Configuración de pines
#define PIN_LED            2

// Configuración de WIFI
#define WIFI_SSID    "XXXXXX"               // Nombre del AP Wifi
#define WIFI_PWD    "XXXXXX"            // Contraseña para conectar
#define WIFI_BPS    9600                // Velocidad del interfaz WIFI

// Configuración de MQTT
#define MQTT_SERVIDOR    "X.X.X.X"        // Dirección IP del broker
#define MQTT_PUERTO        1883
#define MQTT_USUARIO    "XXXXXXXXXXXXX"    // Usuario de acceso
#define MQTT_PWD        "XXXXXXXXXXXXX"    // Contraseña
#define MQTT_CLIENTE    "sensorConsumo"    // Identificador de este cliente
#define MQTT_TOPICO        "micasa/potencia"    // Tópico en el que publicaremos

// Configuración eléctrica
#define RatioTC            2000    // Ratio del transformador
#define ResCarga        91        // Resistencia de carga
#define correccion        1.145    // Factor de corrección adicional. Calculado empíricamente
#define VoltajeLinea    220        // Voltaje típico de la línea
#define T_PAUSA            55        // Intervalo entre medidas, en segundos

// Inicializamos el cliente Wifi y el MQTT
WiFiClient clienteESP;
PubSubClient clienteMQTT(clienteESP);

// Declaramos un lector de consumo de la librería EmonLib
EnergyMonitor emon1;

// Declaramos la cadena que se enviará al servidor MQTT
char payloadMQTT[30];

/**
 * Conecta con el servidor de MQTT (Mosquitto)
 */
void conectarMQTT() {
    if (!clienteMQTT.connected()) {
        Serial.print("Conectando con el servidor MQTT en ");
        Serial.print(MQTT_SERVIDOR);

        boolean conectado = false;
        while (!conectado) {
            Serial.print(".");
            if (clienteMQTT.connect(MQTT_SERVIDOR, MQTT_USUARIO, MQTT_PWD)) {
                conectado = true;
                Serial.println();
                Serial.println("Conectado");
                //clienteMQTT.subscribe(MQTT_TOPICO);
            } else {
                delay(1000);
            }
        }
    }
}

/**
 * Configuración.
 * Se ejecuta sólo una vez, al iniciar el Arduino
 */
void setup() {
    // 1.- Inicializamos el puerto serie USB
    Serial.begin(9600);
    delay(100);
    Serial.println("");
    Serial.println("");
    Serial.println("Lector de consumo eléctrico");
    Serial.println();
    Serial.print("Conectando con ");
    Serial.print(WIFI_SSID);

    // 2.- Inicializamos el módulo WIFI y nos conectamos al AP
    WiFi.persistent(false);
    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PWD);

    // Establecemos un bucle de espera hasta que esté conectado...
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println();
    Serial.println("Conectado.");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());

    // 3.- Nos conectamos al servidor MQTT
    clienteMQTT.setServer(MQTT_SERVIDOR, MQTT_PUERTO);

    // 4.- Inicializamos el LED
    pinMode(PIN_LED, OUTPUT);
    digitalWrite(PIN_LED, LOW);

    // 5.- Indicamos dónde está conectado el sensor de corriente (pin analógico A0) y el factor de calibración.
    emon1.current(A0, RatioTC / ResCarga * correccion);

    Serial.print("Voltaje de alimentación: ");
    Serial.print((double) (emon1.readVcc() / 1000));
    Serial.println("V");

    // Hacemos una primera lectura que desechamos. La primera nunca es fiable
    emon1.calcIrms(14800);

    // 6.- Encendemos el LED antes de leer (extrañamente parece que los valores HIGH y LOW están invertidos en el esp8266)...
    digitalWrite(PIN_LED, LOW);

    if (!clienteMQTT.connected())
        conectarMQTT();

    clienteMQTT.loop();

    // 7.- Leemos la corriente efectiva y calculamos la potencia.
    double corriente = emon1.calcIrms(14800);
    double potencia = corriente * VoltajeLinea;

    Serial.print("Corriente: ");
    Serial.print(corriente);
    Serial.println(" A");

    Serial.print("Potencia: ");
    Serial.print(potencia);
    Serial.println(" W");

    // 8.- Lo mandamos al servidor de MQTT
    sprintf(payloadMQTT, "{\"corriente\" : %d.%03d,\"potencia\" : %d.%03d}",
            (int) corriente, (int) (corriente * 1000) % 1000, (int) potencia,
            (int) (potencia * 1000) % 1000);
    Serial.print("Payload: ");
    Serial.println(payloadMQTT);
    clienteMQTT.publish(MQTT_TOPICO, payloadMQTT);
    clienteMQTT.disconnect();

    // 9.- Volvemos a apagar el led hasta la próxima
    digitalWrite(PIN_LED, HIGH);

    // 10.- Finalmente, nos vamos a dormir
    pinMode(D0, WAKEUP_PULLUP);        // D0 conectada a RST
    ESP.deepSleep(T_PAUSA * 1000000);    // Establecemos el temporizador
    delay(100);        // Normalmente no se ejecutará, pero a veces es necesario.
}

/**
 * Bucle de ejecución
 * Se ejecuta una y otra vez hasta que se apague el NodeMCU
 */
void loop() {
}

Una vez modificado el código, las lecturas de consumo son las siguientes:

Unos 75 mA durante la lectura (5s).
0.46 mA en deep Sleep (55s).

Haciendo la media:

((5 x 75 mA) + (55 x 0,46 mA)) / 60 = 6,67 mA

Luego, la duración de la batería ahora sería de:

2700 mAh / 6,67 mA = 404,80 h = 16.86 días

No está nada mal, la verdad. Pero a lo mejor no necesitamos tener lecturas cada minuto. Veamos qué pasa si las hacemos cada 3 minutos:

((5 x 75 mA) + (175 x 0,46 mA)) / 180 = 2,53 mA
2700 mAh / 2,53 mA = 1067,19 h = 44,46 días

Pues decidido: vamos a hacer las lecturas con un intervalo de unos 3 minutos, con lo cual la batería nos debería durar sobre mes y medio. No pasa nada porque es recargable, así nos entretenemos.

Por tanto, sólo habría que cambiar el parámetro T_PAUSA por el valor 175 y volver a subir el programa al dispositivo, conectarlo todo y probar.

Montaje físico

El montaje físico habría que realizarlo lo más cerca posible de la toma general de la casa, colocando el sensor CT013 alrededor de un sólo cable: o el vivo o el neutro (nunca la tierra). Un buen lugar para coloclarlo sería en la caja para el ICP, aunque ello nos obligaría a abrirla cada vez que queramos cambiar la batería.

En mi caso, lo he colocado de esta manera en una caja de conexiones que tenía cerca del cuadro general:

Conexión con HomeAssistant

Bueno, pues ya tenemos nuestro dispositivo leyendo la corriente y la potencia de nuestra casa y enviando los datos cada 3 minutos al servidor MQTT.

Ahora lo que nos queda es configurar un sensor en HomeAssistant para poder leer y mostrar los valores.

La configuración es muy fácil. En nuestro fichero configuration.yaml deberíamos activar el protocolo mqtt y deberíamos definir (en el mismo configuration.yaml o en sensors.yaml) un sensor para el tópico en el que estamos publicando los datos.

La configuración debería quedar parecida a esta:

mqtt:
  discovery: true
  broker: X.X.X.X
  port: 1883

sensor:
  - platform: mqtt
    name: Consumo Global
    state_topic: "micasa/potencia"
    unit_of_measurement: "kW"
    value_template: '{{ "%0.2f" | format((value_json.potencia | float) / 1000 ) }}'

Yo lo he configurado para que muestre la potencia en kilovatios, redondeándolo a 2 decimales. Si alguien quiere mostrar el valor en vatios, tal como viene del lector, tan sólo bastaría con cambiar la última línea por:

    value_template: '{{ value_json.potencia  }}'

Finalmente, el aspecto que tiene el sensor cuando lo vemos en HomeAssistant es el siguiente:

Conclusión

A lo largo de estas tres entradas hemos construido un sensor de potencia efectiva que nos permite consultar en HomeAssistant la potencia aproximada que se está consumiendo actualmente en toda la casa. Además del circuito eléctrico, hemos creado un pequeño programa que se ejecuta en un dispositivo inalámbrico basado en ESP8266 cada tres minutos y el resto del tiempo permanece dormido. Hemos conectado los datos del dispositivo con un servidor de mensajería MQTT y hemos conseguido visualizar los datos en HomeAssistant.

Para el montaje, hemos utilizado los siguientes componentes:

1 transformador de corriente SCT013-000. Comprado en Aliexpress por unos 5€.
1 dispositivo inalámbrico D1 mini. Comprado en Aliexpress por unos 2,50€.
1 condensador de 10 uF y 25V. Comprado en la tienda de electróncia de la esquina.
2 resistencias de 1/4W y 4,7KΩ.
2 resistencias de 1/4W y 22Ω.
1 resistencia de 1/4W y 47Ω.
Placa de montaje y zócalos.

Entre el condensador y las resistencias no llegan al euro. Lo que sí es importante es comprar resistencias buenas, con una precisión alta. Para el primer montaje que hice utilicé unas resistencias que compré en Aliexpress baratísimas pero que resultaron ser desastrosas. Los voltajes del divisor de tensión no cuadraban y los valores del lector no tenían sentido.

Sensor de consumo eléctrico para HomeAssistant (2)

noreply@blogger.com (Isidoro Aguilar Baeza) — Sat, 5 Aug 2017 18:20:00 +0200

Continuamos en este artículo con el montaje del sensor de consumo para la casa. Venimos de esta entrada.

En la entrada anterior vimos un poco la teoría tanto del sensor de corriente no invasivo CT013 como del esquema eléctrico básico que necesitaremos para leer los datos del mismo.

En esta entrada vamos a ver la implementación real del circuito.

Selección del controlador

Una de las decisiones más importante que tenemos que hacer es qué tipo de controlador vamos a utilizar.

Lo lógico, y lo primero que se nos viene a la cabeza es un Arduino, pero ¿es la solución más eficiente? ¿y qué tipo de Arduino utilizamos?

Normalmente, al iniciar un proyecto sabemos qué sensores vamos a necesitar, que son los componentes que más nos van a determinar el tipo de controlador: en base al voltaje requerido, el consumo, la alimentación disponible, etc.

En este caso utilizamos un sensor pasivo, esto es: no requiere alimentación y por tanto no nos va a condicionar. Pero por otro lado tenemos dos requisitos que tenemos que tener en cuenta:

El dispositivo debe enviar sus lecturas de forma inalámbrica.
El dispositivo debe funcionar, en la medida de lo posible, de forma autónoma. Lo ideal es que funcione con baterías.

Conexión inalámbrica

El primer requisito nos condiciona porque tenemos que utilizar algún componente que nos permita conectarnos con nuestro concentrador de forma inalámbrica:

Podríamos utilizar un transceptor nRF24L01+, que tiene un consumo muy bajo, pero como incoveniente necesitaríamos dos: uno en el emisor y otro en el receptor (OrangePi Zero).
También podríamos utilizar un dispositivo WiFi como el ESP8266, que nos permite conectarnos directamente con nuestra red doméstica sin más requisitos.

En el caso de elegir este segundo, tenemos una ventaja adicional: en la entrada en la que vimos su funcionamiento lo analizamos como componente puro que podíamos utilizar mediante su conexión a un Arduino. Este es el llamado encapsulado ESP8266-01, que tan sólo nos expone 8 pines (entre los cuales están los de alimentación) y que funciona como un modem enviándole comandos AT por el puerto serie.

Sin embargo, existen otros encapsulados del mismo chip que nos permiten explotar toda su pontencialidad, que no es otra que tratarse de un SoC completo con sus pines GPIO digitales, otro pin GPIO analógico, su memoria para ejecutar código y para almacenar datos, soporte para varios protocolos, etc.

Estos encapsulados como el ESP8266-12, ESP8266-07, etc, nos permiten utilizar este dispositivo a modo de controlador con el añadido de que tiene conectividad WiFi.

Este hecho, y teniendo en cuenta lo barato que es, ha propiciado que cada vez exista un mayor uso de este dispositivo en proyectos autónomos en detrimento del tándem Arduino + Wifi.

Tanto es así que ahora mismo en Aliexpress o cualquier otra tienda disponemos de distintos “empaquetados” de este chip como controladores autónomos que incluyen su interfaz USB para conectarlo al ordenador y programarlo, regulador de voltaje, etc. Principalmente encontraremos estos dos modelos:

NodeMCU

Wemos D1 Mini

Además, el dispositivo se puede programar en lenguaje LUA (un lenguaje interpretado) o bien directamente mediante el IDE de Arduino con el mismo lenguaje (y mismas librerías) que utilizamos con el Arduino.

Por tanto, es muy fácil migrar un programa hecho para Arduino al NodeMCU o D1 Mini con muy pocos cambios.

El único impedimento que tendremos es que este dispositivo tiene menos pines GPIO que el Arduino. De hecho sólo tiene 1 pin analógico.

El dispositivo funciona a 3.3V y consume bastante, sobre todo al iniciarse (al igual que el ESP8266-01), pero afortunadamente dispone de un modo deep sleep (sueño profundo) en el que lo único que está alimentado es un pequeño oscilador de cristal que nos marca el tiempo en el que se tiene que “despertar” de nuevo para seguir funcionando. El consumo en el modo deep sleep es bajísimo, lo cual nos permite pensar en su uso por medio de baterías.

Funcionamiento autónomo

El segundo requisito nos lleva a depender de la alimentación por medio de baterías.

Dado que hemos visto que el ESP8266 funciona a 3.3V, lo lógico sería establecer este voltaje como el adecuado para el montaje. Por tanto, o bien utilizamos un Arduino y otro controlador que funcionen a 3.3V, o bien tendremos que tener un regulador que nos dé este voltaje para dicho componente.

Podríamos tener como fuente de alimentación un pack de 3 baterías AA o AAA en serie que nos darían 4.5V. Esto en el caso de funcionar a 3.3V. Después o bien utilizaríamos el regulador interno del controlador o necesitaríamos un regulador del tipo LM1117 (en la imagen).

Otra opción es utilizar una batería recargable de iones de litio de tipo 18650, que nos da un voltaje inicial de 4.2V y va bajando hasta aproximadamente los 2.5V. El voltaje nominal es de 3.7V, el mismo que se usa en los teléfonos de hoy día, y no conviene descargarlas por debajo de los 3V porque pueden pasar cosas muy malas… desde que ya no podamos cargarla más hasta que explote al cargarla la próxima vez.

Yo voy a elegir esta segunda opción: utilizar una única batería recargable 18650, la cual me acabo de dar cuenta de que trae integrado el circuito de protección que evita sobre corrientes y descargas por debajo del mínimo aconsejable.

Decisión

Finalmente, mi decisión va a ser utilizar un módulo D1 Mini como controlador y una batería 18650 como alimentación, utilizando el regulador interno del dispositivo que nos proporciona 3.3V regulados. Intentaré por todos los modos utilizar el modo deep sleep aunque ya sé que tengo otros consumos que no puedo de momento bajar, como son el del propio regulador (que lo tendré que usar de todos modos) y el del interfaz USB (CHG340).

Montaje

Vamos ahora a montar el circuito completo, utilizando el controlador elegido, la fuente de alimentación y el circuito original del sensor de corriente.

Diseño del circuito

El diagrama del circuito básico que usaremos es el siguiente:

Como se puede ver, para el divisor de tensión he elegido dos resistencias de 4K7 Ω, y para la resistencia de carga mantengo los cálculos de la entrada anterior, 3 resistencias en serie con un valor total de 91 Ω.

El montaje en el breadboard quedaría de la siguiente manera:

Y esta es una foto real de cómo quedaría montado físicamente:

Librería emonlib

Para hacer las mediciones del sensor, utilizaremos la librería EmonLib, de OpenEnergyMonitor.

Esta librería funciona muestreando las lecturas del puerto analógico utilizado para conectar el circuito del sensor, y nos calcula todos los parámetros que necesitamos para tratar la Corriente Alterna.

Es importante tener en cuenta que, como la librería puede ser utilizada en una gran variedad de circuitos, cada uno con sus distintos valores relativos al sensor y a la resistencia de carga, es necesario indicar un parámetro de calibración, que se calcula según la documentación de la librería de la siguiente manera:

$Cal = \frac{RatioTC}{R}$

Siendo RatioTC el ratio del transformador de corriente (relación entre primario y secundario) y R la resistencia de carga calculada.

Por tanto, en nuestro caso el parámetro de calibración sería el siguiente:

$Cal=\frac{2000}{91}=21.978$

Programa de prueba

El sketch o programa que utilizaremos para probar el circuito será el siguiente:

#include "EmonLib.h"

#define RatioTC 2000
#define ResCarga 91
#define VoltajeLinea 230

EnergyMonitor emon1;

/**
 * Configuración. Sólo se ejecuta la primera vez que se inicia el dispositivo
 */
void setup() {
    Serial.begin(9600);
    delay(10);
    Serial.println("");
    Serial.println("");
    Serial.println("Lector de consumo eléctrico");

    // Indicamos dónde está conectado el sensor de corriente (pin analógico A0) y el factor de calibración.
    emon1.current(A0, RatioTC / ResCarga);
}

/**
 * Bucle infinito que se ejecuta constantemente
 */
void loop() {
    // Calculamos la corriente efectiva indicando el número de muestras a tomar de la entrada analógica.
    double Irms = emon1.calcIrms(1480);

    Serial.print("I = ");
    Serial.print(Irms);
    Serial.print(" A, P = ");

    // Potencia efectiva = corriente efectiva * voltaje de línea
    Serial.print(Irms * VoltajeLinea);
    Serial.println(" W");

    delay(5000);
}

Una vez compilado, lo ejecutamos y ésta es la salida que obtenemos por el puerto serie:

Lector de consumo eléctrico 
I = 0.67 A, P = 153.95 W
I = 0.16 A, P = 36.60 W
I = 0.05 A, P = 12.24 W
I = 0.04 A, P = 9.64 W
I = 1.14 A, P = 262.96 W
I = 1.15 A, P = 264.73 W
I = 1.16 A, P = 265.78 W
I = 1.18 A, P = 271.47 W
I = 1.13 A, P = 260.15 W
I = 1.48 A, P = 341.17 W
I = 1.35 A, P = 309.65 W
I = 1.17 A, P = 269.78 W
I = 1.19 A, P = 273.09 W
I = 1.18 A, P = 271.46 W
I = 1.25 A, P = 287.18 W
I = 0.95 A, P = 218.53 W
I = 0.92 A, P = 211.87 W
I = 1.03 A, P = 236.09 W
I = 0.75 A, P = 171.41 W
I = 0.02 A, P = 4.92 W
I = 0.16 A, P = 35.81 W
I = 0.16 A, P = 36.02 W
I = 0.15 A, P = 35.48 W
I = 0.06 A, P = 14.40 W

Las lecturas no son demasiado estables (hice una prueba con un Arduino Pro Mini que tengo y las lecturas son algo más estables) porque el puerto analógico no es ninguna maravilla y mete algo de ruido, pero se puede ver perfectamente que a partir de la quinta le he metido una carga de unos 280-300W mientras que después he ido bajándola un poco hasta los 220W, dejándola luego de nuevo a 0.

Puede verse también que cuando teóricamente no hay carga, el sensor todavía detecta algunas décimas de amperio, debido también al ruido. De todos modos, estamos construyendo este componente para medir la potencia de una casa completa, y no pasa nada si tenemos un pequeño ruido de algunas décimas.

Sensor de consumo eléctrico para HomeAssistant (1)

noreply@blogger.com (Isidoro Aguilar Baeza) — Fri, 4 Aug 2017 14:59:00 +0200

Hoy vamos a ver un proyecto que tengo en mente hace tiempo: poder medir el consumo eléctrico de toda la casa en tiempo real.

Para ello, voy a utilizar Home Assistant como centralizador, y mi intención es tener un sensor inalámbrico independiente como medidor.

Requisitos

Para montar el sensor, mis requisitos son los siguientes:

El sensor debe enviar los datos de forma inalámbrica.
El sensor debe ser no invasivo: esto es, no quiero tener que pasar la corriente de toda mi casa por un componente electrónico para medirla. Simplemente no me fío.
Si es posible, me gustaría que el sensor quedase lo más oculto posible y que estuviera alimentado a baterías. No quiero ver cables por medio.

Componentes

Selección del sensor

Para montar un sensor de corriente no invasivo, lo primero que se me vino a la mente fue un transformador de corriente SCT013 que vimos en esta entrada del blog.

Este sensor nos permite leer la corriente alterna del primario del transformador como una corriente alterna en el secundario de mucho menor valor, con un ratio de 2000:1. Esto es: para una corriente de 100A en el primario, nos daría en el secundario:

$\frac{100A}{2000} = 0,05A = 50mA$

Cálculo de componentes del circuito

Ahora es cuando viene el momento matemático. Las fórmulas que utilizaremos a continuación son muy simples, y están extraídas de openenergymonitor.

Lo de que el transformador nos dé una corriente alterna pequeña como salida está muy bien, pero si lo que queremos es medir el consumo mediante un microcontrolador como el Arduino o el ESP8266, tendremos que traducirlo a voltaje.

Esto es muy fácil si recordamos la ley de Ohm:

Voltaje=Intensidad×Resistencia

$Voltaje = Intensidad \times Resistencia$

Por tanto, para tener un voltaje tan sólo tendremos que tener una resistencia en el circuito secundario del transformador. A esta resistencia se le llama de carga (burden en inglés), y tendremos que calcular su valor en base al voltaje que queramos controlar como máximo.

Lo primero que tenemos que saber es qué amperaje máximo vamos a tener realmente.
Si vamos a medir el consumo en una casa, lo normal es que tengamos un interruptor de control de potencia (ICP) que nos corte el suministro al llegar al máximo contratado. En la siguiente tabla podemos ver las potencias más normales que podemos contratar:

Intensidad Potencia

10 A 2,3 kW

15 A 3,45 kW

20 A 4,6 kW

25 A 5,75 kW

Vamos a suponer que en casa tenemos una potencia contratada de 5,75kW con un ICP de 25A (o que tenemos contratado menos pero querernos curarnos en salud por si nos entra algún pico). Consideramos por tanto esta la corriente máxima que vamos a tener en el primario.
Esta corriente es alterna y se denomina corriente RMS (o corriente eficaz, aquella que provoca el mismo efecto calorífico que una corriente continua de la misma intensidad), por lo que antes que nada, tenemos que averiguar cuál es la corriente máxima o pico.

La fórmula que relaciona ambos valores es la siguiente:

$\mathbf{I}_{prim} = \mathbf{I}_{rms}\times \sqrt{2} = 25A\times1.4142 =35.35A$
Esta es la corriente de pico del primario. A continuación tenemos que calcular el del secundario. Sabemos que la proporción es 2000:1, con lo cual:

$\mathbf{I}_{sec}=\frac{\mathbf{I}_{prim}}{2000}= \frac{35.35A}{2000}\simeq 0.01767 A$
Insisto en que la corriente (tanto la de entrada como la de salida) es alterna. Por tanto, para convertir a voltaje, debemos tener en cuenta cuál es el voltaje máximo que admite la entrada del microcontrolador que vamos a utilizar. Más adelante insisto en esto, pero supongamos que el voltaje máximo que admite el dispositivo es de 3.3V.
Al poner una resistencia de carga vamos a tener un voltaje también alterno, con una onda senoidal, que será positivo en el pico más alto (el que corresponda a 0,017 A) pero negativo en el punto más bajo (el que corresponda a -0,017 A). Con la fórmula anterior hemos obtenido la corriente de pico, pero necesitamos saber cuál es el recorrido completo de la onda, desde el punto más bajo hasta el más alto, para después traducir este recorrido a un voltaje por medio de la resistencia.

Esto es lo que denominamos corriente pico-a-pico, que es el doble. Por tanto, la fórmula para calcular la resistencia sería la siguiente:

$\mathbf{R} = \frac{\mathbf{V}_{max}}{\mathbf{I}_{pp}}= \frac{3.3V}{0.03535 A}=\simeq93 \Omega$
Esta es la resistencia de carga ideal. Debemos aproximarla en base a las que hay en el mercado, siempre utilizando el menor valor disponible que se acerque más al valor ideal. En nuestro caso, podemos acercarnos mediante la utilización de tres resistencias en serie:

$22 Ω + 22 Ω + 47 Ω = 91 Ω$ $22\Omega + 22\Omega + 47\Omega = 91\Omega$

Por tanto, este será el valor de nuestra resistencia de carga. Con esta resistencia, podríamos avanzar los valores de voltaje que obtendríamos para ciertos valores de corriente:

$\mathbf{I}_{prim} = 25A \Rightarrow \mathbf{I}_{sec}=\frac{25A}{2000}=0.0125A \Rightarrow \mathbf{V} = \mathbf{I} \times \mathbf{R} = 0.0125A \times 91 \Omega = 1.1375V$

El esquema eléctrico que tenemos hasta ahora sería el siguiente:
Finalmente, tenemos un problema: las corrientes negativas. Hasta ahora los cálculos que hemos hecho nos permiten tener corrientes positivas y negativas (dado que es alterna), lo cual nos daría voltajes positivos y negativos. Las entradas analógicas de los controladores en principio sólo admiten valores de voltaje positivo, con lo cual nos quedaría un último paso: una desviación de voltaje.

El truco consiste en añadir al voltaje que nos da nuestro circuito un voltaje de referencia fijo, que se sumará dándonos siempre valores positivos. Para ello, dado que nuestros cálculos los hemos hecho para una entrada a 3.3V, deberíamos sumarle mediante un divisor de tensión justo la mitad: 1,65V.

Esto lo conseguimos añadiendo un divisor de tensión con dos resistencias del mismo valor a la salida del circuito anterior:

Como podemos ver en el esquema, ahora el voltaje estaría comprendido entre un mínimo de 0 y un máximo de +V (3.3V en nuestros cálculos).

Intensidad	Potencia
10 A	2,3 kW
15 A	3,45 kW
20 A	4,6 kW
25 A	5,75 kW

De todos modos, los cálculos que hemos realizado en base a 25A de máxima intensidad son los más ajustados si queremos cubrir el posible espectro de voltajes con la máxima precisión, pero no quiere decir que sea la forma más fácil, como veremos en la segunda parte del artículo.

Lo más fácil es emplear una resistencia de carga estandarizada para la intensidad máxima del sensor (100A), que sería la siguiente, en función del voltaje de alimentación:

Voltaje	Resistencia
5V regulados	33 Ω
3.3V regulados	22 Ω
3.3V a baterías	18 Ω

Conclusiones

Terminamos aquí la primera parte de este artículo, y a modo de resumen:

Vamos a utilizar un sensor de corriente CT013 no invasivo, basado en un transformador de 2000:1.
Necesitaremos una o más resistencias de carga a la salida del sensor.
Necesitaremos también un divisor de tensión basado en dos resistencias idénticas.
El voltaje de trabajo será de 3.3V.
Aún nos queda por determinar qué dispositivo utilizaremos como controlador, cosa que decidiremos en la segunda parte del artículo.

Sensores de temperatura con HomeAssistant en OrangePi

noreply@blogger.com (Isidoro Aguilar Baeza) — Thu, 3 Aug 2017 12:46:00 +0200

Ahora que tenemos instalado HomeAssistant en nuestra Orange Pi Zero, vamos a ver un ejemplo práctico de cómo conectarle unos cuantos de sensores de temperatura.

Utilizaremos para ello sensores Dallas DS18B20 que ya vimos en esta entrada del blog. Son pequeños, muy baratos y tienen la característica de que funcionanpor medio del protocolo 1Wire, que nos permite establecer un bus lineal (un único cable, para entendernos) en el que podemos colocar varios sensores en distintas posiciones. Si tenemos la posibilidad de hacer llegar un cable de un rincón a otro de la casa, podemos tener sensores en todas las habitaciones de una manera fácil.

HomeAssistant tiene soporte nativo para este protocolo, y la OrangePi Zero permite conectarlos por medio de sus pines GPIO (General Purpose Input Output - Entradas y salidas de propósito general), pero antes tenemos que activar su utilización. Utilizaremos para ello cualquier distribución de armbian para la OPI Zero, como Debian o Ubuntu.

Activar módulos 1Wire

El kernel de armbian soporta el protocolo 1Wire para la OPI Zero, pero hay que activar los módulos correspondientes. Para ello, editaremos el fichero /etc/modules-load.d/modules.conf y descomentaremos todas las líneas que comienzan por w1, quedando de la siguiente manera:

w1-sunxi
w1-gpio
w1-therm
#sunxi-cir
xradio_wlan
g_serial
xradio_wlan

Al reiniciar el sistema, deberían quedar activados los drivers del protocolo 1Wire. Para comprobarlo, basta con acceder al directorio /sys/bus/w1. Si existe este directorio, es que todo ha ido bien.

Comprobar GPIO

Ahora tenemos que comprobar dónde conectar los terminales de los sensores de temperatura.

Vamos a utilizar varios sensores en el mismo cable, siguiendo el esquema que vimos en la entrada citada del blog. Todos ellos utilizan un sólo pin o GPIO, dado que se trata de un bus serie.

El driver de 1Wire que está ahora habilitado en el kernel utiliza un GPIO concreto, y para averiguar cuál es, nos vamos al directorio /boot y ejecutamos el siguiente comando:

$ bin2fex script.bin script.fex

Este comando nos convierte el fichero binario a uno de texto (script.fex) que podemos abrir con un editor y buscaremos en él la cadena “w1”.

En mi OPI Zero, la sección tiene el siguiente contenido:

[w1_para]
w1_used = 1
gpio = 10

Lo que quiere decir que el driver utiliza en este caso el GPIO10.

Podríamos elegir otro GPIO de los que están disponibles en el conector modificando el fichero fex y compilándolo de nuevo con el comando fex2bin, pero en principio nos puede valer el 10 tal y como está.

Conexionado

Siguiendo el esquema de conectores extraído de linux-sunsi, el GPIO10 está disponible en el terminal número 26 (esquina inferior derecha) del bus de GPIO de la OPI Zero:

Por tanto, utilizando la alimentación tradicional (no parasitaria) del sensor de temperatura, las conexiones a realizar serían las tres siguientes:

Pin 2: VDD (5V).
Pin 6: GND.
Pin 26: Datos E/S.

Como se indica en el esquema siguiente (obtenido del proyecto MySensors), podemos establecer un bus llevando a la distancia deseada los tres cables y colocando en los puntos de interes distintos sensores conectados en paralelo:

Entre la línea de alimentación y la de datos conectaremos una resistencia de 4K7 ohmios, al principio del bus.

El cable del bus puede ser bastante largo (hay gente que lo ha llevado más alla de los 500m), y dependerá del tipo de cable (se recomienda par trenzado UTP de clase 5 o superior), de las interferencias, del voltaje empleado en la alimentación, etc.

La alimentación del sensor en teoría se podría hacer a 3,3V, pero como admite un voltaje entre 3 y 5,5V, vamos a hacerlo a 5V para evitar que la caída de potencial a lo largo del bus nos cree un problema de alimentación.

A continuación, unas fotos para ver cómo quedan los sensores en el cable UTP que yo he utilizado:

Conexión del primer sensor (con la resistencia de 4K7)
Conexión de sensor intermedio
Conexión del bus a la Orange Pi Zero

Una vez que conectemos los sensores, nos deben aparecer varios subdirectorios en /sys/bus/w1,con el nombre “28-xxxx“. Cada uno de ellos es un sensor distinto, y el “xxxxx” es el ID único del dispositivo.

Para comprobar que las lecturas de temperatura funcionan, podemos ejecutar en cada uno de ellos el siguiente comando:

$ cat 28-XXXXXXXXXXXXX/w1_slave

Si todo va bien, nos deberá devolver algo parecido a esto:

49 01 4b 46 7f ff 07 10 f6 : crc=f6 YES
49 01 4b 46 7f ff 07 10 f6 t=28355

Esto indica dos cosas:

El dispositivo transmite correctamente (el CRC está bien, sin errores).
La temperatura actual es de 28,355ºC

Activación del sensor en HomeAssistant

Una vez que tenemos todo el cableado conectado y los sensores son detectados a nivel de sistema operativo, nos queda activarlos dentro de Home Assistant.

Para ello, utilizaremos la plataforma onewire, definiendo de esta manera todos nuestros sensores, dentro del fichero de configuración configuration.yaml:

# Sensores de temperatura Dallas 18B20
# Todos conectados en paralelo en el bus 1Wire
- platform: onewire
  names:
    28-000006769469: Temperatura pasillo
    28-0000067761dc: Temperatura salón
    28-000006775fde: Temperatura exterior

Como podemos ver, hacemos una correspondencia entre el identificador de cada sensor (el que aparece en el directorio /sys/bus/w1) y el nombre que le queramos dar a cada sensor.

Por defecto, Home Assistant nos mostrará el sensor como un sensor de temperatura, no tenemos que especificar ni un icono ni la unidad de medida, y nos aparecerá de esta manera:

Instalar HomeAssistant en Orange Pi Zero

noreply@blogger.com (Isidoro Aguilar Baeza) — Sat, 15 Jul 2017 12:16:00 +0200

He comenzado a utilizar un proyecto muy interesante para la Orange Pi Zero.

Se trata de Home Assistant, un proyecto de software libre que nos permite tener un sistema centralizado para la domótica de nuestra casa.

Introducción

Home Assistant es un proyecto de software libre, programador en Python, y con una creciente comunidad de aficionados detrás que están desarrollando sus propios componentes para la interconexión de multitud de dispositivos:

Sensores.
Interruptores.
Enchufes.
Servicios web.
Comandos de sistema.
Etc.

Cada componente se enmarca dentro de una categoría, entre las que se destacan las siguientes:

Sensor. Cualquier cosa capaz de obtener información: sensores de movimiento, sensores de temperatura, estado de un ordenador, velocidad de conexión, información obtenida de una página web, etc.
Interruptor. Cualquier cosa capaz de cambiar de estado: interruptores eléctricos, encender y apagar ordenadores, activar y desactivar servicios, etc.
Reproductores multimedia. Cualquier cosa que reproduzca medios: televisores inteligentes, reproductores software, Chromecast, etc.
Seguimiento de dispositivos. Cualquier cosa que cambie de lugar: posicionamiento GPS, detección por Wifi, por Bluetooth, etc.
Automatismos. Son reglas que establece el usuario para que ocurran cosas cuando se dan ciertas circunstancias en el resto de elementos: que se enciendan las luces cuando no hay sol, estamos en un rango de horas y hay alguien en casa, que se enciendan cosas cuando un servicio está en un estado.... El límite es la imaginación.

No pretendo dar un curso de HomeAssistant, sino explicar brevemente cómo lo tengo instalado en mi Orange Pi Zero.

Instalación

Home Assistant se puede instalar en cualquier ordenador que tenga Python. No es necesariamente sólo para Linux, se puede instalar también en OSX y en Windows.

Pero el verdadero potencial es que la aplicación no necesita grandes recursos, y podemos aprovechar estos pequeños micro-ordenadores como Raspberry u Orange Pi para montar un servidor dedicado.

Estas son las instrucciones para instalar "Home Assistant" en armbian (distribución de Debian para ARM) en Orange Pi Zero. Casi todo está basado en la documentación "oficial"

https://home-assistant.io/docs/installation/armbian/

aunque con las modificaciones realizadas por mí para que funcione correctamente.

Paso 1:

Instalamos todos los paquetes necesarios si no los tenemos ya:

sudo apt-get update
sudo apt-get install python3-dev python3-pip

Paso 2:

Vamos a ejecutar el programa con un usuario específico, de modo que lo creamos, tanto el usuario como su grupo asociado:

sudo addgroup homeassistant
sudo adduser --system --ingroup homeassistant homeassistant
sudo usermod -G aid_inet homeassistant

El último comando es para que el usuario tenga permitido acceder a internet.

Paso 3:

Creamos un entorno virtual para Python asociado al usuario que hemos creado. De este modo, todos los paquetes instalados sólo afectarán al entorno virtual y no a todo el sistema:

sudo pip3 install --upgrade virtualenv
sudo mkdir /srv/homeassistant
sudo chown homeassistant:homeassistant /srv/homeassistant
sudo mkdir /var/lib/home-assistant
sudo chown -R homeassistant:homeassistant /var/lib/home-assistant

Cambiamos al usuario que acabamos de crear y entramos y ejecutamos el entorno virtual:

sudo su -s /bin/bash homeassistant
virtualenv -p python3 /srv/homeassistant
source /srv/homeassistant/bin/activate

Paso 4:

Instalamos homeassistant con el nuevo usuario que hemos creado y lo configuramos como servicio:

pip3 install --upgrade homeassistant

Ejecutamos por primera vez HomeAssistant para que cree la configuración en el directorio que hemos establecido (/var/lib/home-assistant):

hass --config /var/lib/home-assistant

Una vez que todo ha ido bien, detenemos la ejecución con Ctrl-C.

Paso 5:

Creamos un servicio para ejecutar Home Asistant. El fichero se denominará /etc/init.d/hass y su contenido será el siguiente:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          hass
# Required-Start:    $local_fs $network $named $time $syslog
# Required-Stop:     $local_fs $network $named $time $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       Home\ Assistant
### END INIT INFO

# /etc/init.d Service Script for Home Assistant
# Created with: https://gist.github.com/naholyr/4275302#file-new-service-sh
PRE_EXEC=""
RUN_AS="homeassistant"
BIN="/usr/local/bin/hass"
PID_FILE="/tmp/hass.pid"
CONFIG_DIR="/var/lib/home-assistant"
FLAGS="-v -c $CONFIG_DIR --pid-file $PID_FILE --daemon"
REDIRECT=">> $CONFIG_DIR/home-assistant.log 2>&1"

start() {
if [ -f $PID_FILE ] && kill -0 $(cat $PID_FILE) 2> /dev/null; then
    echo 'Service already running' >&2
    return 1
fi
echo 'Starting service…' >&2
local CMD="$PRE_EXEC $BIN $FLAGS $REDIRECT"
su -c "$CMD" $RUN_AS
echo 'Service started' >&2
}

stop() {
    if [ ! -f "$PID_FILE" ] || ! kill -0 $(cat "$PID_FILE") 2> /dev/null; then
    echo 'Service not running' >&2
    return 1
fi
echo 'Stopping service…' >&2
kill $(cat "$PID_FILE")
while ps -p $(cat "$PID_FILE") > /dev/null 2>&1; do sleep 1;done;
echo 'Service stopped' >&2
}

install() {
    echo "Installing Home Assistant Daemon (hass-daemon)"
    echo "999999" > $PID_FILE
    chown $RUN_AS $PID_FILE
    mkdir -p $CONFIG_DIR
    chown $RUN_AS $CONFIG_DIR
}

uninstall() {
echo -n "Are you really sure you want to uninstall this service? That cannot be undone. [yes|No] "
local SURE
read SURE
if [ "$SURE" = "yes" ]; then
    stop
    rm -fv "$PID_FILE"
    echo "Notice: The config directory has not been removed"
    echo $CONFIG_DIR
    update-rc.d -f hass remove
    rm -fv "$0"
    echo "Home Assistant Daemon has been removed. Home Assistant is still installed."
fi
}

case "$1" in
start)
    start
    ;;
stop)
    stop
    ;;
install)
    install
    ;;
uninstall)
    uninstall
    ;;
restart)
    stop
    start
    ;;
*)
    echo "Usage: $0 {start|stop|restart|install|uninstall}"
esac

Una vez creado el servicio, hay que darle permisos de ejecución y activarlo al inicio:

sudo chmod +x /etc/init.d/hass
update-rc.d hass defaults

Utilización

Una vez instalado como servicio, podremos iniciar o detener Home Assistant mediante los siguientes comandos:

service hass start
service hass stop

Destacar también que existe un fichero de log en el directorio /var/lib/home-assistant, que sería conveniente por facilidad enlazarlo en el directorio /var/log:

ln -s /var/lib/home-assistant/home-assistant.log /var/log/hass.log

Instalación de componentes adicionales

Home Assistant tal como lo hemos instalado funciona como un servicio aislado que se ejecuta en un entorno virtual de Python.

Cuando activemos en la configuración algún elemento nuevo, todos los componentes necesarios de Python normalmente se instalarán automáticamente en el directorio deps dentro de /var/lib/home-assistant. Esta instalación la realiza directamente el usuario homeassistant.

Si en alguna ocasión la instalación de un componente de Python fallase (cosa que podemos comprobar monitorizando el fichero de log) podemos realizarla a mano ejecutando el entorno virtual, de la siguiente manera:

sudo su -s /bin/bash homeassistant
source /srv/homeassistant/bin/activate
pip3 install COMPONENTE

Y eso es todo por hoy. Espero que os guste.

Orange Pi

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 9 Jul 2017 20:27:00 +0200

Hola otra vez.

Sí, lo sé: hace muchísimo tiempo que no escribo en el blog. Pero ¿qué le voy a hacer?, es que llevo una temporada sin tiempo para nada.

Así que hoy que tengo un ratito voy a poner aquí unos breves apuntes sobre la Orange Pi.

¿Que qué es la Orange Pi?
¿No has oído hablar de la Raspberry Pi? ¿En serio?
¿Ni de cubietruck? ¿Ni de Banana Pi? ¿Ni de Odroid? ¿Ni de Orange Pi?

Raspberry Pi

Bueno, pues todo comenzó en la Universidad de Cambridge (UK) en 2006. En la Facultad de Informática decidieron fabricar un ordenador de reducidas dimensiones en una única placa, que costase poco y que sirviera de "inspiración" a los alumnos para realizar sus propios proyectos. Recuerda un poco en sus orígenes al Arduino, pero a diferencia de aquel, el objetivo era incluir un ordenador completo, no sólo un microcontrolador.

Raspberry Pi 1 Model B

No fue hasta el año 2012 cuando salió a la venta el primer modelo de Raspberry Pi, micro-ordenador del tamaño de una tarjeta de crédito, que fue un verdadero bombazo por su relación calidad-precio. Estas fueron las especificaciones del primer modelo (Raspbery Pi 1 Modelo B):

Procesador: Broadcom BCM2835. ARMv6 de un sólo núcleo a 700Mhz.
Gráfica: Broadcom VideoCore 4, capaz de codificar y decodificar 1080p, a 250 Mhz.
Memoria: 256 MB.
USB: 2 puertos USB 2.0
Salida de vídeo: vídeo compuesto y HDMI.
Salida de audio: minijack y HDMI.
Almacenamiento: sin almacenamiento interno, con slot para tarjeta SD.
Red: conector RJ45 a 10/100Mbps
Otros puertos: 26 pines GPIO (General Purpose Input / Output). Mediante estos pines se pueden implementar protocolos SPI, I2C, I2S, UART, OneWire, etc.

La placa se alimentaba a 5V con un consumo de unos 700 mA, y el precio inicial fue de unas 22£ (unos 35$) más IVA.

Debido al bajo precio de la placa, de la que se han vendido millones de unidades (tanto de los primeros modelos como de los que fueron saliendo después) pronto comenzó a surgir una gran comunidad de usuarios de manera que cualquiera que la compre puede encontrar miles de páginas donde se explica como instalarle cualquier distribución imaginable de Linux: Debian, Raspbian, ArchLinux, OpenElec, Ubuntu, etc.

Además, el bus de conectores GPIO permite la conexión de cualquier dispositivo de la misma manera que lo hacíamos con un Arduino, con la gran ventaja de poder programar en cualquier lenguaje de programación y no estar limitado al C que utliza Arduino ni a su IDE.

El único inconveniente que tiene esta placa es que, a diferencia del Arduino, se trata de un hardware cerrado. Uno puede montarse con cuatro componentes y medio su propio Arduino, hay cientos de fabricantes que lo hacen, diferentes precios, diferentes variantes.... Sin embargo, Raspberry sólo lo fabrica Raspberry, aunque el código fuente sí sea abierto.

Este hecho, y la necesidad de tener más potencia a menos precio, ha provocado que a lo largo de estos años hayan aparecido distintos proyectos que emulan el concepto de Raspberry Pi, pero siempre mejorando en algo: precio, memoria, procesador, etc. Muchos de estos proyectos, además, se han hecho con la intención de que sean compatibles en software (y muchas veces también en hardware) con la placa original, de manera que lo que se puede hacer en una Raspberry se pueda hacer igual en otra placa.

Orange Pi

Y aquí es donde llegamos a hablar de Orange Pi.
Orange Pi es una alternativa barata a Raspberry, tanto de hardware como de software abierto. Esto quiere decir que quien quiera puede construirse su propia placa o comprarla ya hecha a uno de los fabricantes.

Orange Pi PC

Los creadores originales de este micro-ordenador son la empresa china Shenzhen Xunlong Software CO, y dispone de una creciente comunidad de usuarios gracias a sus bajos precios, la disponibilidad de software y una relativa compatibilidad con las Raspberry Pi.

Modelos y características

Hasta la fecha han salido una gran variedad de modelos de este dispositivo, algunas de cuyas características expongo en la siguiente tabla. La mayoría de ellos se basan en el procesador H3 o variantes de la misma marca china: Allwinner. Este tipo de procesadores es muy habitual encontrarlos en multitud de "tablets" y "Android PC" chinos debido a su gran relación potencia-precio.

Modelo	CPU	RAM	Alm.interno	Alm.externo	Red	Vídeo	Conectores
Orange Pi Zero	H2+ (Cortex-A7 cuádruple núcleo)	256MB/512MB	NO	MicroSD hasta 64GB	Ethernet 10/100 + WIFI	Compuesto	Bus 26 GPIO + conector expansión 13 pines + 2 USB 2.0 + USB OTG
Orange Pi One	H3 (Cortex-A7 cuádruple núcleo)	512MB			Ethernet 10/100 + WIFI	HDMI CEC	Bus 40 GPIO + USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi Lite		512MB					Bus 40 GPIO + 2 USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi PC		1GB					Bus 40 GPIO + 3 USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi PC Plus		1GB	8GB
Orange Pi PC 2	H5 (Cortex-A53 cuádruple núcleo 64 bit)	1GB			Ethernet 100/1GB + WIFI

Orange Pi Zero

Esta es la pequeña de la familia, el modelo que yo tengo actualmente.
No se trata de una placa muy potente ni tiene unas especificaciones sobresalientes. Además, no está pensada para utilizarla como ordenador de escritorio puesto que no tiene salida HDMI ni VGA.

Sin embargo, para una gran cantidad de aplicaciones, tiene potencia suficiente y además incorpora de serie puertos USB, Wifi y conector de red RJ45. A pesar de que las especificaciones indican que necesita un alimentador de unos 1,5A - 2A yo la tengo funcionando conectada a un puerto USB que supuestamente debería dar unos 500 mA como máximo.

Estas son las ventajas, pero también tiene algunos inconvenientes según mi experiencia:

El conector GPIO no viene incluído, sino que tienes que soldarlo a la placa o soldar directamente los cables que necesites.
A pesar de traer WIFI, me ha demostrado que es bastante inestable. Yo particularmente la uso por ethernet y va estupendamente.
El procesador H2+ se calienta una barbaridad, tanto que si empiezas a pedirle es fácil que se ponga por encima de los 80 grados. Es casi imprescindible ponerle al menos un disipador térmico para que pueda funcionar a unos 60 grados que es algo más tolerable aunque no es lo óptimo.
La placa tiene salida de vídeo compuesto y posibilidad de tener más puertos USB aparte del que trae soldado y el USB OTG, pero por problemas de espacio no dispone de conectores para ello, sino que tiene un bus de expansión adicional (que sí viene soldado) de 13 pines en los que están disponibles todas estas señales. Venden un adaptador de expansión que se conecta a este bus y nos permite obtener directamente los conectores.

Software

En la página del fabricante disponemos de descargas de varias versiones de Sistemas Operativos para las Orange Pi:

Ubuntu.
Debian.
Raspbian (Distribución Debian específica par Raspberries).
Armbian (Distribución Debian para dispositivos ARM).
ArchLinux.
Android.

También tenemos la página de armbian donde disponemos de las últimas versiones de esta distribución, para varios modelos de Orange Pi y otras placas similares.

Precios

El precio de la Orange Pi Zero, que es la que yo tengo, es muy barato.

A mí me costó US$15.95 (unos 14€) de oferta en Banggood un kit con:

Orange Pi Zero de 512MB.
Tarjeta de expansión (con salida de vídeo compuesto y 2 puertos USB adicionales).
Caja para montaje de ambos elementos.

También podemos encontrarla en Aliexpress a un precio parecido, por ejemplo en este enlace (16.24$).

De todos modos, a lo mejor comprar la caja es una tontería, dada la temperatura que coge el cacharro estando al aire...

Conclusión

Resumiendo, la placa de la que he hablado hoy es un micro-ordenador muy barato que nos puede servir para hacer muchos proyectos distintos. Podríamos tener distintos servidores preparados y simplemente cambiar de tarjeta SD para cambiar de sistema.

Aunque sus especificaciones no son las mejores del mundo y no tiene una salida HDMI ni VGA (por tanto no es adecuada para montar un ordenador de sobremesa), sí que nos puede servir para montar cualquier servidor que se nos ocurra.

En el siguiente artículo tengo intención de hablar de un proyecto particular de domótica que estoy montando en mi Orange Pi Zero: Home Assistant.

Hasta la próxima.

Componentes (8): Reproductor MP3 DFPlayer Mini

noreply@blogger.com (Isidoro Aguilar Baeza) — Tue, 25 Oct 2016 22:48:00 +0200

El componente que estudiaremos hoy es muy útil cuando queramos emitir sonidos en nuestro montaje. Se trata de un reproductor de MP3 (y otros formatos) completo que tiene un tamaño realmente reducido.

El fabricante original de este componente es DFRobot, una empresa china especializada en kits electrónicos y que tienen un gran soporte para el aficionado por medio de su extensa wiki.

El reproductor dispone de un slot para introducir una tarjeta de memoria microSD de donde leerá los ficheros de audio, y tiene conectores para:

Conectar directamente a un altavoz de pequeñas dimensiones (hasta 3W).
Conectar a un amplificador de sonido o toma de auriculares.
Conectarle directamente una serie de botones que nos encontramos normalmente en cualquier reproductor de MP3, como play, pausa, avance, retroceso, volumen, etc.
Conectar con un dispositivo USB.
Conectar con el puerto serie de un dispositivo externo como un Arduino desde el que lo podemos controlar.

Otras características del dispositivo son las siguientes:

Reproduce audio en formato MP3 y WMA (aunque en las especificaciones indican WMV).
Admite tarjetas de un máximo de 32GB.
Soporta ficheros organizados en hasta 100 directorios con 255 ficheros cada uno.
Incluye un ecualizador de 6 bandas.

Y todo esto en un tamaño de 2cm x 2cm.

Por tanto, el dispositivo puede funcionar directamente como reproductor independiente (simplemente si le conectamos una batería y unos botoncillos de nada) o bien como dispositivo programable y controlarlo desde un controlador como un Arduino.

Descripción de los conectores

Consultando en la Wiki de DFRobot, podemos ver la disposición de los conectores más importantes:

VCC: Conector de alimentación. Admite voltajes entre 3.3V y 5V.
RX: Entrada serie (lectura).
TX: Salida serie (escritura).
DAC_R: Salida de audio canal derecho (para auriculares o línea).
DAC_L: Salida de audio canal izquierdo.
SPK_1: Conector negativo para altavoz externo.
GND: Tierra.
SPK_2: Conector positivo para altavoz externo.
BUSY: Este conector es una salida cuyo valor lógico 0 indica que el dispositivo está reproduciendo. Se puede utilizar para controlar por ejemplo un LED.
USB- y USB+: No me queda muy claro si forman una salida USB (para conectarlo a un ordenador y acceder al almacenamiento) o bien una entrada (para reproducir a partir de un pendrive por ejemplo), aunque me inclino más por lo primero.
ADKEY_2: No me queda claro en la wiki. Literalmente "reproduce el quinto segmento". Supongo que será para ir al último fichero o algo así, ya lo probaré.
ADKEY_1: Igualmente, la wiki menciona "reproduce el primer segmento". Supongo que irá al inicio de la lista.
IO_2: Para conectarle un botón de "avance". Una pulsación corta avanza a la siguiente canción y una larga aumenta el volumen.
IO_1: Para conectarle un botón de "retroceso". Una pulsación corta retrocede a la canción anterior y una larta disminuye el volumen.

Utilización con Arduino

Para utilizar el dispositivo desde Arduino, utilizaremos el protocolo serie conectándolo a un pin para recepción y a otro para emisión. El dispositivo se controla mediante comandos por este protocolo serie como: "avanzar pista", "retroceder pista", "reproducir", "pausa", "modo de repetición", etc.

Todos los comandos se pueden consultar en la Wiki o bien en este documento.

Igualmente, en la misma Wiki podemos descargarnos una librería para no tener que utilizar los comandos sino funciones definidas para cada cosa. La librería también está disponible en Github.

Dónde comprar

Evidentemente, podéis comprar este componente en la propia web de DFRobot, concretamente en esta página, por $8.90, más gastos de envío:

O bien podéis hacer como yo y comprarlo en Aliexpress. A mí me salio por 6 dólares, pero los he visto aquí a partir de 3 dólares. Toda una ganga, ¿no?

Componentes (7): Dispositivo Wifi ESP8266

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 23 Oct 2016 21:18:00 +0200

Pues sí, tenéis razón: tengo el blog completamente abandonado desde hace casi un año. Pero es que ha sido un año muy complicado y cargado de todo tipo de cosas.

Así que hoy que es Domingo, está lloviendo y estamos encerrados en casa, he decidido desempolvar el arduíno, el portátil y el blog y ponerme a escribir un ratito.

Retomo hoy la serie que empecé hace tiempo acerca de componentes electrónicos que conectar a nuestros "cacharros" y le dedico hoy un rato al ESP8266.

Introducción

El ESP8266 es un dispositivo (SoC o System on a Chip) que permite incorporar funcionalidad Wifi a cualquier aparato. Se trata de un componente de muy bajo coste y alta miniaturización producido por el relativamente recién llegado fabricante chino Espressif.

El chip en sí mide 5x5 mm e incorpora:

Una unidad microcontroladora (MCU) a modo de CPU, de 32 bits.
Memoria RAM para instrucciones de 64KB, y para datos de 96KB.
Memoria Flash.
Un sistema operativo integrado de tiempo real.
Una pila de controladores software y hardware para WIFI b/g/n.
Conectores para antena y otros (entre ellos 16 puertos de entradas y salidas).
Amplificadores de potencia, filtros y gestión de energía de bajo consumo.

De hecho, el dispositivo posee tres modos de funcionamiento: activo, suspendido y sueño profundo (deep sleep), que permite un aprovechamiento óptimo de la energía, motivo por el cual ha sido adoptado en muchos dispositivos como "TV Sticks" que vienen de China.

El dispositivo puede funcionar conectado a un controlador, como un Arduino por ejemplo, o bien de manera autónoma puesto que es programable.

En el caso de funcionar conectado a un controlador, su manejo se realiza mediante comandos "AT" como si se tratase de un modem, utilizando el protocolo Hayes.

Presentación y conexiones

Como hemos dicho, el chip mide 5mm de lado, y se puede soldar directamente sobre la placa, pero para nuestros propósitos, existe una presentación que se denomina ESP-01 (o ESP8266-01) que incluye el módulo ESP8266, un oscilador, y un interfaz con 8 pines de control (ver foto del párrafo anterior).

El conexionado de esta presentación es el que se muestra en la siguiente imagen:

RX: Recepción de datos.
GPIO0 y GPIO2: Estos dos pines son de entrada/salida, y se utilizan para arrancar el módulo en distintos modos: modo normal, programación, etc. Hay quien dice que deben conectarse a una alimentación de 3,3V con una resistencia de "pull-up", pero para las pruebas que yo he hecho (tengo uno funcionando desde hace más de un año) simplemente los dejo sin conectar y el módulo arranca correctamente.
GND: Tierra
VCC: Alimentación. OJO: debe recibir una alimentación de 3,3V (en las especificaciones indica un máximo de 3,6V).
RESET: Alimentar para reiniciar el dispositivo.
CHPD: Si este pin recibe un valor lógico de 1, el dispositivo se mantendrá en modo activo, mientras que si recibe un 0 permanecerá suspendido. En mis experimentos, sueldo este pin directamente con el VCC de alimentación, a 3,3V.
TX: Transmisión de datos.

Funcionamiento

El dispositivo puede funcionar tanto como un cliente, para conectarse a una red Wifi, o como un servidor (por ejemplo para montar un minúsculo servidor web).

Todas las funciones se pueden controlar por medio de comandos AT (también conocido como Hayes), que son comandos de texto que se envían mediante una conexión serie y comienzan todos con las letras "AT". La lista completa de comandos se puede consultar en este enlace, pero a continuación hago un pequeño resumen para ver qué podemos llegar a conseguir con él:

AT+CWLAP: Permite obtener una lista de las distintas redes Wifi disponibles.
AT+CWJAP: Nos permite conectarnos con una red especificando su SSID y contraseña.
AT+CIFSR: Nos permite consultar la dirección IP obtenida.
AT+CIPSTART: Inicia una conexión con una dirección IP remota.
AT+CIPSEND: Envía datos a la dirección especificada anteriormente.
AT+CIPCLOSE: Termina la conexión con la dirección remota.
AT+CIPSERVE: Inicia o finaliza el modo servidor.

Como se puede ver, su utilización es muy simple. Además, siempre podemos utilizar una librería que nos permita enviar los comandos necesarios.

Librerías

Para utilizar este módulo con Arduino, hay numerosas librerías; sobre todo considerando la posibilidad de utilizarlo como dispositivo independiente o como dispositivo serie conectado al Arduino.

La librería "oficial" de la comunidad ESP8266 es la siguiente:

https://github.com/esp8266/Arduino

Aunque la que yo he utilizado hasta ahora es esta otra (de James Sleeman) que es muy fácil de utilizar:

https://github.com/Autonomi/ESP8266

Precios

Finalmente, este módulo está disponible en una gran cantidad de sitios. Como siempre yo lo compré directamente a China en este enlace de Aliexpress, aunque parece que ya no lo tienen disponible. Da igual, en este otro enlace lo tienen aún más barato, a 1,70$ y es un éxito de ventas.

Cómo comprar en China y no fastidiarla en el intento

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 29 Nov 2015 02:39:00 +0100

Consejos para la compra online en China

Black Friday, Cyber Monday, Navidad, Acción de Gracias, 9 de Septiembre, 11 de Septiembre, el día de la primavera, el día de los solteros, el año nuevo chino...

Toda celebración es buena para fomentar el consumismo. Y mucho mejor si el que vende está en un país comunista... ¡Viva el libre mercado!

Sí, ya sé que este es un blog de tecnología, pero en fin, hoy me apetecía hablar un poco sobre las compras online, y especialmente las referidas a tiendas o plataformas chinas a las que soy tan aficionado.

Cuando uno oye hablar de esto por primera vez, piensa que esto de comprar en el extranjero es muy complicado y muy peligroso, y cuando piensas en China inevitablemente se te viene a la cabeza el típico establecimiento chino de tu barrio donde sólo el dependiente sabe dónde está cada cosa, donde hay un espía vigilándote en cada esquina de cada pasillo de la tienda y cuando tienes una duda y le preguntas al chino por algo, él te sonríe como si te hubiera entendido, le habla en chino a otro empleado y él te explica que "...segulo, no ploblema..." y te vas a casa más mosqueado que un pavo pensando que posiblemente te hayan engañado...

Y es verdad, los chinos y los españoles no somos muy distintos a pesar de las diferencias culturales: el que te puede engañar seguramente te va a engañar, o a lo mejor no, nunca se sabe...

Luego piensas que en realidad, quitando honrosas excepciones, la mayoría de las cosas que hoy compramos en una tienda española (o francesa, o italiana, o estadounidense, o ....) se ha fabricado en China. Y resulta que esos mismos fabricantes chinos que fabrican para empresas europeas o americanas luego te van a vender el mismo producto (o casi) casi a precio de fábrica; eso sí: olvídate de controles de calidad, de pruebas y de muchas otras cosas que encarecen el producto final. Lógicamente también te evitas las comisiones de terceros: transporte, marcas, etc.

Si añadimos a esto el hecho de que China posee un servicio postal a coste casi cero, promocionado por su gobierno, las empresas chinas se lanzaron hace años a una carrera por la venta por internet; y el crecimiento de intermediarios que se encargan de vender artículos al por menor es imparable.

Mi intención en este artículo es proporcionar una serie de consejos o "verdades fundamentales" que tenemos que tener en cuenta si queremos convertirnos en "importadores de autoconsumo" y comprar en tiendas chinas. Como este es un blog de tecnologías, me voy a centrar en lo referente a las compras tecnológicas en base a mi experiencia, pero la mayor parte de lo que aquí expongo puede valer para otro tipo de compras.

Cosas básicas a tener en cuenta

Lo primero que tenemos que tener en cuenta es que se trata de una compra a distancia, y la relación entre el vendedor y el comprador es difícil cuando no se conocen mutuamente, cuanto más si viven en países distantes de culturas muy diferentes. Por esto y por otros factores de riesgo, os expongo a continuación unos consejos generales relacionados con los peligros de nuestra transacción.

Los chinos son muy buenos imitadores.
Este factor es muy importante. No sólo se trata de que la mayor parte de los artículos se fabriquen en China, sino que los chinos, como su forma de vida, están acostumbrados a subsistir imitando todo aquello que exista. Tiene mucho que ver con las restricciones que tienen originadas por su sistema político, pero también con su bajo nivel económico. En China puedes encontrar imitaciones virtualmente de todo: desde un Windows XP que resulta que ni Microsoft, ni Windows ni XP hasta piezas de LEGO que no son LEGO, pasando por tarjetas de memoria que no son lo que parecen, etc. Se trata de aparentar, y muchas veces van a intentar colártela. Si nos centramos en el tema de los teléfonos móviles, decir que existen imitaciones chinas de otras marcas chinas que a su vez son imitaciones de marcas occidentales... Y más de uno ha caído, lo advierto. Muchas veces la calidad del objeto imitado es muy buena, la verdad, pero otras deja muchísimo que desear.
Desconfiar por sistema.
Otra cosa que hay que tener en cuenta es que no podemos fiarnos nunca al 100% de lo que diga un vendedor, ya que por norma general puede pasar una de las siguientes cosas:

Que el vendedor no sepa lo que vende, y simplemente ponga una información que no se corresponde con el artículo.
Que el vendedor haya puesto una descripción del artículo que ha copiado de otra web, que a su vez han copiado de otra web, que a su vez tecleó el becario de una empresa china subcontratada por 5 euros el día por una empresa que vende el artículo original; pero que luego resulte que esa información es incorrecta porque ya el artículo que venden no es el mismo.
Que el vendedor te esté engañando vilmente y te quiere vender gato por liebre.

Es verdad que esto puede ser un poco decepcionante, pero es mejor estar prevenido antes de darle al botón "comprar". Esto no se puede aplicar al 100% de los casos, lógicamente, pero hay cosas que yo no compraría jamás en una tienda china por mucha reputación que tenga, como tarjetas de memoria y pendrives. Leí hace un tiempo un artículo en el que un servicio técnico abre un disco duro que un cliente había comprado en China y no le funcionaba bien. Al abrir el disco, esto es lo que encontraron:

Se trata de una carcasa de disco duro con supuestamente 500GB que en su interior sólo tenía un pendrive de 8GB "trucado" y algo de metal para hacer peso. El truco del pendrive consiste en que al sistema le dice que tiene 500GB (o lo que quiera) pero a la hora de grabar ficheros, cuando llega al final del disco sigue grabando por el principio machacando lo que hubiera. En este enlace de reddit y en este otro podéis ver casos similares. Y la cosa parece ser bastante habitual, hay que tener mucho cuidado porque hay vendedores que incluso te lo dicen a la cara: "...oye, que es mentira, que estas tarjetas de 128 GB que vendemos, en realidad son de mentira, tienen sólo 16...". Así que recordad: nada de tarjetas ni pendrives ni discos duros supermaravillosos.

El menos común de los sentidos.
Dicen que así es el sentido común, y es verdad. Vamos a ver: ¿de verdad tú crees que por 90 dólares te van a vender un iPhone? ¿de verdad crees que una tarjeta microSD de 128GB puede llegar a costar 10 dólares?
Hay cosas que no son comprensibles. Si tú haces una búsqueda de un artículo electrónico en una plataforma de compra, ordenas los resultados por precios y resulta que hay un vendedor que vende ese artículo a la mitad de precio que el resto, pues ve pensándote que es un engaño, por muy bonitas que sean las fotos que te pone y las especificaciones que te escribe.
Por tanto, hay que usar muchísimo el sentido común.
La experiencia es la madre de la ciencia.
Este es un consejo también muy importante a tener en cuenta: nadie nace sabiendo, y para todo hay que aprender, a veces de forma agradable y a veces de forma traumática. Por tanto mi consejo es que si no tenéis experiencia previa, no os toméis a la ligera vuestras compras, no seáis compradores compulsivos.
Esto es importante tenerlo en cuenta siempre, pero más en situaciones de supuestas "rebajas" o "días locos" que se repiten a lo largo del calendario, porque como pongo al principio, cualquier conmemoración es buena para vender.
Lo importante es que estemos informados, que consultemos las opiniones de otros compradores, que consultemos al vendedor todas nuestras sospechas, que leamos mucho en distintos foros de compras las experiencias que otros han tenido. A pesar de que el vendedor nos puede querer engañar, nosotros debemos saber leer entre líneas y sobretodo si nos ponemos en contacto con él la experiencia suele ser buena. Los trabajadores que están a cargo del soporte tanto en las propias tiendas como en foros especializados suelen saber bien de lo que hablan y normalmente no te van a engañar.
Casi todas las tiendas tienen un apartado donde los compradores pueden poner su valoración de la transacción una vez realizada. Es muy importante leer estas valoraciones o al menos ver si hay muchos puntos negativos. Es verdad que esto tampoco es una regla de tres, porque hay vendedores excelentes y compradores muy "tiquis miquis". Por lo contrario, a veces también hay malos vendedores y compradores falsos que dejan buenas valoraciones; pero por norma general os doy dos apuntes acerca de este consejo:

No comprar artículos sin valoraciones ni compras anteriores. No queráis ser el primer comprador de un artículo, dejad egoistamente que otros experimenten antes que vosotros.
Leed bien los comentarios negativos: muchas veces tampoco los compradores saben lo que compran, o no entienden que un artículo tarde un mes y medio en llegar a su casa. Sed justos.

Las malas consejeras.
Insisto: las prisas son malas. Para toda compra, pero sobre todo las chinas.
Habrá quien no estará de acuerdo, habrá a quien le guste ser un comprador compulsivo; pero por experiencia os puedo decir que a la hora de hacer una compra en China hay que mirar muchas cosas, no ser de gatillo fácil, y más teniendo en cuenta la gran cantidad de "ofertas" que nos vienen a las manos o a nuestro correo electrónico. Curiosamente, el otro día me llegó una "oferta" de viernes negro de un móvil que, supuestamente rebajado, costaba 10 dólares más que su precio normal en el resto de las tiendas. Por tanto hay que ser muy precavido ante supuestas ofertas, mirar en el resto de tiendas "legales" que conozcamos, buscar cupones descuento, etc. Además, las prisas pueden hacer que nos equivoquemos a la hora de pagar, o a la hora de elegir el método de envío, y en infinidad de cosas.

Qué horas son estas.
Un riesgo a tener en cuenta es que la tienda en la que estás comprando no está en España. Está en un lugar en el que cuando tú entras a trabajar, ellos ya están pensando en volver a casa. Son 8 horas más en China que en España, así que tenlo en cuenta si quieres ponerte en contacto con el servicio técnico o quieres entrar en un chat online de la tienda. Muchas veces te dejarán en espera, porque toda Europa está intentando hablar con ellos cuando para ellos son las 5 o las 6 de la tarde, y no creo que para ellos sea muy agradable. Si intentas hablar con ellos después de las 10 de la mañana, acostúmbrate a que no te van a responder como mínimo hasta mañana.
En un lugar muy, muy lejano.
Otra cosa que hay que entender es la distancia, por algo se le llama el lejano Oriente. Estamos hablando de hacer una compra en una tienda que la mayoría de las veces es un intermediario. Que normalmente no va a tener stock de todos los artículos que vende, que muchas veces tiene que pedir material al almacén, que luego tiene que mandarlo por el correo, que no es el correo más rápido del mundo, y que tu pedido tiene que pasar por multitud de países, de oficinas de correos, y de manos.
Otra cosa es saber diferenciar entre "tiempo de preparación" o "processing time", que es el tiempo que tarda la empresa en preparar tu pedido desde que lo compras hasta que ellos lo envían y "tiempo de envío" o "shipping time" que es el tiempo que tardan las compañías de correos o mensajería internacionales en llevarte el pedido desde la tienda hasta tu casa.
Así que, sin prisas. Si quieres hacerlo bien, prepárate a esperar entre la suma de estos dos tiempos al menos 20 días para recibir tu pedido. Mientras tanto, puedes consultar el estado de tu pedido en la tienda y la situación aproximada del paquete mediante webs especializadas como 17track.
Normalmente, todas las tiendas van a ofrecerte diferentes métodos de envío, y cada uno tiene sus ventajas e inconvenientes. A continuacion os pongo los más comunes:

Air mail o flat rate mail.
Se trata del método más barato, equiparable a nuestro "correo ordinario" con la diferencia de que a ellos con China Post les sale prácticamente gratis mandar un paquete de esta forma a cualquier parte del mundo. Es un método lento y poco seguro, porque no lleva número de "tracking" o seguimiento y no podemos saber dónde está nuestro pedido. Por contrapartida, tiene la ventaja de ser gratuíto para el comprador y en el 99,99% de las ocasiones no lo parará la aduana al entrar en España.
Registered air mail.
Este método es el equivalente de nuestro "correo certificado". Tiene tracking o seguimiento y podemos saber mediante 17track y otras webs por dónde va pasando, siempre que las correspondientes compañías se encarguen de ir actualizándolo. En algunas tiendas este envío es gratuíto (la mayoría) y en otras depende del importe del artículo. El tiempo de envío es prácticamente el mismo y tiene la misma ventaja "aduanera". Sin embargo, existe un límite en el peso del artículo de aproximadamente 2Kg.
Decir también que el vendedor puede elegir diferentes compañías para realizar este tipo de envío, como China Post, Hong Kong Post, Singapore Post, PostNL, Deutsche Post y otras menos conocidas. El funcionamiento de todas ellas es igual, y al final aquí en España lo reparte Correos y tienes que firmar la entrega al cartero.
Expedited shipping.
Este tipo de envío no viene por Correos sino por diferentes agencias de transporte como DHL, UPS, etc. El envío es muy rápido, 4 ó 5 días, pero como contrapartida hay un 99% de probabilidad de que te lo paren en la aduana y tengas que pagar (ver punto siguiente). Además este tipo de envío no suele ser gratuíto sino bastante caro.

Esto es una importación.
Algo que muchas veces se nos olvida y que es muy importante: al comprar en un país extracomunitario estamos realizando una importación, y dependiendo de cómo lo hagamos estamos obviando todo el tema de impuestos que este hecho lleva asociado.
Por un lado, según la ley 37/1992 del Impuesto de Valor Añadido, toda importación está sujeta a IVA; pero además, la base imponible de dicho IVA irá incrementada por los impuestos y gravámenes que se devenguen de la importación y los gastos accesorios. Y da igual que seamos una empresa o un particular.
Por tanto, si lo hiciésemos bien, pagando todos nuestros aranceles e impuestos, la compra que realizamos en una tienda china debería pasar por aduana y pasar por caja, incrementando el gasto al menos en un 21%. Lo que pasa es que casi nadie hace esto, luego veremos por qué. Pero la ley es la ley.
La garantía, esa gran desconocida.
Finalmente está el tema de la garantía. Por norma general, los artículos electrónicos comprados en China tienen 1 año de garantía, no 2 como en España. Pero hay que hacer varias consideraciones sobre esto:

El período de garantía digamos que no es una norma general en el caso de las exportaciones. Hay tiendas que la acatarán y tiendas que no.
Se trata de una garantía en China, de manera que toca mandar el aparato de vuelta si tienes algún problema, y los gastos de España a China son mucho más caros en este caso.
Si el aparato viene defectuoso, queda en manos de la tienda la potestad de cambiártelo por otro o bien considerarlo como garantía, todo esto previo envío a China.
Algunas tiendas te darán la opción de arreglar el aparato en una tienda española de tu confianza siempre y cuando pidas un presupuesto previo y ellos te lo acepten.
Dado el volumen de negocio, algunas tiendas te dan ahora la opción de mandarlo a un servicio técnico español propuesto por ellos.
En todo caso, si tienes una avería te toca confiar en la buena fe del vendedor y tendrás que esperar bastante: primero a que el aparato llegue a China (o al servicio técnico de España y que ellos lo envíen a China); después esperar que su servicio técnico o bien el fabricante arreglen el aparato; y finalmente esperar que te lo vuelvan a mandar. El tiempo puede sobrepasar perfectamente los dos meses.

Medios de pago

Si a pesar de haber leido todo lo anterior eres valiente y sigues queriendo comprar en China, tendremos que hablar del dinero, que es algo que a la gente le duele más que saber a qué tienda se dirige: cómo pagar.

Paypal

El primer medio de pago reomendado y del que casi todo el mundo ha oido hablar es Paypal.

Paypal es un intermediario. Podemos pensar en Paypal como una cuenta corriente que tenemos en otro banco y a la que transferimos el dinero cuando queremos comprar, de manera que el vendedor no conozca tu cuenta real que tienes en tu banco de siempre.

Además de proteger tu identidad bancaria, Paypal tiene otras muchas ventajas, como la protección ante fraudes y los gastos de devolución gratuitos.

El tema de la protección funciona de la siguiente manera: supongamos que vas y compras un teléfono en una tienda online y que después de dos meses el teléfono no te ha llegado.

Si el vendedor admite Paypal, tú has pagado mediante tu cuenta Paypal, que a su vez te ha cargado el coste en tu cuenta corriente o en tu tarjeta de débito o de crédito. Paypal le ha pagado al vendedor y se ha quedado con una pequeña comisión.
En caso de fraude (te han enviado algo que no es lo que compraste) o de no recepción, puedes abrir una disputa. Paypal entonces hará de mediador y se pondrá en contacto con el vendedor, y probablemente te pedirá que demuestres el hecho: documentos, correos electrónicos, fotos, etc. Si el vendedor acepta la disputa, normalmente se va aponer en contacto contigo para llegar a un acuerdo: devolverte el dinero, mandarte otro artículo o lo que sea. En caso de que no se llegue a un acuerdo, Paypal te debe devolver el dinero.

Si la compra se hace en eBay, además hay una ventaja añadida y es que no se te va a cobrar nada hasta que hayas recibido el artículo. También han añadido otra ventaja recientemente y es que te reembolsan los gastos de envío en caso de que sea necesario devolver el artículo.

Abrir una cuenta en Paypal es de lo más fácil del mundo, tan fácil como crearnos una dirección de correo electrónico. Una vez que tengamos nuestra cuenta, hay que añadirle fondos; esto es, decirle dónde va a realizar los cargos correspondientes a los pagos que hagamos con Paypal.

Podemos elegir cargar los gastos en una o más tarjetas de crédito y también directamente como un cargo en nuestra cuenta corriente. Podemos tener un origen de los fondos para todas las compras, o bien elegirlo en cada compra. En cualquier caso, Paypal realizará un pequeño cargo (algunos céntimos) en nuestro origen de fondos con un código que tendremos que rellenar si queremos tener los beneficios de una cuenta registrada.

La cuenta que abrimos en Paypal está en euros al abrirse desde España. Esto quiere decir que los cargos siempre nos los va a hacer en euros, independientemente de la moneda en la que se haga la compra. Si la compra se hace en dólares es Paypal el que hace el cambio, y hay que tenerlo en cuenta a la hora de pagar porque este cambio suele ser menos favorable que el que nos haría nuestro banco, porque incluye una comisión. Antiguamente, en la propia web de Paypal había una calculadora que permitía obtener el importe exacto al que correspondía una cantidad concreta de dólares, pero desde que cambiaron el diseño esta herramienta ha desaparecido.

Alipay

Alipay es otro intermediario parecido a Paypal.

Dicen las malas lenguas que en el origen de los tiempos, cuando hacías una compra en una tienda del grupo Alibaba (Aliexpress, TaoBao, Tmall...) podías pagar también por Paypal. Esto cambió en poco tiempo debido a discrepancias entre las dos empresas (hay que tener en cuenta que Paypal formó parte durante bastante tiempo de la empresa eBay) y por la política del gobierno chino de no tener ninguna dependencia de empresas o sistemas extranjeros.

A partir de ahí surgió Alipay, que es un medio de pago válido (aunque no obligatorio) en los portales indicados, y propiedad de dicho grupo empresarial. La diferencia con Paypal es que Alipay retiene nuestro dinero y no se lo paga al vendedor hasta que el cliente verifica que el producto es correcto, se ha recibido y no se trata de un fraude. Esto está bien en principio, pero para evitar que el vendedor se quede esperando para siempre a que el cliente confirme la recepción, existe un período de protección preestablecido pasado el cual se cierra automáticamente la transacción dándola por buena y pagando finalmente al vendedor. El sistema nos avisará un poco antes de que termine el periodo de protección para que lo ampliemos si es que todavía no hemos recibido nada.

En caso de problemas, también permite abrir una disputa y Alipay responderá en caso de que no se llegue a un acuerdo con el vendedor.

Crear una cuenta en AliPay también es inmediato. A diferencia de Paypal, en este caso sólo se admiten tarjetas como origen de los fondos.

Tarjetas de crédito

Otro medio de pago que se puede utilizar son las tarjetas de crédito (o débito).

Evidentemente, esta forma de pagar es más "peligrosa" porque ya no hay un intermediario entre el cliente y el vendedor, sino que damos directamente nuestros datos (número de cuenta, fecha de caducidad, código de verificación) a alguien del que muchas veces no conocemos mucho. Es cierto que los emisores de tarjetas como Visa y Mastercard tienen ciertos mecanismos de protección frente al fraude, pero yo no recomiendo para nada este tipo de pago. Siempre que sea posible, hay que elegir una tienda que admita pagos por Paypal o bien por AliPay.

Plataformas de compra

A continuación voy a hablar brevemente sobre dónde podemos hacer nuestras compras tecnológicas. Voy a distinguir entre plataformas de compra y tiendas.

Este primer caso, el de las plataformas, sigue siempre el mismo esquema:

Por un lado está el vendedor, que puede ser o bien una tienda física que quiere vender también online, o bien una tienda puramente online, o incluso un particular que quiera vender algo.
Por otro lado está el dueño de la plataforma, que se encarga de poner su infraestructura: un escaparate virtual, unas herramientas de búsqueda, una gestión de cuentas de clientes, una gestión de tiendas para que el vendedor exponga sus artículos, unos accesos a las pasarelas de pagos, etc. El dueño de la plataforma normalmente cobrará al vendedor una comisión por cada venta que realice, en función de muchos criterios: tipo de artículo, volumen de ventas, etc.
Finalmente tenemos al cliente que somos nosotros. Para accede a la plaraforma de compra necesitaremos registrarnos y podremos hacer un seguimiento de lo que hemos comprado, su estado, la posibilidad de reclamar al vendedor, etc.

Lo que hay que saber es diferenciar entre la plataforma, que no vende nada, y el vendedor que puede ser uno u otro para un mismo artículo que busquemos.

eBay

eBay fue la primera plataforma internacional de compras online y todavía hoy sigue siendo de las más importantes y conocidas.

eBay se dio a conocer principalmente por las "subastas", que es una forma de compra en la que el artículo no tiene un precio fijo y son los clientes los que pujan hasta la cantidad que están dispuestos a pagar. Aunque son algo muy interesante, ya veces puedes encontrar algún chollo, no es el mejor método para comprar.

Cuando quieres comprar un artículo tecnológico en eBay, lo primero es saber lo que buscas. Una vez que has localizado un artículo que tiene un precio que te parece bueno, hay que fijarse en los datos concretos del vendedor.Vamos a mirar tres datos fundamentales que nos van a permitir decidir si comprar o no:

Nº de ventas.
En la ficha del artículo podemos ver el número de unidades que el vendedor ha vendido de este artículo. Si se trata de un artículo que acaba de salir al mercado, es normal que haya pocas ventas, pero si se trata de algo que no es nuevo, desconfía de los vendedores que tienen un precio superestupendo pero casi ninguna venta. Por algo será. Es como cuando pasas por la calle y ves un bar con unos precios estupendos pero todas las mesas están vacías... ¿entrarías?
Puntuación del vendedor.
La puntuación del vendedor la ponen los clientes, y éstos pueden votar de forma positiva o bien negativa. En base a esto, un vendedor tendrá mejor puntuación cuanto más contentos hayan quedados sus clientes. Podemos leer también los comentarios concretos que ha dejado la gente al votar, lo que nos puede aclarar muchas cosas.
Antigüedad.
Finalmente, y relacionado con los dos puntos anteriores, tenemos la antigüedad del vendedor. No es lo mismo comprar en un vendedor que abrió la tienda hace 7 años que en uno que la acaba de abrir este mes. Hay muchos casos de tiendas que abren venden unos cuantos de artículos con una calidad muy mala y a los tres meses cierran y se acabó el negocio.

Lógicamente, deberemos sopesar otras cosas, como el medio de pago (Paypal preferentemente), la forma de envío, si es gratuíto o no, si lleva número de seguimiento o no, etc. Una vez realizada la compra ya sólo nos queda esperar y realizar el seguimiento si es posible.

eBay nos aporta la posibilidad de establecer comunicación con el vendedor y de abrir una disputa en caso de que algo vaya mal, como que el artículo no llegue, o llegue estropeado, o bien se trate de una estafa. El plazo para abrir disputa es de 45 días a partir de la fecha de compra, así que tenemos que estar pendiente. Si el artículo no ha llegado en 45 días, abrir disputa por si acaso. Después la disputa se puede elevar en reclamación para que se nos devuelva el dinero si no hay acuerdo.

Aliexpress

Aliexpress es una plataforma de compra del grupo Alibaba. Sus vendedores son en su mayor parte de China y de Hong Kong.

Inicialmente, de cara a occidente sólo,existía la plataforma alibaba.com, que estaba destinada sobre todo a los importadores occidentales que quisieran revender productos chinos, comprándolos en grandes lotes. Al cabo de un tiempo comprendieron que había mucho más negocio si vendías al pormenor, a importadores particulares en lugar de a empresas. Y así surgió Aliexpress.

Aliexpress es una plataforma gigante semejante a eBay, pero sin subastas. En ella puedes encontrar cualquier producto que se fabrique en China, de todo tipo, y su funcionamiento es muy fácil. Aunque a día de hoy, puedes configurar la plataforma para que se vea en español y los precios en euros, yo os recomiendo todo lo contrario: ponerla en inglés y los precios en dólares. Así nos ahorraremos dolores de cabeza al intentar entender la pintoresca traducción automática, y no nos llevaremos a engaños con el cambio de moneda, ya que internamente la plataforma siempre nos cobrará en dólares y será tu banco el que te haga el cambio.

Una vez que realizamos la búsqueda, podemos ordenarla por varios criterios, y aquí os hago las mismas recomendaciones que en eBay. Podemos ordenar los resultados por precio, pero yo os aconsejo hacerlo mejor por número de pedidos o por la puntuación del vendedor (seller rating). También podríamos ordenar por precio pero deberemos ver si el vendedor tiene buena reputación y si ha vendido muchas unidades del artículo.

Dentro de la ficha de un artículo podemos comprobar la puntuación del vendedor y consultar los comentarios de los usuarios. Los comentarios son muy relativos porque hay gente muy exigente o con pocos conocimientos, y también hay gente que se conforma con cualquier cosa, es muy relativo. Lo que más ayuda son las fotos o vídeos en los comentarios de manera que podamos comprobar la calidad o veracidad del producto.

Otra recomendación es usar siempre que sea posible la aplicación móvil en vez del navegador de escritorio. Hay aplicación móvil para Android, iPhone y iPad, y hay muchos artículos que tienen un precio más bajo cuando se compra desde ella.

Para pagar el artículo, podemos hacerlo por tarjeta de crédito/débito o bien por Alipay. En cualquiera de los casos, Aliexpress nos cobra a nosotros pero no le paga al vendedor hasta que se dé por conforme la recepción. Hay un perïodo de protección establecido por cada artículo, y al terminar éste si el cliente no ha dicho nada, se le paga automáticamente al proveedor. Aliexpress nos mandará un correo electrónico unos días antes de que esto ocurra para que nos dé tiempo de solicitar al proveedor que nos extienda el período de protección, a lo que éste accederá normalmente.

Dentro del período de protección podemos abrir una disputa para que el vendedor responda ante una incidencia. Además, cada vendedor puede añadir protecciones adicionales, como por ejemplo que nos devuelva el dinero íntegro en caso de que el artículo no llegue en 60 días, o que nos mande otro artículo en caso de que llegue defectuoso.

Normalmente, los vendedores enviarán el pedido por correo aéreo registrado, con número de seguimiento, y de forma gratuíta. También hay otras formas de envío, incluyendo el envío por correo ordinario o por mensajería. En los dos primeros casos el envío es bastante lento, y las compañías utilizadas suelen ser China Post, Hong Kong Post, Singapore Post, PostNL o Deutsche Post. Todas ellas nos llegarán por Correos, con muy baja probabilidad de tener que pagar en aduanas. Por otro lado, el envío por mensajería es rápido pero caro. Nos llega principalmente por DHL o UPS y tiene alta probabilidad de parar en aduanas.

Una vez que nos llegue el producto, tendremos la oportunidad de marcar el pedido como entregado y dejar comentarios positivos o negativos. Os recomiendo no pulsar el botón en cuanto nos llegue, sino comprobar antes si realmente el artículo funciona bien. En caso contrario, no podremos abrir una disputa.

Yo he comprado muchísimo en esta plataforma a numerosos vendedores y hasta ahora no he tenido ningún problema. Es verdad que alguna vez ha llegado algún artículo mal pero o bien el vendedor o bien Aliexpress han dado la cara. Muy importante sobre todo no dejar que se pase el período de protección.

Taobao

Si Aliexpress es la plataforma china para occidente, Taobao (y más recientemente Tmall) está considerada como el (gigante) eBay de China.

Se trata de otra plataforma del grupo Alibaba donde infinidad de vendedores ofrecen millones de productos a los compradores chinos, con unos precios mucho más bajos que los que ofrecen al mercado exterior. Su funcionamiento es muy semejante a Aliexpress, con las siguientes salvedades:

El único idioma utilizado es el chino.
Sólo se admite el envío a direcciones físicas de China.

Por tanto, si sabes chino y vives allí está muy bien, pero de lo contrario...

Bueno, pues de lo contrario tienes la posibilidad de usar un "agente taobao". Se trata de intermediarios que tienen su negocio en China y admiten pedidos del extranjero. Ellos se encargan de comprar el artículo en Taobao y cuando lo reciben te lo mandan a tí, a cambio de una módica comisión. Después depende de la forma de envío que tengas que pagar aduanas y demás. Los mejores agentes incluyen la posibilidad de pagar con Paypal y la traducción automática a la hora de hacer búsquedas y obtener resultados.

Os pongo algunos de los agentes más conocidos:

taobao.es
yoybuy.com
budybuy.com

Que conste que yo nunca he usado este método. Es verdad que es mucho más barato, pero si le sumas los gastos de envío, la comisión del agente y demás, ya no estoy tan seguro de que merezca la pena.

Tiendas especializadas

Para terminar, os pongo una pequeña reseña de algunas tiendas verificadas y moderadamente fiables, donde yo he comprado y normalmente no he tenido problemas. Ojo: no me hago responsable si os dan algún problema, simplemente digo que yo no los he tenido.

DealExtreme.
Esta fue la primera tienda china en la que compré. Tienen todo tipo de artículos de electrónica y sus precios suelen ser competitivos. No aconsejada para móviles ni tablets porque tienen poca variedad.
Lightinthebox.
Aconsejable para bombillas. Ojo porque aunque tienen mucha variedad, las especificaciones en cuanto a lúmenes son cosa de ciencia ficción.
En cuanto a resolución de problemas funcionan muy bien.
Banggood.
Esta tienda para mi gusto es la que mejor realiza los envíos y mejor soporte tienen. Tienen gran variedad de artículos electrónicos, aunque lo más interesante son las ofertas puntuales, porque normalmente en aliexpress encontraremos mejores precios. Venden pocos móviles pero cuando tienen uno en oferta son casi insuperables.
Pandawill.
Tienda especializada en móviles y tablets. Creo que es en la que más he comprado, seguida de Antelife. Tienen buenos precios y un catálogo grandísimo. Lo más interesante es su "Happy Hour", ofertas diarias en las que puedes conseguir un móvil rebajado.
Antelife.
Otro clásico para móviles y tablets. Sus precios son iguales o ligeramente inferiores a los de Pandawill, y cada semana tienen ofertas limitadas. El soporte bastante bueno.
Otras tiendas especializadas.
Pongo aquí otra lista de tiendas en las que no tengo tanta experiencia. No me hago responsable de su funcionamiento:

Gearbest.
Geekbuying.
1949deal.
Geekvida (con almacén en España).
Tinydeal.

Conclusión

Bueno, pues esto ha sido todo por hoy, al final me he pasado escribiendo.

Espero que a alguien le sirva para tener cabeza y saber lo que hace si tiene el gusanillo de lanzarse a la aventura del comercio chino.

Ahora os toca a vosotros: espero vuestros comentarios y no dudéis en preguntar y matizar todo lo que se os pase por la cabeza.

Gracias.

Componentes (6): Display LCD 16x02

noreply@blogger.com (Isidoro Aguilar Baeza) — Mon, 23 Nov 2015 20:13:00 +0100

El dispositivo que estudiamos hoy es muy útil porque nos puede permitir ver qué es lo que ocurre dentro de nuestro Arduino.

Se trata de una pantalla o display LCD bastante utilizado, un estándar utilizado en multitud de aparatos. Hay varias versiones pero nos vamos a centrar en el que nos permite mostrar 2 líneas de texto de 16 caracteres cada una.

Una pantalla LCD es básicamente una matriz (filas x columnas) de puntos o píxeles en un panel de un material (cristal líquido) que tiene unas características que permiten modificar su transparencia aplicándole una corriente eléctrica de la forma adecuada. Normalmente, un panel LCD no emite ninguna luz, sino que se le aplica una luz de fondo (backlight) por ejemplo a partir de un conjunto de LEDs, y son las propiedades de transparencia u opacidad del material las que hacen que se vea más o menos esta luz de fondo.

Para poder obtener un texto o una imagen del panel LCD, necesitaremos una parte electrónica o controlador que se encargará de traducir lo que queremos representar por una disposición de puntos apagados o encendidos según sea necesario.

El dispositivo del que hablamos hoy tiene un controlador que nos permite representar dos líneas de texto con un máximo de 16 caracteres en cada una. El controlador original (HD44780) está fabricado por Hitachi, pero de él se han hecho innumerables copias por parte de otros fabricantes.

Conexiones

El controlador HD44780 tiene un conexionado paralelo a base de 16 pines, de los cuales se muestra su función a continuación. Paralelo quiere decir que tanto los datos como los comandos se mandan byte a byte, no como una secuencia de bits.

Tierra.
VCC. Alimentación entre 3.3V y 5V.
Ajuste del contraste.
Register Select (RS). RS=0 para comandos, RS=1 para datos.
Read / Write (RW). RW=0 para escribir, RW=1 para leer.
Enable. Puesto a 1 habilita el display, y a 0 lo inhabilita.
Bit 0.
Bit 1.
Bit 2.
Bit 3.
Bit 4.
Bit 5.
Bit 6.
Bit 7.
Positivo de la luz de fondo.
Negativo de la luz de fondo.

El dispositivo dispone de un juego de comandos que nos permiten realizar todas las operaciones de escritura y configuración necesaria, como por ejemplo: limpiar la pantalla, posicionar el cursor, escribir caracteres, etc.

De los 8 pines de datos en realidad podemos utilizar sólo los 4 últimos (11 a 14), dado que el dispositivo tiene un modo de funcionamiento en que se mandan los bytes en dos ciclos de escritura.

Aún así, se ve claramente que conectar un display a nuestro Arduino por paralelo es un problema, porque al menos necesitaremos 7 pines de nuestro Arduino (RS, RW, Enable y los 4 bits de datos). Si nuestro montaje ya incorpora otros dispositivos, es muy probable que nos quedemos sin conexiones disponibles, o bien que tengamos que utilizar un Arduino Mega.

De todos modos, si queréis utilizar así el display, lo podéis hacer perfectamente. Para ello, el IDE de Arduino incorpora de serie la librería LiquidCrystal, con lo cual no tenemos que descargar nada adicional.

Adaptador serie

Otra posibilidad es la de utilizar un adaptador serie que nos permita controlar el display mediante el protocolo I2C.

Este interfaz nos permite controlar un display nada más que con 2 pines (aparte de GND y VCC, claro). Como se puede ver en la imagen, el dispositivo tiene por una cara una hilera de pines que se conecta directamente al bus de 16 pines del HD44780, y por la otra cara tiene 4 pines:

GND.
VCC.
SDA.
SCL.

Los dos primeros son para la alimentación, y los otros dos forman parte del protocolo I2C. Además, en la misma cara tenemos un regulador que nos permite graduar la intensidad de la iluminación del display.

El bus I2C (Inter-Integrated Circuits) es un bus de comunicaciones que nos permite interconectar circuitos integrados mediante un protocolo serie. Este protocolo utiliza la línea SDA para transferir datos y la línea SCL para la señal de reloj.

Como ya se dijo en el artículo sobre Arduino, hay ciertos puertos que tienen un propósito específico, y este es el caso para el bus I2C. Para conectar el interfaz al Arduino, necesitaremos utilizar forzosamente los puertos A4 y A5 del Arduino a los pines SDA y SCL respectivamente.

Además, si queremos utilizar esta configuración, tendremos que utilizar las siguientes librerías:

Wire (incluído en el IDE de Arduino).
LiquidCrystal_I2C (fmalpartida).

Precios

Si queremos utilizar el display tal cual, sólo con el controlador paralelo, podemos comprarlo en Aliexpress por 1,44$ en este enlace.

Por otra parte, pagando un poquito más os lo podéis comprar con el interfaz I2C incluido por 2,12$ en este otro enlace (que es el que yo compré).

Componentes (5): Sensores de temperatura

noreply@blogger.com (Isidoro Aguilar Baeza) — Tue, 17 Nov 2015 21:02:00 +0100

Una de las primeras cosas que se nos viene a la cabeza cuando queremos hacer nuestro primer montaje con un Arduino es medir la temperatura...

Me he comprado un Arduino...

¿Y para qué?

Pues.... quiero hacer un termómetro.

¿Y no tienes un termómetro en casa?

Ya, pero.....

Bueno, vale, es verdad, lo de las estaciones meteorológicas no es ningún invento nuevo, pero... mola más cuando lo haces tú mismo. Además, es mucho menos limitado, podemos hacer muchas cosas: termómetros conectados a internet, una red de termómetros repartidos por todas partes, conexión con LCD's, mostrar las máxima y mínimas diarias, calcular las tendencias....

Vamos a ver dos tipos de componentes que nos permiten medir la temperatura en nuestros montajes.

DHT11 / DHT22

Estos componentes de DFRobot son de los más conocidos a la hora de medir temperatura, por su bajo coste y también por ser de los más fáciles de utilizar. Además de la temperatura, también miden la humedad.

Existen dos versiones, cada una con una precisión distinta:

DHT11.

Mide la temperatura y la humedad en grados enteros (o puntos porcentuales en caso de la humedad). Su rango de temperatura va entre 0ºC y 50ºC, con una precisión de 2ºC, y el de la humedad va entre 20% y 80%, con una precisión del 5%.

DHT22.

Mide la temperatura y la humedad en décimas de grado (o décimas porcentuales), y sus rangos admisibles son de -40ºC a 125ºC con una precisión de 0.5ºC y de 0% a 100% de humedad con una precisión de 2-5%.

Básicamente su comportamiento es idéntico, salvo las diferencias de precisión indicadas. El DHT11 está empaquetado normalmente en color azul mientras que el DHT22, algo más grande y caro, está empaquetado en blanco.

Funcionamiento

Su funcionamiento es muy sencillo: tienen cuatro patillas, de las cuales conectaremos sólo tres. Si miramos el componente tal como se muestran en las fotos, las conexiones son las siguientes:

Alimentación. Requieren de un voltaje de entre 3 y 5V.
Salida. Este pin es el que nos proporciona la medida. La señal que proporciona no es analógica, sino digital.
No conectado.
Masa. Este pin irá conectado a GND.

Para utilizarlo con Arduino, podemos usar una de las muchas librerías que existen, pero yo recomiendo la de Adafruit:

https://github.com/adafruit/DHT-sensor-library

Es importante remarcar la velocidad a la que podemos leer los datos. En el caso del DHT11 podemos leerla como máximo una vez por segundo (1Hz), mientras que en el caso del DHT22 podremos leer como mucho una vez cada dos segundos (0,5Hz).

Para más información y para ver ejemplos de código, os recomiendo esta página de adafruit.

Precios

Si ya habéis leido otras entradas del blog sabréis mi afición por las compras orientales. Pues bien, aquí van algunos enlaces de Aliexpress donde podéis comprar estos componentes:

DHT11: este sale muy barato. En el enlace está a 0.73$ (unos 0.70€).
DHT22: este es el que yo tengo, sale un poco más caro pero nada del otro mundo. 2.50$ (unos 2.38€).

Dallas DS18B20

Este es otro sensor muy conocido. Lo fabrica Dallas Semiconductors y sólo mide la temperatura, no la humedad.

La precisión y el rango de temperaturas son muy similares a los del DHT22: entre -55ºC y +125ºC y precisión de 0.5ºC, y existen muchas formas de empaquetado: en forma de transistor, en forma de integrado para zócalo, impermeable para exterior, etc.

Funcionamiento

La característica más destacable de este sensor es que se comunica por medio un bus denominado "1 Wire", que utiliza un sólo cable (más la masa) tanto para leer los datos como para alimentarse. En un mismo bus "1 Wire" puede haber multitud de sensores conectados (de este o de otro tipo). A la hora de leerlos, se diferencian unos de otros en que cada uno de ellos tiene una dirección física de 64 bits distinta, parecido a las MAC que utilizan las tarjetas de red.

De las tres patillas que tiene el sensor de la imagen, el conexionado es el siguiente, de izquierda a derecha:

GND.
Entrada / salida digital de datos.
Vdd. Alimentación opcional a 5V.

Existen dos modos de funcionamiento:

Modo alimentado.
En este modo se utilizan los 3 pines del sensor. Alimentaremos a 5V por medio del pin 3 y conectaremos el 2 a una entrada digital, con una resistencia de "pull-up" entre los pines 2 y 3. Esta resistencia en principio puede ser de cualquier valor alto, pero os recomiendo encarecidamente que utilicéis una de 4.7KΩ. A mi sólo me ha funcionado así.
Modo parasitario.
En este modo tan sólo se utilizan dos pines, el 1 y el 2, mientras que el 3 lo conectamos a tierra junto con el 1. El sensor "tomará prestada" la alimentación del bus de datos acumulando energía por medio de un condensador interno. Para que funcione bien, tenemos que utilizar de nuevo la resistencia de 4.7KΩ entre +5V y el pin de datos. La diferencia, es que a los sensores sólo mandamos dichos dos pines. En el siguiente esquema se puede ver mejor lo que digo:

A la hora de conectarlo a un Arduino, el pin de datos lo conectaremos a cualquier entrada/salida digital, al igual que los sensores DHT.

En cuanto a las librerías que tendremos que usar, utilizaremos estas dos:

Precios

Este sensor es más barato que el anterior.

Yo lo compré en Aliexpress y aquí tenéis el enlace. Me salieron a 0,53€ cada uno, comprándolo en un paquete de 10.

Y eso es todo por hoy. Hay más sensores de temperatura, pero creo que con estos cubrimos el expediente de momento.

Componentes (4): Programador para Arduino

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 4 Oct 2015 18:32:00 +0200

En el artículo anterior hablábamos de dos modelos concretos de Arduino, el Uno y el Pro Mini. Vimos igualmente que el segundo modelo no trae conexión directa por USB, lo cual es una ventaja (menos coste, tamaño y consumo) y un inconveniente (necesidad de interfaces externas).

Hoy vamos a ver brevemente cómo hacemos para programar el Arduino Pro Mini.

Adaptador CP2102

Arduino implementa un bus denominado UART (Universal Asynchronous Receiver Transmitter) que es una conexión serie que permite comunicarse con otros dispositivos. Utilizaremos este bus para conectarnos al PC y poder programarlo, pero existe un problema: en nuestro PC tenemos otros tipos de buses de comunicación en serie, como RS232 y USB. Por tanto, necesitamos un adaptador o interfaz que nos permita "traducir" la conversación entre ambos extremos. Este adaptador debe convertir además los voltajes, puesto que UART utiliza niveles lógicos TTL mientras que USB no.

Existen muchos fabricantes que venden este tipo de adaptadores, pero básicamente hablaremos de estos dos:

Silicon Labs CP2102.
Este adaptador lo encontramos en este artículo que compré en Aliexpress. Viene un pack compuesto por un Arduino Pro Mini y el adaptador por un precio de 3,71€, o también podemos encontrarlo suelto por unos 1,36€. Como se puede ver es muy barato y tiene una gran ventaja: si lo enfrentamos al lado pequeño del Arduino por donde está accesible el bus UART, sus conexiones van perfectamente emparejadas, sobre todo la conexión entre RXD y TXD, que tienen que ir "cruzadas", esto es: de RX a TX y de TX a RX. Este circuito ya viene así preparado.

Por otro lado, tiene un inconveniente que hay que tener en cuenta:
USB proporciona 5V, y este dispositivo propaga esta alimentación al Arduino por el bus UART. Esto está muy bien si nuestro Arduino funciona a 5V, pero si tenemos el modelo que va a 3.3V, aunque por la alimentación no hay problema porque está en los límites admisibles, sí que podemos tener un problema si desde el Arduino estamos alimentando algún dispositivo que vaya a 3.3V, podríamos quemarlo.
Hay que tener esto en cuenta ya que podemos tener nuestro montaje preparado con sus dispositivos conectados y a la hora de programarlo podemos quemar algo. Para evitar esto, podríamos desconectar el pin VCC del adaptador, para que la alimentación la coja Arduino de otra patilla.

Por otro lado, su utilización es muy sencilla. En esta foto podemos ver un detalle de cómo lo podemos conectar al Arduino, gracias a que trae unas patillas que puedes soldar a modo de zócalo. Lo pinchas en el Arduino y a programar. Insisto, siempre que no tengas dispositivos sensibles que vayan a 3.3V.
Por la parte del conector USB lo conectamos al PC y nos aparecerá un nuevo puerto serie que es el que tenemos que utilizar para mandar el programa desde nuestro IDE. Si por lo que sea, tu ordenador no te reconoce el dispositivo, en esta página tenéis los drivers:

https://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx
FTDI FT232R.
Este otro chip es de FTDI (Future Technology Devices Technology) y lo incorpora este otro artículo que también compré en Aliexpress, por uno 1,62€. Lo compré para evitar el problema que acabo de describir, porque la ventaja que tiene es que tú configuras mediante un puente a qué voltaje quieres trabajar: a 5V o a 3.3V.
En otro orden de cosas, la conexión es igual de fácil que en el otro chip, con la diferencia de que tienes que ponerlo "boca abajo" con respecto al Arduino, y no "enfrentado" como era el otro. Hay que fijarse mucho en las conexiones. La clave está de nuevo en los pines RX/TX que debemos asegurarnos de que van del receptor al transmisor y viceversa.

Con este además tuve problemas de detección inicialmente por parte de Windows, por lo que os pongo un enlace a los drivers oficiales por si os pasa lo mismo. Una vez instalado el driver, el ordenador lo detecta como un nuevo puerto COM.

http://www.ftdichip.com/Drivers/VCP.htm

Y eso es todo por hoy.

Componentes (3): Arduino UNO y Pro Mini

noreply@blogger.com (Isidoro Aguilar Baeza) — Sat, 19 Sep 2015 21:45:00 +0200

En este artículo hablaremos un poco del "cerebro" de algunos de los montajes que haremos. Se trata de Arduino, una plataforma de hardware libre enfocada al aprendizaje de microelectrónica que ha tenido una repercusión bestial a nivel mundial, teniendo una amplísima comunidad detrás que en sus 10 años de vida ha generado literalmente millones de programas y librerías de código abierto al alcance de todos.

Un poco de historia

Arduino es un proyecto que se inicia en Italia en 2005 como soporte para hacer prácticas de electrónica en el Instituto de Diseño Interactivo de la ciudad de Ivrea.

No es que no hubiera en aquella época plataformas de experimentación y microcontroladores programables, pero el problema era que su hardware era cerrado; esto es, eran los fabricantes los que diseñaban las placas, las conexiones, los componentes, etc y al usuario final se le vendía como un producto hecho tan sólo especificando el modo de programarlo.

Con el auge del software libre en mente, los creadores de Arduino pretendían fomentar el uso de una plataforma totalmente abierta, en su software y también en su hardware, mediante la utilización de componentes baratos y ampliamente conocidos, entregando a la comunidad el diseño de las placas de manera que cualquier persona pudiera o bien comprar un Arduino por poco precio o bien construírselo el mismo, bien en forma de kit o construyéndolo desde cero con sus fotolitos, sus soldaduras, etc.

El proyecto no sólo incorporaba una placa de hardware, sino también un bootloader para el microcontrolador, un lenguaje de programación y un entorno de desarrollo que funciona tanto en Windows como en Mac y en Linux, todo de código abierto. El coste total de las primeras unidades debía ser inferior a los 30€.

Con el tiempo, el proyecto saltó del entorno educativo al gran público: aficionados a la electrónica, diseñadores de hardware, empresas, etc. La comunidad de personas que utilizan Arduino en sus proyectos es gigantesca y prácticamente se puede hacer de todo con ellos.

Además, recientemente con el auge de las compras de componentes electrónicos directamente a los fabricantes (China) y a precios irrisorios, montar un proyecto electrónico es francamente fácil y barato, que es lo que vamos a ver en próximos artículos.

Para el que quiera ver un poco más de historia de Arduino en detalle, os recomiendo ver el siguiente documental (en español):

Componentes

El núcleo de Arduino es un microcontrolador de la marca Atmel.

¿Que qué es un microcontrolador? Pues un microcontrolador es un ordenador en miniatura; se trata de un circuito integrado que, a diferencia de muchos otros circuitos de propósitos específicos, es programable, y tiene su CPU, su memoria y sus interfaces de entrada/salida para comunicarse con otros dispositivos.

Por otro lado, la marca Atmel os sonará a algunos si habéis conocido el mundo de la "educación" de tarjetas decodificadoras de televisión por satélite. Por los tiempos de Vía Digital, se utilizaba un microcontrolador (el AT90S8515 principalmente) de Atmel para programarle cierto código que permitía ver "florecer" los canales emulando la codificación Nagravisión. En aquellos tiempos, este Atmel era un chip que había que programar con un programador externo que se conectaba al PC por medio del puerto serie o paralelo.

Pues bien, el microcontrolador que utilizan los Arduino son una evolución de aquellos Atmel, específicamente los modelos Atmega168, Atmega328, Atmega1280, Atmega8 entre otros. El modelo específico de microcontrolador que se incorpore implicará las principales diferencias entre los distintos modelos de Arduino, como su capacidad de memoria, de almacenamiento, su velocidad, el número de puertos, etc. En la siguiente tabla podemos ver una relación entre el modelo de Arduino, el microcontrolador que usa y sus características principales:

Arduino	Microcontrolador	Voltaje	Velocidad	RAM	Flash	EEPROM	Puertos Digitales	Puertos Analógicos
UNO R3	Atmega328P	5V	16Mhz	2KB	32KB	1KB	14 (6 PWM)	6
Mega R3	Atmega2560	5V	16Mhz	8KB	256KB	4KB	54 (15PWM)	16
Pro Mini 3.3V	Atmega328	3.3V	8Mhz	2KB	32KB	1KB	14 (6 PWM)	6
Pro Mini 5V	Atmega328	5V	16Mhz	2KB	32KB	1KB	14 (6 PWM)	6
Arduino DUE	AT91SAM3X8E	3.3V	84Mhz	96KB	512KB	-	54 (12PWM)	12
Arduino Lilypad	Atmega168V	3.3V	8Mhz	1KB	16KB	512B	14 (6 PWM)	6

Hay muchos más modelos que los que se muestran en la tabla, pero nos sirve para hacernos una idea. Como se puede ver, tenemos varios parámetros a tener en cuenta y que condicionarán nuestra elección, como por ejemplo:

Voltaje de funcionamiento.
Hay modelos que funcionan a 5V y otros que lo hacen a 3.3V.
Velocidad.
A más velocidad, más consumo del microcontrolador. Nos condicionará si queremos alimentarlo a baterías.
RAM.
El microcontrolador incorpora una memoria volátil para almacenar datos temporales (variables de nuestro programa).
Flash.
Además, también incorpora un chip de memoria no volátil para el almacenamiento de nuestro programa. Si vamos a hacer un programa muy grande, tendremos que elegir un tipo adecuado de Arduino.
EEPROM.
El micro también incorpora memoria no volátil de propósito específico: almacenar configuraciones y parámetros que no forman parte del código.
Entradas/salidas digitales.
Cada modelo tiene un número de puertos digitales de entrada y salida. Algunos de ellos tienen propósitos específicos como servir de puerto serie de comunicaciones, o conectar con otros dispositivos por medio de los protocolos I2C o ISP. Además, algunos de estos puertos pueden funcionar como salidas "pseudo-analógicas" PWM.
Entradas analógicas.
Cada modelo tiene también una serie de puertos de entrada analógicos, conectados a un conversor analógico/digital.

Arduino UNO

Este modelo de Arduino es el más adecuado para todo principiante. Está basado como hemos visto en la tabla superior en el microcontrolador Atmega328P de Atmel, y funciona con 5V y a 16Mhz.

La placa tiene, además del microcontrolador, un oscilador de cristal a 16Mhz, un botón de reset, un regulador de tensión de 5V, un conector hembra para USB-B y un conector para un alimentador externo. Además, para comunicarse mediante el puerto USB incorpora otro controlador, el Atmega16U2.

Puertos

Dispone de 14 pines de entrada/salida digital (numerados del 0 al 13), algunos de los cuales tienen propósitos específicos:

0 y 1: Se utilizan como consola de comunicaciones serie, para poder leer y escribir caracteres y comunicarse así con el mundo exterior. El 0 es para la recepción y el 1 para la emisión. Ambos pines están replicados también por el puerto USB, de manera que podemos comunicarnos con el ordenador al que esté conectado.
2 y 3: Sirven como entradas de interrupción. Podemos conectarlas a un dispositivo que emita una alerta cuando cambie un estado, cuando se reciban datos, etc.
3, 5, 6, 9, 10 y 11: Se pueden utilizar como salidas analógicas PWM. Al escribir un valor entre 0 y 255 producirá un voltaje entre 0 y 5V de forma uniformemente distribuida.
10, 11, 12 y 13: Se pueden utilizar para conectar dispositivos siguiendo el protocolo SPI.
13: Lleva conectado un LED que hay en la placa. Este se encenderá cuando configuramos el puerto como salida y escribimos un 1.

Además también existen 6 puertos de entrada analógica (A0 a A5) que están conectados a un conversor analógico/digital de 10 bits.

Alimentación

En cuanto a la alimentación, hemos dicho que el microcontrolador funciona a 5V, pero la placa generalmente necesitará algo más de voltaje para funcionar. El regulador se encargará de proporcionar los 5V a partir de la tensión de entrada. Existen las siguientes posibilidades a la hora de alimentar la placa:

A través del conector USB. Si tenemos el Arduino conectado al ordenador, además de servirnos para programarlo y para tener acceso a la consola serie, podemos alimentarlo a través del mismo cable. La tensión es entonces de 5V.
A través del conector de alimentación externa. Este conector admite entre 6V y 20V, pero normalmente deberemos proporcionar un mínimo de 7 si queremos que el regulador de tensión y la placa funcionen de forma estable.
A través del pin Vin. Este conector está unido a la entrada anterior, y podemos alimentarlo con el mismo voltaje.
A través del pin 5V. Este conector realmente es una salida que proviene del regulador cuando alimentamos el Arduino por cualquiera de las entradas anteriores. Normalmente no debe usarse de entrada, a menos que no tengamos nada más conectado en el resto y que la tensión que proporcionemos sea exactamente de 5V regulados.

Además existe un pin 3.3V que funciona normalmente como salida regulada a dicha tensión. Su salida nos proporciona un máximo de 50 mA que podemos utilizar para alimentar periféricos.

Arduino Pro Mini

Este otro modelo es apropiado para montajes independientes, sin necesidad de tener el Arduino conectado al ordenador y pudiendo alimentarlo mediante un transformador o bien pilas o baterías.

Su tamaño es mucho más pequeño y tiene ciertas carencias con respecto al UNO dado el uso que se le va a dar.

La principal carencia que tiene es que no tiene puerto USB. En su lugar, cada vez que queramos programarlo deberemos conectarlo porlos conectores del lado derecho de la imagen con un adaptador FTDI, que nos permite adaptar los niveles lógicos del circuito con los de la conexión USB.
Otra carencia es que en lugar de tener unos zócalos para pinchar conectores directamente, sólo dispone de pequeños orificios en su lugar, en los que podremos soldar patillas para montar en tableros o bien directamente los cables que necesitemos.
Finalmente este Arduino sólo tiene un regulador, por lo que no podremos alimentar dispositivos externos que tengan un voltaje distinto al propio del Arduino.

Por lo demás, las características son las mismas que las del Arduino UNO en cuanto a memoria y conectores, distinguiéndose sólo en cuanto a voltaje y velocidad. Existen de hecho dos variantes distintas de este Arduino:

Arduino Pro Mini 5V.
Funciona a 5V y 16Mhz, y se puede alimentar por el conector "RAW" con una tensión de entre 5V y 12V, o bien por medio del conector "VCC" por donde deben entrar exactamente 5V.
Arduino Pro Mini 3.3V.
Este otro funciona a 3.3V y 8Mhz, siendo el más adecuado para montajes en los que se requiera muy poco consumo. Se puede alimentar de igual forma por RAW entre 3.3V y 12V o por VCC con 3.3V. Es muy interesante leer este artículo de mysensors.org en el que hacen una modificación a este Arduino para que se pueda alimentar sólo con dos pilas AA, a 3V. La modificación consiste básicamente en eliminar el LED de encendido y el regulador de 3.3V.

Clónicos

Como hemos dicho al principio, Arduino es una plataforma de hardware libre, lo que quiere decir que o bien puedes comprarlo en los canales y tiendas "oficiales", o bien puedes irte a la página oficial (www.arduino.cc) y descargarte los esquemas de la placa que quieras y montarla tú mismo añadiendo, modificando o eliminando lo que quieras.

También quiere decir que cualquier otro fabricante puede construir su propio Arduino y venderlo al precio que quiera. Dada mi afición a la importación al por menor desde China, mis Arduinos son todos clónicos y procedentes del Oriente. Os dejo unos enlaces a algunos de los productos que he comprado:

Clónico del Pro Mini 3.3V

Arduino UNO R3 modificado.
Este dispositivo es un Arduino UNO que en lugar del Atmel Atmega328P "normal" utiliza el Atmega328P-AU que es exactamente igual pero empaquetado en un formato mucho más reducido (y barato). Otra modificación con respecto al original es que, en lugar de utilizar el Atmega16U2, utiliza el chip CH340G que es mucho más barato y da menos problemas con Windows 8 y superiores. Este artículo en concreto de Aliexpress incorpora un cable USB para conectarlo al ordenador y sale por unos 2,93€. Si ya tenéis un cable de este tipo (USB-A a USB-B, el de las impresoras) os podéis ahorrar todavía más.
Lote de 5 Arduinos Pro Mini 3.3V.
Es un pedido de 5 Arduinos clónicos por un total de 8,23€ (1,65€ la unidad). Según dicen en las especificaciones, el rango de voltaje admitido es más amplio que el del original, llegando a permitir hasta 15V (yo no lo probaría). Recomiendan utilizar el pin VCC si el voltaje está entre 2,7V y 5V o bien el RAW en caso de que sea superior a 5V.
Lote de Arduino Pro Mini 3.3V + Programador FTDI.
Finalmente, este lote lo compré porque era más barato que comprar el programador por separado. Se trata de un Arduino como los anteriores y un programador FTDI que se puede conectar directamente al Arduino. El lote completo sale por 3,64€ en Aliexpress. Es importante señalar que este programador entrega 5V de alimentación siempre, aunque el Arduino sea de 3.3V.

Proyecto Ibertren: Presentación

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 6 Sep 2015 22:13:00 +0200

Introducción

Cuando yo era pequeño, uno de los hobbies que tenía era el modelismo de trenes en miniatura.

Los que tengan una edad parecida a la mía, recordarán la marca IBERTREN, una empresa dedicada a hacer trenes de juguete en miniatura que en aquella época no existían en España. Inicialmente, se dedicó a la escala N (9mm entre raíles), y todas las vías tenían 3 contactos: los dos raíles más un contacto central sobre el que se desliza un patín de la locomotora. Por esta razón, esta escala pasó a denominarse más tarde como 3N. Mientras tanto, en el modelismo "de verdad" la escala era 2N, esto esto es: la corriente se toma de los dos raíles, uno positivo y otro negativo.

Más tarde, Ibertren entró también en la escala HO, mucho más grande, y eventualmente también hizo modelos en escala 2N, pero eso es otra historia.

La cosa es que yo tenía una maqueta de Ibertren, con tres trenes distintos, uno de pasajeros, un talgo completo y uno de mercancías, cada uno con su respectiva locomotora. Aquí os adjunto algunas fotografías de cómo se conserva la maqueta a día de hoy.

Lamentablemente, el transformador original que traía el Ibertren se estropeó. Mi padre, que siempre ha sido bastante manitas para la electrónica, me hizo otro transformador y reutilizó algunas partes del original, y además añadió ciertas "características" como un silbato y un control de luces de las casas de la maqueta.

La cosa es que la maqueta se abandonó debajo de una cama durante muchos años, y a día de hoy aunque bien conservada, no funciona el alimentador porque el circuito se rompió.

Tres generaciones, una afición

Algunos detalles de la maqueta

Como se puede ver, queda un buen trabajo de restauración

Objetivos

Mi objetivo en este proyecto no es tan sólo arreglar el alimentador sino, dados los tiempos que corren y las nuevas tecnologías que ahora existen (han pasado 30 años) vamos a intentar "modernizar" un poquito el asunto.

Mi intencion es utilizar un Arduino para mover todo el invento, y esta es mi lista de intenciones:

Control suave de los trenes.
Arduino incorpora salidas PWM que no son analógicas pero se comportan como tales, ya hablaremos un poco más de esto más adelante. La ventaja es que el avance de las locomotoras a velocidades bajas es bastante más eficiente y suave que la simple regulación de voltaje que se hacía habitualmente en los circuitos analógicos.
Control digital de la marcha.
Antiguamente, para cambiar la marcha de los trenes, el controlador de Ibertren disponía de un conmutador que cambiaba el sentido de la corriente. Si el tren estaba en marcha, esto era catastrófico: imagínate meter marcha atrás en el coche cuando éste está en movimiento... Con un control digital podemos programar el Arduino de manera que cuando solicitemos el cambio de sentido, éste puede reducir la velocidad hasta cero, cambiar la polaridad y después incrementar de nuevo la velocidad hasta donde estaba anteriormente.
Display digital.
¿Por qué no ponerle al invento un display que nos muestre información como la velocidad, la marcha, o lo que se nos ocurra?
Sonidos personalizados.
La maqueta tenía como os he dicho un circuito que hacía sonar un silbato al pulsar un botón. Con un Arduino podemos tener muchos tipos de sonidos grabados en MP3 (o WAV) que se activen con un panel de distintos botones: campanas de la estación, silbato, locuciones, etc. Hay componentes baratísimos que nos permiten reproducir sonidos almacenados en una microSD y controlándolo desde Arduino.
Control de iluminación.
La maqueta dispone de varias casas que tenían una pequeña bombilla de 12V. Hay un interruptor general que nos permite encender o apagar las luces. Mi intención es sustituir este circuito por LED's de bajo consumo y voltaje (3.3V - 5V) y alta luminosidad. Además podemos programar el encendido o apagado automático, disminuir o aumentar la luminosidad al pulsar un botón, etc.

Hay ciertas cosas que todavía tengo que pensar, pero las posibilidades son muy grandes: por ejemplo podríamos poner sensores de presencia en ciertos puntos del circuito de vías y detener los trenes si hay un obstáculo, o activar automáticamente los cambios de vía eléctricos, etc. Ya veremos lo que da de sí.

Análisis de requerimientos

A continuación, vamos a ver qué elementos vamos a necesitar para realizar el proyecto.

Primero, veamos qué circuitos de corriente vamos a necesitar:

Los trenes de Ibertren en la escala N (3N) funcionan con corriente continua a 12V, y su control es analógico; esto es, se regula su velocidad modificando el voltaje entre 0V y 12V. Para el cambio de sentido simplemente se invierte la polaridad, alimentándolos entre -12V y 0V. En cuanto a la corriente máxima necesaria, creo (a ojo de buen cubero) que con 2A tendremos bastante para mover un máximo de 2 locomotoras. Si no recuerdo mal, he leído en algún sitio que el alimentador original de Ibertren proporcionaba un máximo de 2,5A, pero compartido entre 12V alterna y 12V continua. Por lo tanto, vamos a necesitar un circuito de 12V DC 2A.
Tengo que especificar que con nuestro Arduino no vamos a proporcionar realmente corriente continua sino PWM, es decir corriente "pulsada", pero para el caso nos vale.
Además, la maqueta dispone de cuatro cambios de vía eléctricos. Estos cambios consisten en un doble electroimán y un núcleo metálico que se desplaza en un sentido u otro. Estos electroimanes se alimentan a 12V con corriente alterna mediante unos pulsadores. Vamos a suponer también que la corriente máxima es de 2A. Por tanto, vamos a necesitar otro circuito de 12V AC 2A.
Finalmente está la alimentación de todo lo demás: necesitamos alimentar un Arduino, unos LED's y otra serie de componentes electrónicos: display, amplificadores PWM, reproductor de MP3... Para todos estos elementos lo ideal es una alimentación a 5V en continua. Por tanto vamos a necesitar un tercer circuito a 5V DC. Ya veremos la corriente máxima necesaria, pero no creo que supere 1A.

Por tanto, estos son los requerimientos a primera vista:

Un transformador de 220V AC a 12V AC. Creo que en la maqueta debe haber alguno que funcione todavía y en caso contrario habría que comprar uno. Con él alimentaremos el circuito número 2 (desvíos eléctricos).
Un alimentador que nos dé 12V DC y 5V DC. Podríamos construir uno que nos dé estas tensiones o bien podemos comprar este alimentador de discos duros que nos da 2A en cada circuito independiente a 12V y a 5V. Cuesta unos 2,74€ en Aliexpress y con él podemos alimentar los circuitos números 1 y 3 (motores y electrónica).
Un Arduino a 5V.
Podemos utilizar un Arduino UNO o un Pro Mini. Opto por el segundo por ser más barato y ocupar menos espacio. 1,41€ en Aliexpress.
Un display digital.
Hay muchos displays LCD disponibles que nos permiten mostrar 2 líneas de 16 caracteres cada una. Normalmente utilizan un protocolo de comunicación en paralelo, es decir, utiliza 8 líneas de datos al mismo tiempo. Si no queremos quedarnos sin pines disponibles en el Arduino, deberemos utilizar un adaptador al protocolo serie. Se puede conseguir un pack con los dos componentes por 1,96€ en Aliexpress, y sólo tendremos que utilizar 4 pines incluyendo la alimentación.
Un amplificador de potencia PWM.
Si nuestro Arduino funciona a 5V, el voltaje máximo que podremos sacar por los pines PWM será de 5V, insuficiente para alimentar el circuito de los motores de los trenes. Además necesitaremos mucha más intensidad de corriente de la que nos va a proporcionar el Arduino (unos 2A según hemos estimado). Por tanto, necesitaremos construirnos un circuito amplificador basado en un transistor que nos controle hasta 12V a partir de los 5V del Arduino. O también podemos comprar este componente que está ya diseñado específicamente para motores y cuesta unos 1,72€ en Aliexpress y permite controlar dos canales independientes de 2A cada uno y para un voltaje de entre 5V y 35V.
Un reproductor de sonidos.
Este componente es opcional, pero mola. Se trata del DFPlayer Mini, un mini reproductor de MP3 (o WAV, o WMA) que incorpora un lector de tarjetas microSD y puede reproducir ficheros de música (o sonido) de forma independiente o controlado por un Arduino. Se puede conectar directamente a un altavoz y también tiene una salida de línea. Cuesta 5,48€ en Aliexpress.
Algunos pulsadores.
Vamos a necesitar varios pulsadores, tanto para el cambio de sentido como para activar y desactivar el alumbrado como para el reproductor de sonido.
Para el cambio de sentido me han gustado estos que tienen una tapa en forma de flecha e incorporan iluminación mediante LED's. Midem 1 cm de diámetro y cuestan 4,56€ en Aliexpress el lote de 5 pulsadores.
Para el resto, podemos utilizar estos otros, que sólo cuestan 0,69€ el lote de 20 en Aliexpress.
Unos cuantos de LED's.
También vamos a necesitar LED's, tanto para la iluminación como para indicar ciertas cosas, como el funcionamiento del circuito como para indicar que las luces están activadas, o para lo que sea. En Aliexpress venden este lote de 100 LED's en blanco por 0,98€. O si los queremos en colores también tenemos este otro lote de 100 LED's en 5 colores (20 de cada) por 1,03€. Todos ellos son pequeños (3mm de diámetro), de alta luminosidad y admiten un voltaje máximo de 3,4V, lo que podemos conseguir por medio de algunas resistencias a partir de los 5V que tenemos en el circuito 3.

Finalmente, también habrá que buscar otra serie de componentes, como un potenciómetro que gire menos de 180º entre la posición mínima y la máxima (es posible que valga el que tiene el circuito antiguo); una bonita cubierta para el mismo; una caja para montar la consola con el display, el potenciómetro, los botones, etc (o ya veremos si utilizamos la propia consola de Ibertren aunque sea un sacrilegio para coleccionistas); cable, resistencias, condesadores, etc.

Quitando todas estas cosas, de momento vamos por unos 19€ de presupuesto, que no está nada mal.

Siguientes pasos

Antes de seguir adelante, tengo que hacer algunas mediciones en la maqueta, para ver qué se puede aprovechar y qué hay que comprar. En cuanto lo tenga claro, pediré los componentes e iremos estudiando cómo funciona cada uno de ellos para realizar el montaje de todos. Seguramente este artículo lo vaya modificando a medida que vaya dando dichos pasos.

Componentes (2): Transceptor inalámbrico nRF24L01+

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 16 Aug 2015 18:26:00 +0200

En el artículo de hoy vamos a conocer otro componente muy útil para nuestros montajes: el transceptor inalámbrico nRF24L01+.

Se trata de un transceptor inalámbrico, esto es, un dispositivo capaz de funcionar como transmisor y como receptor por medio de radiofrecuencia. La banda de radiofrecuencia utilizada es la ISM (Industrial, Scientifical and Medical), una banda reservada para su uso no comercial por parte de particulares, y concretamente el rango de frecuencias desde 2,400 a 2,500 Ghz que todos conocemos por ser el utilizado por microondas, WIFI, Bluetooth, teclados y ratones inalámbricos, y multitud de otros aparatos.

Este dispositivo, fabricado por Nordic Semiconductor, nos permitirá comunicar un dispositivo (arduino o de cualquier otro tipo) con otro, pudiendo funcionar como emisor o receptor en cada momento. Hay multitud de artículos en los que se puede encontrar información sobre él, de manera que paso a destacar sus características principales.

Primero lo que no es:

El nRF24L01+ no es un dispositivo WIFI, aunque utilice la misma frecuencia.
Tampoco se trata de un dispositivo Bluetooth, aunque hay personas, como Dmitry Grinberg, que han conseguido empaquetar parte del protocolo Bluetooth LE mediante el dispositivo y comunicarse de una manera algo rudimentaria con otros dispositivos Bluetooth.

Lo que sí es:

Se trata de un dispositivo inalámbrico de ultra-baja potencia. Su pico de consumo cuando está recibiendo o emitiendo es de 14 mA, cuando está en modo de reposo 26 μA, y cuando está en modo "apagado" es de 900 nA. El tiempo de activación cuando está en uno de estos modos es rapidísimo, lo que facilita su utilización en entornos con necesidades de muy bajo consumo.
Utiliza la banda de 2,4 Ghz a 2,525 Ghz para la comunicación, y puede hacerlo a una velocidad de 250kbps, 1 Mbps o 2 Mbps. Su alcance máximo (en abierto y sin obstáculos) puede llegar a los 200 metros, lo cual no está nada mal.
Puede utilizar cualquiera de los 126 canales disponibles en su rango de frecuencias.
Puede mandar secuencias de datos hasta 32 bytes seguidos en modo "ShockBurst" (ráfagas).
6 canales de datos simultáneos para comunicación en estrella con otros dispositivos iguales. Cada uno de estos canales debe tener una dirección, que debe ser igual en el receptor que en el emisor. Estas direcciones son un número de entre 3 y 5 bytes. Se recomienda para evitar errores que los bits de la dirección cambien de nivel (de 0 a 1 o de 1 a 0) varias veces.
En las especificaciones del fabricante indica que puede funcionar con una alimentación de entre 1,9V a 3,6V, aunque según lo que yo he leído parece ser muy quisquilloso y deberíamos alimentarlo siempre a 3,3V. Ya veremos cómo se comporta con un par de pilas AA, que es como quiero probarlo...
Su coste es muy bajo, tirando a ridículo. En la foto de arriba podéis ver el que yo he comprado en Aliexpress por un precio de 0,60€, con los gastos de envío incluídos desde China y puesto en casa. Es verdad que yo he pedido 10 y así salen más baratos, pero aún así el precio es ridículo. Os pongo el enlace del mío por si le interesa a alguien:

http://www.aliexpress.com/item/Free-Shipping-10PCS-NRF24L01-wireless-data-transmission-module-2-4G-the-NRF24L01-upgrade-version-We-are/1680738017.html
En cuanto a la comunicación inalámbrica, utiliza un protocolo propio que asegura la integridad de los paquetes, reenviando paquetes que se pierdan de forma transparente y devolviendo un "ACK" que asegura al emisor que el mensaje ha llegado al receptor.
En cuanto a la comunicación con controladores como el arduino, utiliza el protocolo SPI (Serial Peripheral Interface), un estándar utilizado en los equipos electrónicos para transmitir información de un integrado a otro. Las señales estandar de dicho protocolo están disponibles en sus patillas según el siguiente esquema:

Y este es el significado de cada una de ellas:

GND: Tierra o masa común.
VCC: Conector de alimentación. En las especificaciones se indica que debe estar comprendida entre 1,9V y 3,6V. OJO: nunca alimentar a 5V o adiós transceptor.
Por internet hay multitud de comentarios acerca de que la alimentación debe ser exclusivamente de 3,3V y muchos incorporan un pequeño condensador entre las patillas 1 y 2 para estabilizar la alimentación. En mis pruebas voy a intentar alimentarlo a 3V a partir de pilas, a ver qué tal va.
CE (Chip Enable): Hay que ponerlo a 1 cuando queramos recibir o enviar datos.
CSN (Chip Select Not): Hay que ponerlo a 0 cuando queramos mandar un comando SPI al dispositivo desde el controlador.
SCK (SPI Clock): Señal de reloj para el protocolo SPI.
MOSI (Master Output Slave Input): Esta línea sirve para enviar datos desde el controlador (denominado maestro) al dispositivo inalámbrico (denominado esclavo).
MISO (Master Input Slave Output): Esta línea hace lo contrario, enviar datos desde el dispositivo inalámbrico (slave out) al controlador (master in).
IRQ: Esta línea de interrupción se activa en determinadas circunstancias alertando al controlador. Se puede programar para que se ponga a 1 cuando se reciba un paquete de datos, o cuando se termine la transmisión, etc.

El funcionamiento del protocolo SPI en este dispositivo se sale del ámbito que quiero darle a este artículo; se trata de una serie de comandos a bajo nivel que se asemejan mucho a la programación en código máquina, escribiendo valores en registros concretos del dispositivo. No obstante, si alguien quiere hacerse su propia librería para programarlo, puede encontrar todo muy bien documentado en el este artículo de gizmosnack.

Y eso es todo por ahora. Sólo decir que para utilizar el dispositivo desde Arduino hay numerosas librerías, como ésta, ésta, ésta, ésta, ésta, ésta, ésta, ésta o muchas otras. Cuando haga más pruebas os diré la que yo voy a usar.

Componentes (1): Sensor de corriente SCT013

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 9 Aug 2015 03:23:00 +0200

Con la entrada de hoy comienzo una serie de entradas en las que voy a describir algunos de los componentes eléctricos/electrónicos que voy a usar en mis montajes. Yo no es que sea un genio en el campo de la electrónica ni de la electricidad: lo poco que estudié fue ya hace muchos años, pero conozco los fundamentos porque siempre me ha gustado. Como curiosidad, todavía en casa de mis padres conservo un par de cajas de Electro-L como el de la imagen:

(No, el de la foto no soy yo, aunque lo parezca...)

Lo que quiero decir con esto es que voy a intentar explicar los fundamentos como para tontos, y así nos enteramos todos, incluido yo.

El transformador

Para entender el funcionamiento de nuestro sensor de corriente eléctrica, tenemos que hablar antes del transformador (enlace a Wikipedia)

Un transformador es uno de los componentes fundamentales de la distribución de la electricidad tal y como la conocemos hoy. Su fundamento es la inducción electromagnética: ese famoso fenómeno que he tenido que volver a aprender este año al preguntarle a mi hija de 12 años un tema de Conocimiento del Medio que dice que al mover con rapidez un campo magnético en las cercanías de un conductor eléctrico enrollado a modo de espiral sobre un núcleo de hierro, en dicho conductor se produce una corriente eléctrica que es proporcional a la velocidad con la que muevas el campo magnético, y viceversa; que al recorrer una corriente eléctrica pulsante por dicho conductor se induce un campo magnético proporcional...

El transformador hace uso de los dos efectos al mismo tiempo. Básicamente son dos bobinas enrolladas sobre un núcleo común (normalmente un núcleo de hierro o ferrita en forma circular o cuadrangular). Al circular una corriente alterna sobre la bobina número 1 (el primario), esto genera un campo magnético que se propaga por el núcleo común, induciendo una nueva corriente en la bobina número 2 (el secundario).

Una de las características más interesantes de este componente es que en él confluyen dos circuitos eléctricos independientes, cada uno con unas características, pero la potencia se conserva (idealmente, aunque siempre puede haber alguna pérdida) en ambos circuitos. Otra de las características interesantes es que la intensidad de la corriente inducida en el secundario es inversamente proporcional al número de vueltas de su bobina, y directamente proporcional al número de vueltas de la bobina principal. De este modo, obtenemos las siguientes fórmulas:

V_p * I_p = V_s * I_s (potencia invariable)

N_p/N_s = I_s/I_p(proporcionalidad de las intensidades)

Siendo V_p el voltaje del circuito primario, V_s el del secundario, N_p el número de vueltas de la bobina del primario, N_s el número de vueltas del secundario, I_p la intensidad de la corriente que circula por el circuito primario e I_s la que circula por el secundario.

Pongamos un ejemplo para comprender todo esto. Si tenéis una cierta edad, supongo que habréis conocido esos transformadores que había en nuestras casas cuando teníamos la corriente a 125V y las televisiones y otros electrodomésticos funcionaban a 220V. Estos transformadores tenían por tanto un primario cuyo V_p = 125V y un secundario cuyo V_s = 220V. Si nuestra tele tenía un consumo digamos de unos 100W, podemos calcular las intensidades de ambos circuitos porque sabemos que la potencia es (aproximadamente) la misma a ambos lados del transformador:

P = V * I, 100W = 125V * I_p = 220V * I_s

Despejando, I_p = 100W / 125V = 0,8A

Igualmente, I_s = 100W / 220V = 0,45A

Vemos por tanto que la intensidad de la corriente que pasa por este secundario es inferior a la del primario mientras que el voltaje es superior, manteniéndose siempre el producto de ambos, que es la potencia, invariable.

Podríamos también calcular el número de vueltas de cada bobina según la proporción que hemos visto antes. Supongamos que el primario tenía un devanado de 1000 vueltas. ¿Cuantas vueltas tendría el secundario?

I_s/I_p = 0,45A / 0,8A = 1000/N_s

Ns = 0,8A * 1000 / 0,45A = 1760 vueltas

Vemos por tanto que, si el número de vueltas del secundario es superior al del primario, aumenta proporcionalmente el voltaje y disminuye inversamente la intensidad. De hecho, si tuviéramos el mismo número de vueltas en ambos lados, ambos circuitos,tendrían las mismas características, con la diferencia de que serían dos circuitos aislados.

El sensor de corriente

Bueno, pues ya está bien de teoría. El componente que nos traemos entre manos, el sensor de corriente (también llamada pinza amperimétrica en algunos sitios) es un tipo específico de transformador, con ciertas características particulares:

El núcleo del transformador se puede abrir y cerrar, para poder situarlo alrededor de un conductor sin tener que desconectarlo.
El devanado primario lo constituye el conductor a medir al pasar por dentro del núcleo, y tiene por tanto una sola vuelta.

El resto de las características (y las fórmulas matemáticas empleadas) son exactamente iguales que en el resto de los transformadores.

En la imagen pongo el que yo he comprado:

Se trata de un sensor SCT013 de la marca yhdc (chino) que se puede comprar en muchas partes. Yo el mío lo compré en Aliexpress y me costó unos 5€ puesto en casa. El enlace al producto en cuestión es el siguiente:

http://www.aliexpress.com/item/Free-Shipping-New-Non-invasive-0-100A-AC-Sensor-Split-Core-Current-Transformer-SCT-013-000/32264516329.html

Este sensor admite una intensidad máxima de 100A en el primario, transformándola en una intensidad máxima de 50mA en el secundario. Como hemos dicho, el primario tendrá una única vuelta, por lo que aplicando la fórmula de proporcionalidad obtenemos que el secundario esta formado por una bobina con 2000 vueltas en su devanado.

100A / 0,05A = 2000 / 1

El sensor viene con un cable de aproximadamente un metro y con un conector de tipo minijack en su extremo, con tres contactos (minijack audio stereo) de los cuales el intermedio no tiene conexión. El secundario por tanto se accede por medio de los otros dos contactos.

El sensor es pasivo (no requiere alimentación) y su funcionamiento es lógicamente muy sencillo si sabemos cómo funciona un transformador: en el primario (el conductor a medir) se aplica una corriente alterna con un consumo determinado y como resultado tenemos la intensidad a medir. Dicha corriente genera otra corriente inducida en el secundario que tiene una intensidad 2000 veces menor. Lógicamente, lo que nos interesa no es obtener una intensidad proporcional, sino un voltaje proporcional que podamos medir más fácilmente, pero eso es otra historia y ya la veremos cuando conectemos el sensor al arduino.

Por otra parte, una vez calculada la intensidad en el primario, calcular la potencia o consumo eléctrico es tan fácil como multiplicarla por el voltaje de entrada (normalmente 230V).

Como ya digo, este artículo es tan sólo una introducción al funcionamiento de este componente. Su utilización practica la veremos más adelante, mediante un montaje con arduino.

Servers Ultimate Pro gratis hoy en Amazon

noreply@blogger.com (Isidoro Aguilar Baeza) — Wed, 5 Aug 2015 15:49:00 +0200

Si te parece muy complicado instalarte un servidor en tu móvil, hay aplicaciones que te permiten tener uno o varios servicios directamente desde Android: FTP, servidor web, repositorios, etc.

Entrando hoy por casualidad en la tienda de Amazon, he visto que la aplicación gratuita del día es Servers Ultimate Pro:

http://www.amazon.es /Ice-Cold-Apps-Servers-Ultimate /dp /B00E00C70C

Yo me la he bajado, para un futuro, merece la pena.

Un servidor en tu móvil (y II)

noreply@blogger.com (Isidoro Aguilar Baeza) — Tue, 14 Jul 2015 16:27:00 +0200

En el artículo anterior [Un servidor en tu móvil (I)], vimos cómo montar todo un servidor Debian Linux en un teléfono móvil con Android sin una potencia exagerada. Vamos a continuar hoy donde lo dejamos, para configurar ciertas cosas que nos pueden venir bien.

Pantalla de configuración

A diferencia de la pantalla de "propiedades" que vimos en el artículo anterior, donde podíamos seleccionar la distribución de linux y demás, a la pantalla de configuración de Linux Deploy se accede pulsando la tecla de menú de Android. Nos aparece el menú de la aplicación donde seleccionamos "configuración" o "settings":

Uno de los principales ajustes que podemos hacer, lógicamente, es poner el idioma en español. Por defecto, al instalar la aplicación nos lo pondrá en inglés. Además, podemos cambiar el tema entre el oscuro y el claro.

Pero lo que más tenemos que tener en cuenta son los siguientes puntos:

Por defecto, la aplicación está configurada para que la pantalla se quede encendida todo el tiempo mientras que el Linux esté funcionando. Esta es la primera opción, que en español se llama "bloquear pantalla". Yo os recomendaría que desmarcaseis esta opción, porque de lo contrario terminaremos con un teléfono que se calienta como un demonio y una pantalla gastada, si es que realmente vamos a utilizar este invento como un servidor.
¿Que por qué la aplicación viene configurada así? Pues muy fácil: Android hace una gestión del procesador de manera que cuando la pantalla se apaga es porque realmente no vamos a utilizar el teléfono, y por tanto la mayoría de las aplicaciones se quedan suspendidas o con un modo de funcionamiento de "bajo consumo". El procesador entra en modo "sleep" y sólo se despierta para hacer ciertas tareas urgentes: atender a las señales provenientes de la red de telefonía, mostrar notificaciones, etc. El resultado que yo observé al principio es que, si desmarcas esta opción, el Linux sigue funcionando, pero muuuuuuuyyyyyyyy leeeeeeennnntttooooooooo.
De todos modos, os insisto en que desmarquéis la opción y ahora vemos como solucionar este problema.
Bloquear Wi-Fi.
Esta opción hay que dejarla marcada, para que no se nos desconecte el servidor de la red.
Autoarranque.
Marcando esta opción, cada vez que arranquemos el teléfono se nos iniciará nuestro servidor Linux, con lo cual es muy recomendable mantenerla marcada.

Como mantener el procesador despierto

Como hemos visto antes, por defecto Android pone en modo "sleep" al procesador cuando la pantalla está apagada, y nosotros no queremos tener la pantalla siempre encendida para que funcione bien nuestro servidor.

Hay una pequeña aplicación que nos permite evitar que el procesador se duerma y se denomina "RedEye Stay Awake". Su versión gratuíta, con algo de publicidad puede descargarse aquí:

Como su nombre indica, esta aplicación le pone los "ojos rojos" al procesador porque no le deja dormir, y hay varios métodos para hacerlo. Podemos elegir el método en la opción "awake level":

El método que debemos elegir es "CPU awake only", porque todos los demás mantendrán la pantalla encendida en mayor o menor medida.

Otras opciones que debemos seleccionar son las que se ven en esta pantalla: "start at boot" para que la aplicación se inicie al arrancar el teléfono y no nos tengamos que preocupar por iniciarlo y "enable at startup" para que se active el mantener despierto al procesador al iniciar la aplicación. De lo contrario necesitaríamos pulsar sobre el icono de la barra de notificaciones para activar este modo la primera vez.

Una vez que tenemos todo así configurado ya no tenemos que preocuparnos porque se inicie correctamente el servidor. Tendremos un servidor que se inicia cuando encendemos el teléfono y además lo tenemos configurado de manera que no duerma nunca.

Iniciando los servicios automáticamente

Por último vamos a ver cómo configurar nuestro Linux para que los servicios que tengamos instalados se arranquen correctamente.

Supongamos que instalamos un servicio como Apache o MySQL. Al instalar los paquetes con las herramientas estándar como apt-get o dpkg, se nos van a crear los scripts de inicio de los servicios como es normal, de manera que podemos iniciarlos a mano con el comando "service":

> service apache2 start

> service apache2 stop

...

Sin embargo, si reiniciamos el Linux observaremos que los servicios no se inician automáticamente..

Inicialmente se me ocurrió instalar el comando rcconf (apt-get install rcconf) que yo he usado otras veces. Se trata de una pequeña utilidad que nos permite activar o desactivar el arranque automático de los servicios instalados, de una manera muy gráfica. Pero fue en vano: a pesar de que los servicios están en teoría activados, la realidad es que no se inician en el inicio del sistema.

La solución es la siguiente: dentro de la pantalla de "propiedades" de Linux Deploy hay una opción que se llama "Scripts personalizados". Hay que activar esta opción y después se nos activa otra entrada que dice "Lista de scripts". Pulsando sobre esta opción nos aparece la siguiente pantalla:

La pantalla no es más que una lista de los servicios que queremos iniciar automáticamente. Pulsando la tecla de menú podemos dar de alta, modificar o dar de baja elementos de la lista. Cada elemento de la lista debe ser la ruta al script del servicio. Concretamente vemos en la pantalla que yo tengo puestos tres servicios en arranque automático: MySQL, Apache y el cron.

Y esto es todo de momento. Más adelante veremos cómo instalar ciertos servicios en nuestro flamante servidor.

Un servidor en tu móvil (I)

noreply@blogger.com (Isidoro Aguilar Baeza) — Sun, 5 Jul 2015 18:35:00 +0200

¿Cuántos de vosotros tiene olvidado en un cajón un móvil que ya no usa?

Con el ritmo de los tiempos y el consumismo, vamos almacenando (o tirando) piezas de tecnología que hace dos años (o menos) se nos antojaban como la mayor maravilla del mundo, hasta que salió su sucesor. Salen nuevos programas y tu móvil ya no puede con ellos, tienes que desinstalar y limpiar si te quieres instalar el último juego, vas acumulando ficheros, programas, fotos, lo que sea.... y de repente: ¡anda! ¡si ya ha salido el S6! Y va una operadora y te lo vende a un módico precio que tú estás dispuesto a pagar...

La cosa es que tu viejo móvil acaba en un cajón (o en las manos de tu hija o de tu sobrino), mientras que tú disfutas de otro aparato que tiene mucha más potencia de lo que realmente necesitas.

Pues la entrada de hoy es una respuesta a la siguiente pregunta: ¿qué utilidad le puedo dar a mi antiguo móvil?

Resulta que en términos de potencia, estamos tirando a la basura o al abandono verdaderos ordenadores, que son mucho más potentes que los ordenadores de escritorio que teníamos hace unos años. Yo por ejemplo, tenía olvidado un Sony Xperia P que había dejado de usar porque la batería no intercambiable que traía me duraba unas dos horas y lo cambié por un teléfono chino que me va mil veces mejor. Pero resulta que dicho Xperia es todo un equipo con un procesador de doble núcleo, 1 GB de RAM y 16GB de almacenamiento interno. Más que suficiente para montar un pequeño servidor doméstico.

Os cuento qué es lo que hice:

Resulta que Android es, en gran parte, un sistema basado en Linux. No es que sea un Linux completo, pero posee un núcleo con las funcionalidades básicas.
En principio, podríamos pensar que podríamos utilizar Android como servidor Linux, y en cierto modo es así: existen aplicaciones (por ejemplo Servers Ultimate) que nos permiten montar servidores desde el propio Android... pero sigue sin ser un servidor completo.

Lo que yo quería era tener una distribución completa de Linux en el móvil. Para esto hay principalmente dos programas disponibles en el Play Store:

Ambas parten del mismo principio: establecen un "chroot", que no es más que un entorno virtual independiente dentro del sistema de ficheros de un sistema linux, en el que podemos instalar lo que queramos, como si se tratase de otra máquina. No es exactamente el concepto de "máquina virtual", porque realmente no hay nada que emular, se trata de la misma máquina ejecutando otro sistema operativo, independiente del principal. Se asemeja mucho al concepto de "jaula" como se conoce en FreeBSD.

Pues bien, resulta que ambas aplicaciones nos permiten establecer un "chroot" dentro del sistema de ficheros de Android, sobre el cual instalan una distribución completa de Linux: Debian, Ubuntu, Gentoo, Kali, OpenSUSE y muchas otras.

Yo he probado ambas como digo, pero me quedo con la segunda: Linux Deploy. Es mucho más versátil, falla menos y me permite hacer todo lo que le pido. A continuación os cuento los pasos principales para poner en marcha un sistema Linux completo en vuestro Android con Linux Deploy:

Instalamos la aplicación.
Este paso está claro, se trata de una aplicación gratuita y se encuentra en el Play Store en el enlace que os he puesto arriba. Sólo una advertencia: vuestro teléfono debe estar rooteado, de lo contrario no funcionará.
Otra cosa a tener en cuenta es la memoria. Si tenéis el teléfono cargado de aplicaciones, vais a tener problemas. Yo lo que hice fue restablecer el teléfono de fábrica y dejarlo con el mínimo de aplicaciones: de hecho le desactivé muchas aplicaciones de Google que están cargando siempre la memoria.
Elegimos nuestra distribución.
Para ello, pulsamos sobre el icono inferior derecho de la pantalla principal del programa:

Una vez que entramos en esta ventana, podemos seleccionar la distribución a instalar. Como podéis ver hay bastantes para elegir. Yo instalé Debian, a la que estoy bastante acostumbrado.

Lo siguiente es seleccionar la versión de la distribución. Como se puede ver, yo he cogido el canal "stable", que en la fecha actual (Julio 2015) corresponde a la versión 8 de Debian, también llamada "Jessie".
Configuración adicional.
Sin salir de esta pantalla, elegiremos también las siguientes opciones, dejando el resto tal cual:

Seleccionar componentes: dejaremos marcado sólo "servidor SSH". El resto lo vamos a desmarcar porque en principio no nos va a hacer falta. Si lo que queremos es montar un servidor, no nos hace falta para nada un "ambiente de escritorio", ni necesitamos un servidor VNC ni por supuesto un servidor X. Todas esas opciones tienen como cometido acceder al Linux de forma gráfica. Nosotros somos más frikis y lo único que queremos es poder conectarnos desde un terminal de comandos.
Desmarcamos la opción "GUI".
Localización: la ponemos en "es_ES.UTF8, para que el sistema nos hable en nuestro idioma.

Instalación.
Una vez que hemos realizado la configuración indicada, pulsamos la primera entrada de esta pantalla, que en español dice "Instalar". Al hacer esto, la aplicación va a hacer lo siguiente:

Va a crear un fichero "linux.img" en nuestra tarjeta SD o almacenamiento interno. El tamaño dependerá de la distribución seleccionada. Para Debian, en principio el tamaño será de 4GB. Si queremos otro tamaño, tenemos que tener en cuenta que la tarjeta SD normalmente está formateada en FAT32, que tiene un límite de tamaño de 4GB para los ficheros, con lo que deberíamos crear una partición ext2, ext3 o ext4 y cambiar el tipo de instalación. A mí concretamente con 4GB me sobran.
Se va a descargar la distribución y versión seleccionadas (imprescindible tener el móvil conectado a la WIFI).
Va a instalar una serie de paquetes básicos necesarios para las opciones seleccionadas.
Una vez que está todo terminado, lo indicará por pantalla.

Arrancamos nuestro Linux.
Una vez instalada la distribución, podemos pasar a arrancarla. Para ello pulsaremos el botón "Start" o "Iniciar" de la pantalla principal de la aplicación.
Ya tenemos el Linux funcionando. Podemos conectarnos desde nuestro ordenador abriendo un terminal SSH y conectándonos a la dirección IP del teléfono (la muestra en la pantalla principal).

El usuario por defecto es "android", y su contraseña "changeme". Dicho usuario tiene permisos de "sudoers", con lo que mediante el comando "sudo" puede ejecutar instrucciones como root. Os recomiendo que la primera instrucción que ejecutéis sea para cambiar la contraseña del usuario "android":

> sudo passwd android

Y esto es todo por hoy. Ya tenemos nuestro servidor instalado y funcionando. En la próxima entrada veremos cómo optimizar el funcionamiento de todo esto.

A modo de presentación

noreply@blogger.com (Isidoro Aguilar Baeza) — Thu, 2 Jul 2015 19:04:00 +0200

Muy buenas.

Pues nada, sólo unas pocas palabras a modo de introducción del blog.

Me llamo Isidoro y soy de Huelva, y me gustan los aparatos y la electrónica desde que tengo uso de razón, por influencia de mi padre.

A los 12 años me regalaron un ZX Spectrum y ese fue el detonante de mi gran afición por la informática, que posteriormente se convirtió en mi carrera y hoy mi trabajo.

A lo largo de los años he programado mucho, y en muchos lenguajes: Basic, código máquina de Z80 y 8086, C, C++, Modula 2, Cobol, Delphi, PowerBuilder, Visual C, Clipper, Java, JavaScript, PHP, C#, y seguramente algún otro que me dejo en el tintero...

Pero este blog en principio no va de programación, aunque seguramente algo saldrá por el camino. Mi intención es que este blog contenga una serie de "recetas" relacionadas con los "pequeños dispositivos" que hoy día nos invaden, la informática de las cosas pequeñas: arduino, android, algo de linux, montajes de pequeños servidores y cosas así... La idea es documentar aquí los montajes que voy haciendo (o que ya tengo hechos) de manera que luego no tenga que decir: "¿Y cómo monté esto que ya no me acuerdo?". De camino, espero que a alguien más le sirva de "inspiración".

Pues nada más, que seáis bienvenidos y espero poder tener tiempo para ir escribiendo de vez en cuando.