Controllo elettrovalvola

[Livio Orsini]

l'elettrovalvola in questione è praticamente un  relè, dove al posto dell'ancoretta che apre dei contatti elettrici, c'è un otturatore meccanico che apre o chiude un circuito fluidico.

Potresti alimentare un relè in rampa? Ci hai mai provato? Io da giovane ho fatto anche questa nefandezza e ti assicuro che ui risultati non sono belli.

[gabri-z]

 

Quote

 

Potresti alimentare un relè in rampa? Ci hai mai provato? Io da giovane ho fatto anche questa nefandezza e ti assicuro che ui risultati non sono belli.

 

L'ho sempre evitato , forse perché qualcosa mi diceva che non va bene ..cosi , ho domandato !

Visto che li andrebbe bene usare i MOS-FET che ha già (sono gratis ) , e per 50 ms dalla accensione dovrebbero supportare il doppio della loro corrente , mi domandavo , a voce alta  , come fare .

[Livio Orsini]

2 MOSFET in parallelo, con piccoli resitori di gate per equilibrare il carico, però è una soluzione schifosissima.

[gabri-z]

D'accordo, ma visto che " il lavoro " e' da regalare, meno costa , meglio e' ; importante è che svolga il suo compito senza errori !

Magari può incidere sul PCB : Fatto in condizioni di massimo risparmio ! haha.

[dott.cicala]

Dopo un mese di collaudi e maltrattamenti di ogni genere....è venuto fuori questo....nell'ottica del massimo risparmio e cercando di realizzare qualcosa di decente.

 

 

E' capace di rilevare solenoidi interrotti e in corto.....senza che scoppi niente!

[gabri-z]

Dott " , ci metti alla prova ? Haha!

Sei certo di aver collegato così il 7805 ?

[dott.cicala]

Ovviamente  non è così

[dott.cicala]

Dopo una lunga e attenta analisi con il  Project Manager e previa sua approvazione, abbiamo deciso di chiamare questa centralina:

SalvaValvolaPinuccia

[gabri-z]

Interrotta , in corto , ma se ha qualche spira in corto , la sente ?

[dott.cicala]

Il controllo è sulla corrente e quindi tutto dipende da quanto aumenta, altrimenti avrei dovuto controllare il flusso, ma la cosa sarebbe diventata molto più complicata

[gabri-z]

E .... per un regalo e' già tanto cosi ! Haha!

[dott.cicala]

Dopo essermi consultato con l' Electronic Development Engineer (che sarei io) e ottenuta l'approvazione alla pubblicazione, ecco lo schema corretto del

"SalvaLaValvolaPinuccia"

Il solo schema però non è molto esplicativo e quindi, dopo aver ottenuto l'approvazione del Software Development Engineer (che sarei io)

abbiamo deciso di pubblicare il firmware ed eventualmente provvedere alla sua descrizione riga per riga.

//******************************************************************************
// Project :            Valve Control
// Author  :            S.T.
// Date    :            30/01/2016
// MCU     :            PIC12F1572 - INT.OSC. 32MHz
// Compiler:            MikroC PRO for PIC V6.6.3
//******************************************************************************
//****** I/O *******************************************************************
       sbit Start    at RA0_BIT;  // Pushing Button
       sbit LedG     at RA4_BIT;  // Green Led
       sbit LedR     at RA5_BIT;  // Red Led
//****** TAGs ******************************************************************
       sbit Load     at PWM1LDCON.B7;
       unsigned int  DcSel=0, Dc1=0, Doff=0, Dtest=128, Dwork=1022;
       unsigned int  ActCurr, LoCurr=64, ShCurr=1000, WrkCurr=512;
       unsigned int  Cnt, Cnt1=100, Cnt2=50;
       short         blk1, blk2, blk3, tmr=6;
       bit           lOpen, lShort, lGood, lBad, wrk;
//******************************************************************************
//* SetUp
//******************************************************************************
void setup()
     {
//******************************************************************************
//                          OSCILLATOR REGISTER
//******************************************************************************
       OSCCON  = 0XF0;     // Int Osc 32MHz 4xPLL ON
//******************************************************************************
//                           PORT[A] REGISTERS
//******************************************************************************
       WPUA    = 0X00;     // PULL UP WEAK RESISTORS 0=Off - 1=On
       ANSELA  = 0X04;     // ANALOG INPUTS - Ai=RA2
       INLVLA  = 0X01;     // INPUTS Ctrl. 0=TTL-1=Scmitt Triggered
       TRISA   = 0X0D;     // RA0-RA2-RA3=INPUT   RA1-RA4-RA5=OUTPUT
//******************************************************************************
//                            OPTION REGISTER
//******************************************************************************
       OPTION_REG  = 0X04; // Prescaler Rate 32
//******************************************************************************
//                            INTCON REGISTER
//******************************************************************************
       INTCON.TMR0IE  =1;  // TMR0 Overflow Interrupt Enable bit
       INTCON.GIE     =1;  // Global Interrupt Enable bit
//******************************************************************************
// Registri configurazione 16-BIT PWM MODULE
//******************************************************************************
//----RA1 - PWM1 ---------------------------------------------------------------
       PWM1CON   = 0XC0;   // module en, output en, norm pol, standard m.
       PWM1CLKCON= 0X21;   // HFINTOSC clock, Prescaler /4
       PWM1PR    = 0x3FF;  // PWM PERIOD COUNT REGISTER
       PWM1PH    = 0x3FF;  // PWM PHASE  COUNT REGISTER
       PWM1DC    = 0X0;    // PWM DUTY CYCLE COUNT REGISTER
}
//******************************************************************************
//* BLINK RED
//******************************************************************************
void blinkR()
     {
       LedG =0;
       if(blk1<10)
        {
         blk1++;
        }
       if(blk1>=10)
        {
         LedR=~LedR;
         blk1 = 0;
        }
     }
//******************************************************************************
//* BLINK GREEN
//******************************************************************************
void blinkG()
     {
       LedR =0;
       if(blk2<10)
        {
         blk2++;
        }
       if(blk2>=10)
        {
         LedG=~LedG;
         blk2 = 0;
        }
     }
//******************************************************************************
//* BLINK RED/GREEN
//******************************************************************************
void blinkRG()
     {
       if(blk3<25)
        {
         blk3++;
        }
       if(blk3>=25)
        {
         LedG=~LedG;
         LedR=!LedG;
         blk3 = 0;
        }
     }
//******************************************************************************
//* Load OFF
//******************************************************************************
void noCmd()
     {
     DcSel = Doff;
     LedG  = 0;
     LedR  = 0;
     lOpen = 0;
     lShort= 0;
     lGood = 0;
     blk1  = 0;
     blk2  = 0;
     blk3  = 0;
     wrk   = 0;
     Cnt   = 0;
     }
//******************************************************************************
//* Load Test
//******************************************************************************
void test()
     {
       DcSel = Dtest;
       LedR  = 0;
       blinkG();
     }
//******************************************************************************
//* Load OK - Full Activation - green led on
//******************************************************************************
void work()
     {
       DcSel = Dwork;
       wrk   = 1;
       LedG  = 1;
       LedR  = 0;
     }
//******************************************************************************
//* Load Test: Short - red led on
//******************************************************************************
 void Cshort()
     {
       DcSel = Doff;
       blinkR();
     }
//******************************************************************************
//* Load Test: Open - red led blinking
//******************************************************************************
 void Open()
     {
       DcSel = Doff;
       blinkR();
     }
//******************************************************************************
//* Load Test: Bad - red-green leds blinking
//******************************************************************************
 void Bad()
     {
       if(DcSel<Dwork)
        {
         DcSel++;
        }
       blinkRG();
       if(DcSel>=Dwork)
        {
        work();
        }
     }
//******************************************************************************
//* Current Check
//******************************************************************************
 void CurChk()
     {
       ActCurr =ADC_Read(2);
//************************************************************
//* shorted coil
//************************************************************
       if(ActCurr>=ShCurr)
        {
         lShort = 1;
        }
//************************************************************
//* Open coil
//************************************************************
       if(ActCurr<=LoCurr)
        {
         lOpen = 1;
        }
//************************************************************
//* Bad coil
//************************************************************
   lBad=!Open&!lShort&!lGood&!wrk;
//************************************************************
//* Good coil
//************************************************************
   lGood=!lShort&!lOpen&(ActCurr>=WrkCurr)&(ActCurr<ShCurr);
//************************************************************
//* step counter
//************************************************************
       Cnt++;
       if(Cnt>=Cnt1)
        {
         Cnt=Cnt2;
        }
     }
//******************************************************************************
//* PWM
//******************************************************************************
void pwm()
     {
      if(Dc1!=DcSel)
       {
        Dc1    = DcSel;
        Load   = 1;
        PWM1DC = Dc1;
       }
      }
//******************************************************************************
//* SWEEP
//******************************************************************************
void sweep()
     {
      TMR0=tmr;
      INTCON.TMR0IF=0;
     }
//******************************************************************************
//* MAIN
//******************************************************************************
void main()
     {
      setup();
      noCmd();
     }
//******************************************************************************
//* INTERRUPT 1ms
//******************************************************************************
void interrupt()
     {
      if(Start)
       {
       CurChk();
       if(Cnt<Cnt2)test();
       if(Cnt>=Cnt2)
        {
         if(lShort)Cshort();
         if(lOpen)   Open();
         if(lGood)   work();
         if(lBad)     Bad();
        }
       }
      if(!Start)
        {
         noCmd();
        }
      pwm();
      sweep();
     }

 

[gabri-z]

Quote

 

dott.cicala

Utente con >1600 post

Utenti PLC Forum +

2879 discussioni

Inserito il: 13 febbraio · Segnala abuso

O controllato......il mos ce la fa

 

 

 

Dott'' , ci prendi in giro , dove l'hai trovato questo ?  Mi sono pulito gli occhiali due volte e non ci credevo lo stesso  , un secchio ( anche due ) di.........Amper  

'sta volta non credo che servano due in parallelo .......

[Livio Orsini]

Perchè non lo hai ralizzato con arduino?

[dott.cicala]

Ce la faceva anche l'altro, solo che aveva una RDSon troppo alta essendo un NMOS da 600V....e tra resistenza di shunt e RDSon la caduta di tensione era eccessiva, funzionava ugualmente, ma ai capi della valvola, che poi è diventata da 35VA, si avevano solo 21-22V....Così ho dovuto recuperare da RS questo bel mosfet...che è anche il componente più costoso di tutto il progetto.

 

Sto preparando una bella tabella con tutti i dati ricavati, in merito a tensioni-correnti-potenze dissipate in tutte le condizioni.

 

In pratica, nei primi 50ms il solenoide viene pilotato in pwm con duty cycle al 25%. La valvola non si muove, ma si riesce già a capire se è in corto, se non lo è, al 51° ms, il duty cycle viene portato al 100% e viene verificato se il solenoide è interrotto. Dopo la prima fase relativa all'accensione, la corrente è monitorata ogni ms e nel caso qualcosa non torni, viene spento tutto. I led generano varie segnalazioni con vari tipi di lampeggii o acensioni fisse.....non sarà il massimo....ma negli innumerevoli prototipi (1) funziona....

[dott.cicala]

Quote

Perchè non lo hai ralizzato con arduino

 

Perché....prima di tutto ci deve stare nel connettore della valvola....con arduino volevo fare il traccia curve che sto realizzando, ma poi, mi è salita l'antipatia alla 10⁹⁹  che ho deciso di farlo con il pic....anche se gestire il display da 5 pollici 65mila colori mi sta facendo un pochino capire quali sono i miei limiti attuali...ma ce la farò....non sono mica un ragioniere io  

ci vorrà un po' più di tempo.....e pensare che ero partito con un crt

[gabri-z]

Quote

 La valvola non si muove, ma si riesce già a capire se è in corto, se non lo è, al 51° ms, il duty cycle viene portato al 100% e viene verificato se il solenoide è interrotto

Hai avuto un motivo preciso o , è capitato di pensarlo cosi ? In teoria si poteva capire se è interrotta o no anche prima , o mi sbaglio ? Questione di programma , e non sei mica '' non sono mica un ragioniere io '' , con tutto il rispetto per il mestiere .

[dott.cicala]

Certamente...tutto il rispetto per il Ragionier Ugo Fantozzi e Colleghi.

 

Perché....tu come avresti fatto per capire se la sola è in corto? Cioè...come avresti sviluppato il SalvaLaValvolaPinuccia ?

 

Al momento l'idea che mi è venuta è stata quella di fornire un po' di energia al solenoide e misurarne l'assorbimento.

Risulta semplice ed economico il circuito e anche il firmware. I 50ms derivano da quanto sono riuscito a verificare dalla documentazione di vari produttori di elettrovalvole in merito alla extracorrente di eccitazione. Contemporaneamente, se la bobina fosse in corto, in 50ms l'energia che la resistenza di shunt deve dissipare è circa 10volte la sua nominale (30W circa) ma miracolosamente non esplode.

In realtà io ce  l'ho fatta a farla esplodere: basta mettere in corto la bobina e resettare ripetutamente....e infatti sto provvedendo ad introdurre una temporizzazione che eviti tutto questo. Nella pratica questo problema non c'è perché lo start viene dato da un interruttore il quale non si riesce a manovrare così rapidamente...ma già che ci sono....ho già discusso la questione con  Software Developer Engineer per il rilascio di una "revision" ....ma è uno sfaticato rompi balle

 

 

[gabri-z]

Quote

..ma è uno sfaticato rompi balle 

Fai come me , puniscilo ! 

Il circuito si può accorgere del mancato assorbimento anche prima del avvenuto ON ! se questo non crea complicazioni nel programma , o no ? 

Ma dai , Ti rendi conto (tutte le parole portano al .....ragioniere  , colpa di Livio ..) quanto risparmio se ci stavi nei 50 ms ......

[del_user_231807]

Complementi che ingegno. Vedo che avete portato la discussione ad un livello medio alto. Speriamo che qualche moderatore no chiuda la discussione rischiando di tappare i vostri concetti illuminanti.

 

[gabri-z]

Sei un ragioniere ?

[del_user_231807]

no e tu cosa fai nella vita. 

ragioni..

.......

[dott.cicala]

Allora....il controllo non dura 50ms....ne dura 51 

 

Per acquisire l'ingresso analogico bastano 15us al massimo, ma è il picco di corrente che produce il solenoide ad essere l'evento più duraturo...

 

Nelfrattempo...il ragioniere della ns. società "SalvaLaValvolaPinuccia" avvalendosi della collaborazione del Electronic Development Engineer e del Software Development Engineer...ovvero, avuto il benestare dei capi progetto....ha prodotto  la seguente tabella....

 

 

[gabri-z]

Tabella bocciata prima della lettura terminata  UM pot. solenoide 

[dott.cicala]

Quote

Speriamo che qualche moderatore no chiuda la discussione rischiando di tappare i vostri concetti illuminanti.

 

se la chiude, da bravi ragionieri, ce ne faremo una ragione.....

 

Quote

Tabella bocciata

perché...cosa c'è che non va?