Para realizar un sistema de detección facial con esp8266, Arduino, etc, puedes seguir los siguientes pasos:

• Necesitas una placa ESP32-CAM, que tiene una cámara integrada y un módulo WiFi. También necesitas un Arduino Uno o Mega, un relé, un servomotor, un LED y una cerradura eléctrica.
• Conecta el ESP32-CAM al Arduino mediante un cable USB y sube el código que te permite acceder al servidor web de la cámara. Puedes encontrar el código y el esquema en el enlace 2.
• Descarga el archivo shape_predictor_68_face_landmarks.dat desde el enlace 4 y cópialo en la carpeta de tu proyecto. Este archivo contiene el modelo de reconocimiento facial que usarás con la librería OpenCV.
• Instala la librería OpenCV en tu ordenador y crea un script en Python que se conecte al servidor web de la cámara y reciba las imágenes. En el script, usa la función cv2.face_landmarks para detectar los puntos de referencia faciales y la función cv2.face_recognition para comparar los rostros con una base de datos de imágenes previamente almacenadas.
• Si el rostro detectado coincide con alguno de la base de datos, envía una señal al Arduino a través del puerto serie para que active el relé y el servomotor, que a su vez abrirán la cerradura y encenderán el LED. Si no hay coincidencia, el sistema no hará nada o mostrará un mensaje de error.
• Puedes encontrar un ejemplo de código y un vídeo explicativo en el enlace 3.

DHT11 Temperatura y humedad

El sensor DHT11 es un sensor digital que mide la temperatura y la humedad del aire. Puedes usarlo con Arduino para hacer proyectos como una estación meteorológica, un sistema de monitoreo de plantas o un controlador de clima. El sensor DHT11 tiene 3 pines. Los pines son:

• 1 VCC: alimentación
• 2 DATA: transmisión de datos
• 3 NO USADO
• 4 GND: conexión a tierra

El pin DATA es digital, no analógico, y se conecta a un pin digital de Arduino. El sensor DHT11 usa un protocolo de comunicación especial para enviar los datos al Arduino, por lo que necesitas usar una biblioteca como la de Adafruit para leerlos correctamente.

Aquí tienes un ejemplo de código para usar el sensor DHT11 con Arduino:

#include "DHT.h"

#define DHTPIN 2
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    Serial.println("Error al leer el sensor");
    return;
  }

  Serial.print("Humedad: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.println(" *C");

  delay(1000);
}

SRF04 Distancia

El sensor ultrasónico SRF04 es un sensor que mide la distancia a un objeto mediante el envío y la recepción de ondas ultrasónicas. El sensor tiene dos pines: uno para enviar un pulso ultrasónico (Trigger) y otro para recibir el eco del pulso (Echo). El sensor también necesita una alimentación de 5V y una conexión a tierra.

Para usar el sensor con Arduino, se necesita conectar el pin Trigger a un pin digital de salida y el pin Echo a un pin digital de entrada. Luego, se necesita enviar un pulso de al menos 10 us al pin Trigger para iniciar la medición. El sensor enviará 8 pulsos ultrasónicos y esperará el eco. El pin Echo se pondrá en estado alto cuando reciba el eco y se mantendrá así durante un tiempo proporcional a la distancia al objeto. Midiendo ese tiempo con la función pulseIn() se puede calcular la distancia usando la fórmula:

Distancia = (Tiempo x Velocidad del sonido) / 2

Donde la velocidad del sonido es aproximadamente 343 m/s o 0.0343 cm/us.

Aquí tienes un ejemplo de código para usar el sensor ultrasónico SRF04 con Arduino:

// Define los pines del sensor
#define TRIGGER_PIN 2
#define ECHO_PIN 3

void setup() {
  // Inicia el puerto serie
  Serial.begin(9600);
  // Configura los pines del sensor
  pinMode(TRIGGER_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  // Inicia la medición enviando un pulso al pin Trigger
  digitalWrite(TRIGGER_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);

  // Mide el tiempo que dura el eco en el pin Echo
  unsigned long duration = pulseIn(ECHO_PIN, HIGH);

  // Calcula la distancia usando la fórmula
  float distance = (duration * 0.0343) / 2;

  // Muestra la distancia por el puerto serie
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");

  // Espera un segundo entre mediciones
  delay(1000);
}

ARD-394 Acelerometro

El acelerómetro Siemens ARD-394 es un sensor que mide la aceleración y la rotación en tres ejes. El sensor se basa en el chip MPU-6050, que integra un acelerómetro y un giroscopio de 16 bits. El sensor se comunica con Arduino mediante el protocolo I2C, usando solo dos pines: SDA y SCL.

Para usar el sensor con Arduino, se necesita conectar el pin SDA del sensor al pin A4 de Arduino y el pin SCL del sensor al pin A5 de Arduino. También se necesita conectar el pin VCC del sensor al pin 5V de Arduino y el pin GND del sensor al pin GND de Arduino.

Luego, se necesita usar una biblioteca que facilite la lectura del sensor, como la biblioteca I2Cdevlib. Esta biblioteca se puede descargar desde este enlace: https://github.com/jrowberg/i2cdevlib

La biblioteca incluye varios ejemplos para usar el sensor ARD-394 con Arduino. Uno de ellos es el ejemplo MPU6050_DMP6, que muestra cómo leer los valores de aceleración, rotación y orientación del sensor usando el procesamiento digital de movimiento (DMP) integrado en el chip MPU-6050.

Aquí tienes un ejemplo de código para usar el sensor ARD-394 con Arduino:

// Incluye las bibliotecas necesarias
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#include "Wire.h"

// Crea una instancia del sensor
MPU6050 mpu;

// Define las variables para almacenar los datos del sensor
int16_t ax, ay, az;
int16_t gx, gy, gz;
int16_t mx, my, mz;
Quaternion q;
VectorFloat gravity;
float ypr[3];

void setup() {
  // Inicia el puerto serie
  Serial.begin(115200);
  // Inicia la comunicación I2C
  Wire.begin();
  // Inicializa el sensor
  mpu.initialize();
  // Comprueba si el sensor está conectado
  if (!mpu.testConnection()) {
    Serial.println("Error: no se puede conectar con el sensor");
    while (1);
  }
  // Carga el firmware DMP al sensor
  uint8_t devStatus = mpu.dmpInitialize();
  // Comprueba si la carga fue exitosa
  if (devStatus == 0) {
    // Activa el DMP
    mpu.setDMPEnabled(true);
    Serial.println("DMP activado");
  } else {
    Serial.println("Error: no se puede activar el DMP");
    while (1);
  }
}

void loop() {
  // Comprueba si hay datos disponibles del DMP
  if (mpu.dmpGetCurrentFIFOPacket()) {
    // Lee los datos del DMP
    mpu.dmpGetQuaternion(&q);
    mpu.dmpGetGravity(&gravity);
    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
    mpu.dmpGetAccel(&ax, &ay, &az);
    mpu.dmpGetGyro(&gx, &gy, &gz);
    mpu.dmpGetMag(&mx, &my, &mz);

    // Muestra los datos por el puerto serie
    Serial.print("Aceleracion: ");
    Serial.print(ax); Serial.print(" ");
    Serial.print(ay); Serial.print(" ");
    Serial.println(az);

    Serial.print("Rotacion: ");
    Serial.print(gx); Serial.print(" ");
    Serial.print(gy); Serial.print(" ");
    Serial.println(gz);

    Serial.print("Orientacion: ");
    Serial.print(ypr[0] * 180/M_PI); Serial.print(" ");
    Serial.print(ypr[1] * 180/M_PI); Serial.print(" ");
    Serial.println(ypr[2] * 180/M_PI);

    Serial.println();
  }
}

L293D Control de motores

Permite controlar hasta 4 motores de corriente continua o 2 motores a pasos o 2 servomotores. La tarjeta usa el chip L293D, que es un controlador de motor de doble canal H-Bridge que puede manejar una corriente de hasta 1 A por canal.

Para usar la tarjeta con Arduino, se necesita conectar el shield a los pines correspondientes de Arduino. Los pines usados son:

• Pines digitales 3, 5, 6 y 11: para controlar la velocidad de los motores mediante PWM.
• Pines digitales 4, 7, 8 y 12: para controlar la dirección de los motores mediante señales lógicas.
• Pines analógicos 0 y 1: para controlar los servomotores mediante señales PWM.
• Pin digital 9: para habilitar o deshabilitar el chip L293D mediante una señal lógica.

Luego, se necesita usar una biblioteca que facilite el control de los motores, como la biblioteca AFMotor. Esta biblioteca se puede descargar desde este enlace: https://github.com/adafruit/Adafruit-Motor-Shield-library

La biblioteca incluye varios ejemplos para usar la tarjeta con Arduino. Uno de ellos es el ejemplo MotorTest, que muestra cómo controlar un motor de corriente continua conectado al puerto M1 de la tarjeta.

Aquí tienes un ejemplo de código para usar la tarjeta con Arduino:

// Incluye la biblioteca AFMotor
#include <AFMotor.h>

// Crea una instancia del motor conectado al puerto M1
AF_DCMotor motor(1);

void setup() {
  // Inicia el puerto serie
  Serial.begin(9600);
}

void loop() {
  // Prueba el motor en diferentes velocidades y direcciones
  Serial.print("Forward");
  motor.setSpeed(200); // Establece la velocidad del motor (0-255)
  motor.run(FORWARD); // Establece la dirección del motor (FORWARD o BACKWARD)
  delay(1000);

  Serial.print("Backward");
  motor.setSpeed(100); // Establece la velocidad del motor (0-255)
  motor.run(BACKWARD); // Establece la dirección del motor (FORWARD o BACKWARD)
  delay(1000);

  Serial.print("Release");
  motor.run(RELEASE); // Libera el motor (no lo acciona)
  delay(1000);
}

Servomotor

Un servo es un tipo de motor que permite controlar la posición angular de su eje mediante una señal PWM (modulación por ancho de pulsos). Los servos se usan a menudo en proyectos de robótica, como brazos robóticos, torretas o vehículos.

Para controlar un servo con Arduino, se necesita conectar el cable rojo del servo al pin 5V de Arduino, el cable negro al pin GND y el cable amarillo o blanco a un pin digital que soporte PWM, como el pin 9.

Luego, se necesita usar una biblioteca que facilite el control del servo, como la biblioteca Servo.h que viene preinstalada con el IDE de Arduino. Esta biblioteca permite crear una instancia del servo, asignarle un pin, establecer su posición angular y liberarlo cuando no se usa.

Aquí tienes un ejemplo de código para controlar un servo con Arduino:

// Incluye la biblioteca Servo.h
#include <Servo.h>

// Crea una instancia del servo
Servo miServo;

void setup() {
  // Asigna el pin 9 al servo
  miServo.attach(9);
}

void loop() {
  // Prueba el servo en diferentes posiciones angulares
  Serial.print("0 grados");
  miServo.write(0); // Establece la posición del servo en 0 grados
  delay(1000);

  Serial.print("90 grados");
  miServo.write(90); // Establece la posición del servo en 90 grados
  delay(1000);

  Serial.print("180 grados");
  miServo.write(180); // Establece la posición del servo en 180 grados
  delay(1000);

  Serial.print("Liberar");
  miServo.detach(); // Libera el servo (no lo acciona)
  delay(1000);
}

https://www.luisllamas.es/arduino-lcd-hitachi-hd44780/

1. Instala el paquete de placas de desarrollo basadas en el ESP8266 en el gestor de tarjetas del IDE de Arduino. Para ello, debes agregar la siguiente URL en las preferencias del IDE: http://arduino.esp8266.com/stable/package_esp8266com_index.json.
2. Selecciona la placa que vas a usar (por ejemplo, NodeMCU o Wemos) en el menú Herramientas > Placa.
3. Installa el driver NODE_MCU : https://github.com/nodemcu/nodemcu-devkit/tree/master/Drivers . Al termmminar conecta la placa al ordenador mediante un cable USB y selecciona el puerto correspondiente en el menú Herramientas > Puerto.
4. Escribe o carga un sketch.
5. Compila y sube el sketch a la placa usando el botón Subir o el menú Programa > Subir.

Los modos de funcionalidad que puede brindarnos este controlador son:

• Modo estación (STA): el ESP8266 se conecta a una red WiFi existente como un dispositivo más.
• Modo punto de acceso (AP): el ESP8266 crea su propia red WiFi y permite que otros dispositivos se conecten a él.
• Modo estación + punto de acceso (STA+AP): el ESP8266 actúa como un puente entre dos redes WiFi, una a la que se conecta como estación y otra que crea como punto de acceso.

Puedes cambiar el modo de funcionamiento del ESP8266 usando la función WiFi.mode()³. Por ejemplo:

// Establecer el modo estación
WiFi.mode(WIFI_STA);

// Establecer el modo punto de acceso
WiFi.mode(WIFI_AP);

// Establecer el modo estación + punto de acceso
WiFi.mode(WIFI_AP_STA);

• Para conectarte a una red WiFi existente en modo estación, utiliza la función WiFi.begin(). Aquí tienes un ejemplo básico:

#include <ESP8266WiFi.h>

const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";

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

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a la red WiFi...");
  }

  Serial.println("Conectado a la red WiFi");
}

void loop() {
  // Tu código aquí
}

Asegúrate de reemplazar "nombre_red_wifi" con el nombre de la red WiFi a la que deseas conectarte y "contraseña_red_wifi" con la contraseña correspondiente.

• Para crear tu propia red WiFi en modo punto de acceso, utiliza la función WiFi.softAP(). Aquí tienes un ejemplo básico:

#include <ESP8266WiFi.h>

const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";

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

  WiFi.softAP(ssid, password);

  Serial.println("Red WiFi creada");
}

void loop() {
  // Tu código aquí
}

Reemplaza "nombre_red_wifi" con el nombre que deseas asignar a tu red WiFi y "contraseña_red_wifi" con la contraseña que deseas utilizar.

• Para utilizar el modo estación + punto de acceso, simplemente configura ambos modos en tu sketch. Aquí tienes un ejemplo:

#include <ESP8266WiFi.h>

const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";

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

  WiFi.mode(WIFI_AP_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a la red WiFi...");
  }

  Serial.println("Conectado a la red WiFi");

  IPAddress localIP = WiFi.softAPIP();
  Serial.print("Dirección IP del punto de acceso: ");
  Serial.println(localIP);
}

void loop() {
  // Tu código aquí
}

Recuerda reemplazar "nombre_red_wifi" y "contraseña_red_wifi" con los valores correspondientes.

Otros ejemplos

Para mostrar el tiempo que lleva corriendo el controlador ESP8266 en una página web conectándose a una red, puedes usar el siguiente código:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ArduinoJson.h>

// Reemplaza con los datos de tu red
const char* ssid = "Skynet";
const char* password = "namaste0";

// Crea un objeto ESP8266WebServer en el puerto 80
ESP8266WebServer server(80);

void setup() {
  // Inicia el monitor serie
  Serial.begin(9800);
  // Conecta el ESP8266 a la red WiFi
  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());
  // Define la ruta del servidor para la raíz
  server.on("/", handleRoot);
  // Define la ruta del servidor para /info
  server.on("/info", handleInfo);
  // Inicia el servidor
  server.begin();
}

void loop() {
  // Maneja las peticiones del cliente
  server.handleClient();
}

// Función para manejar las peticiones a la raíz del servidor
void handleRoot() {
  // Crea un objeto DynamicJsonDocument para almacenar los datos en formato JSON
  DynamicJsonDocument doc(1024);
  // Añade el mensaje al JSON
  doc["message"] = "service running";
  // Crea una cadena vacía para almacenar el JSON serializado
  String output;
  // Serializa el JSON en la cadena
  serializeJson(doc, output);
  // Envía una respuesta al navegador con el código JSON
  server.send(200, "application/json", output);
}

// Función para manejar las peticiones a la ruta /info
void handleInfo() {
   // Crea un objeto DynamicJsonDocument para almacenar los datos en formato JSON
   DynamicJsonDocument doc(4096);
   // Añade información sobre la conexión WiFi al JSON
   doc["wifiStatus"] = WiFi.status();
   doc["wifiSSID"] = WiFi.SSID();
   doc["wifiRSSI"] = WiFi.RSSI();
   doc["wifiBSSID"] = WiFi.BSSIDstr();
   // Añade información sobre la dirección IP al JSON
   doc["localIP"] = WiFi.localIP().toString();
   doc["subnetMask"] = WiFi.subnetMask().toString();
   doc["gatewayIP"] = WiFi.gatewayIP().toString();
   doc["dnsIP"] = WiFi.dnsIP().toString();
   // Añade información sobre el nombre del host al JSON
   doc["hostname"] = WiFi.hostname();
   // Añade información sobre la petición al JSON
   doc["method"] = server.method();
   doc["url"] = server.uri();
   // Añade información sobre los parámetros al JSON
   JsonArray params = doc.createNestedArray("params");
   for (int i = 0; i < server.args(); i++) {
     JsonObject param = params.createNestedObject();
     param["name"] = server.argName(i);
     param["value"] = server.arg(i);
   }
   // Añade información sobre las cabeceras al JSON
   JsonArray headers = doc.createNestedArray("headers");
   for (int i = 0; i < server.headers(); i++) {
     JsonObject header = headers.createNestedObject();
     header["name"] = server.headerName(i);
     header["value"] = server.header(i);
   }
   // Crea una cadena vacía para almacenar el JSON serializado
   String output;
   // Serializa el JSON en la cadena
   serializeJson(doc, output);
   // Envía una respuesta al navegador con el código JSON
   server.send(200, "application/json", output);
}

Este código crea un servidor web que responde a las peticiones a la raíz (/) con el tiempo que lleva corriendo el ESP8266 desde que se inició.

• Aquí tienes un ejemplo de programa que utiliza el ESP8266 en modo estación para conectarse a una red WiFi y realizar una solicitud HTTP a un servidor web. El programa utiliza la librería ESP8266WiFi para la conexión WiFi y la librería ESP8266HTTPClient para realizar la solicitud HTTP.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";
const char* serverUrl = "http://ejemplo.com/api";

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

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a la red WiFi...");
  }

  Serial.println("Conectado a la red WiFi");

  // Realizar la solicitud HTTP al servidor
  HTTPClient http;
  http.begin(serverUrl);

  int httpResponseCode = http.GET();

  if (httpResponseCode > 0) {
    Serial.print("Respuesta del servidor: ");
    Serial.println(http.getString());
  } else {
    Serial.print("Error en la solicitud. Código de error: ");
    Serial.println(httpResponseCode);
  }

  http.end();
}

void loop() {
  // Tu código aquí
}

Asegúrate de reemplazar "nombre_red_wifi" y "contraseña_red_wifi" con los detalles de tu red WiFi y "http://ejemplo.com/api" con la URL del servidor web y la ruta a la API que deseas acceder.

• Aquí tienes otro ejemplo de programa que utiliza el ESP8266 en modo estación para leer datos de un sensor DHT11 (sensor de temperatura y humedad) y enviarlos a través de MQTT a un servidor MQTT.

Este ejemplo utiliza la librería ESP8266WiFi para la conexión WiFi, la librería PubSubClient para la comunicación MQTT y la librería DHT para leer los datos del sensor DHT11.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

// Configuración de la red WiFi
const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";

// Configuración del servidor MQTT
const char* mqttServer = "mqtt.example.com";
const int mqttPort = 1883;
const char* mqttUser = "usuario_mqtt";
const char* mqttPassword = "contraseña_mqtt";
const char* mqttTopic = "temperatura_humedad";

// Configuración del pin del sensor DHT11
const int dhtPin = D3;

// Inicialización del objeto DHT
DHT dht(dhtPin, DHT11);

// Inicialización del objeto WiFiClient
WiFiClient espClient;

// Inicialización del objeto PubSubClient
PubSubClient client(espClient);

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

  // Conexión a la red WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a la red WiFi...");
  }

  Serial.println("Conectado a la red WiFi");

  // Conexión al servidor MQTT
  client.setServer(mqttServer, mqttPort);
  client.setCallback(callback);

  while (!client.connected()) {
    if (client.connect("esp8266", mqttUser, mqttPassword)) {
      Serial.println("Conectado al servidor MQTT");
    } else {
      Serial.print("Error en la conexión MQTT. Código de error: ");
      Serial.println(client.state());
      delay(2000);
    }
  }

  // Inicialización del sensor DHT11
  dht.begin();
}

void loop() {
  // Lectura de la temperatura y humedad del sensor DHT11
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Publicación de los datos en el servidor MQTT
  String payload = String(temperature) + "," + String(humidity);
  client.publish(mqttTopic, payload.c_str());

  Serial.print("Temperatura: ");
  Serial.print(temperature);
  Serial.print(" °C, Humedad: ");
  Serial.print(humidity);
  Serial.println(" %");

  delay(5000); // Esperar 5 segundos antes de enviar la siguiente lectura
}

void callback(char* topic, byte* payload, unsigned int length) {
  // Aquí puedes agregar código para manejar mensajes MQTT entrantes, si es necesario
}

Asegúrate de reemplazar "nombre_red_wifi" y "contraseña_red_wifi" con los detalles de tu red WiFi, "mqtt.example.com" con la dirección del servidor MQTT, "usuario_mqtt" y "contraseña_mqtt" con las credenciales de acceso al servidor MQTT, y "temperatura_humedad" con el nombre del tema MQTT al que deseas publicar los datos.

Este programa se conectará a la red WiFi especificada y al servidor MQTT, leerá la temperatura y humedad del sensor DHT11 y enviará los datos al servidor MQTT en formato "temperatura,humedad". Los datos también se imprimirán en el Monitor Serie.

Recuerda incluir las librerías ESP8266WiFi, PubSubClient y DHT en el IDE de Arduino antes de compilar el programa.

• Aquí tienes un ejemplo de programa que utiliza el ESP8266 en modo estación para leer datos de un sensor DHT11 y enviarlos a un servidor MySQL a través de una URL con PHP. También se incluye un ejemplo de cómo recibir esos datos en Python desde el servidor MySQL.

1. Programa en Arduino (ESP8266) para enviar datos a una URL con PHP:

#include <ESP8266WiFi.h>
#include <DHT.h>

// Configuración de la red WiFi
const char* ssid = "nombre_red_wifi";
const char* password = "contraseña_red_wifi";

// Configuración del servidor MySQL
const char* serverUrl = "http://ejemplo.com/insert.php";
const char* apiKey = "clave_de_api";

// Configuración del pin del sensor DHT11
const int dhtPin = D3;

// Inicialización del objeto DHT
DHT dht(dhtPin, DHT11);

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

  // Conexión a la red WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a la red WiFi...");
  }

  Serial.println("Conectado a la red WiFi");

  // Inicialización del sensor DHT11
  dht.begin();
}

void loop() {
  // Lectura de la temperatura y humedad del sensor DHT11
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Construcción de la URL con los datos a enviar
  String url = String(serverUrl) + "?api_key=" + apiKey + "&temperature=" + String(temperature) + "&humidity=" + String(humidity);

  // Realizar la solicitud HTTP al servidor PHP
  WiFiClient client;
  if (client.connect(serverUrl, 80)) {
    Serial.println("Enviando datos al servidor...");

    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + serverUrl + "\r\n" +
                 "Connection: close\r\n\r\n");
    delay(10);

    Serial.println("Datos enviados al servidor");
  } else {
    Serial.println("Error al conectarse al servidor");
  }

  delay(5000); // Esperar 5 segundos antes de enviar la siguiente lectura
}

Asegúrate de reemplazar "nombre_red_wifi" y "contraseña_red_wifi" con los detalles de tu red WiFi, "http://ejemplo.com/insert.php" con la URL de tu servidor PHP y "clave_de_api" con una clave de API si es necesario para autenticación.

2. Ejemplo de código PHP (insert.php) para recibir los datos en el servidor y guardarlos en la base de datos MySQL:

<?php
$apiKey = $_GET['api_key'];

// Verificar clave de API
if ($apiKey != 'clave_de_api') {
  die("Acceso no autorizado");
}

$temperature = $_GET['temperature'];
$humidity = $_GET['humidity'];

// Conexión a la base de datos MySQL
$servername = "localhost";
$username = "nombre_usuario";
$password = "contraseña";
$dbname = "nombre_base_de_datos";

$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
  die("Error de conexión a la base de datos: " . $conn->connect_error);
}

// Insertar datos en la tabla
$sql = "INSERT INTO datos_sensor (temperatura, humedad) VALUES ($temperature, $humidity)";
if ($conn->query($sql) === TRUE) {
  echo "Datos insertados correctamente";
} else {
  echo "Error al insertar datos: " . $conn->error;
}

$conn->close();
?>

Asegúrate de reemplazar "clave_de_api" con la misma clave de API que utilizaste en el programa Arduino, y de configurar correctamente los detalles de conexión a tu base de datos MySQL.

3. Ejemplo en Python para recibir los datos desde la base de datos MySQL:

import mysql.connector

# Conexión a la base de datos MySQL
mydb = mysql.connector.connect(
  host="localhost",
  user="nombre_usuario",
  password="contraseña",
  database="nombre_base_de_datos"
)

mycursor = mydb.cursor()

# Consulta para obtener los últimos datos insertados
mycursor.execute("SELECT * FROM datos_sensor ORDER BY id DESC LIMIT 1")

result = mycursor.fetchone()

# Imprimir los datos obtenidos
if result is not None:
  temperature = result[1]
  humidity = result[2]

  print("Últimos datos registrados:")
  print("Temperatura: " + str(temperature))
  print("Humedad: " + str(humidity))
else:
  print("No hay datos registrados")

mycursor.close()
mydb.close()

Asegúrate de reemplazar "nombre_usuario", "contraseña" y "nombre_base_de_datos" con los detalles de conexión a tu base de datos MySQL.

Este ejemplo utiliza la librería mysql.connector de Python para realizar la conexión y consulta a la base de datos MySQL.

ESP wifi Hacking https://www.youtube.com/watch?v=AnASvDkz7ss

https://github.com/SpacehuhnTech/esp8266_deauther

Deauth attack https://www.youtube.com/watch?v=a9cRrV36m-c

ESPBug https://github.com/willmendil/ESPBug

HoneyPot https://github.com/bdash9/ESP32-SSDP-HoneyPot-Phishing-webserver

Evil Twin https://www.youtube.com/watch?v=V7Tm_kk7r4Q

Arduino MEGA 2560 WiFi - ESP8266

Conexiones de pins:

• Upload ESP8266:
  • 5,6,7 ON
• Upload ATmega:
  • 3,4 ON
• ATmega + ESP COM3:
  • 1,2,3,4 ON