[PYTHON] Nichtlineare Feder mit PyODE-Schieber

Ich habe versucht, die auf die Feder wirkende Kraft (Federkoeffizient usw.) mit einer beliebigen Funktion mit dem Schieberegler (ode.SliderJoint) von PyODE einzustellen.

Dies ist der vorherige Artikel → Versuchen Sie, den PyODE-Schieberegler zu verdoppeln

1 Motivation

Ein Berechnungsbeispiel für diese Art von physischem Motor ist ・ Große Anzahl von Elementen (10 ist weniger) -Federn und Dämpfer sind die einfachsten. Und so weiter.

Ich habe es jedoch mit Feder- / Dämpfersystemen zu tun. Es macht keinen Sinn, nur eine einfache lineare Feder einzustellen. Ist es möglich, den Federkoeffizienten mit ODE (PyODE) beliebig einzustellen? Wenn dies nicht funktioniert, geben Sie die Verwendung von ODE auf.

Fazit zuerst

Zu jedem Zeitpunkt stellte ich fest, dass jede Kraft als Wert von der Instanzmethode " addForce ()` "von" slideJoint``` "übergeben werden kann. Daher können Sie den Federkoeffizienten und die Dämpfung auf Ihre bevorzugten Eigenschaften einstellen.

2 Einstellmethode

Stellen Sie die auf den Schieber erzeugte Kraft direkt ein

Zunächst der Teil, der die vom Schieber erzeugte Kraft als Wert weitergibt. ↓

`Geben Sie mit addForce eine beliebige treibende Kraft`


while() :    ####Zeitverlaufsschleife
    #Unterlassung

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

    world.step(dt)

`j01 ist ein Schieberegler oder eine Ode.SliderJoint-Instanz.`


 Der Wert, der durch die später beschriebene selbst erstellte Funktion `` `spring ()` `` bestimmt wird, wird als `` `f``` gesetzt.

 Jeder Wert kann durch die Methode addForce als treibende Kraft angegeben werden.

#### **`world.step()Ist der zeitliche Fortschritt eines Odenschritts`**
```step()Ist der zeitliche Fortschritt eines Odenschritts

 Sie können addForce kurz davor aufrufen.

#### Bestimmen Sie die Kraft aus dem Zustand des Schiebers
```spring()```Ist eine selbst erstellte Funktion, die Strom aus dem Zustand des Schiebereglers bezieht.


#### **`Feder- / Dämpferfunktion`**
```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

Hier ist `j``` der Schieberegler (ode.SliderJoint-Instanz) Der Betrag der Schiebereglerverschiebung kann mit der Instanzmethode getPosition () `` ermittelt werden. In ähnlicher Weise ist die Verschiebungsrate "getPositionRate ()".

Hier ** eine Feder, die eine Abstoßungskraft erzeugt, die proportional zum Würfel der Verschiebung ist **. (Als ich es mit dem Quadrat versuchte, schien der Unterschied zur linearen Feder unklar zu sein, also machte ich es zum Würfel.)

Durch diese Codierungen wurde die Verarbeitung, die sich auf der C / C ++ - Seite mit einer einfachen linearen Feder befand, auf die Python-Codeseite verschoben. Es kann zu Leistungseinbußen kommen.

3. Ergebnisse

Visualisierung von Pygame. ↓

Schwarze Kreise sind feste Objekte. Die Linie repräsentiert die Position der Feder (Schieberegler). Der rotbraune Kreis schwankt im Frühling.

↓ Dies ist die zeitliche Änderung der Höhe und Geschwindigkeit des rotbraunen Kreises. y_DT0.0005_kp20_kd0_zeta0.png

`KP = 100.0 KD =Es wird auf 0 gesetzt.`


 Es lohnt sich, es nicht linear zu machen
 Sie können eine verzerrte Wellenform sehen, die sich von der Sinuswelle unterscheidet.


## 4 Zusammenfassung
```addforce()```Ich habe festgestellt, dass ich die Leistung nach Belieben einstellen kann.
 In diesem Fall können Sie verschiedene Dinge ausprobieren.
 Also werde ich diesen PyODE für eine Weile benutzen.