Diagrama de flujo del programa. Sobre esto iremos creando el programa.
Iniciamos nuestro código de programa.
/************************************************************************
PROGRAMA CAJA FUERTE
************************************************************************/
// Podemos iniciar nuestro código definiendo algunos argumentos
// Le damos nombre a nuestros pulsadores, y les definimos su correspondiente entrada
#define ROJO 5
#define VERDE 6
#define AZUL 7
#define BLANCO 10
//Incluimos las variables que creemos que nos harán falta para nuestro programa.
// Fijaros que he quitado el número entre los corchetes, puesto que lo determina de forma automática
bool FLAG = 0;
byte PASSWORD [] = {ROJO, VERDE, AZUL, VERDE, ROJO}; //Array con la clave correcta.
byte CLAVE [] = {0, 0, 0, 0, 0}; //Array para guardar la contraseña que se mete, al inicio a cero
byte PULSACION = 0; //Variable que me cuenta las pulsaciones
byte ERRORES = 0; // Variable que cuenta los errores
//void FALLO (); //Subprograma al que se llama cuando se ha pulsado mal la Contraseña
//void COMPROBACION(); //Cuando se pulsa el nº 10, se entra en un subprograma que comprueba la coincidencia o no de la clave
void setup() {
//Definición de los pines de los pulsadores
pinMode(ROJO, INPUT);
pinMode(VERDE, INPUT);
pinMode(AZUL, INPUT);
pinMode(BLANCO, INPUT);
//Definición de los pines de los leds
pinMode(12, OUTPUT); //LED Rojo - NOK
pinMode(11, OUTPUT); //LED Verde- OK
//Iniciamos el puerto serie, que nos servirá para monitorizar parámetros.
Serial.begin(9600);
}
void loop() {
// Empezamos el programa según nuestro diagrama comprovando las pulsaciones
if (digitalRead(ROJO)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = ROJO; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(VERDE)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = VERDE; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(AZUL)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = AZUL; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(BLANCO)) { // Si se pulsa el blanco, pasamos a comprovar
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
COMPROBACION();
}
}
if (!digitalRead(ROJO) && !digitalRead(VERDE) && !digitalRead(AZUL) && !digitalRead(BLANCO)) {
FLAG = 0;
}
}
void COMPROBACION() {
}
void FALLO() {
if (ERRORES < 3) { // Si la cantidad de errores que llegan es inferior a 2 solo debemos parpadear el led rojo
for (int i = 1; i <= ERRORES; i++) {
pinMode(12, HIGH);
delay(1000);
pinMode(12, LOW);
}
}
else // Sin embargo si nos llegan 3 errores debemos bloquear el programa 30 segundos y reiniciar la variables
{
pinMode(12, HIGH);
delay(30000);
pinMode(12, LOW);
PULSACION = 0;
ERRORES = 0;
memset(CLAVE, 0, sizeof(CLAVE)); // Usamos este truco para inicializar a 0 todo el array de manera rápida http://www.utopiamechanicus.com/article/arduino-setup-arrays/
}
}
Vamos a empezar a dar caña este nuevo año..
ResponderEliminarYo empezaría preparando el programa, definiendo las bases...ahí van
byte PASSWORD [5] = {5,6,7,6,5}; //Array con la clave correcta.
byte CLAVE [5] = {0,0,0,0,0}; //Array para guardar la contraseña que se mete, al inicio a cero
byte PULSACION = 0; //Variable que me cuenta las pulsaciones
byte ERRORES = 0; // Variable que cuenta los errores
void FALLO (); //Subprograma al que se llama cuando se ha pulsado mal la Contraseña
void COMPROBACION (); //Cuando se pulsa el nº 10, se entra en un subprograma que comprueba la coincidencia o no de la clave
Perfecta aportación, con esto empezaremos el programa, luego añadiremos o quitaremos según nos vaya haciendo falta. Lo incluyo en el código del programa. Si alguno quiere aportar otra pequeña parte, adelante.
EliminarHe añadido otra pequeña parte del programa. ¿Algún voluntario para el setup?. Venga, quiero que todos participeis.
ResponderEliminarOs indico algunas ideas.
ResponderEliminarEl programa consiste en introducir una combinación de 5 pulsaciones con 3 pulsadores diferentes y comprobar si ésta es correcta utilizando un cuarto pulsador. Si la combinación es correcta se encenderá un led verde, si no un led rojo.
Por tanto, necesitaremos 4 entradas para los pulsadores (ROJO, VERDE, AZUL y BLANCO) y 2 salidas para los LEDs. Normalmente éstos se definen en la función void setup()
Por sencillez podemos asignar a cada color del pulsador un número, de manera que sea más fácil de memorizar la combinación secreta. Por ello yo definiría las variables al inicio del programa de la siguiente manera:
#define ROJO 5 //Código numérico/entrada del pulsador ROJO
#define VERDE 6 //Código numérico/entrada del pulsador VERDE
#define AZUL 7 //Código numérico/entrada del pulsador AZUL
#define BLANCO 10 //Código numérico/entrada del pulsador BLANCO
byte PASSWORD [] = {ROJO, VERDE, AZUL, VERDE, ROJO}; //Array con la clave correcta.
byte CLAVE [5] = {0,0,0,0,0}; //Array para guardar la contraseña que se mete, al inicio a cero
byte PULSACION = 0; //Variable que me cuenta las pulsaciones
byte ERRORES = 0; // Variable que cuenta los errores
void FALLO (); //Subprograma al que se llama cuando se ha pulsado mal la Contraseña
bolean COMPROBACION (); //Cuando se pulsa el pulsador BLANCO, se entra en un subprograma que comprueba la coincidencia de la clave. Si es correcta devuelve true, en caso contrario false
Por sencillez si la función COMPROBACION devuelve true, significará que la combinación es correcta, en caso
contrario devolverá false
void setup()
{
//Definición de los pines de los pulsadores
pinMode(ROJO, INPUT);
pinMode(VERDE, INPUT);
pinMode(AZUL, INPUT);
pinMode(BLANCO, INPUT);
//Definición de los pines de los leds
pinMode(12 OUTPUT); //LED Rojo - NOK
pinMode(11 OUTPUT); //LED Verde- OK
}
Gracias por la aportación, esto va cogiendo color, lo único ¿quien eres?
EliminarLuego lo analizamos e integramos, que esto empieza a coger color.
Ánimo, a ver los que no dicen nada.
Como se ha comentado, una de las tareas que hay que hacer de manera repetitiva, es comprobar si se ha pulsado un pulsador. Normalmente las tareas que se realizan de manera repetitiva, es mejor realizarlas en una función.
EliminarPor ello desarrollaremos una función denominada leerPulsadores que se encargará precisamente de ver el estado de cada pulsador y con ello podremos determinar si se ha pulsado o no un pulsador. Para ser más exacto, nos debemos preguntar cómo sé si se ha presionado un pulsador.
Tened en cuenta que el microcontrolador ejecuta 16 millones de ciclos por segundo, por tanto, es tremendamente rápido. La respuesta a esta pregunta podría ser la siguiente: cuando el pulsador se encuentre en HIGH. Esto no es del todo correcto, porque como el controlador lee millones de veces por segundo los valores de tensión del pulsador, cuando pulsamos éste, tendríamos muchas veces consecutivas que se encuentre éste en HIGH. La respuesta correcta es cuando pase de LOW a HIGH o también de HIGH a LOW.
Buenos pues manos a la obra. Ya sabemos que utilizaremos una función denominada leerPulsadores que se encargará de ver el estado de los pulsadores y que devolverá el código del pulsador presionado (0,1,2,3). En caso de que no se haya pulsador ninguno se devolverá -1.
La función será de la siguiente forma
int leerPulsadores()
{
}
Como hemos dicho, para saber si un pulsador se ha presionado debemos comprobar el estado actual del pulsador con el anterior. Para ello utilizaremos dos variables que guardarán estos estados. Además, como hay 4 pulsadores podriamos definir estas variables de la siguiente forma:
int ValorROJOActual, ValorROJOAnterior, ValorAZULActual, ValorAZULAnterior, ValorVERDEActual, ValorVERDEAnterior, ValorBLANCOActual, ValorBLANCOAnterior;
Ahora bien para simplificar el código y hacerlo más sencillo (esto sería inviable si tuviéramos 20 pulsadores o más, utilizaremos 2 variables de tipo vector que se encargarán de almacenar el estado actual y anterior de todos los pulsadores (que son 4)
Las definiremos de la siguientes manera:
int estadoActualPulsador[4], estadoAnteriorPulsador[4];
Esta forma de escribir código está definiendo 4 variables denominadas estadoActualPulsador y 4 estadoAnteriorPulsador que se diferencian únicamente por el numero que va entre corchetes (es decir por su índice)
Cada vez que leemos el estado actual, debemos también actualizar el estado anterior. Es decir cada vez que leemos en nuevo valor actual, el valor actual anterior pasará a ser el valor anterior.
La función podría tener la siguiente forma:
// Definición de las variables para almacenar el estado actual y anterior de los pulsadores y las inicializamos
int estadoActualPulsador[4]={LOW, LOW, LOW, LOW};
int estadoAnteriorPulsador[4] ={LOW, LOW, LOW, LOW};
int pulsadorsPin[4] = {ROJO, AZUL, VERDE, BLANCO}; //Numeración de los pins en Arduino
//Definimos la función leerPulsadores
int leerPulsadores()
{
for (int i = 0; i < 4; i++) { //Leemos todos los pulsadores
estadoActualPulsador[i] = digitalRead(pulsadorsPin[i]);
}
delay(40); //Esperamos 40ms para evitar leer los picos de los pulsadores
//Comprobamos si ha habido cambio de valores anteriores
for (int i = 0; i < 4; i++){
//Miramos si se ha pasado de pulsado (HIGH) a no pulsado (LOW)
if (estadoAnteriorPulsador[i] == HIGH && estadoActualPulsador[i] == LOW) {
//Se ha pulsado y soltado el pulsador i
estadoAnterior[i] = LOW;
return i;
}
else {
estadoAnterior[i] = estadoActual[i]; //En caso contrario almacenamos el valor de la pulsación
}
}
return -1;
}
¿Se podrían optimizar el de las variables para reducir el consumo de memoria? los array de estado a tipo bool, los i de los for a byte, ¿por ejemplo?
EliminarPerdona Luis, no había visto tu aportación. La verdad es que está de maravilla, aunque quizás un poco compleja de momento, aunque es la ideal. Creo que hace falta experiencia en programación para analizar esta parte, puesto que como veremos es lo que sale de resolver el programa final y optimizarlo.
EliminarEl viernes lo analizamos con detenimiento, porque creo que alguno igual se asusta un poco.
Iñigo
ResponderEliminarGracias Iñigo, he incorporado tus sugerencias en el programa, y algunas cosas como el inicio del puerto serie que nos servirá para monitorizar los parámetros que nos interese. También he puesto los cuatro ifs principales del programa, que ahora hay que ir rellenando. Siempre siguiendo el diagrama.
ResponderEliminarAlguno que se anime a incluir alguna cosilla más....
Me parece que la instruccion de digitalRead, esta erroneamente escrita.
ResponderEliminardigital.Read->digitalRead, sin punto en medio.
Gracias Joel, lo voy escribiendo en el blog. Tendré que ir compilando para evitar estos errores. Lo corrijo.
EliminarPor lo menos has estado atento, y lo has leido.
El programa me daba tres fallos al compilar, ya los he corregido y e conseguido compilar.
ResponderEliminarCuales son esos errores?
EliminarA ver que más puedo comentar.
ResponderEliminarSi pulsamos cualquiera de los botones, introducimos el valor del pulsador en la posición del array que corresponda a la pulsación e incrementamos PULSACION en 1, excepto en el botón que sea de comprobación.
Para evitar problemas, en caso de que las pulsaciones sean superiores a 5, solo permitimos introducir un valor en array mientras PULSACION sea inferior o igual a 4, hay que tener en cuenta que el primer valor que pulsacion va a tener PULSACION es 0.
Si pulsamos el botón blanco llamaremos a la función COMPROBACION
/************************************************************************
PROGRAMA CAJA FUERTE
************************************************************************/
// Podemos iniciar nuestro código definiendo algunos argumentos
// Le damos nombre a nuestros pulsadores, y les definimos su correspondiente entrada
#define ROJO 5
#define VERDE 6
#define AZUL 7
#define BLANCO 10
//Incluimos las variables que creemos que nos harán falta para nuestro programa.
// Fijaros que he quitado el número entre los corchetes, puesto que lo determina de forma automática
byte PASSWORD [] = {ROJO, VERDE, AZUL, VERDE, ROJO}; //Array con la clave correcta.
byte CLAVE [] = {0,0,0,0,0}; //Array para guardar la contraseña que se mete, al inicio a cero
byte PULSACION = 0; //Variable que me cuenta las pulsaciones
byte ERRORES = 0; // Variable que cuenta los errores
void FALLO (); //Subprograma al que se llama cuando se ha pulsado mal la Contraseña
void COMPROBACION (); //Cuando se pulsa el nº 10, se entra en un subprograma que comprueba la coincidencia o no de la clave
void setup(){
//Definición de los pines de los pulsadores
pinMode(ROJO, INPUT);
pinMode(VERDE, INPUT);
pinMode(AZUL, INPUT);
pinMode(BLANCO, INPUT);
//Definición de los pines de los leds
pinMode(12 OUTPUT); //LED Rojo - NOK
pinMode(11 OUTPUT); //LED Verde- OK
//Iniciamos el puerto serie, que nos servirá para monitorizar parámetros.
serial.begin(9600);
}
void loop(){
// Empezamos el programa según nuestro diagrama comprovando las pulsaciones
if (digitalRead(ROJO)){
if (PULSACION<=4)CLAVE[PULSACION]=ROJO;
PULSACION++;
}
if (digitalRead(VERDE)){
if (PULSACION<=4)CLAVE[PULSACION]=VERDE;
PULSACION++;
}
if (digitalRead(AZUL)){
if (PULSACION<=4)CLAVE[PULSACION]=AZUL;
PULSACION++;
}
if (digitalRead(BLANCO)){
}
COMPROBACION();
}
Gracias Luis por la aportación. Lo más importante de esta parte que nos ha puesto Luis, es que pase lo que pase, la variable PULSACIÓN se incrementará. De esta forma, sabremos si se han pulsado más colores de la cuenta, que aunque la combinación sea correcta, daría lugar a combinación erronea. Es decir, primero comprovamos que se ha pulsado un color, luego, si cabe se introduce en la variable, y se suma una pulsación, si no cabe, se suma pulsación. Lo pasamos al programa principal.
EliminarEsto empieza a coger color, y muy buena pinta. Pero tenemos que solucionar el tema del tiempo de pulsación. Y que no se meta el mismo color en la variable si se mantiene pulsado el botón. Vamos a pensar como lo hacemos.
ResponderEliminarEste comentario ha sido eliminado por el autor.
ResponderEliminarVoy a saltar a la función COMPROBACION. He dedicido dar las explicaciones dentro del código en comentarios.
ResponderEliminarComo quedaría el código después de void loop()
/***************************************
*
* La función COMPROBACION se define como void, ya que no devolverá ningún valor, solamente tiene que ejecutar sentencias.
* La función operará en este orden:
*
* Para comprobar la contraseña se debe cumplir (requisitos)
* - Que PULSACION sea exactamente 5
* - Que el modo de pin 11 este a LOW (led verde apagado)
*
* Si los requisitos con correctos:
*
* - Se comparará el array CLAVE contra PASSWORD
* - Si CLAVE coincide con PASSWORD, se cambiará el pin 11 a HIGH (led verde)
* - Si CLAVE no coincide con PASSWORD, se incrementará ERRORES en +1 y se llamará a una función ERROR()
*
* Si los requisitos no son correctos:
*
* - Si PULSACION no es exactamente 5 (puede ser superior o inferior), se incrementa ERRORES +1 y se llamará a la función ERROR()
* - Si el modo del pin 11 es HIGH (led verde está encendido), significa que queremos cerrar y debemos reiniciar la variables.
*
*******************************************************/
void COMPROBACION(){
byte OK; // Creamos la variable necesaria para comprobar que la comparacion de los arrays
bool LED_VERDE; // Creamos la variable que almacenará el estado del led
LED_VERDE=digitalRead(11); // Leemos el estado del led
if (PULSACION==5 && !LED_VERDE){ // Comprobamos los requisitos
for (int i=0; i<5; i++){ // Comparamos los arrays. NOTA: creo que el comando array_cmp compara dos array, pero no encuentro referencias fiables
if (CLAVE[i]==PASSWORD[i]) OK++;
}
if (OK==5){
pinMode(11, HIGH); // Ponemos el pin verde encendido
LED_VERDE=digitalRead(11); //Almacenamos el estado del led
}
else
{
ERRORES++; // Significa que la clave introducida no es correcta
FALLO(); // Nos vamos a la funcion error para gestionarlo
}
}
else
{
if (PULSACION!=5 && !LED_VERDE){ // Significa que las pulsaciones no son acertadas, y que ademas no se ha abierto la caja ya que su estado es LOW por lo tanto esta a CERO lo cual es FALSE
ERRORES++;
FALLO();
}
if (LED_VERDE){ //Significa que el led esta encendido, es verdad o sea que el modo del pin 11 es HIGH y queremos cerrar
pinMode(11, LOW); // Ponemos el pin verde apagado
LED_VERDE=digitalRead(11); // Almacenamos el estado del led
PULSACION=0;
ERRORES=0;
memset(CLAVE,0,sizeof(CLAVE)); // Usamos este truco para inicializar a 0 todo el array de manera rápida http://www.utopiamechanicus.com/article/arduino-setup-arrays/
}
}
}
/*************************************************
* La función ERROR se define como void, ya que no devolverá ningún valor, solamente tiene que ejecutar sentencias.
*
* - Si ERRORES es inferior a 3 y ERRORES es 1, el led rojo parpadeará una vez y si es 2 parpadeará 2 veces
* - Si ERRORES es igual a 3, cambiará el estado del pin 12 a HIGH y pausará el programa durante 30 segundos. Despues de esta pausa debemos reiniciar las variables de nuevo.
*
****************************************/
void FALLO(){
if (ERRORES < 3){ // Si la cantidad de errores que llegan es inferior a 2 solo debemos parpadear el led rojo
for (int i=0; i<=ERRORES; i++){
pinMode(12, HIGH);
delay(1000);
pinMode(12, LOW);
}
}
else // Sin embargo si nos llegan 3 errores debemos bloquear el programa 30 segundos y reiniciar la variables
{
pinMode(12, HIGH);
delay(30000);
pinMode(12, LOW);
PULSACION=0;
ERRORES=0;
memset(CLAVE,0,sizeof(CLAVE)); // Usamos este truco para inicializar a 0 todo el array de manera rápida http://www.utopiamechanicus.com/article/arduino-setup-arrays/
}
}
Hay un error en esta parte del codigo, así seria correcto
Eliminarvoid FALLO(){
if (ERRORES < 3){ // Si la cantidad de errores que llegan es inferior a 2 solo debemos parpadear el led rojo
for (int i=1; i<=ERRORES; i++){
pinMode(12, HIGH);
delay(1000);
pinMode(12, LOW);
}
}
else // Sin embargo si nos llegan 3 errores debemos bloquear el programa 30 segundos y reiniciar la variables
{
pinMode(12, HIGH);
delay(30000);
pinMode(12, LOW);
PULSACION=0;
ERRORES=0;
memset(CLAVE,0,sizeof(CLAVE)); // Usamos este truco para inicializar a 0 todo el array de manera rápida http://www.utopiamechanicus.com/article/arduino-setup-arrays/
}
}
Gracias Luis por esta aportación, está muy bien estructurada, y muy bien pensada. La incorporo al programa. Ya veremos como la llamamos esta función.
Eliminar<Yo quiero añadir el tema de la pulsación, solo lo hago con el pulsador _Rojo_ los demás serían igual..
ResponderEliminarhabria que añadir la definición de las variables al principio
byte PULSADORROJO = 0;
byte PULSADORROJOANT = 0;
byte ESTADOROJO = 0;
--------
PULSADORROJO = digitalRead (ROJO);
if ((PULSADORROJO == HIGH)&&(PULSADORROJOANT == LOW)) //Si se pulsa la entrada ROJO y no estaba pulsada
{
ESTADOROJO = 1 - ESTADOROJO;
delay (40);
}
PULSADORROJOANT == PULSADORROJO;
if (ESTADOROJO == 1)
{
CLAVE [PULSACION] = ROJO;
PULSACION ++; //y se añade uno al número de pulsacion
}
Justo estaba yo escribiendo el código, basado en lo mismo, y ahora veo esta parte que has escrito.
EliminarNo lo veo, de momento, creo que algo no va, no se, pero si mañana lo repasamos y se ve más claro, lo añadimos.
Bueno, como veo que o no me explico, o no....., voy a avanzar un poco el programa.
ResponderEliminarComo he comentado debemos evitar que una pulsación se tome en cuenta varias veces, tanto por rebote de la propia pulsación como por ciclo de programa.
Ya sabemos como evitar el rebote, introduciendo un pequeño delay tras la pulsación, que he escrito en el programa en color verde.
delay(10);
Otro asunto muy diferente, es que el programa sigue funcionando, y recorriendo la pila una vez tras otra, por lo que como ya sabemos que es muy rápido, el programa volverá a ver el mismo pulsador, e irá introduciendo su valor en la variable hasta que soltemos el botón.
Una solución sería con otro delay, el cual con un tiempo prudente, dará el suficiente tiempo para que soltemos el botón, pero limitará en caso de un delay alto la introducción de la combinación de una forma rápida, y si el valor es demasiado bajo, seguiremos teniendo el problema inicial. Entonces ¿como lo solucionamos?
Lo podemos solucionar con una marca, que no es otra cosa que una variable, que nos indique que el botón se encuentra pulsado.
A esta variable en el programa la llamaremos FLAG, pero la podemos llamar PEPITO, y será de tipo bool, puesto que con un 1 o un 0, nos es suficiente. (Toda esta parte la representaré de color rojo).
bool FLAG = 0;
Ahora debemos decidir cuando indicar que se ha pulsado el botón. Lógicamente, deberá ser tras la pulsación.
FLAG = 1; // Activamos la marca de pulsación de botón.
Pero es importante que la activemos tras su comprovación con un if, puesto que si no jamás se ejecutarán las instrucciones por pulsar el botón.
If (FLAG != 1){ // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
Y únicamente nos faltaría poner la marca a 0, en caso de que ningún botón esté pulsado.
if (!digitalRead(ROJO)&!digitalRead(VERDE)&!digitalRead(AZUL)&!digitalRead(BLANCO)){
FLAG = 0;
}
Por cierto, no lo he compilado ni provado, eso para vosotros.
me pierdo desde el principio estoy leyendo y no entiendo nada
ResponderEliminarEl programa ya se puede copiar y pegar en el IDE, no tiene fallos de compilación.
ResponderEliminarSerial.print(CLAVE[0]);Serial.print(CLAVE[1]);Serial.print(CLAVE[2]);Serial.print(CLAVE[3]);Serial.print(CLAVE[4]);
ResponderEliminardelay(250);
Serial.println();
Unas ideas para poner en el loop.....
Faltaria inicializar el puerto serie con:
ResponderEliminarSerial.begin(9600);
meterlo en el setup.
http://elimelecsarduinoprojects.blogspot.com.es/2013/06/compare-arrays-in-arduino.html?m=1
ResponderEliminarEn este enlace encontraréis un buen ejemplo de comparación de arrays.
Espero que lo apliques para la función comparar.
Os pongo el subprograma COMPROBACIÓN para ir completando La Caja Fuerte..
ResponderEliminarvoid COMPROBACION () // Si se ha realizado correctamente la clave, Tiene que cumplir que los dos arrays sean iguales puesto a puesto, entonces se enciende verde
{
if ( PULSACION == 4)&& (PASSWORD [0] == CLAVE [0]) && (PASSWORD [1] == CLAVE [1]) && (PASSWORD [2] == CLAVE [2]) && (PASSWORD [3] == CLAVE [3]) && (PASSWORD [4] == CLAVE [4]))
{
digitalWrite (13, 1); // queda 3 segundos encendida y luego vuelve a 0 las dos variables.
delay (3000);
digitalWrite (13, 0);
CLAVE [0] = 0;
CLAVE [1] = 0;
CLAVE [2] = 0;
CLAVE [3] = 0;
CLAVE [4] = 0;
PULSACION == 0;
}
else
{
FALLO (); // Si no se acierta la contraseña, nos manda al subprograma FAllO
}
}