Come inserire codice serratura dall'esterno

[guidonetto]

Ciao, mi date dei suggerimenti per far funzionare una serratura elettronica?
Vorrei digitare il codice direttamente sul tastierino, salvarlo e sucessivamente richiamarlo per accendere il led su LATC0 (se il codice digitato è esatto).
Posto codice funzinante. Questo codice prevede che la sequenza dei tasti sia impostata nel programma (MplabX) , poi scaricata tramite programmatore nel PIC.
Grazie Guido

Codice: Seleziona tutto

/*Nota: codice tratto da settorezero, riadattato da: StefA, piu alfa75 e Guido*/

#include <xc.h>

#include "PIC18F4550_config.h"

#define  LCD_DEFAULT
#include "LCD_44780.h"
#include "LCD_44780.c"

#include "delay.h"
#include "delay.c"

#define  LED    LATCbits.LATC0

bit flag1=0;
bit flag2=0;
bit flag3=0;
bit flag4=0;

//*************************************
//     Prototipi di funzione
//*************************************
void board_initialization (void);
//void serratura_elettronica (void);

/* tastierino numerico collegato su PORTB
uso un tastierino 4x4 (16 pulsanti)
Per comodità ho collegato il tastierino in questo modo
(C=colonna R=riga)
R1 = RB1
R2 = RB3
R3 = RB5
R4 = RB7
C1 = RB0
C2 = RB2
C3 = RB4
C4 = RB6
I pin di riga saranno input ed attiveremo le resistenze di pullup interne
i pin di colonna saranno output e messi a 1 di default
*/

/* Definisco un array, che scansiona con un ciclo FOR, esso permette di mettere a massa
* le colonne una alla volta e riporta a livello logico alto le altre.
* Andando quindi dal valore colMask[0] al valore colMask[3], porto a massa le colonne una alla volta. */
unsigned char colMask[]=
   {
   0b11111110, // Colonna 1 => RB0 a massa
   0b11111011, // Colonna 2 => RB2 a massa
   0b11101111, // Colonna 3 => RB4 a massa
   0b10111111  // Colonna 4 => RB6 a massa
   };
unsigned char colScan=0; // va da 0 a 3 per scansionare l'array colMask

/* Definisco un array, che scansiona con un ciclo FOR, esso permette di mettere a massa
* le righe una alla volta e riporta a livello logico alto le altre.
* Andando quindi dal valore rowMask[0] al valore rowMask[3], porto a massa le righe una alla volta. */
unsigned char rowMask[]=
   {
   0b00000010, // Riga 1
   0b00001000, // Riga 2
   0b00100000, // Riga 3
   0b10000000  // Riga 4
   };
unsigned char rowScan=0; // va da 0 a 3 per scansionare l'array rowMask

//Array che contiene i simboli disegnati sui pulsanti del tastierino, disposti in un certo ordine:
unsigned char keys[16]={'1','4','7','*','2','5','8','0','3','6','9','#','A','B','C','D'};
unsigned char keypressed=0; // peso numerico del pulsante premuto
unsigned char keyok; // flag del pulsante premuto

unsigned char a;
unsigned char b;
unsigned char c;
unsigned char d;


//Numero da abbinare al tasto
/*tasto 1 numero 0; 4=1; 7=2; *=3; 2=4; 5=5; 8=6; 0=7; 3=8; 6=9; 9=10 #=11;
* A=12; B=13; C=14; D=15 */

//*************************************
//     Programma principale
//*************************************
int main (void){

//Assegnare numero tasto premuto meno uno (si conta anche lo zero).
//I numeri assegnati alle lettere fanno perte del codice segreto.
//Cambiare i numeri; ma non la sequenza delle lettere.
   
    a = 0;  //Tasto 1
    b = 3;  //Tasto *
    c = 2;  //Tasto 7
    d = 13; //Tasto B
   

   
    unsigned char frase [] = "   StefA TEST   ";

    // Abilita i resistori di pull-up sulla PORTB
    INTCON2bits.RBPU = 0x00;

    keyok=0;

    board_initialization ();

    //serratura_elettronica ();

    // Inizializzo il display LCD con quarzo a 20MHz
    LCD_initialize (20);

    LCD_backlight (LCD_TURN_ON_LED);

    LCD_write_message ("Tastiera Matrice");

    LCD_goto_line (2);

    LCD_write_string (frase);

    delay_s(2);

    LCD_clear();

    LCD_write_message ("Premere un tasto");

    // Ciclo infinito
    while(1) {
        /*Effettuo la scansione delle colonne contando da zero a 3 e metto i relativi
         *pin a livello logico basso uno alla volta, ripristinando a 1 gli altri facendo
         *uso dell?array colMask */
        for (colScan=0; colScan<4; colScan++) // porto a massa una colonna alla volta
        {
            PORTB=0xFF; // porto tutte le colonne a 1
            PORTB &= colMask[colScan]; // porto a zero la colonna attuale

        /*Effettuo la scansione delle righe contando da zero a 3 e metto i relativi
         *pin a livello logico basso uno alla volta, ripristinando a 1 gli altri facendo
         *uso dell?array rowMask */
            for (rowScan=0; rowScan<4; rowScan++) {
                /*Controllo se la riga attuale si trova a massa effettuando un AND
                 *con l?elemento dell?array rowScan che mi permette di verificare soltanto
                 *il bit che mi interessa su tutta la porta */
                if (!(PORTB & rowMask[rowScan])) // Riga rowScan trovata a massa
                {
                    delay_ms(200); //Ritardo spike
                    if (!(PORTB & rowMask[rowScan])) {
                        /*Se viene confermato che un pulsante è stato premuto, imposto
                         *il valore che permette di risalire al tasto e indico al programma
                         *che un pulsante è stato premuto */
                        keypressed=rowScan+(4*colScan); // numero del pulsante premuto
                        keyok=1; // è stato premuto un pulsante
                    }
                }
            } // fine scansione righe
        }//for // fine scansione colonne

        if (keyok) { // è stato premuto un pulsante
                   
            // Solo dopo che ho controllato in che punto si trova il
            // cursore posso piazzare il carattere premuto
            LCD_goto_line (2);           
            LCD_write_char(keys[keypressed]);

             
            if (keypressed == a){
             flag1=1;
            LCD_goto_line (2);
            LCD_write_message ("*");//Nascondo il carattere
            LATDbits.LATD0 = 1;//accendo led             
            }//if a
           
             if (keypressed == b && flag1==1){
         flag2=1;                   
            LCD_goto_line (2);
            LCD_write_message (" *");//Nascondo il carattere
            LATDbits.LATD0 = 1;//accendo led             
            }//if b

            if (keypressed == c && flag2==1){
         flag3=1;
            LCD_goto_line (2);
            LCD_write_message ("  *");//Nascondo il carattere
            LATDbits.LATD0 = 1;//accendo led
            }//if c

             if (keypressed == d && flag3==1){     
         flag4=1;       
            LCD_goto_line (2);
            LCD_write_message ("   *");//Nascondo il carattere           
            LATDbits.LATD0 = 1;//accendo led         
            }//if 12           
           
            if (flag1==1 && flag2==1 && flag3==1 && flag4==1){
       flag1=0;
        flag2=0;
        flag3=0;
        flag4=0;
      
        LCD_goto_line (2);
        LCD_write_message ("esatto");
         LED=1;         
        //delay_ms(500);//Tempo attivazione led/porta
         delay_s(2);
        LED=0;       
          }                 
           
            keyok=0; // resetto il flag del pulsante premuto

            // rimango in un ciclo continuo fino a che il pulsante non viene rilasciato
            PORTB=0b10101010;
            while(PORTB != 0b10101010)
                /*Se voglio che i simboli visualizzati siano senpre visibili sul
                 display (cioè cambino alla pressione del tasto) omettere:
                 LCD_goto_line (2);
                 LCD_write_message ("      ");*/
                LCD_goto_line (2);
            //delay_s(1);  //determino per quanto tempo voglio visualizzare il simbolo
             delay_ms(800);
             LCD_write_message ("         ");
        }//if (keyok)

        else{ //messo prima di keyok=0; dopo aver eseguito l'ultima variabile rimane acceso fisso il led LATC0
         LATDbits.LATD0 = 0;//Spengo led
         LATCbits.LATC0 = 0;//Spengo led         
        }//else       
    }//while(1)
}//main


//*************************************
//     Implementazione della funzione
//*************************************
void board_initialization (void) {
//******************//
//Impostazione porte//
//******************//
   // Imposto PORTA tutti ingressi
   LATA = 0x00;
   TRISA = 0xFF;

   // Imposto PORTB
   LATB = 0x00;
   TRISB = 0b10101010;

   // Imposto PORTC tutti ingressi e RC1 e RC0 come uscita
   LATC = 0x00;
   TRISC = 0b11111100;

   // Imposto PORTD tutte uscite
   LATD = 0x00;
   TRISD = 0x00;

   // Imposto PORTE tutti ingressi
   LATE = 0x00;
   TRISE = 0xFF;
}//void board_initialization (void)




[WALTERmwp]

Ciao guidonetto, per fare quello che mi pare tu intenda manca un po di software.
Per non complicare ulteriormente lo sviluppo, per ora escluderei la ricerca dell'effetto ritentivo del codice_serratura (c_s).

Prima, comunque, mi permetto di muoverti una osservazione: non so se sia dovuto alla scrittura all'interno del Post ma, se non dovesse essere per questo, ti suggerisco di indentare il codice in modo leggibile.
L'ho dovuto/voluto fare io in editor per avere certezza di quanto fosse riportato.

Se, quanto hai/avete sviluppato sino ad ora vi funziona, dovreste, da qui in avanti, strutturare il codice per:
i) definire una condizione (uno stato) nella quale si inserisce il c_s con tutte le verifiche/conseguenze del caso; una parte di quello che occorre lo avete scritto ma dovreste introdurre alcuni controlli
ii) definire una condizione alla quale si accede, magari solo dopo avere digitato il c_s, per poterlo modificare
iii) definire una condizione che vi consenta, quando lo si desidera, di effettuare il log-off che, ovviamente, può avvenire solo dopo il log-in.

Sembra poca cosa ma, considerato come e quanto hai proposto, immagino avrai il tuo da fare per implementare (i) e (ii).
Anche dare una soluzione al punto (iii) può impegnarti: tu ad esempio come lo faresti ?

In generale, considera che dovresti lavorare su più gruppi di variabili ( ... del tipo a,b,c,d).
Non è nulla di difficile; lo diventa se non dai ordine a quello che ti proponi di fare.
Ti suggerisco quindi di pensarci bene prima di procedere il che equivale chiarirsi le idee descrivendo (e scrivendo), come fosse una specifica funzionale, quanto poi andrai a tradurre in linguaggio "C".

Saluti

[guidonetto]

Ti ringrazio, per la risposta provo a fare come mi hai suggerito.
Ciao Guido

[aldofad]

Se vuoi spassartela puoi dare un'occhiata alla mia vecchia tesi di laurea proprio su una serratura elettronica.
Niente di sofisticato... Non aspettarti chissà che.
http://www.scribd.com/doc/88190668/Tesi-centralina-di-controllo-per-serrature#scribd
https://www.youtube.com/watch?v=K6dU4a6QJuk
https://www.youtube.com/watch?v=Vv3WsPQmR-w