Salve vorrei realizzare un allarme con arduino con la funzione che testa tutti i componenti del impianto e controlli che nessuno lo manometta.
Distinti Saluti Mattdj
Bene ...
... comincia allora a progettarlo, fare lo schema e buttare giù il codice ... quando hai problemi chiedi aiuto XD
Guglielmo
ho gia progettato ma non so come fare il sistema anti-manomissione ed il test dei componenti io ho trovato qui sul forum questo sketch:
//***************************************************************************************************************************
//** A L L A R M E V e r . 2 . 0
//**
//***************************************************************************************************************************
#include <stdio.h> //serve per far funzionare "sprintf" che ci consente di salvare in un'array CHAR diversi messaggi da
//far visualizzare con un'unico comando Serial.print() questo semplifica e riduce il dispendio di
//FLASH e RAM.
byte Chiave;
byte Sensore;
byte Led=3;
byte Variabile;
byte Allarme=0;
byte Luce;
byte Old_Chiave;
byte Old_Sensore;
byte Old_Variabile;
byte Old_Luce;
byte Old_Allarme;
char Comando_ricevuto;
char buffer[80]; //questo array conterrà i vari messaggi da stampare sulla seriale.
byte Test_Counter=0;
//*****************************************************************************************************
void setup(){
Serial.begin(9600);
pinMode(A0,INPUT); //Sensore PIR
pinMode(4,INPUT); //Chiave
pinMode(3,OUTPUT); //LED
pinMode(13,OUTPUT);
pinMode(5,OUTPUT);
}
//*****************************************************************************************************
void loop(){
Chiave=digitalRead(4);
Sensore=digitalRead(A0); //<-------non sarebbe meglio usare un pin digitale invece che uno analogico?
RX_Comandi_Serial_Monitor(); //secondo me è qui che dovresti inserire la chiamata a funzione RX_Comandi_Serial_Monitor()
Test_Allarme();
Verifica_Stato_1();
Verifica_Stato_2();
Verifica_Stato_3();
Verifica_Stato_4();
Verifica_Stato_5();
Verifica_Stato_6();
Verifica_Stato_7();
}
//*************************************************************************
void Verifica_Stato_1(){
if((Chiave==LOW) && (Variabile==0)) //<----dovrebbe trovare TRUE sia se riceve il comando
// T da seriale sia con le condizioni usuali di funzionam.
{
tone(13,1700);
digitalWrite(5,HIGH);
delay(500);
noTone(13);
digitalWrite(5,LOW);
delay(500);
tone(13,1700);
digitalWrite(5,HIGH);
delay(500);
noTone(13);
digitalWrite(5,LOW);
Variabile=1;
Test_Counter=1; //test 1 eseguito
}
}
//**************************************************************************
void Verifica_Stato_2(){
if ((Chiave==HIGH) && (Variabile==1))
{
Variabile=0;
Test_Counter=2; //test 2 eseguito
}
}
//**************************************************************************
void Verifica_Stato_3(){
if((Variabile==1) && (Sensore==LOW) && (Allarme==0))
{
Serial.println("Allarme Inserito");
delay(5000);
Serial.println("Zona 1 OK!");
digitalWrite(3,LOW);
digitalWrite(5,HIGH);
Test_Counter=3; //test 3 eseguito
}
}
//**************************************************************************
void Verifica_Stato_4(){
if((Variabile==1) && (Sensore==HIGH) && (Allarme==0))
{
Serial.println("Pre-Allarme");
delay(20000);
Allarme=1;
Serial.println("Attenzione!Zona 1");
tone(13,1700);
delay(1000);
Luce=1;
Test_Counter=4; //test 4 eseguito
}
}
//**************************************************************************
void Verifica_Stato_5(){
if((Variabile==0) && (Sensore==LOW))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
Test_Counter=5; //Test 5 eseguito
}
}
//**************************************************************************
void Verifica_Stato_6(){
if((Chiave==HIGH) && (Sensore==HIGH))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
Test_Counter=6; //Test 6 eseguito
}
}
//**************************************************************************
void Verifica_Stato_7(){
if ((Luce==1) )
{
noTone(13);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
delay(250);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
Test_Counter=7;
}
}
//*****************************************************************************************************
void Test_Allarme(){ //il test verrà eseguito solo se presente un comando ricevuto da seriale!!
if (Comando_ricevuto=='T') {
Salva_STATI_Variabili(); //serve a salvare le variabili per rimettere il sistema ai valori originali prima del TEST
Test_1();
Verifica_Stato_1();
Test_2();
Verifica_Stato_2();
Test_3();
Verifica_Stato_3();
Test_4();
Verifica_Stato_4();
Test_5();
Verifica_Stato_5();
Test_6();
Verifica_Stato_6();
Test_7();
Verifica_Stato_7();
Fine_Test_Check();
Restore_STATI_Variabili(); //serve a restituire i valori originali delle variabili al fine di rimanere in operatività dopo TEST
}
}
//*************************
void Salva_STATI_Variabili(){
Old_Chiave=Chiave;
Old_Variabile=Variabile;
Old_Sensore=Sensore;
Old_Allarme=Allarme;
Old_Luce=Luce;
}
//*************************
void Restore_STATI_Variabili(){
Chiave=Old_Chiave;
Variabile=Old_Variabile;
Sensore=Old_Sensore;
Allarme=Old_Allarme;
Luce=Old_Luce;
}
//*************************
void Test_1(){
Chiave=LOW;
Variabile=0;
Test_Counter=1;
sprintf(buffer,"-----Inizio Test-----");
Stampa_Messaggio();
}
//*************************
void Test_2(){
Old_Chiave=
Chiave=HIGH;
Variabile=1;
Test_Counter=2;
sprintf(buffer,"Test 1 ok");
Stampa_Messaggio();
}
//*************************
void Test_3(){
Variabile=1;
Sensore=LOW;
Allarme=0;
Test_Counter=3;
sprintf(buffer,"Test 2 ok");
Stampa_Messaggio();
}
//*************************
void Test_4(){
Variabile=1;
Sensore=HIGH;
Allarme=0;
Test_Counter=4;
sprintf(buffer,"Test 3 ok ");
Stampa_Messaggio();
}
//*************************
void Test_5(){
Variabile=0;
Sensore=LOW;
Test_Counter=5;
sprintf(buffer,"Test 4 ok");
Stampa_Messaggio();
}
//*************************
void Test_6(){
Chiave=HIGH;
Sensore=HIGH;
Test_Counter=6;
sprintf(buffer,"Test 5 ok");
Stampa_Messaggio();
}
//*************************
void Test_7(){
Luce=1;
Test_Counter=7;
sprintf(buffer,"Test 6 ok");
Stampa_Messaggio();
}
//*************************
void Fine_Test_Check(){
if ((Test_Counter==7) && (Luce==1)) {
Comando_ricevuto=' '; //azzera il contenuto della variabile.
Test_Counter=0; //Azzera il contatore test eseguiti
sprintf(buffer,"Test 7 ok");
Stampa_Messaggio();
delay(10);
sprintf(buffer,"-----Test Eseguito-----");
Stampa_Messaggio();
}
else {
sprintf(buffer,"Test 7 Fallito!");
Stampa_Messaggio();
delay(10);
sprintf(buffer,"-----Test FALLITO !-----");
Stampa_Messaggio();
}
}
//*************************
void Stampa_Messaggio(){
Serial.println(buffer); //fatto così, usi un'unico Serial.print() !!
}
//*********************************************************************************************
void RX_Comandi_Serial_Monitor(){
if(Serial.available()>0){ //Se ci sono caratteri in arrivo.
Comando_ricevuto=Serial.read(); //Legge un byte dalla seriale.
delay(2);
Test_Counter=0; //viene azzerato per evitare che rimanesse in memoria l'ultimo numero dall'ultimo test e quindi non venisse
//eseguito più di una volta il test con comando seriale...
}
}
mattdj:
ho gia progettato ma non so come fare il sistema anti-manomissione ed il test dei componenti ...
Purtroppo ... non abbiamo ... 
Spiega bene che circuito hai immaginato, posta lo schema e poi chiarisci :
-
anti-manomissione dove ??? sui cavi, sulla centralina, su cosa ???
-
test di quali componenti ? che tipo di test ?
Guglielmo
anti manomissione sui componenti quindi centralina ed cavi.Per il test intendo che prova ad esempio il sensore pir quindi se sente il movimento o meno
... si, ma ... non ho capito ... vuoi che ti facciamo noi il lavoro ??? 
Perché qui NON funziona così ...
... tu butti giù le TUE idee di come fare una cosa e noi ti possiamo aiutare ... ma il lavoro e le idee devono essere tue ...
Quindi, ripeto, comincia a progettare questa benedetta centrale, i vari collegamenti, i vari sensori, ecc. ecc. e poi pubblica il progetto, il codice base (anche di base, senza il controllo anti-manomissione e senza i test .. che aggiungerai mano mano) e si discute di come fare le varie cose ...
Adesso come adesso ... stiamo a ZERO ... non c'è nulla da cui partire ... :~
Guglielmo
ok ho fatto tutti i collegamenti dei sensori,led e sirena.ho creato uno sketch molto base.
int Chiave;
int Sensore;
int Led=3;
int Variabile;
int Allarme=0;
int Luce;
void setup()
{
Serial.begin(9600);
pinMode(A0,INPUT); //Sensore PIR
pinMode(4,INPUT); //Chiave
pinMode(3,OUTPUT); //LED
pinMode(13,OUTPUT);
pinMode(5,OUTPUT);
}
void loop()
{
Chiave=digitalRead(4);
Sensore=digitalRead(A0);
if((Chiave==LOW) && (Variabile==0))
{
tone(13,1700);
delay(500);
noTone(13);
delay(500);
tone(13,1700);
delay(500);
noTone(13);
Variabile=1;
}
else if ((Chiave==HIGH) && (Variabile==1))
{
Variabile=0;
}
if((Variabile==1) && (Sensore==LOW) && (Allarme==0))
{
Serial.println("Allarme Inserito");
delay(5000);
Serial.println("Zona 1 OK!");
digitalWrite(3,LOW);
digitalWrite(5,HIGH);
}
else if((Variabile==1) && (Sensore==HIGH) && (Allarme==0))
{
Serial.println("Pre-Allarme");
delay(20000);
Allarme=1;
Serial.println("Attenzione!Zona 1");
tone(13,1700);
delay(1000);
Luce=1;
}
else if((Variabile==0) && (Sensore==LOW))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
}
else if((Chiave==HIGH) && (Sensore==HIGH))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
}
else if (Luce==1)
{
noTone(13);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
delay(250);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
}
}
Nessuno può aiutarmi?
Manca lo schema.
Come dice Guglielmo, senza queste info non ti si può aiutare.
Ti dico come ho fatto io per il test al mio sistema.
Utilizzo 2 variabili "allarme" e "allarme test", se "allarme" = 1 (quindi attivo) esegue le operazioni associate, attiva quindi la sirena, invia sms ed email ecc.
Se "allarme test" è 1 (quindi attivo) mi invia solo sms e email (contenenti la specifica per i vari sensori che hanno generato l'allerta) senza far suonare la sirena.
Ovviamente l'inserimento di "allarme" esclude in automatico "allarme test" così nel caso avessi lasciato attivo per sbaglio "allarme test" avrei comunque la copertura totale del sistema.
mattdj:
Per il test intendo che prova ad esempio il sensore pir quindi se sente il movimento o meno
Allora Ti serve un intruso ogni x ore per provare se il sensore funziona? 
Ciao Uwe
L'antimanomissione sui cavi viene fatta in 2 modi che in tutte le centrali viene chiamato tamper. Queste linee di protezione lavorano 24h su 24h e forniscono un allarme anche a impianto disinserito proprio per evitare che il tapezziere, idraulico, elettricista casuali possano manomettere l'impianto per tornare in un secondo momento all'insaputa dei proprietari, ne esistono di 2 tipi.
- con sistema di continuità, ovvero taglio cavi
- con sistema a bilanciamento
Nel primo caso (continuità): 2 conduttori creano un circuito chiuso lungo il cavo che generano un allarme quando il cavo viene di netto tranciato, il tallone di achille di questo sistema è che posso sguainare i cavi e trovare la coppia da cortocircuitare a monte per poi tagliare il cavo illudendo il sistema.
Nel secondo caso, una resistenza crea una tensione di un certo valore detto bilanciato (che non è ne 0v ne 12v) quindi non posso ne cortocircuitare l'anello ne lasciare aperto l'anello, ma devo dare alla centrale un valore corretto riconosciuto dal tamper, di norma i valori sono standard e non posso dirti quali, meglio che ne crei uno tu.
Poi esistono in tutti i componenti microswitch antiapertura, antistrappo, sistemi antimascheramento intelligenti (porre un oggetto freddo permanente davanti a sensori) ecc ecc che lavorano 24h su 24h per i motivi sopradescritti
Posso strappare una sirena autoalimentata e buttarla in un secchio d'acqua anche se hai messo un antischiuma al suo interno.
Posso rendere inefficace un combinatore gsm se non hai previsto un anti hammer nei paraggi.
Cosa vuoi sapere con esattezza?
pablos:
L'antimanomissione sui cavi viene fatta in 2 modi che in tutte le centrali viene chiamato tamper. Queste linee di protezione lavorano 24h su 24h e forniscono un allarme anche a impianto disinserito proprio per evitare che il tapezziere, idraulico, elettricista casuali possano manomettere l'impianto per tornare in un secondo momento all'insaputa dei proprietari, ne esistono di 2 tipi.
- con sistema di continuità, ovvero taglio cavi
- con sistema a bilanciamento
Nel primo caso (continuità): 2 conduttori creano un circuito chiuso lungo il cavo che generano un allarme quando il cavo viene di netto tranciato, il tallone di achille di questo sistema è che posso sguainare i cavi e trovare la coppia da cortocircuitare a monte per poi tagliare il cavo illudendo il sistema.
Nel secondo caso, una resistenza crea una tensione di un certo valore detto bilanciato (che non è ne 0v ne 12v) quindi non posso ne cortocircuitare l'anello ne lasciare aperto l'anello, ma devo dare alla centrale un valore corretto riconosciuto dal tamper, di norma i valori sono standard e non posso dirti quali, meglio che ne crei uno tu.
Poi esistono in tutti i componenti microswitch antiapertura, antistrappo, sistemi antimascheramento intelligenti (porre un oggetto freddo permanente davanti a sensori) ecc ecc che lavorano 24h su 24h per i motivi sopradescritti
Posso strappare una sirena autoalimentata e buttarla in un secchio d'acqua anche se hai messo un antischiuma al suo interno.
Posso rendere inefficace un combinatore gsm se non hai previsto un anti hammer nei paraggi.Cosa vuoi sapere con esattezza?
Il secondo metodo devo mettere due cavi uno che trasmette e l'altro che riceve per collegarli tra loro devo mettere una resista(ad esempio 220ohm) vero?
Non è una trasmissione dati, è un contatto chiuso o aperto verso gnd, se vuoi farlo bilanciato dovrai usare un ingresso analog con laresistenz leggi il valore analog che ti entra con un piccolo range, attenzione che deve essere stabile quindi ti conviene usare l'AREF e un alimentatore ben stabilizzato.
ciao
forse con un disegno capisci meglio
Brunello:
forse con un disegno capisci meglio
ho messo una resistenza al gnd e una a +5 ,il valore lo leggo con il pin analogico ma non so come implementarlo nello sketch
mattdj:
ho messo una resistenza al gnd e una a +5 ,il valore lo leggo con il pin analogico ma non so come implementarlo nello sketch
... perdona, ma qui siamo veramente alle basi !!!
Non puoi pensare di partire con un progetto di una centrale antifurto con tanto di anti-tamper e self-test ... senza sapere le basi di Arduino e della sua programmazione !
Tu bisogna che ti prendi uno starter kit e ti fai tutti gli esercizi, così impari le varie funzionalità, ti studi il C/C++ e ... quando sarai pronto, potrai passare a cose più complesse come questa che vuoi fare.
Così come stai messo, non arrivi da nessuna parte e ... non puoi pretendere che il lavoro te lo facciamo noi ... 
Guglielmo
concordo con Guglielmo....
il forum serve per superare dei momenti di impasse... quando per un motivo o un'altro non ci si arriva da soli...
e basta, tanto hai capito
gpb01:
mattdj:
ho messo una resistenza al gnd e una a +5 ,il valore lo leggo con il pin analogico ma non so come implementarlo nello sketch... perdona, ma qui siamo veramente alle basi !!!
Non puoi pensare di partire con un progetto di una centrale antifurto con tanto di anti-tamper e self-test ... senza sapere le basi di Arduino e della sua programmazione !
Tu bisogna che ti prendi uno starter kit e ti fai tutti gli esercizi, così impari le varie funzionalità, ti studi il C/C++ e ... quando sarai pronto, potrai passare a cose più complesse come questa che vuoi fare.
Così come stai messo, non arrivi da nessuna parte e ... non puoi pretendere che il lavoro te lo facciamo noi ...
Guglielmo
CIao fino a qui ci sono arrivato adesso non mi resta che implementare il test .Ho solamente un problema che se stacco una resistenza suona(quindi funziona) ma quando la riattacco smette di suonare.In allegato lo sketch:
int Chiave;
int Sensore;
int Led=3;
int Variabile;
int Allarme=0;
int Luce;
int Anti;
int Ant;
int Anti2;
void setup()
{
Serial.begin(9600);
pinMode(A0,INPUT); //Sensore PIR
pinMode(6,INPUT);
pinMode(4,INPUT); //Chiave
pinMode(3,OUTPUT); //LED
pinMode(13,OUTPUT);
pinMode(5,OUTPUT);
}
void loop()
{
Chiave=digitalRead(4);
Sensore=digitalRead(6);
Anti=analogRead(A0);
Anti2=(Anti-840);
if ((Anti2>100) || (Anti2<88) || (Ant==1))
{
Ant=1;
Allarme=1;
Serial.println("Attenzione Cavo reciso");
tone(13,1700);
delay(1000);
}
else if((Chiave==LOW) && (Variabile==0) && (Ant==0))
{
tone(13,1700);
delay(500);
noTone(13);
delay(500);
tone(13,1700);
delay(500);
noTone(13);
Variabile=1;
}
else if ((Chiave==HIGH) && (Variabile==1) && (Ant==0))
{
Variabile=0;
}
if((Variabile==1) && (Sensore==LOW) && (Allarme==0) && (Ant==0))
{
Serial.println("Allarme Inserito");
delay(5000);
Serial.println("Zona 1 OK!");
digitalWrite(3,LOW);
digitalWrite(5,HIGH);
}
else if((Variabile==1) && (Sensore==HIGH) && (Allarme==0) && (Ant==0))
{
Serial.println("Pre-Allarme");
delay(20000);
Allarme=1;
Serial.println("Attenzione!Zona 1");
tone(13,1700);
delay(1000);
Luce=1;
}
else if((Variabile==0) && (Sensore==LOW) && (Ant==0))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
}
else if((Chiave==HIGH) && (Sensore==HIGH) && (Ant==0))
{
noTone(13);
Serial.println("Allarme Disinserito");
digitalWrite(3,HIGH);
digitalWrite(5,LOW);
Luce=0;
Allarme=0;
}
else if (Luce==1)
{
noTone(13);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
delay(250);
digitalWrite(5,HIGH);
delay(250);
digitalWrite(5,LOW);
}
Quando vai in allarme ti salvi il "momento" in cui la cosa accade in una variabile di tipo unsigned long ... il "momento" te lo da la funzione millis().
Nel loop, quando allarme torna a 0 (ovvero non c'è più condizione di allarme) tu non spegni subito la segnalazione, ma verifichi se, dal "momento" che ti sei segnato al "momento attuale" sono passati X secondi. Se si spegni, altrimenti continui a suonare.
Per imparare i concetti di millis() e come usarla ... prima studia QUESTO e poi QUESTO.
Guglielmo