Quel pezzo di sketch é inutile perché non si capisce cosa fanno le variabili. Non posso ne dire che funziona ne che é errato.
In realtà quello che mi serve è calcolare con una certa precisione il delta_t
che intercorre tra due impulsi, ossia il tempo tra un incremento del contatore ed il successivo. In questo modo dividendo dist
(la distanza che la ruota percorre in un impulso) per il delta_t
in cui lo percorre, è possibile ottenere la velocità istantanea.
Per questo non ho postato il resto del programma, che come richiesto riporto in seguito.
r////////////////////////////////////////////////////////////////////////////////// T R I P M A S T E R //////////////////////////////////////////////////////////////////////////////////
const byte switch_1 = 4; // switch tra trip_a - trip_b ----> lo switch avviene mandando a massa i pin per poter utilizzare la resistenza di pullup interna
const byte switch_2 = 5; // switch tra odo - v_ist
const byte switch_3 = 6; // switch tra t_parz - t_tot
const byte azzera_1 = 9; // azzeramento trip_a - trip_b ----> l'azzeramento avviene mandando a massa i pin per poter utilizzare la resistenza di pullup interna
const byte azzera_3 = 10; // azzeramento t_parz
float trip_a, trip_b, odo, v_ist;
unsigned long t_parz, t_tot, t0 = 0;
volatile unsigned long a, b, c;
volatile unsigned long t = 0, delta_t;
const float rap = 11.0 / 43.0; // 43 giri albero = 11 giri ruota rapporto coppie coniche differenziale sj410
const float circ = 2.18; // [m] (MISURARE)
const float dist = circ * rap; // PER VERIFICARE: misurare spazio noto e visualizzare la variabile a ---> dist = spazio/a
const int debounceDelay = 20;
const int azzeraDelay = 1000;
void setup() {
Serial.begin(9600);
pinMode(switch_1, INPUT_PULLUP);
pinMode(switch_2, INPUT_PULLUP);
pinMode(switch_3, INPUT_PULLUP);
pinMode(azzera_1, INPUT_PULLUP);
pinMode(azzera_3, INPUT_PULLUP);
attachInterrupt(0, contatore, RISING); // interrupt 0 = pin D2 interrupt 1 = pin D3
}
void loop() {
trip_a = a * dist;
trip_b = b * dist;
odo = c * dist / 1000;
t_parz = (millis() - t0) * 1000; // [s]
t_tot = millis() * 1000; // [s]
v_ist = (dist / delta_t) * 3600000000; // [km/h]
Serial.print("impulsi_a = ");
Serial.print(a);
Serial.print(" | ");
Serial.print("impulsi_b = ");
Serial.print(b);
Serial.print(" | ");
Serial.print("trip_a =");
Serial.print(trip_a);
Serial.print(" m | ");
Serial.print("trip_b =");
Serial.print(trip_b);
Serial.print(" m | ");
Serial.print("odo =");
Serial.print(odo);
Serial.print(" km | ");
Serial.print("t_parz =");
Serial.print(t_parz);
Serial.print(" s");
Serial.print("t_tot =");
Serial.print(t_tot);
Serial.print(" s");
Serial.print("delta_t = ");
Serial.print(delta_t / 1000);
Serial.print(" s | ");
Serial.print("velocita' =");
Serial.print(v_ist);
Serial.println(" km/h");
if (debounce(switch_1) == LOW) {
// visualizza trip_a su schermo 1
}
if (debounce(switch_1) == HIGH) {
// visualizza trip_b su schermo 1
}
if (debounce(switch_2) == LOW) {
// visualizza odo su schermo 2
}
if (debounce(switch_2) == HIGH) {
// visualizza v_ist su schermo 2
}
if (debounce(switch_3) == LOW) {
// visualizza t_parz su schermo 3
// fino ad un'ora [mm:ss], poi [hh:mm]
}
if (debounce(switch_3) == HIGH) {
// visualizza t_tot su schermo 3
// fino ad un'ora [mm:ss], poi [hh:mm]
}
if (debounce(azzera_1) == LOW) {
delay(azzeraDelay);
if (debounce(azzera_1) == LOW && debounce(switch_1) == LOW) {
a = 0;
}
if (debounce(azzera_1) == LOW && debounce(switch_1) == HIGH) {
b = 0;
}
}
if (debounce(azzera_3) == LOW && debounce(switch_3) == LOW) {
delay(azzeraDelay);
t0 = millis();
}
}
}
void contatore() {
delta_t = millis() - t;
a++;
b++;
c++;
t = millis();
}
boolean debounce(int pin) {
boolean state;
boolean previousState;
previousState = digitalRead(pin);
for (int counter = 0; counter < debounceDelay; counter++) {
delay(1);
state = digitalRead(pin);
if ( state != previousState) {
counter = 0;
previousState = state;
}
}
return state;
}
Riepilogo la logica di funzionamento: lo strumento, un tripmaster, verrà montato in un fuoristrada, in quanto gli organizzatori dei diversi raduni indicano le note del percorso in un roadbook misurando la distanza tra di esse in metri. Vorrei realizzarlo utilizzando tre schermi di quattro cifre a 7 segmenti (nonostante si possano far stare tutte le informazioni in un LCD, preferisco l'aspetto vintage) e tre switch a levetta per visualizzare di volta in volta le informazioni che desidero. Leggendo le note del programma risulta molto chiaro. Infine attraverso due pulsanti è possibile azzerare le distanze o i tempi.
Questo ultimo programma riporta anche una funzione di debouncing (in realtà necessaria solo per i pulsanti di azzeramento, ma che utilizzo anche per quelli a levetta), e le resistenze di pullup, che (assieme a quella di pulldown "fisica") hanno permesso di eliminare il disturbo.
Ora, tornando al discorso iniziale, come posso misurare il tempo tra un incremento ed il successivo (cioè il tempo tra un interrupt ed il seguente)?
La mia idea è quella di salvare il tempo dell'i-esimo interrupt, e sottrarlo a quello dell'interrupt i+1-esimo, in modo da ottenere la differenza tra i due. E' un ragionamento corretto?