automazione tapparelle

[nicolini2000]

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

[Claudio_FF]

Per gli ingressi e alimentazione pensavo a qualcosa del genere:

[nicolini2000]

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

[elettrico]

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

Code: [Select]

/*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;

}   
   

[gpb01]

>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

[Claudio_FF]

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

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:

Code: [Select]

//---------------------------------------------------------------------------------------------------------
#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).

[elettrico]

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

[Claudio_FF]

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.

[elettrico]

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?

[Claudio_FF]

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.

[elettrico]

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?

[Claudio_FF]

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).

[elettrico]

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

[Claudio_FF]

Esempio di cosa di tutte le cose dette?

[elettrico]

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