buzzer

salve a tutti, sto cercando di famigliarizzare con un pulsante, un buzzer e arduino nano. Dopo tanti esempi trovati sui forum non ci sono problemi a farlo suonare al premere del pulsante, ma prova e riprova non riesco a fare questa sequenza: premo il pulsante, il buzzer suona per il tempo impostato e non suona più fino a che non rilascio il pulsante e lo ripremo. chi mi puo aiutare? appena sono davanti al pc vi faccio vedere lo sketh che ho creato Grazie

vi posto lo sketch

const int pulsante = 7;     // pulsante 
int Buzzer = 6;              //buzzer

int pulsanteState = 0;         // variabile per leggere lo stato del pulsante

void setup() 
{
pinMode(Buzzer, OUTPUT);      //dichiaro il pin del buzzer
pinMode(pulsante, INPUT);     //dichiaro il pin del pulsante
}

void loop(){
  
pulsanteState = digitalRead(pulsante); //leggo lo stato del valore del pulsante
  
if (pulsanteState == HIGH)               //  controllo lo stato del pulsante
{     
tone(Buzzer,3500,500);
delay(500);
}
}

Invece di testare il livello letto dall'ingresso (che rimane fisso finché il pulsante rimane premuto), va testata la variazione confrontando la lettura attuale dell'ingresso con la precedente salvata in una variabile. Se c'è variazione e il livello attuale è premuto, allora abbiamo rilevato il momento della pressione, e possiamo dare il via a quello che serve. Naturalmente ad ogni giro la variabile precedente va attualizzata con la lettura attuale, che diventa la precedente per il prossimo giro.

non ne vengo a capo

I pin in input di Arduino (quelli collegati ai pulsanti) non possono essere lasciati scollegati, altrimenti captano sporcizia elettromagnetica e cambiano lo stato HIGH o LOW a casaccio. Un pulsante aperto (non premuto) è equivalente a pin scollegato. Per questo motivo occorre mettere una resistenza da una decina di kOhm fra il pin e GND se il pulsante è posto fra il pin e il +5V (attivo HIGH quando premuto, LOW quando rilasciato).

Per rendere più semplici i programmi con i pulsanti conviene utilizzare la funzione dell'Arduino che consente di ancorare al livello HIGH il pin del pulsante attraverso l'istruzione "pinMode(mioPin, INPUT_PULLUP);". Quindi la condizione normale del pin sarà HIGH, mentre a pulsante premuto diventerà LOW. Così non ci sono resistenze in giro e il pulsante è posto fra il pin e GND. Il tuo setup diventa quindi:

void setup()
{
pinMode(Buzzer, OUTPUT);      //dichiaro il pin del buzzer
pinMode(pulsante, INPUT_PULLUP);     //dichiaro il pin del pulsante
}

Altro problema con i pulsanti è il rimbalzo dei contatti (bounce) che va contrastato con appositi accorgimenti. Ce ne sono molti. Per tua informazione chiedi a Google: debounce arduino.

Per il programma che vuoi fare un esempio di logica può essere questo

SE il pulsante è premuto accendi il buzzer per N secondi FINCHÉ il pulsante resta premuto non fare niente

Con le ipotesi fatte sopra un esempio di codice potrebbe essere questo

if (digitalRead(pulsante) == LOW) {
 delay(20); //antibounce
 tone(Buzzer,3500,500);
 delay(500);
 //aspetta finché il pulsante resta premuto
 while (digitalRead(pulsante) == LOW) {
   ; //questo significa "non fare niente"
 }
 delay(20); //antibounce
}

Ciao, P.

ho inserito l’esempio ma succede:
porto a +5v il pin 7 il led di attivato Pin 8 non si accende e il buzzer inizia a bippare trascorso il tempo delayRed (dovrebbe bippare subito) Se abbasso il tempo delayRead bippa prima ma se la tessera è rimasta avvicinata riparte il ciclo e la centrale si disattiva

inoltre se il pin 8 rimane a +5v il ciclo reset on-off non riparte

altra chicca che vorrei fare quando disattivo l’impianto non passare per releReset

/****************** Mxxx V1.1 LETTORE RFID CARD RC-522 e BUZZER 

  
  ************* QUESTO SKETCH PASSA SEMPRE PER IL RESET 
  *
  ************* NON FUNZIONA LA PARTE DI LED E BUZZER STATO ATTIVATO 
  
  
  
  
  scopo del progetto: realizzare un lettore rfid da installare in una centrale allarme senza inseritori
  
  occorre comandare 1 rele per effettuare un reset impianto e un secondo rele per attivarlo
  chiaramente la centrale deve prevedere la programmazione di 1 ingresso come reset e 1 come on-off

  Se la tessera viene riconosciuta o viene premuto il pulsante si accende un releReset,per un tempo,pausa e
  si accende un secondo rele che si spegne dopo un'altro tempo
  i comandi di reset e onff non si devono sovrapporre in centrale
  
  
  la centrale deve restituire un segnale di venuta attivazione e questo segnale deve accender un led
  che rimane fisso per tutto il tempo di attivato e far suonare un buzzer per un tempo programmato

  possibiita di NON far intervenire il releReset quando disattivo (non di vitale importanza)   
  
  Se la tessera è falsa si accende un ledfalsa con dei lampeggi e relativo buzzer per indicare l`inaccessibilità.
  
  Il codice tessera si idividua dal monitor seriale di arduino, con uno sketch a parte



  PINOUT:

  RC522 MODULO    Uno/Nano
  SDA             D10
  SCK             D13
  MOSI            D11
  MISO            D12
  IRQ             N/A
  GND             GND
  RST             D9
  3.3V            3.3V

  pulsante esterno al Pin 2 e +5v
  resistenza 10K  pin 2 e gnd 
  
  comando esterno di attivato al Pin 7 e +5v
  resistenza 10K  pin 7 e gnd se il comando è un contatto
  
  ledFalsa al Pin 3 e gnd
  releReset al Pin 4 e gnd
  releOnoff Pin 5 e gnd
  buzzer al pin 6 e gnd
  ledattivato al pin 8 e gnd
*/



#include <SPI.h>
#include <RFID.h>
/* Vengono definiti PIN  */
#define SDA_DIO 10
#define RESET_DIO 9
#define delayRead 3000     // Tempo di attesa fra ogni lettura
#define delayLed 1000      // Tempo di accensione led verde ok prima di chiudere il rele

#define ledFalsa 3         // segnala chiave falsa
#define releReset 4        // Segnala chiave vera 
#define releOnoff 5        // comanda il rele
#define buzzer 6           // comanda il buzzer 
#define ledattivato 8      // segnala impianto attivato

const int pulsante = 2;    // pulsante collegato a positivo e pin-resistenza fra gnd e pin
int statopulsante = 0;     //variabile lettura del pulsante se aperto è LOW

const int attivato = 7;    // pulsante collegato a positivo e pin-resistenza fra gnd e pin
int statoattivato = 0;     //variabile lettura del pulsante se aperto è LOW




/* Viene creata una istanza della RFID libreria */
RFID RC522(SDA_DIO, RESET_DIO);
// inserire tutti i codici esadecimali delle schede magnetiche riconosciute
String codiceAutorizzato1 = "A6424373D4";
String codiceAutorizzato2 = "6BEF9F1B0";
String codiceAutorizzato3 = "207A56737F";
String codiceAutorizzato4 = "359D46739D";
String codiceAutorizzato5 = "B9A347732E";


void setup()
{
Serial.begin(9600);
/* Abilita SPI*/
SPI.begin();
/* Viene inizilizzato RFID reader */
RC522.init();
Serial.println("Passare Carta");   // intestazione su monitor seriale
pinMode(releReset, OUTPUT);
pinMode(releOnoff, OUTPUT);
pinMode(ledFalsa, OUTPUT);
pinMode(pulsante, INPUT);
pinMode(buzzer,  OUTPUT);
pinMode(attivato, INPUT);
pinMode(ledattivato, OUTPUT);

}

void loop()

{

/************************************************************************/

/**questa parte riguarda  il buzzer quando centrale allarme mi da un segnale di attivato**/


if (digitalRead(attivato) == HIGH) 
{
delay(20); //antibounce
tone(buzzer,3500,500);
delay(500);
//aspetta finché il pulsante resta premuto
while (digitalRead(attivato) == HIGH) 
{
; //questo significa "non fare niente"
}
delay(20); //antibounce

}

/**questa parte riguarda  il led quando centrale allarme mi da un segnale di attivato**/

if (attivato == HIGH) 
{
digitalWrite (ledattivato, HIGH);
}
else
{
digitalWrite (ledattivato, LOW); 
}


/*************************************************************************/


/************* questa parte è per un comando con un pulsante esterno **************/

statopulsante = digitalRead(pulsante);  // qui leggo lo stato del pulsante
if (statopulsante == HIGH)              // se il pulsante è premuto HIGH
{                                        
accendiLed(releReset);                  // accendo il releReset per il tempo delayLed
delay (800);                            // pausa fra releReset e releOnoff    
digitalWrite(releOnoff, HIGH);          // finito il tempo delayLed accendo il releOnoff 
delay (1000);                           // dopo questo tempo
digitalWrite (releOnoff, LOW);          // spengo il releOnoff
delay(delayRead);                       //il ciclo si ripete ogni tempo di delayRead
}



/* Temporary loop counter */
byte i;
// Se viene letta una tessera
if (RC522.isCard())
{
// Viene letto il suo codice
RC522.readCardSerial();
String codiceLetto = "";
Serial.println("Codice delle tessera letto:");

// Viene caricato il codice della tessera, all'interno di una Stringa
for (i = 0; i <= 4; i++)
{
codiceLetto += String (RC522.serNum[i], HEX);
codiceLetto.toUpperCase();
}

/* se si aggungono i codici aggiungere la stringa attenzione alle 2 parentesi tonde finali))*/

Serial.println(codiceLetto);
if (verificaCodice(codiceLetto, codiceAutorizzato1) || verificaCodice(codiceLetto, codiceAutorizzato2)
|| verificaCodice(codiceLetto, codiceAutorizzato3) || verificaCodice(codiceLetto, codiceAutorizzato4)
|| verificaCodice(codiceLetto, codiceAutorizzato5))

{  
Serial.println("Tessera autorizzata");          // se tessera ok accendo releReset 
accendiLed(releReset);                          // accendo il releReset per il tempo delayLed 
delay (800);                                    // pausa fra releReset e releOnoff 
digitalWrite (releOnoff, HIGH);                 // finito il tempo delayLed accendo il releOnoff           
delay (1000);                                   // dopo questo tempo   
digitalWrite (releOnoff, LOW);                  // spengo il releOnoff
}  
else                                            // allora 
{    
Serial.println("Tessera non autorizzata");      // la chiave è falsa
accendiLedFalsa(ledFalsa);                      // accendo il ledFalsa  
delay (200);                                    //per untempo di 20 millisecondi
}
delay(delayRead);                               //il ciclo si ripete ogni tempo di delayRead
}
}

// Questa funzione verifica se il codice Letto è autorizzato
boolean verificaCodice(String codiceLetto, String codiceAutorizzato) 
{
if (codiceLetto.equals(codiceAutorizzato))
{
return true;
} 
else
{
return false;
}
}




// Questa funzione permette di accendere il LED per un determinato periodo
// vedi tempo di "accendiLed"
void accendiLed(int ledPin) {
digitalWrite(ledPin, HIGH);
delay(delayLed);
digitalWrite(ledPin, LOW);
}
// questa funzione permette di accendere il ledfalso per alcuni lampeggi se card non riconosciuta
void accendiLedFalsa(int ledPin)        //se accendo ledfalsa
{
digitalWrite(ledPin, HIGH);             // accendo ledFalsa  
tone (buzzer,3500,30);                  //accendo il buzzer con la stessa tempo del delay
delay(30);                              // per un tempo
digitalWrite(ledPin, LOW);              // spengo ledFalsa  continuo
delay(30);
digitalWrite(ledPin, HIGH);
delay(30);
digitalWrite(ledPin, LOW);
delay(30);
}

In questo caso l'antirimbalzo non serve, perché ogni volta che c'è un falso contatto parte il tempo di 3,5s e poi si riazzera appena finisce il falso contatto. Io farei così:

const byte buzzer=6;
const byte pulsante=7;
const int durata=3500; // Durata in ms.
unsigned long t=0;
byte suono=0;

void setup()
{
pinMode(buzzer, OUTPUT);      //dichiaro il pin del buzzer
pinMode(pulsante, INPUT_PULLUP);  //dichiaro il pin del pulsante e attivo la resistenza di pullup
}

void loop()
{
if(!digitalRead(pulsante) && suono==0) {suono=1; t=millis(); tone(buzzer, 3500);}
if(suono==1 && digitalRead(pulsante) && millis()-t>durata) {suono=0; noTone(buzzer);}
}

Ho messo i commenti all’interno del programma, che allego perché troppo lungo.

Alcune considerazioni generali:

  • Il programma tutto allineato a sinistra è di difficile lettura. Usa la funzione Formattazione automatica dell’IDE. La trovi in Strumenti->Formattazione automatica oppure Ctrl+T.
  • Anche l’uso di molte righe vuote fra una parte e l’altra rende difficile la lettura
  • Come già detto l’uso della funzione String è altamente sconsigliato, ma questo si può vedere dopo.
  • Sarebbe MOLTO opportuno uno schema elettrico, anche fotografando un disegno su carta.

Ciao,
P.

sketch_mar03a.ino (8.53 KB)

allego schema progetto
e libreria Rc522

rfid.zip (5.96 KB)

Adesso devo capire come funziona il sistema. Provo a descrivere ciò che ho capito.

Le condizioni iniziali dell'impianto sono: - Arduino spento - Centrale disattiva

All'accensione dell'Arduino le condizioni sono: - Centrale disattivata - Scheda RFID inizializzata - pulsante aperto - relè "attivato" aperto (OFF) - relè "reset" OFF - relè "OnOff" OFF - led attivato spento - led falsa spento - buzzer spento

Per attivare la Centrale ci sono due modi: - pulsante "pulsante" chiuso - tessera RFID valida

In ENTRAMBI i casi si ha: - relè "reset" ON - attesa M secondi - relè "reset" OFF - eventuale piccola attesa per evitare contemporaneità relè "reset" con relè "OnOff" - relè "OnOff" ON - attesa N secondi - relè "OnOff" OFF - attivazione relè "attivato" - accensione led attivato - buzzer suona per P secondi e basta

Quindi in condizioni di centrale attiva si ha: - Centrale attiva - Scheda RFID inizializzata - pulsante aperto - relè "attivato" chiuso (ON) - relè "reset" OFF - relè "OnOff" OFF - led attivato acceso - led falsa spento - buzzer spento

Se la tessera RFID non è valida - led falsa acceso - buzzer suona - attesa Q secondi - buzzer spento - led falsa spento - attesa Q secondi - ripeti sequenza per tre volte - la centrale RESTA comunque nella condizione precedente (ACCESA/SPENTA)

Mi sembra che non sia molto importante usare la tessera valida per ACCENDERE la centrale, quanto piuttosto usarla per SPEGNERLA. Non trovi?

Ciao, P.

fabio1970:
non ne vengo a capo (Riferito ai post #1 e #2)

pulsanteState = digitalRead(pulsante);

if (pulsanteStatePrecedente != pulsanteState)  // se c'e` variazione
{
    pulsanteStatePrecedente = pulsanteState;   // aggiorna stato precedente
    if (pulsanteState == HIGH)                 // se premuto
    {     
        tone(Buzzer,3500,500);
        delay(500);
    }
}

per pgiagno

si la sequenza è giusta

"""Mi sembra che non sia molto importante usare la tessera valida per ACCENDERE la centrale, quanto piuttosto usarla per SPEGNERLA. Non trovi? """

si potrebbe essere giusto Di solito le tessere non programmate sulle centrali non fanno nessuna funzione in questo caso i bip e il led è un qualcosa in più

pgiagno scrive

//SE NON HAI BISOGNO DI CONSERVARE LO STATO DEL PULSANTE LETTO CONVIENE
  //SOSTITUIRE QUESTE DUE ISTRUZIONI
  statopulsante = digitalRead(pulsante);  // qui leggo lo stato del pulsante //
  if (statopulsante == HIGH)              // se il pulsante è premuto HIGH   //
  //CON
  if (digitalRead(pulsante) == HIGH)                                          //
  {
    accendiLed(releReset);                  // accendo il releReset per il tempo delayLed
    delay (800);                            // pausa fra releReset e releOnoff
    digitalWrite(releOnoff, HIGH);          // finito il tempo delayLed accendo il releOnoff
    delay (1000);                           // dopo questo tempo
    digitalWrite (releOnoff, LOW);          // spengo il releOnoff
    delay(delayRead);                       //il ciclo si ripete ogni tempo di delayRead

io fabio1970 rispondo in questo modo posso bloccare il ciclo se tengo premuto il pulsante

statopulsante = digitalRead(pulsante);  // qui leggo lo stato del pulsante
if (statopulsante  == HIGH)              // se il pulsante è premuto HIGH
{                                        
accendiLed(releReset);                  // accendo il releReset per il tempo delayLed
delay (800);                            // pausa fra releReset e releOnoff    
digitalWrite(releOnoff, HIGH);          // finito il tempo delayLed accendo il releOnoff 
delay (1000);                           // dopo questo tempo
digitalWrite (releOnoff, LOW);          // spengo il releOnoff
delay(delayRead);                       //il ciclo si ripete ogni tempo di delayRead
while (digitalRead(pulsante) == HIGH)   //se il pulsante è premuto blocco il ciclo
{
;                                       //questo significa "non fare niente"
}
delay(20);                              //antibounce

fabio1970:
per pgiagno

si la sequenza è giusta

Bene. Allora facciamo un passo alla volta. C’è un errore nella sequenza originale. Questa è quella corretta

  • relè “reset” ON
  • attesa M secondi
  • relè “reset” OFF
  • eventuale piccola attesa per evitare contemporaneità relè “reset” con relè “OnOff”
  • relè “OnOff” ON
  • attesa N secondi
  • relè “OnOff” OFF
  • verifica attivazione relè “attivato”
  • accensione led attivato
  • buzzer suona per P secondi e basta

Va implementata per prima. Lascia stare il resto del programma. Prova a implementare questa sequenza nel tuo programma che ho “amputato” e che ti allego. Ho lasciato tutte le funzioni che avevi scritto, anche se alcune non sarebbero, per il momento, necessarie.

Ciao,
P.

Nicolini-A.ino (4.86 KB)

spero di aver capito
(rinomino lo sketch con la data del post

/****************** Mxxx V1.1 LETTORE RFID CARD RC-522 e BUZZER


  scopo del progetto: realizzare un lettore rfid da installare in una centrale allarme senza inseritori

  occorre comandare 1 rele per effettuare un reset impianto e un secondo rele per attivarlo
  chiaramente la centrale deve prevedere la programmazione di 1 ingresso come reset e 1 come on-off

  Se la tessera viene riconosciuta o viene premuto il pulsante si accende un releReset,per un tempo,pausa e
  si accende un secondo rele che si spegne dopo un'altro tempo
  i comandi di reset e onff non si devono sovrapporre in centrale


  la centrale deve restituire un segnale di venuta attivazione e questo segnale deve accender un led
  che rimane fisso per tutto il tempo di attivato e far suonare un buzzer per un tempo programmato

  possibiita di NON far intervenire il releReset quando disattivo (non di vitale importanza)

  Se la tessera è falsa si accende un ledfalsa con dei lampeggi e relativo buzzer per indicare l`inaccessibilità.

  Il codice tessera si idividua dal monitor seriale di arduino, con uno sketch a parte



  PINOUT:

  RC522 MODULO    Uno/Nano
  SDA             D10
  SCK             D13
  MOSI            D11
  MISO            D12
  IRQ             N/A
  GND             GND
  RST             D9
  3.3V            3.3V

  pulsante esterno al Pin 2 e +5v
  resistenza 10K  pin 2 e gnd

  comando esterno di attivato al Pin 7 e +5v
  resistenza 10K  pin 7 e gnd se il comando è un contatto

  ledFalsa al Pin 3 e gnd
  releReset al Pin 4 e gnd
  releOnoff Pin 5 e gnd
  buzzer al pin 6 e gnd
  ledattivato al pin 8 e gnd
*/


#include <SPI.h>
#include <RFID.h>
/* Vengono definiti PIN  */
#define SDA_DIO 10
#define RESET_DIO 9
#define delayRead 3000     // Tempo di attesa fra ogni lettura
#define delayLed 1000      // Tempo di accensione led verde ok prima di chiudere il rele

#define pulsante 2         // pulsante attivazione manuale
#define ledFalsa 3         // segnala chiave falsa
#define releReset 4        // comando "RESET" VERSO centrale
#define releOnoff 5        // comanda il rele
#define buzzer 6           // comanda il buzzer
#define attivato 7         // comando "ATTIVATO" PROVENIENTE da centrale
#define ledattivato 8      // segnala impianto attivato

int statopulsante = 0;     //variabile lettura del pulsante se aperto è LOW
int statoattivato = 0;     //variabile lettura del pulsante se aperto è LOW

/* Viene creata una istanza della RFID libreria */
RFID RC522(SDA_DIO, RESET_DIO);
// inserire tutti i codici esadecimali delle schede magnetiche riconosciute
String codiceAutorizzato1 = "A6424373D4";
String codiceAutorizzato2 = "6BEF9F1B0";    //QUESTO CODICE HA UNA LETTERA IN MENO
String codiceAutorizzato3 = "207A56737F";
String codiceAutorizzato4 = "359D46739D";
String codiceAutorizzato5 = "B9A347732E";

void setup()
{
  Serial.begin(9600);
  /* Abilita SPI*/
  SPI.begin();
  /* Viene inizilizzato RFID reader */
  RC522.init();
  Serial.println("Passare Carta");   // intestazione su monitor seriale
  pinMode(pulsante, INPUT);
  pinMode(ledFalsa, OUTPUT);
  pinMode(releReset, OUTPUT);
  pinMode(releOnoff, OUTPUT);
  pinMode(buzzer, OUTPUT);
  pinMode(attivato, INPUT);
  pinMode(ledattivato, OUTPUT);
  //
  //AGGIUNGERE QUI LE ISTRUZIONI PER LED SPENTI E RELÈ OFF
  //
  digitalWrite (pulsante, LOW);
  digitalWrite (ledFalsa, LOW);
  digitalWrite (releReset, LOW);
  digitalWrite (releOnoff, LOW);
  digitalWrite (buzzer, LOW);
  digitalWrite (attivato, LOW);
  digitalWrite (ledattivato, LOW);

}

void loop()
{

  /************************************************************************/
  /************* questa parte è per un comando con un pulsante esterno **************/

  if (digitalRead(pulsante) == HIGH)
  {
    //QUESTE LE AZIONI DA FARE. METTI LE ISTRUZIONI SOTTO OGNI COMMENTO
    //- relè "reset" ON
    {
      digitalWrite(releReset, HIGH);                 // accendo il releReset
      //- attesa M secondi
      delay (1000);
      //- relè "reset" OFF
      digitalWrite(releReset, LOW);
      //- eventuale piccola attesa per evitare contemporaneità relè "reset" con relè "OnOff"
      delay (800);
      //- relè "OnOff" ON
      digitalWrite (releOnoff, HIGH);
      //- attesa N secondi
      delay(1000);
      //- relè "OnOff" OFF
      digitalWrite (releOnoff, LOW);
      //- verifica attivazione relè "attivato"
      if (digitalRead(attivato) == HIGH)
        //- accensione led attivato
        digitalWrite (ledattivato, HIGH);
      //- buzzer suona per P secondi e basta
      tone (buzzer, 3500, 500);
      delay(3500);

    }
  }
}


// Questa funzione verifica se il codice Letto è autorizzato
boolean verificaCodice(String codiceLetto, String codiceAutorizzato)
{
  if (codiceLetto.equals(codiceAutorizzato))
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Questa funzione permette di accendere il LED per un determinato periodo
// vedi tempo di "accendiLed"
void accendiLed(int ledPin)
{
  digitalWrite(ledPin, HIGH);
  delay(delayLed);
  digitalWrite(ledPin, LOW);
}
// questa funzione permette di accendere il ledfalso per alcuni lampeggi se card non riconosciuta
void accendiLedFalsa(int ledPin)        //se accendo ledfalsa
{
  digitalWrite(ledPin, HIGH);             // accendo ledFalsa
  tone (buzzer, 3500, 30);                //accendo il buzzer con la stessa tempo del delay
  delay(30);                              // per un tempo
  digitalWrite(ledPin, LOW);              // spengo ledFalsa  continuo
  delay(30);
  digitalWrite(ledPin, HIGH);
  delay(30);
  digitalWrite(ledPin, LOW);
  delay(30);
}

Bene. Adesso il programma dovrebbe far accendere la centrale allarmi. Se puoi provarlo dovrebbe funzionare, altrimenti dimmi che succede.

In allegato trovi il programma con alcuni commenti e il prossimo passo che consiste nel provare a spegnere la centrale con il riconoscimento della tessera RFID valida. Il pezzo di programma per il riconoscimento tessera è quello che hai scritto tu; spero che funzioni perché io non ho la possibilità di provarlo. Inserisci le istruzioni per lo spegnimento. Io non so se è necessario il reset o se basta OnOff, vedi tu.

Ciao,
P.

Nicolini-B.ino (7.91 KB)

grazie pgiagno, questi giorni mi sono dato da fare, ho fisicamente collegato arduino e centrale allarme cosi i test sono veritieri

la parte riferita alla RC522 in realtà l'avevo già aggiunta e funziona.

non funziona la parte attivato-ledattivato ( #14)e gli ho parcheggiati

ora sto provando a scriverla io faccio un piccolo riepilogo la centrale manda HIGH il pin attivato quando lei attivata viceversa LOW quando disattivata, e a sua volta il ledattivato segue lo stato del pin attivato

con lo sketch che ho scritto succede che alla centrale arriva il comando ON-OFF, lei restituisce il comando Attivato dopo 2 secondi, il led attivato si accende trascorso i tempi:

""delay 3000 ""attendo n secondi prima di un'altra operazione con pulsante"" oppure ""delayRead 3000 Tempo di attesa fra ogni lettura usando rfid card ""

ora la sequenza:

avvicino la tessera e la mantengo inizia il ciclo dei comandi Reset e ON-OFF non vedo cosa succede quindi mantengo tessera avvicinata trascorsi i tempi delay (3000) e delayRead si accende il ledattivato, contemporaneamente riparte il ciclo reset ma non posso saperlo tolgo la tessera la centrale dopo il RESET attiva il rele ON-OFF e quindi si spegne

sequenza esatta avvicino la tessera e la mantengo inizia il ciclo dei comandi Reset e ON-OFF non vedo cosa succede quindi mantengo tessera avvicinata trascorsi il tempo ON-OFF la centrale restituisce dopo 2 secondi il comando attivato si accende il ledattivato per tutto il tempo del comando attivato tolgo la tessera

con questa sequenza aumentando il tempi

""delay 3000 ""attendo n secondi prima di un'altra operazione con pulsante"" oppure ""delayRead 3000 Tempo di attesa fra ogni lettura usando rfid card ""

evito che tenendo la tessera anche per qualche istante in più non inizi un nuovo ciclo che sarebbe lo spegnimento della centrale

oppure mantenendo il pulsante premuto o rfid appoggiata il programma esegua un solo ciclo e riprenda solo dopo aver aperto il pulsante o allontanato la rfid

allego mio sketch ma continuerò a cercare la soluzione

quello che non ho proprio capito, ed è dove mi sono soffermato di più è:

volevo allineare lo sketch in questo modo:

void loop ()

inserire parte riguardante il pulsante inserire parte riferita all RC522 inserire parte relè e ledfalsa inserire parte di colloquio fra arduino e centrale.

con questa sequenza cè un errore che non sono riuscito a capire

non ho errori ma poi succede quello gia raccontato con questa sequenza

inserire parte di colloquio fra arduino e centrale inserire parte riguardante il pulsante inserire parte riferita all RC522 inserire parte relè e ledfalsa

allego mio sketch in un altro post

sono quasi le 1.30 vado a letto buonanotte a tutti

[code]
/****************** Mxxx V1.1 LETTORE RFID CARD RC-522 e BUZZER


  scopo del progetto: realizzare un lettore rfid da installare in una centrale allarme senza inseritori

  occorre comandare 1 rele per effettuare un reset impianto e un secondo rele per attivarlo
  chiaramente la centrale deve prevedere la programmazione di 1 ingresso come reset e 1 come on-off

  Se la tessera viene riconosciuta o viene premuto il pulsante si accende un releReset,per un tempo,pausa e
  si accende un secondo rele che si spegne dopo un'altro tempo
  i comandi di reset e onff non si devono sovrapporre in centrale


  la centrale deve restituire un segnale di venuta attivazione e questo segnale deve accender un led
  che rimane fisso per tutto il tempo di attivato e far suonare un buzzer per un tempo programmato

  possibiita di NON far intervenire il releReset quando disattivo (non di vitale importanza)

  Se la tessera è falsa si accende un ledfalsa con dei lampeggi e relativo buzzer per indicare l`inaccessibilità.

  Il codice tessera si idividua dal monitor seriale di arduino, con uno sketch a parte



  PINOUT:

  RC522 MODULO    Uno/Nano
  SDA             D10
  SCK             D13
  MOSI            D11
  MISO            D12
  IRQ             N/A
  GND             GND
  RST             D9
  3.3V            3.3V

  pulsante esterno al Pin 2 e +5v
  resistenza 10K  pin 2 e gnd

  comando esterno di attivato al Pin 7 e +5v
  resistenza 10K  pin 7 e gnd se il comando è un contatto

  ledFalsa al Pin 3 e gnd
  releReset al Pin 4 e gnd
  releOnoff Pin 5 e gnd
  buzzer al pin 6 e gnd
  ledattivato al pin 8 e gnd
*/


#include <SPI.h>
#include <RFID.h>
/* Vengono definiti PIN  */
#define SDA_DIO 10
#define RESET_DIO 9
#define delayRead 3000     // Tempo di attesa fra ogni lettura usando rfid card
#define delayLed 1000      // Tempo di accensione relereset  prima di chiudere il rele

#define pulsante 2         // pulsante attivazione manuale
#define ledFalsa 3         // segnala chiave falsa
#define releReset 4        // comando "RESET" VERSO centrale
#define releOnoff 5        // comanda il rele
#define buzzer 6           // comanda il buzzer
#define attivato 7         // comando "ATTIVATO" PROVENIENTE da centrale
#define ledattivato 8      // segnala impianto attivato

int statopulsante = 0;     //variabile lettura del pulsante se aperto è LOW
int statoattivato = 0;     //variabile lettura del pulsante se aperto è LOW
int val = 0;

/* Viene creata una istanza della RFID libreria */
RFID RC522(SDA_DIO, RESET_DIO);
// inserire tutti i codici esadecimali delle schede magnetiche riconosciute
String codiceAutorizzato1 = "A6424373D4";
String codiceAutorizzato2 = "6BEF9F1B0";    //QUESTO CODICE HA UNA LETTERA IN MENO
String codiceAutorizzato3 = "207A56737F";
String codiceAutorizzato4 = "359D46739D";
String codiceAutorizzato5 = "B9A347732E";

void setup()
{
  Serial.begin(9600);
  /* Abilita SPI*/
  SPI.begin();
  /* Viene inizilizzato RFID reader */
  RC522.init();
  Serial.println("Passare Carta");   // intestazione su monitor seriale
  pinMode(pulsante, INPUT);
  pinMode(ledFalsa, OUTPUT);
  pinMode(releReset, OUTPUT);
  pinMode(releOnoff, OUTPUT);
  pinMode(buzzer, OUTPUT);
  pinMode(attivato, INPUT);
  pinMode(ledattivato, OUTPUT);
  //
  //AGGIUNGERE QUI LE ISTRUZIONI PER LED SPENTI E RELÈ OFF
  //
  digitalWrite (pulsante, LOW);
  digitalWrite (ledFalsa, LOW);
  digitalWrite (releReset, LOW);
  digitalWrite (releOnoff, LOW);
  digitalWrite (buzzer, LOW);
  digitalWrite (attivato, LOW);
  digitalWrite (ledattivato, LOW);

}

void loop()
{

  /**** QUESTA PARTE RICONOSCE L'AVVENUTA ATTIVAZIONE DELLA CENTRALE E ACCENDE UN LED ****/

  val = digitalRead(attivato);  // legge il valore dell'input e lo conserva

  if (val == HIGH) {          // controlla che l'input sia HIGH (pulsante premuto)
    digitalWrite(ledattivato, HIGH);  // accende il led
  }
  else {
    digitalWrite(ledattivato, LOW);   // spegne il led
  }

  /************ QUESTA PARTE E PER ATTIVARLO CON UN PULSANTE **************/

  if (digitalRead(pulsante) == HIGH)

    //QUESTE LE AZIONI DA FARE. METTI LE ISTRUZIONI SOTTO OGNI COMMENTO
    //- relè "reset" ON
  {
    digitalWrite(releReset, HIGH);                 // accendo il releReset
    //- attesa M secondi
    delay (1000);
    //- relè "reset" OFF
    digitalWrite(releReset, LOW);
    //- eventuale piccola attesa per evitare contemporaneità relè "reset" con relè "OnOff"
    delay (800);
    //- relè "OnOff" ON
    digitalWrite (releOnoff, HIGH);
    //- attesa N secondi
    delay(1000);
    //- relè "OnOff" OFF
    digitalWrite (releOnoff, LOW);
    //- verifica attivazione relè "attivato"
    //    if (digitalRead(attivato) == HIGH)           parcheggiato
    //- accensione led attivato
    //      digitalWrite (ledattivato, HIGH);          parcheggiato
    //- buzzer suona per P secondi e basta
    ////////////////////tone (buzzer, 3500, 500);  nel mio caso qui non serve
    //attendo n secondi prima di un'altra operazione con pulsante
    delay(3000);
  }

  /*********** QUESTA PARTE E PER ATTIVARLO CON TESSERA RFID **************/
  /* Temporary loop counter */
  byte i;
  // Se viene letta una tessera
  if (RC522.isCard ())
  {
    // Viene letto il suo codice
    RC522.readCardSerial();
    String codiceLetto = "";
    Serial.println("Codice delle tessera letto:");

    // Viene caricato il codice della tessera, all'interno di una Stringa
    for (i = 0; i <= 4; i++)
    {
      codiceLetto += String (RC522.serNum[i], HEX);
      codiceLetto.toUpperCase();
    }

    //se si aggungono i codici aggiungere la stringa attenzione alle 2 parentesi tonde finali))*/

    Serial.println(codiceLetto);
    if (verificaCodice(codiceLetto, codiceAutorizzato1) || verificaCodice(codiceLetto, codiceAutorizzato2)
        || verificaCodice(codiceLetto, codiceAutorizzato3) || verificaCodice(codiceLetto, codiceAutorizzato4)
        || verificaCodice(codiceLetto, codiceAutorizzato5))

    {
      Serial.println("Tessera autorizzata");          // se tessera ok accendo releReset
      accendiLed(releReset );                          // accendo il releReset per il tempo delayLed
      delay (800);                                    // pausa fra releReset e releOnoff
      digitalWrite (releOnoff, HIGH);                 // finito il tempo delayLed accendo il releOnoff
      delay (1000);                                   // dopo questo tempo
      digitalWrite (releOnoff, LOW);                  // spengo il releOnoff
    }
    else                                            // allora
    {
      Serial.println("Tessera non autorizzata");      // la chiave è falsa
      accendiLedFalsa(ledFalsa);                      // accendo il ledFalsa
      delay (200);                                    //per untempo di 20 millisecondi
    }
    delay(delayRead);                               //il ciclo si ripete ogni tempo di delayRead
  }
}

// Questa funzione verifica se il codice Letto è autorizzato
boolean verificaCodice(String codiceLetto, String codiceAutorizzato)
{
  if (codiceLetto.equals(codiceAutorizzato))
  {
    return true;
  }
  else
  {
    return false;
  }
}
/********* Questa funzione permette di accendere il LED per un determinato periodo ******/
// vedi tempo di "accendiLed"
void accendiLed(int ledPin) {
  digitalWrite(ledPin, HIGH);
  delay(delayLed);
  digitalWrite(ledPin, LOW);
}
/** QUESTA FUNZIONE ACCENDE ledfalsa  E buzzer PER ALCUNI LAMPEGGI SE CARD NON RICONOSCIUTA **/
void accendiLedFalsa(int ledPin)        //se accendo ledfalsa
{
  digitalWrite(ledPin, HIGH);             // accendo ledFalsa
  tone (buzzer, 3500, 30);                //accendo il buzzer con la stessa tempo del delay
  delay(30);                              // per un tempo
  digitalWrite(ledPin, LOW);              // spengo ledFalsa  continuo
  delay(30);
  digitalWrite(ledPin, HIGH);
  delay(30);
  digitalWrite(ledPin, LOW);
  delay(30);
}

[/code]

Nel tuo programma manca la parte di spegnimento della centrale. Ti avevo suggerito di usare il pulsante per attivarla e la tessera per disattivarla. Dimmi cosa vuoi fare per disattivarla.

Nella parte di comando con il pulsante tu eviti la ripetizione della serie di istruzioni introducendo alla fine un ritardo di 3 secondi (delay(3000);), presupponendo che il pulsante sia stato già rilasciato PRIMA della scadenza di quel tempo. Per sicurezza bisognerebbe IMPEDIRE la ripetizione di quel ciclo prima del rilascio e successiva pressione del pulsante. Per il momento va bene così. Ricordati solo di rilasciare il pulsante prima dei 3 secondi.

La tua "sequenza esatta" a mio avviso è sbagliata. Tu dici:

avvicino la tessera e la mantengo
inizia il ciclo dei comandi Reset e ON-OFF
non vedo cosa succede quindi mantengo tessera avvicinata
trascorsi il tempo ON-OFF la centrale restituisce dopo 2 secondi il comando attivato
si accende il ledattivato per tutto il tempo del comando attivato
tolgo la tessera

Dovrebbe essere:

avvicino la tessera
IL PROGRAMMA RICONOSCE LA TESSERA VALIDA E DÀ UN LAMPEGGIO BREVE SUL ledFalsa
POSSO TOGLIERE LA TESSERA OPPURE NO
inizia il ciclo dei comandi Reset e ON-OFF
trascorsi il tempo ON-OFF la centrale restituisce dopo 2 secondi il comando attivato
si accende il ledattivato per tutto il tempo del comando attivato
SE NON HO ANCORA TOLTO LA TESSERA IMPEDISCO L'INIZIO DI UN NUOVO CICLO

Do un'occhiata al programma e ti so dire. Tu intanto dimmi come vuoi comportarti per spegnere la centrale.

Ciao, P.

Ho inserito delle correzioni. Le trovi in maiuscolo nel testo allegato. Prova e dimmi cosa non funziona.

Ciao,
P.

Fabio1970-A.ino (8.03 KB)