Sistema de alarma con Arduino

En una casa con dos puertas de acceso, una trasera y otra delantera, se quiere montar un sistema de alarma que funciona cuando se conecta un interruptor (P), de modo que cuando se abre cualquiera de las puertas se activa una alarma sonora. Realiza el circuito correspondiente para Arduino.
  • Dibuja el circuito correspondiente.
  • Realiza el algoritmo.
  • Realiza el programa para Arduino.


Una posible solución al problema

Material necesario
  
Arduino UNO 
  • Placa protoboard
  • 2  pulsadores
  • Interruptor
  • Zumbador
  • Cables 
Circuito eléctrico



 Montaje realizado en tinkercad



Diagrama de flujo



Código

 int Zumbador=10;
int PulsadorA=13;
int PulsadorB=11;
int Interruptor=12;
int estadoPulsadorA=0;
int estadoPulsadorB=0;
int estadoInterruptor=0;

void setup()
{
  pinMode(Zumbador,OUTPUT);
  pinMode(PulsadorA,INPUT);
  pinMode(PulsadorB,INPUT);
  pinMode(Interruptor,INPUT);
}

void loop()
{  
 estadoInterruptor=digitalRead(Interruptor);
  if(estadoInterruptor==HIGH)
  {
    estadoPulsadorA=digitalRead(PulsadorA);
    estadoPulsadorB=digitalRead(PulsadorB);
 
    if(estadoPulsadorA==HIGH||estadoPulsadorB==HIGH)
    {
      digitalWrite(Zumbador,HIGH);
      delay(1000);
     }
     else
     {
     digitalWrite(Zumbador,LOW);
     delay(1000);
     }
    }
    else
    {
     digitalWrite(Zumbador,LOW);
      delay(1000);
     }
}


Enceder un led desde tres posiciones

Diseña un circuito para Arduino constituido por tres pulsadores (a,b y c) y una lámpara (led) que se encenderá cuando se pulsen los tres pulsadores a la vez o sólo uno de ellos.

  • Dibujar el circuito correspondiente.
  • Realizar el algoritmo.
  • Realizar el programa para Arduino.
Circuito eléctrico



Diagrama de flujo

 Montaje realizado

Código
int pinPulsador3= 10;
int estadoPulsador1=0;
int estadoPulsador2=0;
int estadoPulsador3=0;

void setup()
{
  pinMode(pinLed1,OUTPUT);
  pinMode(pinPulsador1,INPUT);
  pinMode(pinPulsador2,INPUT);
  pinMode(pinPulsador3,INPUT);
}
void loop()
{
  estadoPulsador1=digitalRead(pinPulsador1);
  estadoPulsador2=digitalRead(pinPulsador2);
  estadoPulsador3=digitalRead(pinPulsador3);

  if(estadoPulsador1==HIGH)
  {
    digitalWrite(pinLed1,HIGH);
    //delay(1000);
  }

  
   if(estadoPulsador2==HIGH)
  {
    digitalWrite(pinLed1,HIGH);
    //delay(1000);
  }


  if(estadoPulsador3==HIGH)
  {
    digitalWrite(pinLed1,HIGH);
    //delay(1000);
  }

  digitalWrite(pinLed1,LOW);
 
}
En se siguiente enlace se puede acceder al simulador: Circuito con tres pulsadores

 

Tinkercad. Simulador

Tinkercad es una herramienta online ofrecida por Autodesk. Se utiliza de forma gratuita y sólo requiere crearse una cuenta de usuario. De entre sus utilidades, probablemente la más conocida es la de diseñar piezas en 3D. Sin embargo, ofrece también una posibilidad realmente interesante y es la de montar, programar y simular circuitos con Arduino. Leer más...



Contador BCD

Diseñar un circuito que realice la cuenta en binario, en nuestra caso será un contador BCD (0-9).


Sketch que hay que cargar en la placa


int diodo0=9;
int diodo1=10;
int diodo2=11;
int diodo3=12;


void setup()
{
  pinMode(diodo0, OUTPUT);
  pinMode(diodo1, OUTPUT);
  pinMode(diodo2, OUTPUT);
  pinMode(diodo3, OUTPUT);
}

void loop()
{
  encenderDiodos(0,0,0,1);
  encenderDiodos(0,0,1,0);
  encenderDiodos(0,0,1,1);
  encenderDiodos(0,1,0,0);
  encenderDiodos(0,1,0,1);
  encenderDiodos(0,1,1,0);
  encenderDiodos(0,1,1,1);
  encenderDiodos(1,0,0,0);
  encenderDiodos(1,0,0,1);
}
void encenderDiodos(int d3,int d2, int d1, int d0)
{
  digitalWrite(diodo0, d0);
  digitalWrite(diodo1, d1);
  digitalWrite(diodo2, d2);
  digitalWrite(diodo3, d3);
  delay(500);
 
  digitalWrite(diodo0, LOW);
  digitalWrite(diodo1, LOW);
  digitalWrite(diodo2, LOW);
  digitalWrite(diodo3, LOW);
  delay(500);
}

Vamos a introducir un pulsador en el circuito con la intención de que nos sirva para iniciar el comienzo de la cuenta, el circuito modificado será el siguiente:


Sketch que hay que cargar en la placa

int diodo0=9;
int diodo1=10;
int diodo2=11;
int diodo3=12;
int pinPulsador=0;
int estadoPulsador=0;

void setup()

{
  pinMode(diodo0, OUTPUT);
  pinMode(diodo1, OUTPUT);
  pinMode(diodo2, OUTPUT);
  pinMode(diodo3, OUTPUT);
  pinMode(pinPulsador, INPUT);
 
}

void loop()

{
  estadoPulsador=digitalRead(pinPulsador);
  while(estadoPulsador==LOW)
  {
  encenderDiodos(0,0,0,1);
  encenderDiodos(0,0,1,0);
  encenderDiodos(0,0,1,1);
  encenderDiodos(0,1,0,0);
  encenderDiodos(0,1,0,1);
  encenderDiodos(0,1,1,0);
  encenderDiodos(0,1,1,1);
  encenderDiodos(1,0,0,0);
  encenderDiodos(1,0,0,1);
  estadoPulsador=digitalRead(pinPulsador);
 
  }
  }

//Función declarada para activar los diodos
void encenderDiodos(int d3,int d2, int d1, int d0)

{
  digitalWrite(diodo0, d0);
  digitalWrite(diodo1, d1);
  digitalWrite(diodo2, d2);
  digitalWrite(diodo3, d3);
  delay(500);
 
  digitalWrite(diodo0, LOW);
  digitalWrite(diodo1, LOW);
  digitalWrite(diodo2, LOW);
  digitalWrite(diodo3, LOW);
  delay(500);


RecordMyDestop


La importancia de las contraseñas


Desde tiempos inmemoriales la humanidad ha guardado bajo llave sus pertenencias y secretos para protegerlos de accesos no deseados. De hecho, se han encontrado cerraduras egipcias que datan del 2000 a.C. aunque se cree que fue un invento importado de China.

Hoy, una parte no despreciable de nuestras pertenencias y secretos se ha despojado de su fisicidad y está almacenada como ceros y unos en nuestros dispositivos o en la nube. Así, también se han vuelto inmateriales las llaves que dan acceso a esos datos y servicios: las contraseñas.

Una contraseña o clave es una forma de autenticación que da acceso a ciertos recursos y servicios. Al igual que sucedía en la antigüedad cuando los centinelas que vigilaban una determinada posición pedían el "santo y seña" a quien se acercaba, las contraseñas suelen ir asociadas a un usuario (santo).

¿Te has parado a pensar cuántas veces al día introduces una contraseña en tu dispositivo? ¿Cuántos servicios utilizas que requieran autenticación? ¿Qué podría pasar si dejaras la "puerta abierta" a todos tus dispositivos, datos y servicios? ¿Si alguien no deseado se hiciera con tus claves de acceso bien robándolas bien "adivinándolas"?

Las contraseñas dan acceso a datos y servicios de gran valor para nosotros como pueden ser nuestros ahorros a través de la banca online o nuestra identidad digital a través de nuestro correo electrónico y redes sociales y por ello debemos ser especialmente diligentes a la hora de gestionarlas.

Hay cuatro normas básicas que debemos respetar:

- Que sean secretas. Esto implica no compartirlas con nadie ni tenerlas apuntadas donde pueda acceder un tercero. También supone tener especial cuidado con las preguntas de seguridad que nos permiten "recuperarlas": las respuestas deben ser igualmente secretas (el nombre de tu perro, por ejemplo, no es una información que solo tú conozcas)

- Que sean robustas. Veremos cómo crear contraseñas robustas en el siguiente enlace. Crear contraseñas robustas y seguras

- Que sean únicas. Debemos usar una contraseña distinta para cada uno de los servicios que usemos para que, no comprometamos la seguridad de todos en el caso de que se dé un robo de contraseñas en uno de ellos.

- Que tengan fecha de caducidad. Debemos cambiar con frecuencia nuestras contraseñas y siempre que pensemos que pueden haberse visto comprometidas. Es importante que las nuevas -que deben seguir estas mismas cuatro normas básicas- no sean transformaciones predecibles de la anterior.

Contraseñas robustas y seguras

Contador

Un contador no es más que una variable destinada a contener un valor que se irá incrementando o decrementando en una cantidad fija y constante, y que es almacenado en memoria principal.

Los contadores suelen utilizarse generalmente para el control de procesos repetitivos, es decir, su principal objetivo es contabilizar un conjunto de sucesos o acciones que se desean repetir en un programa mediante el uso de estructuras de control repetitivas ( Mientras, Repetir-Mientras y Para).

Contador= Contador - Valor constante

Contador = Contador + Valor constante

Todo contador deber tomar un valor inicial antes de ser utilizado.

Ejemplo:

Diseño del algoritmo correspondiente a un programa que escriba en orden decreciente los 50 primeros números pares.

Contador