Rilevatore ad impulsi per contatore Enel

Costruire un rilevatore di impulsi da applicare al contatore Enel.

Forse non tutti lo sanno, ma il contatore dell'Enel possiede 2 LED(qui nell'immagine con il NR 3 sulla sinistra) sul frontale dal quale e' possibile ricavare diverse utili informazioni.
Il LED situato nella parte superiore lampeggia secondo una frequenza indicata nella nota stampigliata sul contatore come Ra, ed indica i Kwh consumati, mentre il LED sotto, lampeggia secondo una frequenza indicata nella nota stampigliata come Rr sul contatore, di seguito alla nota precedente, ed indica i Kwh di Potenza Reattiva, che pero' per l'utente domestico non vengono addebitati.
Ora, analizzando la frequenza di accensione del LED superiore e' possibile determinare 2 valori molto utili:
Si puo' conteggiare il consumo dei Kwh in un periodo di tempo, e si puo' ricavare la potenza istantanea, misurando il tempo tra 2 lampeggi.
Contatore Enel
Fig. 1, Parte Frontale del Contatore Elettrico Monofase(Tratto dal manuale di istruzioni fornito dall'Enel).

Quello che vi volevo proporre oggi e' un circuito che possa conteggiare queste 2 misure e possa trasmetterle, tramite una App, che potete trovare su Google Play sotto il nome di 'Energy Count Lite With Arduino', al Vs telefono Android.
Naturalmente questi 2 valori sono gia' disponibili scorrendo il menu' del contatore, ma col circuito proposto e'possibile memorizzare i valori sul Vs telefono, senza dover aprire il portello del quadro elettrico che contiene il contatore.
Per costruire il circuito ho utilizzato la classica piattaforma Arduino, collegata ad un rilevatore di luce ed equipaggiato con un display LCD locale. Per la trasmissione dei dati alla App ho utilizzato un modulo Bluetooth HC-06.

Cominciamo ad analizzare lo schema elettrico:
Schema Elettrico Rilevatore Impulsi
Fig 2. Schema Elettrico.

Il cuore del sistema e' composto da un Arduino UNO, R.3. Su questa board non c'e' nulla da aggiungere a quanto non sia gia' dettagliatamente descritto nel sito(www.arduino.cc). A tale dispositivo ho aggiunto un display LCD mod. LCM1602C, che e' lo stesso modello che viene fornito con lo starter kit di Arduino.
Il tipo di collegamento ed il modo di pilotaggio di tale dispositivo, nonche' il software di supporto, pero', sono stati pensati diversamente da quelli proposti in rete e sul sito ufficiale. Visto che il progetto e' stato pensato per ridurre al minimo il consumo di energia, il display viene acceso solo su comando. Quindi premendo il pulsante S1, viene dato un comando ad Arduino, tramite l' Ingresso D6, ed il software di supporto attivera' l'uscita D7 per 3 secondi.
Tale uscita mandera' in conduzione, tramite la Resistenza R3, il Transistor Q1 il quale fornira' la corrente necessaria all'accensione ed al pilotaggio del Display. La R" serve per dare un riferimento all'ingresso D7 per tenerlo a livello logico 0 quando il pulsante S1 non e' premuto.
Durante questo periodo, vengono dati i comandi di inizializzazione al display, e viene visualizzata su di esso la potenza utilizzata dall'ultimo Reset, nonche' la potenza ricavata durante l'ultima rilevazione. Dopo 3 Secondi, tutte le uscite che sono collegate al display vengono portate a 0V ed il display si spegnera'.
Andando ad analizzare il software noterete che forzo a 0 esplicitamente tutte le uscite, anziche' lasciare il compito alla libreria di supporto. Sono costretto a questo tipo di approccio perche' se una qualsiasi uscita dati viene portata o lasciata a livello logico 1(5V), questa poi trasferisce la tensione anche al pin 2 di alimentazione(VDD), lasciando, di fatto, acceso il display. Il Potenziometro R1 serve a variare il contrasto del display, mentre la R4 serve per accendere i LED della Retroilluminazione del Display LCD. Anche questa e' stata scelta di un valore elevato per ridurre il consumo durante l'accensione del Display.
Passiamo ora alla sezione di rilevazione impulsi, composta dal Fototransistor Q2 e dalla resistenza R5.
Diciamo innanzi tutto che la resistenza e' stata scelta in modo empirico, cercando di avere una tensione prossima ai 5 V con LED acceso e sotto ad 1V con LED spento.
Aumentando la Resistenza R5 si aumenta la sensibilita' del circuito di ingresso, ovvero serve meno luce per raggiungere una tensione prossima ai 5V,diminuendola si ottiene l'effetto contrario. Diciamo che una sensibilita' troppo elevata rischia di tenere in uscita una tensione troppo elevata quando il led del contatore e' spento, tenedo cosi' a livello logico 1 l'ingresso D2 e non riuscendo, di fatto, a conteggiare gli impulsi. Sebbene questo circuito funzioni bene, in un prodotto commerciale preferirei usare una configurazione di ingresso con un Trigger di Schmit. E' bene ricordare che il Fototransistor e' possibile sostituirlo anche con altri modelli, l'unica accortezza e' quella di calibrare la resistenza R5 in funzione della sensibilita' del componente. Passiamo ora al modulo di comunicazione.
Per inviare i dati ad un dispositivo remoto(in questo caso un Android Phone), ho qui utilizzato un Bluetooth module HC-06. E' un dispositivo molto economico e versatile e viene fornito gia' configurato come modulo Slave, cosicche', per farlo funzionare con questa applicazione, non serve nessun tipo di configurazione, lo si deve giusto collegare come da schema elettrico, scaricare l'Applicazione 'Energy Count Lite With Arduino' da Google Play Store e seguire alcuni semplici procedure per far si che l'App si metta subito in comunicazione. Vedremo di seguito come procedere.
Come vedrete dalle caratteristiche di questo BT Module, esso va alimentato da 3,6V a 6V, pero' le sue uscite di TX e RX hanno una tensione di lavoro di 3,3V. Arduino ha gli GPIO che funzionano a 5V e quindi collegando direttamente i piedini RX e TX del BT Module agli ingressi di Arduino, rischiamo di danneggiare l'ingresso RX del BT Module, e di non rilevare correttamente i dati all'ingresso di Arduino collegato al pin TX del BT Module.
Per risolvere il problema della tensione troppo elevata all'ingresso dell' RX Pin delBT Module, inseriamo un semplice partitore resistivo con un rapporto fra le resistenze che possa abbassare i 5V fino ad un valore di circa 3,3V. Viceversa, il TX all'uscita del modulo andrebbe alzato di tensione da 3,3V fino a 5V, ma qui servirebbero dei componenti attivi. Per non complicare troppo il circuito elettrico, ho collegato questo Pin direttamente all'ingresso di Arduino. In questo caso cio' non causa problemi perche' la soglia di rilevazione dello stato logico 1 e' di 3.0V, quindi 3,3V dovrebbe funzionare bene. In ogni caso sono solito usare un controllo CRC nella comunicazione seriale, quindi se ci fosse qualche problema, il dato acquisito verrebbe scartato senza avere, quindi, letture errate.
Tutto il circuito consuma circa 60/70 ma, di cui 10/15 ma sono del LED sulla scheda HC-06 che indica lo stato di connessione del modulo.
Per alimentare tutto il circuito ho utilizzato un Battery Pack del modello usato come riserva di energia per telefoni cellulari e tablet. Per prelevare l' alimentazione ho preso un cavetto USB ho tagliato il terminale dal lato opposto a quello che si inserisce nel Battery Pack ed ho individuato i 2 cavi che prelevano la tensione delle batterie.
Rilevatore Impulsi montaggio su breadboardFig 3. Montaggio del progetto su Breadboard.

Una volta assemblato tutto il circuito su di una Breadboard, lo collaudiamo.
Per prima cosa dobbiamo scaricare l'Applicazione 'Energy Count Lite With Arduino' da Google Play Store ed installarla sul nostro telefono Android, poi dobbiamo caricare il software di gestione in Arduino.
E' sufficiente creare un nuovo Sketch e quindi sostituire l'intero contenuto del file col contenuto che si trova all'interno dell'Applicazione nella sezione Arduino Sketch, oppure quello contenuto alla fine del presente documento.
Al termine del download del software, proviamo a premere il pulsante S1, il Display dovrebbe apparire come segue:
Rilevatore Impulsi displayFig 4. Display alla prima accensione dopo il caricamento del software su Arduino.
per poi spegnersi dopo circa 3 secondi.

Per simulare il lampeggio del LED del contatore Enel, sfruttiamo il LED che indica lo stato della comunicazione sul BT Module HC-06.
Ora posizioniamo il BT Module in modo che il led di stato del modulo sia sopra il Fototransistor.
Rilevatore Impulsi installazione
Fig 5. Particolare del posizionamento della scheda HC-06 sul Fototransistor per simulare gli impulsi ed eseguire il collaudo del circuito.
A questo punto, nel caso il montaggio sia stato fatto correttamente, il led del BT Module lampeggera' ed il Fototransistor comincera' a rilevare gli impulsi.
Ora premendo nuovamente il pulsante S1, si dovrebbe vedere il valore degli impulsi ed il valore della potenza istantanea, salire, quello dei Kwh salira' dopo aver raggiunto il nr di impulsi impostato.

Appurato che la scheda funziona, passiamo al test di comunicazione con l'App ' Energy Count Lite With Arduino'.
Fig. 6                                Fig.7                                   Fig. 8
Rilevatore Impulsi App1Rilevatore Impulsi App2Rilevatore Impulsi App3A questo punto cliccare sul menu a SX, che si aprira' automaticamente al primo avvio, sulla voce 'New Bluetooth Client', quindi cliccare sul 'Bluetooth Server Address' field ed eseguire il pairing con il modulo Bluetooth cliccando sulla voce, nell'elenco dei Device Bluetooth, Fig 8, corrispondente al nome del Bluetooth Device installato sul circuito.
Naturalmente tutta la procedura va fatta tenendo acceso tutto il circuito.

Fig 9.                                 Fig 10.                                Fig 11.
Rilevatore Impulsi App4Rilevatore Impulsi App5Rilevatore Impulsi App6Una volta che il pairing e' stato eseguito, Fig 9, selezionare il BT Module dalla lista dei Device Paired, Fig 10 ed automaticamente i campi Bluetooth Server Name e Bluetooth Server Address verranno compilati Fig 11.. Lasciare gli altri campi ai valori di default e quindi premere 'Save' dal menu che apparira' dopo aver premuto il tasto del Context Menu'.

Se, dopo aver cliccato nel campo rappresentato nella Fig 8., anziche' apparire la Fig 9., dovesse apparire la Fig 9.1, significa che il modulo non riesce ad instaurare una comunicazione con Arduino. In questo caso verificare la corretta connessione dei Pin. RX e TX e verificare che il software sia stato correttamente scaricato. In ogni caso e' possibile eseguire il pairing anche da queste maschere, che fanno parte delle maschere di default di Android. Per eseguire il pairing da queste maschere, e' sufficiente cliccare sul nome del device ed apparira' quindi la finestra di associazione, Fig 9.2. Ad associazione terminata, Fig 9.3, premere il tasto 'Back' per tornare alla Fig 10.

Fig 9.1                                 Fig 9.2                             Fig 9.3
Rilevatore Impulsi App7Rilevatore Impulsi App8Rilevatore Impulsi App9A questo punto fare lo swipe da SX verso DX in modo da far uscire di nuovo il menu principale e sotto alla voce 'Devices', apparira' il nostro nuovo BT Module. Ora siamo pronti per acquisire il nostro primo dato.

 

 

 

 

Fig 12.                               Fig 13.                                Fig 14.
Rilevatore Impulsi App12 Rilevatore Impulsi App11 Rilevatore Impulsi App10Cliccare ora sulla voce del nuovo BT Device, Fig 12, a questo punto si aprira' la Fig 13 e l'App comincera' la sequenza di scarico dei dati. Se tutta la sequenza va a buon fine, lo schermo dovrebbe essere simile alla Fig 14.
A questo punto il collaudo e' completo, possiamo passare all'assemblaggio meccanico del sensore ed alla sua installazione nel contatore Enel.
Per realizzare il supporto del Fototransistor, ho utilizzato una piccola staffa in alluminio dove ho fissato un portaled, dentro al quale ho inserito il Fototransistor
Fig 15a.                                      Fig 15b.
Rilevatore Impulsi montaggio2 Rilevatore Impulsi montaggio1

 

 

Fig 15c.                                                             Fig 15d.
Rilevatore Impulsi montaggio3Rilevatore Impulsi montaggio4Ho quindi appoggiato la staffa sul contatore dell'Enel come in Fig 15c e Fig 15d.
Per un fissaggio piu' stabile e'possibile applicare un po' di nastro adesivo.

Durante il montaggio della Staffa, fare attenzione di allineare il Fototransistor con il LED del Contatore.

A questo punto, se premete il pulsante S1, comincerete a vedere il nr di Impulsi che cresce e comincerete a vedere il consumo istantaneo di casa vostra.
Il Nr di Impulsi per Kwh verra' impostato all'interno dello Sketch dove c'e' l'apposito valore commentato.

Rilevatore Impulsi completo
Foto del progetto completo.

Software di Gestione del Progetto:

/*Circuit:
 * HC-06 Bluetooth module attached
 * LCM1602C LCD Display Module attached
created 30 08 2015
 by Riccardo Pretolesi
*/
 #include <SoftwareSerial.h>
 #include <LiquidCrystal.h>
// Communication
 #define BT_RX 4 // PIN TO receive from bluetooth
 #define BT_TX 5 // PIN TO transmit to bluetooth
 SoftwareSerial m_btSerial(BT_RX, BT_TX);
// Counter
 #define encoder0PinA 2
 #define encoder0PinB 3
 volatile unsigned int encoder0Pos = 0;
// Display
 LiquidCrystal *m_lcd = 0;
boolean m_bShowDisplayOneShot;
 unsigned long m_ulLCDOffTime;
// Global Data
 byte *m_byteMsgPnt = 0;
 int m_iMsgLenght = 0;
 boolean m_bCRCCntrl = true;
 byte REQ = 5;
 byte ACK = 6;
// Count Value
 volatile long m_lCountValue;
 volatile long m_lCountValueKwh;
 volatile long m_lCountValueKwhPrev;
 volatile unsigned long m_ulCountValueTimePrev;
 volatile long m_lLastPowerCalculationValue;
 volatile unsigned long m_ulCountValueTime;
 volatile unsigned long m_ulCountValueSpanTime;
 // Change this value in according with the nr of pulses for each Kwh
 long m_lNrOfPilseForKwh = 1000;
void setup() {
 // put your setup code here, to run once:
 Serial.begin(9600);
 // Initialize Bluetooth SoftwareSerial port for selected data speed
 m_btSerial.begin(9600);
// Counter
 pinMode(encoder0PinA, INPUT);
 pinMode(encoder0PinB, INPUT);
 // encoder pin on interrupt 0 (pin 2)
 attachInterrupt(0, doEncoderA, RISING);
 // encoder pin on interrupt 1 (pin 3)
 attachInterrupt(1, doEncoderB, FALLING);
m_lCountValue = 0;
 m_lCountValueKwh = 0;
 m_lCountValueKwhPrev = 0;
 m_ulCountValueTimePrev = 0;
 m_lLastPowerCalculationValue = 0;
// Display
 pinMode(6, INPUT);
 pinMode(7, OUTPUT);
// setDisplayValuePos_1(m_lCountValueKwh);
 m_ulLCDOffTime = millis();
 m_bShowDisplayOneShot = false;
}
void loop() {
 // Data Acquisition...
// LCD
 // In order to save power, i turn on the display only by a button,
 // But if one of the pins are ON, also the power Supply is ON and the display get the power from these pins.
 // I don't have the internal electrical drawing of the LCD(LCM1602C) and i don't know the causes of this behavior...
 // To avoid it, i set these all to OFF
 if (digitalRead(6) == HIGH) {
 if (m_bShowDisplayOneShot == false) {
 m_bShowDisplayOneShot = true;
 m_ulLCDOffTime = millis();
 // Turn ON the LCD
 digitalWrite(7, HIGH);
 // I need to init the LCD every time i turn it on.
 if(m_lcd == 0){
 m_lcd = new LiquidCrystal(13, 12, 11, 10, 9, 8);
 m_lcd->begin(16, 2);
 m_lcd->clear();
 }
 setDisplayValueKwhAndW((m_lCountValueKwh / m_lNrOfPilseForKwh), m_lLastPowerCalculationValue);
 setDisplayValuePulse(m_lCountValue);
 }
 } else {
 m_bShowDisplayOneShot = false;
 if((m_ulLCDOffTime + 3000) < millis()) {
 digitalWrite(7, LOW);
 delete m_lcd;
 m_lcd = 0;
 setDisplayDataPinsAllOff();
 }
 }
// Debug
 /*
 if(m_lCountValueKwhPrev != m_lCountValueKwh){
 m_lCountValueKwhPrev = m_lCountValueKwh;
 Serial.print("Kwh: ");
 Serial.print(m_lCountValueKwh);
 Serial.print(", Watt: ");
 Serial.println(m_lLastPowerCalculationValue);
 }
 */
 // Communication
 Communication();
 }
/* Interrupt Routines */
 void doEncoderA(){
// Calculation....
 m_ulCountValueTime = micros();
 // Between 2 pulses should pass at least 100ms(100.000microseconds)(It correspond a consumption of around 36000 Kwh, that it's too much for a Domestic Power)
 // you can reduce or increase this value in case of differents values for pulse(here i use 1 pulse for every Wh)
 if((m_ulCountValueTimePrev > 0) && (m_ulCountValueTime > m_ulCountValueTimePrev) && ((m_ulCountValueTime - m_ulCountValueTimePrev) > 100000)){
 //Pulses Calculation
 m_lCountValue++;
 //Kwh Calculation
 m_lCountValueKwh++;
 // Watt Calculation....
 m_ulCountValueSpanTime = m_ulCountValueTime - m_ulCountValueTimePrev; // microseconds
 m_lLastPowerCalculationValue = (3600 * 1000000) / m_ulCountValueSpanTime;
 } else {
 m_lLastPowerCalculationValue = 0;
 }
 m_ulCountValueTimePrev = m_ulCountValueTime;
 }
 void doEncoderB(){
}
 /* Display */
 void setDisplayValueKwhAndW(long lValueKwh, long lValueW){
 if(m_lcd == 0){
 return;
 }
 m_lcd->setCursor(0, 0);
 m_lcd->print("Kwh:");
 m_lcd->print(lValueKwh);
 m_lcd->setCursor(8, 0);
 m_lcd->print("W:");
 m_lcd->print(lValueW);
 }
 void setDisplayValuePulse(long lValuePulse){
 if(m_lcd == 0){
 return;
 }
 m_lcd->setCursor(0, 1);
 m_lcd->print("P.Cnt.:");
 m_lcd->print(lValuePulse);
 }
 void setDisplayDataPinsAllOff(){
 pinMode(8, OUTPUT);
 digitalWrite(8, LOW);
 pinMode(9, OUTPUT);
 digitalWrite(9, LOW);
 pinMode(10, OUTPUT);
 digitalWrite(10, LOW);
 pinMode(11, OUTPUT);
 digitalWrite(11, LOW);
 pinMode(12, OUTPUT);
 digitalWrite(12, LOW);
 pinMode(13, OUTPUT);
 digitalWrite(13, LOW);
 }
/* Communication */
 void Communication(){
 // Communication...
 // put your main code here, to run repeatedly:
 m_iMsgLenght = 0;
 while(m_btSerial.available() > m_iMsgLenght)
 {
 // update the incoming query message length
 m_iMsgLenght = m_btSerial.available();
 // wait for inter-char time
 delayMicroseconds(4);
 // Serial.print(m_iMsgLenght);
 }
 // Message completed, check for CRC
 m_bCRCCntrl = true;
 if(m_iMsgLenght >= 3){
 // CRC Control
 }
 // Check Msg Request
 if(m_iMsgLenght > 0 && m_bCRCCntrl == true){
 // Serial.println(" ");
 //allocate memory for the incoming query message
 m_byteMsgPnt = (byte*) malloc(m_iMsgLenght);
 //copy the query byte for byte to the new buffer
 for (int i = 0; i < m_iMsgLenght; i++){
 m_byteMsgPnt[i] = m_btSerial.read();
 }
 // get the first byte
 byte byteFirstChar = m_byteMsgPnt[0];
 // free memory...
 free(m_byteMsgPnt);
 m_iMsgLenght = 0;
 // check message
 if(byteFirstChar = REQ){
 // Send back the couut in 32 bits format signed(Android Java doesn't support Unsigned Long, up to now!)
 // Kwh -1
 union {
 long l;
 byte lByteTemp[4];
 } l_1;
 l_1.l = (m_lCountValueKwh / m_lNrOfPilseForKwh); // value
 reverseByteArray(l_1.lByteTemp, 0, 3);
// Kwh -2
 union {
 long l;
 byte lByteTemp[4];
 } l_2;
 l_2.l = m_lCountValue; // value
 reverseByteArray(l_2.lByteTemp, 0, 3);
// W -3
 union {
 long l;
 byte lByteTemp[4];
 } l_3;
 l_3.l = m_lLastPowerCalculationValue; // value
 reverseByteArray(l_3.lByteTemp, 0, 3);
//allocate memory for the outcoming answer message
 m_byteMsgPnt = (byte*) malloc(1 + sizeof(l_1.lByteTemp) + sizeof(l_2.lByteTemp) + sizeof(l_3.lByteTemp) + 2);
 // prepare the answer
 // Head
 m_byteMsgPnt[0] = ACK;
 // Data
 memcpy(&m_byteMsgPnt[1], l_1.lByteTemp, sizeof(l_1.lByteTemp));
 memcpy(&m_byteMsgPnt[5], l_2.lByteTemp, sizeof(l_2.lByteTemp));
 memcpy(&m_byteMsgPnt[9], l_3.lByteTemp, sizeof(l_3.lByteTemp));
 // CRC
 union {
 short temp_short;
 byte temp_bytearray[2];
 } u_CRC;
 u_CRC.temp_short = getCRC(m_byteMsgPnt, (1 + sizeof(l_1.lByteTemp) + sizeof(l_2.lByteTemp) + sizeof(l_3.lByteTemp))); // CRC
 m_byteMsgPnt[13] = u_CRC.temp_bytearray[0]; // CRC
 m_byteMsgPnt[14] = u_CRC.temp_bytearray[1]; // CRC
 // Send answer
 for (int i = 0; i < (1 + sizeof(l_1.lByteTemp) + sizeof(l_2.lByteTemp) + sizeof(l_3.lByteTemp) + 2); i++) {
 m_btSerial.write(m_byteMsgPnt[i]);
 // Serial.print(m_byteMsgPnt[i]);
 }
 // free memory...
 free(m_byteMsgPnt);
 // Serial.println(" ");
 // Serial.print((1 + sizeof(ul.lByteTemp) + 2));
 // Serial.println(" ");
 }
 }
 }
 /* Function to reverse arr[] from start to end*/
 void reverseByteArray(byte Array[], int iStart, int iEnd) {
 byte temp;
 while (iStart < iEnd)
 {
 temp = Array[iStart];
 Array[iStart] = Array[iEnd];
 Array[iEnd] = temp;
 iStart++;
 iEnd--;
 }
 }
 /* CRC Calculation */
 unsigned short getCRC(byte buf[], int len)
 {
 unsigned short crc = 0xFFFF;
for (int pos = 0; pos < len; pos++) {
 crc ^= (unsigned short)buf[pos]; // XOR byte into least sig. byte of crc
for (int i = 8; i != 0; i--) { // Loop over each bit
 if ((crc & 0x0001) != 0) { // If the LSB is set
 crc >>= 1; // Shift right and XOR 0xA001
 crc ^= 0xA001;
 }
 else // Else LSB is not set
 crc >>= 1; // Just shift right
 }
 }
 // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
 return crc;
 }

Note della Redazione:
Ricordo ai nostri lettori che qualunque modifica al contatore Enel è da considerarsi fuorilegge.
Il contatore Enel è e deve rimanere integro pena la denuncia da parte delle autorità competenti.
La Redazione non si assume nessuna responsabilità su eventuali conseguenze dovute all'applicazione del circuito descritto, gli utenti che decideranno di implementare la soluzione proposta lo faranno a loro piena e totale responsabilità.

Ringraziamenti delle Redazione:
La redazione ringrazia il Sig. Riccardo per la partecipazione e per aver condiviso con noi questo utile progetto.
Inoltre si congratula per la chiarezza e la pulizia del codice e condivide con piacere il suo motto evergreen.

Autore: Riccardo Pretolesi

Biografia autore: Riccardo ha conseguito il diploma di Perito Elettronico; e' appassionato dall'inizio dei tempi di informatica ed elettronica(Vi ricordate il Commodore VIC 20??), passione coltivata anche grazie alle sue esperienze professionali in ambito internazionale.
Il suo motto è: Un perdente trova sempre una scusa, un vincente trova sempre una strada.

Contato diretto con l'autore:
Ti è piaciuto questo progetto?
Iscrivite oggi stesso alla nostra newsletter e ricevi gli aggiornamenti su tutti i nostri nuovi progetti direttamente nella tua email!
2 Commenti
  1. Rosario Mussari 2 anni ago
    • Riccardo Pretolesi 2 anni ago

Lascia una Risposta