Lectura de magnitudes con ESP32 - andrerossellm/TC1004B.501_E8 GitHub Wiki

Contenido:

Sensor de distancia

Para realizar la medición de la distancia comprendida entre el conjunto de sensores y el objeto de interés se empleó el componente HC-SR04. imagen

Este, junto con el código correspondiente y la definición de los pines en la placa de desarrollo, proporciona un valor de interpretación numérica al registrar el tiempo que tarda una señal ultrasónica emitida en rebotar y ser captada por un receptor. A continuación se incluye fragmento de código necesario para la obtención de la distancia en centímetros.

#define TRIG_PIN 23 // ESP32 pin GIOP23 connected to Ultrasonic Sensor's TRIG pin
#define ECHO_PIN 22 // ESP32 pin GIOP22 connected to Ultrasonic Sensor's ECHO pin

float duration_us, distance_cm;

void setup() {
  // begin serial port
  Serial.begin (9600);

  // configure the trigger pin to output mode
  pinMode(TRIG_PIN, OUTPUT);
  // configure the echo pin to input mode
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  // generate 10-microsecond pulse to TRIG pin
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // measure duration of pulse from ECHO pin
  duration_us = pulseIn(ECHO_PIN, HIGH);

  // calculate the distance
  distance_cm = 0.017 * duration_us;

  // print the value to Serial Monitor
  Serial.print("distance: ");
  Serial.print(distance_cm);
  Serial.println(" cm");

  delay(500);
}

Sensor de flama

image

El módulo KY-026 nos permite identificar la presencia de una flama en cercanía del fotodiodo contenido en este. Es mediante la validación de una fuente dentro del rango espectral de la llama que el microcontrolador del módulo envía una señal digital a la placa ESP-32, misma que se lee y funciona como condicionante para el despliegue del estado de manera textual. Este sistema proporciona una señal digital HIGH en todo momento que no sea detectada una llama en su cercanía, y una señal LOW cuando es detectada.

A continuación se incluye fragmento de código necesario para la obtención de presencia de llama.

#define isFlamePin 17  // Pin input para el puerto DO 
int isFlame = HIGH;  // HIGH MEANS NO FLAME

void setup() {
  pinMode(isFlamePin, INPUT); //flame sensor should be input as it is giving data
  Serial.begin(9600); //begin Serial communication
  
}

void loop() {
  isFlame = digitalRead(isFlamePin);//Readd the data given by the flame sensor
  if (isFlame== LOW)  //if it is low
  {
    Serial.println("FLAME, FLAME, FLAME"); //Print Flame Flame
    digitalWrite(LED_BUILTIN, HIGH);  //LED on
  }
  else                           //if not
  {                               
    Serial.println("no flame"); //print no  flame
    digitalWrite(LED_BUILTIN, LOW);    //off the LED
  }
  delay(1000);
}

Sensor de temperatura y humedad

imagen

La lectura de la temperatura y humedad del ambiente se realizar mediante el uso del componente DHT11, mismo cuya implementación solo es posible mediante la inclusión de las librerías dedicadas: DHT.h, DHT_U.h y Adafruit_Sensor.h . Utilizaremos las funciones readHumidity() y readTemperature() para obtener mediciones en forma de variable tipo float. Es importante mencionar que debe de haber una pausa en la ejecución de la función loop(), esto es para dejar que el sensor se tome el momento necesario y realice la medición. A continuación se adjunta el código necesario para la implementación.

#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

#include "DHT.h"

#define DHTPIN 22     // Pin digital conectado al sensor

// Se define el tipo de sensor a utilizar
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);
//Variables del sensor temp/humedad
float h;
float t;
float f;

void setup() {
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));
  dht.begin();
} 

void loop(){
  // Se debe de esperar algunos segundos entre mediciones
  delay(2000);
  h = dht.readHumidity();
  // Se leee la temperatura en grados Celsius
  t = dht.readTemperature();
  // Se leee la temperatura en grados Fahrenheit (isFahrenheit = true)
  f = dht.readTemperature(true);

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C , "));
  Serial.print(f);
  Serial.print(F("°F\n"));
}

Sensor de movimiento

imagen

Estaremos implementando el componente HC-SR501 para evaluar la existencia de movimiento en los distintos tiempos de medición. Este componente no implica la necesidad de incluir librerías al programa y solamente cuenta con un pin digital de salida. La forma en la que validaremos la existencia de movimiento será mediante la comparación de variables en distintos momentos consecutivos. La variable declarada pinStateCurrent fungirá como punto de comparación con respecto de la variable pinStatePrevious, la cual representa si existió o no movimiento al momento de la medición anterior. De esta manera, al iterar la comparación de ambas variables podremos determinar tanto si empezó ha haber movimiento, o si el movimiento existente cesó.

const int PIN_TO_SENSOR = 19; // GIOP19 pin connected to OUTPUT pin of sensor
int pinStateCurrent   = LOW;  // current state of pin
int pinStatePrevious  = LOW;  // previous state of pin

void setup() {
  Serial.begin(9600);            // initialize serial
  pinMode(PIN_TO_SENSOR, INPUT); // set ESP32 pin to input mode to read value from OUTPUT pin of sensor
}

void loop() {
  pinStatePrevious = pinStateCurrent; // store old state
  pinStateCurrent = digitalRead(PIN_TO_SENSOR);   // read new state

  if (pinStatePrevious == LOW && pinStateCurrent == HIGH) {
    // pin state change: LOW -> HIGH
    Serial.println("Motion detected!");
    // TODO: turn on alarm, light or activate a device ... here
  }
  else
  if (pinStatePrevious == HIGH && pinStateCurrent == LOW) {
    // pin state change: HIGH -> LOW
    Serial.println("Motion stopped!");
    // TODO: turn off alarm, light or deactivate a device ... here
  }
}
⚠️ **GitHub.com Fallback** ⚠️