Sciences & Technologies

Yo yo yoo,

Je ne m'y connait pas des masses (yes) en physique, alors je viens chercher des pistes à mon problème, pardonnez mon vocabulaire s'il n'est pas très scientifique ou approximatif.
Je bosse actuellement sur un programme qui simule des lois de physique, voici ce que j'ai :
- 2 images -> l'une est un cercle plein qu'on va appeler Manche, l'autre un corps long dont l'une des extrémités est au centre du cercle qu'on va appeler Lame; l'image une est devant l'image deux laissant apparaitre 2/3 du corps long. Dans la vraie vie, ce serrait un handspinner à une seule branche.
- 2 origines -> l'un est le point de rotation de la Lame qui est situé à l'extrémité qui est au centre du cercle plein, on va l'appeler Om et l'autre est le point au centre du Manche, qu'on va appeler Ol, ces deux points étant égaux entre eux et au point de la position de la souris sur l'écran, qu'on va appeler Ps.
- 1 angle -> qui est la position angulaire de la Lame à un instant t (t étant égal au temps écoulé du programme), que j'appellerais Pal avec, donc, comme point d'origine de rotation Om, ce qui fait que, dans le programme, lorsque l'on augmente de 1 la valeur Pal à chaque fois que le t augmente, Lame fait une rotation en Om dans le sens des aiguilles d'une montre et inverse si l'on diminue la valeur.
Tout ça en vu du dessus.

L'idée étant que : lorsque je déplace le Manche (en déplaçant ma souris donc), la Lame doit effectuer une rotation physiquement correcte, avec toutes les forces principales pris en compte. J'aimerais aussi pouvoir gérer les forces qui ralentissent la rotation de la Lame, pour pouvoir lui donner plus ou moins d'inertie.
J'ai fais des tests dans la vraie vie et j'ai remarqué que lorsque l'on déplace un corps long par l'extrémité, avec le doigt en effectuant le moins de pression possible, l'objet tourne et se met dans le même axe que le vecteur de déplacement. Ainsi, si l'on dessine des petits cercles avec le doigt, l'objet tourne. C'est ce que j'aimerais reproduire dans mon programme.

Alors mes questions sont : comment je pourrais faire ? Quels sont les principes physiques qui me seraient utile ?

Ma piste étant de modifier la valeur, quand t augmente, de Pal, en la calculant grâce aux forces qui s'exercent lors du mouvement de la souris. Sauf que je ne connais pas les calculs à effectuer pour trouver Pal(t). Vous pouvez m'aider ?

Petit schéma qui résume ce qui est sensé se passer :

Merci de vos future réponses.

A priori je dirais que c'est comme un pendule sauf que tu devrais faire varier la direction de la gravité en fonction de l'accélération du manche.

Donc je commencerais par le pendule >>

https://youtu.be/9iaEqGOh5WM

Je viens d’essayer et ça ne marchera pas car la gravité n'est pas considérée comme un vecteur dans cette solution trop simplifiée mais c'est une bonne base.

Donc je me suis demandé ou se trouverait le Bob (c'est comme cela qu'il appelle le bout du pendule) après une étape et sans gravité. Je pense qu'on peut dire qu'il sera aligné avec sa précédente position et la nouvelle position du manche, la différence d'angle entre les deux étapes est son accélération angulaire >>>

Pour être sur j'ai fais le même schéma si le manche partait dans l'autre direction et cela pourrait être correcte >>>

Il ne nous reste plus qu'a trouver ce fameux angle.

Alors tu as réussi ? De mon côté j'ai un truc pas trop mal mais parfois un comportement erratique, je ne sais pas pourquoi.

https://gph.is/g/EBgzNPK

Re, alors, par contre, le plan est en vue aérienne "Tout ça en vu du dessus.", c'est à dire que la gravité n'est pas du haut vers le bas mais du devant vers l'arrière, alors je pense que cette force peut être négligé nan ? J'sais pas si ce que tu as fait prend en compte la gravité dans ce sens, mais ça a l'air correcte hein, ça se rapproche de ce que je veux oui. Par contre ouais, y a quelques amélioration à effectuer, des fois il a un comportement étrange.

De mon côté j'ai un peu réfléchis à la chose et j'ai remarqué que les forces s'effectuent un peu comme ça :

F1> étant le vecteur force lorsque l'on déplace la souris, ce qui correspond à :

F1>(XpositionSouris(t1) - XpositionSouris(t0) ; YpositionSouris(t1) - YpositionSouris(t0))

J'ai observé le comportement dans la vraie vie, et j'ai constaté que si on traine un objet long par l'une des extrémités et bah l'autre extrémité se met dans l'axe de la première, alors F2> est l'opposé de F1> avec comme point d'origine l'autre extrémité. J'ai fait une petite équation à deux inconnus qui permet d'avoir le point d'origine par rapport à la distance entre le point d'origine du manche et le point d'origine de la lame qui est une constante, la position angulaire à t(x). Et j'en suis là, faut encore que je vérifie l'équation, etc... Tout ça pour trouver le point d'origine de l'extrémité de la lame.

Problème : j'ai les vecteurs forces, j'ai la masse des deux corps, j'arrive à calculer les distances parcourus, les vitesses et les accélérations du manche, mais je ne sais pas comment appliquer et simuler la force émise dans l'extrémité de la lame en prenant en compte le fait que la lame est accroché au manche, etc...
En écrivant j'ai eu l'idée d'étudier les petites éoliennes en papier pour ça, peut-être que je pourrais trouver les rapports de forces émis à une hélice pour la faire tourner autour de son axe fixe et l'appliquer avec le vecteur force F2>, ça pourrait fonctionner j'pense.

Donc voilà où j'en suis, j'ai pas avancé depuis, j'ai fais d'autres trucs, mais j'pense que c'est sur la bonne voie.

Sinon, tu as fait comment de ton côté ?

Comme j'ai expliqué plus haut. Je suis partis du tuto du pendule, à retrouver ici : https://natureofcode.com/om/book/chapter-3-oscillation/ (aller à 3.9)

J'ai viré tout ce qui était gravité et d'après mon dessin et il ne me restait plus qu'à trouver les orientations du pendule, l'actuelle et celle en fonction de l'accélération de la souris (pas de sa vélocité), de calculer leur différence et d'appliquer cette différence à l'accélération angulaire.

Voici le code pour processing :

Pendulum p;
 
void setup() {
  size(640,360);

  //We make a new Pendulum object with an origin location and arm length.
  p = new Pendulum(75);
}
 
void draw() {
  background(255);
  p.go();
}
 
class Pendulum  {
  
  //Many, many variables to keep track of the Pendulum’s various properties
  PVector location;    // Location of bob
  PVector mouseLoc;    // Position de la souris
  float r;             // Length of arm
  float angle;         // Pendulum arm angle
  float aVelocity;     // Angle velocity
  float aAcceleration; // Angle acceleration
  float damping;       // Arbitrary damping amount
  
  PVector mAcceleration;  // accélération de la souris
  PVector mVelocity;     // velocité de la souris
  PVector prevMouseLoc;  // précédente position de la souris
  PVector prevMVelocity; // précédente vélocité de la souris
  
  Pendulum(float r_) {
    mouseLoc = new PVector(mouseX, mouseY);
    location = new PVector();
    r = r_;
    angle = 0.0;
 
    aVelocity = 0.0;
    aAcceleration = 0.0;
    
    damping = 0.97; //An arbitrary damping so that the Pendulum slows over time
    
    mAcceleration = new PVector(0, 0);
    mVelocity = new PVector(0, 0);
    prevMouseLoc = new PVector(mouseX, mouseY);
    prevMVelocity = new PVector(0, 0);
  }
 
  void go() {
    update();
    display();
  }
 
  void update() {
    
    //Update position de la souris
    mouseLoc.set(mouseX, mouseY);
    
    //Vélocité de la souris
    mVelocity = PVector.sub(mouseLoc, prevMouseLoc);
    println("Mouse Vel " + mVelocity.mag());
    
    //Accélération de la souris
    mAcceleration = prevMVelocity.sub(mVelocity);
    //println("Mouse Acc " + mAcceleration.mag());
    
    ////////////////////////////////////////////////
    //Formula we worked out for angular acceleration
    ////////////////////////////////////////////////
    
    //Précédente orientation du pendule (différence entre
    // prec position de la souris et précédente position du pendule)
    
    PVector prevDirection = PVector.sub(prevMouseLoc, location);
    
    //Nouvelle orientation (différence entre supposée nouvelle position de la souris
    // et précédente position du pendule)
    
    PVector direction = PVector.sub(PVector.add(prevMouseLoc, mAcceleration), location);
    
    //Différence entre les deux orientation appliquée à l'accélération angulaire
    aAcceleration = direction.heading() - prevDirection.heading();
    //Clamp pour éviter les glitchs
    aAcceleration = constrain(aAcceleration, -0.5, 0.5);
    //println("Angular acc " + aAcceleration);
    
    ////////////////////////////////////////////////
    
    //Standard angular motion algorithm
    aVelocity += aAcceleration;
    angle += aVelocity;
    
    //Apply some damping.
    aVelocity *= damping;
    
    //Where is the bob relative to the origin? Polar to Cartesian coordinates will tell us!
    location.set(r*sin(angle),r*cos(angle),0);
    location.add(mouseLoc);
    
    //Update previous mouse position and velocity
    prevMouseLoc.set(mouseX, mouseY);
    prevMVelocity.set(mVelocity.x, mVelocity.y);
  }
  
  void display() {
    stroke(0);
    
    //The arm
    line(mouseLoc.x,mouseLoc.y,location.x,location.y);
    fill(175);
    
    //The bob
    ellipse(location.x,location.y,16,16);
  }
}