Programmation Calcul Acceleration

International Français
1

Bonjour,

J'ai besoin d'aide pour une methode d'approche a envisager pour acquerir correctement l'acceleration d'un mobile.

Je réalise un compteur, sur lequel j'acquiere la "vitesse moyenne" V=D/t / distance / et chrono
en me servant simplement des interruptions et de millis.

La partie "compteur" standart est operationnel.
Le chrono est realisé en utilisant millis() (secondes/minutes/heures)
Les données de vitesses et de distances sont acquises par un capteur IR qui compte les trous de disque. (en l'occurence, sur un disque de frein, par simplicitée de réalisation).
j'ai un disque de 7 trous.

ma fonction d'interruption est un simple "trouDistanceAccel++;"
remis a zero par interval regulier.
je chope la distance avec le temps et le perimetre de ma roue...

je voudrais maintenant pouvoir acquerir l'acceleration dans le but de pouvoir ensuite calculer ma Force de deplacement (F=ma), et en deduire mon couple a la roue.

problèmes:

en utilisant les formules de MRU-MRUV:

D=1/2A.t² + V0.t ==> A=2(D-V0.t)/t² ou A= V1²-V0²/2D
V1=A.T+V0

J'ai des retours de variable definies en float comme INF(infini) ou NAN (not a number)
(utilisation de 0² quand V=0 et utilisation de la division par t²=0 en phase d'initialisation)

Ce problème "semble" "s'estomper" a partir du moment ou j'augmente mes temps de prises de references / reinitialisation des variables. Je considere que cela est du au fait de laisser le temps de rentré des valeurs superieur à 0.

hors, j'aimerais pouvoir incrementer mes retours de valeur avec plus de precision.
(interval plus court dans les prises de valeur pour les calculs, mais impossible pour le moment à cause des retours "INF" et "NAN")
J'imagine que la phase d'acceleration par rapport à la prise de vitesse doit avoir une forme de courbe "en cloche", au debut l'acceleration croit rapidement, ensuite elle à tendance a decroitre jusqu'a V=Constante. (Vconstante <=>accel =0)

Je ne sais pas si les formules de MRU-MRUV sont approprié pour ce que je veux, puisque l'acceleration evolue.

La mise en programme est surement a approché avec finesse.

Si vous avez des idées là dessus, je suis vraiment preneur.

Ce que je voudrais, c'est des retours instantanés de valeur d'accel.

en gros, Accel de 0.01 jusqu'a 5 ou 10(Whouaaaa le G!!)...par les increments de 0.01 (je reve là :D) de V0 à Vmax..

Je ne vois plus comment aborder ça suite a de nombreux essais.
(ne me demander pas le/les prog, je me suis enervé j'ai tout effacé mes betises pour reprendre une futur feuille blanche...).

Je pense qu'une nouvelle approche sera vraiment benefique.

Merci d'avance pour vos retours.

Cordialement, Deut's.

4

Je commencerais par bien nommer les variables : trouDistanceAccel devrait s'appeler cptTrous et la variable distance, si elle est utile, serait calculée par

distance = cptTrous / TROUS_PAR_TOUR * PERIMETRE_ROUE;

ce qui te permettrait de ne pas dire :

car le temps n'intervient pas ici.

Poste ton nouveau code et on devrait pouvoir te dire où ça coince.
Par contre, pour avoir plus de précision, plutôt que de compter les trous, je mémoriserais le compteur de temps à chaque interruption 'trou', quitte à utiliser micro() au delà d'une certaine vitesse...

5

Bonjour Etienne_74

dans l'absolu pour compter seulement la distance, je suis d'accord avec toi.

ma fonction de base pour acquerir la distance est celle là, en effet, elle ne tient pas compte du temps. par contre, elle est "independante". elle compte les metres et les KM.
les Km sont retourner par une autre fonction qui recupere indexKm_h.

unsigned int distanceM() {

  unsigned int copyTrousDistance=trousDistance; //je copie le nombre de trous
  trousDistance=0; // je réinitialise pour l'attachinterrupt
  totalTrousDistance += copyTrousDistance; //je totalise
 
  float milleMetre = ((totalTrousDistance/nbTrousDisk) * perimetreRoue)+ resteDeMilleMetre ; //je calcul en tenant compte du depassement
 
    if(milleMetre>=1000){
      indexKm_h++;

      #ifdef DEBUG1
      //Serial.print("indexKm_h:");
      //Serial.print(indexKm_h);
      //Serial.println();
      #endif DEBUG1
      
      resteDeMilleMetre = milleMetre - 1000;

      #ifdef DEBUG1
      //Serial.print("resteDeMilleMetre:");
      //Serial.print(resteDeMilleMetre);
      //Serial.println();
      #endif DEBUG1
      
      totalTrousDistance=0 ;
         
    }

  return(milleMetre);
  
}

J'ai une autre fonction du meme genre, que je reset avec une autre fonction suivant certaines condition (ex: si D=100m => reset des trous):

unsigned int distanceChrono(){
      
       unsigned int distanceChrono = ((trousDistanceChrono/nbTrousDisk) * perimetreRoue); 
       return (distanceChrono);        
}

bref,

Je me sers juste d'une variable en plus dans mon attachinterrupt, le fameux ''trouDistanceAccel++;", le nom des variables peut etre remis en question, mais je ne pense pas que ce soit le vrai "souci"

Dans ma fonction d'accel, c'est pas seulement la distance qu'il me faut.
j'ai besoin du temps, et, en dessous d'un interval d'une seconde, ça part en cahuete.

j'ai pensais en effet a augmenter le NB de trou via un autre disque, et j'ai songé egalement a micro(), mais pour l'instant, je crois qu'il faut surtout que je comprenne. (apres, je devrais pouvoir plus facilement ameliorer...)

Pour donner une idée, (je sais que c'est pas bon, pas tapé!!) voici un des codes que j'avais sauvegardé dans les nombreux test que j'ai fais, ça peut donner une idée de comment je m'y prend mal.. (c'est à jeter, ça marche pas comme je veux!!)

bool conditionDemarrageReleveeAcceleration(){ //initialise les variables d'entrée dans la fonction getAcceleration

     trousDistanceAcceleration=0; 
     lastAccelMillis=millis();
     vitesseInitiale=0; //ajout test
     vitesseFinale=0;
     //copyTrouDistanceAcceleration=0;
     //totalTrouDistanceAcceleration=0;
     //conditionPremiereAcceleration=true; // permet de rentrer dans la premiere boucle d'acquisition de getAcceleration
     
     //la fonction doit etre encadrer par le fait quelle est toujours active tant que la vitesse est à 0km/h
}




float getAcceleration(){
       
            

     static unsigned long lastAccelMillis; 
     unsigned long currentAccelMillis = millis(); //reference temporelle    
     const unsigned long intervalAcceleration = 1000; // definition de l'interval de mesure entre deux prise de valeur   
  
   
      if(currentAccelMillis - lastAccelMillis >= intervalAcceleration){

         distanceAcceleration = ((trousDistanceAcceleration/nbTrousDisk) * perimetreRoue);
         trousDistanceAcceleration=0;//reset l'attache interrupt pour relever prochaine valeur au plus rapidement dans la boucle
         tempsAcceleration = (currentAccelMillis - lastAccelMillis)/1000;//on enregistre le temps dans une variable, on divise par 1000 pour avoir le temps en seconde
         lastAccelMillis = millis();//reset le temps! sort de la boucle jusqu'a prochain intervalAcceleration
         vitesseFinale = distanceAcceleration/tempsAcceleration; //c'est pas bon.il s'agit de la vitesse moyenne //ce passage devrait utilisé Vf=a.t + V0 et l'acceleration devrait etre calculer avant la vitesse. c'est juste a cause de l'utilisation de l'autre forme de la formule.
         
           

         #ifdef DEBUG1   //print avant le RAZ pour precision des donnée lues
         Serial.print("distance Accel=");
         Serial.print(distanceAcceleration);  
         Serial.println("");
         Serial.print("temps Accel=");
         Serial.print(tempsAcceleration);
         Serial.println("");
         Serial.print("V0:"); 
         Serial.print(vitesseInitiale); 
         Serial.println("");
         Serial.print("V1:");
         Serial.print(vitesseFinale);  
         Serial.println("");    
         #endif DEBUG1

         V1carre = (vitesseFinale*vitesseFinale);
         V0carre = (vitesseInitiale*vitesseInitiale);
         Deux = 2.00001;//test pour retour autre que NAN ou INF

         #ifdef DEBUG1 
         Serial.print("V1carre:"); 
         Serial.print(V1carre); 
         Serial.println("");
         Serial.print("V0carre:");
         Serial.print(V0carre);
         Serial.println("");
         #endif DEBUG1 
         
         acceleration = (V1carre - V0carre)/(Deux*distanceAcceleration);  
         
         //acceleration = (vitesseDeux-vitesseUne) / tempsAcceleration;//acceleration moyenne
         
         vitesseInitiale = vitesseFinale; // vitesseDeux deviens vitesseUn pour prochain calcul

         if(vitesseInitiale == 0 && vitesseFinale ==0){ //passage pour contré le probleme de NAN en retour d'operation 0/0 de calcul acceleration.

          #ifdef DEBUG1
          Serial.print("jepasseici");
          Serial.println("");
          #endif DEBUG1
          acceleration=0;
         }
         
         #ifdef DEBUG1
         Serial.print("Accel=");
         Serial.print(acceleration);  
         Serial.print("M/s");
         Serial.println("");
         #endif DEBUG1

         
         
         return (acceleration);
      }
         
       
}

Ce code est bidon! Par contre, merci pour ta reflexion. Elle me donne la possibilitée de penser differement.

Je ne vais pas avoir accés à ma maquette pendant une semaine pour faire des essais.
ça va me permettre de reflechir peut etre autrement a mon approche foireuse du truc.
Vos idées seront les bien venues pour me sortir du carcant dans lequel je me suis enfermer.

Bien à vous, et merci d'avance pour vos retours.

6

Le nom des variables est très important, en particulier sur un forum car, si toi tu t'y es habitué, les lecteurs qui découvrent ton code ont besoin qu'ils soit "parlant" pour le comprendre sinon ils zappent.

Pour un calcul d'accélération, je ferais simple (code non testé) :

void setup() {
D0 = 0.0;
V0 = 0.0:
lastAccelMillis = millis(); // je déclare les variables de temps en "int64_t globales" plutôt que locales
}

void loop() {
  currentAccelMillis = millis();
  intervalMillis = currentAccelMillis - lastAccelMillis ; // pour ne faire ce calcul qu'une fois
  if(intervalMillis >= intervalAcceleration) {
    D1 = (cptTrous / nbTrousDisk) * perimetreRoue;
    dt = intervalMillis / 1000.0;
    V1 = (D1 - D0) / dt;
    D0 = D1;
    acceleration = (V1 - V0) / dt;
    V0 = V1;
    lastAccelMillis = currentAccelMillis ;
  }
}
7

J'essai au maximum qu'elles soient parlante. Mais la logique ne sera jamais la meme pour tout le monde. Ceci dit, je comprend ce que tu exprimes.

Juste une question, pourquoi en global pour les variables?
Je cherche a gagner de la place aussi...certaines sont en global pour pouvoir les initialiser quand j'ai besoin.

Pour ce qui est de ton code, merci, mais, il est bon pour l'obtention d'une acceleration moyenne (Amoy=Delta V / Delta t). Avec un calcul de vitesses moyennes. il tend vers le reel si Delta t tend vers 0. a condition d'avoir des V reel et non des Vmoyennes.
Deplus c'est vicieux, car, si l'acceleration deviens nulle. Vf =0. reste juste Vmoy...

Je ne te cacherais pas avoir essayer cette version "simple" si je puis dire...
Mais ce n'est pas ce dont j'ai besoin pour calculer la "vrai" Force du produit Masse * acceleration

Pour donner une idée par exemple, si j'ai bien tout compris:

On parcours 2m en 1s en partant de D=0 et t=0, l'acceleration est de 4m/s² et V à T=1s est de 4m/s.
La vitesse moyenne elle, est de 2m/s. On voit l'ecart important qui apparait. Parce que si on utilise l'acceleration moyenne, elle aussi sera de 2m/s² soit moitié moins importante que l'acceleration reel.

D= 1/2A.t² => A= 2D/t² si T et V initiale egal 0.

pour reprendre le point d'apres. il faut integrer V0.t dans le calcul precedent de l'acceleration.

D=1/2A.t² + V0.t (exactement, la formule, c'est X(t) = 1/2A.t²+V0.t+X0)

X(t)-X0 c'est D (pour distance) car X(t) c'est la distance réalisé et X0 la distance initiale. d'ou D(distance parcourue)=1/2A.t²+V0.t (comme l'expression de t qui est reelement, (t1-t0) pour temps finale - temps initiale)

On calcul Vf avec Vf = A.t + V0 mais dans le cycle de calcul suivant, V0=Vfprecedent...

les deux formules sont liées.

probleme en condition de depart, comment ce servir d'autre chose que de Vmoy si on connait pas A?

Comment extrapoler la Vitesse instantanée de la vitesse moyenne sans tenir compte de l'accel??

La Vmoyenne en tant que V0 est elle acceptable pour le calcul?

Je ne veux pas me contenter de calculer l'accel en fonction de V, T ou de D. je veux obtenir l'acceleration dès qu'elle varie. et c'est là ou j'ai mon probleme d'integration du facteur "temps", parce que d'un instant à l'autre, l'acceleration peut enormement varier.
et des que je raccourcie mes temps de reference sous la seconde, j'ai des calculs a l'ouest.

Ton idée sur l'ecart entre trous est pas bete...

Une idée à laquelle je songe egalement, mais j'ai du mal a apprehender la justesse de ma vision du truc...

ex:

Je "lache" deux ancres de ref pour D et T en condition initiale egales a 0, j'ai un retour valable seulement en phase d'accel et/ou deccel tant que j'ai pas de rater de manip.
Je ne peux pas, par exemple, lacher la poignée un certain temps et repartir en ayant le bon retour de la vrai valeur d'acceleration a ce moment là, j'aurais un retour sur l'acceleration "GLOBALE" par rapport a mes conditions initiale ou j'ai mis mes ancres.

Comme dit precedement, ma courbe d'accel devrait avoir une allure de "cloche", par rapport a ma prise de vitesse (que la phase d'acceleration) quand V est croissant jusqu'a Vmax stable, où l'acceleration va etre egal à 0.

Tout mes essais jusqu'a present me fond obtenir des dents de scie...(ben oui, si VF=V0 => A=0) c'est la raison pour laquelle je pense que je m'y prend mal.

je cherche a obtenir quelque chose de plus precis et de plus "smooth" si je puis dire.

Merci en tout cas de t'interesser à mon probleme.

8

À vrai dire, c'est par paresse, j'initialise dans setup() et modifie dans loop() mais les déclarer localement en Static est sûrement plus judicieux...

Tu n'en sais rien, peut-être que l'accélération a été très forte puis que le moteur a calé ! Tout ce que tu sais (sans un accéléromètre pour confirmer), c'est que la roue a parcouru 2m. Entre deux échantillons, on ne connait pas la forme d'une courbe. Au mieux, on peut interpoler et extrapoler.

Sinon, la solution (sans accéléromètre), c'est de mesurer souvent. Et le plus souvent qu'il est possible de le faire, c'est à chaque nouveau trou/interruption.

Et au lieu d'avoir un temps (presque) fixe (­~1000ms), c'est la distance parcourue qui l'est (un septième de circonférence) et le temps est variable.

Mais le calcul reste le même, il est juste réalisé "le plus souvent possible" (au sens où "il est impossible de mesurer plus souvent").

Reste à vérifier que le temps entre 2 interruptions (à vitesse max) est suffisant pour faire le calcul...

9

Pas de soucis, simple curiosité. (pour les variables)

l''exemple que je t'ai donner pour l'accel, c'est juste un excercice type.

concernant les données a acquerir, justement, je peux caller... et là, le temps file, et l'accel sera jamais la meme, ni la bonne.

en parlant d'accelerometre, comment ça fonctionne ces bebetes? c'est a mon avis un bon exemple.

les bancs de puissance utilise un accelerometre et l'acceleration angulaire parce qu'on passe par le calcul d'inertie d'un mobile en rotation.

pour me simplifier la vie, je passe directement par le mobile en translation.

la forme de la cloche pour la courbe, c'est juste de la logique, vue que la courbe d'acceleration au depart a une forme de parabolle. ça me donne juste une idée des resultat que je dois obtenir.. si different, il y a un HIC.

je vais me pencher sur l'approche des trous, c'est interessant je pense.

avec mes resultats obtenu, instinctivement je me demander si il faudrait pas "plus de trous" pour retourner des valeurs autres que nan et inf.

mais je n'avais pas penser à l'approche T entre trou..

On vera ce que j'arrive a obtenir, en attendant, je suis tjr preneur d'idees.
Limite en mode "BrainStorming"!

10

Bonjour 2terium

Oui, pourquoi pas y inviter l'IA:wink:

(ce n'est pas essayé)

Cordialement
jpbbricole

11

Tout simplement parce que l ia..c trop facile. Je prefere comprendre.

1 Like
12

Salut.
On ne peut pas te donner tort. Si le forum ARDUINO devient une simple indirection vers ChatGPT, autant s'adresser directement à ChatGPT.

13

+1
Surtout, que tu réinitialises le timer même s'il n'y a pas de trou. De plus, tu ne sais pas si le trou a été détecté au début ou à la fin du timer (~1 000 ms) !
Dans l'idée, je corrigerais ton exemple comme ceci:

/*
>>  unsigned long currentAccelMillis; // déclaré en variable globale 
*
>>  currentAccelMillis = millis(); // dans la fonction d'interruption pour avoir millis() lors de la dernière détection
*
? ? tempsAcceleration = (currentAccelMillis - lastAccelMillis)/1000;
? au lieu de diviser un temps infime par 1000, pourquoi ne pas utiliser la distance en mm / temps en ms = m/s ?
*/

static unsigned long lastAccelMillis; 
//unsigned long currentAccelMillis = millis(); // référence temporelle    
// ne sert plus >> const unsigned long intervalAcceleration = 1000; // définition de l'intervalle de mesure entre deux prises de valeur   

//if(currentAccelMillis - lastAccelMillis >= intervalAcceleration){
if (trousDistanceAcceleration != 0){
    distanceAcceleration = ((trousDistanceAcceleration * perimetreRoue) / nbTrousDisk ); // périmètreRoue >> [en mm] // voir "?" ci-dessus
    tempsAcceleration = (currentAccelMillis - lastAccelMillis); // voir "?" ci-dessus
    trousDistanceAcceleration = 0; // reset de l'attache interrupt pour relever la prochaine valeur le plus rapidement possible dans la boucle
    //lastAccelMillis = millis(); // reset du temps! sort de la boucle jusqu'au prochain intervalAcceleration
    lastAccelMillis = currentAccelMillis; // le temps lors du dernier trou enregistré
    vitesseFinale = distanceAcceleration / tempsAcceleration; // ce n'est pas bon. Il s'agit de la vitesse moyenne // ce passage devrait utiliser Vf = a.t + V0 et l'accélération devrait être calculée avant la vitesse. C'est juste à cause de l'utilisation de l'autre forme de la formule.
    /// ...
}
14

Bonjour Charles_9999. Merci pour ton retour. En effet la forme et la condition basé sur les trous a l'air très pertinante. J'essayerais ça des que possible et je vous tiendrez au courant des resultats. Merci pour vos reflexions.

15

Bon messieurs, je ne comprend plus rien.

J'ai essayer la forme en m'y prenant comme le suggerer Charles_9999 et j'ai pu d'apres nombreux tests voir que l'approche etait interessante. mais j'ai des valeurs completement à l'ouest de la réalitée.

je ne sais pas ou je m'y prend mal, mais je vois clairement qu'il y a un gros probleme.

Je vous met le morceau de code, peut etre qu'a force d'avoir le nez dedans, je ne vois plus mes erreurs.

J'ai mis currentAccelMillis = millis() dans mon interruption.

float getAcceleration(){

      
         

      if(trousDistanceAcceleration !=0 ){

         unsigned int copyTrousDistanceAcceleration = trousDistanceAcceleration;
         trousDistanceAcceleration=0;//RAZ de la variable en interruption.

         tempsAcceleration = (currentAccelMillis - previousAccelMillis);  // on prend l'interval temporel
         previousAccelMillis = millis(); //on transvase le temps dans l'ancien temps pour le prochain calcul
         tempsAcceleration/=1000;// on convertie en secondes (facilite le calcul de vitesse ensuite.)
         
         totalAccelTime += tempsAcceleration; //on cumule les temps de prise d'acceleration (verif et test)          
         totalTrousDistanceAccel+=copyTrousDistanceAcceleration; //on cumule la distance d'acceleration (verif et test)
         
         distanceAcceleration= (copyTrousDistanceAcceleration/nbTrousDisk)*perimetreRoue;//calcul du delta distance en m

         
  
         #ifdef DEBUG1   
         //Serial.print("NbTrouAccel=");
         //Serial.print(totalTrousDistanceAccel);  
         //Serial.println("");
         Serial.print("distance Accel=");
         Serial.print(distanceAcceleration,6);  
         Serial.println("");
         #endif DEBUG1
                
         #ifdef DEBUG1   
         //Serial.print("temps Accel=");
         //Serial.print(totalAccelTime,6);
         //Serial.print("secondes");
         //Serial.println("");
         #endif DEBUG1

         
         
         
         //on calcul l'acceleration à partir de l'equation D=1/2 a.t² + V0.t => a= 2(D-V0.t) / t²
         acceleration= 2*(distanceAcceleration - ( vitesseInitiale*tempsAcceleration)) / pow(tempsAcceleration,2);

         #ifdef DEBUG1   
         Serial.print("tempsau²=");
         Serial.print(pow(tempsAcceleration,2),6);
         Serial.print("s²");
         Serial.println("");


         
         Serial.print("Acceleration=");
         Serial.print(acceleration,6);
         Serial.print("m/s²");
         Serial.println("");
         #endif DEBUG1

         
         //on calcul la vitesse finale de l'acceleration pour la prochaine valeur de vitesseInitiale
         
         vitesseFinale = (acceleration*tempsAcceleration)+ vitesseInitiale  ;
         

         #ifdef DEBUG1
         Serial.print("V0:"); 
         Serial.print(vitesseInitiale,6);
         Serial.print("m/s"); 
         Serial.println("");
         Serial.print("V1:");
         Serial.print(vitesseFinale,6);
         Serial.print("m/s");   
         Serial.println("");    
         #endif DEBUG1
    
       
         vitesseInitiale=vitesseFinale;
         
         
         return acceleration;   
    
      }  
      
}

les données renvoyées ne me conviennent pas, on voit un probleme de calcul de vitesse et lorsque je n'accelere pas, les vitesses changent ou evolue tout de meme.

on voit que les prise de distance est temps sont presque similaire sur l'imprime ecran et des ecart gigantesque de valeur d'acceleration.

capture retour serie 17-07-24
capture retour serie 17-07-24456×706 52.3 KB

Je suis pommé.

Merci d'avance pour vos retours.

16

hello, je ne suis pas chez moi. mais lorsque tu avais ouvert ton post, j'avais regardé le problème
et j'en étais arrivé à ce code, veux tu le tester

float acceleration = 0;
float cptTrous = 0.0;
float nbTrousDisk = 7.0;
float perimetreRoue = 2000000; //µ **mettre mettre le perimetre exact en microns**
const unsigned long distance_parcourue = perimetreRoue / nbTrousDisk;
unsigned long t0 = micros();
unsigned long t1 = micros();

unsigned long temps_passe = 0;
unsigned long memo_temps_passe = 0;
void isr() {
  cptTrous++;
  t1 = micros();
}
void setup() {
  Serial.begin(250400);
  cptTrous = 0;
  attachInterrupt(0, isr, RISING);
  t0 = micros();
}

void loop() {
  if (cptTrous > 0) {
    temps_passe = t1 - t0; cptTrous = 0; t0 = t1;
    if (temps_passe != memo_temps_passe)
    {
      memo_temps_passe = temps_passe;
      acceleration = distance_parcourue / temps_passe;
      Serial.println(acceleration);
    }
    else {
      acceleration = 0;
    }
  }
}

nota: les Serial. print faussent les résultats.
moins tu en mets, mieux c'est.
donc inutile d'écrire du texte suivi de la variable.
tu ecris seulement la variable, à toi de savoir ce qu'elle représente

dans mon code, je n'ai mis qu'un seul Serial.print de variable, et il est de trop...il doit bien fausser le résultat de temps en temps.

17

Ça ressemble plus à une formule de vitesse que d'accélération. Non ?

18

hello Lesept
accel=delta de d/delta de t

distance parcourue est = périmètre / nb total de trous et comme on à une interruption à chaque trou suivie d'un calcul, delta de d = constante 1/7 du périmètre.
temps passé est le temps en µ secondes entre deux interruptions. donc c'est delta de t.

je me plante ?
edit:
oups, après vérification j'ai bouffé la fin de la formule

image
image1315×183 20.2 KB

bon, reste plus qu'à multiplier par la vitesse

19

Non. Tu ne te plantes pas je crois. Mais comme le suggerer etienne. C est utiliser la formule de l acceleration moyenne avec un delta V sur dt qui tend vers zero. C est peut etre plus facile a utiliser. Je ne sais pas encore vue que mon probleme c est d integrer la vitesseinitiale dans mon champ de deux equations du MRUA.

20

Bonjour

Je le voyais plus simplement,
mais je me trompe peut-être ?

  • temps_passe est en secondes
  • distance_parcourue est en mètres
  • vitesseT1 est la vitesse mesurée à l'instant T1
  • ( dateHeure_T2 - dateHeure_T1 ) est en secondes
  • acceleration est en m/s² (mètres par seconde au carré)

vitesseT1 = distance_parcourue / temps_passe
vitesseT2 = distance_parcourue / temps_passe

acceleration = ( vitesseT2 - vitesseT1 ) / ( dateHeure_T2 - dateHeure_T1 )