mecanum programming

[mrmummert]

Hello...

Last year someone posted a link for information on programming for mecanum wheels usage. Does anyone remember what it was. Our team
is concidering this this year. Any help will be greatly appreciated.

Thank You

[pyr0m_1595]

We're considering it this year; I'd PM or email the main programmer. His forum name's cprogrammer.

[EricS-Team180]

well....

Start here...

and then use the search tool to look for keywords like omni wheel and holonomic and kiwi There are numerous posts and good info out there

SPAM built an omni wheel 'bot for the 2004 game. It was successful, but you will trade off agility for traction and pushing power. Do you wish to run with the big dogs? Or dance around them!

Eric

[Alan Anderson]

This is what we use for a simple open-loop mecanum drivebase. Default_Routine() computes internal speed, turn rate, and slide (sideways travel) values from the joystick inputs, then computes motor speeds from the internal values.

The p1 joystick is on the left, and p2 is on the right.
pwm01 is the right front motor, pwm02 is the left front, pwm03 is the right rear, and pwm04 is the left rear.
rc_dig_in01 is a "deadman" switch which sets the motors to neutral unless it is closed. This was intended to be used by people "riding" the robot.

/*******************
function:	deadband()
inputs:	inp, input value
		center, value of input that represents neutral
		band, size of deadband to consider neutral
output:	scaled and deadband-compensated output value
		inputs below center will yield negative output
		inputs above center will yield positive output
		inputs within deadband either side of center will yield 0
usage:	typically call with joystick value (0-254) as input,
		joystick neutral (127) as center, and a small number (5)
		as the size of the deadband.  The white POS joysticks
		should probably have a much larger band (10) instead.
*******************/
int deadband(int inp, int center, int band)
{
int oup;
	if (inp < center-band)
		oup = inp - center + band;
	if (center-band <= inp && inp <= center+band)
		oup = 0;
	if (center+band < inp)
		oup = inp - center - band;
	return oup;
}

/*********************
function:	pwm_limit()
inputs:	inp, input value
output:	scaled and range-limited output value
usage:	call with signed value (+/- 127) as input,
		will return a valid pwm value
*********************/
unsigned char pwm_limit (signed int inp)
{
	if(inp<-127)
		inp = -127;
	if (inp>127)
		inp = 127;
	inp = inp+127;

	return (char)inp;
}

/*******************************************************************************
* FUNCTION NAME: Default_Routine
* PURPOSE:       Performs the default mappings of inputs to outputs for the
*                Robot Controller.
* CALLED FROM:   this file, Process_Data_From_Master_uP routine
* ARGUMENTS:     none
* RETURNS:       void
*******************************************************************************/
void Default_Routine(void)
{
signed int speed, turn, slide;
signed int front_r, front_l, back_r, back_l;
long int l_y, r_y, l_x, r_x;

	l_y = deadband(p1_y,127,10);
	r_y = deadband(p2_y,127,10);
	l_x = deadband(p1_x,127,10);
	r_x = deadband(p2_x,127,10);

	l_y = l_y/2;
	r_y = r_y/2;
	l_x = l_x/2;
	r_x = r_x/2;

	speed = l_y+r_y;
	turn = l_y-r_y;
	slide = -l_x-r_x;
  
  	front_r = speed-turn+slide;
	front_l = speed+turn-slide;
	back_r = speed-turn-slide;
	back_l = speed+turn+slide;

if (rc_dig_in01 == 0)
{
	pwm01 = pwm_limit(front_r);
	pwm02 = pwm_limit(front_l);
	pwm03 = pwm_limit(back_r);
	pwm04 = pwm_limit(back_l);
}
else
{
	pwm01 = 127;
	pwm02 = 127;
	pwm03 = 127;
	pwm04 = 127;
}

[kaszeta]

Originally Posted by Alan Anderson

This is what we use for a simple open-loop mecanum drivebase. Default_Routine() computes internal speed, turn rate, and slide (sideways travel) values from the joystick inputs, then computes motor speeds from the internal values.

This is pretty similar to what Team 95 has used on holonomic/omni test robots in the past (we haven't competed with one since around '97 or so, however).

It's easy for things like variations in the carpet and motor differences to cause your drive mechanism to drive slightly off. You should consider adding a gyroscope and feedback loop so your bot can drive 100% straight (and there's good code examples out there for doing this).

And, with the USB Chiklet available this year, it's really easy to use a three-axis joystick, so it's not hard to control an omni-robots three degrees of freedom direct from one joystick.

[dtengineering]

It looks like we aren't the only team who is going to be trying out mecanums this year... just a couple of tips when searching for info, so far I have found results by searching for a couple of common spellings:

meccanum
mechanum and
mecanum

All produce results.

FIRST has info at http://www.usfirst.org/uploadedFiles...heels_Hine.ppt

and the CD white papers have a great power point presentation called "strafing", I believe that runs you through the derivation of the formulas used for a variety of omni-drive systems.

Good luck, and have fun going sideways.

Jason

[mrmummert]

Thanks guys...Hmmmm....will send this along to our programmers

Our team's programmer (<--Yes singular!!) worked out all the math to use the omniwheels, and the mechanum twice, with the wheels oriented differently. Turns out, since we have no money, that we won't be using any holonomic drive this year.

[DustinB_3]

I am trying to use the code posted above but I am not able to make it strafe using the code. Is there as simple way of doing this. Help is appreciated.

[Alan Anderson]

If by "strafe" you mean travel sideways, the code I posted does that when the joysticks are pushed sideways.

[DustinB_3]

I am using your code but when I move both joysticks to one side the wheels spin but the robot stays in place. All the wheels either spin inward or all wheels spin outward but never one side spins inward and the other spins outward.

[Alan Anderson]

You're using terms that I don't understand. How does a wheel spin "inward" or "outward"?

This code is for a mecanum drive base, with four mecanum wheels all mounted so they spin either forward or backward. The "handedness" of the wheels is important, and it's possible to set things up in one of two ways. One way has the angled rollers contacting the floor so that the robot can very nearly spin in place without any of the wheels turning. This code assumes the other way, where the angled rollers resist spinning in place when the wheels are stationary.

The "meat" of the code is these four lines:

  	front_r = speed-turn+slide;
	front_l = speed+turn-slide;
	back_r = speed-turn-slide;
	back_l = speed+turn+slide;

All wheels drive at the same rate based on the (forward) speed. The left motors drive more and the right motors drive less based on the (right-hand) turn. The motors on one diagonal drive more in one direction, and the motors on the other diagonal drive more in the other direction, based on the sideways slide.

You might need to change the sign of some of these parts based on how your motors are wired.

[DustinB_3]

I got your code to work and it works great. One problem: speed controls orange light goes off or blinks about every 5 minutes and we have to recalibrate the speed controls. Is there any way to alleviate or completely fix this. Help is greatly appreciated.

[Alan Anderson]

Originally Posted by DustinB_3

...speed controls orange light goes off or blinks about every 5 minutes and we have to recalibrate the speed controls...

Are you using the white joysticks from the Kit of Parts? The mechanical trim adjustment on the ones I know from prior years has a habit of moving by itself when you push the joystick far from the center. If that's your problem, try taping it down or using a spot of hot melt glue to keep it in place.

[DustinB_3]

We'll try that. That's what I think the problem is but our drivers think it's all because of the code. We are using black joysticks from a while ago. They have a square base.