Autonomous Control

[mwtidd]

Originally Posted by kamocat

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]

Originally Posted by 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?

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]

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?