Connect with us

crosspost: request for algorithms!

Discussion in 'Electronic Design' started by Jamie Morken, Aug 5, 2006.

Scroll to continue with content
  1. Jamie Morken

    Jamie Morken Guest


    I have a 2 wheel balancing robot I am working on that needs some TLC in
    the form of new algorithms. I am starting to hear creaks and groans
    in its drivetrain caused by my experiments trying to get this robot
    to drive around. I have the robot able to balance well in one spot
    using a simple PID loop, but I am getting tired watching it sit in
    one place and would like to see it drive around a bit without
    having a seizure as it currently does. For those who reply to this,
    I will put your algorithm on the robot and test it out and will
    film and post the best performing ones to the web. Any type of
    algorithm is appreciated, but the main goals of the robot are first
    to balance, drive forwards and backwards and steer. I have measured
    the properties of the robot and put them in the below C code under
    the comment "robot physical characteristics". There are sensor
    feedback variables under the comment "robot sensor derived variables",
    and the joystick variables under the comment "robot control input
    variables". The two variables that must be set by the algorithms are
    under the comment "robot control output variables" which are the
    left and right wheel torques. These can be scaled linearly from
    -1 to +1 or -100 to +100 for each wheel. Zero is no torque.

    If you need any other variables let me know or you can declare them
    as static (in C code). I have a task loop that can switch between 5
    different algorithms on the fly so testing should be fast if you want
    to try multiple algorithms. The balance algorithm is called 33.3 times
    per second but this can be changed too.

    Here is the algorithm I am using for balancing right now:

    balance_loop() //called 33.3X per second

    left_wheel_torque = (platform_pitch_degrees * K1) +
    (platform_pitch_degrees_per_second * K2); //K1 = 7, K2 = 0.8

    right_wheel_torque = left_wheel_torque;



    If you want to set gain factors for your algorithm,
    use these variables:
    float K1;
    float K2;

    Thanks for your participation and may the best algorithm win!

    best regards,
    Jamie Morken


    //robot physical characteristics
    #define wheel1_diameter_meters 0.495
    #define wheel1_circumference_meters (pi * wheel1_diameter_meters)
    #define wheel2_diameter_meters 0.495
    #define wheel2_circumference_meters (pi * wheel2_diameter_meters)
    #define robot_weight_kg 71.2 //it's heavy!
    #define center_of_gravity_height_meters 0.54
    #define wheel_axle_height_meters 0.24
    #define wheelbase_meters 0.556

    //robot sensor derived variables
    float platform_pitch_degrees; //forwards backwards tilt
    float platform_pitch_degrees_per_second;
    float platform_yaw_degrees; //steering
    float platform_yaw_degrees_per_second;
    float encoder1_degrees_per_second; //left wheel encoder
    float encoder2_degrees_per_second; //right wheel encoder
    float wheel1_degrees_per_second;
    float wheel2_degrees_per_second;
    float wheel1_meters_per_second;
    float wheel2_meters_per_second;
    float platform_meters_per_second;
    float wheel1_position_meters;
    float wheel2_position_meters;
    float platform_position_meters;

    //robot control input variables (joystick driving and steering)
    float desired_platform_meters_per_second;
    float desired_platform_yaw_degrees_per_second;

    //robot control output variables
    float left_wheel_torque;
    float right_wheel_torque;

  2. Guest

    The algorithm used by the first balancing two wheeled robot and by far
    the most common algorithm to get the robot to drive around is to add an
    offset to the platform_pitch_degrees. And to get it to steer is to
    again add a differential between the left and right wheels. I'd do
    something like:

    torque = ((platform_pitch_degrees + offset) * K1) +
    (platform_pitch_degrees_per_second * K2);

    left_wheel_torque = torque + steering;
    right_wheel_torque = torque - steering;

    Basically what this method does is to trick the balancing algorithm by
    lying to it about the actual platform pitch and so you're really using
    the balancing algorithm to constantly get the robot to be slightly
    off-balance causing it to constantly try to re-balance the robot which
    in turn causes an average motion in one direction. Kind of like how a
    human would do it when balancing a broom - you'd tilt the broom a bit
    in order to move forward.
Ask a Question
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.
Electronics Point Logo
Continue to site
Quote of the day