Autonomous Control

[kamocat]

With the goal of making a robot fully autonomous (http://www.chiefdelphi.com/forums/showthread.php?t=84797):

How should the mechanisms be controlled?

What sorts of control might you want over a mechanism?

This thread may also be used to discuss the bobotics Autonomous Development Kit (http://firstforge.wpi.edu/sf/projects/bobotics).

[kamocat]

Here's a summary of the Autonomous Development Kit:

The idea is each robot registers an autonmous or operator controller.

This controller then determines what the current maneuver is and notifies the mechanisms of a change.
The controller also registers the current maneuver with the robot.

The mechanisms refer to the robot for the current maneuver.
the mechanisms the send a response when they complete or fail a given task.

each mechanism should be able to work independently of the other mechanisms, so your examples of maneuvers are drive maneuvers, not robot maneuvers.

How I implemented it is all mechanisms recieve a drive forward command (which is really drive forward and shoot).
think of it as a phase 1 command (phase 0 being init)

when the drive recieves that command it drives forward infinitely
when the shooter recieves the command it shoots if the ball breaks the ir beam
when it shoots it responds to the controller with a pass.
the controller keeps looping this until it has seen N number of passes
the the passes >= N it has succesfully completed that maneneuver (shooting N balls) and can move on to its next
maneuver.

As the controller handles the maneuvers, if it changes the current maneuver it overrides it for every mechanism, however a mechanism itself can choose to ignore a given maneuver command.

[kamocat]

Here's how I've interpreted that for translation to LabVIEW:
Each mechanism has an event manager assigned to it, which handles the dequeuing of events for that mechanism, whether to override an event for a newer one, and informs the Planner whether each event succeeded, failed, or was aborted.
The Planner is what actually determines what the robot should be doing.
(Autonomous planning can be discussed here (http://www.chiefdelphi.com/forums/showthread.php?p=950228#post950228))

[mwtidd]

Here's a summary of the Autonomous Development Kit:

First off I would like to thank Marshal (Kamocat) for starting this thread. It is definitely a good place to start.

Let me state it as simply as possible.

There are two types of events in the system: MechanismEvents and ManeuverEvents.

MechanismEvents will be used for mechanism-mechanism communications
-these are one way and have not yet been implemented

All Events are sent through a single EventManager.

ManeuverEvents will be used for controller-mechanism communications.
-these are two way, the AutonomousController sends an event to the mechanisms and waits for a reply

Mechanisms are high level things like arms, shooters and drives. The developer will implement these, not the ADK. However we will provide basic templates

Maneuvers are tasks to be completed by the robot. Each maneuver has a pass fail and time out.

This is a collaborative initiative and we would like as many teams to get involved as they can, regardless of experience level. The idea is that it should be able to be used as a black box, but have many extension points.

Follow the link above to join the first forge project.
(Java, C++ repositories have been created, waiting on the lab view to be accepted.)

[kamocat]

Okay, good, were're mostly describing the same thing.
However, to keep the LabVIEW code as transparent as possible, I was thinking that I wouldn't call the mechanism functions by reference and use OOP, but instead use parallel dataflow and cluster (struct) typedefs.

So the way it is working currently, each mechanism has its own task manager, and its own queue. There may have to be a dispatcher taking all the events and putting them in the appropriate queues, and getting the "pass/fail/timeout" back from the mechanism event managers, so that it's easily accessible by the planner.

Currently the event datatype looks like this:

cluster "Action"
string "action name/#"
u16 "Action Type" enum {no action, forward(ft/s), turn(deg/s), strafe(ft/s), move(fwd, stf, trn), kick(ft), retract, kick-retract(ft, s), arm height(ft)}
array "action values" 1D
sgl "value"
cluster "start"
u8 "when" enum {now, named value=, named input=, action complete, wait (s), time (s)}
string "name"
sgl "value"
u8 "compare" enum {=, >, <}
u8 "if conflict" enum {wait until finished, override that, skip this}
cluster "end"
u8 "when" enum {auto, named value=, named input=, action complete, wait (s), time (s)}
string "name"
sgl "value"
u8 "compare" enum {=, <, >}
bool "allow override"

The "override" here is very similar to timeout, but it doesn't time out until another event is sent. I tried to make this as flexible as possible, so people could do anything from "drive forward until you are 20in away from an obstacle" to "kick when the robot is done turning".

[davidthefat]

while(gameRunning)
{
KickButt("Chuck Norris Style");
}

[mwtidd]

So the way it is working currently, each mechanism has its own task manager, and its own queue. There may have to be a dispatcher taking all the events and putting them in the appropriate queues, and getting the "pass/fail/timeout" back from the mechanism event managers, so that it's easily accessible by the planner.



One goal of this is to have rookie teams be able to use this, so I opted to not go with a queue. In my case the maneuver factory handles all of the pass fail timeout options.

As a maneuver changes it registers the maneuver with the robot. Each mechanisms just reference the robot for the current maneuver. This eliminates the need for different types of ManeuverEvents beyond pass fail and change.

The EventManager also sends all maneuver change events to all mechanisms, all mechanism events to all of the mechanisms. This allows us to keep the event manager unchanged, simplifying to code for rookies.

all a rookie team would have to implement:
Robot
Maneuver Factory (could take a template)
Mechanisms

example maneuver factory
for a robot which drives straight, shoots, repeat.

(draw out the state machine, its easier to picture it way)
..Maneuver(passManeuver,failManeuver,toManeuver);

public class ManeuverFactory implements IManeuverFactory{
private static ManeuverFactory factory = new ManeuverFactory();

private static int mode = 0;

private ManeuverFactory(){}

public Maneuver get(String type){
Maneuver man = null;

if(type.equalsIgnoreCase(Maneuver.INIT)){
man = new Initialize();
man.setNext(ManeuverType.STRAIGHT, Maneuver.INIT, Maneuver.HALT);
}else if (type.equalsIgnoreCase(ManeuverType.STRAIGHT)){
man = new Maneuver(ManeuverType.STRAIGHT, ManeuverType.STRAIGHT_TO) {};
man.setNext(ManeuverType.SHOOT, Maneuver.HALT, Maneuver.HALT);
}else if (type.equalsIgnoreCase(ManeuverType.SHOOT)){
man = new Maneuver(ManeuverType.SHOOT, ManeuverType.SHOOT_TO) {};
man.setNext(ManeuverType.STRAIGHT, ManeuverType.SHOOT, Maneuver.HALT);
}else if (type.equalsIgnoreCase(Maneuver.OPERATOR)){
man = new Maneuver(Maneuver.OPERATOR, Maneuver.OPERATOR_TO) {};
man.setNext(Maneuver.OPERATOR, Maneuver.INIT, Maneuver.OPERATOR);
}
return man;
}

public static IManeuverFactory getInstance() {
return factory;
}
}

[kamocat]

The only events I'm familiar with are user events (the user interacting with a GUI). However, you seem to be using "events" as a method of transferring data from one place to another.
How are you "registering" a maneuver? Is it all variable scope?

Does each mechanism only perform one action? For example, is the Drive mechanism always in the form of Drive(Forward, Strafe, Turn); ?

Are all the maneuvers "canned", so to speak? Can a mechanism be controlled without performing a maneuver?

[mwtidd]

The only events I'm familiar with are user events (the user interacting with a GUI). However, you seem to be using "events" as a method of transferring data from one place to another.
How are you "registering" a maneuver? Is it all variable scope?

Does each mechanism only perform one action? For example, is the Drive mechanism always in the form of Drive(Forward, Strafe, Turn); ?

Are all the maneuvers "canned", so to speak? Can a mechanism be controlled without performing a maneuver?

An event is not so much a way transferring data, but more a way of notifying.
If the current maneuver is changed the mechanisms should be notified.

Here's some code from another teams robot which i converted to the ADK

example robot code (registers on initialize):



public class Wolv extends Robot
{

public synchronized void initialize() {
timer.reset();
timer.start();

getWatchdog().setExpiration(0.1);

controller.setFactory(ManeuverFactory.getInstance( ));

controller.addEventListener(ManeuverEvent.CHANGE, shooter);
controller.addEventListener(ManeuverEvent.CHANGE, drive);
controller.addEventListener(ManeuverEvent.CHANGE, roof);
}

}

example drive code:


public void actAutonomous() {
if(timer.get() > GYRO_TO){
gy.reset();
timer.stop();
timer.reset();
timer.start();
}
String type = Wolv.getInstance().getManeuver().getType();
if (type.equalsIgnoreCase(ManeuverType.NOT_STRAIGHT))
notStraight();
else if (type.equalsIgnoreCase(ManeuverType.ROTATE))
if(rotate())
this.respond(new MechanismEvent(MechanismEvent.PASS));
else if (type.equalsIgnoreCase(ManeuverType.STRAIGHT))
straight();
else if (type.equalsIgnoreCase(ManeuverType.STRAFE))
strafe();
else if (type.equalsIgnoreCase(Maneuver.OPERATOR))
actOperator();
else
halt();

}

public void actOperator() {
if(timer.get() > GYRO_TO){
gy.reset();
timer.stop();
timer.reset();
timer.start();
}

if(Wolv.getJoystick().getRawButton(DRIVE_STRAIGHT_ BUTTON))
driveStraight();
else
drive(Wolv.getJoystick());
}

a maneuver decides for itself what it should do. it could run by itself and ignore everything else.

or it could only listen for events from a MechanismController which would send events through the form of a MechanismEvent

also everything is extendable, beginner users wouldn't make custom maneuvers per se, but advanced users could. Here is a maneuver which needs to receive 3 passes from the mechanisms before it triggers a pass and gets the next maneuver.


public class DriveForward extends Maneuver{
private static int BALLS_EXPECTED = 3;

private int ballCount = 0;

public DriveForward()
{
super(ManeuverType.DRIVE_F, ManeuverType.DF_TO);
}

public void pass()
{
ballCount++;
if(ballCount >= BALLS_EXPECTED)
{
Bob.getInstance().setManeuver(pass);
Bob.getInstance().getManeuver().start();
}
else
ballCount++;

}

[mwtidd]

ADK architecture:


================= Robot
================== |
(Brains)ManeuverFactory - EventManager - Controller(Auton,Operator)
================== |
================ Mechanism

Everything above is extendable except the EventManager.

All basic teams would need to implement is:

ManeuverFactory - Robot - Mechanism

everything else should be able to work as a black box if they want it to.


I hope this helps...

[kamocat]

Here is one method of autonomous control for LabVIEW.
NOTE: it is *not* the autonomous development kit, but I *am* calling it an Autonomous Control Framework.
Here's how it works:
Each mechanism has its own dequeuer, which deals with dequeuing the events for that mechanism, and what to do when a new event arrives. (abort current, wait until done, or skip new)
There is also a main disbacher, to send events to the appropriate dequeuers.

This framework is intended to go with an autonomous program that includes Planner (for deciding what to do next) and a Perceiver (for taking sensor data, processing it, and storing it as named values)

With it, any action can be started or stopped with any of the following conditions:

immidiately
time delay
time in match
named value =, <, or >
named input =, <, or >
Completion of antother event
Sucess of another event



I wanted to try making this in addition to the autonomous development kit described by Mike (lineskier).
This Autonomous Control Framework is quite functional (except perhaps the value comparison being backwards of what is intuitive).

So, now that this is public, I'm going to resume work on the autonomous development kit.

[kamocat]

Okay, so I finally understand how the ADK works:
The "robot" consists of three components:

Human Operator or the maneuver Planner (decides what maneuver should be performed)
Event Handler (makes sure the maneuver factory changes maneuvers when it should)
Maneuver Factory (performs the maneuvers)

The manuever types are all pre-coded, and can involve multiple mechanisms. (For example, you could have a maneuver type that says "go forward 2 feet, spin in a circle, and fire 3 balls") It's effectively a canned move, and as far as I'm aware, it is not dynamically configurable.
The maneuver factory can only perform one maneuver at a time (to prevent simultaniously sending two different values to a mechanism).
When the maneuver is changed, the mechanisms don't necessarily stop whatever they were doing and accept the new command. Some actions require completion before a new one can be issued. (for example, you don't want a kicker to try to extend when it's already extended; it must retract for two seconds to avoid penalty.)

How accurate is that?