no..infatti il MFRC522 init è posto insieme al openoffice..quindi se non è in modalità open il lettore manco viene attivato..per scrupolo l'ho riprovato a caricarlo ora con il close alle 23 e non legge nessuna tessera.. 
xilav:
Scusa, ma non ho fatto a meno di guardare il tuo codice, ma mi sembra che anche se sono le 2 di notte ed esegui la closeOffice(), se passo il tag corretto apro lo stesso la porta. E' voluto?
Grazie ancora Guglielmo spero non te la sia presa per gli altri commenti 
imparerò a guardare bene prima di esprimermi..mi dici la differenza in poche parole tra || e &&?
grazie
gpb01:
if ((h == 0) || (h >= 7)) openOffice();
else closeOffice();Se la esamini bene la IF chiede prima se h è uguale a zero, oppure si chiede se h è uguale o maggiore di 7 (7, 8, 9, ... 23) ed in tal caso chiama openOffice(), altrimenti, per gli altri casi (1, 2, 3, 4, 5, 6) chiama closeOffice().
Guglielmo
Premetto che non conosco il lettre RFID per cui vado ad intuizione:
la Init() serve per inizializzare il lettore per cui basterebbe che sia chiamata una sola volta, è corertto?
Se la mia ipotesi fosse corretta pensa questo scenario:
Sono le 23:59 -> Chiamo OpenOffice() -> inizializzo il RFID -> passo il tag e apro la porta
... intanto la toutine di loop() continua a girare...
Sono le 00:15 -> Chiamo CloseOffice() -> NON chiamo l'inizializzazione del RFID ma tanto non serve perchè lo avevo già inizializzato alle 23:59 -> passo il tag e apro lo stesso la porta
Hai provato questo scenario?
|| sta per OR logico
se una condizione è soddisfatta OPPURE un'altra è soddisfatta
&& sta per AND logico
se una condizione è soddisfatta E ANCHE un'altra è soddisfatta
da non confondere con | e &
che sono rispettivamente l'OR e l'AND binario
ad esempio
**__ <strong>**byte myByte = 0b00110011 & 0b00011111; // qui & (uno solo!) effettua l'AND binario, per cui myByte varrà 0b00010011**</strong> __**
capisco cosa dici..allora ti spiego..la init era sul setup..quindi di logica il programma impostava l'attivazione del rfid appena viene alimentato arduino per poi rimanere acceso a prescindere dal loop.
Bene io con molta pazienza chirurgica ho preso lo sketch d'esempio della libreria e togliendo pezzo per pezzo ho capito qual'era la funzione che lo attivava ed è appunto quella init..quindi l'ho tolta dal setup e inserita nella funzione di interesse.
il codice di if và sull'ora..quindi se sono le 23.50 e l'open è vero se sono le 23 in loop scrive l'orologio e mantiene il rfid attivo..mentre appena scattano le 00 è l'open è falso passa in close..il close scrive system locked ma non ha all'interno la funzione int che attiva l'rfid quindi non legge nessuna tessera..
magari l'ho spiegato male o chissa altro..ma io lo stò testando qui davanti e non legge nessuna tessera se è in modalità closeoffice.
Sicuramente non ne giova di lettura al volo rispetto a un int impostato nel setup..ma fà il suo sporco lavoro
comunque grazie a tutti finalmente dopo 1 mese sono riuscito a fare il mio primo programmino..ora preparerò il cad per stamparlo con la 3d.
xilav:
Premetto che non conosco il lettre RFID per cui vado ad intuizione:la Init() serve per inizializzare il lettore per cui basterebbe che sia chiamata una sola volta, è corertto?
Se la mia ipotesi fosse corretta pensa questo scenario:
Sono le 23:59 -> Chiamo OpenOffice() -> inizializzo il RFID -> passo il tag e apro la porta
... intanto la toutine di loop() continua a girare...
Sono le 00:15 -> Chiamo CloseOffice() -> NON chiamo l'inizializzazione del RFID ma tanto non serve perchè lo avevo già inizializzato alle 23:59 -> passo il tag e apro lo stesso la portaHai provato questo scenario?
Attenzione! Il codice in setup() viene chiamato una sola volta all'accensione del sistema, poi Arduino chiama ciclicamente la loop().
La init serve per inizializzare la comunicazione ed è necessaria una sola volta, poi la comunicazione è sempre attiva.
Fai per favore la controprova; imposta l'RTC alle 23.58 e passa l'RFID, poi aspetta che l'orologio segni le 00:01 e ripassa l'RFID. Dimmi se alle 00:01 ha aperto la porta...
hai presente quando fai una cosa ma non sai come rifarla da capo? ahahha se ti dico che quando passa in system locked non legge nessun tag va bene? o faccio la controprova? (però devi darmi un attimo di tempo xD)
xilav:
Attenzione! Il codice in setup() viene chiamato una sola volta all'accensione del sistema, poi Arduino chiama ciclicamente la loop().
La init serve per inizializzare la comunicazione ed è necessaria una sola volta, poi la comunicazione è sempre attiva.
Fai per favore la controprova; imposta l'RTC alle 23.58 e passa l'RFID, poi aspetta che l'orologio segni le 00:01 e ripassa l'RFID. Dimmi se alle 00:01 ha aperto la porta...
Sicuramente mi sarò sbagliato; te l'ho scritto solo perchè mi ha assalito il dubbio di quella possibilità: provarlo non costa nulla (a parte il tempo perso) e comunque è l'unico modo per essere sicuri che il sistema funzioni correttamente eheheheh.. se poi ho sbagliato, allora ti devo una birra
allora adesso ho impostato alle ore 00 open office e alle ore 01 close office.. se è come dici all'una di notte rimane comunque attivo? all'una ti scrivo sul funzionamento
xilav:
TI DEVO UNA BIRRA IO!! 
si vede che facendo prove statiche partendo già in lock non dava questo problema..come posso fare?
xilav:
La soluzione più velòoce è:
...l'implementazione la lascio fare a te; logicamente rifai tutti i test per i vari scenari al fine di controllare che tutto sia a posto
Ciao!
Grazie Xilav..stasera lo provo..comunque ho capito che serve un operatore booleano che in caso di true legge il tag..in caso di false il rfid è attivo ma non legge nessun tag..corretto??
stasera e finchè non riuscirò provero!! a presto!!
grazie ancora!!
ps.sta birra quando ce la facciamo??
xilav:
La soluzione più velòoce è:
- Rimettere la mfrc522.PCD_Init() della NFC nel Setup() (dove dovrebbe stare)
- Creare una variabile globale di tipo bool (es: bool bSystemLocked;)
A questo punto il bSystemLocked verrà impostato true in CloseOffice() ed a false in OpenOffice()- Nel codice di check della NFC controllo anche la variabile bSystemLocked:
- Se la NFC è trovata allora controllo se bSystemLocked è false. Se è false sblocco la porta.
- In uscita del blocco di check delle tags se la variabile controllo è false oppure bSystemLocked è a true allora visualizzo il messaggio di 'Non consentito' (alternativamente in questo secondo caso controllo solo se la variabile conrtrrollo è a false, cosa che hai già fatto, per cui se sei in CloseOffice() non visualizzo il 'Non consentito' lampeggiante oltre al testo standard di 'System Locked' che hai già impostato)
...l'implementazione la lascio fare a te; logicamente rifai tutti i test per i vari scenari al fine di controllare che tutto sia a posto
Ciao!
allego il codice rifatto..in questo modo quando passa a System Locked il rfid è attivo ma non attiva la funzione Open Door e restituisce "non consentito" sia con NFC sconosciuta e conosciuta..devo capire bene come funzionano i booleani..ma comunque grazie Xilav!!
#include <DS1302RTC.h> //includo libreria rtc
#include <Time.h> //includo libreria gestione time
#include <SPI.h> // includo libreria spi
#include <MFRC522.h> //includo libreria lettore rfid
#include <LiquidCrystal_I2C.h> //libreria lcd I2C
#include <Wire.h> //includo libreria wire
#define SS_PIN 6 //definisco i pin rfid
#define RST_PIN 7 // definisco pin reset rfid
LiquidCrystal_I2C mylcd(0x38, 16, 2); // setto il display
DS1302RTC RTC(10, 9, 8); // setto pin RTCD
MFRC522 mfrc522(SS_PIN, RST_PIN); // setto e creo l'istanza rfid
long previousMillis = 0; //variabili tempo rfid
long interval = 10;
bool bSystemLocked;
int rele = 2; //pin relè
int buzzer = 3; //pin buzzer
int hour() ; //variabile tempo
String uidRFID[] = {"b34cdcc7", "codeRFID_B", "codeRFID_C", "codeRFID_D"}; // tag abilitati (da modificare con i tag di interesse)
byte locked[8] = {B00000, B01110, B10001, B10001, B11111, B11111, B11111, B00000}; // creo carattere speciale
byte Clock[8] = {B00000, B01110, B10011, B10101, B10001, B01110, B00000, B00000};
void setup() {
mylcd.begin(); //inizializzo lcd
mylcd.backlight(); //abilito retroilluminazione
mylcd.createChar(0, locked); //creo carattere speciale e imposto la sua assegnazione a 0
mylcd.createChar(1, Clock);
SPI.begin(); // Inizializzo SPI
mfrc522.PCD_Init(); // Inizializzo MFRC522
pinMode(rele, OUTPUT); //imposto il pin del rele come output
mylcd.clear(); //pulisco display
if (RTC.haltRTC()) { //ciclo di controllo sul rtc se attivo
mylcd.print("Clock stopped!");
}
else {
mylcd.print("Clock working.");
}
mylcd.setCursor(0, 1);
if (RTC.writeEN()) { //controllo rom rtc
mylcd.print("Write allowed.");
}
else {
mylcd.print("Write protected.");
}
delay ( 2000 ); //attendo
// Setup Time libreria
mylcd.clear();
mylcd.print("RTC Sync");
setSyncProvider(RTC.get); // acquisisco i dati dal rtc e verifico
if (timeStatus() == timeSet) {
mylcd.print(" Ok!");
}
else {
mylcd.print(" FAIL!");
}
delay ( 2000 );
mylcd.clear();
}
void loop() {
mylcd.setCursor(2, 0);
mylcd.print("STUDIO GLOBAL");
if (timeStatus() != timeSet) {
mylcd.setCursor(0, 1);
mylcd.print(F("RTC ERROR"));
}
int h = hour();
if ((h == 23) || (h >= 7))
{
openOffice();
}
else
{
closeOffice();
}
unsigned long currentMillis = millis();
if (currentMillis - previousMillis > interval) {
previousMillis = currentMillis;
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial()) {
return;
}
String uid_s = "";
if (!mfrc522.PICC_IsNewCardPresent() && !mfrc522.PICC_ReadCardSerial()) {
for (byte i = 0; i < mfrc522.uid.size; i++) {
String uid_a = String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : "");
String uid_b = String(mfrc522.uid.uidByte[i], HEX);
uid_s = uid_s + uid_a + uid_b;
}
}
boolean controllo = false;
if(!bSystemLocked){
for (int i = 0; i < sizeof(uidRFID) / sizeof(String); i++)
if (uidRFID[i] == uid_s) {
mylcd.setCursor(3, 1);
mylcd.print("Consentito");
tone(buzzer, 800, 100);
delay(500);
openDoor();
controllo = true;
bSystemLocked = false;
break;
}
}
if (!controllo) {
mylcd.setCursor(0, 1);
mylcd.print("!Non Consentito!");
tone(buzzer, 800, 500);
displayBlink(3, 400);
delay(2000);
}
mylcd.clear();
}
mylcd.clear();
}
void openDoor() {
digitalWrite(rele, HIGH);
delay(2000);
digitalWrite(rele, LOW);
}
void print2digits(int number) {
// Output leading zero
if (number >= 0 && number < 10) {
mylcd.write('0');
}
mylcd.print(number);
}
void openOffice() {
mylcd.setCursor(3, 1);
mylcd.write(1);
mylcd.setCursor(4, 1);
mylcd.print("");
print2digits(hour());
mylcd.print(":");
print2digits(minute());
mylcd.print(":");
mylcd.print(second());
bSystemLocked = false;
}
void closeOffice() {
mylcd.setCursor(1, 1);
mylcd.write(0);
mylcd.setCursor(2, 1);
mylcd.print("System Locked");
bSystemLocked = true;
}
void displayBlink(int blinks, int duration)
{
while (blinks--)
{
mylcd.noDisplay();
delay(duration);
mylcd.display();
delay(duration);
}
}
Benissimo!
Ciao!
P.S. giusto un appunto; ne codice che hai scritto
if(!bSystemLocked){ // <-- Entro solo se bSystemLocked è a false
for (int i = 0; i < sizeof(uidRFID) / sizeof(String); i++)
if (uidRFID[i] == uid_s) {
mylcd.setCursor(3, 1);
mylcd.print("Consentito");
tone(buzzer, 800, 100);
delay(500);
openDoor();
controllo = true;
bSystemLocked = false; // <-- Non necessario
break;
}
}
quel bSystemLocked = false; non è necessario, in quanto quel blocco di codice viene eseguito solo se bSystemLocked è false
(nella riga if(!bSystemLocked){).
Logicamente non comporta nessun problema nel funzionamento, ma è ridondante.
Ciao!
Grazie di tutto...ti devo una damigiana di birra!!
xilav:
Benissimo!Ciao!
P.S. giusto un appunto; ne codice che hai scritto
if(!bSystemLocked){ // <-- Entro solo se bSystemLocked è a false
for (int i = 0; i < sizeof(uidRFID) / sizeof(String); i++)
if (uidRFID[i] == uid_s) {
mylcd.setCursor(3, 1);
mylcd.print("Consentito");
tone(buzzer, 800, 100);
delay(500);
openDoor();
controllo = true;
bSystemLocked = false; // <-- Non necessario
break;
}
}
quel *bSystemLocked = false;* non è necessario, in quanto quel blocco di codice viene eseguito solo se bSystemLocked è false (nella riga *if(!bSystemLocked){*). Logicamente non comporta nessun problema nel funzionamento, ma è ridondante. Ciao!