Mecanum omnidirectional robot example (demo_IRR_mecanum.cpp)

Simulate a small mobile robot with omnidirectional 'mecanum' wheels.

Use keyboard to perform basic motion.

This tutorial shows how to:

  • make complex models, with 'barrel' collision shapes.
  • add motors between parts.
  • use the keyboard in Irrlicht 3D view, to interact with the system in realtime.
  • manage rotations of references using ChCoordsys and ChFrame classes.
// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Alessandro Tasora
// =============================================================================
//
// Demo code about
// - collisions and contacts
// - using the 'barrel' shape to create rollers for building omnidirectional
// wheels in a mobile robot.
//
// =============================================================================
#include "chrono/core/ChRealtimeStep.h"
#include "chrono/physics/ChLinkMotorRotationSpeed.h"
#include "chrono/physics/ChSystemNSC.h"
#include "chrono/physics/ChBodyEasy.h"
#include "chrono/utils/ChUtilsGeometry.h"
#include "chrono/assets/ChBarrelShape.h"
#include "chrono_irrlicht/ChVisualSystemIrrlicht.h"
// Use the namespaces of Chrono
using namespace chrono;
using namespace chrono::irrlicht;
// Use the main namespaces of Irrlicht
using namespace irr;
using namespace irr::core;
using namespace irr::scene;
using namespace irr::video;
using namespace irr::io;
using namespace irr::gui;
double STATIC_rot_speed = 0;
double STATIC_x_speed = 0;
double STATIC_z_speed = 0;
float STATIC_wheelfriction = 0.6f;
#define MAX_ROT_SPEED 0.8
#define MAX_XZ_SPEED 10
class MyEventReceiver : public IEventReceiver {
public:
MyEventReceiver() {}
bool OnEvent(const SEvent& event) {
// check if user presses keys
if (event.EventType == irr::EET_KEY_INPUT_EVENT && !event.KeyInput.PressedDown) {
switch (event.KeyInput.Key) {
case irr::KEY_KEY_Q:
STATIC_x_speed += 1.5;
if (STATIC_x_speed > MAX_XZ_SPEED)
STATIC_x_speed = MAX_XZ_SPEED;
return true;
case irr::KEY_KEY_W:
STATIC_x_speed -= 1.5;
if (STATIC_x_speed < -MAX_XZ_SPEED)
STATIC_x_speed = -MAX_XZ_SPEED;
return true;
case irr::KEY_KEY_A:
STATIC_z_speed += 1.5;
if (STATIC_z_speed > MAX_XZ_SPEED)
STATIC_z_speed = MAX_XZ_SPEED;
return true;
case irr::KEY_KEY_Z:
STATIC_z_speed -= 1.5;
if (STATIC_z_speed < -MAX_XZ_SPEED)
STATIC_z_speed = -MAX_XZ_SPEED;
return true;
case irr::KEY_KEY_E:
STATIC_rot_speed += 0.05;
if (STATIC_rot_speed > MAX_ROT_SPEED)
STATIC_rot_speed = MAX_ROT_SPEED;
return true;
case irr::KEY_KEY_R:
STATIC_rot_speed -= 0.05;
if (STATIC_rot_speed < -MAX_ROT_SPEED)
STATIC_rot_speed = -MAX_ROT_SPEED;
return true;
default:
break;
}
}
return false;
}
};
// This small function creates a Mecanum wheel, made with many ChBodySceneNode rigid bodies (a central
// wheel and the many radial rollers, already lined to the wheel with revolute joints.)
// The function returns the pointer to the central wheel.
std::shared_ptr<ChBody> create_mecanum_wheel(ChSystemNSC& sys,
ChVector<> shaft_position,
ChQuaternion<> shaft_alignment,
double wheel_radius,
double wheel_width,
int n_rollers,
double roller_angle,
double roller_midradius,
double roller_density,
double spindle_density) {
ChFrameMoving<> ftot(shaft_position, shaft_alignment); // will be used to transform pos & rot of all objects
auto centralWheel = chrono_types::make_shared<ChBodyEasyCylinder>(wheel_radius / 2, wheel_width, // radius, height
spindle_density, // density
true, // visualize
false); // no collision
centralWheel->SetPos(shaft_position);
centralWheel->SetRot(shaft_alignment);
centralWheel->GetVisualShape(0)->SetTexture(GetChronoDataFile("textures/pinkwhite.png"));
sys.Add(centralWheel);
auto wheel_mat = chrono_types::make_shared<ChMaterialSurfaceNSC>();
wheel_mat->SetFriction(STATIC_wheelfriction);
double half_length_roller = 0.5 * wheel_width * 1.0 / (cos(roller_angle));
double roller_elliptical_rad_Hor = wheel_radius;
double roller_elliptical_rad_Vert = wheel_radius * 1.0 / (cos(roller_angle));
for (int iroller = 0; iroller < n_rollers; iroller++) {
double pitch = CH_C_2PI * ((double)iroller / (double)n_rollers);
double Roffset = -(wheel_radius - roller_midradius);
// Create the roller
auto roller = chrono_types::make_shared<ChBody>();
sys.Add(roller);
// move it to slanted aligment
ChFrameMoving<> f1(ChVector<>(0, 0, -(wheel_radius - roller_midradius)),
Q_from_AngAxis(roller_angle, ChVector<>(0, 0, 1)));
ChFrameMoving<> f2(ChVector<>(0, 0, 0), Q_from_AngAxis(pitch, ChVector<>(0, 1, 0)));
ChFrameMoving<> f3 = f1 >> f2 >> ftot;
// approximate mass & inertia to a cylinder:
roller->SetMass(utils::CalcCylinderVolume(roller_elliptical_rad_Hor + Roffset, 2 * half_length_roller) *
roller_density);
roller->SetInertia(utils::CalcCylinderGyration(roller_elliptical_rad_Hor + Roffset, 2 * half_length_roller) *
roller_density);
// add collision shape
roller->GetCollisionModel()->ClearModel();
roller->GetCollisionModel()->AddBarrel(wheel_mat, //
-half_length_roller, +half_length_roller, //
roller_elliptical_rad_Vert, roller_elliptical_rad_Hor, //
Roffset);
roller->GetCollisionModel()->BuildModel();
roller->SetCollide(true);
// add visualization shape
auto rollershape =
chrono_types::make_shared<ChBarrelShape>(-half_length_roller, +half_length_roller, //
roller_elliptical_rad_Vert, roller_elliptical_rad_Hor, //
Roffset);
roller->AddVisualShape(rollershape);
// Make the revolute joint between the roller and the central wheel
// (preconcatenate rotation 90 degrees on X, to set axis of revolute joint)
ChFrameMoving<> fr(ChVector<>(0, 0, 0), Q_from_AngAxis(CH_C_PI / 2.0, ChVector<>(1, 0, 0)));
ChFrameMoving<> frabs = fr >> f3;
auto link_roller = chrono_types::make_shared<ChLinkLockRevolute>();
link_roller->Initialize(roller, centralWheel, frabs.GetCoord());
sys.AddLink(link_roller);
}
return centralWheel;
}
int main(int argc, char* argv[]) {
GetLog() << "Copyright (c) 2017 projectchrono.org\nChrono version: " << CHRONO_VERSION << "\n\n";
// Create a ChronoENGINE physical system
double platform_radius = 8;
double wheel_radius = 3;
double roller_angle = CH_C_PI / 4;
// Create the robot truss, as a circular platform
auto platform = chrono_types::make_shared<ChBodyEasyCylinder>(platform_radius * 0.7, 2, // radius, height
1000, // density
true, // visualize
false); // no collision
sys.Add(platform);
// ChCollisionModel::SetDefaultSuggestedEnvelope(0.01);
// ChCollisionModel::SetDefaultSuggestedMargin(0.005);
// create the wheels and link them to the platform
ChFrame<> f0(ChVector<>(0, 0, 0), Q_from_AngAxis(CH_C_PI / 2.0, ChVector<>(1, 0, 0)));
ChFrame<> f1(ChVector<>(0, 0, platform_radius), QUNIT);
ChFrame<> f2_wA(VNULL, Q_from_AngAxis(0 * (CH_C_2PI / 3.0), ChVector<>(0, 1, 0)));
ChFrame<> f2_wB(VNULL, Q_from_AngAxis(1 * (CH_C_2PI / 3.0), ChVector<>(0, 1, 0)));
ChFrame<> f2_wC(VNULL, Q_from_AngAxis(2 * (CH_C_2PI / 3.0), ChVector<>(0, 1, 0)));
ChFrame<> ftot_wA = f0 >> f1 >> f2_wA;
ChFrame<> ftot_wB = f0 >> f1 >> f2_wB;
ChFrame<> ftot_wC = f0 >> f1 >> f2_wC;
auto spindle_A = create_mecanum_wheel(sys,
ftot_wA.GetCoord().pos, // wheel position
ftot_wA.GetCoord().rot, // wheel alignment
wheel_radius, // wheel radius
2.2, // wheel width
8, // n. of rollers
roller_angle, // angle of rollers
0.65, // max rad. of roller
1000, // density of roller
1000); // density of the spindle
auto link_shaftA = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
link_shaftA->Initialize(spindle_A, platform, (f1 >> f2_wA));
link_shaftA->SetSpeedFunction(chrono_types::make_shared<ChFunction_Const>(0));
sys.AddLink(link_shaftA);
auto spindle_B = create_mecanum_wheel(sys,
ftot_wB.GetCoord().pos, // wheel position
ftot_wB.GetCoord().rot, // wheel alignment
wheel_radius, // wheel radius
2.2, // wheel width
8, // n. of rollers
roller_angle, // angle of rollers
0.65, // max rad. of roller
1000, // density of roller
1000); // density of the spindle
auto link_shaftB = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
link_shaftB->Initialize(spindle_B, platform, (f1 >> f2_wB));
link_shaftB->SetSpeedFunction(chrono_types::make_shared<ChFunction_Const>(0));
sys.AddLink(link_shaftB);
auto spindle_C = create_mecanum_wheel(sys,
ftot_wC.GetCoord().pos, // wheel position
ftot_wC.GetCoord().rot, // wheel alignment
wheel_radius, // wheel radius
2.2, // wheel width
8, // n. of rollers
roller_angle, // angle of rollers
0.65, // max rad. of roller
1000, // density of roller
1000); // density of the spindle
auto link_shaftC = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
link_shaftC->Initialize(spindle_C, platform, (f1 >> f2_wC));
link_shaftC->SetSpeedFunction(chrono_types::make_shared<ChFunction_Const>(0));
sys.AddLink(link_shaftC);
// Create the ground for the collision
auto ground_mat = chrono_types::make_shared<ChMaterialSurfaceNSC>();
ground_mat->SetFriction(STATIC_wheelfriction);
auto ground = chrono_types::make_shared<ChBodyEasyBox>(200, 1, 200, // size
1000, // density
true, // visualize
true, // collide
ground_mat); // contact material
ground->SetPos(ChVector<>(0, -5, 0));
ground->SetBodyFixed(true);
ground->GetVisualShape(0)->SetTexture(GetChronoDataFile("textures/concrete.jpg"), 100, 100);
sys.Add(ground);
// Create the Irrlicht visualization system
auto vis = chrono_types::make_shared<ChVisualSystemIrrlicht>();
vis->AttachSystem(&sys);
vis->SetWindowSize(800, 600);
vis->SetWindowTitle("Mecanum robot simulator");
vis->Initialize();
vis->AddLogo();
vis->AddSkyBox();
vis->AddCamera(ChVector<>(0, 14, -20));
vis->GetGUIEnvironment()->addStaticText(L"Use keys Q,W, A,Z, E,R to move the robot", rect<s32>(150, 10, 430, 40),
true);
MyEventReceiver receiver;
vis->AddUserEventReceiver(&receiver);
// Prepare the physical system for the simulation
sys.SetTimestepperType(ChTimestepper::Type::EULER_IMPLICIT_PROJECTED);
// Simulation loop
double timestep = 0.01;
ChRealtimeStepTimer realtime_timer;
while (vis->Run()) {
vis->BeginScene();
vis->Render();
vis->EndScene();
// ADVANCE THE SIMULATION FOR ONE TIMESTEP
sys.DoStepDynamics(timestep);
// change motor speeds depending on user setpoints from GUI
ChVector<> imposed_speed(STATIC_x_speed, 0, STATIC_z_speed);
ChFrame<> roll_twist(ChVector<>(0, -wheel_radius, 0), Q_from_AngAxis(-roller_angle, ChVector<>(0, 1, 0)));
ChFrame<> abs_roll_wA = roll_twist >> f2_wA >> ChFrame<>(platform->GetCoord());
double wheel_A_rotspeed =
(STATIC_rot_speed * platform_radius) +
((abs_roll_wA.GetA().transpose() * imposed_speed).x() / sin(roller_angle)) / wheel_radius;
ChFrame<> abs_roll_wB = roll_twist >> f2_wB >> ChFrame<>(platform->GetCoord());
double wheel_B_rotspeed =
(STATIC_rot_speed * platform_radius) +
((abs_roll_wB.GetA().transpose() * imposed_speed).x() / sin(roller_angle)) / wheel_radius;
ChFrame<> abs_roll_wC = roll_twist >> f2_wC >> ChFrame<>(platform->GetCoord());
double wheel_C_rotspeed =
(STATIC_rot_speed * platform_radius) +
((abs_roll_wC.GetA().transpose() * imposed_speed).x() / sin(roller_angle)) / wheel_radius;
if (auto fun = std::dynamic_pointer_cast<ChFunction_Const>(link_shaftA->GetSpeedFunction()))
fun->Set_yconst(wheel_A_rotspeed);
if (auto fun = std::dynamic_pointer_cast<ChFunction_Const>(link_shaftB->GetSpeedFunction()))
fun->Set_yconst(wheel_B_rotspeed);
if (auto fun = std::dynamic_pointer_cast<ChFunction_Const>(link_shaftC->GetSpeedFunction()))
fun->Set_yconst(wheel_C_rotspeed);
realtime_timer.Spin(timestep);
}
return 0;
}
void AddTypicalLights()
Simple shortcut to set two point lights in the scene.
Definition: ChVisualSystemIrrlicht.cpp:274
std::string GetChronoDataFile(const std::string &filename)
Obtain the complete path to the specified filename, given relative to the Chrono data directory (thre...
Definition: ChGlobal.cpp:95
void Add(std::shared_ptr< ChPhysicsItem > item)
Attach an arbitrary ChPhysicsItem (e.g.
Definition: ChSystem.cpp:183
void AddSkyBox(const std::string &texture_dir=GetChronoDataFile("skybox/"))
Add a sky box in a 3D scene.
Definition: ChVisualSystemIrrlicht.cpp:287
virtual void Initialize()
Initialize the visualization system.
Definition: ChVisualSystemIrrlicht.cpp:151
ChLog & GetLog()
Global function to get the current ChLog object.
Definition: ChLog.cpp:39
bool Run()
Run the Irrlicht device.
Definition: ChVisualSystemIrrlicht.cpp:205
virtual void AddLink(std::shared_ptr< ChLinkBase > link)
Attach a link to the underlying assembly.
Definition: ChSystem.cpp:168
void AddCamera(const ChVector<> &pos, ChVector<> targ=VNULL)
Add a camera in an Irrlicht 3D scene.
Definition: ChVisualSystemIrrlicht.cpp:256
Representation of a 3D transform.
Definition: ChFrame.h:34
ChQuaternion< double > Q_from_AngAxis(double angle, const ChVector< double > &axis)
Get the quaternion from an angle of rotation and an axis, defined in abs coords.
Definition: ChQuaternion.cpp:100
virtual void BeginScene(bool backBuffer=true, bool zBuffer=true, ChColor color=ChColor(0, 0, 0))
Clean the canvas at the beginning of each animation frame.
Definition: ChVisualSystemIrrlicht.cpp:489
const ChApi ChQuaternion< double > QUNIT
Constant unit quaternion: {1, 0, 0, 0} , corresponds to no rotation (diagonal rotation matrix)
Namespace with classes for the Irrlicht module.
Definition: ChApiIrr.h:48
Class for a timer which attempts to enforce soft real-time.
Definition: ChRealtimeStep.h:25
Projected SOR (Successive Over-Relaxation)
void Spin(double step)
Call this function INSIDE the simulation loop, just ONCE per loop (preferably as the last call in the...
Definition: ChRealtimeStep.h:34
Definition of general purpose 3d vector variables, such as points in 3D.
Definition: ChVector.h:35
void AddUserEventReceiver(irr::IEventReceiver *receiver)
Attach a custom event receiver to the application.
Definition: ChVisualSystemIrrlicht.cpp:368
void SetSolverType(ChSolver::Type type)
Choose the solver type, to be used for the simultaneous solution of the constraints in dynamical simu...
Definition: ChSystem.cpp:259
int DoStepDynamics(double step_size)
Advances the dynamical simulation for a single step, of length step_size.
Definition: ChSystem.cpp:1426
virtual void EndScene()
End the scene draw at the end of each animation frame.
Definition: ChVisualSystemIrrlicht.cpp:534
void SetSolverMaxIterations(int max_iters)
Set the maximum number of iterations, if using an iterative solver.
Definition: ChSystem.cpp:233
ChFrameMoving: a class for coordinate systems in 3D space.
Definition: ChFrameMoving.h:38
void SetWindowTitle(const std::string &win_title)
Set the windoiw title (default "").
Definition: ChVisualSystemIrrlicht.cpp:118
ChCoordsys< Real > & GetCoord()
Return both current rotation and translation as a coordsystem object, with vector and quaternion.
Definition: ChFrame.h:191
virtual void AttachSystem(ChSystem *sys) override
Attach another Chrono system to the run-time visualization system.
Definition: ChVisualSystemIrrlicht.cpp:135
Class defining quaternion objects, that is four-dimensional numbers, also known as Euler parameters.
Definition: ChQuaternion.h:45
virtual void Render()
Draw all 3D shapes and GUI elements at the current frame.
Definition: ChVisualSystemIrrlicht.cpp:544
Main namespace for the Chrono package.
Definition: ChBarrelShape.cpp:17
void SetTimestepperType(ChTimestepper::Type type)
Set the method for time integration (time stepper type).
Definition: ChSystem.cpp:459
ChMatrix33< Real > & GetA()
Return the current rotation as a 3x3 matrix.
Definition: ChFrame.h:203
void AddLogo(const std::string &logo_filename=GetChronoDataFile("logo_chronoengine_alpha.png"))
Add a logo in a 3D scene.
Definition: ChVisualSystemIrrlicht.cpp:248
Class for a physical system in which contact is modeled using a non-smooth (complementarity-based) me...
Definition: ChSystemNSC.h:29
void ConcatenatePreTransformation(const ChFrameMoving< Real > &T)
Apply a transformation (rotation and translation) represented by another ChFrameMoving T.
Definition: ChFrameMoving.h:331
void SetWindowSize(unsigned int width, unsigned int height)
Set the window size (default 640x480).
Definition: ChVisualSystemIrrlicht.cpp:115