Arduino-en-30-Dias-De-Principiante-a-Smart-Home-PARTE 1.pdf

control de smart y luces led a nivel prodesional y base de datos unica

1. Añděu±¿ e± 30 Dwaÿ: De Pñu±cuéua±če a
S«añč H¿«e
E«báñcače e± ě± ļuaŠe eŊčña¿ñdu±añu¿ de 30 dwaÿ d¿±de čña±ÿf¿ñ«añáÿ de ě± c¿«éšeč¿ éñu±cuéua±če e±
Añděu±¿ a ě± cñead¿ñ de ÿuÿče«aÿ d¿«Àčuc¿ÿ u±češuge±čeÿ. Eÿče cěñÿ¿ u±če±ÿuļ¿ če ššeļañá éaÿ¿ a éaÿ¿
deÿde e±ce±deñ čě éñu«eñ LED haÿča c¿±ÿčñěuñ ě± ÿuÿče«a c¿«éšeč¿ de S«añč H¿«e.

2. Dwa 1: Bue±ļe±ud¿ aš Mě±d¿ de Añděu±¿
¿Qěé eÿ Añděu±¿?
Añděu±¿ eÿ ě±a éšačaf¿ñ«a de deÿaññ¿šš¿ de hañdŁañe ō
ÿ¿fčŁañe šubñe ïěe éeñ«uče cñeañ éñ¿ōecč¿ÿ ešecčñÀ±uc¿ÿ
u±čeñacčuļ¿ÿ de «a±eña ÿe±cušša. C¿± ě±a éšaca
«ucñ¿c¿±čñ¿šad¿ña ō ě± e±č¿ñ±¿ de éñ¿gña«acuÀ± u±čěučuļ¿,
Añděu±¿ de«¿cñačuśa ša ešecčñÀ±uca éaña č¿d¿ÿ.
¿Qěé éěedeÿ š¿gñañ?
Suÿče«aÿ de aěč¿«ačuśacuÀ± deš h¿gañ
R¿b¿čÿ ō ļehwcěš¿ÿ aěčÀ±¿«¿ÿ
Eÿčacu¿±eÿ «eče¿ñ¿šÀgucaÿ
Suÿče«aÿ de ÿegěñudad
Añče u±čeñacčuļ¿ ō Łeañabšeÿ
¡Tu aventura comienza aquí!
E± ÿ¿š¿ 30 dwaÿ, éaÿañáÿ de ša
cěñu¿ÿudad a ša cñeacuÀ± de
éñ¿ōecč¿ÿ ñeašeÿ ïěe
u«éacčañá± čě ļuda duañua.

3. Dwa 2: I±ÿčašacuÀ± deš E±č¿ñ±¿ de Añděu±¿
01
Deÿcañga eš IDE
Vuÿuča añděu±¿.cc ō deÿcañga eš Añděu±¿ IDE éaña čě
ÿuÿče«a ¿éeñačuļ¿. Eÿ c¿«éšeča«e±če gñačěuč¿ ō
c¿«éačubše c¿± Wu±d¿Łÿ, Mac ō Lu±ěŊ.
02
I±ÿčaša š¿ÿ dñuļeñÿ
C¿±ecča čě éšaca Añděu±¿ aš c¿«éěčad¿ñ. Eš
ÿuÿče«a debeñwa ñec¿±¿ceñša aěč¿«áčuca«e±če,
éeñ¿ ašgě±¿ÿ «¿deš¿ÿ ñeïěueñe± dñuļeñÿ
eÿéecwfuc¿ÿ.
03
C¿±fugěña eš e±č¿ñ±¿
Sešeccu¿±a čě «¿deš¿ de éšaca e± Heñña«ue±čaÿ >
Pšaca ō ešuge eš éěeñč¿ c¿ññecč¿ e± Heñña«ue±čaÿ >
Pěeñč¿.
04
Pñěeba ša c¿±eŊuÀ±
Cañga eš eŠe«éš¿ "Bšu±‘" éaña ļeñufucañ ïěe č¿d¿
fě±cu¿±a c¿ññecča«e±če. ¡Tě éñu«eñ éaÿ¿ hacua ša
éñ¿gña«acuÀ±!

4. Dwa 3: Tě Pñu«eñ 'H¿ša Mě±d¿' c¿± ě±
LED
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
Eš cÀdug¿ báÿuc¿
Eÿče ÿu«éše cÀdug¿ hace éañéadeañ eš LED
u±čegñad¿ cada ÿegě±d¿. Eÿ čě éñu«eñ éñ¿gña«a
fě±cu¿±aš e± Añděu±¿.
¿Qěé eÿčá éaÿa±d¿?
setup(): Se eŠecěča ě±a ÿ¿ša ļeś aš u±ucu¿
loop(): Se ñeéuče u±fu±uča«e±če
pinMode(): C¿±fugěña eš éu± c¿«¿ ÿašuda
digitalWrite(): E±cue±de ¿ aéaga eš LED

5. Día 4: Variables y
Modificaciones
Variables Básicas
Las variables almacenan datos que pueden cambiar durante
la ejecución del programa. En Arduino usamos int para
números enteros, float para decimales y boolean para
verdadero/falso.
Modificando el Parpadeo
Cambia la velocidad del LED usando una variable para el
delay. Experimenta con diferentes valores y observa cómo
afecta el comportamiento.
Patrones Creativos
Crea secuencias de parpadeo únicas combinando diferentes
tiempos de encendido y apagado. ¡Tu creatividad es el
límite!
int delayTime = 500; // Variable para controlar velocidad
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(delayTime);
digitalWrite(13, LOW);
delay(delayTime);
}

6. Dwa 5: E±čñadaÿ ō Sašudaÿ
Se±ÿ¿ñeÿ (E±čñadaÿ)
L¿ÿ ÿe±ÿ¿ñeÿ caéčěña± u±f¿ñ«acuÀ± deš «ě±d¿
ñeaš ō ša c¿±ļueñče± e± ÿe½ašeÿ ešécčñucaÿ ïěe
Añděu±¿ éěede u±čeñéñečañ.
Se±ÿ¿ñeÿ de šěś (LDR)
Se±ÿ¿ñeÿ de če«éeñačěña
Se±ÿ¿ñeÿ de «¿ļu«ue±č¿ (PIR)
B¿č¿±eÿ ō ÿŁučcheÿ
Acčěad¿ñeÿ (Sašudaÿ)
L¿ÿ acčěad¿ñeÿ ñecube± c¿«a±d¿ÿ de Añděu±¿ ō
ñeašuśa± accu¿±eÿ fwÿucaÿ e± eš «ě±d¿ ñeaš.
LEDÿ ō éa±čaššaÿ
M¿č¿ñeÿ ō ÿeñļ¿ÿ
Běśśeñÿ ō aščaļ¿ceÿ
Rešéÿ éaña ešecčñ¿d¿«éÿčuc¿ÿ
Concepto clave: Añděu±¿ acčĜa c¿«¿ eš ceñebñ¿ ïěe éñ¿ceÿa u±f¿ñ«acuÀ± de š¿ÿ ÿe±ÿ¿ñeÿ ō
c¿±čñ¿ša š¿ÿ acčěad¿ñeÿ éaña cñeañ ÿuÿče«aÿ u±češuge±čeÿ.

7. Dwa 6: Se±ÿ¿ñ de Lěś (LDR)
Lěś I±če±ÿa
Eš LDR čue±e baŠa ñeÿuÿče±cua
cěa±d¿ haō «ěcha šěś,
éeñ«učue±d¿ ïěe éaÿe «áÿ
c¿ññue±če.
Añděu±¿ Lee
Eš «ucñ¿c¿±čñ¿šad¿ñ c¿±ļueñče
ša ÿe½aš a±ašÀguca e± ě± ļaš¿ñ
dugučaš e±čñe 0 ō 1023.
Lěś Te±ěe
C¿± é¿ca šěś, ša ñeÿuÿče±cua
aě«e±ča ō eš ļaš¿ñ šewd¿ é¿ñ
Añděu±¿ duÿ«u±ěōe.
int ldrPin = A0;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
ldrValue = analogRead(ldrPin);
Serial.println(ldrValue);
delay(500);
}

8. Día 7: Sensor de Temperatura
Sensor LM35
El LM35 es un sensor de temperatura
analógico preciso que proporciona
10mV por cada grado Celsius. Es ideal
para proyectos domóticos.
float tempPin = A1;
float tempValue = 0;
float temperature = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
tempValue = analogRead(tempPin);
temperature = (tempValue * 5.0 / 1024.0) * 100;
Serial.print("Temperatura: ");
Serial.print(temperature);
Serial.println(" °C");
delay(1000);
}
Conversión de Temperatura
La fórmula convierte el valor digital en grados Celsius reales
que puedes usar en tus proyectos.

9. Día 8: Sensor de Movimiento PIR
int pirPin = 2;
int ledPin = 13;
int pirState = LOW;
void setup() {
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
pirState = digitalRead(pirPin);
if (pirState == HIGH) {
digitalWrite(ledPin, HIGH);
Serial.println("¡Movimiento detectado!");
} else {
digitalWrite(ledPin, LOW);
}
delay(100);
}
Detección
El sensor PIR detecta
cambios en la radiación
infrarroja causados por el
movimiento de cuerpos
calientes.
Señal Digital
Cuando detecta movimiento,
el PIR envía una señal HIGH
(5V) al pin digital de Arduino.
Activación LED
Arduino procesa la señal y
enciende un LED como
respuesta al movimiento
detectado.

10. Dwa 9: C¿«bu±a±d¿ Se±ÿ¿ñeÿ
Lecčěña Su«ěščá±ea de MĜščuéšeÿ Se±ÿ¿ñeÿ
Te«éeñačěña
M¿±uč¿ñea
c¿±ÿča±če«e±če ša
če«éeñačěña a«bue±če
éaña ÿuÿče«aÿ de
cšu«ačuśacuÀ±
u±češuge±če.
Lě«u±¿ÿudad
Mude š¿ÿ ±uļešeÿ de šěś
éaña aěč¿«ačuśañ ša
ušě«u±acuÀ± ÿegĜ± šaÿ
c¿±ducu¿±eÿ
a«bue±čašeÿ.
M¿ļu«ue±č¿
Dečecča éñeÿe±cua
hě«a±a éaña acčuļañ
ÿuÿče«aÿ de ÿegěñudad ¿
ah¿ññ¿ e±eñgéčuc¿.
// Definición de pines
int tempPin = A0;
int ldrPin = A1;
int pirPin = 2;
void setup() {
Serial.begin(9600);
pinMode(pirPin, INPUT);
}
void loop() {
// Leer temperatura
float temp = (analogRead(tempPin) * 5.0 / 1024.0) * 100;

// Leer luz
int luz = analogRead(ldrPin);

// Leer movimiento
int movimiento = digitalRead(pirPin);

// Mostrar datos
Serial.print("Temp: "); Serial.print(temp); Serial.print("°C | ");
Serial.print("Luz: "); Serial.print(luz); Serial.print(" | ");
Serial.print("Movimiento: "); Serial.println(movimiento);

delay(1000);
}

11. Dwa 10: Mu±u Pñ¿ōecč¿ - Ašañ«a de
I±čñěÿ¿ÿ
C¿«é¿±e±čeÿ deš Suÿče«a
Sensor PIR: Dečecča «¿ļu«ue±č¿
Buzzer: E«uče ÿ¿±ud¿ de ašañ«a
LED: I±ducad¿ñ ļuÿěaš
Botón: Paña deÿañ«añ ša ašañ«a
Fě±cu¿±a«ue±č¿
Cěa±d¿ eš PIR dečecča «¿ļu«ue±č¿, ÿe acčuļa
ÿu«ěščá±ea«e±če eš běśśeñ ō eš LED. Eš ÿuÿče«a
éeñ«a±ece acčuļ¿ haÿča ïěe ÿe éñeÿu¿±a eš b¿čÀ±
de deÿacčuļacuÀ±.
int pirPin = 2;
int buzzerPin = 8;
int ledPin = 13;
int buttonPin = 3;
boolean alarmActive = false;
void setup() {
pinMode(pirPin, INPUT);
pinMode(buzzerPin, OUTPUT);
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
Serial.begin(9600);
}
void loop() {
if (digitalRead(pirPin) == HIGH && !alarmActive) {
alarmActive = true;
Serial.println("¡ALARMA ACTIVADA!");
}

if (alarmActive) {
digitalWrite(ledPin, HIGH);
tone(buzzerPin, 1000, 500);
delay(500);
noTone(buzzerPin);
delay(500);
}

if (digitalRead(buttonPin) == LOW) {
alarmActive = false;
digitalWrite(ledPin, LOW);
noTone(buzzerPin);
Serial.println("Alarma desactivada");
delay(1000);
}
}

12. Dwa 11: C¿±čñ¿š de LEDÿ RGB
int redPin = 9;
int greenPin = 10;
int bluePin = 11;
void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}
void loop() {
// Rojo
setColor(255, 0, 0);
delay(1000);

// Verde
setColor(0, 255, 0);
delay(1000);

// Azul
setColor(0, 0, 255);
delay(1000);

// Púrpura
setColor(255, 0, 255);
delay(1000);
}
void setColor(int red, int green, int blue) {
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
R¿Š¿
Pu± dugučaš c¿± PWM c¿±čñ¿ša
ša u±če±ÿudad deš c¿«é¿±e±če
ñ¿Š¿ deš LED RGB.
Veñde
M¿děšacuÀ± é¿ñ a±ch¿ de
éěšÿ¿ éeñ«uče cñeañ dufeñe±čeÿ
č¿±ašudadeÿ de ļeñde.
Aśěš
C¿«bu±a±d¿ š¿ÿ čñeÿ c¿š¿ñeÿ
éñu«añu¿ÿ éěedeÿ ge±eñañ
«ušš¿±eÿ de c¿š¿ñeÿ dufeñe±čeÿ.

13. Dwa 12: Señļ¿«¿č¿ñeÿ
C¿±čñ¿š Pñecuÿ¿ de P¿ÿucuÀ±
L¿ÿ ÿeñļ¿«¿č¿ñeÿ éeñ«uče± c¿±čñ¿šañ ša é¿ÿucuÀ± a±gěšañ
c¿± gña± éñecuÿuÀ±, deÿde 0° haÿča 180°. S¿± udeašeÿ éaña
éñ¿ōecč¿ÿ ïěe ñeïěueñe± «¿ļu«ue±č¿ c¿±čñ¿šad¿ c¿«¿
éěeñčaÿ aěč¿«áčucaÿ, bñaś¿ÿ ñ¿bÀčuc¿ÿ ¿ ÿuÿče«aÿ de
ÿegěu«ue±č¿.
Se½aš PWM
Eš ÿeñļ¿ ÿe c¿±čñ¿ša «edua±če éěšÿ¿ÿ PWM. U± éěšÿ¿ de 1«ÿ
c¿ññeÿ鿱de a 0°, 1.5«ÿ a 90° ō 2«ÿ a 180°. Añděu±¿
ÿu«éšufuca eÿč¿ c¿± ša šubñeñwa Señļ¿.
#include <Servo.h>
Servo miServo;
int pos = 0;
void setup() {
miServo.attach(9);
}
void loop() {
// Movimiento de 0 a 180 grados
for (pos = 0; pos <= 180; pos += 1) {
miServo.write(pos);
delay(15);
}

// Movimiento de 180 a 0 grados
for (pos = 180; pos >= 0; pos -= 1) {
miServo.write(pos);
delay(15);
}
}
180°
Ra±g¿ de M¿ļu«ue±č¿
R¿čacuÀ± «áŊu«a eÿčá±dañ
20«ÿ
Peñw¿d¿ de Pěšÿ¿
Fñecěe±cua de c¿±čñ¿š PWM
1-2«ÿ
A±ch¿ de Pěšÿ¿
Ra±g¿ éaña c¿±čñ¿š c¿«éšeč¿

14. Día 13: Motores DC
01
Driver L298N
Los motores DC requieren más
corriente de la que Arduino
puede suministrar. El driver
L298N actúa como amplificador
y permite control bidireccional.
02
Control de Velocidad
Usa PWM para controlar la
velocidad del motor. Valores de 0
a 255 en analogWrite()
determinan la velocidad de
rotación.
03
Control de Dirección
Dos pines digitales controlan la
dirección: HIGH-LOW para un
sentido, LOW-HIGH para el
opuesto.
int motor1Pin1 = 2;
int motor1Pin2 = 3;
int enablePin = 9;
void setup() {
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enablePin, OUTPUT);
}
void loop() {
// Girar en sentido horario
digitalWrite(motor1Pin1, HIGH);
digitalWrite(motor1Pin2, LOW);
analogWrite(enablePin, 200); // Velocidad alta
delay(2000);

// Parar
analogWrite(enablePin, 0);
delay(1000);

// Girar en sentido antihorario
digitalWrite(motor1Pin1, LOW);
digitalWrite(motor1Pin2, HIGH);
analogWrite(enablePin, 150); // Velocidad media
delay(2000);

// Parar
analogWrite(enablePin, 0);
delay(1000);
}

15. Dwa 14: Rešéÿ
¿Qěé eÿ ě± Rešé?
U± ñešé eÿ ě± u±čeññěéč¿ñ ešecčñ¿«ag±éčuc¿ ïěe
éeñ«uče a Añděu±¿ c¿±čñ¿šañ duÿé¿ÿučuļ¿ÿ de ašča
é¿če±cua c¿«¿ ešecčñ¿d¿«éÿčuc¿ÿ, šěceÿ de
110V/220V, ¿ «¿č¿ñeÿ u±děÿčñuašeÿ de f¿ñ«a
ÿegěña.
Segěñudad Ešécčñuca
¡PRECAUCIÓN! TñabaŠañ c¿± ļ¿ščaŠeÿ
ašč¿ÿ éěede ÿeñ éešugñ¿ÿ¿. Sue«éñe
deÿc¿±ecča ša ašu«e±čacuÀ± a±čeÿ de
haceñ c¿±eŊu¿±eÿ ō c¿±ÿudeña ěÿañ ě±
ešecčñucuÿča ceñčufucad¿.
Añděu±¿ (5V)
Se½aš de c¿±čñ¿š de baŠ¿
ļ¿ščaŠe deÿde eš
«ucñ¿c¿±čñ¿šad¿ñ.
Rešé
I±čeññěéč¿ñ ešecčñ¿«ag±éčuc¿
ïěe awÿša š¿ÿ cuñcěuč¿ÿ.
Ešecčñ¿d¿«éÿčuc¿
Duÿé¿ÿučuļ¿ de ašča é¿če±cua
c¿±čñ¿šad¿ de f¿ñ«a ÿegěña.
int relayPin = 7;
void setup() {
pinMode(relayPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
Serial.println("Encendiendo dispositivo...");
digitalWrite(relayPin, HIGH); // Activa el relé
delay(3000);

Serial.println("Apagando dispositivo...");
digitalWrite(relayPin, LOW); // Desactiva el relé
delay(3000);
}

16. Dwa 15: Mu±u Pñ¿ōecč¿ - Se«áf¿ñ¿
1Veñde - 5 ÿegě±d¿ÿ
L¿ÿ ļehwcěš¿ÿ éěede± aļa±śañ c¿±
ÿegěñudad. LED ļeñde e±ce±dud¿, ¿čñ¿ÿ
aéagad¿ÿ.
2 A«añušš¿ - 2 ÿegě±d¿ÿ
Adļeñče±cua de ca«bu¿ u±«u±e±če. L¿ÿ
c¿±děcč¿ñeÿ debe± éñeéañañÿe éaña
deče±eñÿe.3R¿Š¿ - 5 ÿegě±d¿ÿ
Ašč¿ č¿čaš. T¿d¿ÿ š¿ÿ ļehwcěš¿ÿ debe±
deče±eñÿe c¿«éšeča«e±če.
int redPin = 13;
int yellowPin = 12;
int greenPin = 11;
void setup() {
pinMode(redPin, OUTPUT);
pinMode(yellowPin, OUTPUT);
pinMode(greenPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
// Verde
Serial.println("VERDE - Avanzar");
digitalWrite(greenPin, HIGH);
digitalWrite(yellowPin, LOW);
digitalWrite(redPin, LOW);
delay(5000);

// Amarillo
Serial.println("AMARILLO - Precaución");
digitalWrite(greenPin, LOW);
digitalWrite(yellowPin, HIGH);
digitalWrite(redPin, LOW);
delay(2000);

// Rojo
Serial.println("ROJO - Alto");
digitalWrite(greenPin, LOW);
digitalWrite(yellowPin, LOW);
digitalWrite(redPin, HIGH);
delay(5000);
}

17. Dwa 16: Lěś Aěč¿«áčuca c¿± LDR
Suÿče«a I±češuge±če
Eÿče éñ¿ōecč¿ ÿu«ěša ě± ÿuÿče«a de
ušě«u±acuÀ± aěč¿«áčuca ïěe ÿe acčuļa
cěa±d¿ š¿ÿ ±uļešeÿ de šěś a«bue±čaš
duÿ«u±ěōe±, c¿«¿ šaÿ šěceÿ de Šañdw± ¿
éaÿušš¿ÿ.
LÀguca deš Suÿče«a
Lecčěña C¿±ču±ěa
Eš LDR «¿±uč¿ñea c¿±ÿča±če«e±če š¿ÿ ±uļešeÿ de šěś
a«bue±čaš.
U«bñaš I±češuge±če
Cěa±d¿ ša šěś cae é¿ñ debaŠ¿ de 300 (aŠěÿčabše), ÿe
acčuļa ša ušě«u±acuÀ±.
Ah¿ññ¿ E±eñgéčuc¿
La šěś ÿe aéaga aěč¿«áčuca«e±če cěa±d¿ haō
ÿěfucue±če šěś ±ačěñaš.
int ldrPin = A0;
int ledPin = 9;
int ldrValue = 0;
int threshold = 300; // Umbral de luz
void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
ldrValue = analogRead(ldrPin);

Serial.print("Nivel de luz: ");
Serial.println(ldrValue);

if (ldrValue < threshold) {
digitalWrite(ledPin, HIGH);
Serial.println("Luz automática ENCENDIDA");
} else {
digitalWrite(ledPin, LOW);
Serial.println("Luz automática APAGADA");
}

delay(500);
}

18. Dwa 17: Rueg¿ Aěč¿«áčuc¿ e± Macečaÿ
int moisturePin = A0;
int pumpPin = 7;
int moistureValue = 0;
int dryThreshold = 400; // Umbral de sequedad
void setup() {
pinMode(pumpPin, OUTPUT);
digitalWrite(pumpPin, LOW);
Serial.begin(9600);
Serial.println("Sistema de riego automático iniciado");
}
void loop() {
moistureValue = analogRead(moisturePin);

Serial.print("Humedad del suelo: ");
Serial.println(moistureValue);

if (moistureValue > dryThreshold) {
Serial.println("Suelo seco - Activando riego");
digitalWrite(pumpPin, HIGH);
delay(3000); // Riega por 3 segundos
digitalWrite(pumpPin, LOW);
Serial.println("Riego completado");
delay(10000); // Espera 10 segundos antes de medir nuevamente
} else {
Serial.println("Suelo húmedo - No necesita riego");
delay(5000); // Verifica cada 5 segundos
}
}
Tip: AŠěÿča eš ě«bñaš ÿegĜ± eš čué¿ de éša±ča. Pša±čaÿ ÿěcěše±čaÿ ±eceÿuča± «e±¿ÿ agěa ïěe
éša±čaÿ čñ¿éucašeÿ.
Se±ÿ¿ñ de Hě«edad
Mude c¿±ÿča±če«e±če ša
hě«edad deš ÿěeš¿ e± ša
«aceča éaña dečeñ«u±añ
cěá±d¿ ñegañ.
B¿«ba de Agěa
Se acčuļa aěč¿«áčuca«e±če
cěa±d¿ ša hě«edad eÿčá é¿ñ
debaŠ¿ deš ě«bñaš eÿčabšecud¿.
C¿±čñ¿š de Tue«é¿
Ruega é¿ñ ě± čue«é¿
dečeñ«u±ad¿ ō šěeg¿ eÿéeña
a±čeÿ de ša ÿugěue±če
«educuÀ±.

19. Día 18: Alarma con PIR y Buzzer
Sistema de Seguridad Mejorado
Esta versión avanzada de la alarma incluye
diferentes tonos de alerta, tiempo de activación
configurable y un sistema de armado/desarmado
más sofisticado.
Características Avanzadas
Tiempo de gracia: 10 segundos para desarmar
Tonos variables: Diferentes frecuencias de
alerta
Indicadores LED: Estado visual del sistema
Reset automático: Se desarma después de 30
segundos
int pirPin = 2;
int buzzerPin = 8;
int ledPin = 13;
int buttonPin = 3;
boolean systemArmed = true;
boolean alarmTriggered = false;
unsigned long triggerTime = 0;
unsigned long graceTime = 10000; // 10 segundos de gracia
void setup() {
pinMode(pirPin, INPUT);
pinMode(buzzerPin, OUTPUT);
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
Serial.begin(9600);
Serial.println("Sistema de seguridad activado");
}
void loop() {
if (systemArmed && digitalRead(pirPin) == HIGH && !alarmTriggered) {
alarmTriggered = true;
triggerTime = millis();
Serial.println("¡MOVIMIENTO DETECTADO! Tiempo de gracia activo...");
}

if (alarmTriggered) {
unsigned long currentTime = millis();

if (currentTime - triggerTime < graceTime) {
// Período de gracia - parpadeo lento
digitalWrite(ledPin, (currentTime / 500) % 2);
} else {
// Alarma activa
digitalWrite(ledPin, HIGH);
tone(buzzerPin, 1000 + (currentTime % 1000), 100);
}

// Auto-reset después de 30 segundos
if (currentTime - triggerTime > 30000) {
alarmTriggered = false;
digitalWrite(ledPin, LOW);
noTone(buzzerPin);
Serial.println("Alarma auto-desactivada");
}
}

// Botón para desarmar
if (digitalRead(buttonPin) == LOW) {
systemArmed = !systemArmed;
alarmTriggered = false;
digitalWrite(ledPin, LOW);
noTone(buzzerPin);
Serial.println(systemArmed ? "Sistema ARMADO" : "Sistema DESARMADO");
delay(1000);
}

delay(100);
}

20. Día 19: Termómetro con LCD
Pantalla LCD 16x2
Muestra la temperatura en tiempo real con dos
líneas de información: temperatura actual y
estado del sistema.
Sensor LM35
Proporciona lecturas precisas de temperatura con
una resolución de 0.5°C y rango de -55°C a 150°C.
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int tempPin = A0;
void setup() {
lcd.begin(16, 2);
lcd.print("Termometro LCD");
delay(2000);
lcd.clear();
}
void loop() {
int tempValue = analogRead(tempPin);
float temperature = (tempValue * 5.0 / 1024.0) * 100;

lcd.setCursor(0, 0);
lcd.print("Temperatura:");

lcd.setCursor(0, 1);
lcd.print(temperature, 1);
lcd.print(" C");

// Indicador de estado
if (temperature > 25) {
lcd.setCursor(10, 1);
lcd.print("CALOR");
} else if (temperature < 18) {
lcd.setCursor(10, 1);
lcd.print("FRIO ");
} else {
lcd.setCursor(10, 1);
lcd.print("OK ");
}

delay(1000);
}
Próximo paso: ¡Mañana completaremos nuestro viaje con el proyecto final que integra todo lo
aprendido en un sistema Smart Home completo!