The following provides a summary of the most useful navigational methods. For Simple movements forward and backwards, capablities of the Primtive_Driver can be used like
driver.primitive_motion(TRAVEL_FORWARD, 150,true);
There are many ways to design for dead reckoning mechanism. The design was recently rewritten for optimization (sigh). All low level encoder math is now done in encoder units; i.e., the basic distance between two encoder "clicks" or Encoder Units (EU). This unit is chosen because it is the smallest unit needed; i.e., you can't possibly measure smaller than that anyways. This is measured in nanometers (nm) and on my robot is about 7463 nm.
The navigational design follows an object hierarchy as follows:
The Local_Waypoint_Driver is designed to work in tandem with the mission_profile and the world_model_store to execute the current mission plan. In concept, it is the world model information store (WM-IS) that maintains the world map and all information in it. Thus, the A* search algorithm is confined to the world_model_store. The A* algorithm returns a full expanded motion chain whereas the search method returns a compressed motion_chain where only points that require a vehicle change are recorded in the chain. This mission profile plan executed by the Local Waypoint Driver is usually built via the Moboile Robot Workshop (GUI) and consists of the following elements:
The Motion_Driver is used to ensure vehicle continues to move along the motion chain currently being traversed. Usually, this includes setting up the next starting and destination point in current path.
The Geometry_Driver or Local_Vector_Driver has responsibility for keeping the vehicle along the specified path between the source/destination set up by the motion driver. Usually, this entails checking currect position compared with where robot should be based upon geometry of path (straight, circular, etc.). It (typedef) provides two most often used methods. The First is heading which allows you to specify an absolute direction of travel and speed and it has responsibility to turn vehichle to specified direction. In addition to heading, it provides a foundational method travel which is used to command the vehicle as follows:
The Primitive_Driver contains two oEncodedMotors which do the grunt work of keeping track of wheel "ticks". The Primitive_Driver is just a wrapper for these with initialization and the ability to set velocity of vehicle and add ability to provide a user Proportional gain (PID type) to left or right wheel independently. These methods, Rpower and Lpower and used heavily by lower classes.
The formulas are based upon A Tutorial and Elementary Trajectory Model for the Differential Steering System of Robot Wheel Actuators by G.W. Lucas.
The dead reckoning is achieved through the following tasks in order priority (highest to lowest):
Currently, both modes determine a linear path. Thus the vechicle stops every time so it can make turn to the next direction; thus the future challenge is to transform the motion chain into another geometric besides a simple linear path.
NOTE: The PDF version of this document is missing the greek symbols. Please see the HTML version.
then
D = πb/2, and one click, C = πd/R
thus we want to know how many clicks in total pivot distance traveled,
nC = D or
nC = πb/2 or
n(πd/R) = πb/2 and finally solve for n to obtain n = (bR)/(2d).
To simplify the equation, in making turns, one of the vehicles wheels will maintain a constant velocity and the other wheel will vary--it is the varying wheel's speed that we wish to determine. The Local_Vector_Driver calculates based upon wheel diameter, turn radius, etc., the needed wheel speed to attain that turn.
Thus, given a wheel base L, radius of turn R, and Vr, a fixed velocity of one wheel (right in this case), solve for the needed velocity of the other wheel to achieve a 90 degree turn.
Let: L = wheel base R = radius of turn Vr = velocity of right wheel (fixed in this case) Vl = velocity of left wheel (solve for this) ω = angular velocity of robot From Mobile Robot Locomotion by Prof. Jizhong Xiao's Differential steering Kinematics equations (unfortunately, his presentation has changed since then, and the previous used equations are not there) 1) Vl = ω(R - L/2) [slide 17] 2) ω = Vr -Vl/L [slide 18] Let α = (R -L/2) NOTE: this is constant term; hence it works, thus from eq. 1 we obtain, 3) Vl = ωα A) Vl = (Vr/L -Vl/L)α [substitute eq. 2 for ω into eq. 3] B) Vl = Vrα/L - Vlα/L [multiply out by α] C) Vl+Vlα/L = Vrα/L [add +Vlα/L to both sides] = Vl*((1+α)/L) D) Vl/L(L+α) = Vrα/L [factor out Vl in left] = Vl((L+α)/L E) Vl(L+α) = VrαL/L [mulitpy both sides by L] 3) Vl = Vrα/(L+α) [cancel L on right and divide both sides by (L+α)] Thus Vrα/(L+α) is final equation. For sanity check, put in R=0; i.e, do a 90 degree pivot at some speed, say 400 mm/sec. a = (0-200/2) = -100 400(-100)/(200-100) = 400(-100)/(100) = -400
Which corresponds with common sense. It is the same speed but in the opposite direction.