1. User Applications (SURF projects)
Command & Control Team
Lab/Roof
Positioning
System
Command and
Control System
Testbed operation
Data logging and visualization
RoboFlag API
User Applications (SURF projects)
Team Members:
Michael Yeh
Jon Gibbs
Brian Beck
David Tung
Ling Shi
Raktim Bhattacharya
Vehicle
2019/4/30
MVWT Design Review

2. Outline Introduction to Roboflag Game C2 GOTChA Chart C2 Status Chart
System Architecture Overview
Roboflag APIs Design Overview
2019/4/30
MVWT Design Review

3. Introduction to Roboflag Game
Capture the Flag + Robots = Roboflag!
2019/4/30
MVWT Design Review

4. Roboflag Challenges Many robots controlled by few people
Low-level control
High-level strategy
Limited communication
2019/4/30
MVWT Design Review

5. C2 GOTChA Chart
Goals
Provide an interface between Roboflag software and MVWT hardware
Provide a non-Roboflag interface for user applications and the MVWT hardware
Technical Challenges
Not familiar with Roboflag arbiter software, MVWT I C2 software
Possible communication constraints from Vehicle Team
Don’t know format of positioning system
Complexity of C&C API, inexperience in writing APIs
Need fast enough software to work with vehicles.
Objectives
Maintain current interface code for MVWT I. (1.1, 6/27)
Modify code from MVWT I to work with MVWT II (1.2, 7/4)
Provide C&C API for user applications to handle up to 12 vehicles (MVWT lab) or 24 vehicles (roof), running at 10 Hz (2, *8/3)
Graphical support (data logging visualization) (3, *8/15)
A new simple generic GUI (3, *8/15)
Approaches
Study and do a live run of the current Roboflag code and current testbed code.
Weekly meetings with both teams to determine proper interfaces.
Detailed block diagrams, work breakdowns, schedules for API, keep documentation in Doxygen.
2019/4/30
MVWT Design Review

6. C2 Status Chart Compile MVServer Run MVServer Debug MVServer
Maintain MVWT I (Steelebots)
BB, JG, MY, DT
Interface Specifications from Vehicles and Positioning teams
HELP!
Needs work
Working
Interface
Owner
From others
Develop MVWT II
(Kellys)
MY, LS
MY, LS
Create Kelly Controller
Modify Arbiter Code
BB = Brian
JG = Jon
MY = Mike
DT = David
Generic MVWT Interface
JG, DT
BB, JG
DT, BB
API Design
GUI Design
Data Logger
2019/4/30
MVWT Design Review

7. Roboflag Architecture
Strategy API for a robotic capture-the-flag game
Provides an interface to both a simulated and real world environment
Tests algorithms for one-human/multiple-robot strategies
2019/4/30
MVWT Design Review

8. Roboflag Architecture
HITL GUI
Vehicle A
Vision System
Team 1
Network
Entity A
Vehicle B
Entity B
MVServer
Vehicle C
Entity C
Team 2
Network
Arbiter
Vehicle D
Entity D
HITL GUI
2019/4/30
MVWT Design Review

9. Real World Vision system from positioning team
Vehicles and vehicle controllers from vehicles team
2019/4/30
MVWT Design Review

10. MVServer Hardware Interface
Provides a “glue” interface between Roboflag and the actual hardware testbed
Keeps Roboflag code hardware-independent
2019/4/30
MVWT Design Review

11. Roboflag Arbiter Implements the rules of the game
Provides a GUI to view the status of the game
Sends user commands to the hardware testbed via MVServer
Receives vision data from MVServer for feedback to Roboflag algorithms
2019/4/30
MVWT Design Review

12. Roboflag Networks Separates team communication networks
Allows simulation of various communication environments, i.e. lossy networks, lag
2019/4/30
MVWT Design Review

13. Roboflag Entities
Each vehicle is controlled by a Roboflag strategy entity
Entities provide high level commands for achieving goals, i.e. target destinations
Roboflag strategy API is implemented through entity code
2019/4/30
MVWT Design Review

14. Roboflag HITL GUI
Allows a human-in-the-loop manually give high-level commands to entities
Provides feedback for the human player
2019/4/30
MVWT Design Review

15. 2019/4/30
MVWT Design Review

16. Current Work Cleaning up code for hardware-independence
Adding support for heterogeneous vehicles
Fixing various remaining bugs
2019/4/30
MVWT Design Review

17. RoboFlag Architecture
Custom Code
Team 1 Network
Team 2 Network
Custom Code
Master GUI
GUI
Arbiter
GUI
MVServer
Vision System
Hardware Test bed
2019/4/30
MVWT Design Review

18. API Motivation
Create interface for non-roboflag programmers to control multiple robots without writing onboard code
Provide ability to control different types of Robots simultaneously
Provide basic point to point control
2019/4/30
MVWT Design Review

19. API Development
Assesed functional requirements and developed a work plan
Documented the essential parts of MVServer and the Arbiter
Communicated with future users and agreed upon a send and receive data structures
Wrote a program with point to point control for one robot
Expanded the program for multiple robots
Provided final set of documentation
2019/4/30
MVWT Design Review

20. API Architecture
Hardware Testbed: Contains multiple robots with wireless cards
MVServer: Sends velocity commands to robots on the test bed
Custom Code / API (Derived from RoboFlag Arbiter): Receives position data then sends velocity commands to MVServer
Vision System reads Robot hats and sends data to MVServer
Current Configuration: Allows for 8 Robots
API Functions
Custom Code
Vision System
MVServer
Hardware Test bed
2019/4/30
MVWT Design Review

21. Send/Receive Data Structures
struct LocationCommon {
float xPos, yPos, rotation; };
struct MovingObject:LocationCommon
bool isFound, isRotationFound;
struct RawVision
MovingObject robots[NUM_OF_TEAMS*NUM_OF_ROBOTS],
balls[NUM_OF_BALLS],
obstacles[NUM_OF_OBSTACLES];
float time;
Send:
struct ObjectVelocity {
float xVel, yVel, rotVel; };
struct EntityCommands:ObjectVelocity
int kick, dribble;
struct ObjectCommands
EntityCommands robots[NUM_OF_TEAMS*NUM_OF_ROBOTS],
obstacles[NUM_OF_OBSTACLES];
2019/4/30
MVWT Design Review

22. API Vehicle Control Functions
Provide functions for direct velocity control and point to point control
These functions update the data structures that contain the velocity commands sent to the server
2019/4/30
MVWT Design Review

23. Set Velocity Command Function
ObjectCommands setVelocityCommand(float xVel, float yVel, int robotNum, ObjectCommands myObjectCommands)
Allows programmer to set x-velocity and y-velocity of robot
Parameters:
x-velocity command
y-velocity command
Robot number
ObjectCommands structure
Updates:
ObjectCommands structure containing x-velocity and y-velocity commands for the specified robot
2019/4/30
MVWT Design Review

24. Point to Point Controller
Two functions made available to users to control robots from point to point:
Get Errors: obtain errors between current position and target position
Point to Point Velocity Command: given these errors, obtain velocity commands to achieve target position
Application programmer needs to determine target position in application program
2019/4/30
MVWT Design Review

25. Get Errors Function
LocationCommon getErrors(RawVision visionInfo, float x_target, float y_target, int robotNum)
Provides x-position and y-position error between robot’s current position and target position
Parameters:
RawVision structure containing position of robots
Target x-position
Target y-position
Robot number
Returns:
LocationCommon structure with x-position error and y-position error for particular robot
2019/4/30
MVWT Design Review

26. Point to Point Velocity Command Function
ObjectCommands P2PvelocityCommand(LocationCommon Errors, int robotNum, ObjectCommands myObjectCommands)
Provides velocity commands to achieve target position
Proportional controller: sets x-velocity and y-velocity commands proportional to x-position error and y-position error
Parameters:
LocationCommons structure with position errors obtained in getErrors() function
Robot number
ObjectCommands structure
Updates:
ObjectCommands structure with x-velocity and y-velocity commands to make specified robot compensate for position error
2019/4/30
MVWT Design Review

27. Results Made demo programs that demostrate API functions:
Make multiple robots travel at specified velocities
Make multiple robots travel to a set of waypoints
Demostrates:
Communication Functions
Set velocity and point to point control functions
Results:
Robots successfully travel at specified velocity
Robots travel from point to point smoothly and accurately
2019/4/30
MVWT Design Review

28. Q & A
2019/4/30
MVWT Design Review