¿Estás buscando una forma de proteger tu placa ESP8266 de manera efectiva y versátil? En este artículo te enseñaremos cómo construir un escudo multisensor para ESP8266 que te permitirá monitorear diferentes variables ambientales y proteger tu dispositivo de forma óptima. Sigue leyendo para descubrir cómo crear este escudo personalizado y potenciar las capacidades de tu placa ESP8266.
En este proyecto aprenderá a diseñar y crear un escudo multisensor para la placa ESP8266 Wemos D1 Mini. El escudo tiene un sensor de temperatura (DS18B20), un sensor de movimiento PIR, un LDR y un puerto para conectar un módulo de relé. Empezamos preparando todo el hardware para luego programarlo.
Mira el vídeotutorial
Este proyecto está disponible en vídeo y en formato escrito. Puede ver el vídeo a continuación o desplazarse hacia abajo para leer las instrucciones escritas. Este proyecto consta de dos vídeos.
Diseño y construcción del mini escudo multisensor ESP8266 WeMos D1 – Parte 1
En este primer vídeo decidimos qué hardware usaremos. También veremos las características principales de este proyecto y cómo diseñar y ensamblar su propio WeMos D1 Mini Multisensor Shield.
Programación y prueba del mini escudo multisensor ESP8266 WeMos D1 – Parte 2
En este segundo video, programamos el Wemos D1 Mini Multisensor Shield con un código que ejecuta un servidor web que le permite monitorear y controlar el Multisensor Shield en función de varias configuraciones configurables.
recursos
Todos los recursos que necesita para crear este proyecto se pueden encontrar en los enlaces a continuación (o visite el Proyecto GitHub):
- Código de servidor web (para Arduino IDE)
- Representación esquemática
- Archivos Gerber
- Proyecto KiCad para editar la placa de circuito.
- Caja de impresora 3D (archivos STL y proyecto SketchUp)
- Haga clic aquí para descargar todos los archivos
Descripción del proyecto
El escudo consta de un sensor de temperatura, un sensor de movimiento, un LDR y un enchufe de 3 pines al que se puede conectar cualquier salida. Usamos un módulo de relé.
También escribiremos un programa que ejecute un servidor web para controlar el Shield en cuatro modos diferentes con varias configuraciones configurables.
Al final de este proyecto tendrás un dispositivo de aspecto similar.
Puede encender y apagar el relé en modo manual.
O eliges los modos automáticos:
- Modo de movimiento automático, es decir, cuando se detecta movimiento, el relé permanece encendido durante una cierta cantidad de segundos.
- O puede usar el modo de brillo para que el relé se encienda cuando el brillo caiga por debajo de un cierto umbral.
- Finalmente, es posible controlar el relé en función del valor de luminosidad actual y cuando se detecta movimiento.
Le mostraremos todas estas características en acción más adelante en este proyecto.
JLCPCB
Este proyecto fue financiado por JLCPCB. JLCPCB es una conocida empresa de prototipos de PCB en China. Está especializada en la producción rápida de prototipos de PCB y pequeñas series. Puedes pedir al menos 10 PCB por solo $2.
Si desea convertir sus placas de pruebas en placas de circuitos reales y darle a sus proyectos un aspecto más profesional, solo necesita cargar los archivos Gerber para solicitar PCB de alta calidad a precios asequibles. Le mostraremos cómo hacer esto más adelante en esta publicación de blog.
Características del escudo multisensor ESP8266
El Multisensor Shield tiene múltiples sensores que pueden ser útiles para monitorear su hogar. El Escudo te permite controlar:
- 1x LED SMD para visualización de estado
- 1x resistencia dependiente de la luz (LDR)
- 1x sensor de temperatura DS18B20
- 1x sensor de movimiento PIR
Además, cuenta con una regleta de terminales que te da acceso a GND, 5V y GPIO15. Este puerto se puede utilizar para conectar un relé u otra salida que desee controlar.
Asignación de pines del escudo multisensor ESP8266
La siguiente tabla describe la asignación de pines de los componentes individuales del escudo multisensor:
| componente | Minifiguración de pines Wemos D1 |
| Sensor de movimiento PIR | GPIO5 (D1) |
| Sensor de temperatura DS18B20 | GPIO4 (D2) |
| Resistencia dependiente de la luz | A0 |
| CONDUJO | GPIO12 (D6) |
| Edición adicional | GPIO15 (D8) |
Si desea asignar y utilizar otros pines, consulte nuestra guía de referencia de distribución de pines ESP8266.
Probando el circuito en una placa de pruebas.
Antes de diseñar y construir el blindaje de PCB, es importante probar el circuito en una placa de pruebas. Si no quieres hacer una PCB, aún puedes hacer este proyecto ensamblando el circuito en una placa de pruebas.
Piezas requeridas
Se requieren las siguientes partes para construir el circuito en una placa de pruebas:
- ESP8266 WemosD1Mini – leer La mejor placa de desarrollo Wi-Fi ESP8266
- 1 LED de 5 mm
- 1x resistencia de 330 ohmios
- 1x sensor de temperatura DS18B20
- 1x Mini sensor de movimiento PIR
- 1x resistencia dependiente de la luz
- 2x resistencia de 10k ohmios
- 1x módulo de relé
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Esquema
Una vez que tengas todas las piezas juntas, monta el circuito según el siguiente esquema:
Aquí está el diagrama del circuito:
Diseño de placa de circuito
Después de asegurarme de que el circuito funcionara correctamente en una placa de pruebas, diseñé una placa de circuito KiCad. KiCad es un software de diseño de PCB de código abierto.
Diseñar un escudo de PCB ESP8266 es bastante sencillo. Ya existen piezas KiCad prefabricadas para WeMos. A continuación se muestra un enlace a las piezas de KiCad:
Todos los demás componentes ya están presentes en KiCad, como LED, LDR, resistencias, bloques de terminales, etc.
El diseño del circuito funciona como cualquier otra herramienta de software de circuitos: colocas algunos componentes y los conectas. Una vez que esté satisfecho con su circuito y cómo está usando los pines, es hora de asignar una huella a cada componente.
El WeMos D1 Mini ya se creó y todos los demás componentes también estaban disponibles de forma predeterminada en la biblioteca de piezas de KiCad.
Una vez que haya asignado las piezas, puede comenzar a colocar cada componente. Una vez que esté satisfecho con el diseño, realice todas las conexiones y enrute la placa de circuito.
Cuando haya terminado, guarde su proyecto y exporte los archivos Gerber.
nota: Si está familiarizado con KiCad, puede acceder y editar los archivos del proyecto para personalizar el escudo según sus propias necesidades.
Ordenar las placas de circuito
Si no sabes cómo diseñar la PCB tú mismo pero aun así quieres pedirla, es fácil. Sólo tienes que:
1. Descargue los archivos Gerber – Haga clic aquí para descargar el archivo ZIP
2. Ir a JLCPCB.compresione el «SOLICITA UNA COTIZACIÓN AHORA“ y cargue el archivo ZIP que acaba de descargar.
3. Verá un mensaje de éxito a continuación. Luego puede verificar si todo salió como se esperaba usando el enlace «Gerber Viewer» en la esquina inferior derecha. Puede ver la parte superior e inferior de la PCB. Puede mostrar u ocultar la máscara de soldadura, la serigrafía, el cobre, etc.
Con la configuración predeterminada, puedes pedir 10 PCB por solo $2. Sin embargo, si desea elegir otras configuraciones, como un color de PCB diferente, le costará unos dólares más.
4. Si está satisfecho con su pedido, haga clic en «AÑADIR A LA CESTABotón ”para completar el pedido.
Mis PCB tardaron 2 días en producirse y llegaron en 3 días hábiles con la opción de entrega de DHL.
desempacando
Después de aproximadamente una semana, las placas de circuito llegaron a mi oficina. Como siempre, todo estaba bien empaquetado y las placas de circuito son de muy alta calidad.
Las letras de la serigrafía están muy bien impresas y son fáciles de leer. No creo que pueda obtener un mejor servicio de PCB por este precio.
soldar los componentes
El siguiente paso es soldar los componentes a la placa de circuito. Utilicé un LED SMD y resistencias SMD. Sé que soldar componentes SMD es un poco difícil, pero ahorran mucho espacio en la PCB.
Aquí están las herramientas de soldadura que utilicé:
Lea nuestra reseña del soldador TS100: Revisión del soldador TS100: el mejor soldador portátil.
Aquí hay una lista de todos los componentes que necesita soldar a la PCB (no olvide los encabezados de pines para conectar el blindaje al Wemos D1 mini):
- 1x LED SMD
- 1x resistencias SMD de 330 ohmios
- Resistencia SMD de 2x 10 k ohmios
- 1x sensor de temperatura DS18B20
- 1x Mini sensor de movimiento PIR
- 1x resistencia dependiente de la luz
- 1x bloques de terminales de tornillo
- Toma de cabezal de clavija (hembra)
Comience soldando los componentes SMD. Luego suelde los cabezales de los pines. Finalmente, suelde los demás componentes.
Así es como se ve el WeMos Multisensor Shield después de que se hayan ensamblado todas las piezas. Debería conectarse al ESP8266 WeMos D1 mini sin ningún problema.
estuche impreso en 3D
Finalmente, puedes comprar un estuche para albergar tus circuitos. Si tienes una impresora 3D, puedes construir tu propio recinto.
Imprimí en 3D un recinto simple para colocar el escudo multisensor usando la impresora 3D Creality CR-10.
El estuche consta de dos partes: la base y la tapa. La tapa tiene un lugar para el sensor de movimiento PIR y un orificio rectangular para el LDR y el sensor de temperatura. En el lateral hay un lugar para los cables de relé y otro para el cable USB para encender y programar el ESP8266.
Eso es todo, ¡el cartel está listo!
Ahora es el momento de escribir algo de código.
Programación del escudo multisensor
El código de este proyecto ejecuta un servidor web que le permite monitorear y controlar el Escudo Multisensor en función de varias configuraciones configurables.
Antes de continuar, debes tener el ESP8266 instalado en tu IDE de Arduino. Siga el siguiente tutorial para instalar ESP8266 en el IDE de Arduino si aún no lo ha hecho.
- Cómo instalar la placa ESP8266 en Arduino IDE
Descripción general del servidor web
Sigamos con este proyecto. El servidor web que crearemos le permitirá elegir entre cuatro modos diferentes para controlar el relé:
- Manual (Modo 0): en el que tienes un botón para encender y apagar el relé.
- PIR automático (Modo 1): enciende el relé cuando se detecta movimiento. En este modo, hay un campo donde puede configurar la cantidad de segundos que la salida permanece encendida después de la detección de movimiento.
- LDR (Modo 2): El relé se enciende cuando el brillo cae por debajo de un cierto umbral. Puede establecer un umbral de LDR entre 0 y 100%.
- PIR automático y LDR (Modo 3): Este modo combina el sensor de movimiento PIR y el LDR. Cuando se selecciona este modo, el relé se activará cuando el sensor PIR detecte movimiento y el valor de brillo esté por debajo del umbral. En este modo puede configurar el temporizador y el umbral LDR.
También hay un botón en el servidor web que permite solicitar los valores de temperatura. Después de solicitar los valores de temperatura, puede ocultar los valores usando el botón Eliminar valores del sensor para optimizar el rendimiento del servidor web.
Cada modo tiene una etiqueta que muestra el modo seleccionado así como el estado de salida actual.
Queremos que el ESP8266 recuerde el último estado de salida y la configuración en caso de que se reinicie o pierda energía repentinamente. Por lo tanto, necesitamos almacenar estos parámetros en la EEPROM del ESP8266.
Instalación de bibliotecas
Antes de cargar el código, necesita instalar dos bibliotecas en su IDE de Arduino: la Biblioteca OneWire de Paul Stoffregen y eso Biblioteca de temperatura de Dallaspara que puedas utilizar el sensor DS18B20. Siga los siguientes pasos para instalar estas bibliotecas.
Biblioteca OneWire
- Haga clic aquí para descargar la biblioteca OneWire. Deberías tener una carpeta .zip en tus descargas.
- Descomprime eso .Cremallera carpeta y deberías recibir Maestro OneWire Carpeta
- Cambie el nombre de su carpeta de
Maestro OneWireA Un cable - mueve eso Un cable Carpeta a su instalación Arduino IDE Bibliotecas Carpeta
- Finalmente, vuelva a abrir su IDE de Arduino
Biblioteca de temperatura de Dallas
- Haga clic aquí para descargar la biblioteca DallasTemperature. Deberías tener una carpeta .zip en tus descargas.
- Descomprime eso .Cremallera carpeta y deberías recibir Maestro de la biblioteca de control de temperatura Arduino Carpeta
- Cambie el nombre de su carpeta de
Maestro de la biblioteca de control de temperatura ArduinoA Dallastemperatura - mueve eso DallastemperaturaCarpeta a su instalación Arduino IDE Bibliotecas Carpeta
- Finalmente, vuelva a abrir su IDE de Arduino
código
Copie el siguiente código en el IDE de Arduino.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
// Load libraries
#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include <OneWire.h>
#include <DallasTemperature.h>
// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
// Auxiliary variables for temperature
static char celsiusTemp[7];
static char fahrenheitTemp[7];
String temperatureString = ""; // Variable to hold the temperature reading
// EEPROM size
// Address 0: Last output state (0 = off or 1 = on)
// Address 1: Selected mode (0 = Manual, 1 = Auto PIR,
// 2 = Auto LDR, or 3 = Auto PIR and LDR)
// Address 2: Timer (time 0 to 255 seconds)
// Address 3: LDR threshold value (luminosity in percentage 0 to 100%)
#define EEPROM_SIZE 4
// Set GPIOs for: output variable, status LED, PIR Motion Sensor, and LDR
const int output = 15;
const int statusLed = 12;
const int motionSensor = 5;
const int ldr = A0;
// Store the current output state
String outputState = "off";
// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor
DallasTemperature sensors(&oneWire);
// Timers - Auxiliary variables
unsigned long now = millis();
unsigned long lastMeasure = 0;
boolean startTimer = false;
unsigned long currentTime = millis();
unsigned long previousTime = 0;
const long timeoutTime = 2000;
// Auxiliary variables to store selected mode and settings
int selectedMode = 0;
int timer = 0;
int ldrThreshold = 0;
int armMotion = 0;
int armLdr = 0;
String modes[4] = { "Manual", "Auto PIR", "Auto LDR", "Auto PIR and LDR" };
// Decode HTTP GET value
String valueString = "0";
int pos1 = 0;
int pos2 = 0;
// Variable to store the HTTP request
String header;
// Set web server port number to 80
WiFiServer server(80);
void setup() {
// Start the DS18B20 sensor
sensors.begin();
// Serial port for debugging purposes
Serial.begin(115200);
// PIR Motion Sensor mode, then set interrupt function and RISING mode
pinMode(motionSensor, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(motionSensor), detectsMovement, RISING);
Serial.println("start...");
EEPROM.begin(EEPROM_SIZE);
// Uncomment the next lines to test the values stored in the flash memory
/*Serial.println(" bytes read from Flash . Values are:");
for(int i = 0; i < EEPROM_SIZE; i++) {
Serial.print(byte(EEPROM.read(i)));
Serial.print(" ");
}*/
// Initialize the output variable and the LED as OUTPUTs
pinMode(output, OUTPUT);
pinMode(statusLed, OUTPUT);
digitalWrite(output, HIGH);
digitalWrite(statusLed, LOW);
// Read from flash memory on start and store the values in auxiliary variables
// Set output to last state (saved in the flash memory)
if(!EEPROM.read(0)) {
outputState = "off";
digitalWrite(output, HIGH);
}
else {
outputState = "on";
digitalWrite(output, LOW);
}
selectedMode = EEPROM.read(1);
timer = EEPROM.read(2);
ldrThreshold = EEPROM.read(3);
configureMode();
// Connect to Wi-Fi network with SSID and password
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop() {
WiFiClient client = server.available(); // Listen for incoming clients
if (client) { // If a new client connects,
currentTime = millis();
previousTime = currentTime;
Serial.println("New Client."); // print a message out in the serial port
String currentLine = ""; // make a String to hold incoming data from the client
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected
currentTime = millis();
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == 'n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
// Display the HTML web page
client.println("<!DOCTYPE html><html>");
client.println("<head><meta name="viewport" content="width=device-width, initial-scale=1">");
client.println("<link rel="icon" href="data:,">");
// CSS to style the on/off buttons
// Feel free to change the background-color and font-size attributes to fit your preferences
client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}");
client.println(".button { background-color: #4CAF50; border: none; color: white; padding: 16px 40px;");
client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}");
client.println(".button2 {background-color: #555555;}</style></head>");
// Request example: GET /?mode=0& HTTP/1.1 - sets mode to Manual (0)
if(header.indexOf("GET /?mode=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
selectedMode = valueString.toInt();
EEPROM.write(1, selectedMode);
EEPROM.commit();
configureMode();
}
// Change the output state - turn GPIOs on and off
else if(header.indexOf("GET /?state=on") >= 0) {
outputOn();
}
else if(header.indexOf("GET /?state=off") >= 0) {
outputOff();
}
// Set timer value
else if(header.indexOf("GET /?timer=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
timer = valueString.toInt();
EEPROM.write(2, timer);
EEPROM.commit();
Serial.println(valueString);
}
// Set LDR Threshold value
else if(header.indexOf("GET /?ldrthreshold=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
ldrThreshold = valueString.toInt();
EEPROM.write(3, ldrThreshold);
EEPROM.commit();
Serial.println(valueString);
}
// Web Page Heading
client.println("<body><h1>ESP8266 Web Server</h1>");
// Drop down menu to select mode
client.println("<p><strong>Mode selected:</strong> " + modes[selectedMode] + "</p>");
client.println("<select id="mySelect" onchange="setMode(this.value)">");
client.println("<option>Change mode");
client.println("<option value="0">Manual");
client.println("<option value="1">Auto PIR");
client.println("<option value="2">Auto LDR");
client.println("<option value="3">Auto PIR and LDR</select>");
// Display current state, and ON/OFF buttons for output
client.println("<p>GPIO - State " + outputState + "</p>");
// If the output is off, it displays the ON button
if(selectedMode == 0) {
if(outputState == "off") {
client.println("<p><button class="button" onclick="outputOn()">ON</button></p>");
}
else {
client.println("<p><button class="button button2" onclick="outputOff()">OFF</button></p>");
}
}
else if(selectedMode == 1) {
client.println("<p>Timer (0 and 255 in seconds): <input type="number" name="txt" value="" +
String(EEPROM.read(2)) + "" onchange="setTimer(this.value)" min="0" max="255"></p>");
}
else if(selectedMode == 2) {
client.println("<p>LDR Threshold (0 and 100%): <input type="number" name="txt" value="" +
String(EEPROM.read(3)) + "" onchange="setThreshold(this.value)" min="0" max="100"></p>");
}
else if(selectedMode == 3) {
client.println("<p>Timer (0 and 255 in seconds): <input type="number" name="txt" value="" +
String(EEPROM.read(2)) + "" onchange="setTimer(this.value)" min="0" max="255"></p>");
client.println("<p>LDR Threshold (0 and 100%): <input type="number" name="txt" value="" +
String(EEPROM.read(3)) + "" onchange="setThreshold(this.value)" min="0" max="100"></p>");
}
// Get and display DHT sensor readings
if(header.indexOf("GET /?sensor") >= 0) {
sensors.requestTemperatures();
temperatureString = " " + String(sensors.getTempCByIndex(0)) + "C " +
String(sensors.getTempFByIndex(0)) + "F";
client.println("<p>");
client.println(temperatureString);
client.println("</p>");
client.println("<p><a href="/"><button>Remove Sensor Readings</button></a></p>");
}
else {
client.println("<p><a href="?sensor"><button>View Sensor Readings</button></a></p>");
}
client.println("<script> function setMode(value) { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?mode=" + value + "&", true);");
client.println("xhr.send(); location.reload(true); } ");
client.println("function setTimer(value) { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?timer=" + value + "&", true);");
client.println("xhr.send(); location.reload(true); } ");
client.println("function setThreshold(value) { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?ldrthreshold=" + value + "&", true);");
client.println("xhr.send(); location.reload(true); } ");
client.println("function outputOn() { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?state=on", true);");
client.println("xhr.send(); location.reload(true); } ");
client.println("function outputOff() { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?state=off", true);");
client.println("xhr.send(); location.reload(true); } ");
client.println("function updateSensorReadings() { var xhr = new XMLHttpRequest();");
client.println("xhr.open('GET', "/?sensor", true);");
client.println("xhr.send(); location.reload(true); }</script></body></html>");
// The HTTP response ends with another blank line
client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != 'r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
client.stop();
Serial.println("Client disconnected.");
}
// Starts a timer to turn on/off the output according to the time value or LDR reading
now = millis();
// Mode selected (1): Auto PIR
if(startTimer && armMotion && !armLdr) {
if(outputState == "off") {
outputOn();
}
else if((now - lastMeasure > (timer * 1000))) {
outputOff();
startTimer = false;
}
}
// Mode selected (2): Auto LDR
// Read current LDR value and turn the output accordingly
if(armLdr && !armMotion) {
int ldrValue = map(analogRead(ldr), 0, 1023, 0, 100);
Serial.println(ldrValue);
if(ldrValue < ldrThreshold && outputState == "on") {
outputOff();
}
else if(ldrValue > ldrThreshold && outputState == "off") {
outputOn();
}
delay(100);
}
// Mode selected (3): Auto PIR and LDR
if(startTimer && armMotion && armLdr) {
int ldrValue = map(analogRead(ldr), 0, 1023, 0, 100);
Serial.println(ldrValue);
if(ldrValue < ldrThreshold) {
outputOff();
startTimer = false;
Serial.println("a");
}
else if(ldrValue > ldrThreshold && outputState == "off") {
outputOn();
Serial.println("b");
}
else if(now - lastMeasure > (timer * 1000)) {
outputOff();
startTimer = false;
Serial.println("c");
}
}
}
// Checks if motion was detected and the sensors are armed. Then, starts a timer.
ICACHE_RAM_ATTR void detectsMovement() {
if(armMotion || (armMotion && armLdr)) {
Serial.println("MOTION DETECTED!!!");
startTimer = true;
lastMeasure = millis();
}
}
void configureMode() {
// Mode: Manual
if(selectedMode == 0) {
armMotion = 0;
armLdr = 0;
// Status LED: off
digitalWrite(statusLed, LOW);
}
// Mode: Auto PIR
else if(selectedMode == 1) {
outputOff();
armMotion = 1;
armLdr = 0;
// Status LED: on
digitalWrite(statusLed, HIGH);
}
// Mode: Auto LDR
else if(selectedMode == 2) {
armMotion = 0;
armLdr = 1;
// Status LED: on
digitalWrite(statusLed, HIGH);
}
// Mode: Auto PIR and LDR
else if(selectedMode == 3) {
outputOff();
armMotion = 1;
armLdr = 1;
// Status LED: on
digitalWrite(statusLed, HIGH);
}
}
// Change output pin to on or off
void outputOn() {
Serial.println("GPIO on");
outputState = "on";
digitalWrite(output, LOW);
EEPROM.write(0, 1);
EEPROM.commit();
}
void outputOff() {
Serial.println("GPIO off");
outputState = "off";
digitalWrite(output, HIGH);
EEPROM.write(0, 0);
EEPROM.commit();
}
La explicación de este código es bastante larga, por lo que simplemente puede reemplazar las dos variables siguientes con sus credenciales de red y el código funcionará de inmediato.
const char* ssid = "";
const char* password = "";Si quieres saber cómo funciona este código, sigue leyendo.
Cómo funciona el código
Comience integrando las bibliotecas necesarias.
#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include <OneWire.h>
#include <DallasTemperature.h>El ESP8266WiFi Se requiere biblioteca para utilizar las funciones de ESP Wi-Fi. El EEPROM La biblioteca le permite leer y escribir datos persistentes en la EEPROM ESP8266, y las bibliotecas OneWire y DallasTemperature le permiten leer la temperatura del sensor de temperatura DS18B20.
Configuración de sus credenciales de red
Debe colocar sus credenciales de red en estas dos variables.
const char* ssid = "";
const char* password = "";Estas son variables auxiliares para almacenar la temperatura en Celsius/Fahrenheit:
// Auxiliary variables for temperature and humidity
static char celsiusTemp[7];
static char fahrenheitTemp[7];
static char humidityTemp[7];
String temperatureString = ""; // Variable to hold the temperature readingEEPROM
A continuación definimos el tamaño de EEPROM al que queremos acceder.
#define EEPROM_SIZE 4Necesitamos almacenar cuatro valores en la memoria flash: el último estado de salida en la dirección 0, el modo seleccionado en la dirección 1, el valor del temporizador en la dirección 2 y el umbral LDR en la dirección 3. Entonces necesitamos 4 bytes en la memoria flash.
- Dirección 0: Último estado de salida (0 = apagado o 1 = encendido)
- Dirección 1: Modo seleccionado (0 = Manual, 1 = Auto PIR, 2 = Auto LDR o 3 = Auto PIR y LDR)
- Dirección 2: Temporizador (tiempo de 0 a 255 segundos)
- Dirección 3: Umbral LDR (luminosidad en porcentaje de 0 a 100%)
Definición de GPIO
En este apartado definimos los GPIO para la salida, LED de estado, sensor de movimiento PIR y LDR.
const int output = 15;
const int statusLed = 12;
const int motionSensor = 5;
const int ldr = A0;También creamos una variable de cadena para almacenar el estado de salida que se mostrará en el servidor web.
String outputState = "off";Sensor de temperatura
A continuación, cree las instancias necesarias para el sensor de temperatura. El sensor de temperatura está conectado a GPIO 4.
// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor
DallasTemperature sensors(&oneWire);Temporizador
A continuación creamos variables auxiliares para los temporizadores:
long now = millis();
long lastMeasure = 0;
boolean startTimer = false;Modo seleccionado y configuración
Aquí inicializamos variables para guardar el modo y la configuración seleccionados:
int selectedMode = 0;
int timer = 0;
int ldrThreshold = 0;
int armMotion = 0;
int armLdr = 0;
String modes[4] = { "Manual", "Auto PIR", "Auto LDR", "Auto PIR and LDR" };Configuración de variables para el servidor web.
El siguiente fragmento de código hace referencia al servidor web. Puede seguir el tutorial del servidor web ESP8266 para familiarizarse con algunos códigos básicos del servidor web.
// Decode HTTP GET value
String valueString = "0";
int pos1 = 0;
int pos2 = 0;
// Variable to store the HTTP request
String header;
// Set web server port number to 80
WiFiServer server(80);configuración()
En el configuración()Comience inicializando el sensor de temperatura DS18B20.
sensors.begin();Para fines de depuración, inicialice el puerto serie con una velocidad de baudios de 115200.
Serial.begin(115200);Interrumpir
Configure el sensor de movimiento PIR como INPUT_PULLUP y defínalo como una interrupción en modo RISING.
pinMode(motionSensor, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(motionSensor), detectsMovement, RISING);Memoria flash
Esta parte del código inicializa la memoria flash con el tamaño de EEPROM previamente definido.
EEPROM.begin(EEPROM_SIZE);Configure el LED de estado y el pin de salida como salidas.
pinMode(output, OUTPUT);
pinMode(statusLed, OUTPUT);Estamos controlando un relé con lógica invertida, por lo que comenzaremos configurándolo en ALTO para que realmente funcione.
digitalWrite(output, HIGH);
digitalWrite(statusLed, HIGH);Luego configure la salida al último estado guardado. El estado inicial se guarda en la posición 0, así que use EEPROM.read(0).
Verificamos si el estado guardado está activado o desactivado para actualizar el estado de salida en consecuencia.
if(!EEPROM.read(0)) {
outputState = "off";
digitalWrite(output, HIGH);
}
else {
outputState = "on";
digitalWrite(output, LOW);
}También actualizamos todas las variables que contienen configuraciones con los valores almacenados en la EEPROM, como el modo seleccionado, el temporizador y el umbral LDR.
selectedMode = EEPROM.read(1);
timer = EEPROM.read(2);
ldrThreshold = EEPROM.read(3);Entonces los llamamos configurarModo() Función para asignar los valores correctos a cada modo.
configureMode();función configureMode()
Echemos un vistazo a cómo funciona esta característica. Si el modo seleccionado es Manual, el movimiento no se activará (movimiento del brazo), ni la LDR (pobreLdr). También ponemos el LED de estado en LOW para indicar que estamos en modo manual (en modo automático, el LED de estado está encendido).
if(selectedMode == 0) {
armMotion = 0;
armLdr = 0;
// Status LED: off
digitalWrite(statusLed, LOW);
}Se realiza un proceso similar para configurar los otros modos. Cambia las variables del brazo para habilitar o deshabilitar un sensor. Ahora volvamos a configuración().
Conexión wifi
Aquí nos conectamos a la red Wi-Fi e imprimimos la dirección IP del ESP8266 en el monitor serie.
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();Cinta()
En el Cinta()mostremos el servidor web y dejemos que las cosas sucedan de acuerdo con el modo y la configuración seleccionados.
Hemos cubierto los servidores web en detalle en el tutorial del servidor web ESP8266. Por lo tanto, sólo veremos las partes que sean más relevantes para este proyecto.
Esta parte del código es más fácil de entender si explicamos qué está pasando con una demostración en vivo.
Cuando acceda al servidor web, verá una página web similar.
Arriba puede seleccionar uno de estos cuatro modos diferentes.
- Manual (Modo 0)
- PIR automático (Modo 1)
- LDR automático (Modo 2)
- PIR automático y LDR (Modo 3)
Modo manual
Por ejemplo, si elige el modo manual, se ejecutará la siguiente parte del código.
if(header.indexOf("GET /?mode=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
selectedMode = valueString.toInt();
EEPROM.write(1, selectedMode);
EEPROM.commit();
configureMode();
}El modo seleccionado se muestra en modo seleccionado variable y la guarda en la memoria flash con:
EEPROM.write(1, selectedMode);La apariencia del sitio web cambia según el modo seleccionado. En este caso, como hemos seleccionado el modo manual, que es igual a 0, la siguiente declaración if es verdadera y la página web muestra dos botones para controlar la salida.
if(selectedMode == 0) {
if(outputState == "off") {
client.println("<p><button class="button" onclick="outputOn()">ON</button></p>");
}
else {
client.println("<p><button class="button button2" onclick="outputOff()">OFF</button></p>");
}
}Cuando hace clic en los botones de encendido y apagado, se ejecuta el siguiente código y una de estas dos declaraciones else if activa o desactiva la salida.
// Change the output state - turn GPIOs on and off
else if(header.indexOf("GET /?state=on") >= 0) {
outputOn();
}
else if(header.indexOf("GET /?state=off") >= 0) {
outputOff();
}Modo PIR automático
Ahora seleccione el modo Auto PIR en el menú desplegable.
Aparecerá un nuevo campo de entrada en el sitio web. En este campo puede ingresar un número entero entre 0 y 255 para especificar la cantidad de segundos que desea que la salida permanezca encendida después de que se detecte movimiento.
Cuando cambia el número, se llama a la siguiente parte del código y se cambia la variable del temporizador.
else if(header.indexOf("GET /?timer=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
timer = valueString.toInt();
EEPROM.write(2, timer);
EEPROM.commit();
Serial.println(valueString);
}En este modo (modo 1) sólo se muestra el campo de entrada para el temporizador.
else if(selectedMode == 1) {
client.println("<p>Timer (0 and 255 in seconds): <input type="number" name="txt" value="" +
String(EEPROM.read(2)) + "" onchange="setTimer(this.value)" min="0" max="255"></p>");
}Modo LDR automático
Seleccione el modo Auto LDR y aparecerá un nuevo campo de entrada.
Esto establece el umbral de LDR. Puede ingresar un número entre 0 y 100 para indicar el porcentaje de luminosidad. Cuando cambia este campo, se llama a la siguiente parte del código para actualizar el umbral de LDR:
else if(header.indexOf("GET /?ldrthreshold=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
ldrThreshold = valueString.toInt();
EEPROM.write(3, ldrThreshold);
EEPROM.commit();
Serial.println(valueString);
}Este es el Modo 2 y se muestra el campo de entrada LDR Threshold.
else if(selectedMode == 2) {
client.println("<p>LDR Threshold (0 and 100%): <input type="number" name="txt" value="" +
String(EEPROM.read(3)) + "" onchange="setThreshold(this.value)" min="0" max="100"></p>");
}Modo automático PIR y LDR
Al seleccionar el modo PIR y LDR automático se activan tanto PIR como LDR. También se cargará una nueva página web con dos campos de entrada.
Ambos campos de entrada funcionan de la misma manera que describimos antes.
Valores de los sensores
Finalmente, hay un botón para solicitar y mostrar valores de temperatura.
if(header.indexOf("GET /?sensor") >= 0) {
sensors.requestTemperatures();
temperatureString = " " + String(sensors.getTempCByIndex(0)) + "C " +
String(sensors.getTempFByIndex(0)) + "F";
client.println("<p>");
client.println(temperatureString);
client.println("</p>");También hay un botón que le permite eliminar estas métricas.
client.println("<p><a href="/"><button>Remove Sensor Readings</button></a></p>");Cómo configurar los ajustes de su multisensor. Luego, dependiendo del modo y la configuración seleccionados, otra parte del Cinta() se ejecuta para comprobar si la salida debe estar activada o desactivada.
Controlar el estado de salida
Por ejemplo, si detecta movimiento, llama al detecta movimiento() Función que pone en marcha un cronómetro.
void detectsMovement() {
if(armMotion || (armMotion && armLdr)) {
Serial.println("MOTION DETECTED!!!");
startTimer = true;
lastMeasure = millis();
}
}Luego la salida se encenderá o apagará dependiendo del tiempo transcurrido.
// Mode selected (1): Auto PIR
if(startTimer && armMotion && !armLdr) {
if(outputState == "off") {
outputOn();
}
else if((now - lastMeasure > (timer * 1000))) {
outputOff();
startTimer = false;
}
}También existe la siguiente sección de código para activar o desactivar la salida según el brillo del umbral.
// Mode selected (2): Auto LDR
// Read current LDR value and turn the output accordingly
if(armLdr && !armMotion) {
int ldrValue = map(analogRead(ldr), 0, 1024, 0, 100);
//Serial.println(ldrValue);
if(ldrValue > ldrThreshold && outputState == "on") {
outputOff();
}
else if(ldrValue < ldrThreshold && outputState == "off") {
outputOn();
}
delay(100);
}Finalmente, el siguiente fragmento de código se ejecuta cuando se selecciona el modo automático PIR y LDR y se detecta movimiento.
// Mode selected (3): Auto PIR and LDR
if(startTimer && armMotion && armLdr) {
int ldrValue = map(analogRead(ldr), 0, 4095, 0, 100);
//Serial.println(ldrValue);
if(ldrValue > ldrThreshold) {
outputOff();
startTimer = false;
}
else if(ldrValue < ldrThreshold && outputState == "off") {
outputOn();
}
else if(now - lastMeasure > (timer * 1000)) {
outputOff();
startTimer = false;
}
}En términos generales, así es como funciona el código. También nos tomamos la molestia de escribir una serie de comentarios en el código para que sea más fácil de entender.
Programamos el WeMos Multisensor Shield con este código, pero también puedes escribir tu propio código para integrarlo en cualquier plataforma domótica. Sólo hay que tener en cuenta la asignación de pines del escudo multisensor.
Sube el código
Haga clic en el botón Cargar para cargar el código en su ESP8266. Asegúrese de haber seleccionado la placa y el puerto COM correctos.
Prueba del escudo multisensor
Abra el monitor serie con una velocidad de baudios de 112500. Presione el botón de habilitación ESP8266 para imprimir la dirección IP ESP.
Abra su navegador e ingrese la dirección IP del ESP8266. La siguiente página debería cargarse.
Conectamos un módulo de relé al zócalo del conector de salida, por lo que controlamos una lámpara de 12 V, pero usted puede controlar cualquier salida que desee.
Ahora seleccione cada modo y pruebe diferentes configuraciones para comprobar si todo funciona correctamente.
Por ejemplo, seleccione el modo Manual y encienda y apague la lámpara.
Seleccione el modo PIR automático. En este modo, la lámpara se enciende durante la cantidad de segundos que establezca cuando se detecta movimiento.
En el modo LDR puedes establecer el umbral en el que se enciende la lámpara. Cuando cubro el LDR, la luminosidad cae por debajo del umbral y la lámpara se enciende.
En el modo Auto PIR y LDR puedo configurar el temporizador y el umbral LDR.
Si se detecta movimiento pero la intensidad de la luz está por encima del umbral, no sucede nada. Pero si cubro el LDR, es decir, no hay luz y se detecta movimiento, la lámpara se enciende durante la cantidad de segundos que he especificado en la configuración.
También puede hacer clic en el botón Ver lecturas del sensor para solicitar las últimas lecturas de temperatura.
Envolver
¡Regalaremos 5 PCB en blanco a todos los que dejen un comentario a continuación! Simplemente deje un comentario en esta publicación de blog indicándonos qué le gustaría hacer con la PCB y tendrá la oportunidad de ganar una de estas PCB en blanco. ¡Los ganadores serán anunciados la próxima semana! ¡Así que estad atentos! [Update] El sorteo ha finalizado y los ganadores son: Ram Chivukula, Phillip R. Hickman, Douglas W Murray, Terry Wegener y Dale Wolver.
Eso es todo por este proyecto. Esperamos que este proyecto le haya resultado útil y pueda crearlo usted mismo. Puede programar el Multisensor Shield con otro código que se adapte a sus necesidades. Por ejemplo, puede controlar la salida en función del valor de temperatura actual. También puede editar los archivos Gerber y agregar más funciones al ESP8266 Multisensor Shield.
Si te gusta este proyecto, es posible que también te gusten otros proyectos relacionados:
- Curso de domótica con ESP8266
- Construya un escudo de estación meteorológica ESP32 todo en uno
- Servidor web ESP32 con BME280 – mini estación meteorológica
Gracias por leer.
Construya un escudo multisensor para ESP8266
En este proyecto descubrirás cómo diseñar y crear un escudo multisensor para la placa ESP8266 Wemos D1 Mini. El escudo cuenta con un sensor de temperatura (DS18B20), un sensor de movimiento PIR, un LDR y un terminal para conectar un módulo de relé. Empezaremos por preparar todo el hardware y luego programarlo.
Ver el tutorial en video
Este proyecto está disponible en formato de video y escrito. Puedes ver el video a continuación o desplazarte hacia abajo para ver las instrucciones escritas. Este proyecto está dividido en dos videos.
Diseño y Construcción del Escudo Multisensor ESP8266 WeMos D1 Mini – Parte 1
En este primer video decidiremos el hardware que vamos a utilizar. También veremos las características principales de este proyecto y cómo diseñar y ensamblar tu propio escudo multisensor WeMos D1 Mini.
Programar y Probar el Escudo Multisensor ESP8266 WeMos D1 Mini – Parte 2
En este segundo video, programaremos el escudo multisensor Wemos D1 Mini con un código que ejecuta un servidor web que te permite monitorear y controlar el escudo multisensor basado en varias configuraciones.
Recursos
Puedes encontrar todos los recursos necesarios para construir este proyecto en los enlaces a continuación (o puedes visitar el proyecto en GitHub):
Código del servidor web (para Arduino IDE)
Diagrama esquemático
Archivos Gerber
Proyecto KiCad para editar el PCB
Carcasa de impresión en 3D (archivos STL y proyecto de SketchUp)
Haz clic aquí para descargar todos los archivos
Visión General del Proyecto
El escudo consiste en un sensor de temperatura, un sensor de movimiento, un LDR y un zócalo de 3 pines al que puedes conectar cualquier salida. Nosotros usaremos un módulo de relé.
También escribiremos un programa que ejecuta un servidor web para controlar el escudo usando 4 modos diferentes con varias configuraciones ajustables.
Al final de este proyecto, tendrás un gadget similar funcionando. Podrás controlar el relé activándolo y desactivándolo en modo manual.
O puedes elegir los modos automáticos:
- Modo de movimiento automático
- Modo de luminosidad
- Control automático basado en la luminosidad actual y si se detecta movimiento
Te mostraremos todas estas características en acción más adelante en este proyecto.
JLCPCB
Este proyecto fue patrocinado por JLCPCB. JLCPCB es una conocida empresa de prototipos de PCB en China. Se especializa en prototipos rápidos de PCB y producción en pequeñas cantidades. Puedes pedir un mínimo de 10 PCBs por solo $2.
Si quieres convertir tus circuitos de protoboard en placas reales y hacer que tus proyectos luzcan más profesionales, solo tienes que cargar los archivos Gerber para pedir PCBs de alta calidad a precios bajos. Te mostraremos cómo hacerlo más adelante en esta publicación.
Características del Escudo Multisensor ESP8266
El escudo multisensor cuenta con varios sensores que pueden ser útiles para monitorear tu casa. El escudo te permite controlar:
- 1x LED SMD para indicar un estado
- 1x fotocélula (LDR)
- 1x sensor de temperatura DS18B20
- 1x sensor de movimiento PIR
Además, también cuenta con un bloque de terminales que te brinda acceso a GND, 5V y GPIO15. Ese terminal puede ser usado para conectar un relé, o cualquier otra salida que desees controlar.
Asignación de Pines del Escudo Multisensor ESP8266
La siguiente tabla describe la asignación de pines para cada componente del escudo multisensor:
| Componente | Wemos D1 Mini Pines Asignados |
|---|---|
| Sensor de Movimiento PIR | GPIO5 (D1) |
| Sensor de Temperatura DS18B20 | GPIO4 (D2) |
| Fotocélula (LDR) | A0 |
| LED | GPIO12 (D6) |
| Salida adicional | GPIO15 (D8) |
Pruebas del Circuito en un Protoboard
Antes de diseñar y construir el escudo PCB, es importante probar el circuito en un protoboard. Si no quieres hacer un PCB, aún puedes seguir este proyecto ensamblando el circuito en un protoboard.
Partes Necesarias
Para ensamblar el circuito en un protoboard, necesitas las siguientes partes:
- ESP8266 Wemos D1 Mini
- 1 LED de 5mm
- 1 resistencia de 330 Ohmios
- 1 sensor de temperatura DS18B20
- 1 sensor de movimiento PIR miniatura
- 1 fotocélula (LDR)
- 2 resistencias de 10k Ohmios
- 1 módulo de relé
- Protoboard
- Cables de puente
Puedes usar los enlaces anteriores o ir directamente a MakerAdvisor.com/tools para encontrar todas las piezas para tus proyectos al mejor precio.
Esquemático
Después de reunir todas las piezas, ensambla el circuito siguiendo el diagrama esquemático a continuación:
Diseñando el PCB
Después de asegurarte de que el circuito funcionaba correctamente en el protoboard, diseñé un PCB en KiCad. KiCad es un software de código abierto utilizado para diseñar PCBs.
El diseño de un escudo PCB ESP8266 es bastante sencillo. Ya existen partes de KiCad predefinidas para el WeMos, y puedes encontrar un enlace a las partes KiCad a continuación:
WeMos D1 Mini Parte KiCad
Todas las demás piezas ya existen en KiCad, como el LED, LDR, resistencias, bloques de terminales, etc.
Diseñar el circuito funciona como en cualquier otra herramienta de diseño de circuitos. Colocas algunos componentes y los conectas entre sí. Cuando estés satisfecho con tu circuito y el uso de pines, es hora de asignar cada componente a un footprint.
El WeMos D1 Mini ya estaba creado y todas las demás componentes también estaban disponibles de forma predeterminada en la biblioteca de partes de KiCad.
Una vez que hayas asignado las partes, puedes comenzar a colocar cada componente. Cuando estés satisfecho con el diseño, haz todas las conexiones y ruta tu PCB. Cuando termines, guarda tu proyecto y exporta los archivos Gerber.
Nota: si estás familiarizado con KiCad, puedes obtener los archivos del proyecto y editarlos para personalizar el escudo según tus necesidades.
Descargar archivo comprimido de GERBER
Proyecto KiCad para editar el PCB
Pidiendo los PCBs
Si no sabes cómo diseñar el PCB tú mismo, pero igual quieres pedirlos, es muy fácil. Solo tienes que:
- Descargar los archivos Gerber – haz clic aquí para descargar el archivo .zip
- Ir a JLCPCB.com, hacer clic en el botón «QUOTE NOW» y subir el archivo .zip que acabas de descargar.
- Verás un mensaje de éxito en la parte inferior. Luego, puedes usar el enlace «Gerber Viewer» en la esquina inferior derecha para verificar si todo salió como se esperaba. Puedes ver la parte superior y la inferior del PCB. Puedes ver u ocultar la máscara de soldadura, la inscripción, el cobre, etc.
- Con la configuración predeterminada, puedes pedir 10 PCBs por solo $2. Sin embargo, si quieres seleccionar otras opciones como un color de PCB diferente, te costará unos dólares más.
- Cuando estés satisfecho con tu pedido, haz clic en el botón «SAVE TO CART» para completar el pedido.
Mis PCBs tardaron 2 días en ser fabricados y llegaron en 3 días hábiles usando la opción de entrega de DHL.
Desempaquetado
Después de aproximadamente una semana, recibí los PCBs en mi oficina. Como siempre, todo venía muy bien embalado y los PCBs son de alta calidad.
Las letras en la serigrafía están muy bien impresas y son fáciles de leer. No creo que puedas obtener un mejor servicio de PCB por este precio.
Conectando los Componentes
El siguiente paso es soldar los componentes en el PCB. He utilizado un LED SMD y resistencias SMD. Sé que puede ser un poco difícil soldar componentes SMD, pero ahorran mucho espacio en el PCB.
Estos son las herramientas de soldadura que he usado:
- Hierro de soldar mini portátil TS100
- Estaño de 60/40 con diámetro de 0.5mm
- Tapete de soldadura
Aquí tienes una lista de todos los componentes que necesitas soldar en el PCB (no olvides los pines de cabecera para conectar el escudo a la Wemos D1 mini):
- 1x LED SMD
- 1x resistencia SMD de 330 Ohmios
- 2x resistencias SMD de 10k Ohmios
- 1x sensor de temperatura DS18B20
- 1x sensor de movimiento PIR miniatura
- 1x fotocélula (LDR)
- 1x bloques de terminales
- Pines hembra para cabecera
Empieza soldando los componentes SMD. Luego, suelda los pines de cabecera. Finalmente, suelda los demás componentes en su lugar.
Así es como se ve el Escudo Multisensor WeMos una vez ensamblados todos los componentes. Debería encajar perfectamente en la ESP8266 WeMos D1 mini.
Estuche Impreso en 3D
Por último, puedes comprar una carcasa para colocar tu circuito. Si tienes una impresora 3D, puedes construir tu propia carcasa.
Imprimí una carcasa sencilla para colocar el escudo multisensor utilizando la impresora 3D Creality CR-10.
La carcasa consta de dos piezas: la base y la tapa. La tapa tiene un espacio para el sensor de movimiento PIR y un agujero rectangular para el LDR y el sensor de temperatura. En un lado, hay un espacio para los cables del relé y otro para que pase el cable USB para alimentar y programar la ESP8266.
¡Y listo, el escudo está terminado!
Programando el Escudo Multisensor
El código de este proyecto ejecuta un servidor web que te permite monitorear y controlar el escudo multisensor basado en varias configuraciones ajustables.
Antes de continuar, debes tener el ESP8266 instalado en tu Arduino IDE. Sigue el siguiente tutorial para instalar el ESP8266 en el Arduino IDE, si aún no lo has hecho.
Cómo Instalar la Placa ESP8266 en Arduino IDE
Visión General del Código
Comencemos incluyendo las bibliotecas necesarias.
#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include <OneWire.h>
#include <DallasTemperature.h>La biblioteca ESP8266WiFi es necesaria para utilizar las capacidades Wi-Fi del ESP. La biblioteca EEPROM te permite leer y escribir datos permanentes en la EEPROM de ESP8266, y las bibliotecas OneWire y DallasTemperature te permiten leer la temperatura del sensor DS18B20.
Sigue configurando tus credenciales de red:
const char* ssid = "";
const char* password = "";Estas son variables auxiliares para almacenar la temperatura en Celsius/Fahrenheit:
static char celsiusTemp[7];
static char fahrenheitTemp[7];
String temperatureString = ""; // Variable to hold the temperature readingA continuación, especifica el tamaño de la EEPROM que deseas acceder:
#define EEPROM_SIZE 4Para controlar la salida, el LED y los sensores, define los pines GPIO correspondientes:
const int output = 15;
const int statusLed = 12;
const int motionSensor = 5;
const int ldr = A0;Define la variable outputState para mostrar el estado de la salida en el servidor web:
String outputState = "off";Configura el bus OneWire y el sensor de temperatura para el DS18B20:
const int oneWireBus = 4;
OneWire oneWire(oneWireBus);
DallasTemperature sensors(&oneWire);Continúa configurando variables para los temporizadores, modos seleccionados y ajustes:
long now = millis();
long lastMeasure = 0;
boolean startTimer = false;
int selectedMode = 0;
int timer = 0;
int ldrThreshold = 0;
int armMotion = 0;
int armLdr = 0;
String modes[4] = { "Manual", "Auto PIR", "Auto LDR", "Auto PIR and LDR" };Especifica el puerto del servidor web y comienza la configuración en el setup:
WiFiServer server(80);
void setup() {
// Inicializa el sensor DS18B20
sensors.begin();
// Inicializa el puerto serie para fines de depuración
Serial.begin(115200);
// Inicializa el sensor de movimiento PIR
pinMode(motionSensor, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(motionSensor), detectsMovement, RISING);
Serial.println("Comenzando...");
EEPROM.begin(EEPROM_SIZE);
pinMode(output, OUTPUT);
pinMode(statusLed, OUTPUT);
digitalWrite(output, HIGH);
digitalWrite(statusLed, LOW);
if(!EEPROM.read(0)) {
outputState = "off";
digitalWrite(output, HIGH);
}
else {
outputState = "on";
digitalWrite(output, LOW);
}
selectedMode = EEPROM.read(1);
timer = EEPROM.read(2);
ldrThreshold = EEPROM.read(3);
configureMode();
Serial.print("Conectando a ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.println("Dirección IP: ");
Serial.println(WiFi.localIP());
server.begin();
}Continúa con el bucle loop() donde se maneja la lógica del servidor web y el control de salida basado en los modos y ajustes seleccionados.
void loop() {
WiFiClient client = server.available();
if (client) {
currentTime = millis();
previousTime = currentTime;
String currentLine = "";
while (client.connected() && currentTime - previousTime <= timeoutTime) {
currentTime = millis();
if (client.available()) {
char c = client.read();
Serial.write(c);
header += c;
if (c == 'n') {
if (currentLine.length() == 0) {
if (header.indexOf("GET /?mode=") >= 0) {
¡Qué interesante! Me encantaría poder construir mi propio escudo multisensor con ESP8266. Gracias por compartir este artículo.
¡Wow, esto es genial! Definitivamente voy a intentar construir mi propio escudo multisensor con ESP8266 siguiendo estos pasos. ¡Gracias por la inspiración!