# What are the 45 degree angels called?

I’ve seen a couple robots at a scrimage with four wheels all angeled at about 45 degrees. It moves wonderfully, much better than just a 1-1 ratio drive train.
Does anyone know what it is offically called and how you would possibly do it? is there special programming or is it just channels 1234?

I’m assuming that the drive train your talking about had 4 omni wheels placed at 90 degree angles to each other (45 degrees to the direction of movement) and it could move in many direction if so this is called a holonomic drive or more commonly and omni drive. They work because they channel all the force from the drive motrs in a particuls direction. It’s kinda hard to explain over the internet but there really simple if you ever see them. Programming them is a bit harder but i have programmed a few of them before if you interested in seeing the code then send me a PM or post it here.

Edit:

heres some code:

#include “Main.h”

void main ( void )
{
int LF; // Left Front
int RF; // Right Front
int LR; // Left Rear
int RR; // Right Rear
int leftx;
int lefty;
int rightx;
int spin;
while ( 1 )
{
// Get Data
leftx = GetRxInput ( 1 , 4 ) ; // Left Joystick, X Axis
lefty = GetRxInput ( 1 , 3 ) ; // Left Joystick, Y Axis
rightx = GetRxInput ( 1 , 1 ) ; // Right Joystick, X Axis
// Half the input signal (so code does not overflow past 255)
leftx = leftx / 2 ;
lefty = lefty / 2 ;
spin = rightx / 2 ;
// Drive Code Algorithim
LF = RR = lefty - leftx + 127 ;
RF = LR = 255 - lefty - leftx ;
RR = 255 - RR ; // Reverse Direction of RR motor
LR = 255 - LR ; // Reverse Direction of LR motor
// Spin Code Algorithim
RF = RF - spin + 63 ;
RR = RR - spin + 63 ;
LF = LF - spin + 63 ;
LR = LR - spin + 63 ;
// Code overflow prevention
if ( LF < 0 )
{
LF = 0 ;
}
else if ( LF > 255 )
{
LF = 255 ;
}
if ( RF < 0 )
{
RF = 0 ;
}
else if ( RF > 255 )
{
RF = 255 ;
}
if ( RR < 0 )
{
RR = 0 ;
}
else if ( RR > 255 )
{
RR = 255 ;
}
if ( LR < 0 )
{
LR = 0 ;
}
else if ( LR > 255 )
{
LR = 255 ;
}
// Set Motors
SetMotor ( 1 , RF ) ;
SetMotor ( 2 , LF ) ;
SetMotor ( 3 , LR ) ;
SetMotor ( 4 , RR ) ;
}
}

took it from here http://www.chiefdelphi.com/forums/showthread.php?t=40723&page=2&highlight=holonomic+drive thats what i based my code off of if you convert this all into the block version of easyC it should work or you can copy all of this into C code blocks of easyc and it will work also further down that page is a illustration of how the wheels work.

-Dustin

Close, but not quite. They channel a significant fraction of the force all 4 wheels exert, into making the machine move. The rest is wasted (the wheels partially oppose each other in addition to combining to make the machine move).

As you know, folks accept the loses, because they get extreme maneuverability in exchange.

Lehman - Be warned - If a holonomic gets into a pushing/pulling contest with a “regular” drive train, if all other things are equal, the holonomic will lose. It has agility, but not much friction and some of its motors’ output gets wasted (on purpose). With a holonomic you need an intended use (a strategy) that lets you succeed by avoiding obstacles rather than overcoming them.

Blake

Cold cherubs?

My original holonomic code and diagrams certainly get a lot of mileage. One of these days I think I’m going to work on a [relatively] simple absolute holonomic drive code using lookup tables instead of floating point math and a breakout board gyro.

Alright, So I used the program, put it into easy C and made sure everything matched. It does, but when I turn on my bot all the wheels spin… Not touching anything, and one of them is much slower than the others.