Autonomous Control

[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?