Contenidos uso exclusivo de Arduino uno cansamientos básicos
Objetivo: Diseñar un sistema de control de acceso automatizado que funcione con
detección de movimiento, apertura de una puerta mediante un servomotor, y
activación de un dispositivo secundario a través de un relé, todo controlado por un
Arduino Uno.
Contexto
Descripción del proyecto:
El sensor PIR detecta movimiento en un área específica.
Si detecta una persona, Arduino acciona un servomotor que simula la
apertura de una puerta.
Al mismo tiempo, Arduino activa un relé, que podría encender una luz de
aviso o una alarma simple para indicar que alguien ha ingresado.
Después de unos segundos, el servomotor regresa a su posición inicial,
cerrando la puerta.
Por favor esto debe realizar la programación y la simulación por favor no la
implementación
MODULO DE RELÉ
Es un dispositivo electromagnético que funciona como un interruptor controlado por
un circuito eléctrico en el que, por medio de una bobina y un electroimán, se acciona
un juego de uno o varios contactos que permiten abrir o cerrar otros circuitos
eléctricos independientes.
El relé es capaz de controlar cargas de alta corriente y voltaje, lo que lo hace
especialmente útil en aplicaciones donde se necesita controlar dispositivos eléctricos
de potencia como motores, bombas y luces, entre otros.
¿Cómo conectar y programar su relé?
Ahora que sabes cómo funciona un relé y cuáles son los diferentes tipos de relés,
pasemos a aprender cómo conectar y programar un relé con un Arduino.
1
Contenidos uso exclusivo de Arduino uno cansamientos básicos
Después de conectar el hardware como se describe, necesitas escribir un código simple
que establece el pin 7 como un pin de salida y envía una señal para encender y apagar
la bombilla a través del módulo de relé. Así es como puedes escribir el código para el
circuito que se muestra en la imagen de arriba.
void setup() {
// initialize the digital pin as an output.
pinMode(7, OUTPUT);
}
void loop() {
digitalWrite(7, HIGH); // turn the BULB on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(7, LOW); // turn the BULB off by making the voltage LOW
delay(1000); // wait for a second
}
SENSOR PIR
os sensores infrarrojos pasivos (PIR) son dispositivos para la detección de movimiento.
Son baratos, pequeños, de baja potencia, y fáciles de usar. Por esta razón son
frecuentemente usados en juguetes, aplicaciones domóticas o sistemas de seguridad.
Los sensores PIR se basan en la medición de la radiación infrarroja. Todos los cuerpos
(vivos o no) emiten una cierta cantidad de energía infrarroja, mayor cuanto mayor es
su temperatura. Los dispositivos PIR disponen de un sensor piro eléctrico capaz de
captar esta radiación y convertirla en una señal eléctrica.
Primero vamos a explicar el principio de funcionamiento. El módulo en realidad consta
de un sensor piroeléctrico que genera energía cuando se expone al calor.
2
Contenidos uso exclusivo de Arduino uno cansamientos básicos
Eso significa que cuando un cuerpo humano o animal entre en el rango del sensor,
detectará un movimiento porque el cuerpo humano o animal emite energía térmica en
forma de radiación infrarroja. De ahí viene el nombre del sensor, un sensor infrarrojo
pasivo. Y el término "pasivo" significa que el sensor no usa energía para detectar, solo
funciona al detectar la energía emitida por los otros objetos.
El módulo también consta de una cubierta especialmente diseñada llamada lente
Fresnel, que enfoca las señales infrarrojas en el sensor piroeléctrico.
3
Contenidos uso exclusivo de Arduino uno cansamientos básicos
El módulo dedigitalWrite(LEDPin, LOW);
}
}
Si quisiéramos ejecutar una acción una única vez al detectar movimiento, en lugar de todo el
tiempo que la señal este activa, usaríamos el siguiente código.
const int LEDPin = 13; // pin para el LED
const int PIRPin = 2; // pin de entrada (for PIR sensor)
int pirState = LOW; // de inicio no hay movimiento
int val = 0; // estado del pin
void setup()
{
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
Serial.begin(9600);
}
void loop()
{
val = digitalRead(PIRPin);
if (val == HIGH) //si está activado
4
Contenidos uso exclusivo de Arduino uno cansamientos básicos
{
digitalWrite(LEDPin, HIGH); //LED ON
if (pirState == LOW) //si previamente estaba apagado
{
Serial.println("Sensor activado");
pirState = HIGH;
}
}
else //si esta desactivado
{
digitalWrite(LEDPin, LOW); // LED OFF
if (pirState == HIGH) //si previamente estaba encendido
{
Serial.println("Sensor parado");
pirState = LOW;
}
}
}
El servo motor
El código necesario para realizar la lectura es simple. Simplemente leemos la salida del
PIR, y hacemos parpadear el LED mientras la señal esté activa.
const int LEDPin= 13;
const int PIRPin= 2;
void setup()
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
5
Contenidos uso exclusivo de Arduino uno cansamientos básicos
void loop()
int value= digitalRead(PIRPin);
if (value == HIGH)
digitalWrite(LEDPin, HIGH);
delay(50);
digitalWrite(LEDPin, LOW);
delay(50);
else
digitalWrite(LEDPin, LOW);
Servo motores
Un servomotor es un dispositivo que controla con precisión la posición, velocidad y
aceleración de un mecanismo. Se usa en muchas aplicaciones industriales y
comerciales, como la robótica, la aeroespacial y el modelismo.
Un servomotor es un motor eléctrico que hace accionar partes de una maquina con
alta eficiencia y precisión. El servomotor trabaja junto con un sensor, también llamado
encoder, que lo retroalimenta, es decir que le manda constantemente una señal de
velocidad y posición exacta al servo.
Un servomotor es un dispositivo alimentado por corriente continua que puede
controlar de modo muy exacto la posición (de 0º a 180º) o la velocidad (en
revoluciones por minuto, rpm, en sentido horario o antihorario). Tienen 3 pines para su
conexión: alimentación (5 V, normalmente), tierra (GND) y el pin de la seña
El código para girar el motor de 0º a 180º
6
Contenidos uso exclusivo de Arduino uno cansamientos básicos
Esta acción ya nos ha hecho un include en nuestro código que nos permite controlar el
servo. Os dejo a continuación un código básico para posicionar el servo en los
ángulos 0º, 90º y 180º
// Incluímos la librería para poder controlar el servo
#include <Servo.h>
// Declaramos la variable para controlar el servo
Servo servoMotor;
void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);
// Iniciamos el servo para que empiece a trabajar con el pin 9
servoMotor.attach(9);
void loop() {
// Desplazamos a la posición 0º
servoMotor.write(0);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 90º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);
7
Contenidos uso exclusivo de Arduino uno cansamientos básicos
// Desplazamos a la posición 180º
servoMotor.write(180);
// Esperamos 1 segundo
delay(1000);
De la librería Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso
de dos métodos. Por un lado el attach, que nos permite indicar en que pin tenemos
conectado nuestro servo, y por otro lado el write, donde indicamos en qué ángulo
queremos posicionar nuestro servomotor.
Girando grado a grado el servomotor
Vamos a realizar otro ejemplo un poco más complicado, en este caso queremos que el
servo haga un barrido desde el 0 al 180º y luego en sentido contrario. Vamos a utilizar
los mismos métodos pero incorporamos dos bucles for, uno para cada sentido.
1 /*
2 Creado: Luis del Valle (ldelvalleh@programarfacil.com)
3 https://programarfacil.com
4 */
6 // Incluímos la librería para poder controlar el servo
7 #include <Servo.h>
9 // Declaramos la variable para controlar el servo
10Servo servoMotor;
11
12void setup() {
13 // Iniciamos el monitor serie para mostrar el resultado
14 Serial.begin(9600);
15
8
Contenidos uso exclusivo de Arduino uno cansamientos básicos
16 // Iniciamos el servo para que empiece a trabajar con el pin 9
17 servoMotor.attach(9);
18
19 // Inicializamos al ángulo 0 el servomotor
20 servoMotor.write(0);
21}
22
23void loop() {
24
25 // Vamos a tener dos bucles uno para mover en sentido positivo y otro en sentido
negativo
26
// Para el sentido positivo
27
for (int i = 0; i <= 180; i++)
28
{
29
// Desplazamos al ángulo correspondiente
30
servoMotor.write(i);
31
// Hacemos una pausa de 25ms
32
delay(25);
33
}
34
35
// Para el sentido negativo
36
for (int i = 179; i > 0; i--)
37
{
38
// Desplazamos al ángulo correspondiente
39
servoMotor.write(i);
40
// Hacemos una pausa de 25ms
41
delay(25);
42
}
43
9
Contenidos uso exclusivo de Arduino uno cansamientos básicos
10
