automazione tapparelle

elettrico:
si potrebbe mettere 2 contatti in serie up e dn in serie a T cosi la temporizzazione inizia quando si rilasciano i pulsanti cosa ne dici?

Si questa parte funzionerebbe, a meno di guasto nel cablaggio o di deviatori al posto dei pulsanti come mi è capitato di vedere.

Invece la fermata (premendo il pulsante opposto al movimento) farebbe subito ripartire in senso opposto. Il relé R in pratica non interviene mai, e anche ammesso che riuscisse ad attrarre darebbe giusto un impulso.

Per farlo attrarre in un circuito reale, 'A' e 'B' dovrebbero essere ritardati alla caduta. Mentre nel circuito simulato l'espressione di 'R' andrebbe scritta prima di quelle di 'A' e 'B' (o in alternativa bisognerebbe fare un aggiornamento sincrono delle variabili). Ma darebbe sempre un singolo impulso. Lo scopo principale di R è proprio quello di tenere bloccato tutto quando si preme il pulsante di fermata e aspettare il rilascio dei pulsanti.


Comunque per curiosità ho voluto vedere quanto verrebbe complesso il circuito con le specifiche iniziali complete, che quindi comprendono: "1 pulsante di salita generale PGEN_UP che premuto arresta ogni movimento e la faccia salire tutte con autoritenuta. 1 pulsante di discesa generale PGEN_DW che premuto arresta ogni movimento e la faccia scendere tutte con autoritenuta. Un tempo di attesa fra eventuale inversione da una direzione all'altra."

Rimane il problema che se una tapparella sta già scendendo, il comando generale di discesa la ferma, o, in alternativa, non si potrebbe fermare nulla dal generale. Ma questo è un problema non risolvibile, in quanto intrinseco nelle specifiche di fermata che non distinguono tra pulsante su o giù (come invece fa il mio schema).

I relé 'W' e 'Z' si attivano quando viene dato il comando generale opposto al movimento attuale, e dopo mezzo secondo si attiva il movimento opposto.

È evidente che senza modifiche non sarebbe praticamente realizzabile per l'esagerato numero di contatti, ma la versione simulata con Arduino non ha questi vincoli, le espressioni potrebbero considerare senza alcun problema decine di contatti.

nel post 27 si parla di alimentare arduino e gli ingressi con un atensione di 12v per poi abbassarla.
Quindi se si alimenta il tutto con un 5vcc direttamente con un unico alimentatore che posizionerei nel quadro generale potrei avere dei malfunzionamenti del tipo che causa disturbi sugli ingressi le tapparelle potrebbero aprirsi o chiudersi da sole?

elettrico:
se si alimenta il tutto con un 5vcc direttamente con un unico alimentatore che posizionerei nel quadro generale potrei avere dei malfunzionamenti

Si, è cercarsi dei guai. I 5V della logica devono essere assolutamente stabili e "locali". Altrimenti qualsiasi tipo di disturbo può causare effetti imprevedibili (non solo errori nella lettura degli ingressi, ma anche reset dei micro, malfunzionamenti dell'oscillatore, errori nel funzionamento del programma).

A dire il vero sarebbe meglio non portare in giro neanche la massa e optoisolare ogni linea remota. Idealmente ogni elemento di controllo dovrebbe essere un'isola... ma anche penjsola può funzionare benissimo lo stesso, purché tutte le linee prolungate non attraversino mai direttamente la logica. Nel caso di ingressi uscite si mettono come minimo delle resistenze di disaccoppiamento in serie ai pin. Nel caso della massa comune, le masse remote vanno all'alimentatore (o al punto più vicino possibile ad esso).

potresti farmi un esempio data la mia scarsa conoscenza dell'elettronica?

Esempio di cosa di tutte le cose dette?

un esempio di resistenze di disaccoppiamento in serie ai pin se si utilizzasse una tensione di 5vcc

È la resistenza da 10kΩ del post #31. Fondamentalmente evita che i semiconduttori dell'ingresso siano direttamente "esposti" alla linea esterna lunga e ai suoi disturbi (il condensatore, facoltativo, forma un filtro RC con la duplice funzione di debounce e di abbattimento di eventuale radiofrequenza captata dai fili).

Su un'uscita invece può andare bene una resistenza da 220Ω.

Questo discorso vale per ingressi e uscite prolungati senza optoisolatori.

ho modificato lo schema post #39, credo di averlo migliorato

inoltre ho disegnato il circuito di alimentazione arduino e modificato quello del post #31 come mi suggerisce claudio_FF spero di aver capito bene

dato che ogni arduino comanda un solo rele alla volta è possibile omettere il transistor e resistenze come da schema trovato nei vari forum e lasciare solo il diodo?

il cavo che trasporta il 5vcc e i pulsanti generali (cavo 4x0.50) è nello stesso tubo con i conduttori 220v che alimentano le tapparelle
tutta la tratta, cio dall'alimentatore ai pulsanti generali per poi andare su tutti gli arduino potrebbe essere lunga anche 70-80 mt, ci potrebbereo essere disturbi di malfunzionamento?

elettrico:
inoltre ho disegnato il circuito di alimentazione arduino e modificato quello del post #31 come mi suggerisce claudio_FF spero di aver capito bene

Ehmm... diciamo che non c'è una sola cosa giusta:

  • Mancano le resistenze di pull-up/down per gli ingressi
  • i terminali C-E dei transistor sono invertiti (e spero siano NPN)
  • alimentazione remota 5V che come già detto espone ad ogni più piccolo disturbo
  • parallelo dei comandi generali realizzato con il parallelo diretto sui pin di ingresso, anche qui antenne perfette per captare ogni disturbo e far resettare gli Arduino ad ogni scatto dei relé

dato che ogni arduino comanda un solo rele alla volta è possibile omettere il transistor e resistenze come da schema trovato nei vari forum e lasciare solo il diodo?

Un relé 5V richiede come minimo 70..100mA, un'uscita di Arduino può gestire una ventina di mA al massimo.

il cavo che trasporta il 5vcc e i pulsanti generali (cavo 4x0.50) è nello stesso tubo con i conduttori 220v che alimentano le tapparelle

Ok, sei elettricista, ti modifichi l'impianto come vuoi, ma per non incorrere in violazioni del regolamento meglio non toccare più il tasto 220.

Comunque quel cavo, non schermato (quindi sensibile ai campi elettrici), non twistato (quindi sensibile ai campi magnetici), promiscuo per quasi 100 metri (quindi accoppiato capacitivamente e induttivamente), è sicuramente fonte di guai, soprattutto se si insiste a voler usare i 5V.

Uno schema con cui mi sentirei un minimo "al sicuro" (ma non è detto al 100%) può essere il seguente. Gli ingressi vanno configurati in modalità PULLUP. Tutti gli ingressi non usati andrebbero configurati come uscite oppure andrebbero attivate le resistenze di pull-up interne.

avrei pensato a questa soluzione:
i pulsanti in loco distano di 2-3mt quindi collegati direttamente su arduino,
mentre con i pulsanti generali che distano parecchi metri potrei comandare dei relè e il contatto chiude poi l' ingresso che ne dite? evito i disturbi? potrei comandare i relè a 24 vdc e modificare l'alimentazione di arduino che anziché 12vcc diventa 24vcc
allego uno schema per 1 arduino

il pulsante PGUP comanderà tanti rele RGUP
cosi come il pulsante PGDW tanti rele RGDW

Usare relé ausiliari per i comandi generali sicuramente "separa dai disturbi". Alzare la tensione a 24Vcc comporta il dover rivedere bene la parte alimentazione degli arduini e il collegamento degli ingressi locali. E a proposito di ingressi locali quelli dello schema sono sempre a 0V. Infatti sono tenuti normalmente a zero dalla resistenza, e premere i pulsanti non fa che chiudere ancora verso zero.

Questo può essere un modo per collegare i pulsanti remoti (a sinistra) e locali (a destra, sia in versione 12 che 24V)

grazie ai consigli ho cercato di scrivere questo sw ma non va
sapete dirmi dove sbaglio? forse per la contemporaneità dei contatti? allego schema

                          // COMANDI SALITA

  #define P_UP         2            // pulsante salita locale
  #define PGEN_UP      4            // pulsante salita Generale
  #define RELEUP       9            // relè comando salita
  #define PRESS_LEVELUP  HIGH       // livello ingresso salita locale  premuto
  #define PRESS_LEVELGENUP  HIGH    // livello ingresso salita generale  premuto
  #define ON_LEVELUP     HIGH        // livello uscite accese
  #define OFF_LEVELUP !ON_LEVELUP   // livello uscite spente
  


                         //COMANDI DISCESA

  #define P_DW          3            // pulsante discesa locale
  #define PGEN_DW       5            // pulsante discesa generale
  #define RELEDW       10            // relè comando discesa
  #define PRESS_LEVELDW  HIGH        // livello ingresso discesa locale premuto
  #define PRESS_LEVELGENDW  HIGH     // livello ingresso discesa generale premuto
  #define ON_LEVELDW     HIGH         // livello uscite accese
  #define OFF_LEVELDW !ON_LEVELDW    // livello uscite spente
 
 


//-------------------------------------------------------------------------------

  void setup()
  {
                   //DICHIARAZIONE PIN DI SALITA
 
  pinMode(P_UP, INPUT);
  pinMode(PGEN_UP, INPUT);
  pinMode(RELEUP, OUTPUT);
  digitalWrite(RELEUP, OFF_LEVELUP);
  
                 //DICHIARAZIONE PIN DI DISCESA
  
  pinMode(P_DW, INPUT);
  pinMode(PGEN_DW, INPUT);
  pinMode(RELEDW, OUTPUT);
  digitalWrite(RELEDW, OFF_LEVELDW);
  
  }

                //Definizione variabili di lavoro globali
                
  byte A = 0;   
  byte B = 0;
  byte RUP = 0;
  byte RDW = 0;
  byte X = 0;
  byte Y = 0;
  byte Z = 0;
  byte W = 0;
  byte T1 = 0;
  byte T2 = 0;
  byte T3 = 0;
  uint32_t t1=0;
  uint32_t t2=0;
  uint32_t t3=0;
  


//---------------------------------------------------------------------------------------------------------
                    
  void loop()
  {                     
                        //LOOP DI SALITA LOCALE


                     
  // Lettura ingressi per la salita (serve debounce hardware)
  
  byte up = (digitalRead(P_UP) == PRESS_LEVELUP);
  byte gup = (digitalRead(PGEN_UP) == PRESS_LEVELGENUP);
            
           
  // Rung
  A = ( up | T3 | A  ) & !B & !RUP & !T1;
 

  // Aggiornamento uscite con interblocco
  digitalWrite(RELEUP, (A & !B) ? ON_LEVELUP : OFF_LEVELUP);
   
  
  //--------------------------------------------------------------------

                     //LOOP DI DISCESA LOCALE

  // Lettura ingressi per la discesa (serve debounce hardware)
  
  byte dw = (digitalRead(P_DW) == PRESS_LEVELDW);
  byte gdw = (digitalRead(PGEN_DW) == PRESS_LEVELGENDW);
  
  
  // Rung             
  B = ( dw | T2 | B ) & !A & !RDW & !T1;
  
    // Qui imposto il tempo per il timeout delle tapparelle in discesa
   

  // Aggiornamento uscite con interblocco
  digitalWrite(RELEDW, (B & !A) ? ON_LEVELDW : OFF_LEVELDW);
  

 //------------COMANDO RESET DEI MOVIMENTO-------------------------------------

 
 
  // Lettura ingressi (serve debounce hardware)
   
                    // qui memorizzzo che sono in SALITA con il pulsante LOCALE             
  X = (( A & !up ) | X ) & !B & !RUP & !T1;
  
                    // qui memorizzzo che sono in DISCESA con il pulsante LOCALE
  Y = (( B & !dw ) | Y ) & !A & !RDW & !T1;
   
                  // qui memorizzzo che voglio andare in Discesa con il pulsante GENERALE
  W = (( gup & A ) | W );

                 // qui memorizzzo che voglio andare in SALITA con il pulsante GENERALE
  Z = (( gdw & B ) | Z );

                  // qui arresto i movimento in salita 
  RUP = ( ( up | gdw ) & X ); 

                   // qui arresto i movimenti in discesa
  RDW = ( ( dw | gup ) & Y ); 



  
                   // qui arresto i movimenti con un timeout GENERALE  dopo 5 secondi
   T1 = 0;
   if( A & B ) 
   {
   t1 = millis();  
   }
   else if(millis() - t1 >= 20000) T1 = 1;

                   // qui comando la discesa dopo 0.5 secondi che ho rilasciato il pulsante di DISCESA GENERALE
                   // questo serve a fare in modo che se una tapparella stava andando in salita si ferma e riparte dopo il tempo
  T2 = 0;
  if(!gdw & W ) 
   {
   t2 = millis();  
   }
   else if(millis() - t2 >= 500) T2 = 1;

                   // qui comando la discesa dopo 0.5 secondi che ho rilasciato il pulsante di SALITA GENERALE
                   // questo serve a fare in modo che se una tapparella stava andando in discesa si ferma e riparte dopo il tempo

  T3 = 0;
  if(!gup & Z ) 
   {
   t3 = millis();  
   }
   else if(millis() - t3 >= 500) T3 = 1;



}

Sono sbagliate le condizioni dei timer. Queste quelle corrette:

  if( !(A | B) ) { T1=0;  t1=millis(); } 
    else if(millis() - t1 >= 20000) T1 = 1;

    if( !(!gdw & W) ) { T2=0;  t2=millis(); } 
    else if(millis() - t2 >= 500) T2 = 1;

    if( !(!gup & Z) ) { T3=0;  t3=millis(); } 
    else if(millis() - t3 >= 500) T3 = 1;

In pratica la condizione dell'if è quella per cui il relé/timer deve essere disattivo, cioè l'inverso dei contatti.
Applicando De Morgan si possono anche semplificare rispettivamente in:

if(!A & !B)
if(gdw | !W)
if(gup | !Z)

grazie claudio ho modificato le condizioni ma il sw continua a fare quello che vuole
un esempio
ho impostato T1 a 5 secondi per accorciare i tempi

dopo aver scaricato sw tutto a riposo
premo P_UP il rele A va alto, dopo 5 secondi va basso e automaticamente va alto il B che dopo 5 secondi si diseccita
a volte questo giochetto di A e B continua per diverse volte e a volte dopo alcuni cicli il rele A rimane alto e si diseccitab premendo PG_DW e il giochetto ricomincia
a volte dopo 1 ciclo i rele sono entrambi bassi e premendo un pulsante qualsiasi non succede nulla, bisogna spegnere o scaricare sw per far si che si possa riprovare la sequenza

Questo ha tutta l'aria di un problema hardware, non software. Perché fosse software avrebbe un comportamento costante

Non so come risolvere, ma penso che per testare basterebbe aggiungere l'uso della seriale (visto che il progetto non funziona ancora mi auguro sia possibile farlo) e verifiare lo stato percepito dei tasti.

A occhio è sbagliato anche lo schema elettrico dei relé simulati, non è possibile che i relè 'W' e 'Z' una volta attratti non cadano più.

a questo punto credo che il problema sia nella parte hardware
ho utilizzato negli ingressi resistenze e condensatore diverse dallo schema proposto, in quanto da una prima prova sembravano funzionare

a questo punto credo che il problema sia nella parte hardware
ho utilizzato negli ingressi resistenze e condensatore diverse dallo schema proposto, in quanto da una prima prova sembravano funzionare

I due circuiti di ingresso postati non fanno alcuna differenza nelle prove, ma una R pull-down da 1k invece che 10k aiuta contro i disturbi.

Se temi che ci sia un problema hardware puoi replicare il circuito di arduino sul simulatore tinkercad, li sicuramente falsi contatti non ne hai.

circuito-tinkercad_.png

L'unica accortezza è aggiungere un piccolo delay(10); come ultima istruzione del loop per aiutare il simulatore a mostrare i corretti tempi di avanzamento.

Così avrai un arduino simulato, senza problemi di debounce, che esegue a sua volta dei relé simulati :slight_smile:

Normalmente preferisco sempre test su circuiti reali, ma in un caso come questo dove di fatto possiamo testare tutto solo con pulsanti e LED può essere di aiuto.