Diodi varicap & C.

[dott.cicala]

Come al solito, quando inizio la costruzione di un progetto mi capita che quel particolare componente non si faccia trovare. Sono fermamente convinto che si nasconda di proposito. Stavo cercando appunto dei varicap di bassa capacità, sicurissimo di averne un discreto numero, ma niente, si erano nascosti. 

Così, stufo di cercarli, e sapendo  che appena sospesa la ricerca salteranno fuori, mi è venuto in mente che quella particolare proprietà non è solo dei diodi varicap, ma è presente in tutti i semiconduttori.

 

Come verificarla nella maniera più semplice, senza arducosi o micro in genere, senza l'uso di capacimetri e/o frequenzimetri ma facendo uso solamente di un normalissimo tester?

 

Mi è venuto fuori questo

 

U1a è un oscillatore ad onda quadra la cui frequenza è definita da R2-C4. In parallelo a C4 c'è la giunzione di cui si vuole determinare la capacità.

(C4 deve essere di buona qualità e preferibilmente NP0)

Tramite RV1 si applica la tensione di polarizzazione, che qui arriva solo fino al valore della tensione di alimentazione (5-15v).

Per testare tutti i tipi di varicap servirebbe arrivare fino a 33v...ma chi si accontenta gode.

 

L'oscillatore pilota uno dei due monostabili presenti nel 4538, la cui costante di tempo è determinata da R3-C5. Sull'uscita Q al pin 6 si avrà una frequenza che potrà variare fra 20 e 50kHz circa, ma ciò che interessa è invece il duty cycle.

Maggiore sarà la capacità della giunzione applicata a P3, maggiore sarà il duty cycle del segnale presente all'uscita Q di  U2a.

R4-C6 eseguono l'integrazione di questo segnale è quindi si avrà una tensione continua ai capi di P2 misurabile con un normale tester.

 

Rv2 serve per azzerare la lettura,operazione che deve essere eseguita senza collegare nulla ai morsetti di P3.

 

 

Avendo vari condensatori di valore noto fra 10 e 100pF  (meglio se NP0) da collegare di volta in volta (in parallelo fra loro) a P3 è possibile trcciare una scala graduata o tabella di conversione.

 

Concludendo, in circuiti dove la frequenza non supera i 100MHz e dove c'è la necessità di avere una capacità variabile al massimo di qualche centinaio di pF, non necessariamente si deve ricorrere ad un varicap.

 

Ad esempio, il classico 1N4148 polarizzato inversamente esibisce una capacità variabile in funzione della tensione di polarizzazione (0..1.6v)

fra 5..20pF.

Le giunzioni di un BC337 esibiscono differenti capacità a differenti tensioni di polarizzazione, fra i 15 e i 500pF....

 

Con questo aggeggio, che non ha pretese professionali, è possibile farsi un'idea di questo fenomeno.

 

Modificato: 27 aprile 2019 da dott.cicala

[gabri-z]

Non è che le giunzioni vanno polarizzate sempre inversamente? 

[dott.cicala]

Una giunzione pn esibisce sempre una capacità.

 

Polarizzata direttamente è detta capacità di diffusione ed è dovuta ai portatori minoritari

Polarizzata inversamente è detta  capacità di svuotamento ed è dovuta ai portatori maggioritari

 

Ovviamente in un semiconduttore qualsiasi, l'andamento di queste due capacità non è per niente lineare e l'andamento dell'una e diverso dall'altra.

 

In un varicap invece è lineare per gran parte del valore che assume la tensione di polarizzazione.

 

Nel circuito, nel caso di giunzione polarizzata direttamente, superata la tensione di soglia, si può dire che C3 viene collegato a massa e il semiconduttore in questo caso è come se funzionasse da interruttore chiuso, ma prima di raggiungere questa soglia si verifica quanto detto sopra e quindi in serie a C3 si troverà la capacità di diffusione con valore molto più basso di C3 e quindi la capacità equivalente assumerà circa il valore di quella di diffusione.

 

Col circuito di cui sopra è possibile fare qualche piccolo esperimento e provare vari semiconduttori, led, fet e mosfet compresi, senza rischiare di danneggiarli. E' anche possibile prelevare il segnale da integrare anche dall'altra uscita del monostabile....

 

 

 

[Mauro Dalseno]

Interessante Stefano, sei sempre attivo con idee nuove, complimenti

[dott.cicala]

Grazie Mauro.

 

Questa è la versione evoluta dove non ho resistito alla tentazione di usare una MCU

 

[gabri-z]

Tanto per testare anche quelli usati nelle TV..... (di una volta, forse) 

[Livio Orsini]

14 ore fa, dott.cicala scrisse:

Una giunzione pn esibisce sempre una capacità.

  

Polarizzata direttamente è detta capacità di diffusione ed è dovuta ai portatori minoritari 

Polarizzata inversamente è detta  capacità di svuotamento ed è dovuta ai portatori maggioritari 

 

Infatti ai tempi ho usato gli zener, nella zona di tensione che precede il ginocchio di zener, come diodi varicap. Perchè? perchè circa 50 anni fa gli zener eran relativamente a buon mercato ed i varicap da noi eran quasi introvabili. Nella zona ante zener la variazione di capacità è abbastanza lineare, non come un vero e proprio varicap, ma abbastanza; e poi chi si contenta gode .... così così.

 

10 ore fa, dott.cicala scrisse:

 

Questa è la versione evoluta dove non ho resistito alla tentazione di usare una MCU

 

Scusa ma a questo punto potevi anche aggiungere un display e far fare tutto al micro: misure e visualizzazioni. (magari al prossimo step).

 

Magari, se nei prossimi giorni mi viene un attacco di buona volontà e sono libero da lavori agresti, condizioni non facili da avere contemporaneamente, mi metto a sperimentare una versione con arduino.

[dott.cicala]

1 ora fa, Livio Orsini scrisse:

potevi anche aggiungere un display

Hai ragione. Avrei dovuto usare un pic con qualche pin in più.

Questo è l'unico in mio possesso in cui è presente il Capacitive Sensing Module.

Al momento però....non funziona nulla 

[Livio Orsini]

1 ora fa, dott.cicala scrisse:

Questo è l'unico in mio possesso in cui è presente il Capacitive Sensing Module.

 

E po' che non mi aggiorno sui PIC.

Come funziona il modulo?

Mi sa che magari mi compro un PicKit 4 e riprendo a smanettare i PICs.

Bhee dato che mio nipote a 10 anni manifesta già brutte tendenze nei confronti dell'elettronica, magari trovo un compagno di giochi

[dott.cicala]

2 ore fa, Livio Orsini scrisse:

mio nipote a 10 anni manifesta già brutte tendenze nei confronti dell'elettronica

Che fortuna.

Mio figlio che ha un anno in meno trova l'elettronica e la matematica noiose. Difficile che cambi idea nonostante tutti i circuitini per generare suoni ed effetti luminosi che gli ho costruito. Si diverte ad usarli ma ha poco interesse nello scoprire "cosa c'è dentro".

Io alla sua età smontavo tutto quello che mi capitava a tiro.

2 ore fa, Livio Orsini scrisse:

Come funziona il modulo

E' stato concepito per gestire dei tasti touch capacitivi, quindi si basa su di un oscillatore la cui frequenza è influenzata da una capacità esterna. Può generare interrupts e si può interfacciare direttamente ai timers interni, quindi è possibile realizzare anche il conteggio della frequenza.

 

Siccome a me interessava misurare capacità di basso valore, come può essere quella di un tasto touch capacitivo, ho pensato bene di usare questa cip così da non impegnare inutilmente la mcu con altre istruzioni.

 

Questo è il suo schema a blocchi

 

e qui c'è l'oscillatore

Una volta configurati i vari registri è sufficiente applicare un condensatore tra il pin selezionato e gnd per ottenere la frequenza corrispondente sul flag CPSOUT.

 

Per avere questa frequenza su un altro pin configurato come uscita a questo punto basta una sola istruzione

 

// RA4 è l'uscita di CPSOUT

LATA.b4 = CPSCON0.CPSOUT;   

 

 

 

 

 

 

Modificato: 28 aprile 2019 da dott.cicala

[Livio Orsini]

Perbacco è veramente interessante, dovrei studiarmelo. Magari ci provo.

[Nino1001-b]

Io sono rimasto al " Ricordatevi che lavorando in Alta Frequenza la capacità parassità di un componente o l'impedenza o tutti e due, a seconda il componente, rende critica la progettazione di un circuito. Anche lo spessore e la distanza fra le piste del circuito stampato vi potranno portare fuori strada".

Non mi è mai venuto in mente che la capacità parassita potesse essere variata e far diventare un componete un varicap.

[Livio Orsini]

13 ore fa, Nino1001-b scrisse:

Non mi è mai venuto in mente che la capacità parassita potesse essere variata e far diventare un componete un varicap.

 

Nelle giunzioni i "parassiti" non sono costanti come, ad esempio, in un circuito stampato. Poco o tanto variano in funzione dei parametri elettrici; proprio per questo motivo, spesso, nei data sheets dei componenti per alta freqeunza, ci sono curve che danno i valori di capacità di giunzione in funzione della tensione.

[dott.cicala]

Il cap sense funziona benissimo, ma la capacità la misura malissimo 

In effetti non è concepito per questo tipo di misura e la risoluzione che ottengo non è quella che mi servirebbe.

 

Questa è la curva V/F che ho ottenuto con un BB112 (1..8v -> 17,5..470pF)

non va bene 

 

Modificato: 30 aprile 2019 da dott.cicala

[Livio Orsini]

1 ora fa, dott.cicala scrisse:

Il cap sense funziona benissimo, ma la capacità la misura malissimo 

 

Versione elettronica del famoso: "Operazione perfettamente riuscita, ma paziente deceduto".

Non ti scoraggiare, puoi sempre usare il pic per contare la frequenza e visualizzare la capacità, magari usando un diplay in I2C

[dott.cicala]

Il prova varicap fantozziano è pronto! 

Il campo di misura si estende tra 1 e 1000pF. Più che sufficiente per verificare ogni tipo di varicap.

Il povero pic qui è usato solo per ridurre il circuito di una decina di componenti e si occupa di:

1)Generare il segnale di pilotaggio del convertitore dc/dc il quale può fornire le 3 più comuni tensioni necessarie a questo tipo di prove

2) Generare un segnale quadro a 100kHz che passando attraverso il filtro passa basso C2-L1-C6 diventa perfettamente sinusoidale ed è        usato per  "alimentare" il diodo (o la giunzione) in esame.

Da C6 in poi c'è un rivelatore di picco, quindi il tester  - o un micro amperometro per il quale servirà almeno un trimmer per il fondo scala -

per misurare la tensione funzione della reattanza e quindi della capacità.

Niente display I2C perché lo scopo dell'aggeggio è quello di fornire un indicazione visiva " a colpo d'occhio".

Questa curva rappresenta la tensione misurata all'uscita del rivelatore di picco in funzione della tensione di polarizzazione.

Ci siamo! Bisognerà tracciare una scala per lo strumentino servendosi di capacità campioni. 

Se interessa a qualcuno posso fornire il .HEX e/o il sorgente....

Modificato: 30 aprile 2019 da dott.cicala

[Livio Orsini]

10 ore fa, dott.cicala scrisse:

Se interessa a qualcuno posso fornire il .HEX e/o il sorgente....

 

Lo hai scritto in "C"?, potresti fornire gentilmente il sorgente? Così tanto per vedere come hai arrangiato questo PIC (almeno io ho questa curiosità).

 

Sembra lavori bene, sarà anche "fantozzianio" ma fa il suo dovere.

[dott.cicala]

Ok inserisco di seguito il sorgente premettendo che la maggior parte del codice è superflua e ciò che esegue il micro consiste in ben poche righe.

Quando mi metto a giocare con un micro, ho il vizio di inserire la maggior parte dei registri e relativi commenti che suppongo di dover usare. Una volta raggiunto lo scopo elimino tutto il superfluo.

 

Rispetto allo schema qui sopra, in seguito ho deciso di lasciare attivo il cap sense (per successive prove) e di usare RA5 come uscita sulla quale trasferire la frequenza del suo oscillatore, quindi RA0 è libero mentre il selettore fa capo a RA1.

 

In sintesi uso:

 

- TMR0 per generare un impulso molto stretto a 100kHz che poi diventerà il segnale sinusoidale che alimenta il varicap (RA4out_100KHz)

 

- Durante lo stesso interrupt vado a scrivere su RA5Fout lo stato dell'uscita del cap sense

 

Fuori dall'interrupt leggo il selettore e invio il valore di duty cycle a CCP1 per il survultore che genera la tensione di polarizzazione.

 

Mi sono accorto solo dopo aver realizzato l'ultima versione del circuito che scrivendo RA5Fout all'interno dell'interrupt, dal cap sense ottengo corrispondenze molto precise e stabili  fra capacità e frequenza...quindi prossimamente riproverò quella strada...

 

//******************************************************************************
//     Vapicaè Tester
//     Capacitive Sensing Module Test
//     PIC12F1840
//******************************************************************************
/*
   CONFIG1 : $8007 : 0x3FA4
   CONFIG2 : $8008 : 0x1FFF
*/
//******************************************************************************
// GLOBAL VARIABLES
//******************************************************************************
   sbit D_nA          at SSPSTAT.B5;
   sbit Rd_nWr        at SSPSTAT.B2;

   sbit RA4out_100KHz at LATA.B4;
   sbit RA5Fout       at LATA.B5;
   
   unsigned int  RqVolt, ActVin, ActVout, ActIout, Dcharge, ActFout;
   unsigned char I2C_ADDR, read_buffer, nTx, nRx;
   unsigned char Rx[5],Tx[5];
   unsigned char Counter0, Counter1, Counter2;

   bit RxFlag2, RxFlag3, RxFlag4, RxFlag5, RxFlag6, RxFlag7;
   bit TxFlag2, TxFlag3, TxFlag4, TxFlag5, TxFlag6, TxFlag7;
   bit rStart, rRange, rRun, rCharge, rDischarge, rTrip, rRdy, rWd;
   bit tStart, tRange, tRun, tCharge, tDischarge, tTrip, tRdy, tWd;
//******************************************************************************
// Scaling
//******************************************************************************
#define Scl(In,Imin,Imax,Umin,Umax)(((((In-Imin)/(Imax-Imin))*(Umax-Umin))+Umin));
//******************************************************************************
// CONFIGURATION ROUTINE
//******************************************************************************
 void init() {
   OSCCON      = 0b11110000;    // Int Osc 8MHz + 4xPLL On
//******************************************************************************
// PORT[A] I/O REGISTER
//******************************************************************************
   TRISA.B0          = 1;       // RA0 Ai  - Cap Sense Input
   TRISA.B1          = 1;       // RA1 Ai  - Varicap Voltage Range Selector
   TRISA.B2          = 0;       // RA2 PWM Output - DcDc Varicap
   TRISA.B3          = 1;       // RA3 Input
   TRISA.B4          = 0;       // RA4 Output - 100kHz pulse
   TRISA.B5          = 0;       // RA5 Output - Cap Sense Frequency
//******************************************************************************
// PORT[A] ANALOG SELECT REGISTER
//******************************************************************************
   ANSELA.ANSA0      = 1;       // RA0 Analog - Cap Sense
   ANSELA.ANSA1      = 1;       // RA1 Analog - Varicap Voltage Range Selector
   ANSELA.ANSA2      = 0;       // RA2 Analog
   ANSELA.ANSA4      = 0;       // RA4 Analog
//******************************************************************************
// OPTION REGISTER
//******************************************************************************
   OPTION_REG.B7     = 1;       // WPUEN Weak Pull-Up Enable bit
   OPTION_REG.INTEDG = 0;       // Interrupt Edge Select bit
   OPTION_REG.TMR0CS = 0;       // Timer0 Clock Source Select bit
   OPTION_REG.TMR0SE = 0;       // Timer0 Source Edge Select bit
   OPTION_REG.PSA    = 0;       // Prescaler Assignment bit
   OPTION_REG.B2     = 0;       // Prescaler Rate Select bits
   OPTION_REG.B1     = 0;       // Prescaler Rate Select bits
   OPTION_REG.B0     = 0;       // Prescaler Rate Select bits
//******************************************************************************
// INTERRUPT CONTROL REGISTER
//******************************************************************************
   INTCON.GIE        = 1;       // Global Interrupt Enable bit
   INTCON.PEIE       = 0;       // Peripheral Interrupt Enable bit
   INTCON.TMR0IE     = 1;       // Timer0 Overflow Interrupt Enable bit
   INTCON.INTE       = 0;       // INT External Interrupt Enable bit
   INTCON.IOCIE      = 0;       // Interrupt-on-Change Enable bit
   INTCON.TMR0IF     = 0;       // Timer0 Overflow Interrupt Flag bit
   INTCON.INTF       = 0;       // INT External Interrupt Flag bit
   INTCON.IOCIF      = 0;       // Interrupt-on-Change Interrupt Flag
//******************************************************************************
// PERIPHERAL INTERRUPT ENABLE REGISTER 1
//******************************************************************************
   PIE1.TMR1GIE      = 0;       // Timer1 Gate Interrupt Enable bit
   PIE1.ADIE         = 0;       // ADC Interrupt Enable bit
   PIE1.RCIE         = 0;       // USART Receive Interrupt Enable bit
   PIE1.TXIE         = 0;       // USART Transmit Interrupt Enable bit
   PIE1.SSP1IE       = 0;       // Synchronous Serial Port Interrupt Enable bit
   PIE1.CCP1IE       = 0;       // CCP1 Interrupt Enable bit
   PIE1.TMR2IE       = 0;       // TMR2 to PR2 Match Interrupt Enable bit
   PIE1.TMR1IE       = 0;       // Timer1 Overflow Interrupt Enable bit
//******************************************************************************
// PERIPHERAL INTERRUPT ENABLE REGISTER 2
//******************************************************************************
   PIE2.OSFIE        = 0;       // Oscillator Fail Interrupt Enable bit
   PIE2.C1IE         = 0;       // Comparator C1 Interrupt Enable bit
   PIE2.EEIE         = 0;       // EEPROM Write Completion Interrupt Enable bit
   PIE2.BCL1IE       = 0;       // MSSP Bus Collision Interrupt Enable bit
//******************************************************************************
// PERIPHERAL INTERRUPT REQUEST REGISTER 1
//******************************************************************************
   PIR1.TMR1GIF      = 0;       // Timer1 Gate Interrupt Flag bit
   PIR1.ADIF         = 0;       // ADC Interrupt Flag bit
   PIR1.RCIF         = 0;       // USART Receive Interrupt Flag bit
   PIR1.TXIF         = 0;       // USART Transmit Interrupt Flag bit
   PIR1.SSP1IF       = 0;       // Synchronous Serial Port Interrupt Flag bit
   PIR1.CCP1IF       = 0;       // CCP1 Interrupt Flag bit
   PIR1.TMR2IF       = 0;       // Timer2 to PR2 Interrupt Flag bit
   PIR1.TMR1IF       = 0;       // Timer1 Overflow Interrupt Flag bit
//******************************************************************************
// PERIPHERAL INTERRUPT REQUEST REGISTER 2
//******************************************************************************
   PIR2.OSFIF        = 0;       // Oscillator Fail Interrupt Flag bit
   PIR2.C1IF         = 0;       // Comparator C1 Interrupt Flag bit
   PIR2.EEIF         = 0;       // EEPROM Write Completion Interrupt Flag bit
   PIR2.BCL1IF       = 0;       // MSSP Bus Collision Interrupt Flag bit
//******************************************************************************
// TIMER1 CONTROL REGISTER - NON USATO
//******************************************************************************
   T1CON.B7          = 1;       // TMR1CS1 Timer1 Clock Source Select
   T1CON.B6          = 1;       // TMR1CS0 Timer1 Clock Source Select
   
   T1CON.B5          = 0;       // T1CKPS1 Timer1 Input Clock Prescale Select
   T1CON.B4          = 0;       // T1CKPS0 Timer1 Input Clock Prescale Select
   
   T1CON.T1OSCEN     = 0;       // LP Oscillator Enable Control bit
   T1CON.B2          = 0;       // T1SYNC Timer1 Synchronization Control bit
   T1CON.TMR1ON      = 0;       // Timer1 On bit

   T1GCON.TMR1GE     = 1;       // Timer1 Gate Enable bit
   T1GCON.T1GPOL     = 0;       // Timer1 Gate Polarity bit
   T1GCON.T1GTM      = 1;       // Timer1 Gate Toggle Mode bit
   T1GCON.T1GSPM     = 0;       // Timer1 Gate Single-Pulse Mode bit
   T1GCON.B3         = 0;       // T1GGO/DONE: Gate Single-Pulse Acquisition
   T1GCON.T1GVAL     = 0;       // Timer1 Gate Current State bit
   
   T1GCON.B1         = 0;       // T1GSS1 Timer1 Gate Source Select bits
   T1GCON.B0         = 1;       // T1GSS0 Timer1 Gate Source Select bits
//******************************************************************************
// TIMER2 MODULE
//******************************************************************************
   T2CON.B7    = 0;        // Unimplemented: Read as ‘0’

                           // b6 b5 b4 b3 Timer Output Postscaler Sel. bits
   T2CON.B6    = 0;        // 1  1  1  1 = 1:16 Postscaler
   T2CON.B5    = 0;        // 1  1  1  0 = 1:15 Postscaler
   T2CON.B4    = 0;        // 1  1  0  1 = 1:14 Postscaler
   T2CON.B3    = 0;        // 1  1  0  0 = 1:13 Postscaler
                           // 1  0  1  1 = 1:12 Postscaler
                           // 1  0  1  0 = 1:11 Postscaler
                           // 1  0  0  1 = 1:10 Postscaler
                           // 1  0  0  0 = 1:9 Postscaler
                           // 0  1  1  1 = 1:8 Postscaler
                           // 0  1  1  0 = 1:7 Postscaler
                           // 0  1  0  1 = 1:6 Postscaler
                           // 0  1  0  0 = 1:5 Postscaler
                           // 0  0  1  1 = 1:4 Postscaler
                           // 0  0  1  0 = 1:3 Postscaler
                           // 0  0  0  1 = 1:2 Postscaler
                           // 0  0  0  0 = 1:1 Postscaler

   T2CON.B2    = 1;        // Timer2 On bit
                           // b1 b0 Timer2 Clock Prescale Select bits
   T2CON.B1    = 0;        // 1  1 = Prescaler is 64
   T2CON.B0    = 0;        // 1  0 = Prescaler is 16
                           // 0  1 = Prescaler is 4
                           // 0  0 = Prescaler is 1
//******************************************************************************
// PWM MODULE
//******************************************************************************
// CCP1CON CCP1 CONTROL REGISTER
//******************************************************************************
   CCP1CON.B7  = 0;        // Enhanced PWM Output Configuration bits
   CCP1CON.B6  = 0;        // Enhanced PWM Output Configuration bits
                           // PWM Duty Cycle Least Significant bits
   CCP1CON.B5  = 1;        // b5 b4 PWM Duty Cycle Least Significant bits
   CCP1CON.B4  = 1;        // b5 b4 PWM Duty Cycle Least Significant bits

                           // b3 b2 b1 b0 ECCP1 Mode Select bits
                           // 1  1  1  1 =PWM : P1A active-low; P1B active-low
                           // 1  1  1  0 =PWM : P1A active-low; P1B active-high
                           // 1  1  0  1 =PWM : P1A active-high; P1B active-low
                           // 1  1  0  0 =PWM : P1A active-high; P1B active-high
   CCP1CON.B3  = 1;        // 1  0  1  1 =Comp mode: Special Event Trigger
   CCP1CON.B2  = 1;        // 1  0  1  0 =Comp mode: generate software interrupt
   CCP1CON.B1  = 0;        // 1  0  0  1 =Comp mode: initialize ECCP1 pin high
   CCP1CON.B0  = 0;        // 1  0  0  0 =Comp mode: initialize ECCP1 pin low
                           // 0  1  1  1 =Capture mode: every 16th rising edge
                           // 0  1  1  0 =Capture mode: every 4th rising edge
                           // 0  1  0  1 =Capture mode: every rising edge
                           // 0  1  0  0 =Capture mode: every falling edge
                           // 0  0  1  1 =Reserved
                           // 0  0  1  0 =Comp mode: toggle output on match
                           // 0  0  0  1 =Reserved
                           // 0  0  0  0 =Capture/Compare/PWM off
//******************************************************************************
// PWM Period register
//******************************************************************************
   PR2         = 255;
//******************************************************************************
// PWM DUTY CYCLE RATIO
//******************************************************************************
   CCP1CON.B5  = 0;        // b5 PWM Duty Cycle Least Significant bits
   CCP1CON.B4  = 0;        // b4 PWM Duty Cycle Least Significant bits
   CCPR1L      = 0;
//******************************************************************************
// FIXED VOLTAGE REFERENCE CONTROL REGISTER - NON USATO
//******************************************************************************
   FVRCON.FVREN      = 1;       // Fixed Voltage Reference Enable bit
   FVRCON.TSEN       = 0;       // Temperature Indicator Enable
   FVRCON.TSRNG      = 0;       // Temperature Indicator Range Selection bit
   FVRCON.B3         = 1;       // Comparator FVR Buffer Gain Selection bit[0]
   FVRCON.B2         = 1;       // Comparator FVR Buffer Gain Selection bit[1]
   FVRCON.B1         = 0;       // ADC FVR Buffer Gain Selection bit[0]
   FVRCON.B0         = 0;       // ADC FVR Buffer Gain Selection bit[1]
//******************************************************************************
// COMPARATOR MODULE - NON USATO
//******************************************************************************
   CM1CON0.C1ON      = 0;       // Comparator Enable bit
   CM1CON0.C1OUT     = 0;       // Comparator Output bit
   CM1CON0.C1OE      = 0;       // Comparator Output Enable bit
   CM1CON0.C1POL     = 0;       // Comparator Output Polarity Select bit
   CM1CON0.C1SP      = 0;       // Comparator Speed/Power Select bit
   CM1CON0.C1HYS     = 0;       // Comparator Hysteresis Enable bit
   CM1CON0.C1SYNC    = 0;       // Comparator Output Synchronous Mode bit

   CM1CON1.C1INTP    = 0;       // Comparator Interrupt on Positive Going Edge
   CM1CON1.C1INTN    = 0;       // Comparator Interrupt on Negative Going Edge
   CM1CON1.B5        = 0;       // Comparator Positive Input Channel Select bits
   CM1CON1.B4        = 0;       // Comparator Positive Input Channel Select bits
   CM1CON1.C1NCH     = 0;       // Comparator Negative Input Channel Select bit
//******************************************************************************
// CAPACITIVE SENSING MODULE - NON USATO
//******************************************************************************
   CPSCON0.CPSON     = 1;       // CPS Module Enable bit
   CPSCON0.CPSRM     = 0;       // Capacitive Sensing Reference Mode

   CPSCON0.b3        = 1;       // CPSRNG: Capacitive Sensing Current Range
   CPSCON0.b2        = 0;       // CPSRNG: Capacitive Sensing Current Range

   CPSCON0.CPSOUT    = 0;       // Capacitive Sensing Oscillator Status bit
   CPSCON0.T0XCS     = 0;       // Timer0 External Clock Source Select bit

   CPSCON1.b1        = 0;       // Capacitive Sensing Channel Select bit
   CPSCON1.b0        = 0;       // Capacitive Sensing Channel Select bit
//******************************************************************************
// MASTER SYNCHRONOUS SERIAL PORT MODULE
//******************************************************************************
/*
   I2C_ADDR    = 0x50;          // MSSP1 ADDRESS
   SSP1ADD     = I2C_ADDR << 1; // MSSP1 ADDRESS AND BAUD RATE REGISTER (I2C)
   SSP1MSK     = I2C_ADDR << 1; // MSSP1 MASK ADDRESS
   SSP1CON1    = 0x36;          // SSP1EN,Enable clock,I2C Slave, 7-bit address
   SSPSTAT     = 0x00;          // All bits must be cleared
   BOEN_bit    = 0;             // Buffer Overwrite Enable bit
   SEN_bit     = 1;             // Start Condition Enable/Stretch Enable bit
   AHEN_bit    = 0;             // Address Hold Enable bit
   DHEN_bit    = 0;             // Data Hold Enable bit
*/
//******************************************************************************
// Diag
//******************************************************************************
   Counter0 = 0;
   Counter1 = 0;
   Counter1 = 0;
   Dcharge  = 0;
   LATA     = 0;
   TMR1H    = 0;
   TMR1L    = 0;
   TMR0     = 0;
   ADC_Init();
   
 }
//******************************************************************************
// I2C SLAVE - SEND-RECEIVE ROUTINE - NON USATO
//******************************************************************************
 void i2cCom(){
               if (SSP1IF)
                {
              //****************************************************************
              // overflow
              //****************************************************************
                  if(SSPOV_bit || WCOL_bit)
                    {
                     SSPBUF = SSPBUF;
                     SSPOV_bit = 0;
                    }
              //****************************************************************
              // ricevo dati dal master
              //****************************************************************
                  if(S_bit &!Rd_nWr)
                    {
                      SSP1IF_bit=0;
                      read_buffer = SSPBUF;
                      CKP_bit=1;
                    }
              //****************************************************************
              // trasmetto dati al master
              //****************************************************************
                 if(S_bit &Rd_nWr &!BF)
                    {
                     SSPBUF = ++Counter0;
                     CKP_bit=1;
                    }
              //****************************************************************
                 SSP1IF_bit=0;
              }
             }
//##############################################################################
// PWM output - DcDc Varicap polarization
//##############################################################################
void(PwmOut)()
{
   //*** Leggo selettore **********************
   RqVolt = ADC_Read(1);
   //*** Polarizzazione Max 8V ****************
   if(RqVolt<300)Dcharge = 16;
   //*** Polarizzazione Max 12V ***************
   if(RqVolt>400 && RqVolt<600)Dcharge = 65;
   //*** Polarizzazione Max 30V ***************
   if(RqVolt>800)Dcharge = 860; //30v

   CCPR1L  = Dcharge>>2;
   CCP1CON = CCP1CON|((Dcharge<<4)&0x30);
}
//##############################################################################
// PROGRAMMA PRINCIPALE
//##############################################################################
void(MainPrg)()
{
      PwmOut();
}
//##############################################################################
// MAIN ROUTINE
//##############################################################################
 void main()
     {
      init();
      while(1)(MainPrg)();
     }
//##############################################################################
//                        Interrupt Routine
//##############################################################################
void interrupt()
     {
      //*********************************
      // TMR0 OVERFLOW
      //*********************************
        if(INTCON.TMR0IF)
         {
          INTCON.TMR0IF = 0;
          RA4out_100KHz = 1;
          RA5Fout       = CPSCON0.CPSOUT;
          TMR0          = 220;
          RA4out_100KHz = 0;
         }
      //*********************************
      // TMR1 OVERFLOW - NON ATTIVO
      //*********************************
        if(PIR1.TMR1IF)
         {
          PIR1.TMR1IF = 0;
          TMR1H = 0x0;
          TMR1L = 0x0;
         }
     }

 

 

 

 

 

Modificato: 1 maggio 2019 da dott.cicala

[dott.cicala]

Curva tracciata usando 20 condensatori senza misurarne la capacità (valore riportato sul corpo) e posti in parallelo ad un condensatore da 1nF.

Le ondulazioni potrebbero dipendere dalle tolleranze.....

[Livio Orsini]

Grazie Stefano, poi mi stampo il listato e me lo studio. Io sono all'antica, per concentrarmi devo leggere la carta. Gli e book mi vanno bene per le letture di evasione.