ruckig 0.17.3

Instantaneous Motion Generation for Robots and Machines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

# Only with Ruckig Pro

from math import sin, cos

from ruckig import Trackig, TrackigMode, TargetState, InputParameter, OutputParameter


# Create the target state signal
def model_ramp(t, ramp_vel=0.5, ramp_pos=1.0):
    target = TargetState(1)
    on_ramp = t < ramp_pos / abs(ramp_vel)
    target.position = [t * ramp_vel] if on_ramp else [ramp_pos]
    target.velocity = [ramp_vel] if on_ramp else [0.0]
    target.acceleration = [0.0]
    return target


def model_constant_acceleration(t, ramp_acc=0.05):
    target = TargetState(1)
    target.position = [t * t * ramp_acc]
    target.velocity = [t * ramp_acc]
    target.acceleration = [ramp_acc]
    return target


def model_sinus(t, ramp_vel=0.4):
    target = TargetState(1)
    target.position = [sin(ramp_vel * t)]
    target.velocity = [ramp_vel * cos(ramp_vel * t)]
    target.acceleration = [-ramp_vel * ramp_vel * sin(ramp_vel * t)]
    return target


if __name__ == '__main__':
    # Create instances: Trackig as well as input and output parameters
    inp = InputParameter(1)
    out = OutputParameter(inp.degrees_of_freedom)
    trackig = Trackig(inp.degrees_of_freedom, 0.01)

    # Set input parameters
    inp.current_position = [0.0]
    inp.current_velocity = [0.0]
    inp.current_acceleration = [0.0]

    inp.max_velocity = [0.8]
    inp.max_acceleration = [2.0]
    inp.max_jerk = [5.0]

    # Optional minimum and maximum position
    inp.min_position = [-2.5]
    inp.max_position = [2.5]

    trackig.mode = TrackigMode.Optimized  # Optimized or Fast
    trackig.reactiveness = 1.0  # default value, should be in [0, 1]

    print('target | follow')

    # Generate the trajectory following the target state
    steps, target_list, follow_list = [], [], []
    for t in range(500):
        target_state = model_ramp(trackig.delta_time * t)

        steps.append(t)
        res = trackig.update(target_state, inp, out)

        out.pass_to_input(inp)

        print(
            '\t'.join([f'{p:0.3f}' for p in target_state.position] + [f'{p:0.3f}' for p in out.new_position]),
            f'in {out.calculation_duration:0.2f} [µs]',
        )

        target_list.append([target_state.position, target_state.velocity, target_state.acceleration])
        follow_list.append([out.new_position, out.new_velocity, out.new_acceleration])

    # Plot the trajectory
    # from pathlib import Path
    # project_path = Path(__file__).parent.parent.absolute()

    # import numpy as np
    # import matplotlib.pyplot as plt

    # follow_list = np.array(follow_list)
    # target_list = np.array(target_list)

    # plt.ylabel(f'DoF 1')
    # plt.plot(steps, follow_list[:, 0], label='Follow Position')
    # plt.plot(steps, follow_list[:, 1], label='Follow Velocity', linestyle='dotted')
    # plt.plot(steps, follow_list[:, 2], label='Follow Acceleration', linestyle='dotted')
    # plt.plot(steps, target_list[:, 0], color='r', label='Target Position')
    # plt.grid(True)
    # plt.legend()

    # plt.savefig(project_path / 'examples' / '14_trajectory.pdf')