Password para teclado Matricial 4x4

Olá pll,
Estou-me a iniciar no mundo dos Arduinos…comecei por ler o básico e pus mão à obra.

O objectivo (para já) é controlar 8 reles com o Arduino.
O hardware é:

  • Arduino Uno;
  • Teclado Matricial 4x4;
  • 8 Relés

Pretendia:

  1. Através de senha “accionar” o sistema, (senha correcta “libera” o teclado, senha errada “nada”)
  2. “Liberado” o teclado:
    2.1 Uma tecla acciona rele, na mesma tecla desliga rele;
    2.2 Uma tecla acciona 3 reles, na mesma tecla desliga 3 reles

Em relação aos pontos 2.1 e 2.2 já consegui fazer o código;
Em relação ao ponto 1 também já tenho o código, (é o exemplo “PasswordKeypad” da biblioteca Password.h

Agora o que não estou a conseguir, (já ando nisto à 3 dias), é “inserir” os pontos 2.1 e 2.2 no ponto 1

Alguém pode ajudar?
Aqui ficam os códigos em causa)

Da Password:

..... void setup(){

  Serial.begin(9600);
 [font=Verdana] keypad.addEventListener(keypadEvent); //add an event listener for this keypad[/font]
}

void loop()[font=Verdana]{
  keypad.getKey();
}

//take care of some special events
void keypadEvent(KeypadEvent eKey){
  switch (keypad.getState()){
    case PRESSED:
	Serial.print("Pressed: ");
	Serial.println(eKey);
	switch (eKey){
	  case '*': checkPassword(); break;
	  case '#': password.reset(); break;
	  default: password.append(eKey);
     }
  }
}

void checkPassword(){
  if (password.evaluate()){
    Serial.println("Success");
    //Add code to run if it works (POIS JÁ TENTEI INSERIR AQUI A PARTE DE CARREGAR NAS TECLAS...MAS SEM SUCESSO  :sweat_smile:
  }else{
    Serial.println("Wrong");
    //add code to run if it did not work
  }

[/font]

Agora a programação que “fiz” e na qual quero inserir a password:

#include <Password.h> //http://www.arduino.cc/playground/uploads/Code/Password.zip
#include <Keypad.h> //http://www.arduino.cc/playground/uploads/Code/Keypad.zip

Password password = Password( "1234" ); // Senha utilizada

const byte ROWS = 4; //quatro linhas - Fios Laranja
const byte COLS = 4; //quatro colunas - Fios Brancos

//Define o Keypad (mapa do circuito do teclado).
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = { 9,8,7,6 };//ligar as linhas do teclado
byte colPins[COLS] = {12,11,10,5};//ligar as colunas do teclado


// Create the Keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int releHQI = 2;                  // Atribui Lâmpadas HQI ao Rele 1 - conectado na porta 02 do arduino no IN1 da placa rele - Fio Roxo
int releT8 = 3;                    // Atribui Lâmpadas T8 ao Rele 2   - conectado na porta 03 do arduino no IN2 da placa rele - Fio Verde
int releMoonlight = 4;    // Atribui Lâmpadas Moonlight ao Rele 3 - conectado na porta 04 do arduino no IN3 da placa rele - Fio Cinzento
int releEscumador = 13;   // Atribui Escumador ao Rele 4 - conectado na porta 13 do arduino no IN4 da placa rele - Fio Amarelo


void setup(){

  Serial.begin(9600);
  pinMode(releHQI,OUTPUT);                                             // Define a porta 02 como sendo de saída.
  digitalWrite(releHQI,HIGH);                                              // inicializa com o Lâmpadas HQI desligadas.
  pinMode(releT8,OUTPUT);                                                // Define a porta 03 como sendo de saída.
  digitalWrite(releT8, HIGH);                                                // inicializa com o Lâmpadas T8 desligadas.
  pinMode(releMoonlight,OUTPUT);                                // Define a porta 04 como sendo de saída.
  digitalWrite(releMoonlight, HIGH);                               // inicializa com o Lâmpadas Moonlight desligadas.
  pinMode(releEscumador,OUTPUT);                              // Define a porta 13 como sendo de saída.
  digitalWrite(releEscumador, HIGH);                              // inicializa com o Escumador desligado.

 
}

void loop(){

  char Key = keypad.getKey();
  if (Key != NO_KEY)
  {
    Serial.println(Key);
  }
if(Key)                                                                                                   // Checa se um botão foi pressionado.
{
  switch (Key)
    {
     case '1' :                                                                                           // Se for pressionado…
        if(digitalRead(releHQI)==LOW)                                         // verifica se as Lâmpadas HQI estão desligadas
        {digitalWrite(releHQI, HIGH);                                              // se verdadeiro liga as Lâmpadas HQI
        }else
        {digitalWrite(releHQI,LOW);                                                 // se falso desliga Lâmpadas HQI
        }break;                                                                                         // Parada, aguardando pressionar outro botão
     case '2' :                                                                                          // Se for pressionado…
        if(digitalRead(releT8)==LOW)                                            // verifica se as Lâmpadas T8 estão desligadas
        {digitalWrite(releT8, HIGH);                                                 // se verdadeiro liga as Lâmpadas T8
        }else                           
        {digitalWrite(releT8,LOW);                                                  // se falso desliga Lâmpadas T8
        }break;                                                                                        // Parada, aguardando pressionar outro botão
      case '3' :                                                                                        // Se for pressionado…
        if(digitalRead(releMoonlight)==LOW)                            // verifica se as Lâmpadas Moonlight estão desligadas
        {digitalWrite(releMoonlight, HIGH);                                 // se verdadeiro liga as Lâmpadas Moonlight
        }else                                                 
        {digitalWrite(releMoonlight,LOW);                                   // se falso desliga as Lâmpadas Moonlight
        }break;                                                                                       // Parada, aguardando pressionar outro botão
      case 'A' :                                                                                       // Se for pressionado…
        if((digitalRead(releHQI)==HIGH)||                                    // verifica se as Lâmpadas estão ligadas
        (digitalRead(releT8)==HIGH)||                                          // verifica se as Lâmpadas estão ligadas
        (digitalRead(releMoonlight)==HIGH))                          // verifica se as Lâmpadas estão ligadas
        {digitalWrite(releHQI, LOW);                                           // se verdadeiro desliga as Lâmpadas HQI
        digitalWrite(releT8, LOW) ;                                              // SE verdadeiro desliga as Lâmpadas T8
        digitalWrite(releMoonlight, LOW);                               // se verdadeiro desliga as Lâmpadas Moonlight
        }else
        {digitalWrite(releHQI, HIGH);                                         // se falso liga as Lâmpadas HQI
        digitalWrite(releT8, HIGH);                                             // se falso liga as Lâmpadas T8
        digitalWrite(releMoonlight, HIGH);                             // se falso liga as Lâmpadas Moonlight
        }break;
       case '4' :                                                                                  // Se for pressionado…
        if(digitalRead(releEscumador)==LOW)                      // verifica se o Escumador está desligado
        {digitalWrite(releEscumador, HIGH);                           // se verdadeiro liga o Escumador
        }else                                                  
        {digitalWrite(releEscumador,LOW);                              // se falso desliga o Escumador
        }break;                                                                                    // Parada, aguardando pressionar outro botão
        default:
        Serial.println(Key);
     }
   }
}

Nota: Destaquei aquilo que acho que devo introduzir neste ultimo programa, se cometi alguma “bacurada” foi mesmo por estar “verde” na materia :fearful:

Mais uma vez alguém pode ajudar?

Obg
NJPinheiro

Devia ter lido as regras do fórum antes de colocar o post (eu sei que estão em inglês, mas pode olhar para as figuras e tirar conclusões). Deve colocar o código dentro das tags "code", clicando no botão ' # '. Caso contrário o código é muito difícil de ler e também é mais difícil encontrar que o ajude.

luisilva: Deve colocar o código dentro das tags "code", clicando no botão ' # '. Caso contrário o código é muito difícil de ler e também é mais difícil encontrar que o ajude.

Corrigido, peço desculpa pelo lapso.

Obg NJPinheiro

Falta-lhe um terceiro ponto, que é: premindo a tecla “XPTO” volta ao estado “trancado”.
Nunca utilizei esta biblioteca (Password.h), mas analisando os exemplos, chego à conclusão que os dois programas têm “filosofias” diferentes, isto é, um programa está a ler as teclas via “evento” e o outro está a ler as teclas no ciclo principal (função loop()). Eu penso que deve alterar um dos dois e fazer para ambos a mesma “filosofia”. Depois disso, penso que deve adicionar uma variável “estado” (ou uma coisa parecida) que indique se o teclado está “trancado” (e à espera da introdução da password) ou “liberto” (e está à espera da ordem para alterar as lâmpadas).
Sendo assim, eu alterava a filosofia do programa de introdução de password e juntava tudo no programa das lâmpadas.

#include <Password.h> //http://www.arduino.cc/playground/uploads/Code/Password.zip
#include <Keypad.h> //http://www.arduino.cc/playground/uploads/Code/Keypad.zip

Password password = Password( "1234" ); // Senha utilizada

const byte ROWS = 4; //quatro linhas - Fios Laranja
const byte COLS = 4; //quatro colunas - Fios Brancos

//Define o Keypad (mapa do circuito do teclado).
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = { 9, 8, 7, 6 }; //ligar as linhas do teclado
byte colPins[COLS] = {12, 11, 10, 5}; //ligar as colunas do teclado


// Create the Keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int releHQI = 2;                  // Atribui Lâmpadas HQI ao Rele 1 - conectado na porta 02 do arduino no IN1 da placa rele - Fio Roxo
int releT8 = 3;                    // Atribui Lâmpadas T8 ao Rele 2   - conectado na porta 03 do arduino no IN2 da placa rele - Fio Verde
int releMoonlight = 4;    // Atribui Lâmpadas Moonlight ao Rele 3 - conectado na porta 04 do arduino no IN3 da placa rele - Fio Cinzento
int releEscumador = 13;   // Atribui Escumador ao Rele 4 - conectado na porta 13 do arduino no IN4 da placa rele - Fio Amarelo

boolean estado = false;

void setup() {

  Serial.begin(9600);
  pinMode(releHQI, OUTPUT);                                            // Define a porta 02 como sendo de saída.
  digitalWrite(releHQI, HIGH);                                             // inicializa com o Lâmpadas HQI desligadas.
  pinMode(releT8, OUTPUT);                                               // Define a porta 03 como sendo de saída.
  digitalWrite(releT8, HIGH);                                                // inicializa com o Lâmpadas T8 desligadas.
  pinMode(releMoonlight, OUTPUT);                               // Define a porta 04 como sendo de saída.
  digitalWrite(releMoonlight, HIGH);                               // inicializa com o Lâmpadas Moonlight desligadas.
  pinMode(releEscumador, OUTPUT);                             // Define a porta 13 como sendo de saída.
  digitalWrite(releEscumador, HIGH);                              // inicializa com o Escumador desligado.
}

void loop() {

  char Key = keypad.getKey();

  if (estado == false && Key != NO_KEY)
  {
    switch (Key) {
      case '*':
        if (password.evaluate()) {
          Serial.println("Success");
          estado = true;
          //Add code to run if it works (POIS JÁ TENTEI INSERIR AQUI A PARTE DE CARREGAR NAS TECLAS...MAS SEM SUCESSO 
        }
        break;
      case '#': password.reset(); break;
      default: password.append(Key);
    }
  }
  else if (estado == true && Key != NO_KEY) {
    Serial.println(Key);
    if (Key)                                                                                                  // Checa se um botão foi pressionado.
    {
      switch (Key)
      {
        case '1' :                                                                                           // Se for pressionado…
          if (digitalRead(releHQI) == LOW)                                      // verifica se as Lâmpadas HQI estão desligadas
          { digitalWrite(releHQI, HIGH);                                              // se verdadeiro liga as Lâmpadas HQI
          } else
          { digitalWrite(releHQI, LOW);                                                // se falso desliga Lâmpadas HQI
          } break;                                                                                        // Parada, aguardando pressionar outro botão
        case '2' :                                                                                          // Se for pressionado…
          if (digitalRead(releT8) == LOW)                                         // verifica se as Lâmpadas T8 estão desligadas
          { digitalWrite(releT8, HIGH);                                                 // se verdadeiro liga as Lâmpadas T8
          } else
          { digitalWrite(releT8, LOW);                                                 // se falso desliga Lâmpadas T8
          } break;                                                                                       // Parada, aguardando pressionar outro botão
        case '3' :                                                                                        // Se for pressionado…
          if (digitalRead(releMoonlight) == LOW)                         // verifica se as Lâmpadas Moonlight estão desligadas
          { digitalWrite(releMoonlight, HIGH);                                 // se verdadeiro liga as Lâmpadas Moonlight
          } else
          { digitalWrite(releMoonlight, LOW);                                  // se falso desliga as Lâmpadas Moonlight
          } break;                                                                                      // Parada, aguardando pressionar outro botão
        case 'A' :                                                                                       // Se for pressionado…
          if ((digitalRead(releHQI) == HIGH) ||                                // verifica se as Lâmpadas estão ligadas
              (digitalRead(releT8) == HIGH) ||                                       // verifica se as Lâmpadas estão ligadas
              (digitalRead(releMoonlight) == HIGH))                        // verifica se as Lâmpadas estão ligadas
          { digitalWrite(releHQI, LOW);                                           // se verdadeiro desliga as Lâmpadas HQI
            digitalWrite(releT8, LOW) ;                                              // SE verdadeiro desliga as Lâmpadas T8
            digitalWrite(releMoonlight, LOW);                               // se verdadeiro desliga as Lâmpadas Moonlight
          } else
          { digitalWrite(releHQI, HIGH);                                         // se falso liga as Lâmpadas HQI
            digitalWrite(releT8, HIGH);                                             // se falso liga as Lâmpadas T8
            digitalWrite(releMoonlight, HIGH);                             // se falso liga as Lâmpadas Moonlight
          } break;
        case '4' :                                                                                  // Se for pressionado…
          if (digitalRead(releEscumador) == LOW)                   // verifica se o Escumador está desligado
          { digitalWrite(releEscumador, HIGH);                           // se verdadeiro liga o Escumador
          } else
          { digitalWrite(releEscumador, LOW);                             // se falso desliga o Escumador
          } break;                                                                                   // Parada, aguardando pressionar outro botão
        default:
          estado = false;
      }
    }
  }
}

O código compila correctamente, não tenho o teclado nem o relés para testar se o funcionamento é o correcto ou não, mas fica aqui a ideia.

Diga se funcionou correctamente.

luisilva: Falta-lhe um terceiro ponto, que é: premindo a tecla "XPTO" volta ao estado "trancado". .... penso que deve adicionar uma variável "estado" (ou uma coisa parecida) que indique se o teclado está "trancado" (e à espera da introdução da password) ou "liberto" (e está à espera da ordem para alterar as lâmpadas).

Diga se funcionou correctamente.

Boas!! Dito assim até parece fácil :)

Obrigado Sr Luis, funcionou 100%

Agora vou passar para a fase 2, :~ que é programar os 8 reles, e trocar do Arduino para o Arduino Mega, uma vez que já estou praticamente sem portas digitais. A programação pode ser a mesma, certo? ou há diferenças do UNO para o Mega?

Depois seguir-se-à a fase 3 que é tentar juntar a tudo isto um relógio e um LCD, (já estou a voar alto....mas o céu é o limite).

O que me aconselham 1º, juntar o relógio, (DS_1307) ou um LCD que ainda não sei bem qual?

Obg NJPinheiro

Neste caso, penso que não há diferença entre o MEGA e o UNO (o programa é tão simples que não vai trazer problemas). Em relação à fase 3. Pode utilizar um LCD 16x2 (LCD alfa numérico de 2 linhas de 16 caracteres) são bastante fácies de usar, e penso que também devem ser os mais acessíveis (do ponte de vista do preço): http://www.ebay.co.uk/sch/i.html?_sacat=0&_from=R40&_nkw=lcd+16x2+Arduino&_sop=15

Em relação à questão de qual o dispositivo que deve ser integrado primeiro, penso que deve ser mais fácil integrar primeiro o LCD. Se não for assim, vai estar-se a fazer o código para a porta série (para por exemplo visualizar a data e hora) que posteriormente vai ter que ser adaptado para o LCD. Se for integrado em primeiro lugar o LCD, não vei ser preciso "deitar código para o lixo". Eu até penso, que devia ter sido integrado antes do teclado!

luisilva: Em relação à fase 3. Pode utilizar um LCD 16x2 (LCD alfa numérico de 2 linhas de 16 caracteres) são bastante fácies de usar, e penso que também devem ser os mais acessíveis

Olá Sr.Luis, deixe-me começar por agradecer a sua colaboração ;)

Sei que provavelmente já estou a abusar da sua disponibilidade, mas aqui fica mais uma pergunta se poder ser :roll_eyes: Procurei no ebay o LCD 16x2 e aparecem vários, uns têm um componente I2C e outros não, por qual devo optar? algum especifico que recomende?

Obg NJPinheiro

Não há problema. Se não quisesse ajudar, não escrevia post, não é?! Os LCD's com I2C basicamente permitem "poupar" pinos. Eles conseguem fazer com 2 pinos o mesmo que os outros fazem com 6. Como existem bibliotecas tanto para uma versão como para a outra, em termos de "dificuldade" na escrita do software, não deve existir grande diferença. Também em termos de preço, o LCD com o conversor I2C deve ser mais caro, mas a diferença não deve ser muito grande. Fazendo as contas ao número de pinos que tem que utilizar: 4 para os relés; 8 para o teclado; 2 para o RTC; dá 14 pinos. O Arduino UNO tem disponíves:

Digital I/O Pins 14 (of which 6 provide PWM output)

Sendo assim, à primeira vista, o meu conselho é, se quiser manter o UNO, deve utilizar o LCD com I2C, se não é indiferente.

Nesta altura deve estar a pensar, este tipo não sabe fazer contas, porque 14+2=16 e sendo assim, não se os pinos do UNO não chegam. No entanto, O RTC também utiliza o barramento I2C, e sendo assim, podem "compartir" os mesmos 2 pinos. Ainda digo mais. Se por acaso quiser acrescentar mais qualquer coisa ao projecto e precisar de mais pinos, pode também "pendurar" os relés no barramento I2C, utilizando por exemplo o IC PCF8584. Mesmo para o teclado, também se pode utilizar este IC: http://playground.arduino.cc/Main/I2CPortExpanderAndKeypads

Já agora, penso que também é o IC que é utilizado (pelo menos em alguns) dos adaptadores I2C para LCD.

luisilva: Os LCD's com I2C basicamente permitem "poupar" pinos. Eles conseguem fazer com 2 pinos o mesmo que os outros fazem com 6. Como existem bibliotecas tanto para uma versão como para a outra, em termos de "dificuldade" na escrita do software, não deve existir grande diferença.

o meu conselho é, se quiser manter o UNO, deve utilizar o LCD com I2C, se não é indiferente.

. No entanto, O RTC também utiliza o barramento I2C, e sendo assim, podem "compartir" os mesmos 2 pinos. Ainda digo mais. Se por acaso quiser acrescentar mais qualquer coisa ao projecto e precisar de mais pinos, pode também "pendurar" os relés no barramento I2C, utilizando por exemplo o IC PCF8584.

Acabei de encomendar o Arduino Mega, no código que postei tinha 4 reles, mas na realidade devo precisar de pelo menos 8 reles,, e a acrescentar a isto, (se conseguir ter bagagem para tal) ainda: - LCD - Relógio; - 2 electrovalvulas; - Medidor de Temperatura; - Sensor de nível de Agua;

E vamos ver se não invento mais qualquer coisa XD

Com o Arduino Mega acabaram-se os problemas de falta de portas :)

Isto não vai ser Pêra Doce, mas passo a passo, com muito estudo e com alguma ajuda :) espero chegar a bom porto :)

Quanto ao LCD estou a pensar neste: http://www.ebay.es/itm/Arduino-I2C-Serial-LCD-controller-with-16x2-Display-Module-TWI-IIC-controlador-/321450324433?pt=LH_DefaultDomain_186&hash=item4ad7eeb1d1&_uhb=1

Parece-lhe uma boas escolha?

Obg NJPinheiro

Sim, este LCD deve dar bem, mas para o MEGA, sendo assim, não é necessário ter I2C. Eu comprei sem I2C e custou-me, se não me engano cerca de 5€.

Comprei este:

http://www.ebay.es/itm/221483002068?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2649

PS: Estou mesmo a arranjar lenha para me queimar :blush:

Sim, esse parece-me bem. Isso é bastante simples de usar. As bibliotecas estão escritas, e há muito material na "net" com esquemas de ligações, exemplos, etc. Por exemplo este: http://arduino.cc/en/Tutorial/LiquidCrystal

Está tudo feito e explicado. Este está em inglês, mas também se arranja em português.

Obg Sr Luis, A sua ajuda tem sido preciosa neste processo!

Vou começar agora a pesquisar e ler sobre especificamente o LCD para saber "em que águas me cozo".

Dado o numero de pins que o LCD e o teclado juntos consomem, ( 6 e 8 respectivamente), vou ter mesmo que esperar pela chagada do Arduino Mega para tentar incorporar o LCD no programa que já tenho. Depois o passo seguinte vai ser "escrever" o menu de navegação, e aqui é que vão ser elas :drooling_face:

NJPinheiro

ola!
Enquanto não chega o LCD fui-me entretendo a escrever o programa para que apareça no serial monitor a acção incorrida a cada tecla que se pressionar, ficou assim:

#include <Password.h> 
#include <Keypad.h> 
Password password = Password( "1234" ); 
const byte ROWS = 4; //quatro linhas
const byte COLS = 4; //quatro colunas
//Define o Keypad (mapa do circuito do teclado).
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = { 9, 8, 7, 6 }; //ligar as linhas do teclado
byte colPins[COLS] = {12, 11, 10, 5}; //ligar as colunas do teclado

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int releHQI = 2;          
int releT8 = 3;          
int releMoonlight = 4;    
int releEscumador = 13;  


boolean estado = false;

void setup() {

  Serial.begin(9600);                                 
  pinMode(releHQI, OUTPUT);                   
  digitalWrite(releHQI, HIGH);                    
  pinMode(releT8, OUTPUT);                     
  digitalWrite(releT8, HIGH);                       
  pinMode(releMoonlight, OUTPUT);         
  digitalWrite(releMoonlight, HIGH);          
  pinMode(releEscumador, OUTPUT);        
  digitalWrite(releEscumador, HIGH);         
}

void loop() {
  char Key = keypad.getKey();
/************************Código para desbloqueio de teclado****************************/
  if (estado == false && Key != NO_KEY)                                        //verifica o estado do teclado
  {
    switch (Key) {
      case '*':  
        if (password.evaluate()) {                                                           // verifica se password introduzida é correcta
          Serial.println("Teclado desbloqueado");                                 // se sim imprime Teclado desbloqueado no serial monitor
          estado = true;}                                                                           // e activa o teclado
        break;
      case '#': password.reset(); break;                                                // se precionado # reseta password
      default: password.append(Key);
    }
  }
  else if (estado == true && Key != NO_KEY) {                              // se o teclado está activado, e foi precionada uma tecla
    //Serial.println(Key);                                                                      

/*******************Código para escrever no serial monitor************************/
if (Key)                                                                                               
    {
      switch (Key)
      {
        case '1' :                                                                                         
        if (digitalRead(releHQI) == HIGH)                                            
          { Serial.println("HQI ligada");                                                   
          } else
          { Serial.println("HQI desligada");                                           
          } break;
        case '2' :                                                                                         
          if (digitalRead(releT8) == HIGH)                                             
          { Serial.println("T8 ligada");                                                     
          } else
          { Serial.println("T8 desligada");                                               
          }break ;
          case '3' :                                                                                      
          if (digitalRead(releMoonlight) == HIGH)                               
          { Serial.println("Moonlight ligada");                                        
          } else
          { Serial.println("Moonlight desligada");                                 
          }break ;
           case 'A' :                                                                                     
          if ((digitalRead(releHQI) == HIGH) ||                                     
              (digitalRead(releT8) == HIGH) ||                                        
              (digitalRead(releMoonlight) == HIGH))                            
          { Serial.println("Calha ligada");                                                
          } else
          { Serial.println("Calha desligada");                                         
          } break;
          case '4' :                                                                                      
          if (digitalRead(releEscumador) == HIGH)                            
          { Serial.println("Escumador ligado");                                    
          } else
          { Serial.println("Escumador desligado");                                
          }break ;
        }
      }
   
    /**************Código para acção em função da tecla premida*************************/ 
    
    
    if (Key)                                                                                            
    {
      switch (Key)
      {
        case '1' :                                                                                       
          if (digitalRead(releHQI) == LOW)                                        // verifica se as Lâmpadas HQI estão desligadas
          { digitalWrite(releHQI, HIGH);                                               // se verdadeiro liga as Lâmpadas HQI
          } else
          { digitalWrite(releHQI, LOW);                                                // se falso desliga Lâmpadas HQI
          } break;                                                                                   
        case '2' :                                                                                      
          if (digitalRead(releT8) == LOW)                                           // verifica se as Lâmpadas T8 estão desligadas
          { digitalWrite(releT8, HIGH);                                                   // se verdadeiro liga as Lâmpadas T8
          } else
          { digitalWrite(releT8, LOW);                                                   // se falso desliga Lâmpadas T8
          } break;                                                                                      
        case '3' :                                                                                      
          if (digitalRead(releMoonlight) == LOW)                             // verifica se as Lâmpadas Moonlight estão desligadas
          { digitalWrite(releMoonlight, HIGH);                                     // se verdadeiro liga as Lâmpadas Moonlight
          } else
          { digitalWrite(releMoonlight, LOW);                                     // se falso desliga as Lâmpadas Moonlight
          } break;                                                                                      
        case 'A' :                                                                                      
          if ((digitalRead(releHQI) == HIGH) ||                                    // verifica se as Lâmpadas estão ligadas
              (digitalRead(releT8) == HIGH) ||                                        // verifica se as Lâmpadas estão ligadas
              (digitalRead(releMoonlight) == HIGH))                          // verifica se as Lâmpadas estão ligadas
          { digitalWrite(releHQI, LOW);                                                // se verdadeiro desliga as Lâmpadas HQI
            digitalWrite(releT8, LOW) ;                                                  // se verdadeiro desliga as Lâmpadas T8
            digitalWrite(releMoonlight, LOW);                                      // se verdadeiro desliga as Lâmpadas Moonlight
          } else
          { digitalWrite(releHQI, HIGH);                                               // se falso liga as Lâmpadas HQI
            digitalWrite(releT8, HIGH);                                                  // se falso liga as Lâmpadas T8
            digitalWrite(releMoonlight, HIGH);                                     // se falso liga as Lâmpadas Moonlight
          } break;
        case '4' :                                                                                      
          if (digitalRead(releEscumador) == LOW)                           // verifica se o Escumador está desligado
          { digitalWrite(releEscumador, HIGH);                                  // se verdadeiro liga o Escumador
          } else
          { digitalWrite(releEscumador, LOW);                                  // se falso desliga o Escumador
          } break;                                                                                    
        default:
          estado = false;
      }}}
}

O que pretendo saber é se depois para “escrever” no LCD 16x2 em vez de no serial monitor, em termos de codigo, (além de ter de indicar a coluna e linha onde ele vai começar a escrever), se é suficiente substituir “Serial.print” por “LCD.print” ?

PS: Desculpem se as perguntas são básicas, mas eu também ainda estou muito verde na matéria, (ainda só tenho 15 dias de pesquisa na net) :~

Infelizmente, no seu caso é! Passo a explicar, como não está a ter cuidado com o tamanho das strings que está a enviar, na altura que as for escrever para o LCD não lhe vão caber lá. O LCD apenas tem espaço para 16 caracteres por linha e não vai ficar muito bonito que as coisas apareçam com a maior parte do texto numa lina e depois 3 ou 4 letras na linha seguinte, pois não?!

exemplo:

Teclado desbloqu
eado

ou ainda pior, se estiver a escrever na linha de baixo (começar a escrever em 0, 1):

eado
Teclado desbloqu

Também pode pensar em substituir o Serial.println por outra coisa, por exemplo:

        if (password.evaluate()) {                                                           // verifica se password introduzida é correcta
          MostraInfo(TARGET, 0,0,"Teclado desbloqueado");    // se sim imprime Teclado desbloqueado no serial monitor
          estado = true;}                                                                           // e activa o teclado
        break;
      case '#': password.reset(); break;                                                // se precionado # reseta password
      default: password.append(Key);

onde, TARGET, pode ser uma constante ou um #define no inicio do programa, onde define LCD ou SERIAL, e conforme seja o valor desta constante, pode enviar a informação para um lado ou para o outro. No caso da SERIAL os valores seguintes seriam "dummy values", mas no caso do LCD serial as coordenadas X e Y do local onde começaria a escrever. Qualquer coisa como:

void MostraInfo(bool target, int X, int Y, char* message) {
   if (target == SERIAL) {
      Serial.println(message);
   }
   else {
      lcd.setCursor(X, Y);
      lcd.print(message);      
   }

E para já pode comentar até as linhas do LCD para não ter que estar a pensar nisso, sem ter aí "o bicho".

Os #define podem apenas ser uma coisa do género:

#define SERIAL 0
#define LCD 1

#define TARGET SERIAL

Quando tiver tudo pronto substitui:

#define TARGET LCD

É apenas uma ideia que me veio à cabeça assim que vi a pergunta, claro que não precisa de ser implementada para que tudo funcione depois (apenas deve ter atenção ao comprimento das mensagens).

Sr Luis, Help estou á nora :~ :~

Não sei se interpenetrei correctamente o seu post :(

A minha interpretação foi: 1 - introduzir no inicio do programa as definições:

#define SERIAL 0
#define LCD 1

#define TARGET SERIAL

2 - Substituir o Serial.println por outra coisa, ou seja, onde tenho:

if (password.evaluate()) {                   
          Serial.println("Teclado desbloqueado");    
          estado = true;}                           
        break;

Passaria a ter:

if (password.evaluate()) {                                                          
          MostraInfo(TARGET, 0,0,"Teclado desbloqueado");    
          estado = true;}                                                                          
        break;

3 - Verifica o que está activo, (Serial Monitor ou LCD) e mostra a mensagem no que estiver activo; Esta parte seria a acrescer ao código já escrito, seria onde estou a perguntar???

default: password.append(Key);
    }
  }
  else if (estado == true && Key != NO_KEY) {  
      
        .....SERIA AQUI???????????????    
       
  if (Key)                                           
    {
      switch (Key)
      {
        case '1' :

Será isto? É que já tentei e o programa não compila, dá o erro:

"Mostrainfo" was not declared in this scope

Onde é que eu estou a falhar?

Obg NJPinheiro

Os dois primeiros passos estão correctos. O último não. Para o último tem que copiar esta função:

void MostraInfo(bool target, int X, int Y, char* message) {
   if (target == SERIAL) {
      Serial.println(message);
   }
   else {
      lcd.setCursor(X, Y);
      lcd.print(message);      
   }
}

e colar antes da função setup().

Sr Luis, Já introduzi o código indicado antes do void setup e ao compilar ele parou na linha:

lcd.setCursor(X, Y);

Deu erro ao compilar:

"lcd" was not declared in this scope

tive de lhe introduzir indicação dos pinos do lcd, mas como ainda não o tenho, e também não tenho o Arduíno Mega, e já não tenho pinos que cheguem....inventei para conseguir compilar o programa e pus:

LiquidCrystal lcd(14,15,1,2,3,4);

Depois quando ligar o LCD é só uma questão de indicar os pinos correctos, certo?

luisilva: (...) E para já pode comentar até as linhas do LCD para não ter que estar a pensar nisso, sem ter aí "o bicho". (...)

Não é preciso definir o LCD e perder tempo com isso, basicamente, só tem que escrever a função da seguinte forma:

void MostraInfo(bool target, int X, int Y, char* message) {
   if (target == SERIAL) {
      Serial.println(message);
   }
   else {
      //lcd.setCursor(X, Y);
      //lcd.print(message);      
   }
}

A partir do momento em que se colocam as duas barras (juntas) o compilador ignora o que está a seguir. A isto chama-se comentário e serve basicamente, como o próprio nome indica para comentar o código, ou seja, para introduzir texto (em linguagem normal) que informa quem está a ler o programa do que foi feito. Esse texto é ignorado pelo compilador e sendo assim, normalmente também se usa para temporariamente "inutilizar" uma parte do programa.

Pois é coisas de maçarico, esqueci me das barras :astonished:

NJPinheiro