Ressort non linéaire avec curseur PyODE

J'ai essayé de régler la force agissant sur le ressort (coefficient de ressort, etc.) avec une fonction arbitraire avec le curseur (ode.SliderJoint) de PyODE.

C'est l'article précédent → Essayez de doubler le curseur PyODE

1 Motivation

Un exemple de calcul utilisant ce type de moteur physique est ・ Grand nombre d'éléments (10 est moins) -Les ressorts et les amortisseurs sont les plus simples. Etc.

Cependant, je m'occupe de systèmes à ressort / amortisseur. Il ne sert à rien de régler uniquement un simple ressort linéaire. Est-il possible de définir arbitrairement le coefficient de ressort avec ODE (PyODE)? Si cela ne fonctionne pas, vous renoncerez à utiliser ODE.

Conclusion d'abord

A chaque fois, j'ai trouvé que n'importe quelle force peut être passée comme valeur de la méthode d'instance " ʻaddForce ()`` "de"slideJoint```". Par conséquent, vous pouvez régler le coefficient de ressort et l'amortissement selon vos caractéristiques préférées.

2 Méthode de réglage

Réglez directement la force générée sur le curseur

Tout d'abord, la partie qui transmet la force générée par le curseur en tant que valeur. ↓

`Donnez une force motrice arbitraire avec addForce`


while() :    ####Boucle de progression temporelle
    #Omission

    f = spring( j01 , KP, KD )    
    j01.addForce( f )

    world.step(dt)

`j01 est un curseur ou une ode.Instance SliderJoint.`


 La valeur déterminée par la fonction auto-fabriquée `` `` spring () '' décrite plus loin est définie comme `` `` f ''

 Toute valeur peut être donnée comme force motrice par la méthode addForce.

#### **`world.step()Est-ce que la progression temporelle d'une étape d'ode`**
```step()Est-ce que la progression temporelle d'une étape d'ode

 Vous pouvez appeler addForce juste avant cela.

#### Déterminez la force à partir de l'état du curseur
```spring()```Est une fonction auto-conçue qui obtient de l'énergie à partir de l'état du curseur.


#### **`Fonction ressort / amortisseur`**
```python

def spring( j, kp, kd=None ):
    r = j.getPosition()
    f = r*r*r * kp
    if None is not kd:
        f += j.getPositionRate() * kd
    return - f

Ici, `j``` est le curseur (instance ode.SliderJoint) La quantité de déplacement du curseur peut être obtenue avec la méthode d'instance getPosition () ''. De même, le taux de déplacement est `` getPositionRate () ''.

Ici, ** un ressort qui génère une force répulsive proportionnelle au cube du déplacement **. (Quand je l'ai essayé avec le carré, la différence avec le ressort linéaire ne semblait pas claire, alors j'en ai fait le cube.)

Par ces codages, le traitement qui était du côté C / C ++ avec un simple ressort linéaire a été déplacé vers le côté code Python. Il peut y avoir une certaine dégradation des performances.

3. Résultats

Visualisation par Pygame. ↓

Les cercles noirs sont des objets fixes. La ligne représente la position du ressort (curseur). Le cercle rouge-brun se balance sur le ressort.

↓ C'est le changement d'heure de la hauteur et de la vitesse du cercle rouge-brun. y_DT0.0005_kp20_kd0_zeta0.png

`KP = 100.0 KD =Il est mis à 0.`


 Cela vaut la peine de le rendre non linéaire
 Vous pouvez voir une forme d'onde déformée différente de l'onde sinusoïdale.


## 4 Résumé
```addforce()```J'ai trouvé que je pouvais régler la puissance à ma guise.
 Si tel est le cas, vous pouvez essayer différentes choses.
 Donc, je vais utiliser ce PyODE pendant un moment.