Strano comportamento Arduino UNO e dubbi su sensore reed

Ciao a tutti, non so se vi ricordate di me, avevo in progetto di costruire un frigo pwm per medicinali.
Progetto che devo terminare oltretutto.

Ma sono tornato qui dopo quasi un'anno per un problema diverso ora.

Ho la necessità di rilevare gli RPM di un albero motore di un macchinario e in base ad essa pilotare l'accensione e l'arresto di un relè.
Ho realizzato un banalissimo circuito di prova composto da un sensore reed, un magnete sulla pala di una ventola 12v azionata da un'alimentatore, un led (con resistore da 1KOhm) che simula il relè e un'altro led che segnala la chiusura del reed ad ogni giro della ventola (che poi sarà l'albero cardanico)

Ho provato con questo codice, non scritto da me ma solo adattato:

// read RPM

volatile int rpmcount = 0;//see http://arduino.cc/en/Reference/Volatile
int rpm = 0;
unsigned long lastmillis = 0;
int attuatore = 5; //pin del relè attuatore

void setup(){
  pinMode (attuatore, OUTPUT);
  Serial.begin(9600);
  attachInterrupt(0, rpm_fan, FALLING);//interrupt cero (0) is on pin two(2).
}

void loop(){
  if (millis() - lastmillis == 1000){  /*Uptade every one second, this will be equal to reading frecuency (Hz).*/

    detachInterrupt(0);    //Disable interrupt when calculating

    rpm = rpmcount * 60;  /* Convert frecuency to RPM, note: this works for one interruption per full rotation. For two interrups per full rotation use rpmcount * 30.*/

    Serial.print("RPM =\t"); //print the word "RPM" and tab.
    Serial.print(rpm); // print the rpm value.
    Serial.print("\t Hz=\t"); //print the word "Hz".
    Serial.println(rpmcount); /*print revolutions per second or Hz. And print new line or enter.*/

    rpmcount = 0; // Restart the RPM counter
    lastmillis = millis(); // Uptade lasmillis
    attachInterrupt(0, rpm_fan, FALLING); //enable interrupt
  }
  if (rpm < 25) { // legge se la velocità dell'albero è bassa
    digitalWrite(attuatore, HIGH);  //eccita relè attuatore
  } 
  if (rpm > 30) { // legge se la velocità dell'albero è sufficente
    digitalWrite(attuatore, LOW);
  } //diseccita relè attuatore
}

void rpm_fan(){ /* this code will be executed every time the interrupt 0 (pin2) gets low.*/
  rpmcount++;
}

Il problema è che ieri sera bene o male funzionava o sembrava funzionare ma erano le 3 di notte non ero molto fresco... Ho avuto anche la malaugurata idea di provare a montare un potenziometro e quando o acceso Arduino ha quasi fumato il potenziometro stesso, non so se la board abbia patito... coi programmi come blink classici funziona Però intanto ogni tanto si blocca e per resettarlo devo staccare alimentazione, ogni tanto interrompe la scrittura via seriale (serial monitor) insomma fa cose strane.
Tornando al discorso, Ora non funziona più lo sketch mostrato pocanzi cioè ignora i cicli dell'interruttore reed quasi del tutto addirittura se la ventola col magnete non gira ma l'alimentatore 12 v è acceso il serial monitor legge degli rpm che salgono e poi scendono per i fatti loro, solo se tolgo il filo del pin di lettura smette di leggere RPM "fantasma"

Cosa sta succedendo? Avete dei sospetti? sto dando di matto.

Premetto che sto usando per la prima volta il nuovo IDE su Windows 8 32bit per gli sketch.

magari non è il tuo caso, ma un reed oltre un certo numero di giri non riesce piu' a commutare.
per rilevare il numero di giri forse è meglio usare un sensore di hall ed un piccolo magnetino.
oppure un tx ed un rx ad infrarossi che lavorano per riflessione.
prova ad usare un cavetto schermato, per i fili che dal reed vanno all'arduino, così eviti che vengano pescati disturbi.

per le cose strane, eventualmente prova a sostituire l'atmega con uno vergine, ci carichi il bootloader e lo sketch e magari risolvi (spesa intorno ai 4 euro)
ciao

Grazie! Ho pensato agli IR solo che il macchinario lavora nella polvere, sporco e segatura, gli IR smetterebbero presto di comunicare, il sensore Hall non ho ben capito cosa sia, cioè è come un reed ma elettronico? Comunque il reed è solo per test figurati che l'ho recuperato da una bicicletta rotta.

Poco prima che rispondessi di usare un cavo schermato sai che ho fatto? Ho messo un resistore tra segnale del reed e massa pare andare meglio anche se ha dei picchi ancora, non pensavo raccogliessero spurie così forti da falsare la conta dei giri. I sensori Hall sono meno soggetti a questo problema?

Una cosa strana, mi legge 3000 giri quando ne farà si e no 1000... codice sbagliato?

purtroppo sul codice, non sono in grado di aiutarti, faccio anch'io come te copio in giro spudoratamente.

per il sensore di hall, si presenta come un piccolo transistor con tre piedini, va alimentato, e dal terzo piedino prelevi gli impulsi.
cerca in rete, dovresti trovare di tutto e di piu' compresa la pidinatura, è molto diffuso ad es tra gli aereomodellisti.
devi sempre usare il magnetino.
della polvere se ne frega.
aggiungo anche che il reed essendo un contatto meccanico alla chiusura fa dei rimbalzi che a noi passano inosservati ma l'elettronica li sente.
mi spiego meglio, quando gli passa davanti il magnetino, fa diversi impulsi in chiusura che sfalsano la lettura.
so che si puo' evitare il fenomeno agendo sul software, ma non so come si fa.
ciao

Grazie. Purtroppo senza gli sketch pronti da cercare di capire è quasi impossibile imparare da zero ad usare arduino sarò uno zuccone ma è l'unica via che riesco a usare.

L'atmega l'ho già ordinato con 2 condensatori qualche resistenza un regolatore di tensione e tutto l'occorrente per metterlo in stand alone. Proverò a ricaricare il bootloader appena arriva tutto.

vedrai che prima o dopo, se ci sono arrivati gli altri ci arriveremo anche noi

Per quanto riguarda la velocita' di commutazione, devi considerare anche la posizione del sensore e del magnetino ... il problema principale e' la velocita' angolare (o per essere piu esatti, la velocita' periferica), non il numero di giri ... se ad esempio metti il magnetino ad un'estremita' della pala, smettera' di funzionare molto prima di quanto farebbe se lo mettessi vicino all'albero, perche' la velocita' periferica dell'estremita' della pala e' piu alta di quella dell'albero ...

Cerco di farti un'esempio al volo ... pensa alla ruota di una bici, con attaccato uno di quei contagiri che hanno il magnete ed il reed ... immagina di avere due di questi magneti, uno posto a 50cm dall'asse ed uno posto a 10cm dall'asse ... poniamo che la tua ruota faccia 10 RPM, il magnete posto a 10cm dall'asse si muove con una velocita' periferica di circa 10,46 cm/s, mentre quello posto a 50cm si muove a circa 52,33 cm/s ... arrotondiamo e andiamo a spanne :P, se il campo di lettura del sensore e' di 1 cm, vedi che il magnete a 10 cm stara' nel campo di lettura per circa 1/10 di secondo (chiudendo quindi il contatto per circa 100ms), mentre quello a 50cm ci stara' per circa 1/50 di secondo (chiudendolo per circa 20ms) ... se la velocita' di rotazione aumenta, ovviamente, anche le velocita' angolari e periferiche dei due punti aumentano in proporzione ... a 100RPM, il magnete piu vicino all'asse chiude il contatto per circa 10ms, quello piu lontano per circa 2 ... e cosi via ...

Ovviamente, essendo il contatto un dispositivo fisico con una sua inerzia, oltre una certa velocita' il magnete non riuscira' piu a farlo chiudere ...

Quindi se devi mettere un magnete o un sensore per rilevare la velocita' di rotazione di qualcosa che gira veloce, e' sempre meglio che lo posizioni il piu possibile vicino all'asse di rotazione, anziche' all'estremita' di una pala o sulla circonferenza di una ruota ...

Inoltre, hai messo vero la resistenza di pulldown sull'ingresso ? :wink: ... e possibilmente anche un condensatorino, magari solo da 1n ? (per i rimbalzi del contatto del reed, anche se di solito sono pochissimi, potrebbero esserci ... se usi un sensore di Hall, il condensatore non serve)

Su Windows 8 e 8.1 puoi usare le versioni 1.0.5r2 o 1.5.5r2 che hanno i nuovi driver aggiornati e certificati.
Riguardo al codice ho fatto qualche piccolo cambiamento.
Vedi se cosi va meglio.

// read RPM
volatile unsigned int rpmcount = 0;//see http://arduino.cc/en/Reference/Volatile
unsigned int rpm = 0;
unsigned long lastmillis = 0;
const int attuatore = 5; //pin del relè attuatore
const int sensor = 2; //pin del sensore reed

void setup()
{
	pinMode (attuatore, OUTPUT);
	pinMode (sensor, INPUT);
	Serial.begin(9600);
	attachInterrupt(0, rpm_fan, FALLING);//interrupt cero (0) is on pin two(2).
}

void loop()
{
	if (millis() - lastmillis >= 1000)   /*Uptade every one second, this will be equal to reading frecuency (Hz).*/
	{
		detachInterrupt(0);    //Disable interrupt when calculating
		rpm = rpmcount * 60;  /* Convert frecuency to RPM, note: this works for one interruption per full rotation. For two interrups per full rotation use rpmcount * 30.*/

		Serial.print("RPM =\t"); //print the word "RPM" and tab.
		Serial.print(rpm); // print the rpm value.
		Serial.print("\t Hz=\t"); //print the word "Hz".
		Serial.println(rpmcount); /*print revolutions per second or Hz. And print new line or enter.*/

		rpmcount = 0; // Restart the RPM counter
		lastmillis = millis(); // Uptade lasmillis
		attachInterrupt(0, rpm_fan, FALLING); //enable interrupt
	}

	if (rpm < 25)   // legge se la velocità dell'albero è bassa
	{
		digitalWrite(attuatore, HIGH);  //eccita relè attuatore
	}
	else if (rpm > 30)   // legge se la velocità dell'albero è sufficente
	{
		digitalWrite(attuatore, LOW);
	} //diseccita relè attuatore

}  // End Loop

void rpm_fan()  /* this code will be executed every time the interrupt 0 (pin2) gets low.*/
{
	rpmcount++;
}

Etemenanki
Come non ricordare le tue risposte sempre così complete! grazie!

Ho capito perfettamente il discorso dei metri-secondo e del tempo di chiusura del reed, Ho spostato il magnete direttamente al centro della ventola, praticamente sulla circonferenza esterna del mozzo che misura circa 3 cm.

Non ho messo resistenze all'entrata del sensore reed, mi spiegheresti che funzione ha e come calcolarla? il sensore si comporta in egual modo sia alimentato a 5 vdc che a 3,3 vdc. La resistenza l'ho messa tra uscita del reed e massa da 1 K ed in parallelo con un'altra resistenza da 1K che porta il segnale a un diodo led il quale scarica la tensione a massa.
Il condensatore non ce l'ho da 1 nano farad, aiuterebbe molto a stabilizzare la lettura?

Resta il fatto strano che con la ventola che a occhio farà meno di 1000 RPM il software restituisce un valore instabile a 4000 RPM


PaoloP

Grazie mille, ho provato ad aggiungere quelle variabili ma apparentemente le letture sono invariate qui sotto vi mostro la lettura ricevuta sul monitor seriale quando a occhio la ventola farà si e no 900 RPM.

RPM =	4020	 Hz=	67
RPM =	4200	 Hz=	70
RPM =	4140	 Hz=	69
RPM =	4140	 Hz=	69
RPM =	4200	 Hz=	70
RPM =	4620	 Hz=	77
RPM =	4020	 Hz=	67
RPM =	4080	 Hz=	68
RPM =	4140	 Hz=	69
RPM =	4140	 Hz=	69
RPM =	4080	 Hz=	68
RPM =	4080	 Hz=	68
RPM =	4200	 Hz=	70
RPM =	4320	 Hz=	72
RPM =	4260	 Hz=	71
RPM =	4200	 Hz=	70
RPM =	4260	 Hz=	71
RPM =	4260	 Hz=	71
RPM =	4260	 Hz=	71
RPM =	4200	 Hz=	70
RPM =	4140	 Hz=	69
RPM =	4320	 Hz=	72
RPM =	4200	 Hz=	70
RPM =	4080	 Hz=	68
RPM =	4200	 Hz=	70
RPM =	4140	 Hz=	69
RPM =	4140	 Hz=	69
RPM =	4140	 Hz=	69
RPM =	3960	 Hz=	66
RPM =	4260	 Hz=	71
RPM =	4200	 Hz=	70
RPM =	4260	 Hz=	71
RPM =	4200	 Hz=	70
RPM =	4080	 Hz=	68
RPM =	4140	 Hz=	69
RPM =	4260	 Hz=	71
RPM =	4140	 Hz=	69
RPM =	4320	 Hz=	72
RPM =	4260	 Hz=	71
RPM =	4140	 Hz=	69
RPM =	4080	 Hz=	68
RPM =	4200	 Hz=	70
RPM =	4020	 Hz=	67
RPM =	3840	 Hz=	64
RPM =	4020	 Hz=	67
RPM =	3840	 Hz=	64
RPM =	3840	 Hz=	64
RPM =	3840	 Hz=	64
RPM =	3840	 Hz=	64
RPM =	3840	 Hz=	64
RPM =	4320	 Hz=	72
RPM =	3900	 Hz=	65
RPM =	3900	 Hz=	65
RPM =	3840	 Hz=	64
RPM =	3840	 Hz=	64
RPM =	4200	 Hz=	70
RPM =	3900	 Hz=	65
RPM =	3840	 Hz=	64
RPM =	3780	 Hz=	63
RPM =	4260	 Hz=	71
RPM =	3900	 Hz=	65
RPM =	3840	 Hz=	64
RPM =	4260	 Hz=	71
RPM =	4080	 Hz=	68
RPM =	3900	 Hz=	65
RPM =	2520	 Hz=	42
RPM =	2400	 Hz=	40
RPM =	540	 Hz=	9
RPM =	0	 Hz=	0
RPM =	0	 Hz=	0
RPM =	0	 Hz=	0

Il reed non va "alimentato", e' semplicemente un contatto magnetico, un'interruttore che si chiude quando il campo magnetico fa attrarre le due lamelle ... consideralo come se fosse un pulsante, solo che per chiuderlo, invece di premerlo, gli avvicini il magnete.

Detto questo, c'e' una precisazione da fare sui reed ... se usi un magnete con 2 poli, lungo piu o meno come il reed, chiude quando lo avvicini all'ampollina di lato, se invece usi un solo polo del magnete (ad esempio perche' hai il magnete incollato con uno dei poli, quindi ti resta libero solo quello opposto), e' meglio usarlo avvicinando una delle estremita', anziche' il centro del contatto ... questo perche' se metti il polo del magnete al centro del contatto, molte volte non si chiude correttamente (il campo magnetico e' simmetrico ed ha la stessa polarita' nelle due lamine, che quindi invece di attrarsi si respingono) ... quindi se usi il magnete con un polo solo verso il reed, tieni il contatto spostato in modo che il magnete passi piu su una estremita', non al centro, altrimenti potrebbe dare falsi azionamenti o chiusure incostanti e casuali.

Per il condensatore, non e' indispensabile, serve solo a ridurre i rimbalzi, ma nel caso dei contatti reed i rimbalzi sono abbastanza infrequenti, di solito ... inoltre un valore troppo elevato ti "cancellerebbe" anche gli impulsi buoni, se fossero troppo veloci ... puoi provare in questo modo, tanto per fare una prova:

un capo dell'ampollina reed al positivo (+5V di Arduino), dall'altro capo dell'ampollina, con una resistenza di basso valore (da 22 a 100 ohm) al pin di ingresso, dal pin di ingresso a massa una resistenza di pulldown da 10K, con in parallelo un condensatore da 1nF, o anche meno ... (ovviamente usando una resistenza di pulldown non bisogna abilitare il pullup interno dell'ingresso)

Non riesco mai a utilizzare i termini appropriati! :disappointed_relieved:
Non volevo dire alimentare il reed ma non sapevo come dire che "gli mando corrente a 5 o 3,3 volt" grazie della correzione cercherò di tenerlo a mente, ho una memoria di un malato di Alzheimer! :disappointed_relieved:

Interessantissimo ciò che hai detto sui reed! purtroppo perrò non ho la possibilità di vedere l'ampollina è incapsulata in un cilindretto plastico a tenuta stagna (derivazione computer per biciclette) per testare il suo funzionamento (a bassi giri) posso usare un normale multimetro impostato per la lettura delle resistenze / diodi?

Per il collegamento del segnale tra reed e pin di "rilevazione impulsi" della board, mi consigli una resistenza (massimo 100 Ohm) Quale funzione svolge? attenua le spurie in RF raccolte dal filo?

Poi il pulldown tra massa e segnale con resistenza da 10K e condensatore (che non ho mannaggia, ad avere un negozio fisico dal quale comprare!) non riesco a dare un senso logico a questo, non che non lo abbia non fraintendere è che proprio non ci arrivo.

In ultimo, Ho letto parecchio del pullup interno di Arduino ma non so ne cosa sia ne a cosa serva e indovina un po' nemmeno come si attivi e disattivi :roll_eyes: ci sono articoli a riguardo?

Grassssie! :sweat_smile:

Goretto:
... per testare il suo funzionamento (a bassi giri) posso usare un normale multimetro impostato per la lettura delle resistenze / diodi?

Si, anche se tutto quello che puoi testare e' se funziona o no, se avvicinando la calamita chiude, allora e' ok (cosi puoi anche vedere come si comporta tenendo il magnete in diverse posizioni :wink: )

la resistenza serve semplicemente per evitare picchi di corrente sul reed quando chiudi il circuito (perche' c'e' un condensatore), ma con quel valore di condensatore e' praticamente inutile, puoi eliminarla ...

Il pulldown serve a mantenere l'ingresso ad uno stato fisso (in questo caso massa) finche' non ci colleghi un segnale ... senza un pulldown (o un pullup, dipende da come si usa l'ingresso) il pin resterebbe "volante" con il reed aperto, ed essendo ad alta impedenza il filo farebbe da antenna captando tutti i disturbi e creandoti false letture ...

Il condensatore invece serve per "tagliare" i disturbi da rimbalzo e gli eventuali disturbi RF raccolti dal circuito ... se fosse un pulsante fisico sarebbe sempre meglio metterlo, essendo un reed, puoi provare anche senza ...

Il pullup interno e' un'opzione che si puo attivare quando definisci i pin ... qui usando un pulldown, non ti serve, ma se ad esempio dovessi usare il circuito con i pullup e non avessi spazio per metterci le resistenze esterne, definendo un pin con "pinMode(numeropin, INPUT_PULLUP)" anziche "pinMode(numeropin, INPUT)", il micro attiva una resistenza interna di pullup da 20K su quel pin, come se ce l'avesi collegata esternamente, ma senza la necessita' di mettercela fisicamente tu ...

Eccomi! allora ecco cosa sono riuscito a combinare coi componenti in mio possesso:

E queste sono le letture, incredibile! il valore al minimo è passato da 3000 e oltre a 900 giri com'è possibile?
Ecco come si comporta a "regime" e i valori sono decisamente molto più verosimili ai giri reali della ventola, anche se qualche fluttuazione persiste:

RPM =	0	 Hz=	0
RPM =	0	 Hz=	0
RPM =	120	 Hz=	2
RPM =	660	 Hz=	11
RPM =	1020	 Hz=	17
RPM =	1320	 Hz=	22
RPM =	1320	 Hz=	22
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1920	 Hz=	32
RPM =	2040	 Hz=	34
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1440	 Hz=	24
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1440	 Hz=	24
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1440	 Hz=	24
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1740	 Hz=	29
RPM =	1740	 Hz=	29
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	1500	 Hz=	25
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1560	 Hz=	26
RPM =	1500	 Hz=	25
RPM =	5940	 Hz=	99
RPM =	1320	 Hz=	22
RPM =	600	 Hz=	10
RPM =	240	 Hz=	4
RPM =	0	 Hz=	0
RPM =	0	 Hz=	0
RPM =	0	 Hz=	0

Mentre attendo la risposta, avanzo un nuovo quesito. Se al posto del relè attuatore mettessi un servocomando da pilotare a più stadi sarebbe molto meglio, ho provato ad implementare la libreria servo.h ma mi da errore perchè a quanto pare va in conflitto con il timer dell'atmega, come posso fare? utilizzo un Atmega per la lettura e un secondo Atmega per pilotare il segnale del servocomando? che ne dite?

Mi sembra strano che vada in conflitto perché non stai manipolando i timer direttamente ma utilizzando esclusivamente la funzione millis().
Puoi postare lo sketch col servo?

Il perché ora conti giusto è un mistero. :grin:
Forse come suggerito hai eliminato false letture.

Gne gne gne prendimi pure ingiro! :stuck_out_tongue: ho capito che evidentemente ho eliminato letture fasulle ma sono cresciuto in un officina se una cosa funziona e prima non funzionava non ci dormo se non capisco fisicamente cosa succede.... che brutto non avere un analizzatore di frequenze!!! se non fosse che lo userei ogni morte di papa me lo sarei comprato! un po' d'amarezza per le limitazioni che ho :disappointed_relieved:

Vabè nel frattempo ho perso lo sketch che avevo creato integrando il codice appropriato.

Ma un po' stufo di usare pezzi di sketch di altri ho provato la via (forse sbagliata) di partire ragionando solo con la mia testa da zero e ho "partorito" questo sketch:

int led=5; //simula relè attuatore
int reedSW=2; //sensore di giri (reed switch)

unsigned long duratagiro;
unsigned long rpm;
unsigned long Hz;

void setup(){
pinMode (led,OUTPUT);
pinMode (reedSW,INPUT);
Serial.begin(9600);
}

void loop(){
duratagiro=pulseIn(reedSW,HIGH); //la durata del giro è uguale al tempo trascorso tra HIGH e LOW
rpm=60000000/duratagiro; //giri al minuto è uguale a 60 secondi fratto la durata di un giro
Hz=rpm*0.0166666666667;

if (rpm < 1000) { // legge se la velocità dell'albero è bassa
digitalWrite(led, HIGH); //eccita relè attuatore
}
if (rpm > 1200) { // legge se la velocità dell'albero è sufficente
digitalWrite(led, LOW); //diseccita relè attuatore
}

Serial.println(rpm);
Serial.println(Hz);

delay(1);

}

//Goretto beginner project 26/01/04

Molto reattivo, anche troppo, inoltre da meno false letture (anche se non capisco il motivo) l'unico problema ora è che quando il magnete si arresta i valori restituiti dal calcolo degli rpm ed hertz schizzano alle stelle, ho provaro ad aggiungere il TimeOut nel comando Pulse ma non ha avuto nessun effetto se non quello di rallentare la frequenza di aggiornamento delle letture sul monitor seriale. Cosa c'è di errato?

mi avete abbandonato? :frowning: forse è meglio che sposto in sezione software in effetti. :cold_sweat: