ESP8266 Introducción

Hoy les traigo una placa que seguramente ya la escucharon nombrar o incluso ya la conocen, se trata de la ESP8266. Esta placa viene en una infinidad de formatos, tamaños y prestaciones. Vamos a ver la versión ESP-12E que cuenta con:

Procesador de 32 bits y 80MHz de reloj (hay versiones de menor frecuencia y versiones que alcanzan los 160MHz)

4 MB de memoria flash (en el entorno de arduino se puede dividir la memoria para programa y para datos)

WiFi integrado

modos  STA/AP/STA+AP

una entrada analógica de 10 bits

16 pines GPIO

Estos micros trabajan con tensiones de 3v a 3,6v y son muy sensibles (se queman si se excede la tensión) aunque vienen placas que soportan alimentación desde el USB. En definitiva, tenemos un equipo que supera por mucho a un arduino (en cuanto a procesamiento y velocidad de reloj), cuenta con conectividad WiFi, tiene pines de entrada y salida que podemos programar como queramos además de uno que puede hacer lecturas analógicas de 10 bits (ojo, en este pin solo se admiten tensiones máximas de 1V, por lo que si ponemos una tensión superior a esa corremos el riesgo de que se queme el pin o incluso el microcontrolador) y si bien nativamente solo se puede usar con comandos AT, el verdadero poder de este micro se encuentra en que podemos cambiarle el firmware por el nuestro desde el IDE de arduino, lo que lo hace muy flexible. Como desventajas (frente a un arduino común y corriente) no contamos con una gran cantidad de pines analógicos (solo uno) y es medio engorroso programarlo (para programarlo hay que presionar el botón de reset, apretar el botón de flash, soltar el de reset y una vez que comienza a grabar la memoria flash, podemos soltar el botón de flash, y todo esto si la placa cuenta con estos botones).

A continuación voy a dejar el instructivo (paso a paso) para programar el ESP8266 con el ide de arduino.

1. Descargar e instalar Python 2.7.x (www.python.org/downloads/) (donde dice "customize python 2.7.x" buscar la opción donde dice "add python .exe to path" y seleccionar la opción "will be installed on local hard drive" y darle al botón "next" hasta que se instale).
2. Ir al IDE de arduino (preferentemente tener la última versión) e ir a archivos, preferencias y donde dice "gestor de URL's adicionales de tarjetas" poner el siguiente link: arduino.esp8266.com/package_esp8266com_index.json (reiniciar el IDE de arduino al finalizar este punto).
3. Ir a herramientas, placa, gestor de placas, buscar esp8266 e instalar el que diga "esp8266  by esp8266 comunity". Una vez que se descargó e instaló reiniciamos nuevamente el IDE.

Con esos tres pasos ya deberíamos tener todo listo para poder cargar nuestro programa.

Para utilizarlo seleccionamos la placa esp8266 genérica de las placas nuevas y nos van a aparecer un montón de opciones y deberíamos elegir las correctas para nuestra versión de la placa esp8266.

const int pin_led = 5;

void setup() {
  pinMode(pin_led, OUTPUT);   
}

void loop() {
  digitalWrite(pin_led, !digitalRead(pin_led));
  delay(1000);
}

Si cargamos este sencillo código en nuestra placa esp8266 podremos ver como el led integrado en la misma cambia de estado cada un segundo. El número del pin del led puede variar entre los fabricantes de las placas, de las que yo usé el número cambia de 5 a 2.

GSM

Introduciendo: MODULO GSM.

Luego de tanto tiempo pude hacerme con un módulo GSM, muy simple, compacto y principalmente barato. Este módulo viene sin borneras (hay que soldarlas uno mismo) y no posee una antena incorporada, por lo que hay que soldarle una, también nos da la posibilidad de utilizar un conector U.fl (conectado en paralelo al agujero donde podemos soldarle la antena) en el cual podemos acoplarle una antena más "profesional".

En mi experiencia utilizando un cable (de los que se usan para los cables de red, un solo hilo) de 4cm da pésimos resultados, quizá porque la frecuencia utilizada no sea de 1900MHz sino que de 850MHz por lo que habría que poner una antena de 9cm aproximativamente. Utilizando una antena comprada con el conector U.fl se obtienen muchísimos mejores resultados (aclaro, para mi que no tengo experiencia fabricando antenas) y no hay problemas con las conexiones por soldaduras frías o malos contactos (cosa que me pasó cuando estaba soldando la antena porque el calor del soldador durante mucho tiempo puede dañar el integrado SIM800L).

En la foto de arriba se puede apreciar el módulo, el tamaño (lo que sobresale arriba azul es una micro sim), como se puede ver arriba a la izquierda está el conector U.fl, inmediata- mente abajo del conector se puede apreciar el sobrante del estaño utilizado para soldar la antena. A la derecha podemos apreciar un led de color verde, cuando tiene señal hace un destello cada tanto y cuando está buscando señal se queda titilando muy rápido.

Acá podemos apreciar la leyenda de cada pin y el porta micro sim, así como el modelo del módulo (por mi parte no encontré mucha bibliografía). 

Esta es la pequeña antena que me dio tan buenos resultados.

En esta última imágen (gracias a las borneras) se puede apreciar el tamaño del módulo y de la antena.

Este módulo (así como como cualquier integrado gsm si no me equivoco) se comunica utilizando el puerto serie (la velocidad se adapta a la que nosotros usemos, osea que la autodetecta), y como "idioma" utiliza los famosos comandos AT, que una vez que se juega un poco con ellos son bastante fáciles de utilizar (al final dejo el pdf que utilizé como referencia).

Para ir finalizando en la introducción de este módulo, la alimentación tiene que estar comprendida entre 3,7v a 4,2v que es la tensión que proporciona una batería de litio-polímero, que justamente son las que se usan en los celulares. Mi solución es sencilla, con una batería lipo conecto el negativo al arduino y al módulo (para tener una masa común) el positivo al vcc del módulo y el arduino conectado vía USB con la computadora, de esta forma el módulo tiene la corriente que necesita (picos de hasta 2A que son proporcionados por la batería de lipo) y el USB conserva su integridad y alimenta únicamente al arduino.

A continuación un breve programa para tener funcionando el módulo rápido:

// Conectar RX al pin digital 11
// Conectar TX al pin digital 10

#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11); // RX, TX

void setup()  
{
  Serial.begin(9600);
  mySerial.begin(9600);
  delay(15000);
  Serial.println("inicio del informe");
  comando ("at");
  delay(15000);
  comando ("ATI+CMEE=2");         //pone el modo de los errores en texto
  comando ("at");                 //mandamos el comando básico para recibir un ok 
  comando ("ati");                //obtiene nombre del módulo y versión
  comando ("at+ccid");            //obtiene el número de la tarjeta sim
  comando ("at+cbc");             //obtiene el estado de la batería
  comando ("at+csq");             //obtiene la fuerza de la señal
  comando ("at+cops?");           //obtiene la conección de la red
  mySerial.print("AT+CMGF=1\r");  //modo texto
  Serial.println("fin del informe");
  tiempo = millis();
}

void loop() // run over and over
{
  
  if (mySerial.available())
  {
    Serial.write(mySerial.read());
  }  
  if (Serial.available())
  { 
    while(Serial.available())
    {
      mySerial.write(Serial.read());
    }
    mySerial.println();
  }

}

void comando (char com[40])
{
  mySerial.write(com);
  mySerial.write('\r');
  delay(200);
  while (mySerial.available())
  {
    Serial.write(mySerial.read());
  }
}

Comandos AT aceptados por el integrado:

https://cdn-shop.adafruit.com/datasheets/sim800_series_at_command_manual_v1.01.pdf

Vuelta ¿?

Bueno, espero que esta sea la vuelta del blog (si, después de dos años finalmente conseguí inspirarme lo suficiente jaja), espero que disfruten los contenidos que se vienen.

Proyecto: integración de módulos (2)

Bueno, les quiero dejar el programa de integración de módulos. Recuerden que funciona con las librerías de la pantalla, sensor de temperatura y del módulo nrf24l01 para poder funcionar correctamente.

Sin más, acá les dejo el link para que puedan bajarlo!

Programa:
https://mega.nz/#!3ohUgBbQ!qkQU7D-mcURIWdzxYvfEcP015TmrJchWKaGQMx6t7Uw

Librerías:

DHT:
https://mega.nz/#!K0hi2YaC!Spubjr7ApxeBBqBSpDXeofYLQ9JDDn4AfqzeWCas4lA

MIRF:
https://mega.nz/#!e95mAbjQ!3IODmjbqTFaPyV-JfWrcHqYfgZ1kem02rLMNbO3gmKk

Pantalla:
https://mega.nz/#!H5gCzSiL!9PSVtEKC326hzOGqBiLbj_rzA-WvoyYP7OYyO4FoJvc

Proyecto: Sonómetro libre gigante (3)

Bueno, en vista de que ya tengo el programa en mi poder y así como los circuitos, simplemente voy a dejarles los archivos con las cosas necesarias.

Acá el apunte de los circuitos:

https://mega.nz/#!694RnQ6R!qWZPC8xzSQwp9Lj870W4qShS-DBzk9stBCRKRt4QIXc

y acá les dejo el programa del arduino:

https://mega.nz/#!H9JTCC4I!sNSEIdr-0s4SZ7f3xD1z_HjMIeaiBgR1BWE3e-Jup6I

Placa de desarrollo

Hoy les traigo una pequeña placa de desarrollo que realicé para un arduino nano, cuenta con borneras macho para conectar servos, una configuración para conectar un nrf24l01 y borneras hembra. Se puede acceder a cualquier pin de la placa nano (sea o no un pin programable ya sea tanto de entrada como de salida). En principio tiene un puerto USB tipo A, pero por problemas de espacio no pude conectarlo a la placa y quedó soldado para un "futuro" mejoramiento.

Así es la "etapa" final, como se puede ver el USB tipo A está bien ubicado, pero si quiero poner un cable para sacar los datos del mini (para no soldar en la plaqueta de la nano) no me dejaría espacio para conectarlo a la pc.

En la siguiente foto se puede apreciar como es la placa, en este caso puse un diodo con una resistencia para obtener los 3,3v necesarios por la placa del nrf24l01 (me había olvidado que el arduino nano entrega esa tensión, pero decidí dejárselo para no saturar el pin de los 3,3v)

En la siguiente foto (se puede agrandar si hacen click en la foto) se puede apreciar el conexionado entre la bornera del nrf24l01 y las borneras donde va el arduino nano, el dibujo lo puse para no tener que aplicar el circuito del diodo con la resistencia, por lo que se obtienen los 3,3v del arduino.

Y por último para que se pueda apreciar bien, la tira de pines que está más a la derecha es el GND, la que le sigue a la izquierda es el positivo y la tercera línea de pines es el "espejo" de los pines del arduino, así como las borneras hembra que están en la 4º línea, todo esto se repite al otro lado del arduino, siendo la 1º línea la tierra, la 2º línea el postivo y la 3º y 4º líneas son los espejos del arduino.

Como último comentario, si se usa el nrf24l01 no se pueden usar los pines encargados del spi como entradas o salidas normales, esto es porque justamente las está usando el transceptor. Los pines que no se pueden usar son: D13, D12, D11, D10 y D9.

Android y arduino

Bueno, hoy les traigo algunas aplicaciones para android con las que se pueden hacer cosas con arduino.

La primera de todas es un IDE con el cual se puede programar desde una tablet o celular (debe tener capacidad de tener USB OTG. Se llama "ArduinoDroid" y es una aplicación que nos permite escribir código y subirlo al aruino. Lamentablemente no soporta todas las placas, pero si las más "comunes" como:

UNO/UNO_r3
Duemilanove
Nano
Mega 2560
Leonardo
Micro/Pro Micro
Pro/Pro Mini

Tiene una versión paga que nos permite tener algunas opciones más, pero la versión gratuita contiene todo lo necesario (ejemplos, librerías, abrir y editar códigos, crear nuevos códigos y lo más importante, subir el código al arduino desde un dispositivo android).

La segunda es una que nos permite controlar el arduino a través de un puerto USB OTG, y podemos poner distintos pines como entrada o salida y también nos permite poner un valor alto o uno bajo en el arduino desde una interfaz gráfica. La aplicación se llama "Arduino UNO Port Control" y es gratuita. Para poder funcionar, hace falta subir un código (que ellos mismos proveen) al arduino.
Una cosa a tener en cuenta es que solo funciona con el Arduino UNO.
El código (por si no quieren ir a la página a buscarlo) es el siguiente:

byte lineEnding = 0x0A;
byte readBuffer[15];
byte defaultByte = 0x10;

void setup() {   
  for (int i=0; i < sizeof(readBuffer)-1 ; ++i) {
    readBuffer[i] = defaultByte;
  } 
  Serial.begin(9600);
}

void loop() {              
  if (Serial.available() > 14) {
    Serial.readBytesUntil(lineEnding, (char*) readBuffer, 15);
    for (int i=2; i < sizeof(readBuffer)-1 ; i++ ) {                
      if( bitRead(readBuffer[i], 4 )) { pinMode(i,INPUT);} else { pinMode(i,OUTPUT);} 
    }
    
    for (int i=2; i < sizeof(readBuffer)-1 ; i++ ) {                
      if( bitRead(readBuffer[i], 0 )) { digitalWrite(i,HIGH);} else { digitalWrite(i,LOW);}
    }  
  }
}

Links:

ArduinoDroid:
https://play.google.com/store/apps/details?id=name.antonsmirnov.android.arduinodroid2

Arduino UNO Port Control:
https://play.google.com/store/apps/details?id=com.erdemaslan.arduinounodigitalportcontrol