Рассчитать координаты смещения полу сочлененного грузовика

Question

Как показано на рисунке ниже, я создаю программу, которая будет создавать 2D-анимацию грузовика, состоящего из двух шарнирных частей.

Грузовик тянет трейлер.

Прицеп движется в соответствии с осью стыковки на грузовике.

Затем, когда грузовик поворачивает, прицеп должен постепенно совмещаться с новым углом наклона грузовика, как это происходит в реальной жизни.

Я хотел бы знать, существует ли какая-либо формула или алгоритм, который делает этот расчет простым способом.

Я уже видел уравнения обратной кинематики, но я думаю, что только для 2 частей это не было бы так сложно.

Кто-нибудь может мне помочь?

Answer 1

По ответам, которые я увидел, я понял, что решение на самом деле не простое и должно быть решено алгоритмом обратной кинематики.

Этот сайт является примером, и это только начало, хотя он все еще не решает все, так как точка C фиксирована и в случае грузовика она должна двигаться.

Answer 2

Основываясь на этом Аналитическом двухкостном ИК в 2D статье , я сделал полностью функциональную модель в геогебре , где ядро ​​состоит из двух простых математических уравнений.

Answer 3

Пусть A будет средней точкой под передней осью, B будет средней точкой под средней осью, а C будет средней точкой под задней осью. Для простоты предположим, что сцепка находится в точке B. Это все функции времени t, например A(t) = (a_x(t), a_y(t).

Хитрость заключается в следующем. B движется прямо к A с компонентом скорости A в этом направлении. Или в символах: dB/dt = (dA/dt).(A-B)/||A-B|| И аналогично dC/dt = (dB/dt).(B-C)/||B-C||, где . - это скалярное произведение.

Это превращается в нелинейную систему первого порядка из 6 переменных. Это можно решить обычными методами, такими как https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods.

ОБНОВЛЕНИЕ: Добавлен код

Вот реализация Python. Вы можете заменить его на https://rosettacode.org/wiki/Runge-Kutta_method для вашего любимого языка и вашей любимой библиотеки линейной алгебры. Или даже раскрутить это вручную.

Для моего примера я начал с A в (1, 1), B в (2, 1) и C в (2, 2). Затем вытащил A к началу шага размером 0.01. Это можно изменить на что угодно.

#! /usr/bin/env python
import numpy

# Runga Kutta method.
def RK4(f):
    return lambda t, y, dt: (
            lambda dy1: (
            lambda dy2: (
            lambda dy3: (
            lambda dy4: (dy1 + 2*dy2 + 2*dy3 + dy4)/6
            )( dt * f( t + dt  , y + dy3   ) )
            )( dt * f( t + dt/2, y + dy2/2 ) )
            )( dt * f( t + dt/2, y + dy1/2 ) )
            )( dt * f( t       , y         ) )


# da is a function giving velocity of a at a time t.
# The other three are the positions of the three points.
def calculate_dy (da, A0, B0, C0):
    l_ab = float(numpy.linalg.norm(A0 - B0))
    l_bc = float(numpy.linalg.norm(B0 - C0))

    # t is time, y = [A, B, C]
    def update (t, y):
        (A, B, C) = y
        dA = da(t)

        ab_unit = (A - B) / float(numpy.linalg.norm(A-B))
        # The first term is the force.  The second is a correction to
        # cause roundoff errors in length to be selfcorrecting.
        dB = (dA.dot(ab_unit) + float(numpy.linalg.norm(A-B))/l_ab - l_ab) * ab_unit

        bc_unit = (B - C) / float(numpy.linalg.norm(B-C))
        # The first term is the force.  The second is a correction to
        # cause roundoff errors in length to be selfcorrecting.
        dC = (dB.dot(bc_unit) + float(numpy.linalg.norm(B-C))/l_bc - l_bc) * bc_unit

        return numpy.array([dA, dB, dC])

    return RK4(update)

A0 = numpy.array([1.0, 1.0])
B0 = numpy.array([2.0, 1.0])
C0 = numpy.array([2.0, 2.0])
dy = calculate_dy(lambda t: numpy.array([-1.0, -1.0]), A0, B0, C0)

t, y, dt = 0., numpy.array([A0, B0, C0]), .02
while t <= 1.01:
    print( (t, y) )
    t, y = t + dt, y + dy( t, y, dt )