Roundup Mentor Bot

RoundUp Mentor Bot:

I mentioned in an earlier post that I built  a prototype High hanging robot that tries to do it all.  Has 38 inch reach with a dual bobcat type linear slides.  It has a plunger and a pincher which allow it to quickly pick up and deposit tubes and also take a few tubes off a goal if need be.  Uses 4 big motors (2 wire) on the lifter , 2 servos, and only 2 direct drive motors.  Might add two motors and increase speed.  Takes about 6 seconds to lift once the initial grip is established.

8/4/2010 Update

Well, after a month of messing around with different configurations… I settled for just a plunger.   This can pick up 4 tubes and drop 1 at a time or all at once.   The pincher worked ok but didn’t have the height necessary to make it functional  so I dropped it.  I decided to focus the design on the programming challenge where a defensive pincher that can remove tubes would not be required.  The bobcat design can easily handle an external claw gripper rather than a plunger.  If a claw is used, then it can readily put tubes on or off any goal.

Slide Friction:

Friction in the linear slides is the major design issue.   When the robot is held by hand from the top , the slides will pull the base up a distance of 19 inches… enough for a high hang…..but when the upper slide is attached to the A frame fixture, the weight of the robot puts an added torque that tends to bend the slides into each other …thus creating more friction.    The lower slides are adequate to lift the base over 6 inches but once the upper slide tries to actuate, it stalls.   This may be too much to over come… we’ll see.  If not, this robot is stuck with 10 bonus points.

Sonic Sensors:

I included two sonic sensors on the front to sense walls and possibly the white base , but it probably won’t be useful.  The sonic sensors cannot detect the base as I had hoped.  Seems the reflections are just deflected in the wrong direction with the rounded base.


The software is complete….. it has all the necessary functions and automatic modes required to accurately move around based upon encoder inputs , track lines, hold heading, turn through a segment, and actuate the lifts and plunger grips.


This is a feature I have used in a lot of robots.  It uses the front four switches of the vex joystick to control the autonomous functions as an operator would.   By pressing the top two buttons for 3 seconds, it puts you into a ready for autonomous script mode.   When the lower_left is pushed, the script starts.  It will either do the complete script if the lower_right was pushed or it will step through each segment if the upper_right was pushed. It will disconnect and return to manual if the upper_left is pushed again.

This is a very nice feature and allows lots of debug with just the joy_stick.  When the autonomous script is done or disconnected, it automatically returns the robot to manual control for setting up the next test.

If the bool_autonomous = true  then the auto_debug_mode is overridden and you go the the normal autonomous mode that just runs the script.


I configured the script to take simple functions that use typically one or two parameters.  E.G.

if(step ==1)


done =move_encoder( dist_goal, set_speed)


else if (step == 2) …..

The step 1  sets the motors to move forward at set_speed and does the compare against the average encoder readings.  When the goal is reached, done goes from 0 to 1 and the next step is signaled.  There is no while() function in the script functions.  They act as code that set speeds and commands for the core functions and are executed by the main() while loop.  A global reset flag is used to initialize each script at its proper values.

Typical script function looks like the   move_encoder(..) shown below.

int move_encoder(int goal , int fwd_speed )

static int target = 0;
static int imdone = 0;

imdone = 0;
target = dist_10in + goal;
if (goal >=0) pwm_sym = fwd_speed ;
else pwm_sym = -fwd_speed;
return 0;
if (goal > 0  && (dist_10in < target) && imdone == 0) return 0;
else if (goal < 0  && (dist_10in > target) && imdone == 0 ) return 0;
imdone = 1;
pwm_sym = 0 ; //stop motors
return 1;


The script function prototypes used so far are:

int move_encoder(int goal , int fwd_speed );//command a distance using encoders.
int turn_encoder(int goal , int turn_rate ); //command a turn using encoders

int ms_timer_T1(int goal); //wait for a time period

int set_lift(int goal, int pwm_input );//set the lift height
int set_grip(int goal, int ms_wait) ; //grip goals: HOLD,DROP,DROP_ONE

Using multiple script functions in one step:

Often times a time_out function is required.  The set_grip has it built in but it can be added to any script step by using an OR of two basic scripts: E.G.

if(step ==1)


int done1 = move_encoder(goal, set_speed);

int done2 = ms_timer_T2( time_out_ms);

if(done1 ==1 ||  done2==1)  { done = 1;}     //OR the  scripts output

// “done” is a global variable that controls the script incrementing


This keeps the logic versatile and the scripts simple.

I will post the software eventually.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: