[Math] Calculate maximum velocity given accel, decel, initial v, final position

physics

I'm trying to calculate the maximum velocity of an object given:

acceleration
deceleration
starting position (0)
ending position
initial velocity

I've been trying to use formulas from:
https://stackoverflow.com/questions/153507/calculate-the-position-of-an-accelerating-body-after-a-certain-time
http://easycalculation.com/physics/classical-physics/constant-acc-velocity.php

but I still can't seem to figure it out.

The closest I've gotten is:
$$t = \frac{V_{max} – V_0}{a} + \frac{0 – V_{max}}{d}$$

But even trying to solve that for Vmax leaves an unknown '$t$' in the equation, and doesn't take into account the ending position either.

A sort of real world example for this, if it helps, is of a car. The car starts at p=0, with a rolling start (in either direction). At the finish line (ending position) is a brick wall. The car must stop with the front bumper touching the brick wall. It must accelerate at a for as long as possible, then decelerate at d, ending at that brick wall, with v=0.

(I'm writing an Arduino library for controlling servos, with speed limits, acceleration and deceleration. I need to know whether the max velocity it can reach given the acceleration and deceleration will ever exceed the max velocity the library user specifies, so I can calculate whether there needs to be any time spent "coasting" between acceleration and deceleration.)

Best Answer

We assume the object starts at time $t=0$ at position $x=0$ and ends at position $\ell$. It accelerates constantly with acceleration $a$ and then suddenly at time $t=t_1$ it decelerates constantly with deceleration $d$ (positive) until stopping at the point $\ell$. Let us call $t_2$ the deceleration time.

Then $v_\max=v_0+at_1$. To find $t_1$, note that $$v_0+at_1-dt_2=0;$$ this is the condition that the speed at $x=\ell$ is zero. And the distance has to be $\ell$, so $$ v_0t_1+\frac12at_1^2+(v_0t_2+at_1t_2-\frac12dt_2^2)=\ell. $$ The term between brackets comes from the fact that the speed during the deceleration process is $v_\max-dt$, so the distance covered during the deceleration process is $v_\max t_2-\frac12dt_2^2$.

From the first equation, we get $t_2=(v_0+at_1)/d$. Plugging this into the second equation and solving, $$ t_1=-\frac{v_0}a+\frac1a\sqrt{\frac{d v_0^2+2a\ell d}{a+d}}. $$ So $$ v_\max=v_0+at_1=\sqrt{\frac{d v_0^2+2a\ell d}{a+d}}. $$

Related Solutions

[Math] Motion with acceleration and deceleration

You need a function $f\colon[0,T]\to[0,d]$ (your specific example has $d=300$ and $T=70$) that looks like $$ f(t)=\begin{cases}\frac12at^2&\text{if }t<\frac3{10}T,\\ vt+x_0&\text{if }\frac3{10}T\le t\le \frac7{10}T,\\ d-\frac12a(T-t)^2&\text{if }t>\frac7{10}T.\end{cases}$$ By symmetry, $vt+x_0=v(t-\frac T2)+\frac d2$. The facts that $f$ and its derivative $f'$ are continouous translate to the conditions $$ a\cdot\frac3{10}T = v$$ and $$ \frac12a\cdot\frac9{100}T^2= -\frac15vT+\frac d2.$$ From this we find $$ a=\frac{200}{21}\cdot \frac d{T^2}$$ and $$v = \frac{20}{7}\cdot \frac dT.$$

Remark: Spline interpolation of the coordinates offsets may be a good and fast alternative.

Calculate the constant acceleration needed for the discrete time trajectory to intersect a given target point

A quick background refresher:

In continuous time, the velocity $v(t)$ and position $x(t)$ with a constant acceleration $a$ are given by $$\left\lbrace\begin{aligned} v(t) &= \int_{0}^{t} a \, d \tau = v_0 + a t \\ x(t) &= \int_{0}^{t} v(\tau) \, d \tau = x_0 + v_0 t + \frac{1}{2} a t^2 \end{aligned}\right.\tag{1}\label{NA1}$$

In discrete time, the velocity and position are given by difference equations. There are three most common definitions:

A. Position updated before velocity: $$\left\lbrace\begin{aligned} x_{i+1} &= x_{i} + v_{i} \\ v_{i+1} &= v_{i} + a \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N (N - 1)}{2} a \tag{2a}\label{NA2a}$$

B. Velocity updated before position: $$\left\lbrace\begin{aligned} v_{i+1} &= v_{i} + a \\ x_{i+1} &= x_{i} + v_{i+1} \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N(N+1)}{2} a \tag{2b}\label{NA2b}$$

C. Velocity updated before and after position: $$\left\lbrace\begin{aligned} v_{i+\frac{1}{2}} &= v_{i} + \frac{1}{2} a \\ x_{i+1} &= x_{i} + v_{i+\frac{1}{2}} \\ v_{i+1} &= v_{i+\frac{1}{2}} + \frac{1}{2} a \\ \end{aligned}\right. \implies x_N = x_0 + N v_0 + \frac{N^2}{2} a \tag{2c}\label{NA2c}$$

In this last case $\eqref{NA2c}$, velocity updates are essentially half a time step out of sync with the position updates, but the position function is most similar to the continuous time one, $\eqref{NA1}$.

(While the formulae above are shown in one dimension, you can use them in 2D or 3D just as well. The time steps ($i$ and $N$) are the same (shared) across all dimensions, but each dimension has their own acceleration $a$. The actual magnitude of the acceleration is then $\sqrt{a_x^2 + a_y^2}$ for 2D, and $\sqrt{a_x^2 + a_y^2 + a_z^2}$ for 3D.)

The problem at hand is to find the smallest $0 \le N \in \mathbb{N}$ and $a_x$ and $a_y$, when $x_0$, $y_0$, $v_{x0}$, $v_{y0}$ are known, but acceleration is limited, $a_x^2 + a_y^2 \le A_{max}^2$.

If we solve $\eqref{NA2a}$ for $a$ for both dimensions, we get $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N (N - 1)} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N (N - 1)} \\ \end{aligned}\right . \tag{3a}\label{NA3a}$$ Solving $\eqref{NA2b}$ similarly yields $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N (N + 1)} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N (N + 1)} \\ \end{aligned}\right . \tag{3b}\label{NA3b}$$ and $\eqref{NA2c}$ yields $$\left\lbrace\begin{aligned} a_x &= \frac{2 (x_N - x_0 - N v_{x0})}{N^2} \\ a_y &= \frac{2 (y_N - y_0 - N v_{y0})}{N^2} \\ \end{aligned}\right . \tag{3c}\label{NA3c}$$ To find out the approximate number of steps (which we need to round upwards to not exceed the specified acceleration $A_{max}$), we could try and solve $$a_x^2 + a_y^2 \le A_{max}^2 \tag{4}\label{NA4}$$ for $N \in \mathbb{R}$ (so the actual number of time steps needed would be rounded up, $\left\lceil N \right\rceil$).

Unfortunately, while there is an algebraic solution (it is a form of a fourth-degree function that does have algebraic solutions), it is too complicated to be useful.

Fortunately, we can use the bisection method (or binary search) to very efficiently find the smallest $N$, and therefore also the largest acceleration $(a_x , a_y)$ not exceeding $A_{max}$ in magnitude, that reaches the target coordinates in minimum number of time steps.

Note that in practice, square root and division operations take much more time than addition or multiplication. Because the bisection method/binary search will have to evaluate the same expression potentially dozens of times, it is a good idea to "optimize" $\eqref{NA4}$ first.

If we use $\Delta_x = x_N - x_0$ and $\Delta_y = y_N - y_0$, then $\eqref{NA4}$ optimizes to: $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^2 (N-1)^2 \frac{A_{max}^2}{4} \le 0 \tag{5a}\label{NA5a}$$ $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^2 (N+1)^2 \frac{A_{max}^2}{4} \le 0 \tag{5b}\label{NA5b}$$ $$(\Delta_x - N v_{x0})^2 + (\Delta_y - N v_{y0})^2 - N^4 \frac{A_{max}^2}{4} \le 0 \tag{5c}\label{NA5c}$$ depending on how the velocity is updated with respect to position updates, respectively. (This means each iteration when finding $N$ takes only something like 8 multiplications and 5 additions or subtractions. Since the number of iterations needed is roughly $2 \log_2 N$, this is actually pretty efficient. Even if we find $N \approx 10,000$, we only end up doing a couple of hundred multiplications and a hundred and thirty additions or subtractions. The algebraic solution has more terms than that!)

Furthermore, the optimized form is defined even for $N = 0$ and $N = 1$, so there is no risk of accidental divide-by-zero error. This makes the bisection search easier to write, too.

If we use EQ5(N) for $\eqref{NA5a}$/$\eqref{NA5b}$/$\eqref{NA5c}$, the pseudocode to find $N$ is something like

Function StepsNeeded(x0,y0, xN,yN, vx,vy, Amax):
    Let  dx = xN - x0
    Let  dy = yN - y0
    Let  Nmin = 0
    Let  Nmax = 2

    # Find the Nmin,Nmax range spanning the solution
    While EQ5(Nmax) > 0:
        Let  Nmin = Nmax
        Let  Nmax = Nmax * 2
    End While

    Let  N = Nmax
    While Nmax > Nmin:
        Let  N = Nmax - floor((Nmax - Nmin)/2)
        Let  C = EQ5(N)
        If C > 0:
            Let  Nmin = N
        Else If C < 0:
            If Nmax > N:
                Let  Nmax = N
            Else:
                Break While
            End If
        Else:
            Break loop
        End If
    End While

    Return N
End Function

When we do have $N$, it is just a matter of plugging it back to $\eqref{NA3a}$/$\eqref{NA3b}$/$\eqref{NA3c}$ to obtain the acceleration vector $(a_x , a_y)$.

The first While loop finds the smallest range containing a root, so that Nmax is a sufficient number of steps (yields an acceleration that does not exceed the given limit), and Nmin is an insufficient number of steps (yields an acceleration that exceeds the given limit). For each iteration $1 \le i \in \mathbb{N}$, Nmin= $2^{i-1}$ (except Nmin=0 for $i = 1$, and Nmin=2 for $i = 2$) and Nmax=$2^i$, so only a few iterations are ever needed.

The second While loop uses the bisection method (or binary search) to find the root within that range. As it halves the range on each iteration, it does at most as many iterations as the first loop did.

Because we want an $N$ that yields $a_x^2 + a_y^2 \le A_{max}^2$, we exclude the minimum (Nmin) and include the maximum (Nmax) in the search. This is why we use N = Nmax - floor((Nmax - Nmin)/2), too: it never yields Nmin. This is also why we start with Nmin = 0: the smallest N returned is 1.

Here is an example Python (works in both Python 2 and Python 3) program, that solves the number of steps and the acceleration, when given the starting x and y coordinates, target x and y coordinates, initial velocity x and y components, and the maximum acceleration allowed:

from math import sqrt
from sys import stderr, argv, exit

# This file is in public domain. No guarantees, no warranties.
# Written by Nominal Animal <[email protected]>.

def solveacceleration(start, finish, velocity, maxaccel):
    dx = finish[0] - start[0]
    dy = finish[1] - start[1]
    vx = velocity[0]
    vy = velocity[1]
    ac = 0.25 * maxaccel * maxaccel

    if maxaccel <= 0.0:
        return 0, (0.0, 0.0)

    nmin = 0
    nmax = 2
    while True:
        cx = dx - nmax*vx
        cy = dy - nmax*vy

        # A) cc = cx**2 + cy**2 - ac * nmax**2 * (nmax-1)**2
        # B) cc = cx**2 + cy**2 - ac * nmax**2 * (nmax+1)**2
        # C) cc = cx**2 + cy**2 - ac * nmax**4

        cc = cx**2 + cy**2 - ac * nmax**2 * (nmax-1)**2
        # stderr.write("nmin=%u, nmax=%u, cc=%.6f\n" % (nmin, nmax, cc))
        if cc > 0:
            nmin = nmax
            nmax = nmax * 2
        else:
            break

    n = nmax
    while nmax > nmin:
        n = nmax - int((nmax - nmin) / 2)
        cx = dx - n*vx
        cy = dy - n*vy

        # A) cc = cx**2 + cy**2 - ac * n**2 * (n-1)**2
        # B) cc = cx**2 + cy**2 - ac * n**2 * (n+1)**2
        # C) cc = cx**2 + cy**2 - ac * n**4
        cc = cx**2 + cy**2 - ac * n**2 * (n-1)**2

        # stderr.write("nmin=%u, nmax=%u, n=%u, cc=%.6f\n" % (nmin, nmax, n, cc))
        if cc > 0:
            nmin = n
        elif cc < 0:
            if nmax == n:
                break
            else:
                nmax = n
        else:
            break

    # A) a_ = 2*(d_ - n*v_) / (n * (n - 1))
    # B) a_ = 2*(d_ - n*v_) / (n * (n + 1))
    # C) a_ = 2*(d_ - n*v_) / (n**2)
    ax = 2*(dx - n*vx) / (n * (n - 1))
    ay = 2*(dy - n*vy) / (n * (n - 1))
    return n, (ax, ay)


if __name__ == '__main__':

    if len(argv) != 8:
        stderr.write("\n")
        stderr.write("Usage: python %s x0 y0 x1 y1 xv yv amax\n" % argv[0])
        stderr.write("\n")
        exit(0)

    p0 = ( float(argv[1]), float(argv[2]) )
    p1 = ( float(argv[3]), float(argv[4]) )
    v0 = ( float(argv[5]), float(argv[6]) )
    amax = float(argv[7])

    n, a = solveacceleration(p0, p1, v0, amax)

    print("#  From: %9.3f %9.3f" % p0)
    print("#    To: %9.3f %9.3f" % p1)
    print("#    v0: %+9.3f %+9.3f" % v0)
    print("# Steps: %9d" % n)
    print("#     a: %+9.3f %+9.3f  (%.3f of maximum %.3f)" %
          (a[0], a[1], sqrt(a[0]*a[0]+a[1]*a[1]), amax))

    p = p0
    v = v0
    print("# step    x         y          vx        vy")
    print("")
    for i in range(0, n+1):
        # A) print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])
        #    v = (v[0]+a[0], v[1]+a[1])

        # B) v = (v[0]+a[0], v[1]+a[1])
        #    print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])

        # C) v = (v[0]+0.5*a[0], v[1]+0.5*a[1])
        #    print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        #    p = (p[0]+v[0], p[1]+v[1])
        #    v = (v[0]+0.5*a[0], v[1]+0.5*a[1])

        print("%-5d %9.3f %9.3f   %+9.3f %+9.3f" % (i, p[0], p[1], v[0], v[1]))
        p = (p[0]+v[0], p[1]+v[1])
        v = (v[0]+a[0], v[1]+a[1])

The solveacceleration() function takes the starting point, target or finish point, and the velocity as two-component tuples. If you include the commented out stderr.write() lines, the function will output a line per iteration when looking for the answer; you'll see that it does very few iterations even for the most complex cases. It returns the number of steps, plus the acceleration as a two-component tuple.

The program itself outputs the parameters and the solution, including the location and velocity at each step, in a format suitable for e.g. gnuplot. If you save the output as e.g out.txt, you can use

plot "out.txt" u 2:3 notitle w lines lc -1, \
     "out.txt" u 2:3:1 notitle w labels \
               hypertext point pt 6

in gnuplot to draw the trajectory, with small circles around each time step; hovering over each circle shows you the time step as a tooltip. To include the velocity in the tooltip, use

plot "out.txt" u 2:3 notitle w lines lc -1, \
     "out.txt" u 2:3:(sprintf("%s: (%s,%s)", stringcolumn(1), stringcolumn(4), stringcolumn(5))) \
               notitle w labels hypertext point pt 6

As it is written above, the example uses the $\eqref{NA2a}$ ("A") logic, position updated before velocity. I've commented the sections where you need to modify the code for the other two ("B" or "C").

Best Answer

Related Solutions

[Math] Motion with acceleration and deceleration

Calculate the constant acceleration needed for the discrete time trajectory to intersect a given target point

Related Question