Esperimenti di Fisica (cinematica) con Arduino a scuola

Ciao,
Al secondo anno di liceo scientifico propongo attività di fisica sul moto rettilineo uniforme e unif. accelerato. Col sensore a ultrasuoni mi pare si possano fare esperimenti utili, voi ne avete mai fatti?

Sono in difficoltà a pensare come usare arduino per moti 2d al terzo anno, invece. In particolare per moto circolare uniforme ok, ma per accelerato? E soprattutto per il moto parabolico?

Se avete idee vi ascolto. Grazie

Puoi usare degli accelerometri a tre assi.
Per il moto, potresti usare delle barriere composte da laser + fotodiodo ed i valori di millis() e micros() inerenti al passaggio di un oggetto fra la sorgente ed il rivelatore.
Oltre al sensore ad ultrasuoni, ci sono anche sensori di distanza IR.

Un approccio interessante potrebbe anche riguardare il coinvolgimento degli studenti nella realizzazione del sistema sperimentale, software compreso.

Concordo con paulus, ma non ho però capito se lo scopo ossia l'uso di Arduino sia quello di attuatore o di misuratore. Per il secondo anno, se si parla di moto rettilineo uniforme o uniformemente accelerato immagino un qualche binario inclinabile ed una pallina, ed Arduino quindi dovrebbe rilevare la posizione della pallina e quindi produrre ad esempio un grafico del moto e/o dell'accelerazione. per dimostrare quello che fece Galileo con un piano inclinato e delle campanelline :wink:
Per il terzo anno invece la cosa è più complessa, anche se si potrebbe realizzare un pendolo ad esempio, ma forse servono comunque degli attuatori per realizzare un moto circolare accelerato, per i quali però non ho idea (sono passati parecchi anni, ma esiste nel programma di terza lo studio del moto circolare uniformemente accelerato?), se non pensare ad un motore DC controllato da un Arduino, quindi come attuatore in questo caso.

Grazie per gli ottimi spunti

Ciao, ritorno su questo topic aperto tempo fa perché finalmente ho tra le mani uno sketch per la velocità di un corpo in moto rettilineo e non capisco cosa sto sbagliando… Per ora gli esperimenti di misurazione della posizione con sensori a ultrasuoni e plottaggio in tempo reale del diagramma orario funzionano bene (anche se solo con IDE su Windows… per ora spero) ma questo sketch che coinvolge ancora il solito hcsr04 (che funziona bene) mi fa ottenere valori di velocità molto variabili anche se non attesi.

Qualcuno può aiutarmi?

// hcsr04 e calcolo della velocità

// non va... la velocità varia troppo, anche se abbiamo MRU

const byte trigPin = 2;
const byte echoPin = 3;


void setup()
{
 Serial.begin(9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
}

void loop()
{
  float distance1 = sonicRead();
  unsigned long t1 = micros();
  float distance2 = sonicRead();
  unsigned long t2 = micros();
  float speed = abs(distance2 - distance1) * 1000000.0 / (t2 - t1);
  if(t1 < t2){
    Serial.print(abs(distance2-distance1));
    Serial.print(" ");
    Serial.print(distance1);
    Serial.print(" ");
    Serial.print(distance2);
    Serial.print(" ");
    Serial.print(t2-t1);
    Serial.print(" ");
    Serial.print(t1);
    Serial.print(" ");
    Serial.print(t2);
    Serial.print(" ");
    Serial.println(speed);
  }
  //Serial.println(micros());
  //delay(100);
  //Serial.println(micros());
}

float sonicRead ()
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  unsigned long duration = pulseIn(echoPin, HIGH, 20000);
  float distance = duration * 0.034 / 2;
  delay(60);
  if(distance >0 && distance <50){ 
    return distance;
  }  
}
// https://forum.arduino.cc/index.php?topic=359544.0

Ed ecco un output (sette colonne con deltas s1 s2 deltat t1 t2 e infine la velocità)

0.02 2.53 2.52 60684 60692 121376 0.28
0.48 2.52 2.99 60712 184252 244964 7.84
0.12 2.87 2.99 60720 307932 368652 1.96
0.56 2.98 2.41 60684 431608 492292 9.24
0.02 2.52 2.53 60692 555240 615932 0.28
0.02 2.52 2.53 60688 678856 739544 0.28
0.12 2.41 2.53 60688 802476 863164 1.96
0.12 2.53 2.41 60684 926112 986796 1.96
0.00 2.53 2.53 60684 1049736 1110420 0.00
0.02 2.53 2.52 60684 1173380 1234064 0.28
0.10 2.41 2.52 60684 1297088 1357772 1.68
0.36 2.52 2.87 60716 1420800 1481516 5.88
0.10 2.99 2.89 60712 1544580 1605292 1.68
0.48 2.99 2.52 60692 1668336 1729028 7.84
0.02 2.52 2.53 60684 1792056 1852740 0.28
0.02 2.57 2.58 60692 1915760 1976452 0.28
0.17 2.47 2.64 60696 2039476 2100172 2.80
0.05 2.64 2.69 60692 2163224 2223916 0.84
0.15 3.40 3.55 60748 2287000 2347748 2.52
0.20 4.01 3.81 60764 2410868 2471632 3.36
0.54 4.23 4.78 60828 2534768 2595596 8.94
0.58 4.73 5.30 60856 2658768 2719624 9.50
0.71 5.15 5.87 60892 2782808 2843700 11.73
0.05 6.02 5.97 60892 2907004 2967896 0.84
0.42 6.38 6.80 60940 3031136 3092076 6.97
0.36 7.62 7.97 61016 3155420 3216436 5.85
1.11 8.26 9.37 61096 3279824 3340920 18.09
1.07 9.49 10.56 61156 3404428 3465584 17.51
0.60 11.34 11.93 61244 3529236 3590480 9.72
0.60 12.78 13.38 61328 3654216 3715544 9.70
0.53 13.24 13.77 61360 3779304 3840664 8.59
0.54 14.06 14.60 61408 3904484 3965892 8.86
0.53 14.94 15.47 61452 4029760 4091212 8.58
0.54 15.76 16.30 61508 4155128 4216636 8.84
0.59 16.95 17.54 61580 4280624 4342204 9.66
0.54 17.46 18.00 61604 4406216 4467820 8.83
0.32 18.73 19.06 61668 4531908 4593576 5.24
0.27 19.41 19.69 61700 4657716 4719416 4.41
0.70 20.08 20.77 61776 4783592 4845368 11.28
0.34 22.17 22.51 61872 4909712 4971584 5.50
0.78 23.27 24.06 61960 5035956 5097916 12.62
1.19 24.36 25.55 62060 5162400 5224460 19.17
1.77 25.89 27.66 62176 5289036 5351212 28.44
1.85 28.02 29.87 62312 5415912 5478224 29.74
0.93 28.99 29.92 62316 5542980 5605296 15.00
1.26 29.85 31.11 62380 5670096 5732476 20.17
0.59 30.62 31.21 62392 5797332 5859724 9.54
0.54 31.37 31.91 62432 5924572 5987004 8.71
0.58 31.55 32.13 62444 6051880 6114324 9.26
1.04 32.22 33.25 62508 6179228 6241736 16.59
0.41 33.37 33.78 62544 6306756 6369300 6.52
0.71 33.10 33.81 62540 6434260 6496800 11.42
0.31 33.10 33.41 62516 6561800 6624316 4.89
0.07 34.00 33.93 62552 6689324 6751876 1.09
0.26 33.56 33.81 62540 6816840 6879380 4.08
0.17 33.66 33.83 62540 6944360 7006900 2.72
0.29 33.59 33.88 62544 7071888 7134432 4.62
0.17 34.44 34.27 62568 7199464 7262032 2.72
0.14 34.02 33.88 62544 7327044 7389588 2.17
0.31 33.61 33.92 62548 7454564 7517112 4.89
0.17 34.07 33.90 62548 7582136 7644684 2.72
0.27 33.61 33.88 62544 7709656 7772200 4.35
0.25 33.66 33.92 62548 7837184 7899732 4.08
0.27 33.66 33.93 62548 7964720 8027268 4.35
0.17 33.64 33.47 62520 8092252 8154772 2.72
0.32 33.61 33.93 62544 8219764 8282308 5.16
0.71 33.63 34.34 62568 8347292 8409860 11.41
0.27 33.61 33.88 62548 8474896 8537444 4.

Ho mosso un pannello davanti al sensore, allontanandolo con velocità costante ma non pare proprio che venga fuori così costante… dove sbaglio? Grazieee e buone feste

docdoc:
... per realizzare un moto circolare accelerato ...

Della serie, motore con regolatore di velocita' a rampa controreazionato, con un disco (o una barra) sull'asse ed un piolo (bilanciato) sul bordo ? ... dove il piolo sarebbe l'oggetto da misurare ... ma servirebbero comunque misure sui due assi, se non ricordo male ...

ora tu fai 2 misurazioni rilevando tempi e distamze
prova a rilevare la distanza ad internvalli uguali di tempo.
occhio però che la risoluzione è di circa 3 millimetri e nell'elenco postato sono poche le letture che hanno più di 3 millimetri di differenza

tra l’altro la colonna t2-t1 da un valore che è sempre in crescita cioè la 69ima coppia di letture impiega 2548 (62548 - delay(60) ) micros mentre la prima coppia 684 (60684- delay(60)) micros cosa che non dovrebbe essere
un’altra cosa, nella sonicRead trovo

  if(distance >0 && distance <50){
    return distance;
  }

perchè limiti il campo di misura da 1 a 49cm?

Io sono promotore della campagna "buttate gli HC-SR04 e usate sempre gli SRF05"!
Ho usato almeno 4 o 5 SR04 e con TUTTI ho avuto problemi, o di affidabilità della lettura o, peggio, di "addormentamento" delle letture. Con gli SRF05 invece mai nessun problema (con l'ovvia eccezione delle normali tolleranze di sensori cinesi).

Detto questo, oltre a provare un SRF05, direi che non puoi fare rilevamenti troppo ravvicinati, ed accettare una tolleranza (variazione random) di misurazione di un 5% (valore che comunque dipende anche dalla forma dell'oggetto e dalla sua velocità di spostamento).

docdoc:
… velocità di spostamento).

Ecco, questo potrebbe influire anche di molto usando frequenze audio o ultrasuoni … l’effetto Doppler aumenterebbe la frequenza con oggetti in avvicinamento e la ridurrebbe con oggetti in allontanamento, e se tale variazione portasse le frequenze riflesse al di fuori della frequenza di risonanza della capsula ricevente, la sensibilita’ del sistema potrebbe peggiorare di molto …

Parliamo comunque di velocita’ abbastanza alte …

Etemenanki:
l’effetto Doppler aumenterebbe la frequenza con oggetti in avvicinamento e la ridurrebbe con oggetti in allontanamento

Vero, parlando in generale, la precisione dipende, come ho detto, non solo dalla velocità (e dalla direzione del moto rispetto al ping sonoro) ma anche dalla forma e dimensione del bersaglio. Se ad esempio volessi rilevare un parallelepipedo dalle facce molto lisce, se questo si presentasse di spigolo (quindi 2 facce a 45 gradi rispetto al sensore) rischierei di non “vederlo” proprio in quanto il suono verrebbe deflesso verso l’esterno e non tornerebbe quasi per nulla al sensore, tanto più se l’oggetto fosse piccolo. poi ci sono anche situazioni ambientali che possono influenzare il rilevamento come pareti o altri oggetti attorno al bersaglio.

Per cui la precisione di un sensore ad ultrasuoni, soprattutto questi “cinesi”, è sempre da prendere con le molle se si desiderano misurazioni molto ravvicinate, o di oggetti piccoli, o di forme particolari potrebbe avere una bassa o nulla affidabilità.

Tornando al progetto in questione:

marcorizzinelli:
Ciao, ritorno su questo topic aperto tempo fa perché finalmente ho tra le mani uno sketch per la velocità di un corpo in moto rettilineo e non capisco cosa sto sbagliando… Per ora gli esperimenti di misurazione della posizione con sensori a ultrasuoni e plottaggio in tempo reale del diagramma orario funzionano bene (anche se solo con IDE su Windows… per ora spero) ma questo sketch che coinvolge ancora il solito hcsr04 (che funziona bene) mi fa ottenere valori di velocità molto variabili anche se non attesi.

Non so quali oggetti con moto uniforme o uniformemente accelerato tu stia considerando, ma diciamo che saranno (spero) delle palline metalliche su un piano più o meno inclinato, per cui una sfera si riesce abbastanza bene a rilevare purché appunto non sia troppo distante dal sensore.

Per il listato che hai mostrato, vedo che fai due letture e dalla loro differenza ricavi la velocità. Per prima cosa direi che le letture così ravvicinate non sono il massimo, io lascerei un minimo delay tra una coppia di letture e la successiva (credo che tra 5 e 10 letture al secondo siano sufficienti per un progetto didattico, quindi un delay 100 o 200). Se parliamo di basse velocità come in un piano inclinato di poche decine di cm non è necessario spingere la risoluzione della misura. D’altronde Galileo faceva queste cose con dei campanellini…:wink: Tu nelle due letture leggi i micros() e con questi calcoli il tempo: sinceramente non credo che sia necessaria una risoluzione di microsecondi, tanto più se si considera che il suono emesso dalla prima sonicRead() è ancora “in viaggio” e rimbalzando in qualsiasi oggetto dell’ambiente rischia di venir rilevato dal secondo sonicRead().

Servono almeno 30-40 millisecondi per avere la quasi certezza di non rilevare echi spuri, per cui metterei un piccolo delay anche tra le due letture. Anzi, io farei una prima lettura, delay di almeno 50 ms, seconda lettura, calcolo distanze e velocità, e poi delay di 150ms per avere un totale di 5 campioni al secondo, secondo me più che sufficienti per lo scopo prefissato. D’accordo che tutte le Serial.prin() che hai messo impiegano del tempo, ma io preferisco controllare meglio i tempi.

Pioi la if(t1 < t2) a che serve? Due letture di micros() sono sempre sequenziali, che hai una macchina del tempo? :slight_smile:

Insomma, una cosa del tipo:

void loop()
{
  float distance1 = sonicRead();
  unsigned long t1 = micros();
  delay(50);
  float distance2 = sonicRead();
  unsigned long t2 = micros();
  float speed = abs(distance2 - distance1) * 1000000.0 / (t2 - t1);

  Serial.print(abs(distance2-distance1));
  Serial.print(" ");
  Serial.print(distance1);
  Serial.print(" ");
  Serial.print(distance2);
  Serial.print(" ");
  Serial.print(t2-t1);
  Serial.print(" ");
  Serial.print(t1);
  Serial.print(" ");
  Serial.print(t2);
  Serial.print(" ");
  Serial.println(speed);
  
  delay(150);
}

Etemenanki:
Della serie, motore con regolatore di velocita' a rampa controreazionato, con un disco (o una barra) sull'asse ed un piolo (bilanciato) sul bordo ? ... dove il piolo sarebbe l'oggetto da misurare ... ma servirebbero comunque misure sui due assi, se non ricordo male ...

Ciao, le rotazioni le tratteró più avanti, grazie cmq degli spunti.

Patrick_M:
ora tu fai 2 misurazioni rilevando tempi e distamze
prova a rilevare la distanza ad internvalli uguali di tempo.

Ciao, non ho proprio idea di come fissare tempi uguali... Tra l'altro se ci riuscissi potrei emulare Galileo cercando la serie dei numeri dispari sugli spostamenti...

Ciao, concordo con tutte le persone che mi hanno indicato attenzione a non prendere troppe misure ravvicinate, causa limiti dello strumento. Grazie ci provo e magari faccio sapere, per curiosità, se questo risolve il problema.

Inoltre anche io ho iniziato a usare gli srf05 però finché funzionano userò, ancora, anche gli hcsr04.

Patrick_M:
tra l’altro la colonna t2-t1 da un valore che è sempre in crescita cioè la 69ima coppia di letture impiega 2548 (62548 - delay(60) ) micros mentre la prima coppia 684 (60684- delay(60)) micros cosa che non dovrebbe essere
un’altra cosa, nella sonicRead trovo

  if(distance >0 && distance <50){

return distance;
  }



perchè limiti il campo di misura da 1 a 49cm?

Ciao, come mai aumenta il deltat? Non me n’ero proprio accorto…

Il limite dei 50 (a volte uso 80 o 100) mi serve didatticamente per avere un buon effetto visivo col serial plotter alla LIM in aula, infatti la portata delle ordinate non eccede se per errore il sensore perde la misura dell’oggetto in moto (a volte mi trovavo dei picchi di 200 cm e si schiacciava molto il grafico, divenendo inutilizzabile). Dite che è un problema?

secondo me dipende dal codice,
come ti dicevo io prenderei un valore fisso di millisecondi e allo scadere del tempo farei la lettura, ad esempio 1 lettura ogni 200 o 300 millisecondi
quindi imposti una variabile (es: intervallo=200) con i millisecondi di attesa
alla fine del setup memorizzi il tempo (es: inizio=millis())
poi nel loop controlli
se (millis() -inizio >= intervallo)
esegui la lettura
memorizzi valore in array
inizio =millis() // nuovo valore di inizio conteggio
fine se
trascorsi n secondi oppure quando hai accumulato n letture esegui tutti i calcoli e la visualizzazione dei risultati

Parlando di effetto Doppler l’ho trascurato a priori ipotizzando velocità basse del corpo in moto…

Per le forme uso sfere (anche se non metalliche) e cilindri.

Infine per il t1 < t2 lo uso perché a volte mi escono tempi uguali e velocità con valore “Inf”… Mah cmq devo proprio inserire dei delay appropriati e usare millis().

Patrick_M:
secondo me dipende dal codice,
come ti dicevo io prenderei un valore fisso di millisecondi e allo scadere del tempo farei la lettura, ad esempio 1 lettura ogni 200 o 300 millisecondi
quindi imposti una variabile (es: intervallo=200) con i millisecondi di attesa
alla fine del setup memorizzi il tempo (es: inizio=millis())
poi nel loop controlli
se (millis() -inizio >= intervallo)
esegui la lettura
memorizzi valore in array
inizio =millis() // nuovo valore di inizio conteggio
fine se
trascorsi n secondi oppure quando hai accumulato n letture esegui tutti i calcoli e la visualizzazione dei risultati

Capito, ci provo.

Riciao, ecco qui con l’SRF05 cosa mi esce (t1, t2, deltat, s1, s2, deltas, v, errore percentuale, assoluto)

1505.00 1756.00 0.25||||||8.52 11.98 3.47||||||||||||13.81 17.31% 2.39
2016.00 2267.00 0.25||||||16.12 21.66 5.53||||||||||||22.05 10.84% 2.39
2528.00 2781.00 0.25||||||26.36 32.05 5.69||||||||||||22.49 10.55% 2.37
3042.00 3295.00 0.25||||||37.41 42.98 5.57||||||||||||22.01 10.77% 2.37
5103.00 5356.00 0.25||||||46.28 41.74 4.53||||||||||||-17.92 13.23% 2.37
5618.00 5871.00 0.25||||||36.90 32.41 4.48||||||||||||-17.72 13.38% 2.37
6133.00 6385.00 0.25||||||26.86 21.86 5.00||||||||||||-19.84 12.00% 2.38
6646.00 6897.00 0.25||||||16.78 12.74 4.03||||||||||||-16.07 14.87% 2.39
7158.00 7409.00 0.25||||||7.22 3.47 3.76||||||||||||-14.97 15.96% 2.39
9172.00 9423.00 0.25||||||3.60 9.02 5.41||||||||||||21.57 11.08% 2.39
11746.00 11998.00 0.25||||||42.48 16.21 26.28||||||||||||-104.27 2.28% 2.38
16777.00 17029.00 0.25||||||13.47 24.97 11.50||||||||||||45.63 5.22% 2.38
17293.00 17546.00 0.25||||||42.36 52.22 9.86||||||||||||38.98 6.08% 2.37
19838.00 20091.00 0.25||||||50.38 43.47 6.91||||||||||||-27.33 8.68% 2.37
20356.00 20606.00 0.25||||||31.79 18.98 12.81||||||||||||-51.24 4.68% 2.40
20870.00 21121.00 0.25||||||9.47 4.09 5.38||||||||||||-21.43 11.15% 2.39
24395.00 24648.00 0.25||||||20.07 23.29 3.22||||||||||||12.74 18.61% 2.37
24910.00 25163.00 0.25||||||26.69 29.91 3.22||||||||||||12.74 18.61% 2.37
26438.00 26692.00 0.25||||||45.00 48.72 3.72||||||||||||14.66 16.11% 2.36
26956.00 27210.00 0.25||||||51.74 55.78 4.03||||||||||||15.88 14.87% 2.36
28525.00 28779.00 0.25||||||55.28 51.34 3.93||||||||||||-15.48 15.26% 2.36
29550.00 29803.00 0.25||||||40.12 37.07 3.05||||||||||||-12.06 19.66% 2.37
31077.00 31329.00 0.25||||||24.64 21.62 3.02||||||||||||-11.97 19.89% 2.38
31592.00 31843.00 0.25||||||16.16 12.02 4.14||||||||||||-16.49 14.50% 2.39
32106.00 32357.00 0.25||||||7.59 4.45 3.14||||||||||||-12.50 19.12% 2.39

e con l’HCSR04

502.00 754.00 0.25||||||12.98 19.66 6.67||||||||||||26.48 8.99% 2.38
1012.00 1264.00 0.25||||||25.81 33.86 8.05||||||||||||31.95 7.45% 2.38
2548.00 2800.00 0.25||||||31.91 26.17 5.74||||||||||||-22.78 10.45% 2.38
3062.00 3313.00 0.25||||||20.40 13.69 6.71||||||||||||-26.72 8.95% 2.39
3573.00 3824.00 0.25||||||7.19 3.86 3.33||||||||||||-13.26 18.03% 2.39
4585.00 4839.00 0.25||||||20.31 48.26 27.95||||||||||||110.03 2.15% 2.36
6114.00 6365.00 0.25||||||23.50 5.69 17.81||||||||||||-70.96 3.37% 2.39
7628.00 7879.00 0.25||||||7.47 11.83 4.36||||||||||||17.38 13.75% 2.39
8138.00 8391.00 0.25||||||19.66 26.84 7.19||||||||||||28.42 8.35% 2.37
8651.00 8903.00 0.25||||||31.60 37.26 5.66||||||||||||22.44 10.61% 2.38
9165.00 9419.00 0.25||||||46.26 50.28 4.02||||||||||||15.82 14.94% 2.36
9681.00 9935.00 0.25||||||56.91 59.97 3.05||||||||||||12.01 19.66% 2.36
10729.00 10984.00 0.25||||||64.84 61.67 3.17||||||||||||-12.44 18.91% 2.35
11249.00 11502.00 0.25||||||51.43 42.53 8.90||||||||||||-35.16 6.74% 2.37
12270.00 12522.00 0.25||||||26.64 21.10 5.53||||||||||||-21.96 10.84% 2.38
12785.00 13036.00 0.25||||||16.09 11.84 4.24||||||||||||-16.90 14.15% 2.39
13299.00 13550.00 0.25||||||5.22 1.93 3.29||||||||||||-13.12 18.22% 2.39

associato al moto del contenitore di Arduino UNO, con la mia mano. Ecco lo sketch:

const int trigPin = 2;
const int echoPin = 4;
float tempo_onda, t1, t2, deltat, s1, s2, deltas, v, perc, err;

void setup() { 
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
} 

void loop() {
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigPin, LOW); 
  tempo_onda = pulseIn(echoPin, HIGH);
  t1 = millis();
  s1 = tempo_onda / 29 / 2;

  delay(250);
  
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigPin, LOW); 
  tempo_onda = pulseIn(echoPin, HIGH);
  t2 = millis();
  s2 = tempo_onda / 29 / 2;

  delay(250);
  
  deltat = (t2 - t1)/1000;
  deltas = abs(s2 - s1);
  v = deltas/deltat;
  perc = 0.60/deltas * 100 ; 
  err = 0.60/deltas * v ;
  
  if(s1>0 && s1<100 && s2>0 && s2<100 && deltas>3){
    Serial.print(t1);
    Serial.print(" ");
    Serial.print(t2);
    Serial.print(" ");
    Serial.print(deltat);
    Serial.print("||||||");
    Serial.print(s1);
    Serial.print(" ");
    Serial.print(s2);
    Serial.print(" ");
    Serial.print(deltas);
    Serial.print("||||||||||||");
    if(s1>s2){
      Serial.print("-");
    }
    Serial.print(v);
    Serial.print(" ");
    Serial.print(perc);
    Serial.print("%");
    Serial.print(" ");
    Serial.println(err);
  }
}

Mi tocca usare una precisione massima del 20% su spazio percorso e velocità (ipotizzo che il tempo abbia errore trascurabile) per avere un po’ di misure…

Il testing su piano inclinato con i corpi che vi avevo citato lo farò appena posso.

Ora come ora direi che sono migliorate alcune cose. Voi che ne dite?

marcorizzinelli:
Riciao, ecco qui con l’SRF05 cosa mi esce (t1, t2, deltat, s1, s2, deltas, v, errore percentuale, assoluto)

1505.00 1756.00 0.25||||||8.52 11.98 3.47||||||||||||13.81 17.31% 2.39

Ora come ora direi che sono migliorate alcune cose. Voi che ne dite?

Si, però provo a capire meglio, vediamo.

Intanto, soprattutto se per scopo didattico, meglio se cerchi di commentare i vari passi così si capisce esplicitamente cosa intendi fare o calcolare :slight_smile: Inoltre direi di programmare un poco più a blocchi (es. perché hai tolto la sonicRead??).

  1. 250 ms mi sembrano eccessivi, di fatto stai facendo solo 2 campioni al secondo, se per evitare rimbalzi dall’ambiente circostante consideri un timeout diciamo di 20.000 us che corrispondono a circa 6 metri) puoi considerare questo come valore limite minimo tra misurazioni, ossia 20 millisecondi. Per stare tranquilli direi che bastano anche 50, se vuoi diminuire il flusso dati per qualche motivo metti 100 (magari parametrizza il valore in una #define).

  2. perché fai abs(s2-s1)? Di fatto così equipari l’avvicinamento (s2 < s1) all’allontanamento (s2 > s1). Direi che l’esperimento dovrebbe prevedere solo un allontanamento, quindi s2 sarà sempre maggiore di s1.

  3. Tu leggi anche gli istanti tra un ping ed il successivo, ma (come si nota anche dell’output) è inutile in quanto corrisponderà al delay() che imposti tu tra le due letture (la differenza sarà eventualmente dei pochi microsecondi della lettura).

  4. Anche “perc” ed “err” non li ho capiti. Con “perc” calcoli l’inverso della percentuale dello spazio percorso nell’intervallo (deltas) rispetto a 0.60 cm? A cosa serve? E mettili 'sti commenti!..:slight_smile:

  5. Per finire non ho ben capito il punto in cui mandi l’output solamente se deltas>3: perché ignori spostamenti (assoluti tra l’altro) di meno di 3 cm?

Quindi io farei una cosa del genere (modificata/scritta al volo, verifica tu):

const int trigPin = 2;
const int echoPin = 4;
float deltat, s1, s2, deltas, v, perc, err;

// Intervallo tra letture (millisecondi)
#define DELAY 100

void setup() { 
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
} 

void loop() {
  // Prima lettura
  s1 = sonicRead();
  // Pausa tra prima e seconda lettura
  delay(DELAY);
  // Seconda lettura
  s2 = sonicRead();
  // Pausa finale
  delay(DELAY);
  
  // Se le letture sono entrambe "buone" procedo
  if(s1>0 && s2>0){
    // Calcolo i valori che m interessa tracciare
    calcolaValori();
    // Mando i dati sulla seriale
    scriviRisultati();
  }
}

// Lettura della distanza in cm
float sonicRead() {
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigPin, LOW); 
  float tempo_onda = pulseIn(echoPin, HIGH);
  return tempo_onda / 29 / 2;
}

// Calcolo dei valori, e loro memorizzazione nelle variabili globali
void calcoloValori() {
  // Calcolo il deltaT (equivale al DELAY) e deltaS
  deltat = DELAY;
  deltas = (s2 - s1);
  // La velocità sarà deltaS/deltaT 
  // (positiva per allontamenti, negativa per avvicinamenti)
  v = deltas/deltat;
  // Percentuale ed errore (?)
  perc = 0.60/deltas * 100 ; 
  err = 0.60/deltas * v ;
}

// Output dei risultati
void scriviRisultati() {
  //if(deltas>3){
  Serial.print(t1);
  Serial.print(" ");
  Serial.print(t2);
  Serial.print(" ");
  Serial.print(deltat);
  Serial.print("||||||");
  Serial.print(s1);
  Serial.print(" ");
  Serial.print(s2);
  Serial.print(" ");
  Serial.print(deltas);
  Serial.print("||||||||||||");
  if(s1>s2){
    Serial.print("-");
  }
  Serial.print(v);
  Serial.print(" ");
  Serial.print(perc);
  Serial.print("%");
  Serial.print(" ");
  Serial.println(err);
}

Però per capire l’affidabilità del codice per prima cosa dovresti provarlo con un oggetto fermo per capire la stabilità della misura ovvero la tolleranza massima intrinseca, possibilmente a varie distanze. Poi una volta capito e calibrata la lettura per la tolleranza, almeno con un moto rettilineo uniforme, non la scatola di Arduino mossa a mano :slight_smile: