Controllare temperature e ventole pc

Salve, vorrei costruire un rheobus ed essendo solo agli inizi vorrei chiedervi alcuni consigli:

Vorrei gestire 6 ventole con le uscite pwm, leggere il segnale tachimetrico delle suddette ventole (conviene leggerle dai pin analogici o digitali?)
Leggere 6 sensori di temperatura (tipo LM35)
Selezionare il valore pwm tramite un encoder rotativo
Comandare dei relè o simili per accendere o spegnere “qualcosa” (neon, led, etc).

Per ora ho scritto la parte per leggere le temperature:

#include <LiquidCrystal.h>
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

#define LM35_TEMP0 0
int TEMP0;
#define LM35_TEMP1 1
int TEMP1;
#define LM35_TEMP2 2
int TEMP2;
#define LM35_TEMP3 3
int TEMP3;
#define LM35_TEMP4 4
int TEMP4;
#define LM35_TEMP5 5
int TEMP5;
#define FANsensor0 8
int FANs0;


void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(20, 2);
  // Print a message to the LCD.
  lcd.print("Temp1 Temp2 Temp3 Temp4 Temp5 Temp6");
}

void loop() {
  lcd.setCursor(0,1);
  float TEMP0;
  TEMP0 = (float)(5.0*analogRead(LM35_TEMP0)*100.0)/1024.0;
  lcd.print("Temp: ");
  lcd.print(TEMP0,1);
  float TEMP1;
  TEMP1 = (float)(5.0*analogRead(LM35_TEMP1)*100.0)/1024.0;
  lcd.print(" ");
  lcd.print(TEMP1,1);
  float TEMP2;
  TEMP2 = (float)(5.0*analogRead(LM35_TEMP2)*100.0)/1024.0;
  lcd.print(" ");
  lcd.print(TEMP2,1);
  float TEMP3;
  TEMP3 = (float)(5.0*analogRead(LM35_TEMP3)*100.0)/1024.0;
  lcd.print(" ");
  lcd.print(TEMP3,1);
  float TEMP4;
  TEMP4 = (float)(5.0*analogRead(LM35_TEMP4)*100.0)/1024.0;
  lcd.print(" ");
  lcd.print(TEMP4,1);
  float TEMP5;
  TEMP5 = (float)(5.0*analogRead(LM35_TEMP5)*100.0)/1024.0;
  lcd.print(" ");
  lcd.print(TEMP5,1);
  int FANs0;
  FANs0 = analogRead(FANsensor0);
  lcd.print(" RPM: ");
  lcd.print(FANs0);
  delay(1000);
 }

Quanta corrente sopporta il pin Vin? giusto per capire se posso collegarci il positivo delle ventole (ed eventualmente le bobine dei relè) o se è meglio collegarli a monte del connettore di alimenzione.
Poi ho notato che la lettura delle temperature vengono influenzate da quello che collego ai pin vicini (per es il segnale tachimetrico delle ventole)… ho letto una discussione in cui si diceva di collegare gli lm sui 3.3 o fare “magheggi” strani di cui sinceramente non ho capito nulla.

Per il controllo pwm ho visto che ci sono un sacco di possibilità con transistor, mosfet, jfet e vari… cos’è meglio usare secondo voi e perchè?
Tenete conto che con arduino passo attraverso un fotoaccoppiatore per isolare la scheda dalle ventole.

p.s. dimenticavo di dire che ho preso un arduino mega 2560

Ciao :) allora :) Non tutte le ventole possono essere controllate con transistor o mos a causa della loro circuiteria interna... quindi non possono essere controllate con PWM.... poi cosa vuoi fare con il pin Vin? .... mi è poco chiaro.... da li prelevi la corrente che metti dallo spinotto di alimentazione... non so quanta corrente possa passare ma non credo più di .5A anche perchè cè il fusibile di protezione e il suo valore non lo ricordo mai aspettiamo che qualcuno venga in aiuto :) evitando questa cosa puoi fare una "tripla" per portarti la tensionda da dopo il jack di alimentazione e prima dell'arduino così da non toccare minimamente la board... dopo di che si è possibile fare ciò che hai scritto ma è un pò complicatino :) auguri :):):)

Ciao :D

posso aiutarti sia con gli LM35 sia con il pilotaggio dei relè on off oppure pilotaggio in PWM delle ventole :)

ho giusto realizzato un'applicazione arduino che utilizza LM35 + relè -> qui: http://sites.google.com/site/circuitiarduino/home/antigelo-caldaia

il circuito di pilotaggio che ho realizzato monta un mosfet IRF520 NPN, è adatto anche a commutazioni veloci in PWM ;)

devi tenere in cosiderazione che le uscite di arduino NON possono pilotare carichi eccessivi tipo relè, devi usare dei circuiti di pilotaggio comandati con i livelli logici di arduino...

saluti kattivik76

per quanto riguarda l'alimentazione io intendevo questo: alimentatore pc 12v -> spinotto nero dell'arduino -> Vin -> positivo delle ventole oppure alimentatore pc 12v -> Arduino alimentatore pc 12v -> positivo delle ventole

le ventole che voglio pilotare sono quelle classiche da pc "serie" tipo noctua, s-flex, cooler master con 3 pin che già regolo tramite pc ed il programma speedfan... non so se la scheda madre usa il pwm o semplicemente abbassa la tensione ho giusto un IRF520 a disposizione (ho preso un Kit Workshop base con tanto di breadboard), quello che non capisco sono le resistenze che vedo mettere... non basta pin dell'arduino -> entrata optoisolatore - uscita optoisolatore -> base transistor? come faccio a sapere quali resistenze e dove?

per quanto riguarda i relè non vorrei che tenendoli eccitati per tanto tempo si rovinino le bobine, magari basta trovare dei relè bistabili (come per gli impianti di illuminazione domestica che sia per accendere le luci che per spegnerle bisogna premere il tasto)... poi c'è il solito problema di calcolare le resistenze da mettere intorno al transistor per pilotarli

Ciao,

per quanto riguarda l'alimentazione io intendevo questo: alimentatore pc 12v -> spinotto nero dell'arduino -> Vin -> positivo delle ventole oppure alimentatore pc 12v -> Arduino alimentatore pc 12v -> positivo delle ventole

forse meglio la seconda soluzione per l'alimentazione, pero' collegando direttamente i +5V del pc (cavo rosso) all'Arduino (i +5V dell'alimentatore del pc sono stabilizzati).

La sezione alimentazione dell'Arduino scalda un po' a 12 V.

Ciao, Marco.

Quindi allo spinottino nero dell'arduino porto i +5 dell'alimentatore mentre a tutto quello che devo pilotare porto i +12... l'importante è che la massa sia la stessa, giusto?

EDIT: sto smanettando con il pwm ed il sensore tachimetrico... come faccio a distinguere il pin8 del pwm dal pin A8 dell'analogico? poi, visto che presumo il segnale tachimetrico sia un'onda quadra è meglio collegarlo ad un pin analogico o ad uno digitale?

No non puoi portare allo spinotto di alimentazione solo 5V perchè il regolatore interno ha bisogno di una tensione che sia 2V in più cioè da 7V in su... fino a 12-13 non di più per evitare di farlo bollire:) visto che disponi dei +5V ti puoi collegare direttamente sulla board nel piedino 5V oppure passa i 12V dallo spinotto dell'alimentazione (quello nero :) )

si, infatti mi è venuto il dubbio quando ho alimentato arduino con i +5 e si accendeva ma non faceva nulla, mi sono ricordato di sta cosa e gli ho dato +12... in fin dei conti ci alimento solo lui ed un display, il regolatore non dovrebbe soffrire troppo

il mio problema ora è il segnale tachimetrico, da quello che ho letto in giro dovrei avere sul filo giallo 2 impulsi da 12v per ogni giro ma non riesco a capire come farlo leggere ad arduino, sopratutto senza far sballare la lettura del sensore di temperatura, ogni volta che collego il filo giallo ad un'entrata analogia la lettura della temperatura varia dai 19 ai 49° mentre normalmente ne segna 24

dopo ore di smanettamenti e letture sono riuscito a leggere il segnale tachimetrico con questo codice:

#include <LiquidCrystal.h>

int FANsensor0 = 50;   // fan tachometer connected to digital pin 50
int FANsensor1 = 52;   // fan tachometer connected to digital pin 52
unsigned long FANsignal0; // time duration between tachometer pulses
unsigned long FANsignal1; // time duration between tachometer pulses
float RPM0; // fan speed in RPM
float RPM1; // fan speed in RPM

// initialize the LCD library routine with the numbers of the interface pins
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

void setup() {
lcd.begin(20, 2); // set up the LCD's number of rows and columns:
digitalWrite(FANsensor0, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor1, HIGH);  // turn on pull-up resistor
}

void loop() {

FANsignal0 = pulseIn(FANsensor0, HIGH);
FANsignal1 = pulseIn(FANsensor1, HIGH);  

       
RPM0=(float(FANsignal0)); // in RPM
lcd.setCursor(0, 0); // Set for first line
lcd.print(int(RPM0)); // displays RPM value
lcd.print(" RPM");
RPM1=(float(FANsignal1)); // in RPM
lcd.setCursor(0, 1); // Set for first line
lcd.print(int(RPM1)); // displays RPM value
lcd.print(" RPM");
delay(1000);
}

Il mio problema ora è che ovviamente mi scrive sul display dei valori strani del tipo che il valore diminuisce all’aumentare della velocità della ventola
dovrei risolvere “giocando” con questa parte di codice: RPMx=(float(FANsignalx) formula per calcolare il giusto valore);

qualcuno c’è già passato a può comunque aiutarmi a risolvere?
grazie

p.s. mi sono ispirato a questo lavoro: http://forum.myduino.com/viewtopic.php?f=1&t=20

Quello che leggi a me pare che sia il tempo che intercorre fra un giro ed un altro, ecco perché all’aumentare della velocità quel valore diminuisce.

Si ha ragione leo tieni conto che nela ventola per misurare i giri o ci son transistor ad effetto di Hall oppure fotodiodi che appunto segnano ogni ad giro… più veloce va più l’impulso aumenta di freq…

edit:
prova con questo codice… è quello del frequenzimetro preso dal vecchio forum:

//variabili
int sigPin = 7; //signal pin
int state; //the state of the input
int oldstate;
unsigned long t; //timer
unsigned long s; //samples
unsigned long c; //count
unsigned long f; //frequency


void setup()
{
  pinMode(sigPin, INPUT);
  Serial.begin(9600);
}

void loop()
{
  c = 0;

   t = millis(); // read time at start of sampling
   for(s=0; s<10000; s++){ //take a number of samples
	state = digitalRead(sigPin); //read state
	if (state != oldstate){ //if state changes:
	   c++; //increment counter
	   oldstate = state; //and reset current state
	}

   }
   t = millis() - t; //read time at end of sampling

   c = c/2; // need to divide by 2 because counter incremented on each change - two changes per cycle

   f = 1000*c/t; //calculate frequency

  Serial.println("frequenza");
  Serial.println(f);
  delay(500);
}

ringrazie garinus:)
con questo leggi la freq e quindi i giri :slight_smile:

di seguito incollo spezzoni di codice da cui ho preso spunto, questi spezzoni si occupano di leggere il segnale tachimetrico della ventola:

int tachPin = 8;   // fan tachometer connected to digital pin 8
int sensorValue;  // variable to store the value coming from the sensor
unsigned long duration; // time duration between tachometer pulses
float rpm; // fan speed in RPM

void loop() {
duration=0;

for (int i = 0; i < sampletime; i++) { // Average out pulseIn time reading in microseconds
duration = duration+pulseIn(tachPin, HIGH);   
}
       
rpm=600000000/float(duration); // in RPM
speed=rpm/max_rpm*100; // convert to percentage
        
lcd.print(int(rpm)); // displays RPM value
}

se non ho male interpretato quello che ha scritto questo codice fa la stessa cosa di quello che mi avete proposto voi
il problema (per lo meno per quello che ho provato lavorando sul codice di Arduino Malaysia Forum) è che quando raddoppio il codice per gestire 2 ventole anzichè una soltanto rallenta tutto, la lettura al posto di farla 1 volta al secondo la fa ogni 4/5 secondi

poi aggiungo che durante le letture di vari topic mi sono imbattuto in un prouser che diceva di usare gli interrupt dato che la gestione degli lcd ed altri calcoli introduce delle latenze che falsano le letture (ed era pure piuttosto esasperato non sapendo quante volte avrebbe dovuto ancora ripeterlo :P)

purtroppo io per quanto riguarda l’hw non ho problemi (sono un sistemista junior) ma quando si tratta di lavorare sui linguaggi di programmazione non ci capisco proprio nulla… per esempio non capisco come funziona quel for e tutte le cose che ci sono dopo, insomma, mi mancano completamente le basi

Quel for lavora semplicemente facendo la somma delle lettura per un tot di volte, specificato da sampletime. Poi calcola il tempo medio ed estrapola la velocità di rotazione. Prova a postare il codice per 2 ventole per capire cos'hai scritto.

#include <LiquidCrystal.h>

int FANsensor0 = 50;   // fan tachometer connected to digital pin 50
int FANsensor1 = 52;   // fan tachometer connected to digital pin 52
unsigned long FANsignal0; // time duration between tachometer pulses
unsigned long FANsignal1; // time duration between tachometer pulses
float RPM0; // fan speed in RPM
float RPM1; // fan speed in RPM
int sampletime=40; // Number of sample to average-out sampling values

// initialize the LCD library routine with the numbers of the interface pins
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

void setup() {
lcd.begin(20, 2); // set up the LCD's number of rows and columns:
digitalWrite(FANsensor0, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor1, HIGH);  // turn on pull-up resistor
}

void loop() {

FANsignal0=0;
FANsignal1=0;

for (int i = 0; i < sampletime; i++) { // Average out pulseIn time reading in microseconds
FANsignal0 = FANsignal0+pulseIn(FANsensor0, HIGH);
}

for (int i = 0; i < sampletime; i++) { // Average out pulseIn time reading in microseconds
FANsignal1 = FANsignal1+pulseIn(FANsensor1, HIGH);
}
       
RPM0=600000000/float(FANsignal0); // in RPM
lcd.setCursor(0, 0); // Set for first line
lcd.print(int(RPM0)); // displays RPM value
lcd.print(" RPM");
RPM1=600000000/float(FANsignal1); // in RPM
lcd.setCursor(0, 1); // Set for first line
lcd.print(int(RPM1)); // displays RPM value
lcd.print(" RPM");
delay(1000);
}

tra un refresh sull’lcd e l’altra passano 4.5 secondi circa

Intanto mi accorgo che per attivare la pull-up dovresti prima dichiarare un pin come INPUT e poi scriverci HIGH.

Detto questo, fai 40 letture per ogni ventola: non so quanto impiega un PulseIn a leggere la ventolina (ci vorrede l'oscilloscopio di Astrobeed ;) ). Fatte le letture, spedisci all'LCD, che avrà i suoi tempi di risposta. Infine metti un delay(1000) che rallenta per 1 secondo l'esecuzione del codice.

Credo che ci potremmo essere ai 4 secondi da te rilevati.

leo72: Intanto mi accorgo che per attivare la pull-up dovresti prima dichiarare un pin come INPUT e poi scriverci HIGH.

non lo fa la riga: digitalWrite(FANsensor0, HIGH); // turn on pull-up resistor ?

leo72: Detto questo, fai 40 letture per ogni ventola: non so quanto impiega un PulseIn a leggere la ventolina (ci vorrede l'oscilloscopio di Astrobeed ;) ). Fatte le letture, spedisci all'LCD, che avrà i suoi tempi di risposta. Infine metti un delay(1000) che rallenta per 1 secondo l'esecuzione del codice.

Credo che ci potremmo essere ai 4 secondi da te rilevati.

il delay di 1000 l'ho tolto ed adesso il refresh è passato a 3.5 secondi

ho provato a mettere int sampletime0=10; e compensare con una ulteriore divisione per 4 RPM0=(600000000/float(FANsignal0))/4; // in RPM ed il valore mostrato dalla ventolina sembra lo stesso ma la velocità è molto aumentata, senza toccare altro è arrivata a circa mezzo secondo

ho provato a triplicare il sistema ed ora ci mette circa 2.5 secondi… ogni volto che aggiungo una ventola il tutto rallenta un sacco
non c’è un modo per parallelizzare le rilevazioni senza complicare enormemente il codice?

#include <LiquidCrystal.h>

int FANsensor0 = 50;   // fan tachometer connected to digital pin 50
int FANsensor1 = 51;   // fan tachometer connected to digital pin 52
int FANsensor2 = 52;   // fan tachometer connected to digital pin 52
unsigned long FANsignal0; // time duration between tachometer pulses
unsigned long FANsignal1; // time duration between tachometer pulses
unsigned long FANsignal2; // time duration between tachometer pulses
float RPM0; // fan speed in RPM
float RPM1; // fan speed in RPM
float RPM2; // fan speed in RPM
int sampletime0=10; // Number of sample to average-out sampling values
int sampletime1=10; // Number of sample to average-out sampling values
int sampletime2=10; // Number of sample to average-out sampling values

// initialize the LCD library routine with the numbers of the interface pins
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

void setup() {
lcd.begin(20, 2); // set up the LCD's number of rows and columns:
digitalWrite(FANsensor0, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor1, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor2, HIGH);  // turn on pull-up resistor
}

void loop() {

FANsignal0=0;
FANsignal1=0;
FANsignal2=0;

for (int i = 0; i < sampletime0; i++) { // Average out pulseIn time reading in microseconds
FANsignal0 = FANsignal0+pulseIn(FANsensor0, HIGH);
}

for (int i = 0; i < sampletime1; i++) { // Average out pulseIn time reading in microseconds
FANsignal1 = FANsignal1+pulseIn(FANsensor1, HIGH);
}

for (int i = 0; i < sampletime1; i++) { // Average out pulseIn time reading in microseconds
FANsignal2 = FANsignal2+pulseIn(FANsensor2, HIGH);
}
       
RPM0=(600000000/float(FANsignal0))/4; // in RPM
lcd.setCursor(0, 0); // Set for first line
lcd.print(int(RPM0)); // displays RPM value
lcd.print(" RPM");
RPM1=(600000000/float(FANsignal1))/4; // in RPM
lcd.setCursor(0, 1); // Set for first line
lcd.print(int(RPM1)); // displays RPM value
lcd.print(" RPM");
RPM2=(600000000/float(FANsignal2))/4; // in RPM
lcd.setCursor(10, 0); // Set for first line
lcd.print(int(RPM2)); // displays RPM value
lcd.print(" RPM");
}

ho ridotto ulteriormente il sampletime ed aumentato di conseguenza la divisione per compensare

#include <LiquidCrystal.h>

int FANsensor0 = 48;   // fan tachometer connected to digital pin 48
int FANsensor1 = 49;   // fan tachometer connected to digital pin 49
int FANsensor2 = 50;   // fan tachometer connected to digital pin 50
int FANsensor3 = 51;   // fan tachometer connected to digital pin 51
int FANsensor4 = 52;   // fan tachometer connected to digital pin 52
int FANsensor5 = 53;   // fan tachometer connected to digital pin 53
unsigned long FANsignal0; // time duration between tachometer pulses
unsigned long FANsignal1; // time duration between tachometer pulses
unsigned long FANsignal2; // time duration between tachometer pulses
unsigned long FANsignal3; // time duration between tachometer pulses
unsigned long FANsignal4; // time duration between tachometer pulses
unsigned long FANsignal5; // time duration between tachometer pulses
float RPM0; // fan speed in RPM
float RPM1; // fan speed in RPM
float RPM2; // fan speed in RPM
float RPM3; // fan speed in RPM
float RPM4; // fan speed in RPM
float RPM5; // fan speed in RPM
int sampletime0=1; // Number of sample to average-out sampling values
int sampletime1=1; // Number of sample to average-out sampling values
int sampletime2=1; // Number of sample to average-out sampling values
int sampletime3=1; // Number of sample to average-out sampling values
int sampletime4=1; // Number of sample to average-out sampling values
int sampletime5=1; // Number of sample to average-out sampling values
// initialize the LCD library routine with the numbers of the interface pins
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

void setup() {
lcd.begin(20, 2); // set up the LCD's number of rows and columns:
digitalWrite(FANsensor0, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor1, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor2, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor3, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor4, HIGH);  // turn on pull-up resistor
digitalWrite(FANsensor5, HIGH);  // turn on pull-up resistor
}

void loop() {

FANsignal0=0;
FANsignal1=0;
FANsignal2=0;
FANsignal3=0;
FANsignal4=0;
FANsignal5=0;

for (int i = 0; i < sampletime0; i++) { // Average out pulseIn time reading in microseconds
FANsignal0 = FANsignal0+pulseIn(FANsensor0, HIGH);
}

for (int i = 0; i < sampletime1; i++) { // Average out pulseIn time reading in microseconds
FANsignal1 = FANsignal1+pulseIn(FANsensor1, HIGH);
}

for (int i = 0; i < sampletime2; i++) { // Average out pulseIn time reading in microseconds
FANsignal2 = FANsignal2+pulseIn(FANsensor2, HIGH);
}

for (int i = 0; i < sampletime3; i++) { // Average out pulseIn time reading in microseconds
FANsignal3 = FANsignal3+pulseIn(FANsensor3, HIGH);
}

for (int i = 0; i < sampletime4; i++) { // Average out pulseIn time reading in microseconds
FANsignal4 = FANsignal4+pulseIn(FANsensor4, HIGH);
}

for (int i = 0; i < sampletime5; i++) { // Average out pulseIn time reading in microseconds
FANsignal5 = FANsignal5+pulseIn(FANsensor5, HIGH);
}

lcd.clear();
lcd.setCursor(0, 0); // Set for first line
lcd.print("RPM");
RPM0=(600000000/float(FANsignal0))/40; // in RPM
lcd.print(int(RPM0)); // displays RPM value
lcd.setCursor(7, 0); // Set for first line
lcd.print("RPM");
RPM1=(600000000/float(FANsignal1))/40; // in RPM
lcd.print(int(RPM1)); // displays RPM value
lcd.setCursor(14, 0); // Set for first line
lcd.print("RPM");
RPM2=(600000000/float(FANsignal2))/40; // in RPM
lcd.print(int(RPM2)); // displays RPM value
lcd.setCursor(0, 1); // Set for first line
lcd.print("RPM");
RPM3=(600000000/float(FANsignal3))/40; // in RPM
lcd.print(int(RPM3)); // displays RPM value
lcd.setCursor(7, 1); // Set for first line
lcd.print("RPM");
RPM4=(600000000/float(FANsignal4))/40; // in RPM
lcd.print(int(RPM4)); // displays RPM value
lcd.setCursor(14, 1); // Set for first line
lcd.print("RPM");
RPM5=(600000000/float(FANsignal5))/40; // in RPM
lcd.print(int(RPM5)); // displays RPM value
}

con questo codice tra un refresh e l’altro impiega circa un secondo, spero che aggiungendo piano piano il resto delle funzioni che voglio avere non rallenti troppo

se ovviamente avete consigli su come migliorare la situazione non mi dispiace affatto :stuck_out_tongue:

sto modificando lo sketch usando la funzione millis() come spiegato in questa guida: Vittorio Zuccalà: Multitasking Arduino: millis() -- PARTE 1 e sembra funzionare tutto correttamente

#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(32, 30, 28, 26, 24, 22);

#define LM35_TEMP0 0 // Pin analogico 0
int TEMP0; // valore di tensione letto dal pin OUT del sensore
int letturaTEMP0;

int FANsensor0 = 48;   // fan tachometer connected to digital pin 48
int letturaFANsensor0;
unsigned long FANsignal0; // time duration between tachometer pulses
float RPM0; // fan speed in RPM

int FANsensor1 = 49;   // fan tachometer connected to digital pin 48
int letturaFANsensor1;
unsigned long FANsignal1; // time duration between tachometer pulses
float RPM1; // fan speed in RPM

unsigned long int time;
int sampletime=1; // Number of sample to average-out sampling values

void setup() {
  time=millis();
  lcd.begin(20, 2);
  digitalWrite(FANsensor0, HIGH);  // turn on pull-up resistor
  digitalWrite(FANsensor1, HIGH);  // turn on pull-up resistor
}

void loop() {
  time=millis();
  
  lcd.setCursor(0,0);
  if(time>letturaFANsensor0+1){
  lcd.print("RPM:");
  FANsignal0=0;
  for (int i = 0; i < sampletime; i++) { // Average out pulseIn time reading in microseconds
  FANsignal0 = FANsignal0+pulseIn(FANsensor0, HIGH);
  }
  RPM0=(600000000/float(FANsignal0))/40; // in RPM
  lcd.print(int(RPM0)); // displays RPM value
  }
  
  lcd.setCursor(10,0);
  if(time>letturaFANsensor1+1){
  lcd.print("RPM:");
  FANsignal1=0;
  for (int i = 0; i < sampletime; i++) { // Average out pulseIn time reading in microseconds
  FANsignal1 = FANsignal1+pulseIn(FANsensor1, HIGH);
  }
  RPM1=(600000000/float(FANsignal1))/40; // in RPM
  lcd.print(int(RPM1)); // displays RPM value
  } 
  
  lcd.setCursor(0,1);
  
  if(time>letturaTEMP0+1){
  lcd.print("TEMP:");
  float TEMP0;
  TEMP0 = (float)(5.0*analogRead(LM35_TEMP0)*100.0)/1024.0;
  lcd.print(TEMP0,1);
  }
  delay(1000);
}

in questo sketch uso solo due ventole ed un sensore di temperatura perchè sono a corto di componenti

a tal proposito, visto che devo pilotare 6 ventole e 6 sensori di temperatura uno schermo 20x2 non basta di sicuro e pensavo di usare uno schermo tipo questo:
http://tigal.eu/product/1539
e dividere le schermate in 6 selezionabili con l’encoder rotativo

qualcuno di voi hai provato questi tipi di schermi? sono validi? facili da usare? consigli?