Controller-motor container type

This container type allows to control a motor with a reduction and a sensor (usually called motor-reducer or speed-reducer). This container computes PID for speed, position and motion planning.

You can find basic information about PID control here: An introduction to PID control with DC motor, and a code example to tune your PID at the end of this page.

Its type has access to all common capabilities.

containers’s type settings:

Warning: This container doesn't save any of the following parameters, they must be set each time your container reboots.

Before using your Controller-motor container, you have to setup the resolution, motor reduction and eventually the wheel size, if you plan to use translation modes. To check the configuration, just make a complete turn on the motor shaft with your hand and check if the rotation position value is OK.

Both PID’s values have to be set accordingly to the motor-reducer plugged to the board. Each different motor-reducer will have different PID’s values for position and speed control, and you have to define them by yourself. The default values [0, 0, 0] won’t have any effect on the motor, and must be changed if you plan to use any position or speed control mode. To setup your PID please refer to the example at the end of this page.

Warning: PID for position and speed must be set in your code as an initialization before starting to use your container with position or speed control.

Now that everything is configured, you can enable the control modes you want to use. You can use position and speed mode simultaneously. Power mode is only usable alone. The Controller-motor is now ready to use, you can disable compliance to start moving the motor.

Functions

Variables

Motor settings

Motor control modes

Motor sensing

Motor commands

ROS topics

Example code

PID Setting example code

The PID values allow your motor to stick to the target command as fast as possible. The quality of a set of PID values depends on time to reach the target position and position precision. Tuning a PID is something difficult and takes a lot of practice. It's really important to have simple ways to evaluate PID values impact on your motor before starting to tune these values. Here is the code we use at Luos to tune a PID by ourself. Use it with Jupyter notebook to get your plot instantly.

The main code:

%matplotlib inline
from pyluos import Device
from IPython.display import clear_output
import time
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 1. Connect your Luos network (here using an USB container for example)
r = Device('/dev/cu.usbserial-DN2AAOVK')
r.containers

# 2. Select the container of your network you need to configure
container = r.controller_moto

# 3. Setup container basic settings
container.encoder_res = 48
container.reduction = 26.851

def run_speed_test(velocity_target):
    container.rot_position = False
    container.rot_speed = True
    container.rot_position_mode = False
    container.rot_speed_mode = True
    container.target_rot_speed = 0.0
    container.compliant = False
    target = []
    real = []
    test_time_vector = []
    test_start_time = time.time()
    target.append(container.target_rot_speed)
    real.append(container.rot_speed)
    test_time = time.time()
    test_time_vector.append(0.0)
    while (test_time < test_start_time + 0.5):
        target.append(container.target_rot_speed)
        real.append(container.rot_speed)
        test_time_vector.append(test_time - test_start_time)
        test_time = time.time()
    container.target_rot_speed = velocity_target
    while (test_time < test_start_time + 2.5):
        target.append(container.target_rot_speed)
        real.append(container.rot_speed)
        test_time_vector.append(test_time - test_start_time)
        test_time = time.time()
    container.compliant = True
    plot_test(test_time_vector, target, real)

def run_pos_test(pos_target):
    container.rot_speed = False
    container.rot_position = True
    container.rot_speed_mode = False
    container.rot_position_mode = True
    container.target_rot_position = 0.0
    container.compliant = False
    target = []
    real = []
    test_time_vector = []
    test_start_time = time.time()
    target.append(container.target_rot_position)
    real.append(container.rot_position)
    test_time = time.time()
    test_time_vector.append(0.0)
    while (test_time < test_start_time + 1):
        target.append(container.target_rot_position)
        real.append(container.rot_position)
        test_time_vector.append(test_time - test_start_time)
        test_time = time.time()
    container.target_rot_position = pos_target
    while (test_time < test_start_time + 2.5):
        target.append(container.target_rot_position)
        real.append(container.rot_position)
        test_time_vector.append(test_time - test_start_time)
        test_time = time.time()
    container.compliant = True
    plot_test(test_time_vector, target, real)

def plot_test(test_time_vector, target, real):
    fig = plt.figure()
    ax = plt.subplot(111)
    ax.plot(test_time_vector,target,'r')
    ax.plot(test_time_vector,real,'b')
    plt.show()
    plt.close(fig)

Now, you are ready to tune the PID values for position and speed control modes. To do that, you have to try values to get best the result possible. In order to succeed, we advise you to do it step by step:

1. Set P, I, and D values to 0.
2. Increase the P value until you have a small oscillation around the target.
3. Increase the D value until you have a fast and stable position.
4. Increase with really small figures the I value to improve the motor precision.

The code you can use to tune your speed PID:

# Speed PID settings
container.speedPid = [0.1,0.1,0] # speed PID [P, I, D]
run_speed_test(100.0)

The code you can use to tune your position PID:

# Position PID settings
container.positionPid = [4.0,0.02,100] # position PID [P, I, D]
run_pos_test(100.0)

Example command from ROS topics

By publishing on 3 topics you will take control over the Controller-motor named controller_moto to a velocity command of 1.57 rad/s:

# Launch the broker. Note: warnings will be displayed, please ignore them
ros2 launch luos_interface broker.launch.py

# Start the command in velocity mode
ros2 topic pub -1 /controller_moto/variables/rot_speed_mode/write std_msgs/msg/Bool data:\ true\ 
ros2 topic pub -1 /controller_moto/variables/target_rot_speed/write std_msgs/msg/Float32 data:\ 90.0\ 
ros2 topic pub -1 /controller_moto/variables/compliant/write std_msgs/msg/Bool data:\ false\ 

Then publish true to the /controller_moto/variables/compliant/write topic to stop the driver.