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:
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! 
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.