progetto di

Titolo:
INSEGUITORE
MOTORIZZATO PER
IMPIANTI SOLARI,
GESTITO DA PIC.
PROGETTO DI:
Marco Romani
Progetto di: Marco Romani
Descrizione generale:
I pannelli fotovoltaici sfruttano la luce, in particolare quella del sole, diventando generatori di tensione e
corrente. Essi devono essere orientati in modo da prendere in maniera ottimale la luce del sole durante le ore
diurne. Il posizionamento, secondo la legge di Lambert (L’energia ceduta da un raggio di luce alla superficie
che investe è direttamente proporzionale al coseno dell’angolo formato tra la direzione della luce e la
normale della superficie stessa), deve essere fatto in modo che il pannello riceva la massima energia, e quindi
lavori con la massima efficienza possibile.
Il mio progetto è in grado di seguire orizzontalmente la posizione del sole, da est ad ovest (si potrebbe fare
anche verticalmente, ma per semplicità ho tenuto un’inclinazione verticale fissa di circa 135°), durante la
giornata e di tornare alla posizione iniziale al sorgere del sole, in modo da ricominciare l’inseguimento.
Il progetto è stato creato come prototipo per applicazioni su impianti solari di piccole dimensioni.
Funzionamento:
Per rilevare la direzione verso la quale deve girare il pannello, l’inseguitore utilizza un circuito a
microcontrollore (PIC), che esamina i tre segnali analogici dei sensori ottici disposti in modo da ricevere la
luce solare, quando è perpendicolare a loro.
Il dispositivo “ottico” è composto di due sensori disposti nella stessa direzione frontale (ma inclinati tra loro
di circa 60°), ed un sensore_alba disposto in direzione opposta agli altri due.
Il micro legge periodicamente i valori dei sensori, se il valore del sensore che indica la direzione ovest è
molto maggiore del valore del sensore che indica la direzione est, allora il pannello ruota verso ovest fino a
quando i due valori non si eguagliano.
La notte tutti e tre i sensori hanno stesso valore ed il pannello non compie movimenti.
All’alba il sensore_alba posizionato in maniera opposta agli altri due, è rivolto verso il sole, a differenza
degli altri che sono in ombra. Essendo quindi il valore del sensore_alba maggiore degli altri due, il pannello
ruota verso est fino a che non attiva il pulsante di fine-corsa.
Il pannello solare va montato su una staffa rotante insieme ai sensori ottici.
Tutto il circuito funziona a 12 Vdc.
Composizione:
2
Progetto di: Marco Romani
Lo schema a blocchi riportato di seguito indica i principali elementi che compongono l’inseguitore; il gruppo
dei sensori ottici è collegato al micro tramite 3 fili, più 2 fili per l’alimentazione a 5Vdc.
Il micro è collegato al driver per motori passo-passo tramite 4 fili, e lo stesso driver è collegato tramite 4 fili
allo stepper bipolare.
Il driver per stepper richiede di una doppia alimentazione, 5 Vdc e 12 Vdc.
Anche il microcontrollore funziona con una tensione di 5Vdc, ed è per questo che se alimentiamo il tutto ad
una tensione di 12Vdc, abbiamo bisogno di uno stabilizzatore di tensione a 5vdc.
Sensori ottici
Microcotrollore
PIC
Stabilizzatore
di Tensione
5 Vdc
Driver
Stepper
Stepper
12 Vdc
Gruppo sensori ottici:
Di seguito riporto il circuito:
Il gruppo dei sensori ottici non è nient’altro che tre partitori di tensione.
Ogni partitore è costituito da una fotoresistenza da 47 KΩ e una resistenza da 100 Ω.
3
Progetto di: Marco Romani
Le fotoresistenze sono elementi a semiconduttore in cui la radiazione assorbita viene convertita in una
variazione di resistività per il materiale stesso. n genere il materiale utilizzato è il CdS (solfuro di cadmio)
oppure il PbS (solfuro di piombo), depositato in uno strato sottile su un supporto isolante. Affinché il sensore
abbia un’elevata sensibilità, esso deve essere in rado di catturare un numero elevato di fotoni e pertanto si
tende a realizzare una superficie sufficientemente ampia. Per ottenere una fotoresistenza di superficie elevata
e contemporaneamente un cammino dei portatori di carica abbastanza breve, si realizzano elettrodi metallici
a forma di pettine che costituiscono il giusto compromesso tecnico ai due problemi esposti.
La caratteristica statica di una fotoresistenza con resistenza in oscurità totale 10M assume l’aspetto di
figura:
Come si può osservare la relazione che intercorre tra la resistenza e la quantità di radiazione incidente
(illuminamento) è di tipo lineare in scala logaritmica e quindi si può scrivere:
log R=log R1- log IL
in cui R1 è la resistenza presentata dalla fotoresistenza in condizioni di illuminamento IL unitario.
4
Progetto di: Marco Romani
La relazione può essere scritta anche:
log R/R1= log IL^-
ossia:
R= R IL^-
Quindi, la resistività diminuisce con l’aumentare della luce; più ho luce e più sarà alta la tensione del
partitore.
Questi partitori vanno alimentati con una tensione di 5Vdc.
Driver per motori passo-passo:
Dato che la motorizzazione del pannello è fatta con un motore passo-passo bipolare, ho bisogno di un driver
per la gestione del motore, perché il PIC non può gestirlo direttamente.
Il Driver utilizzato è l’integrato L298, il quale necessita di due alimentazioni: una a 5 Vdc per alimentare la
parte logica, ed una che deve essere la tensione di alimentazione dello stepper (max 46V), che in questo caso
è 12 Vdc.
Per questo motivo nel circuito ho inserito uno stabilizzatore di tensione a 5V del tipo L7805 messo in
configurazione in modo che funzioni da regolatore di tensione fissa, come riportato in figura:
Per la protezione del circuito dalle sovracorrenti è bene utilizzare 8 diodi di tipo veloce (shottky) da 1 o 2 o 5
Ampere. I diodi da utilizzare devono avere due caratteristiche fondamentali:


Essere veloci, cioè essere capaci di passare in poco tempo dalla condizione di non passaggio di
corrente a quella di conduzione e viceversa. In genere sono richiesti tempi di intervento dell'ordine
dei 100 ns o anche meno. Per questo motivo non sono adatti per esempio i comuni 1N4001, troppo
lenti.
Essere capaci di gestire correnti elevate in quanto al momento dello spegnimento tutta la corrente del
motore passa nei diodi, ed in genere si tratta di ampere. Per questo motivo non sono adatti per
esempio i comuni 1N4148, che sopportano correnti dell'ordine dei 100 mA.
E’ bene mettere anche un dissipatore sul L298, e sugli stabilizzatori di tensione.
Il circuito è quindi il seguente:
5
Progetto di: Marco Romani
Dove K2 è il connettore per gli ingressi che arrivano direttamente dal microcontrollore e K3 è il connettore
per le uscite che vanno collegate alle 4 fasi dello stepper bipolare.
Per l’alimentazione, il pin 8 va a +5V e il pin 9 a massa (tali pin non sono rappresentati in figura).
6
Progetto di: Marco Romani
I motori passo_passo:
Per far muovere il pannello utilizzeremo un motore passo-passo (stepper) bipolare.
I motori bipolari sono caratterizzati dall'avere solo quattro fili di connessione. Una categoria particolare è
costituita dai motori unipolari a sei fili: è infatti sufficiente in questi motori non collegare la coppia di fili
comuni tra due fasi per ottenere un motore bipolare, anche se in genere con caratteristiche peggiori di quelli
che" nascono bipolari".
Per questi motori il pilotaggio è più complesso che per quelli unipolari: infatti la corrente deve attraversare
gli avvolgimenti nei due versi e questo rende piuttosto complesso il circuito di pilotaggio. Il vantaggio deriva
dal fatto che, essendo le fasi due anziché quattro, a parità di potenza del motore, il peso e la dimensione sono
minori in quanto è necessario usare una minor quantità di rame. Inoltre, usando appositi schemi, è possibile
ottenere circuiti di pilotaggio più efficienti in termini di consumo energetico e velocità di rotazione ottenibile.
Infine si rende possibile introdurre nuove modalità di pilotaggio senza appesantire in modo sostanziale le
difficoltà di progettazione dell'elettronica di potenza.
Anche nel pilotaggio bipolare sono possibili diverse modalità:
WaveMode: una sola fase alla volta è attiva. Da notare che le condizioni di funzionamento per ciascuna fase
sono tre: corrente in un verso, corrente nell'altro verso, assenza di corrente (situazioni indicate
rispettivamente con I, -I e 0 nella tabella).
Passo Ph1 Ph2
1
I
0
2
0
I
3
-I
0
4
0
-I
Two phase-on: la corrente è sempre presente nelle due fasi ma cambia verso. Ho già descritto nel paragrafo
dedicato ai motori unipolari gli effetti sulla coppia (che aumenta di 1.4 volte) e la corrente assorbita (che
raddoppia).
Passo Ph1 Ph2
1
I
I
2
-I
I
3
-I
-I
4
I
-I
L’unità di controllo, il microcontrollore PIC:
E’ la parte più importante del sistema perché presiede a tutte le funzioni, è costituita da un microcontrollore
Microchip PIC16F877A basato su un’architettura a 16 bit, provvisto di Flash-EPROM da 8k e organizzata in
parole da 14 bit e funzionante, in quest’applicazione, con un quarzo esterno a 20 MHz. Dispone inoltre di
convertitori A/D, di comparatori e di porta USART.
7
Progetto di: Marco Romani
Durante l’inizializzazione, il programma azzera le linee delle porte A, B ed E, e imposta le linee RA0, RA2,
RA3 e RE0 come ingressi, e RB7, RB6, RB5, RB4 come uscite, destinante al driver per lo stepper.
Il programma in sequenza acquisisce i valori analogici sui canali AN5, AN2, AN0 e AN3, ne fa la conversione
A/D, e assegna tali valori a delle variabili, rispettivamente res_alba, ok, res_dx e res_sx (resistenza destra e
resistenza sinistra s’intendono guardando il pannello di fronte).
Se la resistenza di destra, res_dx, risulta essere minore della resistenza di sinistra (res_sx), (N.B. In realtà il
PIC rileva la tensione creata dal partitore, essa aumenta o diminuisce in base al valore della fotoresistenza,
più ho luce più bassa sarà la resistenza e più alta sarà la tensione, in pratica vuol dire che è illuminata
maggiormente la res_sx), il micro inizia ad abilitare le uscite in sequenza tale che lo stepper si muova in
verso orario, questo fino a quando il valore delle due fotoresistenza non si eguaglia, cioè ricevono la stessa
quantità di luce.
Seguendo il sole da est ad ovest, la notte il pannello si trova rivolto verso ovest, e la res_alba rivolta verso
est, che aspetta il sorgere del sole.
Il mattino la tensione su res_alba è molto maggiore di quella sulle altre due resistenze e il micro inizia la
procedura per far muovere il pannello in senso antiorario, questo fino a che il pannello fa commutare a massa
il fine-corsa, in modo che sull’ingresso AN2 ci sia una tensione di 0V e la variabile ok diventi 0. Se il
pannello non fosse proprio affacciato al sole, appena avrei la condizione res_dx<res_sx il micro entra nella
procedura per muovere il pannello in senso orario fino a che le due resistenze si eguagliano; ora il pannello è
di fronte al sole. Ora continua il ciclo d’inseguimento del sole.
Quando viene premuto il finecorsa porto le uscite del PIC a 0 (disattivate), questo perché così non ho fasi
attive sullo stepper e non ho consumo di corrente (evitando il surriscaldamento dell’ L298).
La stessa cosa si potrebbe fare, quando le due resistenze frontali hanno lo stesso valore, cioè, quando
ricevono la stessa luce (soprattutto di notte); si può inserire un pezzo di programma del tipo:
if (res_dx==res_sx)
{
PORTB=0;
}
Il circuito risulta essere:
8
Progetto di: Marco Romani
Elenco componenti utilizzati:
-Oscillatore al quarzo: 20MHz
-R1, R2, R3: 100 Ω
-R4, R5: 0,47 Ω
-R6: 10 KΩ
-R7: 470 Ω
-C1: 1 nF
-C2, C4: 0,1 µF
-IC1: L7805
-IC2: L298
-U: PIC16F877A
-PH1, PH2, PH3: fotoresistenza 47 KΩ
-D1÷D8: diodi shottky 2 A
-D9: 1N4005
-Sw1: pulsante
-Stepper bipolare (1 pz.)
Varie:
-Interruttore 12 Vdc (1 pz.)
-Ventola raffreddamento 12 Vdc (1 pz.)
-Zoccoli
-Morsettiera 2 poli (1 pz.)
-Boccole (2 pz.)
-Dissipatori (3 pz.)
-Millefori o base in rame per circuiti stampati
-Ingranaggi per il movimento
Per evitare che res-alba venga disturbata dal sole durante la giornata, possiamo mettere una specie di
parasole per eliminare i riflessi solari.
9
Progetto di: Marco Romani
Programma principale: Main_stepper.c
/**********************************************************
Comando motore passo-passo (stepper)
modalita' passo intero
velocita' fissa
Connessioni:
RA0/AN0 <--> Sensore di luminosita'
res_dx
RA3/AN3 <--> Sensore di luminosita' res_sx
AN5
<--> Sensore di luminosita' res_alba
AN2 <--> Pulsante finecorsa
RB7
<--> comando P1 ponte motori
RB6
<--> comando P2 ponte motori
RB5
<--> comando P3 ponte motori
RB4
<--> comando P4 ponte motori
*********************************************************/
#include <pic.h>
#include "Macro.h"
// NOTA BENE: modificare il valore di PIC_CLK nel file seguente
// se la frequenza del quarzo e' diversa da 20 MHz
// CONFIGURATION BITS
#include "delay.h"
__CONFIG(HS & WDTDIS & PWRTEN & BORDIS & UNPROTECT);
// INTIO: Internal RC No Clock
// XT: External quartz <= 4 MHz
// HS: External quartz > 20 MHz
//WDTDIS: Watchdog timer Disabled
//PWRTEN: Power-up Timer Disabled
//BORDIS: Brown-out detect Disabled
//UNPROTECT: Do not read protect EEPROM data
// INIZIO PROGRAMMA PRINCIPALE
main(void)
{
// DICHIARAZIONE DELLE VARIABILI
int res_dx, res_sx, res_alba, n, ok;
short i;
int full_step[]={0b10000000,
0b00010000,
// P1,
P4,
int full_stepi[]={0b00100000, 0b01000000,
// P3,
P2,
unsigned char step_delay;
0b01000000,
P2,
0b00010000,
P4,
0b00100000};
0b10000000};
// array per il controllo delle fasi antiorario
P3
attive in sequenza
// array per il controllo delle fasi orario
P1
attive in sequenza
// INIZIALIZZAZIONE HARDWARE
PORTA = 0;
PORTB = 0;
PORTE = 0;
// Azzera le linee della porta A
// Azzera le linee della porta B
// Azzera le linee della porta E
TRISA = 0b00001101;
TRISB = 0b00000000;
TRISE = 0b11111111;
ADCON1 = 0b10100000;
// Imposta la porta A con AN0, RA3,RA2 come ingresso
// Imposta la porta B come uscite
// Imposta la porta E con AN5 ingresso
// Setto la conversione A-D:
// Conversion Clock Fosc/16
// Allineamento a DX
// SPEGNI COMPARATORI
CMCON=0x07;
i = 0;
// INIZIO CICLO DEL PROGRAMMA
while(1)
{
ADCON0 = 0b10010001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
ok=ADRESL/100;
ADCON0 = 0b10101001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
// Uso AN2
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
// Assegnazione dal registro alla variabile ok
// Uso AN5
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
10
Progetto di: Marco Romani
res_alba=ADRESL/100;
// Assegnazione dal registro alla variabile res_alba
ADCON0 = 0b10000001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_dx=ADRESL/100;
// Uso AN0
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10011001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_sx=ADRESL/100;
// Uso AN3
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
// Assegnazione dal registro alla variabile res_dx
// Assegnazione dal registro alla variabile res_sx
while(res_dx<res_sx )
{
// Passo intero orario
{
step_delay=200;
PORTB=full_stepi[i];
DelayMs(step_delay);
i=i+1;
i=i%4;
// Cambiamento di fase
// Ritardo per il cambio di fase
// incremento di passo in modulo 4
// i rimane fra 0 e 3
}
ADCON0 = 0b10010001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
ok=ADRESL/100;
// Uso AN2
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10000001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_dx=ADRESL/100;
// Uso AN0
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10011001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_sx=ADRESL/100;
// Uso AN3
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
// Assegnazione dal registro alla variabile ok (controllo finecorsa)
// Assegnazione dal registro alla variabile res_dx
// Assegnazione dal registro alla variabile res
}
if(res_alba>res_sx && res_alba>res_dx)
{
// Passo intero antiorario
while(ok)
{
step_delay=200;
PORTB=full_step[i];
DelayMs(step_delay);
i=i+1;
i=i%4;
// Cambiamento di fase
// Ritardo per il cambio di fase
// incremento di passo in modulo 4
// i rimane fra 0 e 3
ADCON0 = 0b10010001;
DelayMs(50);
// Uso AN2
// Ritardo di 50 ms
GODONE=1;
while(GODONE==1)
continue;
ok=ADRESL/100;
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10101001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_alba=ADRESL/100;
// Uso AN5
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10000001;
// Uso AN0
// Assegnazione dal registro alla variabile ok
// Assegnazione dal registro alla variabile res_sx
11
Progetto di: Marco Romani
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_dx=ADRESL/100;
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
ADCON0 = 0b10011001;
DelayMs(50);
GODONE=1;
while(GODONE==1)
continue;
res_sx=ADRESL/100;
}
// Uso AN3
// Ritardo di 50 ms
// Partenza della conversione A-D
// Attesa della fine della conversione
if(!ok)
{
//se viene premuto il finecorsa
// Assegnazione dal registro alla variabile res_dx
// Assegnazione dal registro alla variabile res_sx
}
PORTB = 0;
//azzero l'uscita
}
} //fine while loop
} // FINE MAIN
Il programma appena visualizzato è nominato come:
- Main_stepper.c
Per il funzionamento dell’intero programma occorre aprire in MPLab un progetto con caricati anche i
seguenti file:
- delay.c
- delay.h
- macro.h
12