Dotclok_Apertura


Pubblichiamo la proposta che ha vinto il concorso iniziato nel fascicolo n° 178: si tratta di una revisione del Dotklok che implementa nuove funzionalità come la lettura della temperatura ambiente e il controllo del livello di luminosità del display sulla base della luce presente nell’ambiente. Il tutto può essere comandato a distanza tramite un comune telecomando TV.

 

Come sapete, il concorso “Aggiungi una funzione in più al tuo DOTKLOK” si è concluso a fine ottobre e nelle scorse settimane abbiamo vagliato con attenzione le soluzioni giunte in Redazione.
Diciamo subito che ci aspettavamo più firmware e meno teoria, ma nonostante ciò qualche interessante proposta – degna di pubblicazione – è arrivata.
Tra queste, quella che ci è sembrata la migliore e che si è aggiudicata il premio in palio, ossia una stampante 3D, è quella del Sig. Stefano Del Bufalo.

 

Il nuovo firmware, contenuto in una cartella zip, può essere scaricato qui.

 

Come promesso, condividiamo con i nostri lettori la soluzione vincente per “snocciolare” gli aspetti che la caratterizzano e che possono certamente rappresentare, per tutti i nostri lettori che lavorano con Arduino, interessanti spunti da cui partire per sviluppare ulteriori applicazioni. Il soggetto lo conoscete dalla pubblicazione dell’articolo nel fascicolo n° 175: è il celebre Dotklok, l’orologio hold fashioned e un po’ vintage, con il display a matrice di LED rossi o verdi che richiama le sveglie di trent’anni fa; oltre che essere un orologio capace di segnare il tempo in vari modi, questo progetto consente di realizzare animazioni grazie, proprio, alla matrice di LED.

 

A rendere ancora più interessante il dispositivo, c’è il fatto che nasce secondo la filosofia open source, cosa che non sorprende, visto che il suo creatore, Andrew O’Malley, ha utilizzato come sistema di programmazione per il micro che controlla tutte le funzioni l’IDE di Arduino; più esattamente, Dotklok è costruito con un display a matrice di LED da 16×24 diodi (disponibile in due colori: rosso e verde), gestito da un controller Holtek HT1632 ad interfaccia seriale. Il tutto è interfacciato ad una scheda di controllo basata su architettura Arduino con microcontrollore Atmel Atmega328P e Real Time Clock integrato incentrato sul classico integrato DS1307 della Dallas Semiconductor.

 

Proprio il firmware e l’hardware open hanno spronato numerosi sperimentatori a costruire e personalizzare il proprio Dotklok, condividendo gli sketch da essi realizzati per aggiungere o cambiare le animazioni di cui Dotklok è capace.

Questo è stato poi il senso del concorso che abbiamo lanciato e che proponeva di ideare e inviare varianti al funzionamento del Dotklok come sviluppato da O’Malley, così da incentivare uno stimolante scambio di idee. Modificare il firmware per aggiungere nuove funzionalità o modificarle non richiede solo pratica con il linguaggio di programmazione e con l’IDE di Arduino, ma anche la capacità di tenere da conto una limitazione di Arduino Uno, che nello specifico è la massima dimensione della Flash a disposizione per il firmware; infatti, ogni eventuale aggiunta richiede spazio, e il firmware originale non ne lascia moltissimo, quindi la modifica impone un lavoro di “limatura” che consiste nell’ottimizzare il firmware togliendo ciò che non serve e aggiungendo il possibile.

La soluzione

Ma entriamo nel vivo del progetto vincente segnalando come l’autore abbia proposto due interessanti modifiche:
una apporta nuovo hardware e l’altra propone il software che permette di sfruttarle.

Per quanto riguarda l’hardware, Stefano ha implementato l’aggiunta di due sensori:

  • uno di temperatura;
  • uno di luce.

Inoltre, è stato previsto anche un ricevitore infrarosso standard a 38 kHz, adatto a ricevere comandi dai classici telecomandi IR dei televisori, DVD, videoregistratori, decoder TV ecc. Questo permette di inviare comandi a distanza a Dotklok, che ognuno potrà scrivere a piacere nel firmware; infatti, la soluzione proposta contiene l’implementazione del codice per leggere il telecomando usato dal vincitore, ma ognuno potrà sostituire il codice con quello adatto al proprio.

Oltre a queste funzionalità, il Dotklok presenta modifiche firmware che cambiano la modalità di rappresentazione dell’orario, implementando, ad esempio, quella visibile in basso:

 

Insieme

Con le modifiche apportate, il firmware occupa “appena” 27 kb, quindi entra senza problemi nella memoria di programma del micro, ampia 32 kb.

Per quanto riguarda i sensori, quello di temperatura permette, mediante un’opportuna modifica dello sketch di rappresentare sul display la temperatura ambiente come se fosse una delle numerose animazioni già presenti in Dotklok.

La sonda di temperatura scelta è la classica e collaudatissima LM35 di Texas Instruments, che fornisce un segnale analogico consistente in una tensione continua di 10 mV per ogni grado centigrado rilevato; l’LM35 fornisce il valore di temperatura con un’accuratezza di 0,5 °C  in un campo di misura compreso tra -55 e +150 °C. L’integrato ha tre piedini, due dei quali sono per l’alimentazione (4÷30 Vcc) mentre quello centrale fornisce la tensione analogica che esprime la temperatura rilevata. Siccome l’LM35 fornisce 10mV/°C a partire dallo 0 K, 0 gradi centigradi, corrispondenti a 273,15 K, determinano in uscita 2,7315 volt.

E passiamo al secondo sensore, che permetterà di attivare o escludere la regolazione automatica della luminosità del display in base alla luce ambientale, per evitare, ad esempio, in situazione di poca luce nell’ambiente, che i LED possano risultare troppo fastidiosi, o al contrario che in caso di forte luce, gli stessi siano poco visibili.

La lettura della sonda di temperatura e quella della fotoresistenza vengono realizzate applicando le tensioni corrispondenti agli ingressi analogici di Arduino; in particolare, la fotoresistenza che presenta un valore in piena oscurità di circa 20 kohm, viene collegato in serie ad una resistenza fissa da 1 kohm, in modo da formare un partitore di tensione alimentato dal +5V.

Affinché la lettura avvenga correttamente, a questo potenziale va portato anche il pin Vref di Arduino.

 

Il telecomando

L’ultima variazione sul tema apportata dal vincitore del concorso è l’aggiunta del telecomando: implementata con poche righe di codice. Questa funzione permette di leggere i segnali inviati dai comuni telecomandi ad infrarossi impiegati in TV, decoder, ecc. Con questa modifica si possono rendere gran parte delle funzioni del Dotklok controllabili da remoto, tanto da poter sostituire i tasti del telecomando ai pulsanti già presenti.

Negli esempi di codice forniti dal Sig. Del Bufalo, il telecomando permette di passare da un’animazione ad un’altra stando comodamente seduti sul divano, oppure, sempre da remoto, disattivare il sensore di luminosità per impostare in modo manuale il grado di luminosità del display; infatti una volta introdotto un sensore e uno sketch che reagisce alla pressione di un qualsiasi pulsante di un qualsiasi telecomando, l’unico freno all’introduzione di nuove funzioni, è la fantasia. Infatti il bello di questa soluzione è che non serve un telecomando specifico, ma il sistema può apprendere i codici della gran parte dei telecomandi, purché funzionanti con portante dati di 38 kHz. Allo scopo, basta impostare il Dotklok nella modalità DEBUG, per vedere sul monitor seriale (Serial Monitor dell’IDE di Arduino) quali valori restituiscono i vari tasti di un qualsiasi telecomando, ed introdurre questi ultimi valori nello sketch; vedremo tra breve come apprendere i codici direttamente dal display, invece che da Serial Monitor.

 

Il nuovo firmware

Purtroppo per realizzare tutto questo, occorre rinunciare a qualche animazione per motivi di spazio, già precario, del microcontrollore ATMega328P; in questo caso l’autore ha rinunciato a “percent_time”, ”random_dot_time”, ”morse_time” e “game_time”, che sono state rimosse dal firmware. Inoltre, chi volesse recuperare più spazio di quello liberato dall’autore, potrà seguire le istruzioni contenute nelle guide del prof. Michele Menniti sul suo sito (http://www.michelemenniti.it/), modificando opportunamente il file board.txt per la programmazione dell’ATMega Stand-Alone con il metodo ISP. Le funzioni aggiunte e quelle tolte hanno comportato una sostanziale modifica dello sketch, per quanto riguarda la parte di setup.

Lo sketch inviato dal Sig. Del Bufalo (scaricabile dal nostro sito web) è aggiornato per essere inserito con l’IDE 1.0.1 di Arduino e le relative librerie (la RTClib attuale, ad esempio) supportano tutte le versioni dell’IDE.

La libreria aggiornata RTClib contiene già il controllo della versione dell’IDE.
Alla libreria Button, contenuta nel file Button.h, l’autore ha aggiunto le seguenti righe per verificare la versione dell’IDE:

#if (ARDUINO >= 100)

#include <Arduino.h>

#else

#include <WProgram.h>

#endif

 

La libreria ht1632 invece, è rimasta quella originalmente pubblicata da noi per il Dotklok originale.
Nel Listato 1, vedete la dichiarazione delle variabili per lo sketch modificato.

 

//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) inizio
//--------------------------------------------------------------
// Sensore LM35
int pin_lm35 = A1;		

// Sensore IR Remote Control
int pin_IR = 12;
#include <IRremote.h>
IRrecv irrecv(pin_IR);
decode_results results;
int ir_mode = 0;  //int ir_mode = 2 (test IR) - int ir_mode = 0 
                  //(funzionamento normale)
int c;
boolean remote_control = false;

// Luminosita’ da fotoresistenza
int pin_fotoresistenza = A0;
int fotoresistenza_val;
int lux_val = 10;
boolean fotoresistenza_stato = true;

//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) fine
//--------------------------------------------------------------

 

Notate le righe:

 

// Sensore LM35

int pin_lm35 = A1;

che riguardano l’aggiunta del sensore di temperatura e:

 

// Sensore IR Remote Control

int pin_IR = 12;

 

che si riferiscono al telecomando IR.

Per questa funzionalità, si carica la libreria IRremote.h:

 

#include <IRremote.h>

 

La libreria da importare per questo progetto è la IR Remote versione 0.11 e solo quella; altre potrebbero non funzionare.

Per quanto riguarda il telecomando, l’abbinamento si effettua in questo modo: per prima cosa bisogna portare Dotklok in modalità 2 (test IR) modificando la riga int ir_mode = 0; nel Listato 1, sostituendo 2 a 0 fino a far diventare la riga int ir_mode = 2;.

 

A questo punto, si punta il telecomando verso il sensore IR a 38 kHz, restando ad almeno mezzo metro di distanza e si trasmette usando i tasti che si desidera comandino le funzioni di Dotklok; grazie alla modifica alla funzione implementata dal Sig. Del Bufalo, il display di Dotklok mostra direttamente il numero corrispondente al codice del tasto premuto.

Basta prendere nota dei numeri e poi andarli a sostituire nella funzione “press_remote”, così il sistema riconoscerà i tasti che desiderate.

 

Per provare IRremote, che è la funzione di lettura del telecomando IR, bisogna impostare la variabile int ir_mode = 2;, che trasforma il DOTKLOK in un tester per telecomandi; potete usare qualsiasi telecomando, ma se vedete passare troppi “0”(zero) alla pressione dei vari tasti, è possibile che esso non lavori proprio a 38 kHz, quindi il sistema non riesce a rilevarlo.

Lo sketch fornito dall’autore contiene, nella funzione “press_remote”,  i codici esadecimali contenuti  e restituiti da un telecomando in suo possesso.

 

Nell’esempio dell’autore, mediante il telecomando è possibile:

A)    cambiare modalità 0, 1 e 2 ( ovverosia valore di ir_mode)

0. in modalità 0 (si accende per un secondo il primo led in alto a sinistra), con i tasti + e – si può cambiare animazione.

1. in modalità 1 (si accende per un secondo il secondo led in alto a sinistra), con i tasti + e – si può cambiare la luminosità del display.

2. in modalità 2 (si accende per un secondo il terzo led in alto a sinistra), si attiva il debug per il controllo remoto, infatti qualsiasi tasto si preme su di un qualsiasi telecomando viene visualizzato il codice esadecimale che restituisce.

B)     Attivare o disattivare la luminosità automatica del display in base alla luce ambientale: premendo una volta la si disattiva, compare un meno (-) in basso a sinistra, premendo di nuovo la si attiva e compare un più (+) in basso a sinistra.
Da tener presente che usando la modalità 1, questa funzione viene disattivata automaticamente.

 

La parte di firmware che gestisce il telecomando IR è riportata nel Listato 2.

 

 

//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) inizio
//--------------------------------------------------------------

// press_remote
// Verifica all’interno dei loop delle animazioni, se si e’ inviato un comando mediante telecomando boolean press_remote(){ 

	//===============================================================
	// Ricezione segnale IR
	//===============================================================
	if (irrecv.decode(&results)) {

	String ir_val = String(results.value, HEX); 
	// legge il codice esadecimale letto dal sensore IR

	if (ir_mode==0 && ir_val==”15”) {
			animation++;
			if(animation > ani_max)  animation = 1;
			delay(50);
	} else if (ir_mode==0 && ir_val==”16”) {
			animation--;
			if(animation < 1)  animation = ani_max;
			delay(50);
	} else if (ir_mode==1 && ir_val==”15”) {
			lux_val++;
			fotoresistenza_stato = false;
			ht1632_sendcmd(11, HT1632_CMD_PWM + lux_val);
			delay(50);
	} else if (ir_mode==1 && ir_val==”16”) {
			lux_val--;
			fotoresistenza_stato = false;
			ht1632_sendcmd(11, HT1632_CMD_PWM + lux_val);
			delay(50);
	}

	if(ir_val==”30”) 
{	// Tasto Mode (il valore esadedimale dipende dal telecomando usato)
			ir_mode++;
			if (ir_mode > 2) { ir_mode = 0; }
			plot(ir_mode,0,1);
			delay(1000);

		} else if(ir_val==”12”) 
{	// Tasto on/off luminosita’ automatica
(il valore esadedimale dipende dal telecomando usato)
			if (fotoresistenza_stato) {
				fotoresistenza_stato = false;
				plot(0,13,1);plot(1,13,1);plot(2,13,1);
			} else {
				fotoresistenza_stato = true;				
				plot(1,12,1);
				plot(0,13,1);plot(1,13,1);plot(2,13,1);
				plot(1,14,1);		
			}			
			delay(1000);

		} else if(ir_val==”11”) 
{	// Funzione 1 (il valore esadedimale dipende dal telecomando usato)
			// test Funzione 3
			plot(1,15,1);
			delay(50);

		} else if(ir_val==”10”) 
{	// Funzione 2 (il valore esadedimale dipende dal telecomando usato)
			// test Funzione 4
			plot(2,15,1);
			delay(50);

		} else if(ir_mode==2)
{ //(Modo 2 - debug per rappresantare a display i codici esadecimali dei vari pulsanti di telecomandi sconosciuti)
			// visualizza i codici esadecimali non usati
			ht1632_clear();
			int step = 0;

			char char_print[10];
			ir_val.toCharArray(char_print, sizeof(char_print));

			scroll_text(char_print);

			delay (500);
		}

		irrecv.resume(); // Pronto per il prossimo segnale

		return true;
	}

	return false;
}

void luce_ambiente(boolean fotoresistenza_stato) {

	if (fotoresistenza_stato) {
		fotoresistenza_val = analogRead(pin_fotoresistenza);

		lux_val = map(fotoresistenza_val, 1023, 700, 0, 15);
		if (fotoresistenza_val<700) { lux_val = 0; }
		ht1632_sendcmd(11, HT1632_CMD_PWM + lux_val);
	}

}
//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) fine
//--------------------------------------------------------------

 

I numeri corrispondenti ai tasti del trasmettitore che avete ricavato durante la prova in modalità test, dovete scriverli nelle porzioni di codice if (ir_mode==0 && ir_val==”15”). Il numero che segue _val== va sostituito per i vari tasti con i codici corrispondenti all’animazione che volete comandare.
Nel Listato 2, la porzione di codice seguente:

 

if (ir_mode==0 && ir_val==”15”) {

animation++;

if(animation > ani_max)  animation = 1;

delay(50);

}
else if (ir_mode==0 && ir_val==”16”) {

animation–;

if(animation < 1)  animation = ani_max;

delay(50);

definisce i codici dei tasti assegnati allo scorrimento in avanti e indietro nelle animazioni (modo 0): la pressione del tasto identificato dal codice 15 avanza e quella del tasto contraddistinto dal 16 fa tornare all’animazione precedente. Se i tasti che avete scelto corrispondono ad altri numeri, inserite questi al posto di 15 e 16.

Sempre nel Listato 2, la porzione di codice:

 

} else if (ir_mode==1 && ir_val==”15”) {

lux_val++;

fotoresistenza_stato = false;

ht1632_sendcmd(11, HT1632_CMD_PWM + lux_val);

delay(50);

} else if (ir_mode==1 && ir_val==”16”) {

lux_val–;

fotoresistenza_stato = false;

ht1632_sendcmd(11, HT1632_CMD_PWM + lux_val);

delay(50);

 

definisce la funzione dei soliti tasti 15 e 16 nel caso il Dotklok sia in modo 1 (regolazione luminosità).
Valgono le considerazioni appena fatte per il modo 0.

La chiamata alle varie funzioni interessate al nuovo firmware è visibile nel Listato 3, che riguarda il setup del sistema; qui trovate una chiamata a vuoto nel setup() “analogRead(pin_lm35);” che serve alla gestione della fotoresistenza.

 

/***************************************************************
 * traditional Arduino sketch functions: 
 and loop.
 **************************************************************/

void setup() 
{
  // init the button inputs
  pinMode(4, INPUT);
  pinMode(5, INPUT);
  pinMode(6, INPUT);
  pinMode(7, INPUT);
  pinMode(8, INPUT);
  digitalWrite(4, HIGH);       
  digitalWrite(5, HIGH);
  digitalWrite(6, HIGH);
  digitalWrite(7, HIGH);
  digitalWrite(8, HIGH);

    // debug mode forced by B4 pressed during start up
  if(!digitalRead(7))  DEBUG=true;

  if(DEBUG){
    Serial.begin(57600);
    Serial.print(“DOTKLOK “); Serial.println(REV);
    Serial.println(“DEBUG true, serial port open at 57600”);
    //Serial.print(“Avail mem = “);
    //Serial.println(availableMemory());
  }
  else{
    Serial.begin(57600);
    Serial.print(“DOTKLOK “); Serial.println(REV);
    Serial.println(“DEBUG false, serial port now closed”);
    Serial.end();
  }

  // display screen setup, software version display, (and test)
  ht1632_setup();
  ht1632_clear();
  putchar_3x5(6, 5, REV[0]);
  putchar_3x5(12, 5, REV[2]);
  putchar_3x5(18, 5, REV[4]);
  plot(10, 9, 1);
  plot(16, 9, 1);
  delay(1000);
  if(DEBUG)  screenTest();

  // general set up
  //pinMode(13, OUTPUT);
  randomSeed(analogRead(0));

  // RTC setup
  Wire.begin();
  RTC.begin();

  if (!RTC.isrunning()) {
    if(DEBUG) Serial.println(“RTC is NOT running!”);
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
  else { 
    if(DEBUG) Serial.println(“RTC is running.”); 
  }

  // test buttons
  /*
  while( b5.isPressed() ){
    for(int i=0; i<4; i++){
      if( buttons[i].isPressed() )  plot(i,0,1);
      else                          plot(i,0,0);
    } 
  } */

	//--------------------------------------------------------------
	//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) inizio
	//--------------------------------------------------------------
	// Avvio ricevitore IR
	irrecv.enableIRIn();
	// settaggio pin fotoresistenza
	pinMode( pin_fotoresistenza, INPUT);
        analogRead(pin_lm35);
	//--------------------------------------------------------------
	//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) fine
	//--------------------------------------------------------------

} // end setup()  

void loop()
{    
  // all time and button checking handled in animation fucntions
  // main loop just handles animation number (init. to 1)
  // bound the animation number
  //animation = constrain(animation,1,ani_max);
  //if(DEBUG)  animation=6; // used to force any animation during testing/debugging
  if(DEBUG) { Serial.print(“loop / animation: “); Serial.println(animation); }

  // run the clock animation
  switch(animation) {
  case 1:
    big_time();
    break;
  case 2:
    basic_date_time();
    break;
  case 3:
    scroll_time();
    break;
	//------------------------------------------------------------
	//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) inizio
	//------------------------------------------------------------
  case 4:
    temperatura_time();
    break;
	//--------------------------------------------------------------
	//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) fine
	//------------------------------------------------------------
  } // end switch(animation)

} // end main loop

//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo) > time_animations.h
//--------------------------------------------------------------
// temperatura_time
void temperatura_time(){

	long millis_now = 0;
	long millis_temp = 0; 
	long gap_temp = 1000;

	boolean power_up = true; // used to force time display on function startup

	/* INIT DISPLAY */

	ht1632_clear();

	/* TIME LOOP */
	do{ // exit based on button presses, checked later in loop

		//========================================================
		// Lettura Sensore Temperatura
		//========================================================
		millis_now = millis();

		if (millis_now - millis_temp > gap_temp )
		{ 	// Refresh Sensore Temperatura ogni “gap” sec
			millis_temp = millis_now;

			float tempLM35 = (5.0 * analogRead(pin_lm35) * 100.0) / 1024.0;
			// (5.0 tensione di alimentazione)
			int tempcalc = tempLM35 * 10.0;

			String str_temp = String(tempcalc, DEC);
			char char_print[3];
			str_temp.toCharArray(char_print, sizeof(char_print));

			int step = 0;
			for (c = 0; c < 3; c++){							// tre cifre in tutto	
				putchar_5x12(1 + step, 2, char_print[c]);
				step = step + 6;
			}

			plot(12, 13, 1);

			plot(19, 1, 1);
			plot(20, 1, 1);
			plot(19, 2, 1);
			plot(20, 2, 1);
		}

		/* CHECK BUTTONS, return if necessary */  
		if( change_animation() )  return;
		if( press_remote() ) return;
		luce_ambiente(fotoresistenza_stato);

	}while(1);

} // end function temperatura_time
//--------------------------------------------------------------
//#### introduzione nuove funzionalita’ (Stefano Del Bufalo)
//--------------------------------------------------------------

Notate che attualmente, visto che il partitore di cui fa parte il fotoresistore è collegato al +5V, il riferimento per l’ADC dell’ATmega328 di Arduino è impostato anch’esso a 5 volt; per aumentare la precisione, si potrebbe usare “analogReference( INTERNAL )”, che imposta AREF a 1,1 volt: così facendo, i 10 bit del convertitore porterebbero ad una risoluzione di circa 1 mV, ma in questo caso occorrerebbe ricalibrare i valori della fotoresistenza.

 

L’hardware

Per ottenere le funzioni descritte è necessaria qualche modifica hardware al circuito di controllo di Dotklok presentato dallo schema elettrico che si trova a pagina 60 del fascicolo n° 175 di Elettronica In; questo schema va modificato come mostra quello che trovate in queste pagine, ossia aggiungendo la fotoresistenza con la relativa resistenza da 1 kohm al positivo dei 5 volt, e la sonda LM35.
Nuovo schema elettrico:

o:Dotklok_schema_elettrico

Dotklok_schema_elettrico

 

A proposito di quest’ultima, va detto che in realtà, fornendo in uscita una tensione continua ed essendo alimentata dalla stessa linea a 5 V che alimenta la matrice di LED, in qualche modo il segnale di temperatura potrebbe essere affetto da lievi fluttuazioni dovute all’assorbimento dalla linea a 5 volt. Si potrebbe ovviare a questo inconveniente, pur poco rilevante, impiegando un sensore (a uscita digitale) tipo DHT11 o DHT22 collegato ad un pin digitale piuttosto che analogico, ma ciò implicherebbe la scrittura di codice per acquisire i dati dalla nuova sonda e la rimozione di quello per la lettura analogica.
Vedete un po’ voi.

Modifiche allo schema pratico:


Dotklok_Pratico

 

Il nuovo firmware, contenuto in una cartella zip, può essere scaricato qui.

Il risultato finale:

Dotclok_Finale

 

Ricordiamo che il Sig. Stefano Del Bufalo si è aggiudicato una stampante 3Drag in scatola di montaggio, complimenti ancora!

 

Il premio:

Printer3D

 

La scatola di montaggio del Dotklok è disponibile presso Futura Elettronica con display verde o rosso.