Multi Agent Class

Note

This class is for advanced users wanting to control multiple robots through QUARC or Quanser SDK. Make sure you have installed the academic resources from the Quanser website. It will only work with Quanser robots that you have a valid Quanser Interactive Labs license for.

This class is still under development.

For any questions, please contact Quanser Support at tech@quanser.com

Description

This class can be utilized for spawning multiple robot agents in Quanser Interactive Labs for user control directly via QUARC or Quanser SDK. This library requires a complete installation of Quanser’s academic resources (available through www.quanser.com) for associated real-time application modules and other supporting libraries.

The class copies and creates all necessary files to run multiple robots at the same time. It will also create a JSON file called RobotAgents.json that will store the information of the agents that were spawned as well as its port and URI numbers.

See the MultiAgent Tutorial to get a better understanding of using the MultiAgent class to spawn multiple agents.

Library

class qvl.multi_agent.MultiAgent(agentList)

This class is for spawning multiple agents in Quanser Interactive Labs that will then be controlled through QUARC/Quanser SKD.

When initializing the class, it will delete all QArms, QCar 2s, QBot Platforms and QDrone 2s in the space.

Member Variables

MultiAgent.robotActors = None

List of qlabs actor objects of the robots that were spawned. Use when using functions from qlabs library.

MultiAgent.robotsDict = {}

Dictionary of dictionaries of all spawned robots. Includes the information that is saved into the JSON file. Including robotType, actorNumber, classID as well as all ports used for the RT file.

Methods

MultiAgent.__init__(agentList)

Constructor Method

Parameters

agentList (list of dictionaries) – A list of dictionaries of the spawned robots.

Tip

The dictionaries can have the following keys (one per robot that will be spawned):

• “RobotType”: string - can be “QC2”/”QCar2” for QCar 2, “QBP” for QBot Platform, “QDrone2”/”QD2” for QDrone 2

• “Location”: float array[3] - for spawning in x, y, z of the QLabs environment

• “Rotation”: (Optional) float array[3] - for spawning in x, y, z. Can be in Degrees or Radians. If it is radians, set the “Radians” key to True. If not defined, will spawn with [0, 0, 0] rotation

• “Radians”: (Optional) boolean - defaults to False. Only needed if rotation is in Radians

• “Scale”: (Optional) float - if you want to change the scaling of the spawned object. If not defined, will spawn with scaling of 1. The scaling will apply in x, y, and z

• “actorNumber”: (Optional) int - set only if you want a predefined actor number for your robot. If not, it will use the next available number for the type of robot. If the number is already in use, it will overwrite it. We do not recommend using it unless tracking of actors is done manually by the user.

If using a QCar 2, the file it will start will be different depending on the scale of 1 (QCar 2 real world car size) or .1 (QCar 2 actual size), to return measurements properly scaled.

multi_agent.readRobots()

Function to read the JSON file created after spawning the robots. The file contains all necessary port/URI numbers to initialize the robots. The function will return the dictionary that was created when spawning the robots it contains the the robots and their properties. The function makes sure that the file is not being used by another process before reading it.

Important

This function is not part of the MultiAgent class. Do not initialize a MultiAgent object only to use this function. It can be called directly from the library.

---

MultiAgent Tutorial

PythonMatlab

Python Tutorial

Raw to download this tutorial: Multi Agent Tutorial (.py).

"""
Multiagent Example
----------------------------

.. note::
    Make sure you have the teaching or research resources from the Quanser website 
    downloaded. It will not find the necessary files if you do not have them.

    Make sure to only try to spawn robots your Quanser Interactive Labs license
    allows for. It will not spawn robots you do not have access to. 

    Make sure you have Quanser Interactive Labs open before running this
    example.  This example is designed to best be run in any of the Open World environments.

"""

#imports to necessary libraries
import time
import numpy as np
from qvl.multi_agent import MultiAgent, readRobots
from qvl.qlabs import QuanserInteractiveLabs
from qvl.free_camera import QLabsFreeCamera
from qvl.basic_shape import QLabsBasicShape
import numpy as np 

qlabs = QuanserInteractiveLabs()
    
print("Connecting to QLabs...")
if (not qlabs.open("localhost")):
    print("Unable to connect to QLabs")   

print("Connected")  

qlabs.destroy_all_spawned_actors()

# create a camera in this qlabs instance
camera = QLabsFreeCamera(qlabs)
camera.spawn_degrees(location=[0.063, 1.9, 0.603], rotation=[0, 9.186, -83.687])
# to switch our view to the new camera we just initialized
camera.possess()

# add shapes in the space
rectangle2 = QLabsBasicShape(qlabs)
rectangle2.spawn(location=[-1,-.8,0], rotation=[0,0,0], scale=[.2,.2,1], configuration=QLabsBasicShape.SHAPE_CUBE, waitForConfirmation=True)
rectangle2.set_material_properties(color=[0,1,0])
time.sleep(1)
cone = QLabsBasicShape(qlabs)
cone.spawn(location=[0.7,-.4,0], rotation=[0,0,0], scale=[.2,.2,1], configuration=QLabsBasicShape.SHAPE_CONE, waitForConfirmation=True)
cone.set_material_properties(color=[0,0,1])
time.sleep(.5)

qlabs.close()

print("Disconnected from camera and object spawn") 

time.sleep(1)

# Initialize an empty list (not a dictionary, because dictionaries are key-value pairs)
myRobots = []

# Adding a new robot to the list
# comment out robots that you may not be licensed for

#QCar 2 needs to be spawned at a smaller scale since it is made to work in
# cityscape where it is made to spawn the size of a real car. 
# as a 1/10th car, spawning at 0.1 scale will make it the size of the real
# QCar 2
myRobots.append({
    "RobotType": "QCar2", 
    "Location": [-.5, 0, 0], 
    "Rotation": [0, 0, 90], 
    "Scale": .1,
    "ActorNumber" : 5 # set actor number to 5
})


myRobots.append({
    "RobotType": "QD2", 
    "Location": [1, 0.5, 0], 
    "Rotation": [0, 0, 90], 
    "Scale": 1
})
 
myRobots.append({
    "RobotType": "QBP", 
    "Location": [.15, -.3, -0], 
    "Rotation": [0, 0, 90], 
})

# only need to call this once, and it will spawn and initialize all necessary
# RT files to start talking to the Robots.
mySpawns = MultiAgent(myRobots)

# list of QLabs objects that were spawned
actors = mySpawns.robotActors

print(actors)
print(actors[0].actorNumber)
print(actors[0].classID)

# this is how to still use the actor functions with the spawns
# setting the color of the LED strip on the QCar 2 to purple
# these functions are directly from qvl.qcar2
actors[0].set_led_strip_uniform(color=[1,0,1])

# robotsDict should be the same as the output of readRobots(). 
# Use readRobots when reading the JSON file from a different python file.
actorsDict = mySpawns.robotsDict
print(actorsDict)

robotsDir = readRobots()
print(robotsDir)

# this would be used when initializing a QCar 2 using HIL to find the assigned port.
print(robotsDir["QC2_5"]["hilPort"]) 

mySpawns.qlabs.close()