How to make a holonomic, omniwheel robot?

A robot that uses omni-wheels can move in any direction, at any angle, without rotating beforehand. If you want a robot that can straff, use an omni-wheel robot. If you want a robot that can spin while translating forward at the same heading, then you want this type of robot.


Look at this video, how cool this is....

The Omni-Wheel 

So how does a robot that can move omni-directionally work? The trick is that it uses special wheels . . . The omni-wheel is not actually just a single wheel, but many wheels in one. There is the big core wheel, and along the peripheral there are many additional small wheels that have the axis perpendicular to the axis of the core wheel. The core wheel can rotate around its axis like any normal wheel, but now that there are additional wheels perpendicular

to it, the core wheel can also move parallel to it's own axis.


Holonomic vs Non-Holonomic Robots 

There are only two types of mobile robots, holonomic robots and non-holonomic robots. Non-holonomic robots are ones that cannot instantaneously move in any direction, such as a car. This type of robot has to perform a set of motions to change heading. For example, if you want your car to move sideways, you must perform a complex 'parallel parking' motion. For the car to turn, you must rotate the wheels and drive forward. This type of robot would have '1.5' degrees of freedom, meaning that it can move in both the X and Y direction, but requires complex motions to achieve the X direction.

A holonomic robot however can instantaneously move in any direction. It does not need to do any complex motions to achieve a particular heading. This type of robot would have 2 degrees of freedom in that it can move in both the X and Y plane freely. A robot arm typically is omni-directly too, with many more degrees of freedom.


3 Wheels vs 4 Wheels 

Most omni-wheel robots consist of a triangular platform and three wheels. But it is possible, and often better, to use four wheels. There is only one good reason why three wheels are better - three wheels and three motors are cheaper than four of each.

There is however a problem inherent with four wheel vehicles, and that is the fact that four points are not guaranteed to be on the same plane. Three points are. If your four wheeled robot encounters uneven terrain, there is a good chance that one of those wheels will not be in contact with the ground - holy squirrels! But there are many simple solutions to this. Cars use spring shocks. You can use a thin flexible aluminum base on which the servos are mounted, able to bend and flex with the terrain. Or you can make springs with a 3D printer.


But I would argue that, with the exception of cost and a small increase in complexity, four wheel designs are better.

Firstly, four wheels are more efficient. With a three wheel design, it is impossible to get 100% efficiency from its wheels. This is because in three wheel designs, no more than one wheel will ever be aligned with the direction of motion. But with four, two wheels can move at 100% efficiency, while the other two remain idle, for full speed more efficient motion. All other angles will also be more efficient than with a three-wheeled omni-wheel robot.

As you can see, in the four wheel design, two wheels are rotating and contributing 100% to motion, while the other two are not moving at all and acting as castors. For this reason, a four-wheeled omni-wheel robot is faster, while using as much or less motor energy.

The other main reason why four wheels are easier is for computational reasons. Four wheels are at 90 degrees to each other, while three wheels are at 120 degree angles. What does this mean? Four wheel designs have wheels directly opposite of each other, meaning a pair of wheels just needs a single calculation, with one wheel receiving a negative number while the other positive. Three wheel designs have no wheel pairs, meaning three calculations are required.


Control of an Omni Wheel Robot 

For an omni-wheel robot to translate at a particular angle, each wheel must rotate at a particular rotational velocity and direction. Since the robot is moving at angles, it will need to do trigonometric calculations to determine these wheel speeds. However trigonometric calculations are not always possible, since control of an omni-wheel robot very much depends on your robots computational processing ability. If you are using a PC or palmpilot as the robot controller, your robot could do thousands of trig calculations per second. However most microcontrollers cannot. A microcontroller (such as a PIC or AVR), not doing anything else, can do about three trig calculations per second.


But unfortunately your robot also needs to read from sensors, drive servos, interpret data, and many other things. Instead, you will need to use what is called a trigonometric lookup table. Basically you do the trig calculations before hand and save them in memory, and the program just references a list. It wont be 100% accurate, or as elegant in code, but it will be much much faster - its a balance of speed and accuracy. An accuracy within 10 degrees worked fairly well.


As for position control, this is impossible with an omni-wheel robot. The omni-wheel works on the basis of wheel slippage, so using things likeencoders for position will not work. You must have the robot detect it's surroundings to track its motion accurately - IMU's, gyros, visual tracking, etc. will work. At you will find many items you will need to do this. 



Optimization of actuator control is a little complicated. There are several things you need to consider:


Angle control. For an omni-wheel robot to translate at a certain angle, each motor needs to go at a certain speed with relation to the others. The speed doesnt matter, just the ratios

Motor speed. The faster the motors go, the faster the robot goes

Rotational control. For an omni-wheel robot to rotate at some particular speed, it must add or subtract equally from the motor speed of each motor

Maximum motor speed. Motors can only go so fast, so when you do ratios, and rotational control additions, you must make sure that you are not commanding a motor to go faster than it can

Global angle. You may or may not want to control for the angle of the robot to it's surroundings.


So how do you do this? Well you do these calculations in this order:

1) Calculate motor ratios to determine translation angle. Do this using the trig lookup tables. It is much much faster than doing sin/cos computations.


2) Calculate rotational velocity constant. Just add or subtract some constant to the translation motor speeds to rotate clockwise or counterclockwise.


3) Check and correct to make sure maximum motor speed isnt exceeded. Suppose maximum speed is 100, but your four-wheel calculations call for motor speeds at 50, -50, -110, and 110. Well the ratio is 50/-50/-110/110. It must be X/-X/-100/100, with an unknown X value, based on a maximum speed of 100. Using algebra, your equation then becomes:

50/110 = X/100 

X = 45.45 =~46

The motor speeds become 46/-46/-100/100.


Again, this calculation is more difficult for a three-wheeled omni-wheel robot, but the calculation can be done in the same manner. You can also slow the robot down by changing the maximum velocity in software.


we copied information from wehre you can find much more. 


Below you find another mathematical approach. the last two sheets give exactly the formula you need for a four wheel robot.

int motorSpeed(float velocity, float phi, float omega)

// compute the velocity of the different wheels. dirPin1x, dirPin2x, SpeedPinx are the digital output pins that have to be #defined. SpeedPinx is PWM

// these are connected to 4 H bridges. We use L293H. 


  int code = 0; 

  const float sfactor = 0,11; // sfactor = 2 * s , s = 0,11 meter de straal van de robot. Zie het logboek. datum 21 augustus 2016. voor test aangepast naar 1. 

  float omegafactor = sfactor*omega; 


  float vx=cos(phi)*velocity;   // snelheid is waarde tussen 0 en 1;  

  float vy=sin(phi)*velocity;


  float va= vx-vy-omegafactor;  // formules zie logboek 21 augustus 2016  

  float vb= vx+vy-omegafactor;  // motoren moeten met de wijzers van de klok meedraaien 

  float vc=-vx+vy-omegafactor;  // 0 radiaal (0 graden) = rechtvooruit. graden gaan met de klok mee  

  float vd=-vx-vy-omegafactor;  // motor A is motor op 45 graden / 1/4 pi radiaal 


  float maxpos=max(vd,max(vc,max(va,vb)));

  float maxneg=min(vd,min(vc,min(va,vb)));

  float maxabs=max(abs(maxpos),abs(maxneg));

  if (maxabs>=1) {













  return code;