miércoles, 30 de noviembre de 2016

Medida de Temperatura/Humedad y publicación en Thingspeak

Esta práctica ya la he realizado utilizando LUA pero en este artículo voy a programar el módulo ESP8266 con el IDE de arduino. El esquema es sencillo:

Yo dispongo de este módulo que solo dispone de tres conectores pero no he encontrado su esquema:


Si deseas más información sobre estos módulos consulta este artículo 

Para programarlo utilizo la librería SimpleDHT11 que puedes instalar haciendo click en Programa - Incluir librerías - Gestionar librerías. Buscamos dht y elegimo SimpleDHT:


Para añadirlo a nuestro proyecto:
#include <SimpleDHT.h>

Hemos conectado el pin DATA del módulo DHT11 en el puerto D0 del módulo ESP8266 que corresponde con GPIO16.
int pinDHT11 = 16;

A continuación declaramos una instancia de la librería para comunicarnos con el sensor:
SimpleDHT11 dht11;

En loop definimos dos variables tipo byte t y h:
byte t = 0;
byte h = 0;


Para leer los datos del sesor utilizamos:
dht11.read(pinDHT11, &t, &h, NULL)

y luego la mostramos por el puerto serie. El código completo es el siguiente:

#include <SimpleDHT.h>

int pinDHT11 = 16; // Puerto D0 entrada de datos
SimpleDHT11 dht11; // Modelo de sensor

void setup() {
  Serial.begin(9600);
  delay(500);
}

void loop() {
  byte t = 0;
  byte h = 0;
  if (dht11.read(pinDHT11, &t, &h, NULL)) {
    Serial.print("Error en la lectura.");
    return;
  }
  // Muestra por el puerto serie las medidas obtenidas
  Serial.print("Humedad relativa: ");
  Serial.print((int)h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print((int)t);
  Serial.println(" *C");
  //El sensor realiza la lectura cada 20 segundos
  delay(20000);
}


Con este código obtenemos las siguientes lecturas:



Publicación en Thingspeak
ThingSpeak es una plataforma Open Source para conectar productos y servicios al Internet de las Cosas (IoT). Permite a los desarrolladores interactuar con los dispositivos utilizando tecnologías Web estándar.

En este artículo obtendrás más información de esta plataforma y de cómo darte de alta.

Vamos instalar la librería de ThingSpeak en el IDE de arduino. Hacemos click Programa - Incluir librería - Gestionar Librerías y en búsqueda escribimos thingspeak


Hacemos click en instalar y listo. Ahora, para añadir la librería a nuestro proyecto:
#include <ThingSpeak.h>

Además, incluimos la librería ESP8266WiFi:
#include <ESP8266WiFi.h>

Definimos los valores de nuestra wifi y creamos una instancia de WiFiClient:
const char* ssid = "WLAN_E17C";
const char* password = "ced0ccb58c84e525e35f";
WiFiClient  client;


Ademas definimos los valores de nuestro canal en ThingSpeak:
unsigned long myChannelNumber = NUMERO_CANAL;
const char* myWriteAPIKey = "API_kEY";

En NUMERO_CANAL y API_KEY teneis que introducir los datos de vuestro canal

En setup() establecemos la conexión wifi e inicializamos ThinkSpeak:
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {   // wait for WiFi
  delay(500);
  Serial.print(".");
}
ThingSpeak.begin(client);


Para enviar los datos de temperatura y humedad a ThingSpeak utilizamos:
ThingSpeak.setField(1,(int)t);
ThingSpeak.setField(2,(int)h);
ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);


Si solo necesitamos enviar un dato (por ejemplo la temperatura) podríamos utilizar:
ThingSpeak.writeField(myChannelNumber, 1, (int)t, myWriteAPIKey);

ThingSpeak solo acepta actualizaciones cada 15 segundas como mínimo

El código completo es el siguiente:

#include <SimpleDHT.h>
#include <ThingSpeak.h>
#include <ESP8266WiFi.h>

const char* ssid = "SSID";
const char* password = "PASSWORD";
WiFiClient  client;
unsigned long myChannelNumber = NUMERO_CANAL;
const char* myWriteAPIKey = "API_KEY"; // API Key del canal
int pinDHT11 = 16; // Puerto D0 entrada de datos
SimpleDHT11 dht11;

void setup() {
  Serial.begin(9600);
  WiFi.mode(WIFI_STA); //Establece el módulo como cliente wifi
  WiFi.disconnect(); //Se desconecta de cualquier WiFi conectado
  delay(100);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {   // wait for WiFi
    delay(500);
    Serial.print(".");
  }
  ThingSpeak.begin(client);
}

void loop() {
  byte t = 0;
  byte h = 0;
  if (dht11.read(pinDHT11, &t, &h, NULL)) {
    Serial.print("Error en la lectura.");
    return;
  }
  // Muestra por el puerto serie las medidas obtenidas
  Serial.print("Humedad relativa: ");
  Serial.print((int)h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print((int)t);
  Serial.println(" *C");

  // Envía los datos a ThinkSpeak
  ThingSpeak.setField(1, (int)t);
  ThingSpeak.setField(2, (int)h);
  ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey); 

  delay(20000);
}


El resultado que obtenemos es el siguiente:


Fuentes:
Enlaces:

sábado, 26 de noviembre de 2016

ESP8266: Diagnóstico WiFi y dirección MAC

El siguiente código muestra por el puerto serie un diagnóstico de estado del Wifi y la dirección MAC del dispositivo:

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200);

  Serial.print("\nDiagnóstico...\n");
  WiFi.printDiag(Serial);
  Serial.println();


  Serial.printf("MAC Address = %s\n", WiFi.softAPmacAddress().c_str());
}

void loop() {
}

El diagnóstico utilizan el comando WiFi.printDiag(Serial). En mi caso, me devuelve por el puerto serie:

Diagnostic...
Mode: STA+AP
PHY mode: N
Channel: 1
AP id: 0
Status: 1
Auto connect: 1
SSID (10): arduino-er
Passphrase (8): 12345678
BSSID set: 0

MAC: 18:FE:34:E0:3A:58

Mode: Nos indica el modo de funcionamiento del módulo WiFi. Puede tomar tres valores:
  • STA (Station): Modo Estación o modo cliente.
  • AP (Access Point): Modo punto de acceso
  • STA+AP: Mixto
Para establecer el modo de funcionamiento se utiliza la instrucción WiFi.mode(valor); donde valor puede tener los valores:
  • WIFI_STA  : Modo estación
PHY mode: nos indica el estándar 802.11 (el que regula las redes locales inalámbricas) configurado en el módulo. Puede tomar los valores:
  • B: 802.11b
  • G: 802.11g
  • N: 802.11n
Channel: Nos indica el canal que está utilizando el módulo Wifi. Cuando se definió el standard IEEE 802.11 se especificó también los tres rangos de frecuencia disponibles para los dispositivos que desearan emitir de esta forma: 2.4 GHz, 3.6 GHz y 5 GHz. La mayoría de dispositivos actuales operan, por defecto, en la franja de frecuencias cercana a 2.4 GHz, Cada rango de frecuencias fue subdividido, a su vez, en multitud de canales. Para 2.4 GHz, estamos hablando de 14 canales, separados por 5 MHz. Eso sí, cada país y zona geográfica aplica sus propias restricciones al número de canales disponibles. Por ejemplo, en Norteamérica tan sólo se utilizan los 11 primeros, mientras que en Europa disponemos de 13. El problema de esta distribución es que cada canal necesita 22MHz de ancho de banda para operar, y esto produce un solapamiento de varios canales contiguos como se parecía en la siguiente figura:

AP id:

Status: estado de la conexión. Puede tener los siguientes valores:
  • 0 : WL_IDLE_STATUS cuando el Wi-Fi está en proceso de cambiar de estado
  • 1 : WL_NO_SSID_AVAIL en caso de que el SSID configurado no pueda ser alcanzado
  • 3 : WL_CONNECTED después de establecer una conexión satisfactoriamente
  • 4 : WL_CONNECT_FAILED si la contraseña es incorrecta
  • 6 : WL_DISCONNECTED si el módulo no está configurado en el modo de estación
Auto connect:

SSID (n): Nos indica el nombre de la red Wifi configurada en nuestro módulo cuando se establece en modo AP. n nos indica la longitud de dicho nombre

Passphrase (n): Password configurado en el módulo wifi. n nmos indica la longitud de dicho password

BSSID set: es el identificador único de una red wifi y se forma a partir de su dirección MAC

Para obtener la dirección MAC utilizamos la instrucción WiFi.softAPmacAddress().

Fuentes:
ESP8266WiFi Library
https://es.wikipedia.org/wiki/Printf
Módulo wifi

martes, 22 de noviembre de 2016

PlatformIO

PlatformIO, un sistema de desarrollo pensado para la IoT con el que se pueden utilizar diferentes tipos de hardware y marcos de trabajo, ya sea desde un IDE genérico o desde la consola o desde el propio IDE de PlatformIO basado en Atom.


PlatformIO trabaja en base a Atom text editor y Python 2.7, por lo que deberemos de tenerlos instalado.

Para instalar ATOM en nuestro PC lo primero que hay que hacer es ir a su página web y descargarlo. Yo lo voy a instalar en Ubuntu por lo que descargaré la versión .deb


Una vez descargado utilizo GDebi para instalarlo.


Ejecutamos ATOM y hacemos click en Install a Package - Open Installer - Mange Packages y buscamos en Search por PlataformIO



Elegimos platformio-ide (install) y esperamos a que se instala el package.


Hacemos click en Reload now y nos aparece PlatformIO.


Después de algún pequeño problema (CLI Failed to retrieve) y hacer un rebuild package al aparecer este error ya tengo plataformIO correctamente instalado:


Para autocompletar el código instalaremos Clang. Para ello abrimos un terminal y ejecutamos el comando

Sudo apt-get install clang

Cerrarmos ATOM y lo volvemos a abrir.

Nuestro primer proyecto

Hacemos click en nuevo proyecto. Elijo las tarjeta (Arduino UNO o Node MCU 1.0 en mi caso), el directorio del proyecto y presiono el botón Initialize:


 Con el botón derecho sobre la carpeta src - New File y escribimos main.cpp


Escribimos el código de nuestro proyecto, en mi caso el famoso blink:


Para compilar el proyecto, hacemos click en el menú PlatformIO - Buid.


Para cargar el programa en la tarjeta (Arduino UNO) primero debemos conectarla a un puerto usb, comprobar su conexión y darle los permisos necesarios.

En un terminal ejecutamos:

dmesg | grep ttyACM 

que nos devolverá algo así como:

[ 2225.269273] cdc_acm 2-1.2:1.0: ttyACM0: USB ACM device

Ahora tendríamos que darle permisos suficientes al puerto ttyACM0 para que nuestro usuario pueda acceder a el a través del IDE (este paso lo tendrás que repetir cada vez que re-conectes el Arduino):

sudo chmod 666 /dev/ttyACM0

Ahora hacemos click en PlatformIO - Upload



Con esto ya podemos realizar nuestros proyectos utilizando este magnífico entorno de programación.

Nota 1: Para programar el módulo Node MCU los comandos que he de introducir desde el terminal son:

dmesg | grep ttyUSB

que en mi caso devuelve:

[ 4533.772296] usb 2-1.5: ch341-uart converter now attached to ttyUSB0
[ 4573.916499] ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
[ 4578.054790] usb 2-1.2: ch341-uart converter now attached to ttyUSB0



y para dar los permisos:

sudo chmod 666 /dev/ttyUSB0

Nota 2: He de decir que con platformIO podremos programar nuestro arduino en C/C++. Si quieres convertir tu código .ido a .cpp consulta el siguiente enlace. También el programa te da la posibilidad de importar un proyecto .ido automáticamente.

Web: http://platformio.org/
Fuentes:

lunes, 21 de noviembre de 2016

Instalación del IDE de Arduino en Windows 10

La instalación del IDE de Arduino en Windows 10, que es el actual S.O. de mi ordenador, es bastante más sencilla que cuando lo instalé en Windows 7 o en Ubuntu 14.04.

Nos vamos a la web oficial de Arduino, a la sección Download, y descargamos una versión compatible con Windows (en mi caso la versión ZIP)


A continuación, en la siguiente pantalla, nos da la posibilidad de realizar una donación al proyecto antes de la descarga. En mi caso hago click directamente en just download.

Una vez descargado, lo descomprimimos en la carpeta que elijamos:



Una vez tengamos el programa descomprimido, conectamos nuestra tarjeta Arduino (en mi caso una Arduino UNO) al puerto USB. En ese momento Windows 10 identificará la tarjeta e instalará el solito el driver para la tarjeta.

Una vez instalado dicho driver, ya podemos ejecutar el IDE identificando el puerto donde tenemos conectado la tarjeta (En mi caso COM3).

Para poder utilizar el IDE de Arduino con el modulo NodeMCU (ESP8266-12) sigue los pasos que se indican en este artículo.



Una vez realizadas estas operaciones ya estamos en disposición de programar nuestras tarjetas con el IDE de Arduino sobre Windows 10.

sábado, 19 de noviembre de 2016

Google Trends

Estoy suscrito a este canal y hace unos días publicó un vídeo sobre google trends. He realizado esta prueba analizando las búsquedas sobre arduino, Raspberry PI, Intel Edison y ESP8266 en los últimos 5 años.



Los resultados son claros, los reyes del mambo en IoT son Arduino y Raspberry Pi