|     Inicio    |   |         |  |   FOROS      |  |      |      
   Elastix - VoIP B4A (Basic4Android) App inventor 2 PHP - MySQL
  Estación meteorológica B4J (Basic4Java) ADB Shell - Android Arduino
  AutoIt (Programación) Visual Basic Script (VBS) FireBase (BD autoactualizable) NodeMCU como Arduino
  Teleco - Emisora de A.M. Visual Basic Cosas de Windows Webs interesantes
Translate:
Búsqueda en este sitio:


.

Arduino en español
Circuitos con Arduino - Juan Antonio Villalpando

-- Tutorial de iniciación a Arduino --

Volver al índice del tutorial                    Return to index tutorial

____________________________

Arduino. Button. Dimmer. LED.

 

57_4.- Módulo Wifi ESP8266 ESP-01.

1.- Servidor Web. Control de un LED por Wifi. Módulo ESP8266 trabajando sin Arduino.

- Vamos a encender/apagar un LED mediante el ESP8266 funcionando independientemente, sin Arduino. El LED lo controlaremos escribiendo una dirección web local.
Utilizaremos el Arduino UNO para cargar el programa en el ESP8366. Luego lo desconectaremos del Arduino.

- Vamos a utilizar el IDE 1.6.7 ya que contiene una herramienta para poder cargar al ESP8266.

- Hay varias acciones que repetirá varias veces, cargar el Bareminimun, quitar y poner la alimentación del módulo para que se reinicie, cambiar la velocidad del Serial Monitor de 9600 a 115200, poner y quitar el GPIO 0, cambiar en el IDE / Herramientas para el Arduino UNO y para Generic ESP8266,...

1.- Ponemos el IDE 1.6.7 en Herramientas / Placa: Arduino UNO

2.- Desconectamos el ESP8266 y cargamos en el Arduino el programa BareMinimun.

3.- Conectamos el ESP8266 y lo ponemos en modo firmware con el GPIO 0 a GND.

4.- Bajamos el programa ESP8266_flasher.zip y cargamos el v0.9.2.4 AT Firmware-ESPFIX.bin, como lo hemos realizado en los tutoriales anteriores.

5.- Una vez cargado quitamos el cable del GPIO 0.

6.- Vamos al Serial Monitor. Lo ponemos en 9600.

7.- Cambiamos la velocidad del módulo a:

AT+CIOBAUD=115200
AT+CIOBAUD?

8.- Ponemos el Serial Monitor a 115200.

9.- Ponemos el IDE 1,6,7 en Herramientas / Placa: Generic ESP8266 Module.

( Cambiaremos a veces a Herramientas / Placa: Arduino UNO o Herramientas / Placa: Generic ESP8266 Module según las necesidades)

10.- Conectamos el ESP8266 a 3,3 V del Arduino y otra vez el GPIO 0 a GND. Además del TX y RX como lo hemos hecho en otros tutoriales.

11.- Cargamos este programa en el IDE y los subimos...

Conviene de vez en cuando quitar la alimentación del ESP8266 y volverla a poner si es que no carga bien.

Código
/*
 *  This sketch demonstrates how to set up a simple HTTP-like server.
 *  The server will set a GPIO pin depending on the request
 *    http://server_ip/gpio/0 will set the GPIO2 low,
 *    http://server_ip/gpio/1 will set the GPIO2 high
 *  server_ip is the IP address of the ESP8266 module, will be 
 *  printed to Serial when the module is connected.
 */

#include <ESP8266WiFi.h>

const char* ssid = "nombredemirouter";
const char* password = "contraseñadelrouter";

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

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

// prepare GPIO2
pinMode(2, OUTPUT);
digitalWrite(2, LOW);

// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");

// Start the server
server.begin();
Serial.println("Server started");

// Print the IP address
Serial.println(WiFi.localIP());
}

void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}

// Wait until the client sends some data
Serial.println("new client");
while(!client.available()){
delay(1);
}

// Read the first line of the request
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();

// Match the request
int val;
if (req.indexOf("/gpio/0") != -1)
val = 0;
else if (req.indexOf("/gpio/1") != -1)
val = 1;
else {
Serial.println("invalid request");
client.stop();
return;
}

// Set GPIO2 according to the request
digitalWrite(2, val);

client.flush();

// Prepare the response
String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
s += (val)?"high":"low";
s += "</html>\n";

// Send the response to the client
client.print(s);
delay(1);
Serial.println("Client disonnected");

// The client will actually be disconnected 
// when the function returns and 'client' object is detroyed
}

- IMPORTANTE para que cargue la aplicación ponemos una resistencia de unos 20k entre GPIO0 y GND.

- Quita el Monitor Serie. Primero pulsa para Compilar, luego el icono de Cargar.

- Le he instalado este firmware: v0.9.2.4 AT Firmware-ESPFIX.bin (ver la primera página para instalar un firmware)

- Puse la placa en Nodemcu 0.9 ESP (12 Module)

Código_2
// Juan A. Villalpando
// ESP8266-01

#include <ESP8266WiFi.h>

const char* ssid = "nombredemirouter";
const char* password = "contraseñadelrouter";

WiFiServer server(80);

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

pinMode(2, OUTPUT); // GPIO2

// Conexión a Wifi
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("Conectado a Wifi.");

// Inicio del Servidor Web
server.begin();
Serial.println("Server iniciado.");

// Muestra la IP.
Serial.println(WiFi.localIP());
}

void loop() {
// Comprueba si se ha conectado algún cliente.
WiFiClient client = server.available();
if (!client) {
return;
}

// Espera hasta que el cliente envie algún dato.
Serial.println("Nuevo cliente.");
while(!client.available()){
delay(1);
}

// Lee la primera línea de petición.
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();

// Lee y muestra información
int val;
if (req.indexOf("/0") != -1)
val = 0;
else if (req.indexOf("/1") != -1)
val = 1;
else {
Serial.println("Peticion incorrecta.");
client.stop();
return;
}

// Pone el terminal GPIO2 al valor deseado.
digitalWrite(2, val);

client.flush();

// Respuesta web
String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n\r\n\r\nGPIO esta ahora en ";
s += (val)?"alto":"bajo";
s += "</html>\n";

// Envía la respuesta al cliente.
client.print(s);
delay(1);
Serial.println("Cliente desconectado.");

}
			

 

Código_3
// Juan A. Villalpando
// ESP8266-01
/ Juan A. Villalpando
// ESP8266-01

#include <ESP8266WiFi.h>

const char* ssid = "nombredemirouter";
const char* password = "contraseñadelrouter";

WiFiServer server(80);

#define LED2  2    // LED en terminal 2
String estado = "";

void setup() {
  Serial.begin(115200);
  pinMode(LED2, OUTPUT);

// Conecta a la red wifi.
  Serial.println();
  Serial.print("Conectando con ");
  Serial.println(ssid);
 
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Conectado con WiFi.");
 
  // Inicio del Servidor web.
  server.begin();
  Serial.println("Servidor web iniciado.");
 
  // Esta es la IP
  Serial.print("Esta es la IP para conectar: ");
  Serial.print("http://");
  Serial.println(WiFi.localIP());
}
 
void loop() {
  // Consulta si se ha conectado algún cliente.
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
   
  Serial.print("Nuevo cliente: ");
  Serial.println(client.remoteIP());
   
  // Espera hasta que el cliente envíe datos.
  while(!client.available()){ delay(1); }

  /////////////////////////////////////////////////////
  // Lee la información enviada por el cliente.
  String req = client.readStringUntil('\r');
  Serial.println(req);

  // Realiza la petición del cliente.
       if (req.indexOf("on2") != -1) {digitalWrite(LED2, HIGH); estado = "Encendido";}
       if (req.indexOf("off2") != -1){digitalWrite(LED2, LOW); estado = "Apagado";}

  //////////////////////////////////////////////
  // Página WEB. ////////////////////////////
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println(""); //  Importante.
  client.println("<!DOCTYPE HTML>");
  client.println("<html>");
  client.println("<head><meta charset=utf-8></head>");
  client.println("<body><center><font face='Arial'>");
  client.println("<h1>Servidor web con ESP32.</h1>");
  client.println("<h2><font color='#009900'>KIO4.COM - Juan A. Villalpando</font></h2>");
  client.println("<h3>Página web.</h3>");
  client.println("<br><br>");
  client.println("<img src='http://juanant91.byethost3.com/kio42.png'><br>");
  client.println("<a href='on2'><button>Enciende LED2</button></a>");
  client.println("<a href='off2'><button>Apaga LED2</button></a>"); 
  client.println("<br><br>");
  client.println(estado);
  client.println("</font></center></body></html>");

  Serial.print("Cliente desconectado: ");
  Serial.println(client.remoteIP());
  client.flush();
  client.stop();
}

- [Puedes obtener una respuesta más rápida simplifica el código HTML, quita los textos, la imagen el button, incluso quita la cabecera.]

 

12.- Quitamos el cable del GPIO 0

13.- Abrimos el Serial Monitor, con velocidad 115200 y observamos la IP asignada, por ejemplo 192.168.1.7

Podemos independizar al módulo ESP8266 del Arduino.

Alimentamos del ESP8266 con alimentación externa, (o bien con el Arduino, en caso que no tengas fuente de alimentación externa. pero le quitamos TX y RX)

14.- Conectamos un LED al terminal GPIO 2 del módulo.

15.- Escribimos esto en un navegador:

http://102.168.1.7/gpio/0

http://102.168.1.7/gpio/1

Se encenderá y apagará el LED y se indicará en una página web.

2.- Sensor de temperatura con el 18B20.

A.- Seguimos con el IDE 1.6.7. Ponemos en Herramientas / Placa: Arduino UNO

- Consulta este tutorial, incluso realízalo primero indendientemente del módulo ESP8266.

- En la carpeta libraries del IDE 1.6.7 pegamos esta carpeta OneWire.zip.

- Realizamos esta conexión en el Arduino UNO.

- Una resistencia de 4k7 y conexión al Pin2 del Arduino:

- En el tutorial Sensor de temperatura con el 18B20 observamos un código, ese código está preparado para varios tipos de sensores, como en mi caso voy a utilizar el 18B20, he reducido el código...

- Abre el Serial Monitor a 9600 y verás la temperatura actual.

Código
Sensor de Temperatura 18B20 en el Arduino UNO

// Modificado por Juan A. Villalpando


#include <OneWire.h>
OneWire  ds(2);
void setup(void) {
  Serial.begin(9600);
}

void loop(void) {
byte i;
byte present = 0;
byte type_s=0;
byte data[12];
byte addr[8];
float celsius;

if ( !ds.search(addr)) {
ds.reset_search();
return;
}

ds.reset();
ds.select(addr);
ds.write(0x44, 1);

delay(2000); 

present = ds.reset();
ds.select(addr); 
ds.write(0xBE);

for ( i = 0; i < 9; i++) { data[i] = ds.read(); }

int16_t raw = (data[1] << 8) | data[0];
celsius = (float)raw / 16.0;
Serial.print(" Temperatura = ");
Serial.println(celsius);
}

Acabamos de comprobar que ese sensor funciona en el Arduino UNO con ese código.

Vamos a pasar ese código al ESP8266

B.- Seguimos con el IDE 1.6.7.

- Realizamos el mismo proceso que hemos visto al inicio de esta página desde el principio, es decir volvemos a grabar el firmware, repetir todo el proceso, lo único que vamos a cambiar es el código final de carga, este...

Código Sensor de temperatura con el 18B20 en el ESP8266
#include <ESP8266WiFi.h>
#include <OneWire.h> ////////////////////////////
OneWire ds(2); /////////////////////////////////
const char* ssid = "nombredeturouter";
const char* password = "contraseñadelrouter";



// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

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



// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");

// Start the server
server.begin();
Serial.println("Server started");

// Print the IP address
Serial.println(WiFi.localIP());
}

void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}

// Wait until the client sends some data
Serial.println("new client");
while(!client.available()){
delay(1);
}

// Read the first line of the request
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();


// Match the request
int val;
if (req.indexOf("/gpio/0") != -1)
val = 0;
else if (req.indexOf("/gpio/1") != -1)
val = 1;
else {
Serial.println("invalid request");
client.stop();
return;
}


////////////////////////-- INICIO DEL CÓDIGO DEL 18B20 --//////////////////////
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
float celsius, fahrenheit;

if ( !ds.search(addr)) {
Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
delay(250);
return;
}

Serial.print("ROM =");
for( i = 0; i < 8; i++) {
Serial.write(' ');
Serial.print(addr[i], HEX);
}

if (OneWire::crc8(addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return;
}
Serial.println();

// the first ROM byte indicates which chip
switch (addr[0]) {
case 0x10:
Serial.println(" Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
Serial.println(" Chip = DS18B20");
type_s = 0;
break;
case 0x22:
Serial.println(" Chip = DS1822");
type_s = 0;
break;
default:
Serial.println("Device is not a DS18x20 family device.");
return;
} 

ds.reset();
ds.select(addr);
ds.write(0x44, 1); // start conversion, with parasite power on at the end

delay(2000); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.

present = ds.reset();
ds.select(addr); 
ds.write(0xBE); // Read Scratchpad

Serial.print(" Data = ");
Serial.print(present, HEX);
Serial.print(" ");
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(" ");
}
Serial.print(" CRC=");
Serial.print(OneWire::crc8(data, 8), HEX);
Serial.println();

// Convert the data to actual temperature
// because the result is a 16 bit signed integer, it should
// be stored to an "int16_t" type, which is always 16 bits
// even when compiled on a 32 bit processor.
int16_t raw = (data[1] << 8) | data[0];
if (type_s) {
raw = raw << 3; // 9 bit resolution default
if (data[7] == 0x10) {
// "count remain" gives full 12 bit resolution
raw = (raw & 0xFFF0) + 12 - data[6];
}
} else {
byte cfg = (data[4] & 0x60);
// at lower res, the low bits are undefined, so let's zero them
if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
//// default is 12 bit resolution, 750 ms conversion time
}
celsius = (float)raw / 16.0;
fahrenheit = celsius * 1.8 + 32.0;
Serial.print(" Temperature = ");
Serial.print(celsius);
Serial.print(" Celsius, ");
Serial.print(fahrenheit);
Serial.println(" Fahrenheit");

///////////////-- FIN DEL CÓDIGO DEL 18B20 --/////////////////////////

client.flush();

// Prepare the response
String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nTemperatura ";
s += celsius;
s += "</html>\n";

// Send the response to the client
client.print(s);
delay(1);
Serial.println("Client disonnected");

// The client will actually be disconnected 
// when the function returns and 'client' object is detroyed
}

 

- He tomado el código que hemos visto al principio de la página. Le he insertado en color azul el código correspondiente a la detección de temperatura con el 18B20, que vimos en un tutorial anterior. No he querido reducir este código, simplemente copio y pego, está en azul.

- Ver la conexión en el dibujo de abajo, pero aún debe estar conectado al Arduino, tanto la alimentación como el RX y TX.

- Estando conectado el circuito al Arduino escribimos esto en un navegador web:

192.168.1.7/gpio/1

Observaremos la Temperatura en la página web, también la veremos en el Serial Monitor.

- Esta sería la conexión independiente del Arduino. He configurado la fuente de alimentación con 3,3 V y con 5 V, según indico en la figura. Si no tienes esta fuente de alimentación puedes alimentar al circuito con los 3,3 V y 5 V del Arduino.

- Una vez realizada esta conexión no veremos al Serial Monitor, ya que lo hemos desconectado del Arduino.

- No he querido tocar el código para facilitar su comprensión ya que se pretende una explicación didáctica sencilla.

- Se observa una temperatura de 48,38º, lo cual no es cierto, se deberá retocar el código para obtener la temperatura correcta.

- La salida de datos es:

Data = 1 6 3 4B 46 7F FF C 10 A5 CRC=A5


- La temperatura se obtiene: 3 x 256 + 6 = 774

774 / 16 = 48.38º

__________________________

Este código es más corto que el anterior pero necesita cargar la librería
#include <DallasTemperature.h>

http://milesburton.com/Dallas_Temperature_Control_Library#Download

Código Sensor de temperatura con el 18B20 en el ESP8266
#include <ESP8266WiFi.h>
#include <OneWire.h> //////////////////////////////////
//OneWire ds(2); //////////////////////////////////////
#include <DallasTemperature.h>

OneWire oneWire(2);
DallasTemperature sensors(&oneWire);

const char* ssid = "nombredeturoueter";
const char* password = "contraseñadelrouter";

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

void setup() {
Serial.begin(115200);
delay(1500);
sensors.begin();

// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");

// Start the server
server.begin();
Serial.println("Server started");

// Print the IP address
Serial.println(WiFi.localIP());
}

void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}

// Wait until the client sends some data
Serial.println("new client");
while(!client.available()){
delay(1);
}

// Read the first line of the request
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();


// Match the request
int val;
if (req.indexOf("/gpio/0") != -1)
val = 0;
else if (req.indexOf("/gpio/1") != -1)
val = 1;
else {
Serial.println("invalid request");
client.stop();
return;
}


////////////////////////-- INICIO DEL CÓDIGO DEL 18B20 --//////////////////////
Serial.print("Requesting temperatures...");
sensors.requestTemperatures();
Serial.println("DONE");
Serial.print("Temperature for Device 1 is: ");
Serial.println(sensors.getTempCByIndex(0));

////////////////////////-- FIN DEL CÓDIGO DEL 18B20 --//////////////////////
client.flush(); // Prepare the response String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nTemperatura "; s += sensors.getTempCByIndex(0); s += "</html>\n"; // Send the response to the client client.print(s); delay(1); Serial.print("Client disonnected"); // The client will actually be disconnected // when the function returns and 'client' object is detroyed }

 

________________________________

- Mi correo:
juana1991@yahoo.com
- KIO4.COM - Política de cookies. Textos e imágenes propiedad del autor:
© Juan A. Villalpando
No se permite la copia de información ni imágenes.
Usamos cookies propias y de terceros que entre otras cosas recogen datos sobre sus hábitos de navegación y realizan análisis de uso de nuestro sitio.
Si continúa navegando consideramos que acepta su uso. Acepto    Más información