automazione tapparelle

Puso:
ci sono molti......#define...... e pochi boolean........in fondo un Relè , è o acceso oppure spento.

Una variabile bool si usa per chiarezza al posto di un byte 1 o 0, ma affinché vi sia la chiarezza il suo nome deve essere una domanda, e la risposta deve essere true o false. I nomi dei relé simulati A B X ecc non sono domande, in questo programma che simula solo un circuito elettrico con una logica "a contatti" non serve controllare l'esecuzione tramite if e variabili booleane.

Grazie Claudio_FF

ho disegnato alcune modifiche ma soprattutto ho collaudato i pulsanti in loco funzionano bene
al momento distano da arduino 1 metro e il debounce e nella breadboard con arduino nano

nella realta i pulsanti in loco distano 4 mt da arduino e i pulsanti generali anche 20 mt

al momento accendo 2 led

ho letto le caratteristiche di arduino nano

Tensione operativa: 5V
Input Voltage: (consigliata) 7-12V
Input Voltage: (limiti) 6-20V

e possibile alimentarlo direttamente al 12 V?

allego alcuni schemi

Per gli ingressi e alimentazione pensavo a qualcosa del genere:

tapparelle-nicolini2.png

i pulsanti generali sono collegati a tutti i pin 4 e 5 di uno o più arduino; nel mio caso 6 tapparelle
allego schema con 2 tapparelle

salve a tutti, con le mie poche conoscenze ho inserito un tempo di lavoro come nicolini2000 chiedeva

chiedeva anche:

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 di qualche millisecondo fra eventuale inversione da una direzione all'altra per fare in modo che i condensatori ancora carichi non incollassero i relè

questo non riesco a programmarlo, qualcuno ci da un'aiuto ?

nel post 31 claudio_ff ci fa vedere 2 pulsanti nello stesso ingresso; penso che si chiedeva un pulsante generale collegato in un'altro ingresso e ha una funzione diversa da quello locale; quello locale passa per uno stop, quello generale eventualmente arresta una tapparella che è in movimento e poi tutte ripartono verso la direzione voluta.

Grazie a chi ci darà qualche consiglio

allego file con con tempo di lavoro

/*VERSIONE CON TIMEOUT 

 
                          // COMANDI SALITA

  #define P_UP                     2                 // pulsante salita locale
  #define PGEN_UP               4                // pulsante salita Generale
  #define RELEUP                11                // relè comando salita
  #define PRESS_LEVELUP  HIGH             // livello ingressi premuti
  #define ON_LEVELUP     LOW                // 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 l
  #define RELEDW               12              // relè comando discesa
  #define PRESS_LEVELDW  HIGH           // livello ingressi premuti
  #define ON_LEVELDW     LOW              // livello uscite accese
  #define OFF_LEVELDW !ON_LEVELDW   // livello uscite spente



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

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

                //Definizione variabili di lavoro globali
                
  byte A = 0;   
  byte B = 0;
  byte R = 0;
  byte T = 0;
  byte X = 0;
  byte Y = 0;
  uint32_t t=0;


  


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


                     
  // Lettura ingressi per la salita (serve debounce hardware)
  
  byte up = (digitalRead(P_UP) == PRESS_LEVELUP);
            
           
  // Rung
  A = (up | A) & !B & !R & !T;

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

                     //LOOP DI DISCESA

  // Lettura ingressi per la discesa (serve debounce hardware)
  
  byte dw = (digitalRead(P_DW) == PRESS_LEVELDW);
  
  // Rung             
  B = (dw | B) & !A & !R & !T;

  // 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 per poi fermarla con un qualsiasi pulsante            
  X = ((A & !up) | X) & !B & !R & !T;
  
                    // qui memorizzzo che sono in discesa per poi fermarla con un qualsiasi pulsante 
  Y = ((B & !dw) | Y) & !A & !R & !T;
  
                   // qui arresto i movimenti premendo un qualsiasi pulsante 
  R = (up | dw) & ( X | Y | T | R);
                   // qui arresto i movimenti con un timeout dopo 10 secondi
  
  T = 0;
  
  if(!A & !B ) 
   {
   t = millis();  
   }
   else if(millis() - t >= 10000) T = 1;

}

>elettrico: essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO ... Grazie.

Guglielmo

elettrico:
salve a tutti, con le mie poche conoscenze ho inserito un tempo di lavoro come nicolini2000 chiedeva

Si, funziona, a meno che i relé A o B non impieghino più di 1192 ore per disattivarsi :slight_smile:

chiedeva anche:
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 di qualche millisecondo fra eventuale inversione da una direzione all'altra per fare in modo che i condensatori ancora carichi non incollassero i relè
questo non riesco a programmarlo, qualcuno ci da un'aiuto ?

È un comportamento abbastanza complesso, cioè la modifica allo schema richiede sicuramente l'aggiunta di altri quattro o cinque relé e uno o due temporizzatori. Per questo al post #4 proponevo un'alternativa molto più semplice, che addirittura riduce il numero di relé. Per salire (in qualsiasi situazione ci si trovi) basta fare due click su e per scendere idem. Per fermare basta un click nella direzione opposta al movimento attuale:

//---------------------------------------------------------------------------------------------------------
#define P_UP           2          // pin pulsante salita
#define RELEUP         11         // pin rele' comando salita

#define P_DW           3          // pin pulsante discesa
#define RELEDW         12         // pin rele' comando discesa

#define PRESS_LEVEL    HIGH       // livello ingressi premuti
#define ON_LEVEL       LOW        // livello uscite accese
#define OFF_LEVEL      !ON_LEVEL  // livello uscite spente

#define TIMEOUT_RL     20000      // timeout attivazione rele'
//-------------------------------------------------------------------------------
void setup()
{
    pinMode(P_UP, INPUT);
    pinMode(RELEUP, OUTPUT);
    digitalWrite(RELEUP, OFF_LEVEL);

    pinMode(P_DW, INPUT);
    pinMode(RELEDW, OUTPUT);
    digitalWrite(RELEDW, OFF_LEVEL);
}
//---------------------------------------------------------------------------------------------------------
//Definizione variabili di lavoro globali
byte A = 0;  
byte B = 0;
byte R = 0;
byte T = 0;
uint32_t t=0;
//---------------------------------------------------------------------------------------------------------
void loop()
{                    
    // Lettura ingressi (serve debounce hardware)
    byte up = (digitalRead(P_UP) == PRESS_LEVEL);
    byte dw = (digitalRead(P_DW) == PRESS_LEVEL);

    // Rung
    A = (up | A) & !B & !R & !T;
    B = (dw | B) & !A & !R & !T;
    R = (dw & A) | (up & B) | ( (up | dw) & (T | R) );

    // Timer
    if(!A & !B) { t = millis();  T = 0; }
    else if(millis() - t >= TIMEOUT_RL) T = 1;

    // Aggiornamento uscite con interblocco
    digitalWrite(RELEUP, (A & !B) ? ON_LEVEL : OFF_LEVEL);
    digitalWrite(RELEDW, (B & !A) ? ON_LEVEL : OFF_LEVEL);
}

nel post 31 claudio_ff ci fa vedere 2 pulsanti nello stesso ingresso; penso che si chiedeva un pulsante generale collegato in un'altro ingresso e ha una funzione diversa da quello locale; quello locale passa per uno stop, quello generale eventualmente arresta una tapparella che è in movimento e poi tutte ripartono verso la direzione voluta.

Mi sono rifatto allo schema del post #16 dove i due ingressi sono stati messi in OR a livello di contatti, diventando di fatto un solo ingresso.

Ma gli schemi (non bisogna per forza usare i miei ;)) sono li solo come esempio di conversione schema relé<->programma a contatti, in alternativa allo studio della programmazione C (che permetterebbe di fare le cose anche in altro modo abbandonando i relé simulati, o di fare cose che a relé simulati sarebbe troppo complicato).

ciao Claudio_FF, potresti spiegarmi a cosa serve la serie fra i 2 or UP e DW con T e R del post #35?
al posto di UP e DW dovrebbe essere A e B e il contatto R si potrebbe eliminare cosi, rispetto anche al post #4, vengono eliminati anche i relè X e Y e tutto si semplificherebbe

elettrico:
a cosa serve la serie fra i 2 or UP e DW con T e R del post #35?

Servono per non far ripartire un'altra sequenza nel caso in cui si stia tenendo un pulsante premuto a lungo. Appena nessun pulsante è più premuto R cade e il circuito è di nuovo pronto per una pressione.

non l'avevo considerato
io metterei in serie al contatto negato B un contatto negato di dn e in serie al negato di A un contatto negato di up cosi non cè nessuna sequenza che si sovrappone in caso di pulsanti premuti a lungo tempo

eliminerei i 2 or come ho scritto cosi semplifico

non necessariamente, 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?

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