Servo + teclado matricial com arduino

[Juliana Batista da Silva]

Bom galera vou direto ao ponto porque tenho um projeto para entregar em menos de uma semana na faculdade com o arduino  e estou fazendo uma fechadura eletrônica que abre a porta por batidas secretas e também por senha através do teclado matricial, o servo é para abrir a fechadura só que ele não está funcionando, já fiz um teste controlando ele pelo potenciômetro e tá funcionando normal. Será o código? Por falar em código vou deixar ele aqui, mas aviso logo que tá bem grandinho, a parte do sensor eu peguei de um cara na net vou deixar o site dele aqui também. Ah e só pra avisar só iniciante no mundo do arduino, então se puderam explicar da forma mais simples possível agradeço. falou... paz .

 

Site do cara  -> http://grathio.com/2009/11/secret_knock_detecting_door_lock/

 

#include <Keypad.h>
#include <Servo.h>
 
Servo servo; //SERVO
char* password = "123"; //SENHA TECLADO
int position = 0; //POSIÇÃO TECLAS PRESSIONADAS
const byte ROWS = 4; //NUMERO DE LINHAS DO TECLADO
const byte COLS = 3; //NUMERO DE COLUNAS DO TECLADO
char keys[ROWS][COLS] = { //DECLARAÇÃO TIPO DO TECLADO
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
 
byte rowPins[ROWS] = { 5, 4, 3, 2 }; // PINOS LINHAS DO TECLADO
byte colPins[COLS] = { 8, 7, 6, }; //PINOS COLUNAS DO TECLADO
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
 
 
// Pin definitions
const int knockSensor = 0;         // Piezo sensor on pin 0.
const int programSwitch = 13;       // If this is high we program a new code.
const int redLED = 11;              // Status LED
const int greenLED = 12;            // Status LED
const int butclose = 9;
 
// Tuning constants.  Could be made vars and hoooked to potentiometers for soft configuration, etc.
const int threshold = 3;           // Minimum signal from the piezo to register as a knock
const int rejectValue = 25;        // If an individual knock is off by this percentage of a knock we don't unlock..
const int averageRejectValue = 15; // If the average timing of the knocks is off by this percent we don't unlock.
const int knockFadeTime = 150;     // milliseconds we allow a knock to fade before we listen for another one. (Debounce timer.)
const int lockTurnTime = 650;      // milliseconds that we run the motor to get it to go a half turn.

const int maximumKnocks = 20;       // Maximum number of knocks to listen for.
const int knockComplete = 1200;     // Longest time to wait for a knock before we assume that it's finished.


// Variables.
int secretCode[maximumKnocks] = {50, 25, 25, 50, 100, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};  // Initial setup: "Shave and a Hair Cut, two bits."
int knockReadings[maximumKnocks];   // When someone knocks this array fills with delays between knocks.
int knockSensorValue = 0;           // Last reading of the knock sensor.
int programButtonPressed = false;   // Flag so we remember the programming button setting at the end of the cycle.

void setup() {
  pinMode (butclose, INPUT);
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(programSwitch, INPUT);
  servo.attach(9); //PINO DE CONTROLE DO SERVO MOTOR
  Serial.begin(9600);                     // Uncomment the Serial.bla lines for debugging.
  Serial.println("Program start.");       // but feel free to comment them out after it's working right.
  
  digitalWrite(greenLED, HIGH);      // Green LED on, everything is go.
}

void loop() {

  char key = keypad.getKey(); //LEITURA DAS TECLAS PRESSIONADAS 
  if (key == '*' || key == '#') { //SE A TECLA PRESSIONADA POR IGUAL A CARACTERE "*" OU "#", FECHADURA TRANCADA
      servo.write(0); 
}
if (key == password[position]){ //SE A TECLA PRESSIONADA FIZER PARTE DA SENHA, PULA PARA A PROXIMA POSIÇÃO
      position ++;
}
if (position == 3){ // SE O VALOR DA VARIAVEL POSIÇÃO FOR IGUAL A 3, QUANTIDADE DE NUM DA SENHA, SENHA ESTÁ CORRETA, ABRE A FECHADURA E RESETA A POSIÇÃO.
      servo.write(100);
      position = 0; 
}
delay(100);
  
  // Listen for any knock at all.
  knockSensorValue = analogRead(knockSensor);
  
  if (digitalRead(programSwitch)==HIGH){  // is the program button pressed?
    programButtonPressed = true;          // Yes, so lets save that state
    digitalWrite(redLED, HIGH);           // and turn on the red light too so we know we're programming.
  } else {
    programButtonPressed = false;
    digitalWrite(redLED, LOW);
  }
  
  if (knockSensorValue >=threshold){
    listenToSecretKnock();
  }
} 


// Records the timing of knocks.
void listenToSecretKnock(){
  Serial.println("knock starting");   

  int i = 0;
  // First lets reset the listening array.
  for (i=0;i<maximumKnocks;i++){
    knockReadings[i]=0;
  }
  
  int currentKnockNumber=0;               // Incrementer for the array.
  int startTime=millis();                 // Reference for when this knock started.
  int now=millis();
  
  digitalWrite(greenLED, LOW);            // we blink the LED for a bit as a visual indicator of the knock.
  if (programButtonPressed==true){
     digitalWrite(redLED, LOW);                         // and the red one too if we're programming a new knock.
  }
  delay(knockFadeTime);                                 // wait for this peak to fade before we listen to the next one.
  digitalWrite(greenLED, HIGH);  
  if (programButtonPressed==true){
     digitalWrite(redLED, HIGH);                        
  }
  do {
    //listen for the next knock or wait for it to timeout. 
    knockSensorValue = analogRead(knockSensor);
    if (knockSensorValue >=threshold){                   //got another knock...
      //record the delay time.
      Serial.println("knock.");
      now=millis();
      knockReadings[currentKnockNumber] = now-startTime;
      currentKnockNumber ++;                             //increment the counter
      startTime=now;          
      // and reset our timer for the next knock
      digitalWrite(greenLED, LOW);  
      if (programButtonPressed==true){
        digitalWrite(redLED, LOW);                       // and the red one too if we're programming a new knock.
      }
      delay(knockFadeTime);                              // again, a little delay to let the knock decay.
      digitalWrite(greenLED, HIGH);
      if (programButtonPressed==true){
        digitalWrite(redLED, HIGH);                         
      }
    }

    now=millis();
    
    //did we timeout or run out of knocks?
  } while ((now-startTime < knockComplete) && (currentKnockNumber < maximumKnocks));
  
  //we've got our knock recorded, lets see if it's valid
  if (programButtonPressed==false){             // only if we're not in progrmaing mode.
    if (validateKnock() == true){
      triggerDoorUnlock(); 
    } else {
      Serial.println("Secret knock failed.");
      digitalWrite(greenLED, LOW);      // We didn't unlock, so blink the red LED as visual feedback.
      for (i=0;i<4;i++){          
        digitalWrite(redLED, HIGH);
        delay(100);
        digitalWrite(redLED, LOW);
        delay(100);
      }
      digitalWrite(greenLED, HIGH);
    }
  } else { // if we're in programming mode we still validate the lock, we just don't do anything with the lock
    validateKnock();
    // and we blink the green and red alternately to show that program is complete.
    Serial.println("New lock stored.");
    digitalWrite(redLED, LOW);
    digitalWrite(greenLED, HIGH);
    for (i=0;i<3;i++){
      delay(100);
      digitalWrite(redLED, HIGH);
      digitalWrite(greenLED, LOW);
      delay(100);
      digitalWrite(redLED, LOW);
      digitalWrite(greenLED, HIGH);      
    }
  }
}


// Runs the motor (or whatever) to unlock the door.
void triggerDoorUnlock(){
  Serial.println("Door unlocked!");
  int i=0;
  
  // turn the motor on for a bit.
  servo.write(100);
  digitalWrite(greenLED, HIGH);            // And the green LED too.
  
  delay (lockTurnTime);                    // Wait a bit.
  
  // Blink the green LED a few times for more visual feedback.
  for (i=0; i < 5; i++){   
      digitalWrite(greenLED, LOW);
      delay(100);
      digitalWrite(greenLED, HIGH);
      delay(100);
  }
   
}

// Sees if our knock matches the secret.
// returns true if it's a good knock, false if it's not.
// todo: break it into smaller functions for readability.
boolean validateKnock(){
  int i=0;
 
  // simplest check first: Did we get the right number of knocks?
  int currentKnockCount = 0;
  int secretKnockCount = 0;
  int maxKnockInterval = 0;               // We use this later to normalize the times.
  
  for (i=0;i<maximumKnocks;i++){
    if (knockReadings[i] > 0){
      currentKnockCount++;
    }
    if (secretCode[i] > 0){           //todo: precalculate this.
      secretKnockCount++;
    }
    
    if (knockReadings[i] > maxKnockInterval){   // collect normalization data while we're looping.
      maxKnockInterval = knockReadings[i];
    }
  }
  
  // If we're recording a new knock, save the info and get out of here.
  if (programButtonPressed==true){
      for (i=0;i<maximumKnocks;i++){ // normalize the times
        secretCode[i]= map(knockReadings[i],0, maxKnockInterval, 0, 100); 
      }
      // And flash the lights in the recorded pattern to let us know it's been programmed.
      digitalWrite(greenLED, LOW);
      digitalWrite(redLED, LOW);
      delay(1000);
      digitalWrite(greenLED, HIGH);
      digitalWrite(redLED, HIGH);
      delay(50);
      for (i = 0; i < maximumKnocks ; i++){
        digitalWrite(greenLED, LOW);
        digitalWrite(redLED, LOW);  
        // only turn it on if there's a delay
        if (secretCode[i] > 0){                                   
          delay( map(secretCode[i],0, 100, 0, maxKnockInterval)); // Expand the time back out to what it was.  Roughly. 
          digitalWrite(greenLED, HIGH);
          digitalWrite(redLED, HIGH);
        }
        delay(50);
      }
    return false;   // We don't unlock the door when we are recording a new knock.
  }
  
  if (currentKnockCount != secretKnockCount){
    return false; 
  }
  
  /*  Now we compare the relative intervals of our knocks, not the absolute time between them.
      (ie: if you do the same pattern slow or fast it should still open the door.)
      This makes it less picky, which while making it less secure can also make it
      less of a pain to use if you're tempo is a little slow or fast. 
  */
  int totaltimeDifferences=0;
  int timeDiff=0;
  for (i=0;i<maximumKnocks;i++){ // Normalize the times
    knockReadings[i]= map(knockReadings[i],0, maxKnockInterval, 0, 100);      
    timeDiff = abs(knockReadings[i]-secretCode[i]);
    if (timeDiff > rejectValue){ // Individual value too far out of whack
      return false;
    }
    totaltimeDifferences += timeDiff;
  }
  // It can also fail if the whole thing is too inaccurate.
  if (totaltimeDifferences/secretKnockCount>averageRejectValue){
    return false; 
  }
  
  return true;
  
}

 

[Visitante]

2 minutos atrás, Juliana Batista da Silva disse:

abre a porta por batidas secretas

Muito legal ^^

 

Pergunta básica:

Sobre o código... você já tentou fazer o mais simples tentar movimentar o servo simplesmente... sem ifs e nem nada... só mudar a posição dele a partir do comando da biblioteca Servo?

https://www.arduino.cc/en/Reference/ServoWrite

 

O ruim que você fala que é novato, mas vem um um código e grande em inglês... ou seja, você ainda nem tentou modificar o código para o que você quer ou verificou para que cada parte serve... complicado.

[Juliana Batista da Silva]

5 minutos atrás, Bommu Perneta disse:

Muito legal ^^

 

Pergunta básica:

Sobre o código... você já tentou fazer o mais simples tentar movimentar o servo simplesmente... sem ifs e nem nada... só mudar a posição dele a partir do comando da biblioteca Servo?

https://www.arduino.cc/en/Reference/ServoWrite

 

O ruim que você fala que é novato, mas vem um um código e grande em inglês... ou seja, você ainda nem tentou modificar o código para o que você quer ou verificou para que cada parte serve... complicado.

Cara, a única parte que eu peguei da net, como eu disse anteriormente, foi a parte do sensor porque realmente não sei nada dessa parte, mas falando de somente mudar a posição do servo sem os if's, como farei isso se preciso verificar primeiro se a senha está correta ou não? não posso simplesmente movimentar o servo a 0 ou 90 graus , ele tem que se mover se e somente se a senha do teclado ou das batidas estiverem corretas.

[Visitante]

você fez o teste ou não? Pois no texto você fala que não sabe se ta funcionando, só usou com potenciômetro e tal... Eu quero saber se está funcionando o servo, você sabe usar o básico dele. Depois disso passamos para o código. ^^

adicionado 7 minutos depois

http://www.instructables.com/id/Sweep-Servo-Motor-With-Arduino-Nano/

 

Porque servo com potenciômetro e sem potenciômetro e` diferente o código...

 

Mas se quiser esperar por outra pessoa `a vontade X)

 

 

fuizzzzzzzzzzzzzzzzzzzzzzzz