• LM35 (U4) es un sensor de temperatura que proporciona una salida de voltaje proporcional a la temperatura en grados Celsius. La señal se procesa con los amplificadores operacionales (U2 y U3) para llevarla a un rango de 4-20 mA.
• Asegúrate de que la conexión de alimentación y tierra estén correctas: conecta U4:+VS a V3:ANODE y U4:GND a Net 7.

• La señal de corriente de 5-20 mA es tomada de R1 y convertida en una señal de voltaje compatible con ESP32. Asegúrate de que la caída de voltaje en R1 está dentro del rango de entrada analógica del ESP32.
• Conectar R1:P1 a $por \ ejemplo$ U1:VP (pin analógico del ESP32).

• Conecta el módulo I2C: H1 al ESP32 para controlarlo:
  • Connect H1:SCK to U1:D22.
  • Connect H1:SDA to U1:D21.
• Alimentar y controlar el LCD:
  • VSS del LCD1 a Net GND.
  • VDD del LCD1 a Net 5 $perteneciente \ a \ una \ fuente \ de \ alimentación \ de \ 5V, \ p. \ ej. \ V3:CATHODE$.
  • Conectar los pines de control (RS, R/W, E) al ESP32 si es necesario.

• La señal de control para el relé K4 es generada con el fotodiodo D9.
• Programar el ESP32 para que verifique la temperatura y controle el relé con lógica de activación específica:
  • Fotodiodo activa el relé: D9:A conectado a U1:D22 para recibir señal de control.
  • Conectar K4:NO a la lámpara de 120VAC y asegurar que está alimentada según especificaciones.

• Cuando la temperatura $ \ 30°C, \ desactiva \ K4$.

1. Lea la señal del LM35.
2. Convierta dicha señal a temperatura.
3. Muestre la temperatura en una pantalla LCD I2C.
4. Controle el relé basado en la temperatura.

Cpp
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Inicializa la dirección del LCD: el común es 0x27 o 0x3F
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorPin = 34;    // $U1:VP$ - Pin analógico en ESP32
const int relayPin = 22;     // Conecta al pin del relé

void setup() {
  Wire.begin();
  lcd.begin();
  lcd.backlight();
  
  pinMode(sensorPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Apaga el relé inicialmente
}

void loop() {
  // Lee el valor analógico del sensor
  int sensorValue = analogRead(sensorPin);
  
  // Convertir el valor leido a temperatura en Celsius
  float temperatureC = $(sensorValue / 4095.0) * 3.3$; // Ajustar según caída en $R1$
  temperatureC = temperatureC * 100; // Si la salida del sensor es 10mV por grado
  
  // Muestra temperatura en la LCD
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatureC);
  lcd.print(" C");
  
  // Control del relé
  if (temperatureC < 10) {
    digitalWrite(relayPin, HIGH); // Activa el relé
  } else if (temperatureC > 30) {
    digitalWrite(relayPin, LOW);  // Desactiva el relé
  }
  
  delay(1000);  // Espera 1 segundo antes de la próxima lectura
}

• Debes instalar la biblioteca LiquidCrystal_I2C en tu IDE de Arduino si no la tienes aún.
• Confirma la dirección I2C de tu pantalla LCD (puede ser 0x27 o 0x3F).
• Los valores de conversión de voltaje y temperatura dependen de la configuración particular y el divisor de tensión en R1.

1. Conexiones I2C:
   • Conectar H1:SCK a otro pin disponible, por ejemplo, U1:D18.
   • Mantener H1:SDA en U1:D21.
2. Conexión al fotodiodo y relé:
   • Dejar U1:D22 para controlar el fotodiodo y, a través de él, el relé.

Cpp
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Inicializa la dirección del LCD. Ajustar si necesario
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorPin = 34;    // U1:VP - Pin analógico en ESP32
const int relayPin = 22;     // Conecta al pin del relé, U1:D22

void setup() {
  // Usa SDA en U1:D21 y SCL en U1:D18
  Wire.begin(21, 18);
  lcd.begin();
  lcd.backlight();
  
  pinMode(sensorPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Apaga el relé inicialmente
}

void loop() {
  // Lee el valor analógico del sensor
  int sensorValue = analogRead(sensorPin);
  
  // Convertir el valor leido a temperatura en Celsius
  float temperatureC = $(\frac{sensorValue}{4095.0}) \times 3.3$; // Ajustar según caída en R1
  temperatureC = temperatureC * 100; // Si la salida del sensor es 10mV por grado
  
  // Muestra temperatura en la LCD
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatureC);
  lcd.print(" C");
  
  // Control del relé
  if (temperatureC < 10) {
    digitalWrite(relayPin, HIGH); // Activa el relé
  } else if (temperatureC > 30) {
    digitalWrite(relayPin, LOW);  // Desactiva el relé
  }
  
  delay(1000);  // Espera 1 segundo antes de la próxima lectura
}

1. Biblioteca Wire:
   • La biblioteca Wire debe estar incluida de manera predeterminada en el IDE de Arduino, ya que es una biblioteca básica. No necesitas instalarla por separado.
2. Instalación de LiquidCrystal_I2C:
   • Abre tu IDE de Arduino.
   • Ve a Herramientas > Manejar Bibliotecas.
   • En la barra de búsqueda, escribe LiquidCrystal_I2C.
   • Busca una biblioteca llamada LiquidCrystal_I2C (hay varias versiones, una popular es de Frank de Brabander).
   • Haz clic en Instalar.

Cpp
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Inicializa la dirección del LCD (ajusta la dirección si es necesario)
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorPin = 34;    // U1:VP - Pin analógico en ESP32
const int relayPin = 22;     // Conecta al pin del relé, U1:D22

void setup() {
  // Usar SDA en U1:D21 y SCL en U1:D18
  Wire.begin(21, 18);
  lcd.begin();
  lcd.backlight();
  
  pinMode(sensorPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Apaga el relé inicialmente
}

void loop() {
  // Lee el valor analógico del sensor
  int sensorValue = analogRead(sensorPin);
  
  // Convertir el valor leído a temperatura en Celsius
  float temperatureC = $sensorValue / 4095.0 * 3.3$; // Ajustar según caída en R1
  temperatureC = temperatureC * 100; // Si la salida del sensor es 10mV por grado
  
  // Muestra temperatura en la LCD
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatureC);
  lcd.print(" C");
  
  // Control del relé
  if (temperatureC < 10) {
    digitalWrite(relayPin, HIGH); // Activa el relé
  } else if (temperatureC > 30) {
    digitalWrite(relayPin, LOW);  // Desactiva el relé
  }
  
  delay(1000);  // Esperar 1 segundo antes de la próxima lectura
}

Cpp
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Inicializa la dirección del LCD: el común es 0x27 o 0x3F
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorPin = 34;    // U1:VP - Pin analógico en ESP32
const int relayPin = 22;     // Conecta al pin del relé, U1:D22

void setup() {
  // Usa SDA en U1:D21 y SCL en U1:D18
  Wire.begin(21, 18);
  lcd.begin();
  lcd.backlight();
  
  pinMode(sensorPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Apaga el relé inicialmente
}

void loop() {
  // Lee el valor analógico del sensor
  int sensorValue = analogRead(sensorPin);
  
  // Convertir el valor leído a temperatura en Celsius
  float temperatureC = $sensorValue / 4095.0 * 3.3$; // Ajustar según caída en R1
  temperatureC = $temperatureC * 100$; // Si la salida del sensor es 10mV por grado
  
  // Muestra temperatura en la LCD
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatureC);
  lcd.print(" C");
  
  // Control del relé
  if (temperatureC < 10) {
    digitalWrite(relayPin, HIGH); // Activa el relé
  } else if (temperatureC > 30) {
    digitalWrite(relayPin, LOW);  // Desactiva el relé
  }
  
  delay(1000);  // Espera 1 segundo antes de la próxima lectura
}

Cpp
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

1. Wire: Esta biblioteca es utilizada para la comunicación I2C. Debe estar predeterminadamente en el IDE de Arduino.
2. LiquidCrystal_I2C: Necesitarás instalar esta biblioteca para controlar la pantalla LCD I2C.

Cpp
#include <Wire.h>             // Biblioteca para comunicación I2C
#include <LiquidCrystal_I2C.h> // Biblioteca para controlar LCD I2C

Cpp
#include <Wire.h>             // Biblioteca para comunicación I2C
#include <LiquidCrystal_I2C.h> // Biblioteca para controlar LCD I2C