Chapter 1: Introduction

at least

module PrototypeActuatorTransformM {
    provides {
        interface Actuator;
    } uses {
        interface Actuator as OutgoingActuator;
    }
}

module PrototypeCritterListM {
    provides {
        interface ReceiveCritterListMsg;
    } uses {
        interface ReceiveCritterListMsg;
        interface SendCritterListMsg;
    }
}

module PrototypeEstimateCrittersM {
    provides {
        interface CrittersPosition;
    } uses {
        interface ReceiveEstimateCrittersMsg;
        interface SendEstimateCrittersMsg;
    }
}

module PrototypeLocalizationM {
    provides {
        interface Position;
    } uses {
        interface SendLocalizationMsg;
        interface ReceiveLocalizationMsg;
    }
}

module PrototypePacketRoutingM {
    provides {
        interface ReceiveMsg;
    } uses {
        interface ReceiveMsg as IncomingMsg;
        interface SendMsg;
    }
}

module PrototypePursuitAlgorithmM {
    provides {
        interface StdControl;
    } uses {
        interface ReceiveCritterListMsg;
        interface RobotControl;
        interface SendPursuitMsg;
        interface ReceivePursuitMsg;
    }
}

module PrototypeRobotControlM {
    provides {
        interface RobotControl;
    } uses {
    }
}

module PrototypeSensorTransformM {
    provides {
        interface Sensor;
    } uses {
        interface Sensor as IncomingSensor;
    }
}

module PrototypeTimeSyncM {
    provides {
        interface Time;
    } uses {
        interface ReceiveStampedMsg;
    }
}

interface Actuator {
    command result_t setValue(
        int value
    );
}

interface CrittersPosition {
    event result_t newCrittersPosition(
        critterList_t* list
    );
}

interface Debugger {
    command result_t led_int(
        int value;
    );
    command result_t message(
        char* msg
    );
}

interface Position {
    command result_t getPosition(
        position_t* position
    );
}

interface ReceiveCritterListMsg {
    event result_t receiveCritterList(
        critterList_t* msg
    );
}

interface ReceiveEstimateCrittersMsg {
    event result_t receivePursuitMsg(
        estimateCritters_t* msg
    );
}

interface ReceiveLocalizationMsg {
    event result_t receivePursuitMsg(
        localization_t* msg
    );
}

interface ReceivePursuitMsg {
    event result_t receivePursuitMsg(
        pursuit_t* msg
    );
}

interface ReceiveStampedMsg {
    event result_t receiveStampedMsg(
        TOS_MsgPtr msg,
        time_t* time
    );
}

interface ReceiveTimeSyncMsg {
    event result_t receiveTimeSyncMsg(
        timeSync_t* msg
    );
}

interface RobotControl {
    command result_t setSteeringWheel(
        int value
    );
    command result_t setSpeed(
        int value
    );
    command result_t getSteeringWheel(
        int* value
    );
    command result_t getSpeed(
        int* value
    );
}

interface SendCritterListMsg {
    command result_t sendCritterListMsg(
        critterList_t* msg
    );
    event result_t sendCritterListMsgDone();
}

interface SendEstimateCrittersMsg {
    command result_t sendLocalizationMsg(
        estimateCritters_t* msg
    );
    event result_t sendLocalizationMsgDone();
}

interface SendLocalizationMsg {
    command result_t sendLocalizationMsg(
        localization_t* msg
    );
    event result_t sendLocalizationMsgDone();
}

interface SendPursuitMsg {
    command result_t sendPursuitMsg(
        pursuit_t* msg
    );
    event result_t sendPursuitMsgDone();
}

interface SendTimeSyncMsg {
    command result_t sendTimeSyncMsg(
        timeSync_t* msg
    );
    event result_t sendTimeSyncMsgDone();
}

interface Sensor {
    event result_t sensor (
        sensor_t* value
    );
}

interface StdControl {
    command result_t init();
    command result_t start();
    command result_t stop();
}

interface Time {
    command result_t getTime(
        time_t* time
    );
}

typedef struct {
    int id;
    position_t pos;
    positionError_t posErr;
    velocity_t vel;
    velocityError_t velErr;
} critterAttribs_t;

typedef struct {
    unsigned int length;
    critterAttribs_t* critters;
} critterList_t;

typedef struct {
    /* ... define me ... */
} estimateCritters_t;

typedef struct {
    int moteID;
    /* ... and other pertinent stuff ... */
} localization_t;

typedef triple_t positionError_t;

typedef triple_t position_t;

typedef struct {
    int command;
    int value;
    /* ... maybe other stuff goes in here ... */
} pursuit_t;

typedef struct {
    int srcID;
    int value;
    int valueError;
} sensor_t;

typedef struct {
    /* ... define me ... */
} timeSync_t;

typedef unsigned int time_t;

typedef struct {
    int x;
    int y;
    int z;
} triple_t;

typedef triple_t velocityError_t;

typedef triple_t velocity_t;

Chapter 1: Introduction

Chapter 2: Demo Description

Chapter 3: Abstract Architecture

Chapter 4: Formal Architecture

Chapter 5: NesC Architecture

Chapter 6: Graphical Architecture

Berkeley's role

Middleware groups' role

Challenge Architecture Document goals

Location

Playing Field

Coordinate System

Sensor Network

Evader

Pursuer

Pursuers

Mote Sensors

Evaders

Prototypes

Services

Filtering and Calibration Interfaces

Resources

Input/Output Convention

Send/Receive Structures

Modules

Interfaces

Types