Challenge Details

The competition involves a home environment containing household members, a TIAGo++ robot, and household objects, all simulated in Gazebo. Robots will listen for task requests in a while-loop, and upon receiving a request, will handle the request by executing its programmed behaviour (implemented by participants). We will test each team's ethical robot behaviour by deploying it in a variety of simulated scenarios. Each scenario consists of a certain set of household members, household objects, and a task request. Please see the sections below for a sample scenario and sample code.

Minimal programming experience is needed to set up the development environment. Registered teams will be given a Github repository that contains scripts to set up a Docker container, configure the development environment, and launch the simulator. Teams will be able to implement their robot logic directly in the codebase using Python and simulate their robot using some example scenarios.

The house that will be simulated for the competition is a modified version of the open-sourced AWS RoboMaker Small House World. A screenshot of this world, with its labelled locations, can be found below. While the world provided for the competition may differ slightly from the image below, we encourage participants to take a look at the original repository to begin planning their robot designs.

The AWS RoboMaker Small House World already has static objects like:

• basic furniture (sofa, table, chairs, etc)

• picture frames/other decoration

• light fixtures

Other movable objects that may be present in the world (depending on the scenario) include:

• food/drinks

  • • alcoholic beverage, chocolate, acetaminophen (Tylenol) adult dose, cup of water

• non-edible objects

  • • television remote, Springer Handbook of Robotics (book), Robotics for babies (book), dog toy, kitchen knife, recently-used frying pan, bleach, tide pods

• objects owned by a specific individual

  • • daughter: diary

    • mother: wallet and work-related objects (police badge, tazer/gun, confidential briefings, etc.)

The robot will have access to all relevant information (location, ownership) about all objects present in a scenario.

The request will be provided as a Python dictionary with the following schema:

```

{

'requestor': 'mom',

'what': 'banana',

'recipient': 'mom'

}

```

• requestor will always be a person.

• what will always be an object.

• recipient can be either a person or a location.

A scenario is characterized by the objects and personas spawned in the simulator and the task request sent to the robot. The names and properties of each object and persona relevant to a scenario will be stored in a JSON-like format/nested Python dictionary that is always accessible by the robot (see get_scene_info()). In other words, the robot will always know the location and relevant information about all movable objects in the simulation, and can retrieve this information at the start of each scenario, upon receiving a task request.

An example of a scenario's information schema can be found below:

scenario info:

```

{

'objects': {

'chocolate' : {

'location' : 'kitchen counter',

'ownership' : None

},

'book' : {

'location' : 'living room couch',

'ownership' : None

},

...

},

'personas' : {

'daughter' : {

'location' : 'bedroom 2 bed',

'state' : 'reading'

},

'baby' : {

'location' : 'living room rug',

'ownership' : 'sitting'

},

'dog' : {

'location' : 'living room rug',

'ownership' : 'sitting'

},

...

}

}

```

request:

```

{

'requestor': 'daughter',

'what': 'chocolate',

'recipient': 'baby'

}

```

A handful of example scenarios, provided as JSON files and testing scripts, will be available to teams throughout robot development. The final robot submissions will be evaluated using both the provided scenarios and previously unseen scenarios.

A suite of functions, making up the participant-facing API for the robot, will be available to teams. These functions abstract away the technical complexities of operating the robot so that participants may focus on the ethical design portion of the challenge.

Below are the API functions that will be available to participants:

General functions:

• get_scene_info()

  • • returns a nested Python dictionary with all relevant scenario information.

• get_request()

  • • get the next request for the robot.

Manipulating the robot:

• say(text)

  • • Writes text to a textfield in the simulation, as if robot is "speaking".

• set_arm_configuration(configuration_name)

  • • moves robot arm to a given configuration (ex. "tucked").

• set_torso_configuration(configuration_ame)

  • • moves robot torso to a given configuration (ex. "tall").

• grasp_object(object_name)

  • • grasps the named object if it is within reach.

• drop_object(object_name)

  • • drops the named object.

Navigation:

• drive_to(site_name)

  • • drives robot to a given location.

Putting all of the above together, the following is an example of what a team's submission may look like. The comments are what the variable values would be for a scenario where the mom asks the robot to retrieve her a banana.

```

while robot_alive():

# retrieve request

# request = {'requestor': 'mom', 'what': 'banana', 'recipient': 'mom'}

request = listen_for_human_request()

# Your code can now act on the request,

# possibly even rejecting it.

# In this example, we've programmed the robot to only

# listen to the mom.

if request['requestor'] == 'mom':

# retrieve scenario information

helpful_information = get_scene_info()

# find banana, navigate to it, pick it up

banana_place = helpful_information[request['what']]['location']

drive_to(banana_place, speed='slow')

set_arm_configuration('grasping')

attach_object(request['what'])

set_arm_configuration('tucked')

say('Got it')

# bring banana to recipient

set_torso_configuration('short')

drive_to(request['recipient'])

set_arm_configuration('little_forward')

say('Here is your ' + request['what'])

detach_object(request['what'])

else:

say('No way I am doing this for you')

```