Hola a todos. Mi nombre es Alessandra y estoy estudiando comunicaciones.
Yo se que ya se ha hablado de este tema en el foro, pero aun no me queda claro.
Estoy tratando de realizar un proyecto (uso personal y didactico), para el cual compre lo siguiente:
-Arduino 1 R3
-ESP2688 (el azulito)
-Shield 4 Reles
El detalle es que quiero conectar mis reles mediante Arduino y que sean gobernados por el ESP.
Mi intencion es aprender dos cosas:
Lo primero, quiero hacer funcionar el circuito con el ESP trabajando sobre internet (montando un servidor web en el esp para que muestre una pagina y se puedan encender/apagar las luces desde ella).
Lo segundo, quiero lograr que el esp este en modo servidor hotspot (o sea, que el esp tenga su propia red WiFi), y que responda a los dispositivos conectados a el.
Conexionado:
ARDUINO | ESP
PIN 3.3 VCC
PIN 3.3 CH_PD
GND GND
PIN 10 UTXD
PIN 11 URXD
ARDUINO | RELES
PIN 5V VCC
PIN 2 IN1
PIN 3 IN2
PIN 4 IN3
PIN 5 IN4
Preparacion:
Descargar el plugin para Arduino que habilita el ESP8266 (descargando un paquete en el admin de tarjetas externas del IDE de Arduino) e instalar.
En Herramientras/Placa, seleccionamos “Generic ESP8266” y en Herramientras/Puerto, seleccionamos el puerto serie.
Desconectamos un momento GPIO0 del circuito y lo conectamos a GND, después desconectamos VCC y lo volvemos a conectar para resetear el ESP8266. Subimos el Sketch a la placa.
Planilla para hacerlo en modo servidor Web:
###Codigo (me lo encontre en la Web, estoy intentando portarlo):
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
const char* ssid = "<<NOMBRE_DE_TU_WIFI>>";
const char* password = "<<PASSWORD_DE_TU_WIFI>>";
const int PIN_RELE = 2;//Es el puerto GPIO2
String ESTADO_RELE = "OFF";
ESP8266WebServer server(80);
void info() {
String info_mensaje = "<b>ESP8266</b>
Comando <b>on</b>: encender
Comando <b>off</b>: apagar
";
String str_estado = ESTADO_RELE;
info_mensaje = info_mensaje + "Estado:" + str_estado + "
";
server.send(200, "text/html", info_mensaje);
}
void estado_rele() {
server.send(200, "text/plain", ESTADO_RELE);
}
void no_encontrado() {
server.send(404, "text/plain", "ERROR EN LA PETICION :( ");
}
void on_rele() {
server.send(200, "text/plain", "OK ON");
ESTADO_RELE = "ON";
digitalWrite(PIN_RELE, LOW);
}
void off_rele() {
server.send(200, "text/plain", "OK OFF");
ESTADO_RELE = "OFF";
digitalWrite(PIN_RELE, HIGH);
}
void setup(void) {
pinMode(PIN_RELE, OUTPUT);
digitalWrite(PIN_RELE, HIGH);
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.println("");
// Esperamos a que se conecte
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Conectedo a ");
Serial.println(ssid);
Serial.print("Dirección IP: ");
Serial.println(WiFi.localIP());
IPAddress sensor_ip = WiFi.localIP();
// Declaramos un par de paths por si queremos consultar directamente el estado
server.on("/", info);
server.on("/estado", estado_rele);
// Declaramos los paths para el control del rele
server.on("/on", on_rele);
server.on("/off", off_rele);
server.onNotFound(no_encontrado);
server.begin();
Serial.println("Servidor HTTP activo");
}
void loop(void) {
server.handleClient();
}
#############################################
Por partes, a lo que entendi:
Usamos las librerías ESP8266WiFi.h y ESP8266WebServer.h:
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
Declaramos el nombre de nuestra wifi y la password para poder conectarnos:
const char* ssid = "<<SSID_WIFI>>";
const char* password = "<<PASSWORD_WIFI>>";
Se define un servidor http que va atender peticiones por el puerto 80.
ESP8266WebServer server(80);
-info() y estado_rele(), sirven para contestar las peticiones http, devolviendo información y estado del relé.
-on_rele() y off_rele(), activan/desactivan el relé.
-no_encontrado(), lleva el manejo de peticiones http incorrectas.
void info() {
String info_mensaje = "<b>ESP8266</b>
Comando <b>on</b>: encender
Comando <b>off</b>: apagar
";
String str_estado = ESTADO_RELE;
info_mensaje = info_mensaje + "Estado:" + str_estado + "
";
server.send(200, "text/html", info_mensaje);
}
void estado_rele() {
server.send(200, "text/plain", ESTADO_RELE);
}
void no_encontrado() {
server.send(404, "text/plain", "ERROR EN LA PETICION :( ");
}
void on_rele() {
server.send(200, "text/plain", "OK ON");
ESTADO_RELE = "ON";
digitalWrite(PIN_RELE, LOW);
}
void off_rele() {
server.send(200, "text/plain", "OK OFF");
ESTADO_RELE = "OFF";
digitalWrite(PIN_RELE, HIGH);
}
Se hace el setup() de las salidas, y WiFi.begin(ssid, password) nos permite conectar al Wifi.
void setup(void) {
pinMode(PIN_RELE, OUTPUT);
digitalWrite(PIN_RELE, HIGH);
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.println("");
// Esperamos a que se conecte
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Conectedo a ");
Serial.println(ssid);
Serial.print("Dirección IP: ");
Serial.println(WiFi.localIP());
IPAddress sensor_ip = WiFi.localIP();
Se declara en el servidor las diferentes rutas que se van a atender y reconocer.
server.on("/", info); define que al recibir una peticion http, llamara a info() definida anteriormente y
mostrara la información que le hemos definido acerca del módulo.
// Declaramos un par de paths por si queremos consultar directamente el estado
server.on("/", info);
server.on("/estado", estado_rele);
Se definen las peticiones de encendido y apagado del relé:
// Declaramos los paths para el control del rele
server.on("/on", on_rele);
server.on("/off", off_rele);
-server.onNotFound() se define la función que se quiere que actue cuando la petición recibida no esta definida, cuando esto sucede se llama a no_encontrado() definido anteriormente.
server.onNotFound(no_encontrado);
server.begin();
Serial.println("Servidor HTTP activo");
}
-loop() invoca al método handleClient() que esta escuchando las peticiones del servidor.
void loop(void) {
server.handleClient();
}
Para cargar el codigo, hay que poner el pin GPIO0 a GNDpara que el boot del módulo entre en modo "upload".
Supuestamente en el ejemplo que encontre, al abrir un navegador y poner la dirección IP que se le asigno al módulo, deberia mostrar la información que se definio en en la función info()
Si se modifica la URL con "/on" le diria al modulo que active el pin GPIO2, o sea, activar el relé (en el codigo solo se usa un rele), esto siguiendo la función on_rele().
Si se manda agrega a la URL "/off", deberia apagar el rele.
#NOTAS:
Como se habra visto, el codigo que puse es para un solo rele, lo quiero portar para 4.
Esto resolveria uno de mis dos puntos a aprender, que es el trabajar el rele sobre internet (al menos parcialmente, ya que estoy segura que si quiero hacer una conexion externa a mi WiFi, no se conectaria al no ser una IP publica).
El conexionado lo segui tratando de seguir algunos ejemplos de la Web (sin resultados), ya que en muchos quieren cargar FirmWare externo o propietario al ESP (lo tengo como cuando lo compre) y otros quieren hacer uso de aplicaciones propias para controlarlo (cosa que no me agrada, ya que lo que quiero es aprender el funcionamiento para jugar con el mini servidor http y enviar ordenes).
Mi objetivo general de esto, es aprender el manejo del ESP2688 con Arduino, y el aprender como Arduino trabaja con reles (mas adelante planeo empezar a meter sensores y que a partir de ellos arduino haga una cosa u otra).
Mis dos grandes problemas es que no conozco mucho del lenguaje C (programo pero en otros lenguajes) y de electronica tengo nociones pero no soy experta.
Cualquier ayuda se agradeceria infinitamente, ya que no quiero incendiar la casa 
.
Besos!!
.
");