“Universidad Nacional de San Agustín de Arequipa”
Escuela profesional: Electrónica
Facultad: Ingeniería de procesos y servicios
Curso: Programación 2
Docente: Dr. Echaiz Espinoza German Alberto
Integrantes: CUI:
Limache Mamani José Luis 20240381
Coaguila Rengifo Cesar Miguel 20240382
1. Fundamento teórico
Arduino: • Es una plataforma de hardware de código abierto basada en microcontroladores y software
que facilita la creación de dispositivos electrónicos interactivos. Utiliza un entorno de desarrollo
integrado (IDE) para escribir y cargar programas (sketches) a la placa Arduino.
Wokwi: • Es una plataforma en línea que ofrece simulaciones de proyectos Arduino y otras placas de
desarrollo en tiempo real. Permite a los desarrolladores probar y depurar código antes de
implementarlo físicamente en hardware, además de facilitar la creación de proyectos educativos y de
prototipado rápido.
Proteus: Es un software de simulación de circuitos electrónicos que permite diseñar, probar y depurar
circuitos antes de construirlos físicamente. Es ampliamente utilizado en la industria y la educación
para el diseño electrónico y la verificación de funcionalidad de
El Arduino Uno es una placa de desarrollo basada en el microcontrolador ATmega328P, que
permite la creación de prototipos electrónicos. Esta plataforma es ampliamente utilizada en
proyectos de automatización, robótica, y domótica debido a su simplicidad y flexibilidad. El Arduino
Uno cuenta con 14 pines de entrada/salida digitales, 6 entradas analógicas, y una interfaz USB para
la comunicación y programación. Su facilidad de uso permite conectar diversos sensores y
actuadores, permitiendo el control y procesamiento de datos de manera eficiente.
Un motor de corriente continua (DC) convierte la energía eléctrica en movimiento rotatorio. Este
tipo de motor es común en aplicaciones que requieren movimiento de rotación continua, como
ventiladores, ruedas de robots, y otros sistemas motorizados. La velocidad de un motor DC puede
controlarse variando el voltaje de entrada, mientras que el cambio de polaridad permite invertir el
sentido de giro. En este proyecto, el motor DC está controlado por un driver L298, que permite
ajustar su velocidad y dirección en función de la temperatura.
El driver L298 es un módulo que permite controlar la velocidad y el sentido de giro de motores DC y
motores paso a paso, actuando como una interfaz entre el microcontrolador y el motor. Es capaz de
manejar corrientes de hasta 2A por canal, lo cual lo hace adecuado para aplicaciones de potencia
media. El L298 incluye dos puentes H, que facilitan el control bidireccional del motor. En este
proyecto, el driver permite variar la velocidad y dirección del motor DC según los valores de
temperatura.
Un servomotor es un tipo de motor que permite controlar el ángulo de giro de su eje de forma
precisa. Los servomotores son comunes en aplicaciones que requieren movimientos específicos,
como en la robótica, el control de brazos mecánicos, o la dirección de vehículos autónomos. En este
proyecto, el servomotor ajusta su ángulo en función de la humedad, donde una humedad baja
posiciona el servomotor en 0° y una humedad alta lo mueve hacia 180°, proporcionando así un
control dinámico basado en las condiciones ambientales.
El sensor DHT11 es un dispositivo de bajo costo que mide la temperatura y la humedad relativa del
ambiente. Este sensor es adecuado para aplicaciones de monitoreo ambiental en interiores, ya que
tiene un rango de medición de temperatura de 0°C a 50°C y un rango de humedad de 20% a 90%. La
precisión del sensor permite obtener datos fiables, lo cual es esencial para el control de sistemas
basados en condiciones ambientales, como en este proyecto, donde la temperatura y la humedad
son parámetros clave para el control de motores.
Una pantalla LCD 16x4 permite mostrar información en 4 líneas de 16 caracteres cada una. Esta
pantalla, conectada a través de una interfaz I2C, facilita la comunicación con el Arduino usando solo
dos pines, simplificando el cableado. La LCD es utilizada en este proyecto para mostrar los datos de
temperatura, humedad, hora y fecha, proporcionando una visualización en tiempo real de las
condiciones ambientales y el estado de los actuadores.
Una tarjeta SD es un dispositivo de almacenamiento que permite guardar grandes cantidades de
datos en un formato compacto. En aplicaciones de Arduino, una tarjeta SD es útil para el registro de
datos (data logging), permitiendo almacenar información de sensores y parámetros de
funcionamiento. Este tipo de almacenamiento es ideal para proyectos que requieren la supervisión
y análisis de datos a largo plazo, como el monitoreo de temperatura y humedad en este caso.
El RTC DS1307 es un reloj en tiempo real que permite mantener la hora y la fecha precisas, incluso
cuando el Arduino se apaga, gracias a su batería interna. Este módulo es especialmente útil en
proyectos de automatización que requieren conocer la hora exacta. En este proyecto, el RTC
proporciona la hora y fecha para mostrar en la pantalla LCD, y también podría usarse para
programar acciones en horarios específicos.
1. Arduino código
CODIGO PROTEUS (LIMACHE)
Código (a):
#include <DHT.h>
#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
#include <SD.h>
#define DHTPIN 2
#define DHTTYPE DHT11
#define MOTOR_IN1 3
#define MOTOR_IN2 4
#define MOTOR_ENA 5
#define SERVO_PIN 6
#define SD_CS 10
DHT dht(DHTPIN, DHTTYPE);
RTC_DS1307 rtc;
LiquidCrystal_I2C lcd(0x27, 16, 4);
Servo servo;
File dataFile;
void setup() {
[Link](9600);
// Inicializar DHT11
[Link]();
// Inicializar RTC DS1307
if (![Link]()) {
[Link]("No se encuentra el RTC");
[Link](0, 0);
[Link]("RTC No Encontrado");
while (1); // Detener ejecución si no se encuentra el RTC
}
if (![Link]()) {
[Link]("RTC no está en hora, configurando a la hora de compilación.");
[Link](DateTime(F(__DATE__), F(__TIME__)));
}
// Inicializar pantalla LCD
[Link](16, 4);
[Link]();
[Link]();
// Mensaje de inicio en pantalla y serial
[Link](0, 0);
[Link]("Iniciando...");
[Link]("Iniciando...");
// Inicializar Servo
[Link](SERVO_PIN);
// Inicializar Motor Driver
pinMode(MOTOR_IN1, OUTPUT);
pinMode(MOTOR_IN2, OUTPUT);
pinMode(MOTOR_ENA, OUTPUT);
// Inicializar tarjeta SD
if () {
[Link]("Error al inicializar la SD");
[Link]();
[Link](0, 0);
[Link]("Error en SD");
delay(2000); // Mostrar el error en pantalla por 2 segundos
} else {
[Link]("SD inicializada correctamente");
[Link]();
[Link](0, 0);
[Link]("SD OK");
delay(2000); // Mostrar éxito en pantalla por 2 segundos
}
[Link](); // Limpiar pantalla después del mensaje inicial
}
void loop() {
// Leer datos del sensor
float temperatura = [Link]();
float humedad = [Link]();
// Verificar si la lectura es válida
if (isnan(temperatura) || isnan(humedad)) {
[Link]("Error al leer DHT11");
[Link](0, 0);
[Link]("Error en DHT11");
delay(2000);
return; // Volver al inicio del loop
}
// Obtener la hora y fecha actual del RTC
DateTime now = [Link]();
int hora = [Link]();
int minuto = [Link]();
int segundo = [Link]();
int dia = [Link]();
int mes = [Link]();
int anio = [Link]();
// Control del motor DC según la temperatura
int velocidadMotor = 0;
if (temperatura < 10) {
velocidadMotor = -100;
} else if (temperatura < 20) {
velocidadMotor = -50;
} else if (temperatura < 25) {
velocidadMotor = 0;
} else if (temperatura < 30) {
velocidadMotor = 50;
} else {
velocidadMotor = 100;
}
// Configuración del giro y velocidad del motor
if (velocidadMotor < 0) {
digitalWrite(MOTOR_IN1, LOW);
digitalWrite(MOTOR_IN2, HIGH);
analogWrite(MOTOR_ENA, abs(velocidadMotor) * 2.55); // 0-255
} else if (velocidadMotor > 0) {
digitalWrite(MOTOR_IN1, HIGH);
digitalWrite(MOTOR_IN2, LOW);
analogWrite(MOTOR_ENA, velocidadMotor * 2.55); // 0-255
} else {
digitalWrite(MOTOR_IN1, LOW);
digitalWrite(MOTOR_IN2, LOW);
}
// Control del servomotor según la humedad
int anguloServo = map(humedad, 0, 100, 0, 180);
[Link](anguloServo);
// Mostrar datos en la pantalla LCD
[Link]();
[Link](0, 0);
[Link]("Tem=");
[Link]((int)temperatura);
[Link]("C M=");
[Link](velocidadMotor);
[Link](0, 1);
[Link]("Hum=");
[Link]((int)humedad);
[Link]("% S=");
[Link](anguloServo);
[Link](0, 2);
[Link]("H=");
if (hora < 10) [Link]("0");
[Link](hora);
[Link](":");
if (minuto < 10) [Link]("0");
[Link](minuto);
[Link](":");
if (segundo < 10) [Link]("0");
[Link](segundo);
[Link](0, 3);
[Link]("F=");
if (dia < 10) [Link]("0");
[Link](dia);
[Link]("/");
if (mes < 10) [Link]("0");
[Link](mes);
[Link]("/");
[Link](anio);
// Almacenar datos en la tarjeta SD
if ([Link](SD_CS)) {
dataFile = [Link]("[Link]", FILE_WRITE);
if (dataFile) {
[Link](dia);
[Link]("/");
[Link](mes);
[Link]("/");
[Link](anio);
[Link](", ");
[Link](hora);
[Link](":");
[Link](minuto);
[Link](":");
[Link](segundo);
[Link](", ");
[Link]((int)temperatura);
[Link](", ");
[Link](velocidadMotor);
[Link](", ");
[Link]((int)humedad);
[Link](", ");
[Link](anguloServo);
[Link]();
[Link]("Datos guardados en SD");
} else {
[Link]("Error al abrir archivo en SD");
[Link](0, 0);
[Link]("Error archivo SD");
delay(2000);
}
} else {
[Link]("Error en SD");
[Link](0, 0);
[Link]("SD no encontrada");
delay(2000);
}
// Esperar 10 segundos antes de la próxima iteración
delay(10000);
}
Código (b):
#include <DHT.h>
#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
#include <SD.h>
#define DHTPIN 2
#define DHTTYPE DHT11
#define MOTOR_IN1 3
#define MOTOR_IN2 4
#define MOTOR_ENA 5
#define SERVO_PIN 6
#define SD_CS 10
DHT dht(DHTPIN, DHTTYPE);
RTC_DS1307 rtc;
LiquidCrystal_I2C lcd(0x27, 16, 4);
Servo servo;
File dataFile;
void setup() {
[Link](9600);
// Inicializar DHT11
[Link]();
// Inicializar RTC DS1307
if (![Link]()) {
[Link]("No se encuentra el RTC");
[Link](0, 0);
[Link]("RTC No Encontrado");
while (1); // Detener ejecución si no se encuentra el RTC
}
if (![Link]()) {
[Link]("RTC no está en hora, configurando a la hora de compilación.");
[Link](DateTime(F(__DATE__), F(__TIME__)));
}
// Inicializar pantalla LCD
[Link](16, 4);
[Link]();
[Link]();
// Mensaje de inicio en pantalla y serial
[Link](0, 0);
[Link]("Iniciando...");
[Link]("Iniciando...");
// Inicializar Servo
[Link](SERVO_PIN);
// Inicializar Motor Driver
pinMode(MOTOR_IN1, OUTPUT);
pinMode(MOTOR_IN2, OUTPUT);
pinMode(MOTOR_ENA, OUTPUT);
// Inicializar tarjeta SD
if () {
[Link]("Error al inicializar la SD");
[Link]();
[Link](0, 0);
[Link]("Error en SD");
delay(2000); // Mostrar el error en pantalla por 2 segundos
} else {
[Link]("SD inicializada correctamente");
[Link]();
[Link](0, 0);
[Link]("SD OK");
delay(2000); // Mostrar éxito en pantalla por 2 segundos
}
[Link](); // Limpiar pantalla después del mensaje inicial
}
void loop() {
// Leer datos del sensor
float temperatura = [Link]();
float humedad = [Link]();
// Verificar si la lectura es válida
if (isnan(temperatura) || isnan(humedad)) {
[Link]("Error al leer DHT11");
[Link](0, 0);
[Link]("Error en DHT11");
delay(2000);
return; // Volver al inicio del loop
}
// Obtener la hora y fecha actual del RTC
DateTime now = [Link]();
int hora = [Link]();
int minuto = [Link]();
int segundo = [Link]();
int dia = [Link]();
int mes = [Link]();
int anio = [Link]();
// Control del motor DC según la temperatura
int velocidadMotor = 0;
if (temperatura < 10) {
velocidadMotor = -100;
} else if (temperatura < 20) {
velocidadMotor = -50;
} else if (temperatura < 25) {
velocidadMotor = 0;
} else if (temperatura < 30) {
velocidadMotor = 50;
} else {
velocidadMotor = 100;
}
// Configuración del giro y velocidad del motor
if (velocidadMotor < 0) {
digitalWrite(MOTOR_IN1, LOW);
digitalWrite(MOTOR_IN2, HIGH);
analogWrite(MOTOR_ENA, abs(velocidadMotor) * 2.55); // 0-255
} else if (velocidadMotor > 0) {
digitalWrite(MOTOR_IN1, HIGH);
digitalWrite(MOTOR_IN2, LOW);
analogWrite(MOTOR_ENA, velocidadMotor * 2.55); // 0-255
} else {
digitalWrite(MOTOR_IN1, LOW);
digitalWrite(MOTOR_IN2, LOW);
}
// Control del servomotor según la humedad
if (humedad < 30) {
[Link](90); // Colocar servo en 90° si la humedad es menor a 30%
} else if (humedad > 32) {
[Link](0); // Colocar servo en 0° si la humedad es mayor a 32%
}
// Mostrar datos en la pantalla LCD
[Link]();
[Link](0, 0);
[Link]("Tem=");
[Link]((int)temperatura);
[Link]("C M=");
[Link](velocidadMotor);
[Link](0, 1);
[Link]("Hum=");
[Link]((int)humedad);
[Link]("% S=");
[Link](humedad < 30 ? 90 : (humedad > 32 ? 0 : 90)); // Mostrar el ángulo
actual del servo
[Link](0, 2);
[Link]("H=");
if (hora < 10) [Link]("0");
[Link](hora);
[Link](":");
if (minuto < 10) [Link]("0");
[Link](minuto);
[Link](":");
if (segundo < 10) [Link]("0");
[Link](segundo);
[Link](0, 3);
[Link]("F=");
if (dia < 10) [Link]("0");
[Link](dia);
[Link]("/");
if (mes < 10) [Link]("0");
[Link](mes);
[Link]("/");
[Link](anio);
// Almacenar datos en la tarjeta SD
if ([Link](SD_CS)) {
dataFile = [Link]("[Link]", FILE_WRITE);
if (dataFile) {
[Link](dia);
[Link]("/");
[Link](mes);
[Link]("/");
[Link](anio);
[Link](", ");
[Link](hora);
[Link](":");
[Link](minuto);
[Link](":");
[Link](segundo);
[Link](", ");
[Link]((int)temperatura);
[Link](", ");
[Link](velocidadMotor);
[Link](", ");
[Link]((int)humedad);
[Link](", ");
[Link](humedad < 30 ? 90 : (humedad > 32 ? 0 : 90)); // Guardar el
ángulo actual del servo
[Link]();
[Link]("Datos guardados en SD");
} else {
[Link]("Error al abrir archivo en SD");
[Link](0, 0);
[Link]("Error archivo SD");
delay(2000);
}
} else {
[Link]("Error en SD");
[Link](0, 0);
[Link]("SD no encontrada");
delay(2000);
}
// Esperar 10 segundos antes de la próxima iteración
delay(10000);
}
CODIGO WOWKI (COAGUILA)
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <RTClib.h>
#include <DHT.h>
#include <Servo.h>
// Pines del Proyecto
#define DHTPIN 2
#define DHTTYPE DHT22
#define SERVO_PIN 9
#define STEP_PIN 6
#define DIR_PIN 7
// Inicialización de objetos
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2);
RTC_DS1307 rtc;
Servo servoMotor;
// Variables
int pasosPorRevolucion = 200; // Pasos completos del motor paso a paso
void setup() {
[Link](9600);
// Inicialización de componentes
[Link]();
[Link]();
[Link]();
if (![Link]()) {
[Link]("No se pudo encontrar el RTC");
while (1);
}
if (![Link]()) {
[Link](DateTime(F(__DATE__), F(__TIME__))); // Configura la hora actual
}
[Link](SERVO_PIN);
pinMode(STEP_PIN, OUTPUT);
pinMode(DIR_PIN, OUTPUT);
}
void moverMotorPasoAPaso(int velocidad, int pasos) {
// Dirección del motor
if (velocidad >= 0) {
digitalWrite(DIR_PIN, HIGH); // Sentido horario
} else {
digitalWrite(DIR_PIN, LOW); // Sentido antihorario
}
// Movimiento del motor
for (int i = 0; i < abs(pasos); i++) {
digitalWrite(STEP_PIN, HIGH);
delayMicroseconds(1000); // Ajusta este valor para cambiar la velocidad
digitalWrite(STEP_PIN, LOW);
delayMicroseconds(1000);
}
}
void loop() {
// Leer datos del RTC
DateTime now = [Link]();
int hora = [Link]();
int minuto = [Link]();
int segundo = [Link]();
int dia = [Link]();
int mes = [Link]();
int anio = [Link]();
// Leer datos del sensor DHT22
float temperatura = [Link]();
float humedad = [Link]();
if (isnan(temperatura) || isnan(humedad)) {
[Link]("Error leyendo el sensor DHT22");
return;
}
// Control del motor paso a paso según temperatura
int velocidadMotor = 0;
int pasosMotor = 0;
if (temperatura < 10) {
velocidadMotor = -100;
pasosMotor = 200; // Una vuelta completa hacia atrás
} else if (temperatura < 20) {
velocidadMotor = -50;
pasosMotor = 100; // Media vuelta hacia atrás
} else if (temperatura < 25) {
velocidadMotor = 0;
pasosMotor = 0; // Motor detenido
} else if (temperatura < 30) {
velocidadMotor = 50;
pasosMotor = 100; // Media vuelta hacia adelante
} else {
velocidadMotor = 100;
pasosMotor = 200; // Una vuelta completa hacia adelante
}
moverMotorPasoAPaso(velocidadMotor, pasosMotor);
// Control del servomotor según humedad y hora
int anguloServo;
if (hora >= 6 && hora < 18) { // De 6:00 a 18:00
anguloServo = map(humedad, 0, 100, 0, 90); // Rango para el día
} else {
anguloServo = map(humedad, 0, 100, 90, 180); // Rango para la noche
}
[Link](anguloServo);
// Mostrar hora, fecha, temperatura y humedad en LCD
[Link]();
[Link](0, 0);
[Link]("Hora: ");
[Link](hora < 10 ? "0" : ""); [Link](hora);
[Link](":");
[Link](minuto < 10 ? "0" : ""); [Link](minuto);
[Link](0, 1);
[Link]("Temp=");
[Link](temperatura);
[Link]("C ");
[Link]("Hum=");
[Link](humedad);
[Link]("%");
delay(10000); // Esperar 10 segundos antes de la siguiente lectura
}
SIMULACION PROTEUS (LIMACHE)
Simulación (a):
Simulación (b):
SIMULACION WOWKI (COAGUILA)
CONCLUSION
La implementación y simulación del sistema de control ambiental en Wokwi y Proteus permitió
verificar el correcto funcionamiento de los diferentes componentes integrados, tales como el sensor
DHT11, el módulo RTC DS1307, el servomotor, el motor DC controlado con el driver L298, la
pantalla LCD y la tarjeta SD para el almacenamiento de datos. La simulación evidenció que el
sistema es capaz de leer la temperatura y humedad del ambiente, ajustar el ángulo del servomotor y la
velocidad del motor DC según los valores programados, y mostrar la información en la pantalla LCD
de manera efectiva. Además, la estructura de registro en la tarjeta SD garantiza un almacenamiento
organizado de los datos en intervalos regulares, permitiendo su análisis posterior.
El uso de simuladores como Wokwi y Proteus facilitó la verificación de la lógica y la interacción de
los componentes sin necesidad de armar físicamente el circuito, lo cual ahorra tiempo y recursos en la
fase de desarrollo. No obstante, se debe considerar que las simulaciones pueden no representar
completamente el comportamiento en un entorno físico debido a limitaciones en la representación de
algunos elementos del sistema. Por ello, una vez validado en simulación, sería ideal realizar pruebas
en un montaje físico para asegurar la robustez y precisión del sistema en condiciones reales.
En conclusión, este proyecto demuestra la utilidad de los simuladores en el desarrollo de sistemas de
monitoreo y control ambiental basados en Arduino, así como la importancia de integrar diferentes
dispositivos para crear una solución completa y funcional.
