Controllo elettrovalvola

[gabri-z]

Quote

, ce ne faremo una ragione.....

...ragionevole.....

UM della potenza solenoide , hai messo Amper 

[elettrodino]

Che pignoli sti ragionieri, vogliono la potenza in Watt 

[gabri-z]

  E no , VA  !

 

Avevo visto l'interrupt  da 1ms , ma potevi anche fare a meno ; tutta questa perdita di tempo .....''.'sto vizio maledetto , ed io ci rimetto ''

[dott.cicala]

 

E' il rischio che si corre ad affidare incarichi a ragionieri invece che a elettronici...

 

Mi ha corretto il VA perché pensava fosse Varese .....provvedo io direttamente....

 

 

[elettrodino]

Ma, non é  DC ??  poi "stona"con tutti i W espressi sotto

[gabri-z]

Quote

Mi ha corretto il VA perché pensava fosse Varese 

Behh , saprà qualcosa sulla storia dei ra...  non lo dico più perché potrebbe sembrare un'offesa .

[gabri-z]

Quote

Ma, non é  DC ?? 

Cosi ricordo anche io ma visto che non è una resistenza ...

[dott.cicala]

Si è DC, ma anche Rexroth una i VA sulle valvole 24Vdc....be...nei primi 50ms non siamo proprio in dc....

[dott.cicala]

Ma come funziona il firmware?

 

In pratica sulla generazione di un interrupt di TMR0.

 

TMR0 è un timer a 8 bit configurato per essere pilotato dal clock di sistema che è generato internamente alla mcu ed è ricavato dall'oscillatore interno settato a 8MHz e moltiplicato x4 dal moltiplicatore PLL.

Per incrementare il timer sono necessari 4 cicli di clock e arrivato all'overflow, cioè al passaggio da 255 a zero, viene generata una richiesta di interrupt.

Il timer, abbinato ad un prescaler settato con fattore di divisione 32,  è caricato con il valore 6.

 

Quindi la richiesta di interrupt verrà generata ogni:                                        Fclock                       

                                                                                                              4*Prescaler*(256-N)

 

dato che

Fclock      = 32MHz

Prescaler = 32

N             = 6  (valore caricato nel timer dal firmware)

 

micro secondo più, micro secondo meno, perché per scrive nel timer servono 2 cicli istruzione (ma non devo misurare periodi o frequenze e quindi a me non interessa) la richiesta di interrupt avverrà ogni 1000uS, cioè 1 ms.

 

 

 

[dott.cicala]

se volessimo a questo punto generare un onda quadra con duty cycle al 50% sfruttando la routine di interrupt

 

//******************************************************************************
//* INTERRUPT 1ms
//******************************************************************************
void interrupt()
     {
      PORTA.B7=~PORTA.B7;
     }

e sulla porta A pin 7, che non è presente nel 12F1572, ma il discorso è valido per qualsiasi mcu,

avremo un'onda quadra con duty cycle al 50% e con frequenza di 500Hz

[Livio Orsini]

Quote

con arduino volevo fare il traccia curve che sto realizzando

 

Io ogni tanto ci penso, così per il gusto di avere un tracciacurve, però ho sempre pensato di usare l'oscilloscopio come visualizzatore, così mi tolgo dai piedi un bel po' di problemi.

 

Quote

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

 

Augustoelektrico guarda che le discussioni non si chiudono ad libitum moderatori, bensì per ragioni precise, ovvero a violazioni del regolamento.

Se dovessi decidere ad libitum, per esempio, ti bloccherei l'account sino ad avvenuta modifica del nome  utente, visto che mal sopporto l'inutile uso delle "k".

[del_user_231807]

Livio, moderatamente eusastivo speriamo 

..... Che io me la cavo!

Augusto

[dott.cicala]

Trolls a parte.....questo è il firmware che include il ritardo  al reset dopo il rilevamento del solenoide in corto, scritto in mplabx-xc8

 

//******************************************************************************
// Project :            Valve Control
// Author  :            S.T.
// Date    :            30/03/2016
// MCU     :            PIC12F1572 - INT.OSC. 32MHz
// Compiler:            MPLABX V3.26 - XC8 V1.37
//******************************************************************************
#include <xc.h>
#include <stdlib.h>
#include <stdio.h>

// CONFIG1
#pragma config FOSC     = INTOSC // (INTOSC oscillator; I/O function on CLKIN pin)
#pragma config WDTE     = OFF    // Watchdog Timer Enable (WDT disabled)
#pragma config PWRTE    = ON     // Power-up Timer Enable (PWRT enabled)
#pragma config MCLRE    = ON     // MCLR Pin Function Select (MCLR/VPP pin function is MCLR)
#pragma config CP       = OFF    // Flash Program Memory Code Protection (Program memory code protection is disabled)
#pragma config BOREN    = OFF    // Brown-out Reset Enable (Brown-out Reset disabled)
#pragma config CLKOUTEN = OFF    // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin)

// CONFIG2
#pragma config WRT      = OFF    // Flash Memory Self-Write Protection (Write protection off)
#pragma config PLLEN    = ON     // PLL Enable (4x PLL enabled)
#pragma config STVREN   = ON     // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset)
#pragma config BORV     = LO     // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.)
#pragma config LPBOREN  = OFF    // Low Power Brown-out Reset enable bit (LPBOR is disabled)
#pragma config LVP      = ON  

//******************************************************************************
// Configurazione Frequenza Clock
//******************************************************************************
#define _XTAL_FREQ 32000000
//****** I/O *******************************************************************
#define Start PORTAbits.RA0
#define LedG  PORTAbits.RA4
#define LedR  PORTAbits.RA5
//****** TAGs ******************************************************************
#define load  PWM1LDCONbits.LDA
unsigned int  DcSel=0, Dc1=0, Doff=0, Dtest=128, Dwork=1022;
unsigned int  ActCurr, LoCurr=64, ShCurr=400, WrkCurr=140;
unsigned int  Cnt, Cnt1=100, Cnt2=50;
short         blk1, blk2, blk3, tmr=6;
bit           lOpen, lShort, lGood, lBad, wrk;
//******************************************************************************
//* SetUp
//******************************************************************************
void setup()
     {
//******************************************************************************
//                           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
//******************************************************************************
       INTCONbits.TMR0IE  =1;  // TMR0 Overflow Interrupt Enable bit
       INTCONbits.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;
     __delay_ms(500);
     }
//******************************************************************************
//* 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()
     {
      ADCON0bits.CHS0 =0;          // BIT0 - AN SELECTOR |
      ADCON0bits.CHS1 =1;          // BIT1 - AN SELECTOR |
      ADCON0bits.CHS2 =0;          // BIT2 - AN SELECTOR |- RA2 SELEZIONATO
      ADCON0bits.CHS3 =0;          // BIT3 - AN SELECTOR |
      ADCON0bits.CHS4 =0;          // BIT4 - AN SELECTOR |
      ADCON0bits.ADON =1;          // ATTIVO CONVERTITORE AD
      __delay_us(6);               // ATTENDO 6us
      ADCON0bits.GO   =1;          // ATTIVO LA CONVERSIONE
      __delay_us(11);              // ATTENDO 11us
      ActCurr     =ADRES;          // TRASFERISCO VALORE AD SU VARIABILE1
      ADCON0bits.GO   =0;          // DISATTIVO LA CONVERSIONE
      ADCON0bits.ADON =0;          // DISATTIVO CONVERTITORE AD     
//************************************************************
//* shorted coil
//************************************************************
       if(ActCurr>=ShCurr)
        {
         lShort = 1;
        }
//************************************************************
//* Open coil
//************************************************************
       if(ActCurr<=LoCurr)
        {
         lOpen = 1;
        }
//************************************************************
//* Bad coil
//************************************************************
   lBad=!lOpen&!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;
      INTCONbits.TMR0IF=0;
     }
//******************************************************************************
//* MAIN
//******************************************************************************
void main()
     {
      setup();
      noCmd();
     }
//******************************************************************************
//* INTERRUPT 1ms
//******************************************************************************
void interrupt Cycle1ms()
     {
      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();
     }