utilities

Class Avoider

java.lang.Object

java.lang.Thread

utilities.Avoider

All Implemented Interfaces:

Runnable

public class Avoider
extends Thread

Checks if the robot must avoid an object in its path and then does it Runs constantly and can interrupt other processes.

Version:

3.0

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Avoider.AvoidState

Nested classes/interfaces inherited from class java.lang.Thread

Thread.State, Thread.UncaughtExceptionHandler

Field Summary

Fields

Modifier and Type	Field and Description
static Avoider.AvoidState	avoidState
private double[]	currPos
private Rectangle	currRect
private Navigation	nav
private Odometer	odo
private Rectangle	RED
private double[]	red_cardinals
private double	RED_E
private double	RED_N
private double	RED_S
private double	RED_W
private USSensor	usSensor
private Rectangle	x1
private Rectangle	x2
private Rectangle	x3
private Rectangle	x4

Fields inherited from class java.lang.Thread

MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors

Constructor and Description
Avoider(Odometer odo, Navigation nav, USSensor usSensor, double[][] RED) Avoider constructor

Method Summary

Modifier and Type	Method and Description
private boolean	chooseOrientation(double[] currPos) Choose rotation sense depending on current position and heading Decides direction to turn when object encountered
private void	linearAvoidance(boolean CCW) Linear set of instructions to avoid obstacle Runs recursively if more obstacles are encountered during avoidance
private void	redAvoidance() Special set of instructions to avoid the RED zone
void	run() Execution for robot avoidance.

Methods inherited from class java.lang.Thread

activeCount, checkAccess, clone, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

odo

private Odometer odo

nav

private Navigation nav

usSensor

private USSensor usSensor

currPos

private double[] currPos

RED

private Rectangle RED

RED_N

private double RED_N

RED_S

private double RED_S

RED_W

private double RED_W

RED_E

private double RED_E

red_cardinals

private double[] red_cardinals

currRect

private Rectangle currRect

x1

private final Rectangle x1

x2

private final Rectangle x2

x3

private final Rectangle x3

x4

private final Rectangle x4

avoidState

public static Avoider.AvoidState avoidState

Constructor Detail

Avoider

public Avoider(Odometer odo,
               Navigation nav,
               USSensor usSensor,
               double[][] RED)

Avoider constructor

Parameters:

odo - Odometer object

nav - Navigation object

usSensor - USSensor object

RED - coordinates of red zone to always avoid

Method Detail

run

public void run()

Execution for robot avoidance. Runs constantly regardless of current state.

Specified by:

run in interface Runnable

Overrides:

run in class Thread

redAvoidance

private void redAvoidance()

Special set of instructions to avoid the RED zone

chooseOrientation

private boolean chooseOrientation(double[] currPos)

Choose rotation sense depending on current position and heading Decides direction to turn when object encountered

Parameters:

currPos - X, Y, heading coordinates

Returns:

chosen rotation sense - true is counterclockwise, false is clockwise

linearAvoidance

private void linearAvoidance(boolean CCW)

Linear set of instructions to avoid obstacle Runs recursively if more obstacles are encountered during avoidance

Parameters:

CCW - direction to turn (should be determined by chooseOrientation)