Corso programmazione PICMicro in C – Lezione 12 (Parte 2/3) – Utilizzare le eeprom esterne I2C

Giovanni Bernardo | 31 agosto 2010
Categorie: PIC® MCUs - PIC® MCUs (8bit)

Nella prima parte di questa lezione abbiamo visto cos’è il modulo (M)SSP e come lo si configura per utilizzarlo in modalità I2C. Vedremo quindi in questa seconda parte un’applicazione pratica delle librerie I2C: come si utilizza una memoria eeprom esterna.

In una lezione precedente, inoltre, abbiamo parlato di memoria eeprom interna: le nozioni e le varie operazioni binarie che abbiamo già visto ci potranno tornare molto utili soprattutto se avremo la necessità di memorizzare nella eeprom valori numerici superiori ad 8 bit.

Sappiamo quindi che una memoria eeprom ha la capacità di trattenere le informazioni anche quando l’alimentazione viene tolta, a differenza della memoria RAM. La memoria eeprom interna di un picmicro è molto utile quando, ad esempio, vogliamo salvare svariate variabili da utilizzare magari come “settaggi” per le nostre applicazioni o altro, ma è comunque una memoria molto limitata che non ci permette di implementare applicazioni che richiedono un alto uso di memoria : un datalogger ad esempio.

Le memorie eeprom esterne

Quando abbiamo bisogno di un certo quantitativo di memoria eeprom ecco che ci vengono incontro le memorie eeprom esterne; di queste ne esistono svariati tipi, classificate principalmente dal tipo di bus di comunicazione che utilizzano. Tempo fa erano molto usate le eeprom parallele, le quali avevano cioè, un bus dati di tipo parallelo (es.: la 28C512), tali memorie sono abbastanza grandi in termini di dimensioni fisiche in quanto hanno appunto bisogno di molti pin. Attualmente sono molto più utilizzate le memorie eeprom seriali (serial eeprom): molto meno ingombranti e che oramai garantiscono tempi di accesso e lettura molto ristretti in dipendenza anche dal tipo di interfaccia seriale utilizzato. A seconda del bus dati utilizzato per il trasferimento, avremo quindi vari tipi di memorie, che possiamo classificare grossolanamente in base all’interfaccia:

Parte iniziale della sigla Tipo bus di comunicazione
28 Parallelo
24 Seriale – I2C
25 Seriale – SPI
93 Seriale – Microwire
11 Seriale – UNI/O

Ovviamente a questa regola alcuni produttori fanno eccezione: la Atmel ad esempio per le memorie eeprom non segue alcuna regola logica e stampa sul corpo dei circuiti integrati delle sigle assolutamente sibilline e di impossibile interpretazione come vedremo in seguito.

Le sigle sulle memorie eeprom I2C

A noi, attualmente, interessano le memorie eeprom I2C, e quindi ci occuperemo di queste. Le memorie I2C hanno la sigla formata dal suffisso 24 (la Atmel non  sempre segue questa regola), una o due lettere che identificano alcuni parametri di funzionamento elettrici del chip e infine un numero da 2 a 4 cifre che è rappresentativo della quantità di memoria disponibile espressa in Kbit (no Kbytes! Fate attenzione), possono seguire una o più lettere che identificano altri parametri di funzionamento che a noi non interessano.

Per quanto riguarda le  lettere nella sigla possiamo riassumere qui brevemente cosa identificano (in questa tabella faccio riferimento alle sigle utilizzate dalla Microchip):

Lettere Range di tensione Frequenza operativa massima
LC 2.5 – 5.5 400Khz
FC 1.7 – 5.5 1MHz
AA 1.7 – 5.5 400Khz
C 4.5 – 5.5 100 / 400KHz

Le eeprom con la sola lettera C nella sigla, per alcune marche (come la Microchip) sono fuori produzione (ma solo per quanto riguarda alcuni formati) mentre altre marche (come la ST o la ATMEL) continuano a produrle ed inoltre le specifiche, per la stessa lettera, potrebbero differire a seconda della marca. La frequenza operativa massima, inoltre, dipende sempre dalla tensione di alimentazione: in linea generale diminuendo la tensione di alimentazione, diminuisce anche la frequenza operativa massima.

Tali parametri elencati in tabella, ovviamente non vanno presi come oro colato ma: andatevi sempre a leggere il datasheet del componente che avete tra le mani (bravi! state imparando!). La differenza tra l’una e l’altra sigla, inoltre, c’è anche nel range di temperature “sopportabili” dall’integrato (in particolare sono identificati due range di temperatura: Industrial e Automotive). In linea di massima per i nostri esperimenti l’una vale l’altra, quindi se avete una memoria con la sola C o con AA per noi è lo stesso in quanto funzionano tutte allo stesso modo, dovremo solo controllare per bene la frequenza di funzionamento: abbiamo difatti visto nella lezione precedente che le frequenze più diffuse per l’I2C sono 100KHz e 400KHz e su un bus I2C, se andiamo a collegare più di un dispositivo, dovremo fare in modo che tutti i dispositivi operino alla frequenza del dispositivo che ha la velocità più bassa. Dal momento che nella sigla possiamo avere diversi tipi di lettere, e a noi questo interessa relativamente, per non fare confusione identificherò un’eeprom in maniera generica con la sigla 24XX.

Abbiamo quindi nella parte finale della sigla, un numero che identifica la quantità di memoria, elenco qui alcuni esempi:

Sigla Quantità di memoria disponibile
24XX00 128bits
24XX02 2Kbits – 256Bytes
24XX04 4Kbits – 512Bytes
24XX08 8Kbits – 1024Bytes (1Kb)
24XX16 16Kbits – 2048Bytes (2Kb)
24XX32 32Kbits – 4096Bytes (4Kb)
24XX64 64Kbits – 8192Bytes (8Kb)
24XX128 128Kbits – 16384Bytes (16Kb)
24XX256 256Kbits – 32768Bytes (32Kb)
24XX512 512Kbits – 65536Bytes (64Kb)
24XX1025 1024Kbits – 131072Bytes (128Kb)

Come vedete c’è una certa corrispondenza tra la parte finale della sigla e la quantità di memoria disponibile espressa in Kbits (tranne per la 24X00 e la 24XX1025). Ad oggi non mi risulta che esistano eeprom I2C con capacità superiore a 128Kb (cioè un’ipotetica 24LC2048 ad esempio)

Alcuni dicono che tali memorie (da 256Kb) sono presenti nelle smart-card, ma  personalmente sono dell’opinione che si tratti, in realtà, di due memorie da 128Kb.

Ovviamente questo elenco, come detto, non è completo, pertanto ne esistono anche altri tipi (ad esempio esiste la 24xx014 che è da 1Kbit ecc). Inoltre fate sempre attenzione tra bit e bytes! 1024KiloBits equivalgono a 128KiloBytes.

Siglatura delle memorie prodotte dalla Atmel

Ho detto più in alto che la Atmel non segue questa regola generale per identificare le eeprom di sua produzione.

In pratica, vi capiterà di trovare una memoria da 512Kbit della Atmel siglata come: ATMLUyxx 2FB 2 (es: ATMLU940 2FB 2 oppure ATMLU802 2FB 2 ecc)

Dove in pratica la y sta per l’anno di produzione e le due xx per la settimana, la sigla “2FB 2” secondo loro dovrebbe aiutare a capire che siamo di fronte ad una memoria da 512Kbits, e la cosa bella è che tale memoria è comunque indicata sul  datasheet come 24C512!

Vi dico questo perchè ho acquistato delle eeprom su Ebay e mi sono ritrovato con questi chip della Atmel con sigle strane e in un primo momento stavo mandando una mail al venditore dicendogli che si era sbagliato ad inviare gli integrati, ma poi ho pensato bene di capire  a cosa mi trovavo di fronte… Per tanto vi lascio qui una tabellina che indica la corrispondenza tra alcune sigle di Atmel con le sigle normalmente utilizzate:

Sigla Atmel Corrispondenza
2FB 2 24xx512
2EC L 24xx256

La sigla che dovete vedere è sulla seconda riga dell’integrato in quanto sulla prima c’è ATMLU seguito dalla data di produzione, sulla seconda c’è la sigla che aiuta ad identificare la memoria e sulla terza altre lettere e numeri che non ci interessano. Purtroppo sul sito della Atmel non sono riuscito a trovare altre informazioni sulle sigle di memorie più piccole di quella da 256Kbit.

Selezione e impostazione dell’indirizzo

Abbiamo detto che, potendo mettere su un unico bus più di un dispositivo I2C, molti di questi hanno la possibilità di impostare l’indirizzo in maniera tale che possano coesistere su un’unica linea due dispositivi uguali (ad esempio se abbiamo bisogno di 256Kbytes di memoria eeprom possiamo montare due 24LC1025 sullo stesso bus), altri dispositivi, invece, non ne hanno la possibilità e hanno l’indirizzo fisso (l’orologio DS1307 ad esempio: sarebbe comunque inutile metterne due, no?). Le eeprom I2C fino alla 24XX512 compresa, hanno la parte alta dell’ indirizzo sempre fissa (1010 – chiamata anche Control Code) e la parte bassa di 3 bit (chiamata  Chip Select)  impostabile agendo sui pin denominati A0, A1 ed A2:

Mettendo un pin di selezione indirizzo a massa, il corrispondente bit dell’indirizzo sarà a zero, mettendolo a Vcc sarà a 1. Sullo stesso bus potremo quindi mettere fino a 8 memorie eeprom  24XX512 (cioè da 64Kbytes l’una) ed avere quindi 512Kbytes di memoria.

La memoria 24xx00, invece, non ha i 3 pin di selezione indirizzo: tali pin vengono difatti lasciati non connessi e si presuppone che sul bus ci sia solo lei per cui non può essere utilizzata insieme ad altre eeprom. Il motivo di questa scelta mi è alquanto oscuro ma sul datasheet è spiegato che tale eeprom è pensata per essere utilizzata laddove è richiesta una quantità di memoria eeprom limitata: dispositivi in cui bisogna salvare valori di calibrazione, ID ecc. Quindi in dispositivi che magari non hanno una loro eeprom interna e non si ha la necessità di collegarne altre. Il fatto che poi tale memoria è molto limitata (solo 128bits!) e non ha la selezione indirizzo mi fa pensare che costi meno di una caramella.

Le memorie 24XX1025, invece, pur avendo anch’esse i pin A0, A1 e A2, richiedono che il pin A2 sia messo fisso a Vcc ed è possibile utilizzare, per la selezione dell’indirizzo, soltanto A0 e A1. Questo perchè, nel byte di indirizzamento, la “posizione” del bit A2 (che viene ora indicato come B0) è in realtà utilizzata per la selezione del “blocco”: tali eeprom possono difatti essere immaginate come due da 512 messe in parallelo: selezioniamo i primi 512Kbits ponendo tale bit a zero e i secondi 512Kbits ponendolo a 1.:

Riassumendo: il bit A2 sulle eeprom da 1024Kbits non può essere utilizzato per la selezione dell’indirizzo e quindi il corrispondente pin va obbligatoriamente messo a Vcc.

Le eeprom da 1024Kbits non possono essere utilizzate sulla FreedomII in quanto i 3 pin di selezione dell’indirizzo sono predisposti a massa e abbiamo visto che questo particolare formato di memoria richiede invece che A2 sia messo a Vcc altrimenti non funziona.

Protezione dalla scrittura

Vediamo inoltre, nello schemino del datasheet, oltre ai pin di alimentazione, a quelli di comunicazione e a quelli di selezione indirizzo, un altro pin denominato WP. WP sta per Write Protect: mettendo questo pin a massa è possibile scrivere sulla memoria eeprom. Se WP invece viene messo a Vcc non è possibile scrivere sull’eeprom ma solo leggerla. Si capisce quindi che per i nostri esperimenti dovremo tenerlo a massa.

Organizzazione della memoria

Come per la memoria eeprom interna del picmicro, anche le memorie eeprom esterne possiamo immaginarle come costituite da numerose celle da 1byte, ognuna delle quali ha un indirizzo numerico a partire da zero.

Su alcune memorie eeprom l’indirizzo di ogni cella è a 16bit, su altre è a 8 bit.

Con un indirizzamento ad 8 bit è facile capire che si possono “richiamare” fino a 256celle di memoria, per cui è facile immaginare che l’indirizzamento ad 8 bit è presente nelle memorie eeprom fino alla capacità di 256Bytes (ovvero 2Kbits).

Con un indirizzamento a 16 bit possiamo invece richiamare 65536 celle di memoria ovvero capacità fino a 512Kbits.

La memoria da 1024Kbits pure ha l’indirizzamento a 16bit che normalmente non permetterebbe l’indirizzamento di tutte le celle: c’è appunto il bit B0 dell’indirizzo che permette, come già detto prima, di selezionare il primo o il secondo blocco da 512K e che quindi può farci immaginare tale memoria come due da 512.

Immagino quindi che, per un’eventuale futura memoria da 1024Kbits o toglieranno un altro pin per la selezione dell’indirizzo o ci sarà un indirizzamento a 24bit.

Operazioni di lettura e scrittura

Nella parte precedente della lezione abbiamo già visto come si realizza, sommariamente, una comunicazione I2C. La regola è sempre la stessa per tutti i dispositivi I2C: quando dobbiamo scrivere sulla periferica si eseguiranno le operazioni:

  1. Sequenza di Start
  2. Invio indirizzo periferica in scrittura (bit zero dell’indirizzo posto a zero)
  3. Invio indirizzo del registro in cui scrivere
  4. Invio del valore da scrivere nel registro
  5. Sequenza di stop

Scrittura dato su memoria eeprom con indirizzamento a 16bit: viene inviata prima la parte alta dell'indirizzo della cella in cui scrivere e poi la parte bassa

Nel caso di una memoria da 1024Kbits al posto di A2 metteremo 1 o 0 per scrivere nel primo o nel secondo blocco.

Scrittura di una eeprom con indirizzo ad 8bit

Questa che ho illustrato qui si chiama scrittura Byte Write e serve, cioè, a scrivere un byte alla volta. Nel caso in cui si voglia risparmiare tempo è possibile anche effettuare la scrittura di tipo Page Write che permette di scrivere una pagina alla volta.

Tale modalità prevede di specificare solo l’indirizzo dal quale partire e quindi di inviare in sequenza un tot di bytes da scrivere uno dopo l’altro. La quantità di bytes da inviare in sequenza varia da formato a formato di memoria in quanto ogni memoria ha la pagina di dimensioni diverse dalle altre:

Modalità di scrittura page write su una 24xx64: scriviamo una "pagina" alla volta. Si specifica l'indirizzo di partenza e si inviano una certa quantità di bytes da scrivere in sequenza. Per la 24xx64 la pagina è composta da 32 bytes.

Tale modalità di scrittura è molto vantaggiosa e permette di risparmiare una quantità di tempo davvero notevole ma non tutte le memorie eeprom la supportano.

Se invece vogliamo leggere dall’eeprom, la sequenza di operazioni sarà un po’ più lunga come abbiamo già visto:

  1. Sequenza di Start
  2. Invio indirizzo periferica in scrittura
  3. Invio indirizzo registro da cui prelevare il dato
  4. Sequenza di start ripetuto
  5. Invio indirizzo periferica in lettura (bit zero dell’indirizzo posto a 1)
  6. Lettura del valore (il valore sarà contenuto nel registro SSPBUF)
  7. Sequenza di stop

Modalità di lettura random

Questa modalità di lettura ci permette di leggere un byte alla volta e si chiama Random Read, notate che, non appena ricevuto il byte di dati, il master non invia l’acknowledge e da quindi lo stop.

E’ possibile anche effettuare la lettura sequenziale, che permette di leggere dall’eeprom i dati in maniera continua senza fermarsi e risparmiando quindi molto tempo. Tale modalità di lettura prende il nome di lettura sequenziale (Sequential Read) e viene inizializzata allo stesso modo della lettura random con la sola differenza che il master, dopo aver ricevuto il primo byte di dati, dovrà dare l’acknowledge: in questo modo l’eeprom “capisce” che deve continuare a sfornare dati e continuerà a farlo incrementando da sè in automatico l’indirizzo da cui leggere di una unità. Quando il master si “sarà stufato” di leggere, terminerà la connessione al solito modo: no acknowledge e stop:

Lettura sequenziale: si inizia allo stesso modo della lettura random ma dopo il primo byte ricevuto bisognerà dare l'acknlowledge e in questo modo l'eeprom fornirà la lettura dei bytes nelle celle successive, fino a che il master non termina la comunicazione

Esempio pratico

Nei file allegati c’è un semplice esempio di scrittura e lettura su eeprom esterna. Sono necessarie le librerie I2C che abbiamo visto nella lezione precedente, per cui sapete già quali librerie includere, con quali pic utilizzarle e come utilizzarle. La libreria per la gestione delle eeprom esterne è molto semplice ed è prevista unicamente per quelle eeprom che hanno l’indirizzamento a 16bit (in teoria dalla 24xx04 alla 24xx512 – non includo la 24xx1025 perchè bisogna gestire il bit B0 per selezionare il blocco e qui non l’ho previsto). Sono presenti soltanto due funzioni: una per leggere e una per scrivere, non sono supportate le modalità di scrittura e lettura sequenziale.

Analizziamo la funzione che effettua la scrittura:

17
18
19
20
21
22
23
24
25
26
27
28
29
30
void eee_write_byte(unsigned char deviceid, const unsigned int address, const unsigned char data)
	{
	// aggiungo all'indirizzo "standard" delle eeprom24, il deviceid che si ottiene
	// settando i pin A0,A1,A2. Il device id devo spostarlo di un bit in quanto il
	// bit 0 è quello che determina la lettura/scrittura
	deviceid = EE_CONTROL_CODE | (deviceid <<1);
        I2cStart();	 // avvio la comunicazione I2C
        I2cWriteMaster(deviceid); // invio l'indirizzo della memoria sulla quale voglio scrivere
        // il bit zero è già posto a zero per specificare l'operazione di scrittura
        I2cWriteMaster((char)(address >> 8)); // invio la parte alta dell'indirizzo in cui scrivere
	I2cWriteMaster((char)(address & 0xFF)); // invio la parte bassa dell'indirizzo in cui scrivere
	I2cWriteMaster(data); // Invio il byte
	I2cStop(); // termino la comunicazione
	}

Come vedete la funzione accetta in ingresso l’indirizzo del dispositivo (deviceid), l’indirizzo della cella (address) in cui scrivere e il byte (data) da scrivere. Se abbiamo impostato l’indirizzo della nostra eeprom su 000 (cioè i pin A2,A1 e A0 connessi a massa), in deviceid andrà messo proprio 0. Se abbiamo, ad esempio, messo A2 e A1 a Vcc e A0 a massa l’indirizzo sarà 6 ecc.

Per la libreria che vi ho allegato, teniamo conto che il bit A0 si trovi in posizione 0, il bit A1 in posizione 1 e il bit A2 in posizione 2 anche se in realtà questi 3 bits dovrebbero trovarsi spostati di una posizione verso sinstra: difatti vedete che nel codice eseguo proprio questa operazione. Ho fatto così in quanto in tal modo è più facile calcolarsi l’indirizzo della memoria.

Andiamo quindi a sommare il nostro indirizzo “personale” con quello standard delle eeprom (0b10100000) memorizzato nella costante EE_CONTROL_CODE. Notiamo che l’indirizzo si trova già in modalità scrittura in quanto il bit zero è già posto a zero.

Avviamo quindi la comunicazione I2C e inviamo la parte alta e la parte bassa dell’indirizzo della cella in cui scrivere, le operazioni fatte vi dovrebbero essere già chiare se avete letto questo articolo e quest’altro. Dopo aver inviato l’indirizzo inviamo il byte e quindi terminiamo la comunicazione.

Fate attenzione ad una cosa: da datasheet la scrittura di un byte prende un tempo di 5mS, per cui se appena dopo aver scritto un byte lo andate subito a leggere senza aspettare tale tempo, otterrete un risultato non reale. Per tale motivo nel programma di esempio ho aggiunto un ritardo di 5mS dopo la scrittura.

La funzione di lettura è anch’essa molto semplice:

33
34
35
36
37
38
39
40
41
42
43
44
45
46
unsigned char eee_read_byte(unsigned char deviceid, const unsigned char address)
	{
	unsigned char data;
	deviceid = EE_CONTROL_CODE | (deviceid <<1);
        I2cStart();
        I2cWriteMaster(deviceid);  // invio l'indirizzo della memoria dalla quale voglio leggere
        I2cWriteMaster((char)(address >> 8)); // invio la parte alta dell'indirizzo da cui leggere
	I2cWriteMaster((char)(address & 0xFF)); // invio la parte bassa dell'indirizzo da cui leggere
	I2cRepStart(); // start ripetuto
	I2cWriteMaster(deviceid | 1); // invio l'indirizzo della memoria dalla quale voglio leggere, in modalità lettura
	data = I2cReadMaster(0); // leggo e non invio l'acknowledge
	I2cStop(); // termino la comunicazione
	return data; // restituisco il valore letto
	}

Come vedete facciamo più o meno la stessa operazione precedente: inviamo sul bus l’indirizzo della memoria (in modalità scrittura in quanto il bit zero è posto a zero), quindi l’indirizzo della cella di memoria, eseguiamo uno start ripetuto che ci permetterà di non perdere la comunicazione (nel frattempo l’eeprom si è memorizzata l’indirizzo della cella da cui vogliamo leggere), inviamo quindi l’indirizzo dell’eeprom in modalità lettura: per tale motivo aggiungiamo un 1 all’indirizzo, effettuiamo quindi la lettura che andrà memorizzata nel byte “data” definito prima. Come vedete nella funzione I2cReadMaster abbiamo messo zero come argomento che ci permette di fare in modo di NON inviare l’acknowledge, come richiesto dalla modalità di lettura random che abbiamo discusso più in alto. Viene quindi terminata la comunicazione e la funzione restituisce il dato letto.

Il sorgente di esempio prevede l’utilizzo di una eeprom qualsiasi (ma con indirizzamento a 16 bit) e di leds collegati alla porta RD0. L’esempio l’ho compilato per la Freedom II con su il PIC16F877A per cui se non avete la freedom o altri sistemi di sviluppo che non prevedono il montaggio di una eeprom esterna, fate riferimento al datasheet del vostro picmicro per vedere in quali punti sono presenti i segnali SCL e SDA e allo schema presentato nella prima parte di questa lezione (estratto dallo schema della FreedomII) per vedere come collegare l’eeprom sul bus I2C: in particolare non dovete assolutamente dimenticare le resistenze di pull-up.

Nell’esempio vengono eseguite queste operazioni: andiamo a scrivere un valore (oxFo) nella cella zero dell’eeprom, attendiamo 5mS perchè la scrittura sia completa e poi lo andiamo a rileggere e lo mostriamo sulla striscia a led. Lasciamo i led accesi per un po’ e andiamo a scrivere il valore 0x0F nella cella 1 della eeprom, lo rileggiamo e lo mostriamo sulla barra  a led.

Al vostro occhio non accadrà nulla di spettacolare: il programma in esecuzione accenderà prima gli ultimi 4 led e poi i primi 4. In realtà l’accensione dei led riflette il valore del byte letto dall’eeprom. Potete divertirvi a modificare anche i sorgenti delle lezioni sull’eeprom interna per adattarli all’eeprom esterna. Una volta avuta padronanza con tali concetti, potete utilizzare le eeprom esterne per memorizzare grosse quantità di dati (per un datalogger che memorizza temperature, bitmap da mostrare su display grafici, una rubrica…).

Downloads

Nota: i programmi di esempio sono stati sviluppati con una versione precedente dell’Hitec-C Compiler, per cui compilati con la nuova versione, restituiscono errori. Fate riferimento a questo articolo per maggiori informazioni su come adattare i vecchi programmi. Consiglio spassionato se volete davvero imparare a programmare: non utilizzate l’include legacy headers, ma imparate a cambiare i nomi mnemonici.

File di supporto alla dodicesima lezione del corso di programmazione picmicro in C (883 download)



Questo articolo ti è stato utile? Ti ha permesso di risolvere un problema o di migliorare le tue applicazioni? Ci lavori? Ti ha permesso di scrivere la tua tesina? Ti ha semplicemente fatto spendere un po' del tuo tempo in maniera costruttiva? Allora clicca il banner qui sotto:


Settorezero.com è un blog personale di Giovanni Bernardo aperto dal 25 Ottobre 2007. Non è una testata giornalistica né un sito a carattere commerciale.
Settorezero.com, il logo Zroid™ e la tagline "Play embedded electronics™" sono copyright ©2007÷2019 Giovanni Bernardo.
La navigazione su settorezero.com e la fruizione dei contenuti ivi presenti sono soggette ai seguenti Termini di utilizzo - Informativa sulla privacy - Utilizzo dei Cookie.
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 poter contattare il gestore del sito potete utilizzare la sezione contatti o inviare una email a gianni[at]settorezero[dot]com.
Per seguire gli aggiornamenti del blog Settorezero, oltre al feed RSS, puoi anche seguire la pagina Facebook o iscriverti al canale Telegram.
Su Twitter, invece, pubblico un po' di tutto e, quando mi va, uso anche Tumblr - Google+ - Blogspot - Youtube.