Acquisizione RPM

Ciao a tutti, E' da questa mattina che sfoglio topic su vari contagiri in questo forum, ma oltre a differire leggermente da ciò che cerco, quasi tutti adoperano linguaggi fuori dalla mia comprensione. Purtroppo le mie conoscenze in elettronica sono nulle, nonostante sia al 3o anno di ingegneria meccanica...neanche un corso che insegni qualcosa di pratico, giusto teoria su elettromagnetismo e elettrotecnica dove si risolvono semplici circuiti. Il punto è che mi serve un qualche modo per acquisire su PC o una memoria(non fa differenza) i tempi tra un passaggio e l'altro. Credo che il sensore Hall sia la soluzione ottimale. Ma al di là del principio del sensore, non so minimamente come muovermi. Giusto ieri ho chiesto un parere ad un mio professore, e lui mi ha accennato all'arduino, anche se sinceramente non so bene nemmeno cosa sia. Diciamo che installato il sensore, quello che vorrei ottenere è una semplice colonna di tempi per ogni passaggio tipo 0 0.254 0.411 0.506 0.687 ecc oppure anche in forma di tempi di singoli cicli va benissimo, cioè le durate tra un passaggio e l'altro. diciamo che come soglia max (ma non credo di arrivarci) stiamo attorno ai 2500 rpm. L'ideale sarebbe, una volta posizionato il magnete e il sensore, poter avviare il conteggio tramite un comando, ottenere l'elenco dei tempi con una buona precisione(nei limiti di un budget relativamente economico...insomma parliamo di un congegno banale, tipo il tachimetro che si mette sulle bici) e poi arrestare il conteggio sempre a comando.

Il topic che più si avvicina a ciò che sto cercando è questo http://forum.arduino.cc/index.php?topic=197094 tuttavia come ho già scritto sono totalmente sprovvisto di nozioni elettroniche per cui anche i termini più banali (per voi) mi mandano in crisi. Spero possiate darmi una mano. Sono gradite spiegazioni il più possibile predisposte verso la totale ignoranza...quindi anche la sola descrizione di che cosa sia esattamente l'arduino non datela per scontata. Vi ringrazio in anticipo!

L'Arduino è questo E' una scheda che ha a bordo un microcontrollore (Atmel ATmega328P) programmabile con il linguaggio C. Per facilitare le cose l'Arduino UNO, e così per quasi tutti i modelli, ha sulla stessa scheda un convertitore USB/seriale che permette di programmarlo semplicemente collegandolo ad una presa USB di un PC (Windows, Linux o Mac) Per facilitare ulteriormente le cose, l'Arduino Team ha creato un ambiente di sviluppo (IDE) che permette con pochi comandi di far eseguire dei semplici compiti al microcontrollore dell'Arduino, ad esempio accendere un led o interpretare la pressione di un pulsante, scrivere su un LCD, ecc. Per compiti più complessi sono disponibili già fornite con l'IDE una serie di librerie e altre sono reperibili su Internet.

Hai già dato l'esame di Informatica?

Si, il mio esame di informatica era su matlab, e modestamente me la cavo piuttosto bene....tant'è che ho continuato ad usarlo per molto altro e mi torna continuamente utile. Purtroppo altri linguaggi non conosco ....ma credo di poterne apprendere qualche base con i tutorial su youtube

hai parlato di programmarlo...ma non ho la più pallida idea di come si possa farlo. nel senso la programmazione che ci hanno insegnato alla fine è una sorta di algoritmo più o meno complesso che prendendo in input numeri, ne calcola altri.

Paperjazz: Ciao a tutti, ........quindi anche la sola descrizione di che cosa sia esattamente l'arduino non datela per scontata. Vi ringrazio in anticipo!

se fai una query su Google con arduino da 10.200.000 risultati in 0,21 secondi, internet e di per se la più grande e veloce biblioteca del mondo ;) basta saper cercare e scremare i risultati

Vabeh se devi fare osservazioni inutili evita di scriverle per favore. Bene o male ho capito che è una scheda programmabile, avevo scritto quella cosa solo perchè essendo ignorante in materia vorrei che non fosse dato nulla per scontato.
Non ho in programma ora di imparare ad usare arduino in todo e per todo, mi serve come dire una cosa funzionale sulla quale poi sviluppare il resto del progetto.
Ciò che mi serve mi sembra di averlo già descritto: ho una ruota che gira e mi serve l’acquisizione della velocità angolare nel tempo. Sarebbe perfetto un sistema che mi permetta di ottenere tutti i tempi tra tutti i passaggi. Va bene sia con scheda sd sia sempre collegato al pc. L’obiettivo è avere i tempi il più possibile precisi. Condizioni limite attorno ai 40 tempi al secondo.
Qualcuno cortesemente potrebbe indirizzarmi verso l’hardware da procurarmi e come programmarlo.
Sicuramente nel futuro con un pò di tempo libero approfondirò un pò l’arduino per interesse personale, ma al momento veramente non ho un respiro e mi serve questo strumentino il prima possibile.
Su youtube ho visto persino che c’è chi ha fatto l’acquisizione in tempo reale con tanto di plottaggio su matlab, il che sarebbe grandioso.

Ciao, per iniziare ti serve acquistare una scheda Arduino UNO, la puoi trovare anche da RS Components e Distrelec ma anche tanti stores sparsi su internet (Amazon per esempio ne raccoglio diversi) per sicurezza, guarda la lista di stores uffciali sul sito arduino.cc ti costerà intorno ai 21-22 euro quindi del tutto nel budget. Ti consiglio l'acquisto della guida uffciale Arduino, è molto ben spiegato per beginners, ha tanti esempi utili a farti comprendere il suo funzionamento, altrimenti, fatti un'infarinatura veloce su internet, meglio ancora, studiati la documentazione del sito ufficiale:

http://arduino.cc/en/Guide/HomePage

Poi ti servirà un cavetto USB e per ultimo, il sensore HALL.

il sensore HALL ha 3 fili, un +5V, una massa (GND) ed il segnale (0 o 5V, onda quadra)

Con arduino potrai avere la giusta precisione per il tuo progetto.

Anch'io sono un principiante in Arduino ma ho già una certa esperienza in programmazione e sto impegnato in progetti dove la misurazione dei giri è all'ordine del giorno, ma sarà dura spiegarti se non hai una minima base.

In linea di massima, sulla scheda troverai, un +5V il quale collegherai al +5v del sensore Hall, allo stesso modo, collegherai la massa del sensore con uno dei pin GND segnalati sulla scheda e per ultimo, devi collegare il segnale del sensore in uno dei canali Digitali, essi sono nominati 0...13, diciamo che lo metti in 2 (dove potrai usare interrupt 0).

Una volta installato il sw IDE sul PC, lo lanci, ti apparirà uno spazio bianco dove scriverai il tuo programma, sopra trovi dei pulsanti, quello con segno di spunta (verify) serve a verificare la correttezza sintattica del codice, una volta scritto il codice, cliccandoci su, l'IDE lo compilerà, se tutto ok, nel riquadro sotto apparirà il messaggio "Dimensione del file binario dello sketch: x.xxx bytes (su un massimo di 32.256 bytes)" quindi sarà corretto e potrai poi inviare alla scheda arduino con il tasto con la freccia dx (Carica). L'altro tasto che ti potrà essere utile sarà quello più a dx, il Serial monitor che ti consentirà di visualizzare i dati che la scheda spedirà al pc.

Ogni programma viene chiamato "sketch"

Ogni programma basicamente è composto da 3 "elementi" base direi:

1-Inizializzazione, in essa si possono dichiarare le variabili, array ecc, 2-una funzione setup con la sintassi: void setup() { il tuo codice qui ....} 3-una funzione loop con la sintassi: void loop() { il tuo codice qui...}

la parola void sta ad indicare che è una funzione che non restituisce parametri, in setup() andranno messi tutti quei comandi che vanno eseguiti una volta sola, all'avvio del programma, quindi l'abilitazione della comunicazione seriale ecc... come si intuisce dal nome, nella funzione loop() andranno tutti i comandi e calcoli da eseguire all'infinito. Puoi creare le tue funzioni così: void NomeMiaFunzione() { mio codice... } questa funzione la potrai richiamare da ogni parte dello sketch così: NomeMiaFunzione();

Ogni funzione viene iniziata dalle parentesi graffe "{" e va chiuso altrettanto con "}" altrimenti, il compilatore darà errore. Queste parentesi stanno ad indicare inizio e fine codice.

Altro elemento importante, è l'uso del punto e virgola ";" alla fine di ogni istruzione, sta ad indicare al compilatore che il comando è terminato, e può passare al prossimo.

Per commentare i tuoi programmi usa doppio slash "//" per ogni rigo.

Vediamo un semplice esempio:

//questo è un commento, serve a rammentarti in futuro di cosa hai fatto   
//il mio primo programma arduino

byte Variabile1;
byte Variabile2;
byte Risultato;

//**********************************************************************
void setup(){

Serial.begin(9600);

Variabile1=10;
Variabile2=2;

}

//**********************************************************************
void loop(){                //inizio del loop infinito


Risultato = Variabile1 * Variabile2;    //operazione matematica

Serial.print(Variabile1);                        //invia alla seriale il contenuto della variabile1 (senza ritorno a capo)
Serial.print(" * ");                                   //invia alla seriale un carattere o parola, va messa tra virgolette.
Serial.print(Variabile2);
Serial.print(" = ");
Serial.println(Risultato);                    //invia alla seriale il risultato, con la dicitura "println" stiamo indicando un ritorno a capo.

delay(1000);                                         //inserisco una pausa di 1000 mS ovvero 1 sec.

}                                                                //con la parantesi graffa chiudo la funzione loop, se manca darà errore alla compilazione.

Per il tuo progetto, dovrai usare la funzione millis() che indica il tempo trascorso dall'avvio della MCU, diciamo un programmino così:

//Misura tempo trascorso tra due eventi interrupt

int Tempo_Attuale;       //variabile che conterra il tempo attuale misurato dalla funzione millis() 
int Tempo_Precedente;    //variabile che conterra la copia del tempo attuale per poter valutare il 
                         //tempo trascorso tra due eventi consecutivi
                         
int Tempo_Evento;        //variabile che conterra il risultato del calcolo del tempo trascorso tra due
                         //eventi in presenza di segnale HALL

//*********************************************************************************************************
void setup(){

attachInterrupt(0,Evento,RISING);  //funzione che serve a "interrompere" il programma alla presenza di 
                                   //un segnale sul pin interrupt 0 (pin 2 dei pin digitali) se trova un 
                                   //segnale RISING ovvero da 0V sale a 5V 
                                   //Evento è la funzione dove andrà in caso di interrupt
                                   
Serial.begin(9600);                //abilita il comando trasmissione seriale a 9600 bps

}

//*********************************************************************************************************
void loop() {                      //loop infinito          

Tempo_Attuale = millis();                    //assegna alla variabile il tempo in mS dall'accensione di Arduino

}

//**********************************************************************************************************
void Evento(){        //la nostra funzione eseguita ogni qual volta si incontra un segnale del sensore HALL.
  
Tempo_Evento = Tempo_Attuale - Tempo_Precedente;

Serial.println(Tempo_Evento);                            //invia alla seriale il contenuto della variabile  

Tempo_Precedente = Tempo_Attuale;            //uguaglia il tempo precedente a quello misurato attualmente,
                                             //serve a permettere la misurazione del tempo trascorso tra due 
                                             //eventi successivi.
                                             
//il dato trasmesso alla variabile è il tempo trascorso tra due eventi segnale HALL, ovvero, se abbiamo un unico
//dente sulla ruota fonica da misurare, significa che ogni giro impiega quel tempo in mS quindi basterà poi 
//calcolare (sul nostro programma PC) i giri/min o RPM così:  RPM = (1000 / Tempo_Attuale) * 60 ). 

}  //fine funzione

Spero di essere stato abbastanza chiaro, c'è molto da imparare, ma in sostanza, da quello che ho capito, usando questo esempio ed adattandolo alle tue necessità potrai fare la lettura dei tempi trascorsi per ogni giro, considera che stiamo parlando di millisecondi, e che con 10ms stai girando a 6000 rpm... Se ti servisse maggiore precisione, potresti usare "micros()" invece di millis() ed avresti la possibilità di misurare i microsecondi (uS) ovvere 1/1000000 Sec. Questa funzione lavora con risoluzione di 4uS ovvero, restituirà solo multipli di 4uS. Leggi le "reference" sul sito ufficiale.

Buon lavoro! ;)

Ho dimenticato di aggiungere:

Se userai micros() invece di millis(), ti conviene dichiarare le tue variabili come unsigned long perchè essendo milionesimi di secondo, con int o unsigned int andrebbero in overflow (arriva al massimo numero misurabile dal tipo variabile e poi riparte da 0) . Invece con unsigned long avresti fino a 70 minuti prima di andare in overflow.

guarda questi link alla pagina uffciale:

http://arduino.cc/en/Reference/Micros

ciao!

Grazie mille!!! Mi hai chiarito un pò di idee. Ieri notte mi sono visto parecchi tutorial base su arduino, quindi più o meno ho capito come funziona, cosa sono i pin. Anche qualche programma molto molto semplice tipo il lampeggio di un led. Insomma molto intuitivo. Ho ancora qualche dubbio sull'acquisizione....parli di porta seriale!?....sul pc non ho la porta seriale(so che esistono dei convertitori da seriale a usb volendo), però pensavo si potesse fare tutto attraverso quell'unico cavo usb con cui lo collego al pc. Comunque mi sono fatto due calcoli, e credo che preferirei usare micros....poi se nascono troppe complicazioni allora vada per millis. In realta 10-6 è fin troppo alta come risoluzione per ciò che devo fare...l'ideale sarebbe 10-4. Comunque a parte un pò di comandi di setup che non mi sono chiarissimi, il contenuto di loop è intuitivo. Mi rimane solo il problema di come ricevere e memorizzare i dati sul pc. Eviterei di fargli fare la differenza per minimizzare approssimazioni ed errori, quindi utilizzerei una sola variabile che è millis o micros e ad ogni impulso del sensore vorrei che mi scrivesse il suo valore...poi ci lavorerò su io con matlab. Per quanto riguarda l'hardware, il sensore dovrà stare a 1/3 metri dall'arduino, che cavetteria mi procuro?

Grazie mille ancora per la risposta, molto molto esaustiva!

Il convertitore è già a bordo dell'Arduino. La connessione è data dal cavo USB ma vista da PC come porta COM ovvero Seriale. Ecco perché si parla di Seriale anche su PC.

Perfetto Paolo, un altro dubbio risolto. Su pc però dove scrive i dati? immagino che il comando Serial.println(valore) invia il valore, ma sul pc dove viene scritto? txt? Excel? O magari direttamente un vettore su matlab? Mi è venuto in mente un altra cosa: il programma è come una loop infinita, nel momento in cui arduino è collegato lo esegue sempre? C'è la possibilità (sicuramente c'è) di avviare e stoppare l'acquisizione ad arduino collegato ed in funzione....senza che debba attaccare e staccare la corrente di alimentazione!? Tutto sommato credo che basti prendere corrente da un pin, e con un interruttore mandarla in un pin digitale, e poi imporre una qualche condizione dentro il programma per avviare il loop e terminarlo. Tipo una condizione if fuori dal loop di hall per farla girare, e dentro il loop un altro if del tipo se il segnale è off, esci dal loop!?

in realtà potrei mettere un interruttore direttamente sul cavo di alimentazione del sensore di Hall.

ciao,

quando Arduino invierà i dati alla seriale essi li potrai acquisire con qualsiasi device che supporta la comunicazione seriale, anche un LCD seriale! Nel caso del PC, il cavetto usb comunicherà direttamente con in transceiver usb-seriale abordo della scheda e quindi il tuo pc, vedrà arduino in una porta COM virtuale quindi da COM2 in avanti (solitamente COM1 è riservata per pc con seriale hardware) Non conosco Matlab in dettaglio, ma secondo me può generare anche pseudo programmi stand alone e l'accesso ai dati della porta seriale sicuramente rientra tra le sue possibilità. Quindi dovrai vedere se matlab può acquisire i dati e salvarli su file txt o csv ecc...

per la precisione dei tempi di campionamento, purtroppo esistono solo millis() e micros(), anche se è fattibile che arduino invii i dati singoli del timer micros() tieni presente che esso sarà ad ogni giri incrementale, fino ad arrivare all'overflow dopo circa 70 minuti (perchè raggiungerà il massimo numero che si può scrivere con la notazione unsigned long (vai a vedere la documentazione ufficiale). Ma non sarebbe meglio farlo in arduino? per quanto piccolo, queste cose sono alla sua portata!! Devi stare attento solo a non invocare troppi Serial.print() perchè essi rallentano il sistema a causa del tempo di trasmissione dati e perchè occupano un buffer da 64 bytes quindi toglie RAM preziosa alla MCU. Ma visto che nel tuo caso, non deve far altro, è più che sovradimensionato per il compito.

Per il comando di attivazione e disattivazione acquisizione è possibile sia farlo attraverso dei pulsanti (uno ne basta) che andrebbe a resettare una variabili che attiverebbe o meno l'acquisizione/trasmissione dei dati o tramite comando provveniente dalla seriale tramite il programma sul PC. Purtroppo, sul PC non posso darti troppi aiuti perchè la programmazione su pc non è il mio forte.

Per fare l'attivazione/disattivazione tramite pulsante, basterà mettere un pulsante con uno dei terminali a massa sulla board arduino, all'altro terminale collegare una resistenza da 4700 ohm al +5V ed a sua volta ad un pin digitale libero (3 per esempio). Collegato così si dice che ha una resistenza di pull-up, quindi arduino vedra una tensione di 5V nel suo pin 3, il comando a quel punto in programma misurerà quando questa tensione scenderà tendendo a zero volt, la resistenza serve come protezione contro corto circuito interno al MCU limitandone la corrente a poche decine di mA. Potresti anche collegarlo tipo pull-down ovvero con il pin che prima avevi collegato a massa con la resistenza e poi a massa, e sull'altro pin il +5V, questa volta però, il pin 3 digitale andrà collegato al piedino dell'interrutore che ora è collegato alla resistenza che va a massa. Così, arduino misurerà costantemente una tensione prossima a 0 Volt, al momento di premere il pulsante, vedrà una tensione di 5V e quindi eseguirà il comando assegnato.

Appena avro un pò più di tempo vedrò di farti qualche esempio del codice da poter usare.

Perfetto. Allora ho finalmente tutto il materiale in mano :) Arduino Uno, sensore di hall, calamita presa dal vecchio geomag, un bel cavo quadripolare (tripolare purtroppo non trovato), il programma sul pc e il cavetto USB.

Tra l'altro mi sono scaricato anche questi programmini per matlab http://www.mathworks.it/matlabcentral/fileexchange/32374-matlab-support-package-for-arduino-aka-arduinoio-package che dovrebbero permettere di gestire l'arduino direttamente da matlab, tuttavia non sono riuscito minimamente a farlo funzionare.

Dunque le strade sono due. Una è quella col programmino sull'arduino e un qualche sistema per acquisire un txt o chessò excell di dati, l'altro è quello di usarlo direttamente da matlab. Non so quale sia il modo più semplice ed efficace, ma vorrei riuscire a far funzionare il tutto il prima possibile. Vi ringrazio per eventuali consigli/suggerimenti!

Qualcuno cortesemente potrebbe spiegarmi le caratteristiche dei sensori unipolari ad effetto Hall con uscita digitale. Sulle schede trovo tensioni e correnti d'alimentazione, intervalli termici di funzionamento ecc ..... poi però l'informazione più utile non riesco a comprenderla. La figurina che ho trovato su una delle schede tecniche è questa: il cui significato è abbastanza chiaro: ci sono due soglie, quando il campo diminuisce il sensore scatta sotto la soglia più bassa, quando il campo sale il sensore scatta sopra la soglia più alta. Il punto è che poi ci sono le tabelle relative ai vari modelli: Perchè ci sono i Bop e Brp max e min, e le loro zone sono perdipiù sovrapposte! Quand'è che questi sensori scattano???

Di recente mi sono comprato un bel pò di calamitine e fatto qualche test con il sensore che ho erroneamente acquistato, ovvero quello analogico bipolare. Ho concluso che nelle condizioni in cui mi servirà il campo magnetico sarà fatto circa in questo modo: In altre parole oltrepasso appena i 10 mT ovvero 100G In realtà potrei anche aumentare il segnale diminuendo la distanza di passaggio, ma nelle condizioni in cui lavorerà prevedo delle sollecitazioni che potrebbero allontanarlo. Insomma il punto è che sensore prendere? Mi serve un sensore unipolare con uscita digitale che scatti diciamo attorno ai 8 mT, anche un pò meno potrebbe essere preferibile. Confido nel vostro aiuto e ringrazio tutti in anticipo!

Usare magneti al neodimio (che hanno una densita' di campo piuttosto elevata) ti potrebbe permettere di usare una distanza un po maggiore ... poi i sensori di hall ci sono di diverse sensibilita', ma fino ad un certo punto (dopo diventano magnetometri, ma non credo tu voglia usare una fluxgate come sensore RPM :P) ...

Ad esempio, HAL506UA-A-2-B-1-00 della Micronas, con un'ON-point a 5.5mT e' gia considerato ad alta sensibilita' ... lo stesso per l'US5681 della Melexis ...

Ci sono piu sensibili, ma sono bipolari e/o latching, oppure con uscita proporzionale (sensori di posizione, anziche' switch)

Ciao, delle caratteristiche che stai chiedendo purtroppo non ti posso dire nulla, ma di sicuro posso consigliarti di usare un sensore HALL di quelli automobilistici, essi danno sicuro, un'onda quadra digitale 0-5V, potresti prenderli usati allo sfasciacarrozze. Se per esempio prendi quelli predisposti al segnale CAMMA, quasi di sicuro sarà HALL, quelli dell'albero motore invece saranno induttivi e quindi richiederebbero un circuito di condizionamento(consiglio l'uso dell'integrato LM1815) prima di passare il segnale ad arduino. Anche i sensori ABS, possono essere HALL, basta che abbiano 3 fili (ma va verificato, potrebbero essere indittivi ed il terzo filo essere una schermatura). Credo che visto che la tua applicazione è automotive, richieda di un sensore espressamente Automotive, ti eviterà altri problemi oltre quelli da te già incontrati. E poi, questi sensori, non richiedono di calamite ma basta un qualsiasi dente di materiale ferroso (se ci si attacca la calamita, va bene). Comprarli nuovi non ti conviene, spenderesti oltre 40 euro, se vai dal tuo meccanico, molto probabilmente ne avrà di sensori buttati qua e la, magari te ne può dare qualcuno per provare. Unico neo per così dire, dovrai crearti dei morsetti per collegarti ai pin del sensore, o trovare uno spinotto compatibile, e poi dovrai cercare in un database la corrispondenza dei pin (Autodata va benissimo).

Ma a te serve per misurare rpm? come mai tutti questi dubbi, non capisco? forse la frequenza del sensore va oltre le specifiche del tuo sensore? a te dovrebbe interessare solo il periodo tra eventi "dente" da questo calcoleresti i giri al sec e/o al minuto, se poi l'idea è anche acquisire la posizione angolare del motore, allora ti conviene passare ad una ruota fonica con più denti, da almeno 12-1 ma consiglio la 36-1 o 60-2. Dipende dai giri, una 60-2 è più precisa, ma implica maggiore potenza di calcolo e di acquisizione interrupts, con arduino uno potrebbe essere un problema andare molto alto di giri (ne so qualcosa ci sto giocando in questi giorni), meno denti garantiscono più "respiro" al MCU ma anche meno precisione angolare (anche perchè, un motore a combustione interna, non ha un'andamento lineare/costante perché è soggetto ad accellerazione durante il ciclo di espansione e a rallentamento durante il ciclo di Compressione (le centraline di serie da quanche decennio prendono in considerazione anche queste accellerazioni/decellerazioni per controllare/verificare lo stato di salute di inniettori e motore o di mancate accensioni per esempio!).

Ovviamente quello che ho scitto precedentemente è valido se fai un programmino sull’Arduino, non so come faresti sul matlab da quello che mi hai spiegato in PM, forse è per questo che hai problemi con il sonsore? perchè non provi a vedere se il sensore riesci a farlo funzionare solo con Arduino ed un Serial.print() ? potresti risolvere senza altre spese e complicazioni varie, poi ti toccherebbe solo decidere come fare l’acquisizione, se in matlab come semplice ricezione di comunicazione seriale da salvare in file .csv (in modo da poterlo analizzare in excel per esempio) o altra strada, (magari un copia incolla dei dati stampati sul serial monitor in un file testo con blocco note rinominato .csv ? potrebbe essere una soluzione grezza ma eficace anche se lenta. Se invece ti serve fare analisi in tempo reale, allora dovrai per forza lavorare con matlab (che conosci) o altro programma (che dovresti imparare o trovare).

Etemenanki:
Usare magneti al neodimio (che hanno una densita’ di campo piuttosto elevata) ti potrebbe permettere di usare una distanza un po maggiore … poi i sensori di hall ci sono di diverse sensibilita’, ma fino ad un certo punto (dopo diventano magnetometri, ma non credo tu voglia usare una fluxgate come sensore RPM :P) …

Ad esempio, HAL506UA-A-2-B-1-00 della Micronas, con un’ON-point a 5.5mT e’ gia considerato ad alta sensibilita’ … lo stesso per l’US5681 della Melexis …

Ci sono piu sensibili, ma sono bipolari e/o latching, oppure con uscita proporzionale (sensori di posizione, anziche’ switch)

Ho già i magneti al neodimio :slight_smile: 10x2 mm magnetizzazione N42 …piuttosto forti.
5.5 mi andrebbe bene, più che altro non capisco perchè anche nella scheda di questo sensore ci sono i punti di on min e max, e quelli di off min e max. Come funziona. Quando sto nella zona sovrapposta cosa fa? Il mio segnale comunque scende sotto lo 0(giustamente le linee di campo escono verso l’alto ma poi devono fare il giro e quindi rientrare da sotto) …insomma questo sensore potrebbe essere la soluzione al mio problema. Dove acquistarlo e sopratutto quanto costa?

@Hiperformance
No guarda non è questione di frequenza, la max velocità angolare sarà di 40 giri al secondo, infatti sto anche valutando di mettere 4 calamitine per un discorso di maggior precisione e guadagno anche ii bilanciamento, visto che comunque gireranno a circa 10 cm dall’asse e quindi una calamitina da 1 grammo spingerà con circa 1/6 kgF che non è poco.
dai vari topic che ho letto mi sembra che anche 160 passaggi al secondo siano fattibilissimi…correggetemi se sbaglio.
Dicevo di matlab perchè lo userò per lavorare sui dati, ma in questi giorni mi sono reso conto che il tempo di un ciclo semplicissimo per acquisire il segnale è di circa 3 centesimi…ho fatto qualche prova sul ventilatore in casa e già a 15 giri al secondo si perde un passaggio su 3, insomma è inutilizzabile. Quindi sono assolutamente convinto di usare lo sketch da te proposto e leggere il segnale seriale. Giusto ieri leggevo su un post inglese che c’è un software che ti crea direttamente un txt con tutti i dati…un excell andrebbe ancora meglio dal momento che può essere aperto anche da matlab senza perdere l’organizzazione per caselle.
Per quanto riguarda il sensore automobilistico…dovrò comunque mettere materiale ferroso perché la superficie sulla quale rilevo non lo è…tanto vale mettere le calamitine. In più il fattore peso non è da trascurare…come ho scritto le sollecitazioni saranno forti, quindi meno peso ci metto meglio è. Il sensore da meno di un grammo è ottimo. Quelli abs ne ho visto già qualcuno ma sono molto più grandi e poi vanno alimentati a 12V, come faccio con arduino?..domanda alla quale non mi serve in realtà la risposta perchè sono orientato al sensorino.
Infine non so se il mio sensore che è proporzionale è possibile farlo funzionare con un sketch con la soglia if, però immagino che così perdo molto nel tempo del ciclo…quindi comunque è preferibile un sensore unipolare digitale.
Quello consigliato da Etemenanki sembra perfetto…tranne il fatto che non so dove trovarlo e quanto mi costa.

Ok, non sono al corrente dei dettagli del tuo progetto, e quindi ti stavo orientando verso una soluzione che sono sicuro avrebbe funzionato. Giusto per chiarire alcuni dubbi, i sensori automotive sono tutti alimentati a 5V, ne conosco pochi che sono alimentati anche a 12V (tipo il riscaldatore del filo caldo del misuratore massa aria o flussometro per esempio) Per la frequenza non vedo il problema, io sto sperimentando con uno sketch che deve leggere i denti (simulati da un circuito apposito) di una ruota fonica 60-2 denti, e usando attachInterrupt() sono riuscito ad acquisire e trasmettere alla seriale senza grossi problemi fino a 4700 rpm (ovvero 78,33 giri/sec x 58 denti = 4543,33 denti al secondo = 4353 Hz) e quindi ben oltre le tue necessità (questo per quanto riguarda il lato arduino). Come soluzione per l'acquisizione seriale, puoi fare una serie di serial.print e formattare i dati in modo da creare un file delimitato da virgola e quindi compatibili con excel (.csv), Magari quel programma che hai visto lavora proprio così. Fare tutto con arduino mi sembra la forma più semplice, poi esporti i dati in matlab e li ti sbizzarrisci con le analisi del caso.

Aproposito di sw, mi è venuto in mente che esiste uno che si chiama STAMPLOT gratuito che se configurato ti legge e fa anche diverse grafiche in tempo reale dei dati seriali se delimitati da virgole, addirittura riesce anche a dividere due o più dati, anni fa lo sperimentai con i picaxe e funzionava molto bene, non so però se può esportare i dati in txt o csv. spero ti possa essere utile.

PS. ho appena provato e funziona, inviando 3 dati separati da virgola e un carriage return (con Serial.println() si ottiene) separe correttamente i dati acquisiti, e li plotta a schermo anche, poi puoi salvare il file txt, e importarlo in excel senza il minimo problema, il programma vi aggiunge data ed orario, magari sono dettagli che a te non servono...

unico neo che ho riscontrato, la mia applicazione invia i dati alla seriale in modo massiccio man mano sale di giri e questo non è l'approccio giusto (tende ad incasinare la trasmissione seriale), che invece sarebbe trasmettere a cadenze di tempo specifiche, io per ora, per debug mi accontento di trasmettere così ma dovrò trovare una buona soluzione, altrimenti va messa la massima velocità di TX (115200) che però non sempre è la soluzione migliore. Comunque se ti va, provalo (esiste sia uno che si chiama STAMPLOT lite che uno demo MAKERPlot sono in sostanza identici.

PS2: ti confermo anche che puoi semplicemente aprire il serial monitor di arduino, ricevere tutti i dati trasmessi, poi fai un copia incolla su un file testo e salvi con formato txt ANSI, poi apri excel e gli dici che è delimitato da virgola, e questo e tutto!!

http://www.semiconductorstore.com/cart/pc/viewPrd.asp?idproduct=6213

L'altro (US5681) sembra non essere distribuito a livello "consumer", solo industrialmente (o almeno io non l'ho trovato)

I punti "min" e "max" sono il range entro il quale il dispositivo puo funzionare ... indicativamente, si tiene conto del "typical", poi se uno e' fortunato, puo trovarne uno un po piu sensibile, o anche il contrario, causa tolleranze di produzione ... ma in genere, il 95% della produzione rimane nella zona "media"