Creative Commons BY-NC-ND 2.5Questo sito e tutto il suo contenuto sono distribuiti sotto la licenza Creative Commons Attribuzione - Non Commerciale - Non opere derivate 2.5 Italia e con le condizioni d'uso definite nel disclaimer: siete pregati di leggere entrambi questi documenti prima di usufruire dei contenuti di questo sito. Per alcuni contenuti è necessaria una registrazione gratuita: non è necessario pagare e non è necessario accumulare punteggi per accedere agli articoli e scaricare i sorgenti. Basta solo essere onesti. Se volete che questo sito continui a rimanere attivo, a contribuire ogni giorno alla diffusione della cultura libera, non copiate il materiale per ripubblicarlo in altri luoghi : chi fa questo è solo un miserabile e un perdente. Se volete partecipare su settorezero e rendere le vostre idee, i vostri progetti, fruibili da tutti senza limitazioni, come dovrebbe essere in un paese civile e acculturato, potete farlo tranquillamente.

Regolazione luminosità / breathing LED PWM con Mosfet e PIC10F322

Autore: Giovanni Bernardo | Data pubblicazione: 10 ottobre 2012
Categorie: PICmicro 10/12/16 Progetti

In realtà il termine breathing (respirare) che ho usato nel titolo non mi piaceva molto ma è così che viene indicato l’effetto di “respirazione” tipico dei led di stato sui macbook della Apple (sleep mode): si tratta di una pulsazione eseguita in maniera graduale: si passa da uno stato di luminosità zero per poter giungere al massimo livello di luce per poter poi di nuovo scendere gradualmente e quindi ricominciare daccapo. L’effetto è sicuramente molto più interessante di un semplice lampeggiamento on/off.

Il circuito (oserei più dire il firmware) qui proposto fa uso della schedina di sviluppo basata sul PIC10F322 vista qualche tempo fa qui.

Vedete che nello schema ho cerchiato in verde le parti aggiunte nell’area di prototipazione della scehda.

Ho collegato questo circuito a delle strisce di led. I led vengono pilotati attraverso un MOSFET. Il mosfet che ho utilizzato è un BUZ91, ma potete usare un qualsiasi mosfet a canale N (o a canale P ma collegandolo in maniera inversa!) purchè la corrente di Drain massima (Id) sia in grado di alimentare il carico e la tensione di funzionamento di questo sia inferiore o uguale alla Vdss (Tensione Drain-Source). Nel mio caso, dovendo pilotare due strisce di led funzionanti a 12V e che hanno un assorbimento totale di 800mA, il BUZ91 è più che sufficiente dal momento che ha una corrente di Drain di 8A. Se siete più esigenti potete utilizzare, tanto per fare un altro esempio, un IRF540 (Id=33A e Vdss=100V). Ad ogni modo al massimo della luminosità, l’aletta del mio BUZ91 comunque scalda tantissimo tanto da non poterla toccare ed è necessario un dissipatore.

Il segnale PWM viene applicato al gate del mosfet a canale N attraverso una resistenza di basso valore (47Ω), il carico da pilotare viene quindi collegato tra tensione di alimentazione e drain (ricordo che se pilotate un motore, o un qualsiasi carico induttivo come un solenoide o un relè, è necessario mettere un diodo di ricircolo in antiparallelo).

Sulla scheda ho messo due screw-terminal in parallelo per facilitare il collegamento delle mie due strisce di led. Per fare in modo che il tutto sia alimentato con una singola tensione (12V, necessaria alla striscia di led), ho incluso anche uno stadio di alimentazione classico con un 7805 e sull’area avanza ancora spazio (mi raccomando, montate il mosfet in maniera tale che poi sia agevole avvitarci un’aletta di raffreddamento):

Il firmware, dicevo, fa uso del modulo PWM e vi sono due modalità di funzionamento, selezionabili tramite il pulsantino SW1:

  • Modalità manuale (evidenziata dal led D1 spento) : il trimmer regola il duty cycle del pwm e quindi la luminosità dei led collegati al mosfet
  • Modalità automatica (evidenziata dal led D2 acceso) : il duty cycle viene variato in maniera ciclica (da un valore minimo a uno massimo e viceversa) e il trimmer regola invece la velocità di lampeggiamento (ovvero il ritardo tra una variazione del duty cycle e la successiva)

Un video dovrebbe spiegare meglio la funzionalità del progetto che vi sto esponendo:

La regolazione del PWM viene eseguita dalla Interrupt Service Routine sull’ overflow del Timer0: ho impostato i registri per avere un interrupt ogni millisecondo circa. Qui vengono incrementati/decrementati i contatori e invertito flag di direzione che determinano insieme l’effetto breathing led. In modalità manuale, invece, nell’ISR viene soltanto impostato il valore di duty cycle determinato dal valore restituito dal modulo AD, fornito dalla posizione del trimmer.

Nel codice vengono eseguite 32 letture dal convertitore AD e quindi fatta la media tramite bitshift a destra di 6 posizioni (2^6=32), questo per avere una lettura più stabile del trimmer ed evitare quindi fastidiose fluttuazioni di luminosità in modalità manuale.

Se ancora non avete pratica con le operazioni di bitshift, leggete il mio articolo sugli operatori di scorrimento

Il senso della riga 119:

119
pwmcounter=adman>>3;

è questo: il valore della variabile adman (valore dal convertitore AD già mediato) viene shiftato a destra di 3 posizioni (ovvero diviso per 2^3=8) in maniera tale da portare i valori 0-255 a 0-31; tale valore viene quindi assegnato alla variabile pwmcounter che si occupa in pratica di generare il ritardo (espresso in millisecondi) tra un incremento/decremento del duty cycle e il successivo in modalità automatica: 255 per me era troppo e i led rimanevano accesi per troppo tempo.

La luminosità dei led collegati al mosfet, variando il duty cycle in maniera lineare, appare scorrere in maniera esponenziale (cioè quando la luminosità deve diminuire, sembra che lo faccia più velocemente di quando invece aumenta). Per poterla linearizzare, i ritardi dovrebbero essere diminuiti per valori “alti” di duty cycle e aumentati per valori bassi.

I due defines:

56
57
#define MAXPWM	180
#define MINPWM	0

impostano i valori massimo e minimo del PWM (nel range 0-255), io ho messo 180 come valore massimo perchè dopo questo valore non noto un cambiamento di luminosità apprezzabile e i led rimanevano quindi accessi al massimo per troppo tempo rispetto a quanto rimangono spenti.

Il parametro:

60
#define MINDELAY 1

invece determina il valore minimo di ritardo tra una variazione di duty cycle e l’altra in modalità automatica, l’ho impostato ad 1mS, in pratica mettendolo a zero, quando si gira il trimmer tutto al minimo, la velocità di lampeggiamento è talmente elevata che i led appaiono fissi, con 1mS lampeggiano abbastanza velocemente, per avere regolazioni più fini si dovrebbe diminuire il tempo di interrupt.

La memoria programma occupata è di circa il 64% con la versione LITE dell’Hi-Tech: questi PIC grandi come un chicco di riso continuano a stupirmi.

Download

Nel file zip è contenuto il sorgente in C per Hi-Tech C Compiler per la famiglia PIC10/12/16, il progetto MPLAB e il file HEX precompilato. Per ulteriori informazioni sulla scheda di sviluppo utilizzata fate riferimento all’articolo precedente su di essa. nei commenti qualcuno ha indicato dove poterla ancora reperire dato che non è più in produzione.

Vi chiedo come sempre di non utilizzare questo materiale o sue parti per ripubblicarlo su altri siti o riviste: non è bello quando vedo i miei lavori su altri siti (di quart’ordine tra l’altro) e la gente (la gentaglia) li vanta come i propri solo perchè “l’ho migliorato cambiando il quarzo e aggiungendo una nuova funzione (totalmente inutile)“: non è così che un progetto è il proprio progetto. E’ triste, meschino e mi fa passare la voglia di fare tutto.

Se potete, supportate settorezero.com con una donazione (link a lato sopra ai siti amici) o con un progetto della sezione servizi o partecipando in maniera attiva.

PDFControllo luminosità/breathing LED PWM con PIC10F322 (5.15 kB - 271 downloads)

L'articolo ti è piaciuto o ti è stato utile per risolvere un problema? SettoreZero è realizzato soltanto contenuti originali: tutti gli articoli sono curati con passione dagli autori e nulla viene copiato da altri siti. Supporta e mantieni in vita SettoreZero con una donazione: basta soltanto un caffè o una birra. Puoi supportare SettoreZero anche con uno dei progetti elencati nella sezione servizi o partecipare anche tu con un tuo articolo/progetto personale.

Se desiderate che SettoreZero continui a rimanere gratuito e fruibile da tutti, non copiate il nostro materiale e segnalateci se qualcuno lo fa.

Puoi andare alla fine dell'articolo e lasciare un commento. I trackback e i ping non sono attualmente consentiti.

  1. #1 da Marco_Fantini il 11 ottobre 2012

    Buongiorno,

    Sono nuovo del forum. Ti faccio i miei sinceri complimenti (se posso darti del tu) per il sito. Girovagavo in rete e mi sono imbattuto in questo sito. Veramente ben fatto. Finalmente non la solita aria fritta. Si vede che ciò che è scritto è prima pensato.

    Ciao

    Marco

  2. #3 da neborkia il 18 ottobre 2012

    Grazie mille per l’articolo! Ho iniziato da poco con i PIC proprio leggendo il tuo corso! E’ una miniera d’informazioni utili, a seguirlo s’impara tantissimo e molto velocemente!

  3. #4 da digito il 23 ottobre 2012

    Salve, volevo solo fare i miei complimenti non solo per questo progetto ma per tutti gli altri proposti,

    dalla semplicità .. la funzionalità, ribadisco elogi per Lei e per tutti quelli che contribuiscono in questo benedetto paese a dare un apporto vero e un impulso verso i giovani a credere che si può; ma tutti assieme e non individualmente.
    Grazie e Distinti Saluti.

  4. #5 da Fabri877 il 13 novembre 2012

    Salve a tutti,
    sono molti anni che progetto e programmo i PIC in principio lo facevo per pura passione, i primi progetti erano con il
    16c55 finestrato!!!!! figuratevi quanto sono anziano.
    E con l’ avvento della rete mi sono documentato un po’ in giro, ma vi giuro che un sito come il vostro
    non esiste.
    Complimenti a tutto lo staff e a Lei Giovanni per la semplicità nelle spiegazioni e nelle info dettagliate ed esempi sempre calzanti
    è così che si incentivano i giovani ad avvicinarsi a questo splendido mondo dei controllori.
    Grazie mille

  5. #6 da Yoba il 28 maggio 2014

    Ciao a tutti,
    sono nuovo del sito e nuovissimo del C e della programmazione dei PIC (diciamo che mi ci sto dedicando da un paio di settimane…).
    Seguo con piacere le lezioni, che trovo molto ben articolate e spiegate. Sinceri complimenti quindi anche da parte mia!
    Veniamo al dunque:
    a proposito di PWM e di regolazione di intensità dei LED, con le mie poche conoscenze di programmazione, a scopo puramente didattico e con la certezza che esistono metodi molto ma molto più “evoluti” e snelli per ottenere il medesimo risultato, ho realizzato un programmino che utilizzo su un PIC12F629.
    Il programma, che riporterò in seguito, sostanzialmente funziona nel modo seguente:
    alla prima attivazione (ON) di un interruttore accendo il LED a piena intensità, alla successiva attivazione alimento il led con un duty cycle di circa l’85% (riduco quindi l’intensità luminosa del led), a quella successiva al 70% e così via, per n volte sino allo spegnimento del led.
    Vorrei da voi (con “voi” intendo tutti gli appassionati del sito ovviamente….) un suggerimento per introdurre nel programma una funzione che mi consenta, in qualsiasi momento dell’esecuzione, per una pressione prolungata (per es > di 2 secondi) dell’interruttore, di spegnere il led e poi ripartire dal primo step.
    Questo il programma (tralascio la configurazione dei fuses che é superflua):

    #include “delay.h”
    #define XTAL_FREQ 4MHZ
    #define LED GP2 // Led su Pin GP2
    #define SWITCH GP4 // Interruttore su Pin GP4
    unsigned char Cont1 = 0;/* Definisco una variabile (Cont1)
    di 8 bit (char) inizializzata a 0*/

    void InitApp(void)
    {
    TRISIO = 0b00011000;/* GP4 e GP3 Input il resto Output (GP3 non può essere
    configurato come out)*/
    LED = 0; // LED spento

    }

    void main(void)
    {

    InitApp();

    while(1)
    {
    if (SWITCH == 0) // Se l’interruttore é ON
    {
    if (Cont1 == 0) // E se il contatore é a 0
    {
    do
    {
    Cont1 = 1; //Porto il contatore a 1 e
    LED = 1; // accendo il led
    }
    while (SWITCH == 0);// Finché interruttore ON
    }
    }
    if (SWITCH == 1) // Se l’interruttore é stato rilasciato (OFF)
    {
    if (Cont1 == 1)// E se il contatore é a 1
    {
    do
    {
    Cont1 = 2; // Porto il contatore a 2
    LED = 1; /* Stato led invariato (probabilmente questa
    istruzione potrebbe essere omessa, oppure
    espressa nella forma LED == LED)*/
    }
    while (SWITCH == 1); // Finchè interruttore OFF
    }
    }
    if (SWITCH == 0) // Se interruttore nuovamente ON
    {
    if (Cont1 == 2) // E se il contatore é a 2
    {
    do
    {
    Cont1 = 3; //Porto il contatore a 3 e
    LED = 1;// Alimento il led
    DelayMs(5);// Ton 5 ms
    LED = 0;
    DelayMs(1);//Toff 1 ms
    }
    while (SWITCH == 0);// Finché interruttore ON
    }
    }
    if (SWITCH == 1) // Se l’interruttore é stato rilasciato (OFF)
    {
    if (Cont1 == 3) // E il conatore é a 3
    {
    do
    {
    Cont1 = 4; // Porto il contatore a 4
    LED = 1;// Situazione lnvariata
    DelayMs(5); // Ton 5 ms
    LED = 0;
    DelayMs(1); // Toff 1 ms
    }
    while (SWITCH == 1);// Finché interruttore OFF
    }
    }
    /* …… e così via, ripetendo gli ultimi due cicli, interruttore ON
    ed interruttore OFF, per n volte a piacere in cui si incrementa il
    contatore e si modificano Ton e Toff.
    Nel mio caso, dato T = Ton + Toff = 6 ms, eseguo 5 cicli diminuendo ed
    incrementando rispettivamente Ton e Toff di una unità.
    Il programma si conclude, con l’azzeramento del contatore e lo
    spegnimento del led, cosi:*/

    if (SWITCH == 0) // Se interruttore nuovamente ON
    {
    if (Cont1 == 12) /* E se il contatore é a 12 (ovviamente questo valore
    dipenderà dal numero di cicli eseguiti in
    precedenza….)*/
    {
    do
    {
    Cont1 = 13; // Porto il contatore a 13
    LED = 0;// e spengo il led
    }
    while (SWITCH == 0); // Finché interuttore ON
    }
    }
    if (SWITCH == 1) // Se l’interruttore é stato rilasciato (OFF)
    {
    if (Cont1 == 13) // E se il contatore é a 13
    {
    do
    {
    Cont1 = 0; // Resetto il contatore
    LED = 0; // Led sempre spento
    }
    while (SWITCH == 1); // Finché interruttore OFF
    }
    }
    }
    }

    Grazie a tutti e ancora sinceri complimenti!

  6. #7 da Yoba il 6 giugno 2014

    Ciao di nuovo a tutti!
    Poco dopo aver postato il precedente messaggio sono riuscito ad ideare una soluzione al mio problema, che condivido con piacere.
    Ho inoltre apportato alcune modifiche ed ottimizzazioni al programma, tempo antirimbalzo, delay in us…..
    Il problema che mi ponevo era sostanzialmente di fare in modo che, in qualunque momento durante l’esecuzione del programma, per una pressione prolungata dell’interruttore, il led si spegnesse (senza dover quindi premere n-volte l’interruttore sino al completamento del programma).
    Ho quindi inserito un secondo contatore ed ho fatto in modo che, ad ogni pressione (ON) dell’interruttore, questo si incrementi di una unità ogni 250 ms. Superato un certo valore di incremento del contatore (nel mio caso 3…. quindi dopo 750 ms) se il pulsante risulta ancora premuto, al suo rilascio (OFF), il led si spegnerà.
    Aggiungo (con un certo grado di soddisfazione da neofita quale sono), che ho definito sia il tempo di antirimbalzo sia il tempo di incremento del contatore come costanti all’inizio del programma, ciò mi consente di modificarle “one shot” per ottimizzarle a piacere senza dover modificare n righe di codice.
    Come per il precedente post, anche stavolta mi prefiggo un nuovo obiettivo (nella rinnovata speranza di qualche utile suggerimento giunga anche da chi legge….):
    - come potrei modificare il programma in modo tale che, per una pressione prolungata dell’interruttore (supponiamo superiore a 3 s) abbia inizio una modulazione continua del duty cycle da 100% a 0 a 100% e così via, sino al rilascio dell’interruttore? Ovviamente ad interruttore rilasciato il mio led dovrà continuare ad essere alimentato con duty cicle costante, uguale a quello raggiunto durante la modulazione al momento del rilascio dell’interruttore…..
    Ecco il programma (anche stavolta tralascio la parte relativa alle impostazioni del PIC):

    #include “delay.h”
    #define XTAL_FREQ 4MHZ
    #define LED GP2 // Led su Pin GP2
    #define SW GP4 // Interruttore (SW) su Pin GP4

    unsigned char Cont1 = 0;/* Definisco due variabili (Cont1 e 2)
    di 8 bit inizializzate a 0*/
    unsigned char Cont2 = 0;
    unsigned char x = 3;// Costante per confrontare il valore di Cont2
    unsigned char y = 10; // Costante per tempo di antirimbalzo (ms)

    void main(void)
    {
    while(1)
    {
    if (SW == 0) // Se SW (interruttore) é ON
    {
    DelayMs(y); // Tempo antirimbalzo
    if (SW == 0)// SW ancora ON?
    {
    if (Cont1 == 0)// Con1 é a 0?
    do
    {
    Cont1 = 1; //Porta Cont1 a 1 e
    LED = 1; // accend1 il led
    }
    while (SW == 0);// Finchè SW ON
    }
    }
    if (SW == 1)// SW OFF?
    {
    if (Cont1 == 1) // E Cont1 a 1?
    {
    do
    {
    Cont1 = 2; // Porta Cont1 a 2
    LED = 1;// Led invariato
    }
    while (SW == 1);// Finchè SW OFF
    }
    }
    if (SW == 0) //SW nuovamente ON?
    {
    DelayMs(y);// Antirimbalzo
    if (SW == 0)// SW ON?
    {
    if (Cont1 == 2)// Cont1 é a 2?
    do
    {
    Cont1 = 3; // Porta Cont1 a 3
    LED = 1;// Accendi led
    DelayUs(225);// Duty 75%
    LED = 0;
    DelayUs(75);
    Cont2++;// Avvia Cont2 con incremento unitario (qui inizia la modifica introdotta rispetto alla precedente versione)
    DelayMs(250);// ogni 250 ms
    }
    while (SW == 0);// Finchè SW ON
    }
    if (SW == 1)// L’interrutoore è stato rilasciato (OFF)?
    {
    DelayMs(y);// Antirimbalzo
    if (SW == 1)// SW OFF?
    {
    if (Cont2 > x)// Se il Cont2 é maggiore di x
    {
    if (Cont1 == 3)// e Cont1 uguale a 3
    {
    LED = 0; // Spengi il led
    Cont1 = 11;/* e porta Cont1 all’ultimo valore del programma (che dipenderà dal numero di cicli complessivi, nel mio caso 11)*/
    }
    }
    if (Cont2 <= x)// Se invece Cont2 <= x
    {
    if (Cont1 == 3)// E se Cont1 a 3
    {
    do
    {
    Cont1 = 4;// Porta Cont1 a 4
    LED = 1;// Led invariato
    DelayUs(225);
    LED = 0;
    DelayUs(75);
    Cont2 = 0;// Azzera Cont2
    }
    while (SW == 1);// Finchè SW OFF
    }
    }
    }
    }
    }
    ….. il programma prosegue come da precedente versione, con l'introduzione per ogni ciclo ON della nuova funzione (e delle migliorie), sino all'ultimo ciclo, così articolato:

    if (SW == 0) // SW ON?
    {
    DelayMs(y);// Antirmbalzo
    if (SW == 0)// SW ON?
    {
    if (Cont1 == 10) // Cont1 é a 10?
    {
    do
    {
    Cont1 = 11; // Porta cont1 a 11
    LED = 0;// e spengi il led
    }
    while (SW == 0);// Finché SW ON
    }
    }
    }
    }
    if (SW == 1) // SW OFF?
    {
    if (Cont1 == 11) // Cont1 é a 11?
    {
    do
    {
    Cont1 = 0; // Azzerta Cont1
    LED = 0;// Led ancora spento
    Cont2 = 0; // Azzera Cont2
    }
    while (SW == 1);// Finché SW OFF
    }
    }
    }
    }

    mantenendo premuto l'interruttore si ottiene anche un "simpatico" lampeggio (ogni 250 ms) che, se avete per esempio impostato a 3 il valore di x, rende l'evidenza (contando i lampeggi) di quando si supera la "soglia di spegimento" del led.

    Ciao e …. commentate!!! (… sennò come faccio ad imparare?)

  7. #8 da Vittorio il 29 agosto 2014

    Salve a tutti

    Ho preso spunto da questo progetto per riscriverlo in .ASM ed appliccarlo al PIC 12F615…ne avevo un paio nel cassetto,mantenendo lo stesso nominativo delle variabili

    Quindi ringrazio Giovanni per l’imput partendo dal sorgente in C.

    2 osservazioni:

    1) Sicuramente è un errore di battuta ma nel testo hai scritto 2^6= 32, va corretto con 2^5 = 32 altrimenti la procedura di media sui campioni acqusiti da parte dell’ ADC sballa

    2) I parametri impostati per la PWM prevedono un periodo di circa 31,25Khz con valore del registro PR2 = 0x40hex = 64dec.
    La risoluzione max per il Dytty Cycle, con i parametri impostati è di 9bit.
    Due di questi 9 bit ,gli LSB, si trovano nel registo CCPON e vengono posti uguale a zero. I 7 bit
    meno significativi che saranno quelli con cui varieremo il Dutty Cycle sono nel registro a 8 bit
    CCPR1L.

    Solo i 7 bit meno significativi di questo registro devono essere presi in considerazione.
    Il peso percentuale che ha il bit di posizione 0 del registro CCPR1L posto ad 1 è:
    65 : 100% = 1 : X —–> X = 100/65 = 1,5% ogni aumento unitario in questi 7 bit
    corrisponde ad un aumento di 1.5% di Dutty Cycle.
    Questo ci fa capire che serve solamente una dinamica tra [0 - 65] per i valori del registro
    CCPR1L per avere una corrispontende dinamica di Dutty Clycle tra [0% 100%].

    Oltre 65, il dutty cycle rimane sempre al 100%.
    Considerare quindi una dinamica [0 -180] equivale a mantenere per 115ms l’uscita GP2 al livello alto al 100% Dutty Cycle. Non abbiamo quindi un respiro regolare per il LED nella modalita automatica in quanto non abbiamo una pausa equivalente quando il Dutty Cycle è allo 0%. Questo si nota a bassa velocità di respiro . Detto in alter parolese l’uscita GP2 fosse dotata di filtro passa basso vedremmo, alla sua uscita, un onda di tensione trapeziodalenon simmetrica. Per migliorare questo respiro,nel sorgente .asm ho inserito una pausa di circa 125ms, pausa cheviene eseguita solamente quando il Dutty Cycle ragginge il valore Max100% o il valore min 0%. Per fare questo ho inserito un flag di pausa che viene settato all’interno del corpo Interrupt solamente quando si ragginge il Max . o il min. del Dutty Cycle ,flag che poi viene controllato nel Main del programma. Inoltre ho dato una priorieta al questo flag pausa, nel senso che, fintanto che la pausa non è stata estinta, gli interrupt che si succedono,sempre ogni 1ms, non vanno a modificare i registri PWM_delay e PWM_value cioè il Dutty Cycle .

    Grazie a tutti quelli che seguono questo Forum
    caffe già pagato Giovanni

Devi essere collegato per lasciare un commento.

  1. Ancora nessun trackback
settorezero.com e il logo Zroid™ ©2007÷2013 Giovanni Bernardo - E' vietata la copia e la distribuzione anche parziale dei contenuti di questo sito web senza l'esplicito consenso dell'autore.
I contenuti di settorezero.com sono distribuiti sotto una licenza Creative Commons Attribuzione-Non Commerciale-Non Opere derivate 2.5 Italia a cui vanno aggiunte le condizioni d'uso definite nel disclaimer.
settorezero.com e tutti i suoi contenuti sono tutelati dalla legge sul diritto d'autore per cui i trasgressori sono perseguibili a norma di legge.
Creative Commons BY-NC-ND 2.5
Il tema di questo sito è basato sul tema Fusion per wordpress, realizzato originariamente da digitalnature e fa uso del plugin Wassup per il computo delle statistiche. Per contattare l'autore siete pregati di utilizzare la sezione contatti.
Per essere aggiornato con tutte le novità di settorezero.com seguici anche anche su Facebook Twitter Tumblr Blogspot Youtube.