Termolino: come costruire uno strumento con interfaccia analogica

Termolino è un termometro che usa componenti digitali come Arduino e un sensore di temperatura della Dallas, il DS18B20, ma rappresenta la temperatura su un quadrante analogico, composto da una scala graduata e una lancetta. E’ un esempio di come si possano costruire interfacce analogiche usando un motore servo e un quadrante tagliato con una macchina Laser Cut. Si abbandona il classico display a cifre per una più elegante visualizzazione, aperta a svariate soluzioni di design e con materiali diversi. Nei limiti di precisione del servo, si possono costruire quadranti anche per misurare altre grandezze, il progetto fornisce indicazioni di tipo generale per realizzare altri strumenti, come ad esempio un barometro.

Cos’è un’interfaccia analogica?

Ne vediamo tante tutti i giorni e più volte al giorno, per esempio l’orologio della cucina, il contagiri e il tachimetro dell’auto o il termometro del forno. In breve, anziché rappresentare un numero con delle cifre su un display LCD o LED, lo rappresentiamo attraverso la posizione di una lancetta su una scala graduata. La gente è così abituata a questo tipo di rappresentazione che quando, un po’ di anni fa, arrivarono sul mercato i primi orologi digitali, passarono subito di moda quelli con il piccolo display numerico e ritornarono quelli a quadrante con le lancette, pur rimanendo digitale il circuito che ci stava dietro.

L’ergonomia è una scienza che studia i migliori modi per far interagire l’uomo con la macchina. Sono proprio questi studiosi che hanno suggerito ai costruttori di aerei di mettere in cabina di pilotaggio strumenti ad ago al posto di quelli digitali. Infatti risulterebbe più immediato per un pilota, che deve tenere sott’occhio molti numeri relativi alla navigazione e allo stato del suo aereo, giudicare la posizione di una lancetta piuttosto che il valore di un numero. Quindi anche se tutta l’elettronica di un aereo è digitale, le interfacce sono rimaste analogiche.

Tremolino2

Anche nel campo della strumentazione con cui abbiamo a che fare tutti i giorni, dagli orologi ai termometri o i barometri delle stazioncine meteo casalinghe, la rappresentazione della misura con una lancetta e una scala graduata, può avere la sua utilità o magari solo un certo fascino vintage. Non sono forse belli gli strumenti a lancetta, come quelli delle navi d’epoca?

Queste considerazioni mi hanno spinto a costruire Termolino che, come caratteristica principale, possiede proprio la rappresentazione della temperatura su una scala graduata.

La temperatura è misurata da un sensore digitale tutto integrato in un chip, il DS18B20. Questo sensore è abbastanza popolare, tanto che è stata prodotta una libreria per Arduino che ne facilita l’interrogazione. La temperatura letta dal sensore è trasmessa ad Arduino già come °C, con una precisione di qualche decimo di grado.

La lancetta sulla scala graduata è mossa da un motorino “servo” di quelli usati per i telecomandi, che fanno ruotare l’asse di tanti gradi quanto vogliamo. Sono molto usati dai maker per tante applicazioni e costano anche poco, se non serve gran potenza o precisione. Anche per il servo è disponibile una libreria che facilita il suo funzionamento.

Termolino3Nel mondo dell’elettronica le più diffuse interfacce analogiche sono quelle che usano i galvanometri, quegli strumenti ad ago mossi da una bobina immersa in un campo magnetico. Quelli della mia età li conoscono bene (io sono della generazione dei tester ICE che erano fatti così). Il galvanometro però, pur avendo un fascino “vintage”, non consente molta varietà di forme. Termolino ha invece il vantaggio che il quadrante e la lancetta possono essere disegnati secondo il proprio gusto e costruiti con materiali diversi, grazie anche alla disponibilità di una macchina Laser Cut.

 

 

Il disegno del quadrante

Lancetta

Quadrante

 

Il disegno delle varie parti di Termolino è stato fatto con il software Inkscape, liberamente scaricabile dal sito https://inkscape.org/it/ . Il quadrante, visibile qui sopra, ha il contorno rosso dove il laser deve tagliare e quello azzurro dove invece deve fare l’incisione (engrave). I caratteri sono scritti in modo speculare al fine di avere la parte incisa nella parte posteriore di una lastra trasparente di metacrilato. Questo accorgimento migliora molto l’aspetto generale. Nel caso invece in cui si volesse usare il legno o altri materiali opachi, bisognerà ovviamente invertire il disegno. La lancetta può essere tagliata da un pezzo di metacrilato di altro colore, per farla risaltare di più. Per Termolino è stato usato un pezzo di metacrilato rosa fluo da 3 mm.

La scatola

Scatola

 

La scatola di Termolino ha lo scopo di contenere Arduino e nello stesso tempo fare da supporto al quadrante. Risulta aperta da un lato per permettere il passaggio del cavetto di alimentazione di Arduino o il cavo USB e il cavo che collega il sensore DS18B20. Anch’essa è ricavata tagliando al Laser lo stesso materiale del quadrante.

Qualche dettaglio tecnico su Termolino

 

Termolino4

Essendo la lancetta di Termolino mossa da un servo, la precisione con cui è in grado di segnare le gradazioni, è legata alla precisione con cui il servo assume la posizione imposta dal software. Il servo che ho usato, ad esempio, può ruotare il suo asse da 0 a 180° con passo 1°. Questo solo in teoria, perché in realtà non è così preciso. Può capitare infatti che a parità di angolo voluto, la posizione del suo perno differisca anche di 1 o 2 gradi. Pertanto, nella scelta della scala graduata, dobbiamo tener conto di questa imprecisione. Nel caso di Termolino è stata incisa una scala con le tacche distanziate di 4° (angolari, non di temperatura!) e ogni tacca rappresenta 1° C. In questo modo anche un’imprecisione di uno o due gradi del servo non fa commettere errori alla lettura della temperatura sulla scala. Tenendo poi conto che il servo nelle sue posizioni estreme, 0° e 180°, tende a “ronzare”, ho deciso di limitare la sua escursione da 10° a 170°. Così facendo ho a disposizione un numero di tacche pari a 41, ( 1 + (170-10)/4 = 41 ). Un altro parametro da tener presente è la distanza tra due tacche. Infatti, affinché la nostra interfaccia sia leggibile, anche ad una certa distanza, specialmente con lancette “grassocce” è bene che lo spessore delle tacche sia di qualche millimetro e la loro distanza di circa 5 mm come nel caso di Termolino. La distanza minima e i gradi angolari tra due tacche determinano il raggio della scala (R = 5 / (3,14 * 4 / 180) = 72 mm) e la lunghezza della lancetta. Questo raggio dovrà essere aumentato di circa un centimetro o meno per avere il raggio del quadrante. Con un quadrante di 41 tacche, così fatto, è possibile rappresentare diverse grandezze, non solo la temperatura. Nel caso di Termolino, ho scelto un intervallo che va da -5°C a 35°C, ma si potrebbe scegliere anche un intervallo diverso. Ad esempio si potrebbe voler apprezzare il mezzo grado centigrado, cosa che il sensore DS18B20 usato consente tranquillamente, in questo caso l’intervallo potrebbe andare, ad esempio, da 10°C a 30°C con ogni tacca del valore di 0,5°C (è meglio usare una tacca lunga per i gradi interi e più corta per i mezzi).

Adesso veniamo alla conversione dalla grandezza temperatura, data dal sensore in °C, in gradi di rotazione dell’asse. Possiamo adottare due strategie: quella più semplice, che consiste nel fidarsi ciecamente della precisione con cui è stato tarato il servo, oppure un metodo più complesso che necessita una ri-calibrazione del servo direttamente sul nostro quadrante. Il primo metodo associa alla temperatura di -5°C l’angolo di 10°, a quella di -4°C l’angolo 10 + 4° e così via. In pratica:

angolo = 10 + 4 * (T + 5) dove T è la temperatura in °C

Calcolato l’angolo si chiama la funzione write(angolo) della libreria Servo.h

Il secondo metodo, quello che poi ho usato per Termolino, usa una funzione della stessa libreria Servo.h che si chiama writeMicroseconds(uS)dove uS è un certo numero di microsecondi. Questa funzione agisce direttamente sui circuiti elettronici del servo e consente di comandare la rotazione dell’asse con maggior precisione, infatti in molti servo, come quello che ho usato, si ha una rotazione di 180 gradi con un numero di microsecondi che va da circa 500 a circa 2300. Purtroppo in ogni servo questo intervallo cambia sensibilmente e quindi non esiste una formula generale per passare dai microsecondi ai gradi, occorre eseguire una taratura per ogni servo. La taratura si effettua con un semplice sketch dove si chiama la funzione writeMicroseconds(uS) per un numero di microsecondi voluto (magari scritto attraverso l’interfaccia seriale di Arduino) e si prende nota della posizione della lancetta, aggiustando il numero di uS in modo che questa coincida con una tacca. In questo modo è possibile per tentativi trovare il numero di microsecondi giusto per far ruotare la lancetta esattamente su una delle tacche. Si ripete questa operazione per un certo numero di tacche, io ne ho tarate 9. Le coppie di valori °C/microsecondi si riportano poi su di un grafico, in questo caso è utile usare un foglio elettronico come excel. Lo stesso foglio elettronico permette di far passare una curva interpolatrice dei dati e di visualizzare la formula della curva assieme al parametro R2 che, se prossimo a 1, ci garantisce una buona approssimazione analitica dei nostri dati sperimentali. Nel caso di Termolino, ho trovato un polinomio di secondo grado, dove la variabile indipendente (x) è la temperatura e quella dipendente (y) è il numero di microsecondi. Il polinomio viene poi inserito nello sketch definitivo.

Schema elettrico di Termolino

Lo schema dei collegamenti in Termolino è abbastanza semplice. Il sensore ha tre fili, da collegare all’alimentazione 5V, al GND e ad un ingresso digitale di Arduino (D10 nel nostro caso). Tra il terminale 5 V e quello del segnale, va collegata una resistenza di pull-up da 4,7 K.

Il servo ha 3 fili anch’esso, alimentazione 5V, GND e segnale (D9 nel nostro caso).

Termolino5

Software

Sketch per il funzionamento di Termolino

Lo sketch di Termolino è stato ricavato partendo da sketch di esempio per il sensore DS18B20 e per il servo.

Ho inserito diversi “print” per poter monitorare su PC il funzionamento dello sketch, in fase di collaudo.

 

// include the servo library

#include <Servo.h>

#include <DallasTemperature.h>

#include <OneWire.h>

#define ONE_WIRE_BUS 10

#define TEMPERATURE_PRECISION 12

 

Servo myServo; // create a servo object

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

DeviceAddress tempDeviceAddress; // We'll use this variable to store a found device address

int angle = 0;   // variable to hold the angle for the servo motor

float x = 0;

int numberOfDevices=0;

int ij=0;

float tempo = 0;

//////////////////////////////////////////////////////////////////

void setup() {

myServo.attach(9); // attaches the servo on pin 9 to the servo object

Serial.begin(9600); // open a serial connection to your computer

// Start up the library I2C

sensors.begin();

numberOfDevices = sensors.getDeviceCount();

Serial.print("Locating devices...");

Serial.print("Found ");

Serial.print(numberOfDevices, DEC);

Serial.println(" devices.");

// report parasite power requirements

Serial.print("Parasite power is: ");

if (sensors.isParasitePowerMode()) Serial.println("ON");

else Serial.println("OFF");

// Loop through each device, print out address

for( ij = 0; ij < numberOfDevices; ij++)

{

// Search the wire for address

// tempDeviceAddress contiene 8 byte

if(sensors.getAddress(tempDeviceAddress, ij))

{

Serial.print("Found device ");

Serial.print(ij, DEC);

Serial.print(" with address: ");

printAddress(tempDeviceAddress);

Serial.println();

// set resolution

Serial.print("Setting resolution to ");

Serial.println(TEMPERATURE_PRECISION, DEC);

// (Each Dallas/Maxim device is capable of several different resolutions)

sensors.setResolution(tempDeviceAddress, TEMPERATURE_PRECISION);

Serial.print("Resolution actually set to: ");

Serial.print(sensors.getResolution(tempDeviceAddress), DEC);

Serial.println();

}

else{

Serial.print("Found ghost device at ");

Serial.print(ij, DEC);

Serial.print(" but could not detect address. Check power and cabling");

Serial.println();

}

}

}

 

//////////////////////////////////////////////////////////////////////////////

void loop() {

sensors.requestTemperatures(); // Send the command to get temperatures

x = sensors.getTempC(tempDeviceAddress);

// converti la temperatura in un numero di microsecondi

// secondo una curva di taratura ottenuta empiricamente registrando

// i tempi in microsec che corrispondono alle temperature sul quadrnate

tempo = 0.1578*pow(x,2) + 35.95*x + 780.05;

Serial.print(x); Serial.print(" "); Serial.println(tempo);

int intempo = nearint(tempo); // arrotonda ll'intero più vicino

myServo.writeMicroseconds(intempo);

delay(1000);

}

 

Schede dell'IDE con le funzioni nearint e printAddress 

 

int nearint(float fangle) {

// ritorna l’intero più vicino a “fangle”

int h;

// Serial.println(f);

if(fangle >= 0) {

h = int(fangle+0.5);

//   Serial.println(h);

}

if(fangle < 0){

h = int(fangle-0.5);

//   Serial.println(h);

}

return h;

}

 

void printAddress(DeviceAddress deviceAddress)

// stampa su interfaccia seriale l’indirizzo del sensore DS18B20

{

for (uint8_t ii = 0; ii < 8; ii++)

{

if (deviceAddress[ii] < 16) Serial.print("0");

Serial.print(deviceAddress[ii], HEX);

}

}

Paolo Bonelli

(Fisico, Maker e divulgatore scientifico)

Scarica subito una copia gratis
Tags:

Scrivi un commento

Seguici anche sul tuo Social Network preferito!

Send this to a friend