file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/rotations.py | """
| File: rotations.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Implements utilitary rotations between ENU and NED inertial frame conventions and FLU and FRD body frame conventions.
"""
import numpy as np
from scipy.spatial.transform import Rotation
# Quaternion for rotation between ENU and NED INERTIAL frames
# NED to ENU: +PI/2 rotation about Z (Down) followed by a +PI rotation around X (old North/new East)
# ENU to NED: +PI/2 rotation about Z (Up) followed by a +PI rotation about X (old East/new North)
# This rotation is symmetric, so q_ENU_to_NED == q_NED_to_ENU.
# Note: this quaternion follows the convention [qx, qy, qz, qw]
q_ENU_to_NED = np.array([0.70711, 0.70711, 0.0, 0.0])
# A scipy rotation from the ENU inertial frame to the NED inertial frame of reference
rot_ENU_to_NED = Rotation.from_quat(q_ENU_to_NED)
# Quaternion for rotation between body FLU and body FRD frames
# +PI rotation around X (Forward) axis rotates from Forward, Right, Down (aircraft)
# to Forward, Left, Up (base_link) frames and vice-versa.
# This rotation is symmetric, so q_FLU_to_FRD == q_FRD_to_FLU.
# Note: this quaternion follows the convention [qx, qy, qz, qw]
q_FLU_to_FRD = np.array([1.0, 0.0, 0.0, 0.0])
# A scipe rotation from the FLU body frame to the FRD body frame
rot_FLU_to_FRD = Rotation.from_quat(q_FLU_to_FRD)
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .thrust_curve import ThrustCurve
from .quadratic_thrust_curve import QuadraticThrustCurve |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/quadratic_thrust_curve.py | """
| File: quadratic_thrust_curve.py
| Author: Marcelo Jacinto ([email protected])
| Descriptio: File that implements a quadratic thrust curve for rotors
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
import numpy as np
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.thrusters.thrust_curve import ThrustCurve
class QuadraticThrustCurve(ThrustCurve):
"""Class that implements the dynamics of rotors that can be described by a quadratic thrust curve
"""
def __init__(self, config={}):
"""_summary_
Args:
config (dict): A Dictionary that contains all the parameters for configuring the QuadraticThrustCurve - it can be empty or only have some of the parameters used by the QuadraticThrustCurve.
Examples:
The dictionary default parameters are
>>> {"num_rotors": 4,
>>> "rotor_constant": [5.84e-6, 5.84e-6, 5.84e-6, 5.84e-6],
>>> "rolling_moment_coefficient": [1e-6, 1e-6, 1e-6, 1e-6],
>>> "rot_dir": [-1, -1, 1, 1],
>>> "min_rotor_velocity": [0, 0, 0, 0], # rad/s
>>> "max_rotor_velocity": [1100, 1100, 1100, 1100], # rad/s
>>> }
"""
# Get the total number of rotors to simulate
self._num_rotors = config.get("num_rotors", 4)
# The rotor constant used for computing the total thrust produced by the rotor: T = rotor_constant * omega^2
self._rotor_constant = config.get("rotor_constant", [8.54858e-6, 8.54858e-6, 8.54858e-6, 8.54858e-6])
assert len(self._rotor_constant) == self._num_rotors
# The rotor constant used for computing the total torque generated about the vehicle Z-axis
self._rolling_moment_coefficient = config.get("rolling_moment_coefficient", [1e-6, 1e-6, 1e-6, 1e-6])
assert len(self._rolling_moment_coefficient) == self._num_rotors
# Save the rotor direction of rotation
self._rot_dir = config.get("rot_dir", [-1, -1, 1, 1])
assert len(self._rot_dir) == self._num_rotors
# Values for the minimum and maximum rotor velocity in rad/s
self.min_rotor_velocity = config.get("min_rotor_velocity", [0, 0, 0, 0])
assert len(self.min_rotor_velocity) == self._num_rotors
self.max_rotor_velocity = config.get("max_rotor_velocity", [1100, 1100, 1100, 1100])
assert len(self.max_rotor_velocity) == self._num_rotors
# The actual speed references to apply to the vehicle rotor joints
self._input_reference = [0.0 for i in range(self._num_rotors)]
# The actual velocity that each rotor is spinning at
self._velocity = [0.0 for i in range(self._num_rotors)]
# The actual force that each rotor is generating
self._force = [0.0 for i in range(self._num_rotors)]
# The actual rolling moment that is generated on the body frame of the vehicle
self._rolling_moment = 0.0
def set_input_reference(self, input_reference):
"""
Receives as input a list of target angular velocities of each rotor in rad/s
"""
# The target angular velocity of the rotor
self._input_reference = input_reference
def update(self, state: State, dt: float):
"""
Note: the state and dt variables are not used in this implementation, but left
to add support to other rotor models where the total thrust is dependent on
states such as vehicle linear velocity
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
"""
rolling_moment = 0.0
# Compute the actual force to apply to the rotors and the rolling moment contribution
for i in range(self._num_rotors):
# Set the actual velocity that each rotor is spinning at (instanenous model - no delay introduced)
# Only apply clipping of the input reference
self._velocity[i] = np.maximum(
self.min_rotor_velocity[i], np.minimum(self._input_reference[i], self.max_rotor_velocity[i])
)
# Set the force using a quadratic thrust curve
self._force[i] = self._rotor_constant[i] * np.power(self._velocity[i], 2)
# Compute the rolling moment coefficient
rolling_moment += self._rolling_moment_coefficient[i] * np.power(self._velocity[i], 2.0) * self._rot_dir[i]
# Update the rolling moment variable
self._rolling_moment = rolling_moment
# Return the forces and velocities on each rotor and total torque applied on the body frame
return self._force, self._velocity, self._rolling_moment
@property
def force(self):
"""The force to apply to each rotor of the vehicle at any given time instant
Returns:
list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant
"""
return self._force
@property
def velocity(self):
"""The velocity at which each rotor of the vehicle should be rotating at any given time instant
Returns:
list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant
"""
return self._velocity
@property
def rolling_moment(self):
"""The total rolling moment being generated on the body frame of the vehicle by the rotating propellers
Returns:
float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm
"""
return self._rolling_moment
@property
def rot_dir(self):
"""The direction of rotation of each rotor of the vehicle
Returns:
list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise)
"""
return self._rot_dir
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/thrust_curve.py | """
| File: thrust_curve.py
| Author: Marcelo Jacinto ([email protected])
| Descriptio: File that implements the base interface for defining thrust curves for vehicles
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from pegasus.simulator.logic.state import State
class ThrustCurve:
"""Class that implements the dynamics of rotors that can be described by a quadratic thrust curve
"""
def __init__(self):
pass
def set_input_reference(self, input_reference):
"""
Receives as input a list of target angular velocities of each rotor in rad/s
"""
pass
def update(self, state: State, dt: float):
"""
Note: the state and dt variables are not used in this implementation, but left
to add support to other rotor models where the total thrust is dependent on
states such as vehicle linear velocity
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
"""
pass
@property
def force(self):
"""The force to apply to each rotor of the vehicle at any given time instant
Returns:
list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant
"""
pass
@property
def velocity(self):
"""The velocity at which each rotor of the vehicle should be rotating at any given time instant
Returns:
list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant
"""
pass
@property
def rolling_moment(self):
"""The total rolling moment being generated on the body frame of the vehicle by the rotating propellers
Returns:
float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm
"""
pass
@property
def rot_dir(self):
"""The direction of rotation of each rotor of the vehicle
Returns:
list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise)
"""
pass |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/ros2_camera.py | """
| File: ros2_camera.py
| License: BSD-3-Clause. Copyright (c) 2023, Micah Nye. All rights reserved.
"""
__all__ = ["ROS2Camera"]
import carb
from omni.isaac.core.utils import stage
import omni.graph.core as og
from omni.isaac.core.utils.prims import is_prim_path_valid
from omni.isaac.core.utils.prims import set_targets
from pegasus.simulator.logic.graphs import Graph
from pegasus.simulator.logic.vehicles import Vehicle
import numpy as np
class ROS2Camera(Graph):
"""The class that implements the ROS2 Camera graph. This class inherits the base class Graph.
"""
def __init__(self, camera_prim_path: str, config: dict = {}):
"""Initialize the ROS2 Camera class
Args:
camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path
config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera.
Examples:
The dictionary default parameters are
>>> {"graph_evaluator": "execution", # type of the omnigraph to create (execution, push)
>>> "resolution": [640, 480], # output video stream resolution in pixels [width, height]
>>> "types": ['rgb', 'camera_info'], # rgb, depth, depth_pcl, instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose, bbox_3d, camera_info
>>> "publish_labels": True, # publish labels for instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose and bbox_3d camera types
>>> "topic": "" # base topic name for the camera (default is camera name in Isaac Sim)
>>> "namespace": "" # namespace for the camera (default is vehicle name in Isaac Sim)
>>> "tf_frame_id": ""} # tf frame id for the camera (default is camera name in Isaac Sim)
"""
# Initialize the Super class "object" attribute
super().__init__(graph_type="ROS2Camera")
# Save camera path, frame id and ros topic name
self._camera_prim_path = camera_prim_path
self._frame_id = camera_prim_path.rpartition("/")[-1] # frame_id of the camera is the last prim path part after `/`
self._base_topic = config.get("topic", "")
self._namespace = config.get("namespace", "")
self._tf_frame_id = config.get("tf_frame_id", "")
# Process the config dictionary
self._graph_evaluator = config.get("graph_evaluator", "execution")
self._resolution = config.get("resolution", [640, 480])
self._types = np.array(config.get("types", ['rgb', 'camera_info']))
self._publish_labels = config.get("publish_labels", True)
def initialize(self, vehicle: Vehicle):
"""Method that initializes the graph of the camera.
Args:
vehicle (Vehicle): The vehicle that this graph is attached to.
"""
# Set the namespace for the camera if non is provided
if self._namespace == "":
self._namespace = f"/{vehicle.vehicle_name}"
# Set the base topic for the camera if non is provided
if self._base_topic == "":
self._base_topic = f"/{self._frame_id}"
# Set the tf frame id for the camera if non is provided
if self._tf_frame_id == "":
self._tf_frame_id = self._frame_id
# Set the prim_path for the camera
if self._camera_prim_path[0] != '/':
self._camera_prim_path = f"{vehicle.prim_path}/{self._camera_prim_path}"
# Create camera prism
if not is_prim_path_valid(self._camera_prim_path):
carb.log_error(f"Cannot create ROS2 Camera graph, the camera prim path \"{self._camera_prim_path}\" is not valid")
return
# Set the prim paths for camera and tf graphs
graph_path = f"{self._camera_prim_path}_pub"
# Graph configuration
if self._graph_evaluator == "execution":
graph_specs = {
"graph_path": graph_path,
"evaluator_name": "execution",
}
elif self._graph_evaluator == "push":
graph_specs = {
"graph_path": graph_path,
"evaluator_name": "push",
"pipeline_stage": og.GraphPipelineStage.GRAPH_PIPELINE_STAGE_ONDEMAND,
}
else:
carb.log_error(f"Cannot create ROS2 Camera graph, graph evaluator type \"{self._graph_evaluator}\" is not valid")
return
# Creating a graph edit configuration with cameraHelper nodes to generate ROS image publishers
keys = og.Controller.Keys
graph_config = {
keys.CREATE_NODES: [
("on_tick", "omni.graph.action.OnTick"),
("create_viewport", "omni.isaac.core_nodes.IsaacCreateViewport"),
("get_render_product", "omni.isaac.core_nodes.IsaacGetViewportRenderProduct"),
("set_viewport_resolution", "omni.isaac.core_nodes.IsaacSetViewportResolution"),
("set_camera", "omni.isaac.core_nodes.IsaacSetCameraOnRenderProduct"),
],
keys.CONNECT: [
("on_tick.outputs:tick", "create_viewport.inputs:execIn"),
("create_viewport.outputs:execOut", "get_render_product.inputs:execIn"),
("create_viewport.outputs:viewport", "get_render_product.inputs:viewport"),
("create_viewport.outputs:execOut", "set_viewport_resolution.inputs:execIn"),
("create_viewport.outputs:viewport", "set_viewport_resolution.inputs:viewport"),
("set_viewport_resolution.outputs:execOut", "set_camera.inputs:execIn"),
("get_render_product.outputs:renderProductPath", "set_camera.inputs:renderProductPath"),
],
keys.SET_VALUES: [
("create_viewport.inputs:viewportId", 0),
("create_viewport.inputs:name", f"{self._namespace}/{self._frame_id}"),
("set_viewport_resolution.inputs:width", self._resolution[0]),
("set_viewport_resolution.inputs:height", self._resolution[1]),
],
}
# Add camerasHelper for each selected camera type
valid_camera_type = False
for camera_type in self._types:
if not camera_type in ["rgb", "depth", "depth_pcl", "semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d", "camera_info"]:
continue
camera_helper_name = f"camera_helper_{camera_type}"
graph_config[keys.CREATE_NODES] += [
(camera_helper_name, "omni.isaac.ros2_bridge.ROS2CameraHelper")
]
graph_config[keys.CONNECT] += [
("set_camera.outputs:execOut", f"{camera_helper_name}.inputs:execIn"),
("get_render_product.outputs:renderProductPath", f"{camera_helper_name}.inputs:renderProductPath")
]
graph_config[keys.SET_VALUES] += [
(f"{camera_helper_name}.inputs:nodeNamespace", self._namespace),
(f"{camera_helper_name}.inputs:frameId", self._tf_frame_id),
(f"{camera_helper_name}.inputs:topicName", f"{self._base_topic}/{camera_type}"),
(f"{camera_helper_name}.inputs:type", camera_type)
]
# Publish labels for specific camera types
if self._publish_labels and camera_type in ["semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d"]:
graph_config[keys.SET_VALUES] += [
(camera_helper_name + ".inputs:enableSemanticLabels", True),
(camera_helper_name + ".inputs:semanticLabelsTopicName", f"{self._frame_id}/{camera_type}_labels")
]
valid_camera_type = True
if not valid_camera_type:
carb.log_error(f"Cannot create ROS2 Camera graph, no valid camera type was selected")
return
# Create the camera graph
(graph, _, _, _) = og.Controller.edit(
graph_specs,
graph_config
)
# Connect camera to the graphs
set_targets(
prim=stage.get_current_stage().GetPrimAtPath(f"{graph_path}/set_camera"),
attribute="inputs:cameraPrim",
target_prim_paths=[self._camera_prim_path]
)
# Run the ROS Camera graph once to generate ROS image publishers in SDGPipeline
og.Controller.evaluate_sync(graph)
# Also initialize the Super class with updated prim path (only camera graph path)
super().initialize(graph_path)
def camera_topic(self, camera_type: str) -> str:
"""
(str) Path to the camera topic.
Args:
camera_type (str): one of the supported camera output types
Returns:
Camera topic name (str) if the camera type exists, else empty string
"""
return f"{self._namespace}{self._base_topic}/{camera_type}" if camera_type in self._types else ""
def camera_labels_topic(self, camera_type: str) -> str:
"""
(str) Path to the camera labels topic.
Args:
camera_type (str): one of the supported camera output types
Returns:
Camera labels topic name (str) if the camera type exists, else empty string
"""
if not self._publish_labels or \
not camera_type in self._types or \
not camera_type in ["semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d"]:
return ""
return f"{self._namespace}{self._base_topic}/{camera_type}_labels"
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/__init__.py | """
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved.
"""
from .graph import Graph
from .ros2_camera import ROS2Camera
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/graph.py | """
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved.
"""
__all__ = ["Graph"]
class Graph:
"""The base class for implementing OmniGraphs
Attributes:
graph_prim_path
"""
def __init__(self, graph_type: str):
"""Initialize Graph class
Args:
graph_type (str): A name that describes the type of graph
"""
self._graph_type = graph_type
self._graph_prim_path = None
def initialize(self, graph_prim_path: str):
"""
Method that should be implemented and called by the class that inherits the graph object.
"""
self._graph_prim_path = graph_prim_path
@property
def graph_type(self) -> str:
"""
(str) A name that describes the type of graph.
"""
return self._graph_type
@property
def graph_prim_path(self) -> str:
"""
(str) Path to the graph.
"""
return self._graph_prim_path
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/magnetometer.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Simulates a magnetometer. Based on the original implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov
"""
__all__ = ["Magnetometer"]
import numpy as np
from scipy.spatial.transform import Rotation
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.sensors import Sensor
from pegasus.simulator.logic.rotations import rot_ENU_to_NED, rot_FLU_to_FRD
from pegasus.simulator.logic.sensors.geo_mag_utils import (
get_mag_declination,
get_mag_inclination,
get_mag_strength,
reprojection,
)
class Magnetometer(Sensor):
"""The class that implements a magnetometer sensor. This class inherits the base class Sensor.
"""
def __init__(self, config={}):
"""Initialize the Magnetometer class
Args:
config (dict): A Dictionary that contains all the parameters for configuring the Magnetometer - it can be empty or only have some of the parameters used by the Magnetometer.
Examples:
The dictionary default parameters are
>>> {"noise_density": 0.4e-3, # gauss / sqrt(hz)
>>> "random_walk": 6.4e-6, # gauss * sqrt(hz)
>>> "bias_correlation_time": 6.0e2, # s
>>> "update_rate": 250.0} # Hz
"""
# Initialize the Super class "object" attributes
super().__init__(sensor_type="Magnetometer", update_rate=config.get("update_rate", 250.0))
# Set the noise parameters
self._bias: np.ndarray = np.array([0.0, 0.0, 0.0])
self._noise_density = config.get("noise_density", 0.4e-3) # gauss / sqrt(hz)
self._random_walk = config.get("random_walk", 6.4e-6) # gauss * sqrt(hz)
self._bias_correlation_time = config.get("bias_correlation_time", 6.0e2) # s
# Initial state measured by the Magnetometer
self._state = {"magnetic_field": np.zeros((3,))}
@property
def state(self):
"""
(dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time
"""
return self._state
@Sensor.update_at_rate
def update(self, state: State, dt: float):
"""Method that implements the logic of a magnetometer. In this method we start by computing the projection
of the vehicle body frame such in the elipsoidal model of the earth in order to get its current latitude and
longitude. From here the declination and inclination are computed and used to get the strength of the magnetic
field, expressed in the inertial frame of reference (in ENU convention). This magnetic field is then rotated
to the body frame such that it becomes expressed in a FRD body frame relative to a NED inertial reference frame.
(The convention adopted by PX4). Random noise and bias are added to this magnetic field.
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
(dict) A dictionary containing the current state of the sensor (the data produced by the sensor)
"""
# Get the latitude and longitude from the current state
latitude, longitude = reprojection(state.position, np.radians(self._origin_lat), np.radians(self._origin_lon))
# Magnetic declination and inclination (radians)
declination_rad: float = np.radians(get_mag_declination(np.degrees(latitude), np.degrees(longitude)))
inclination_rad: float = np.radians(get_mag_inclination(np.degrees(latitude), np.degrees(longitude)))
# Compute the magnetic strength (10^5xnanoTesla)
strength_ga: float = 0.01 * get_mag_strength(np.degrees(latitude), np.degrees(longitude))
# Compute the Magnetic filed components according to: http://geomag.nrcan.gc.ca/mag_fld/comp-en.php
H: float = strength_ga * np.cos(inclination_rad)
Z: float = np.tan(inclination_rad) * H
X: float = H * np.cos(declination_rad)
Y: float = H * np.sin(declination_rad)
# Magnetic field of a body following a front-left-up (FLU) convention expressed in a East-North-Up (ENU) inertial frame
magnetic_field_inertial: np.ndarray = np.array([X, Y, Z])
# Rotate the magnetic field vector such that it expresses a field of a body frame according to the front-right-down (FRD)
# expressed in a North-East-Down (NED) inertial frame (the standard used in magnetometer units)
attitude_flu_enu = Rotation.from_quat(state.attitude)
# Rotate the magnetic field from the inertial frame to the body frame of reference according to the FLU frame convention
rot_body_to_world = rot_ENU_to_NED * attitude_flu_enu * rot_FLU_to_FRD.inv()
# The magnetic field expressed in the body frame according to the front-right-down (FRD) convention
magnetic_field_body = rot_body_to_world.inv().apply(magnetic_field_inertial)
# -------------------------------
# Add noise to the magnetic field
# -------------------------------
tau = self._bias_correlation_time
# Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt.
sigma_d: float = 1 / np.sqrt(dt) * self._noise_density
sigma_b: float = self._random_walk
# Compute exact covariance of the process after dt [Maybeck 4-114].
sigma_b_d: float = np.sqrt(-sigma_b * sigma_b * tau / 2.0 * (np.exp(-2.0 * dt / tau) - 1.0))
# Compute state-transition.
phi_d: float = np.exp(-1.0 / tau * dt)
# Add the noise to the magnetic field
magnetic_field_noisy: np.ndarray = np.zeros((3,))
for i in range(3):
self._bias[i] = phi_d * self._bias[i] + sigma_b_d * np.random.randn()
magnetic_field_noisy[i] = magnetic_field_body[i] + sigma_d * np.random.randn() + self._bias[i]
# Add the values to the dictionary and return it
self._state = {"magnetic_field": [magnetic_field_noisy[0], magnetic_field_noisy[1], magnetic_field_noisy[2]]}
return self._state
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/geo_mag_utils.py | """
| File: geo_mag_utils.py
| Description: Provides utilities for computing latitude, longitude, and magnetic strength
given the position of the vehicle in the simulated world. These computations and table constants are in agreement
with the PX4 stil_gazebo implementation (https://github.com/PX4/PX4-SITL_gazebo). Therefore, PX4 should behave similarly
to a gazebo-based simulation.
"""
import numpy as np
# Declare which functions are visible from this file
__all__ = ["get_mag_declination", "get_mag_inclination", "get_mag_strength", "reprojection", "GRAVITY_VECTOR"]
# --------------------------------------------------------------------
# Magnetic field data from WMM2018 (10^5xnanoTesla (N, E D) n-frame )
# --------------------------------------------------------------------
# Declination data in degrees
DECLINATION_TABLE = [
[ 47,46,45,43,42,41,39,37,33,29,23,16,10,4,-1,-6,-10,-15,-20,-27,-34,-42,-49,-56,-62,-67,-72,-74,-75,-73,-61,-22,26,42,47,48,47 ],
[ 31,31,31,30,30,30,30,29,27,24,18,11,3,-4,-9,-13,-15,-18,-21,-27,-33,-40,-47,-52,-56,-57,-56,-52,-44,-30,-14,2,14,22,27,30,31 ],
[ 22,23,23,23,22,22,22,23,22,19,13,5,-4,-12,-17,-20,-22,-22,-23,-25,-30,-36,-41,-45,-46,-44,-39,-31,-21,-11,-3,4,10,15,19,21,22 ],
[ 17,17,17,18,17,17,17,17,16,13,8,-1,-10,-18,-22,-25,-26,-25,-22,-20,-21,-25,-29,-32,-31,-28,-23,-16,-9,-3,0,4,7,11,14,16,17 ],
[ 13,13,14,14,14,13,13,12,11,9,3,-5,-14,-20,-24,-25,-24,-21,-17,-12,-9,-11,-14,-17,-18,-16,-12,-8,-3,-0,1,3,6,8,11,12,13 ],
[ 11,11,11,11,11,10,10,10,9,6,-0,-8,-15,-21,-23,-22,-19,-15,-10,-5,-2,-2,-4,-7,-9,-8,-7,-4,-1,1,1,2,4,7,9,10,11 ],
[ 10,9,9,9,9,9,9,8,7,3,-3,-10,-16,-20,-20,-18,-14,-9,-5,-2,1,2,0,-2,-4,-4,-3,-2,-0,0,0,1,3,5,7,9,10 ],
[ 9,9,9,9,9,9,9,8,6,1,-4,-11,-16,-18,-17,-14,-10,-5,-2,-0,2,3,2,0,-1,-2,-2,-1,-0,-1,-1,-1,1,3,6,8,9 ],
[ 8,9,9,10,10,10,10,8,5,0,-6,-12,-15,-16,-15,-11,-7,-4,-1,1,3,4,3,2,1,0,-0,-0,-1,-2,-3,-4,-2,0,3,6,8 ],
[ 7,9,10,11,12,12,12,9,5,-1,-7,-13,-15,-15,-13,-10,-6,-3,0,2,3,4,4,4,3,2,1,0,-1,-3,-5,-6,-6,-3,0,4,7 ],
[ 5,8,11,13,14,15,14,11,5,-2,-9,-15,-17,-16,-13,-10,-6,-3,0,3,4,5,6,6,6,5,4,2,-1,-5,-8,-9,-9,-6,-3,1,5 ],
[ 3,8,11,15,17,17,16,12,5,-4,-12,-18,-19,-18,-16,-12,-8,-4,-0,3,5,7,9,10,10,9,7,4,-1,-6,-10,-12,-12,-9,-5,-1,3 ],
[ 3,8,12,16,19,20,18,13,4,-8,-18,-24,-25,-23,-20,-16,-11,-6,-1,3,7,11,14,16,17,17,14,8,-0,-8,-13,-15,-14,-11,-7,-2,3 ]]
# Inclination data in degrees
INCLINATION_TABLE = [
[ -78,-76,-74,-72,-70,-68,-65,-63,-60,-57,-55,-54,-54,-55,-56,-57,-58,-59,-59,-59,-59,-60,-61,-63,-66,-69,-73,-76,-79,-83,-86,-87,-86,-84,-82,-80,-78 ],
[ -72,-70,-68,-66,-64,-62,-60,-57,-54,-51,-49,-48,-49,-51,-55,-58,-60,-61,-61,-61,-60,-60,-61,-63,-66,-69,-72,-76,-78,-80,-81,-80,-79,-77,-76,-74,-72 ],
[ -64,-62,-60,-59,-57,-55,-53,-50,-47,-44,-41,-41,-43,-47,-53,-58,-62,-65,-66,-65,-63,-62,-61,-63,-65,-68,-71,-73,-74,-74,-73,-72,-71,-70,-68,-66,-64 ],
[ -55,-53,-51,-49,-46,-44,-42,-40,-37,-33,-30,-30,-34,-41,-48,-55,-60,-65,-67,-68,-66,-63,-61,-61,-62,-64,-65,-66,-66,-65,-64,-63,-62,-61,-59,-57,-55 ],
[ -42,-40,-37,-35,-33,-30,-28,-25,-22,-18,-15,-16,-22,-31,-40,-48,-55,-59,-62,-63,-61,-58,-55,-53,-53,-54,-55,-55,-54,-53,-51,-51,-50,-49,-47,-45,-42 ],
[ -25,-22,-20,-17,-15,-12,-10,-7,-3,1,3,2,-5,-16,-27,-37,-44,-48,-50,-50,-48,-44,-41,-38,-38,-38,-39,-39,-38,-37,-36,-35,-35,-34,-31,-28,-25 ],
[ -5,-2,1,3,5,8,10,13,16,20,21,19,12,2,-10,-20,-27,-30,-30,-29,-27,-23,-19,-17,-17,-17,-18,-18,-17,-16,-16,-16,-16,-15,-12,-9,-5 ],
[ 15,18,21,22,24,26,29,31,34,36,37,34,28,20,10,2,-3,-5,-5,-4,-2,2,5,7,8,7,7,6,7,7,7,6,5,6,8,11,15 ],
[ 31,34,36,38,39,41,43,46,48,49,49,46,42,36,29,24,20,19,20,21,23,25,28,30,30,30,29,29,29,29,28,27,25,25,26,28,31 ],
[ 43,45,47,49,51,53,55,57,58,59,59,56,53,49,45,42,40,40,40,41,43,44,46,47,47,47,47,47,47,47,46,44,42,41,40,42,43 ],
[ 53,54,56,57,59,61,64,66,67,68,67,65,62,60,57,55,55,54,55,56,57,58,59,59,60,60,60,60,60,60,59,57,55,53,52,52,53 ],
[ 62,63,64,65,67,69,71,73,75,75,74,73,70,68,67,66,65,65,65,66,66,67,68,68,69,70,70,71,71,70,69,67,65,63,62,62,62 ],
[ 71,71,72,73,75,77,78,80,81,81,80,79,77,76,74,73,73,73,73,73,73,74,74,75,76,77,78,78,78,78,77,75,73,72,71,71,71 ]]
# Strength data in centi-Tesla
STRENGTH_TABLE = [
[ 62,60,58,56,54,52,49,46,43,41,38,36,34,32,31,31,30,30,30,31,33,35,38,42,46,51,55,59,62,64,66,67,67,66,65,64,62 ],
[ 59,56,54,52,50,47,44,41,38,35,32,29,28,27,26,26,26,25,25,26,28,30,34,39,44,49,54,58,61,64,65,66,65,64,63,61,59 ],
[ 54,52,49,47,45,42,40,37,34,30,27,25,24,24,24,24,24,24,24,24,25,28,32,37,42,48,52,56,59,61,62,62,62,60,59,56,54 ],
[ 49,47,44,42,40,37,35,33,30,28,25,23,22,23,23,24,25,25,26,26,26,28,31,36,41,46,51,54,56,57,57,57,56,55,53,51,49 ],
[ 43,41,39,37,35,33,32,30,28,26,25,23,23,23,24,25,26,28,29,29,29,30,32,36,40,44,48,51,52,52,51,51,50,49,47,45,43 ],
[ 38,36,35,33,32,31,30,29,28,27,26,25,24,24,25,26,28,30,31,32,32,32,33,35,38,42,44,46,47,46,45,45,44,43,41,40,38 ],
[ 34,33,32,32,31,31,31,30,30,30,29,28,27,27,27,28,29,31,32,33,33,33,34,35,37,39,41,42,43,42,41,40,39,38,36,35,34 ],
[ 33,33,32,32,33,33,34,34,35,35,34,33,32,31,30,30,31,32,33,34,35,35,36,37,38,40,41,42,42,41,40,39,37,36,34,33,33 ],
[ 34,34,34,35,36,37,39,40,41,41,40,39,37,35,35,34,35,35,36,37,38,39,40,41,42,43,44,45,45,45,43,41,39,37,35,34,34 ],
[ 37,37,38,39,41,42,44,46,47,47,46,45,43,41,40,39,39,40,41,41,42,43,45,46,47,48,49,50,50,50,48,46,43,41,39,38,37 ],
[ 42,42,43,44,46,48,50,52,53,53,52,51,49,47,45,45,44,44,45,46,46,47,48,50,51,53,54,55,56,55,54,52,49,46,44,43,42 ],
[ 48,48,49,50,52,53,55,56,57,57,56,55,53,51,50,49,48,48,48,49,49,50,51,53,55,56,58,59,60,60,58,56,54,52,50,49,48 ],
[ 54,54,54,55,56,57,58,58,59,58,58,57,56,54,53,52,51,51,51,51,52,53,54,55,57,58,60,61,62,61,61,59,58,56,55,54,54 ]]
SAMPLING_RES = 10.0
SAMPLING_MIN_LAT = -60 # deg
SAMPLING_MAX_LAT = 60 # deg
SAMPLING_MIN_LON = -180 # deg
SAMPLING_MAX_LON = 180 # deg
EARTH_RADIUS = 6353000.0 # meters
# Gravity vector expressed in ENU
GRAVITY_VECTOR = np.array([0.0, 0.0, -9.80665]) # m/s^2
def get_lookup_table_index(val: int, min: int, max: int):
# for the rare case of hitting the bounds exactly
# the rounding logic wouldn't fit, so enforce it.
# limit to table bounds - required for maxima even when table spans full globe range
# limit to (table bounds - 1) because bilinear interpolation requires checking (index + 1)
val = np.clip(val, min, max - SAMPLING_RES)
return int((-min + val) / SAMPLING_RES)
def get_table_data(lat: float, lon: float, table):
# If the values exceed valid ranges, return zero as default
# as we have no way of knowing what the closest real value
# would be.
if lat < -90.0 or lat > 90.0 or lon < -180.0 or lon > 180.0:
return 0.0
# round down to nearest sampling resolution
min_lat = int(lat / SAMPLING_RES) * SAMPLING_RES
min_lon = int(lon / SAMPLING_RES) * SAMPLING_RES
# find index of nearest low sampling point
min_lat_index = get_lookup_table_index(min_lat, SAMPLING_MIN_LAT, SAMPLING_MAX_LAT)
min_lon_index = get_lookup_table_index(min_lon, SAMPLING_MIN_LON, SAMPLING_MAX_LON)
data_sw = table[min_lat_index][min_lon_index]
data_se = table[min_lat_index][min_lon_index + 1]
data_ne = table[min_lat_index + 1][min_lon_index + 1]
data_nw = table[min_lat_index + 1][min_lon_index]
# perform bilinear interpolation on the four grid corners
lat_scale = np.clip((lat - min_lat) / SAMPLING_RES, 0.0, 1.0)
lon_scale = np.clip((lon - min_lon) / SAMPLING_RES, 0.0, 1.0)
data_min = lon_scale * (data_se - data_sw) + data_sw
data_max = lon_scale * (data_ne - data_nw) + data_nw
return lat_scale * (data_max - data_min) + data_min
def get_mag_declination(latitude: float, longitude: float):
return get_table_data(latitude, longitude, DECLINATION_TABLE)
def get_mag_inclination(latitude: float, longitude: float):
return get_table_data(latitude, longitude, INCLINATION_TABLE)
def get_mag_strength(latitude: float, longitude: float):
return get_table_data(latitude, longitude, STRENGTH_TABLE)
def reprojection(position: np.ndarray, origin_lat=-999, origin_long=-999):
"""
Compute the latitude and longitude coordinates from a local position
"""
# reproject local position to gps coordinates
x_rad: float = position[1] / EARTH_RADIUS # north
y_rad: float = position[0] / EARTH_RADIUS # east
c: float = np.sqrt(x_rad * x_rad + y_rad * y_rad)
sin_c: float = np.sin(c)
cos_c: float = np.cos(c)
if c != 0.0:
latitude_rad = np.arcsin(cos_c * np.sin(origin_lat) + (x_rad * sin_c * np.cos(origin_lat)) / c)
longitude_rad = origin_long + np.arctan2(y_rad * sin_c, c * np.cos(origin_lat) * cos_c - x_rad * np.sin(origin_lat) * sin_c)
else:
latitude_rad = origin_lat
longitude_rad = origin_long
return latitude_rad, longitude_rad
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .sensor import Sensor
from .barometer import Barometer
from .gps import GPS
from .imu import IMU
from .magnetometer import Magnetometer
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/sensor.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Definition of the Sensor class which is used as the base for all the sensors.
"""
__all__ = ["Sensor"]
from pegasus.simulator.logic.state import State
class Sensor:
"""The base class for implementing a sensor
Attributes:
update_period (float): The period for each sensor update: update_period = 1 / update_rate (in s).
origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors).
origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors).
origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors)
"""
def __init__(self, sensor_type: str, update_rate: float):
"""Initialize the Sensor class
Args:
sensor_type (str): A name that describes the type of sensor
update_rate (float): The rate at which the data in the sensor should be refreshed (in Hz)
"""
# Set the sensor type and update rate
self._sensor_type = sensor_type
self._update_rate = update_rate
self._update_period = 1.0 / self._update_rate
# Auxiliar variables used to control whether to update the sensor or not given the time elapsed
self._first_update = True
self._total_time = 0.0
# Set the "configuration of the world" - some sensors might need it
self._origin_lat = -999
self._origin_lon = -999
self._origin_alt = 0.0
def initialize(self, origin_lat, origin_lon, origin_alt):
"""Method that initializes the sensor latitude, longitude and altitude attributes.
Note:
Given that some sensors require the knowledge of the latitude, longitude and altitude of the [0, 0, 0] coordinate
of the world, then we might as well just save this information for whatever sensor that comes
Args:
origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors).
origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors).
origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors).
"""
self._origin_lat = origin_lat
self._origin_lon = origin_lon
self._origin_alt = origin_alt
def set_update_rate(self, update_rate: float):
"""Method that changes the update rate and period of the sensor
Args:
update_rate (float): The new rate at which the data in the sensor should be refreshed (in Hz)
"""
self._update_rate = update_rate
self._update_period = 1.0 / self._update_rate
def update_at_rate(fnc):
"""Decorator function used to check if the time elapsed between the last sensor update call and the current
sensor update call is higher than the defined update_rate of the sensor. If so, we need to actually compute new
values to simulate a measurement of the sensor at a given rate.
Args:
fnc (function): The function that we want to enforce a specific update rate.
Examples:
>>> class GPS(Sensor):
>>> @Sensor.update_at_rate
>>> def update(self):
>>> (do some logic here)
Returns:
[None, Dict]: This decorator function returns None if there was no data to be produced by the sensor at the
specified timestamp or a dict with the current state of the sensor otherwise.
"""
#
# Define a wrapper function so that the "self" of the object can be passed to the function as well
def wrapper(self, state: State, dt: float):
# Add the total time passed between the last time the sensor was updated and the current call
self._total_time += dt
# If it is time to update the sensor data, then just call the update function of the sensor
if self._total_time >= self._update_period or self._first_update:
# Result of the update function for the sensor
result = fnc(self, state, self._total_time)
# Reset the auxiliar counter variables
self._first_update = False
self._total_time = 0.0
return result
return None
return wrapper
@property
def sensor_type(self):
"""
(str) A name that describes the type of sensor.
"""
return self._sensor_type
@property
def update_rate(self):
"""
(float) The rate at which the data in the sensor should be refreshed (in Hz).
"""
return self._update_rate
@property
def state(self):
"""
(dict) A dictionary which contains the data produced by the sensor at any given time.
"""
return None
def update(self, state: State, dt: float):
"""Method that should be implemented by the class that inherits Sensor. This is where the actual implementation
of the sensor should be performed.
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
(dict) A dictionary containing the current state of the sensor (the data produced by the sensor)
"""
pass
def config_from_dict(self, config_dict):
"""Method that should be implemented by the class that inherits Sensor. This is where the configuration of the
sensor based on a dictionary input should be performed.
Args:
config_dict (dict): A dictionary containing the configurations of the sensor
"""
pass
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/barometer.py | """
| File: barometer.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Simulates a barometer. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov.
| References: Both the original implementation provided in the gazebo based simulation and this one are based on the following article - 'A brief summary of atmospheric modeling', Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf
"""
__all__ = ["Barometer"]
import numpy as np
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.sensors import Sensor
from pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR
DEFAULT_HOME_ALT_AMSL = 488.0
class Barometer(Sensor):
"""The class that implements a barometer sensor. This class inherits the base class Sensor.
"""
def __init__(self, config={}):
"""Initialize the Barometer class
Args:
config (dict): A Dictionary that contains all the parameters for configuring the Barometer - it can be empty or only have some of the parameters used by the Barometer.
Examples:
The dictionary default parameters are
>>> {"temperature_msl": 288.15, # temperature at MSL [K] (15 [C])
>>> "pressure_msl": 101325.0, # pressure at MSL [Pa]
>>> "lapse_rate": 0.0065, # reduction in temperature with altitude for troposphere [K/m]
>>> "air_density_msl": 1.225, # air density at MSL [kg/m^3]
>>> "absolute_zero": -273.15, # [C]
>>> "drift_pa_per_sec": 0.0, # Pa
>>> "update_rate": 250.0} # Hz
"""
# Initialize the Super class "object" attributes
super().__init__(sensor_type="Barometer", update_rate=config.get("update_rate", 250.0))
self._z_start: float = None
# Setup the default home altitude (aka the altitude at the [0.0, 0.0, 0.0] coordinate on the simulated world)
# If desired, the user can override this default by calling the initialize() method defined inside the Sensor
# implementation
self._origin_alt = DEFAULT_HOME_ALT_AMSL
# Define the constants for the barometer
# International standard atmosphere (troposphere model - valid up to 11km) see [1]
self._TEMPERATURE_MSL: float = config.get("temperature_msl", 288.15) # temperature at MSL [K] (15 [C])
self._PRESSURE_MSL: float = config.get("pressure_msl", 101325.0) # pressure at MSL [Pa]
self._LAPSE_RATE: float = config.get(
"lapse_rate", 0.0065
) # reduction in temperature with altitude for troposphere [K/m]
self._AIR_DENSITY_MSL: float = config.get("air_density_msl", 1.225) # air density at MSL [kg/m^3]
self._ABSOLUTE_ZERO_C: float = config.get("absolute_zero", -273.15) # [C]
# Set the drift for the sensor
self._baro_drift_pa_per_sec: float = config.get("drift_pa_per_sec", 0.0)
# Auxiliar variables for generating the noise
self._baro_rnd_use_last: bool = False
self._baro_rnd_y2: float = 0.0
self._baro_drift_pa: float = 0.0
# Save the current state measured by the Baramoter
self._state = {"absolute_pressure": 0.0, "pressure_altitude": 0.0, "temperature": 0.0}
@property
def state(self):
"""
(dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time
"""
return self._state
@Sensor.update_at_rate
def update(self, state: State, dt: float):
"""Method that implements the logic of a barometer. In this method we compute the relative altitude of the vehicle
relative to the origin's altitude. Aditionally, we compute the actual altitude of the vehicle, local temperature and
absolute presure, based on the reference - [A brief summary of atmospheric modeling, Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf]
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
(dict) A dictionary containing the current state of the sensor (the data produced by the sensor)
"""
# Set the initial altitude if not yet defined
if self._z_start is None:
self._z_start = state.position[2]
# Compute the temperature at the current altitude
alt_rel: float = state.position[2] - self._z_start
alt_amsl: float = self._origin_alt + alt_rel
temperature_local: float = self._TEMPERATURE_MSL - self._LAPSE_RATE * alt_amsl
# Compute the absolute pressure at local temperature
pressure_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 5.2561)
absolute_pressure: float = self._PRESSURE_MSL / pressure_ratio
# Generate a Gaussian noise sequence using polar form of Box-Muller transformation
# Honestly, this is overkill and will get replaced by numpys random.randn.
if not self._baro_rnd_use_last:
w: float = 1.0
while w >= 1.0:
x1: float = 2.0 * np.random.randn() - 1.0
x2: float = 2.0 * np.random.randn() - 1.0
w = (x1 * x1) + (x2 * x2)
w = np.sqrt((-2.0 * np.log(w)) / w)
y1: float = x1 * w
self._baro_rnd_y2 = x2 * w
self._baro_rnd_use_last = True
else:
y1: float = self._baro_rnd_y2
self._baro_rnd_use_last = False
# Apply noise and drift
abs_pressure_noise: float = y1 # 1 Pa RMS noise
self._baro_drift_pa = self._baro_drift_pa + (self._baro_drift_pa_per_sec * dt) # Update the drift
absolute_pressure_noisy: float = absolute_pressure + abs_pressure_noise + self._baro_drift_pa_per_sec
# Convert to hPa (Note: 1 hPa = 100 Pa)
absolute_pressure_noisy_hpa: float = absolute_pressure_noisy * 0.01
# Compute air density at local temperature
density_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 4.256)
air_density: float = self._AIR_DENSITY_MSL / density_ratio
# Compute pressure altitude including effect of pressure noise
pressure_altitude: float = alt_amsl - (abs_pressure_noise + self._baro_drift_pa) / (np.linalg.norm(GRAVITY_VECTOR) * air_density)
#pressure_altitude: float = alt_amsl - (abs_pressure_noise) / (np.linalg.norm(GRAVITY_VECTOR) * air_density)
# Compute temperature in celsius
temperature_celsius: float = temperature_local + self._ABSOLUTE_ZERO_C
# Add the values to the dictionary and return it
self._state = {
"absolute_pressure": absolute_pressure_noisy_hpa,
"pressure_altitude": pressure_altitude,
"temperature": temperature_celsius,
}
return self._state
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/gps.py | """
| File: gps.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Simulates a gps. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Amy Wagoner and Nuno Marques
"""
__all__ = ["GPS"]
import numpy as np
from pegasus.simulator.logic.sensors import Sensor
from pegasus.simulator.logic.sensors.geo_mag_utils import reprojection
# TODO - Introduce delay on the GPS data
class GPS(Sensor):
"""The class that implements a GPS sensor. This class inherits the base class Sensor.
"""
def __init__(self, config={}):
"""Initialize the GPS class.
Args:
config (dict): A Dictionary that contains all the parameters for configuring the GPS - it can be empty or only have some of the parameters used by the GPS.
Examples:
The dictionary default parameters are
>>> {"fix_type": 3,
>>> "eph": 1.0,
>>> "epv": 1.0,
>>> "sattelites_visible": 10,
>>> "gps_xy_random_walk": 2.0, # (m/s) / sqrt(hz)
>>> "gps_z_random_walk": 4.0, # (m/s) / sqrt(hz)
>>> "gps_xy_noise_density": 2.0e-4, # (m) / sqrt(hz)
>>> "gps_z_noise_density": 4.0e-4, # (m) / sqrt(hz)
>>> "gps_vxy_noise_density": 0.2, # (m/s) / sqrt(hz)
>>> "gps_vz_noise_density": 0.4, # (m/s) / sqrt(hz)
>>> "gps_correlation_time": 60, # s
>>> "update_rate": 1.0 # Hz
>>> }
"""
# Initialize the Super class "object" attributes
super().__init__(sensor_type="GPS", update_rate=config.get("update_rate", 250.0))
# Define the GPS simulated/fixed values
self._fix_type = config.get("fix_type", 3)
self._eph = config.get("eph", 1.0)
self._epv = config.get("epv", 1.0)
self._sattelites_visible = config.get("sattelites_visible", 10)
# Parameters for GPS random walk
self._random_walk_gps = np.array([0.0, 0.0, 0.0])
self._gps_xy_random_walk = config.get("gps_xy_random_walk", 2.0) # (m/s) / sqrt(hz)
self._gps_z_random_walk = config.get("gps_z_random_walk", 4.0) # (m/s) / sqrt(hz)
# Parameters for the position noise
self._noise_gps_pos = np.array([0.0, 0.0, 0.0])
self._gps_xy_noise_density = config.get("gps_xy_noise_density", 2.0e-4) # (m) / sqrt(hz)
self._gps_z_noise_density = config.get("gps_z_noise_density", 4.0e-4) # (m) / sqrt(hz)
# Parameters for the velocity noise
self._noise_gps_vel = np.array([0.0, 0.0, 0.0])
self._gps_vxy_noise_density = config.get("gps_vxy_noise_density", 0.2) # (m/s) / sqrt(hz)
self._gps_vz_noise_density = config.get("gps_vz_noise_density", 0.4) # (m/s) / sqrt(hz)
# Parameters for the GPS bias
self._gps_bias = np.array([0.0, 0.0, 0.0])
self._gps_correlation_time = config.get("gps_correlation_time", 60)
# Save the current state measured by the GPS (and initialize at the origin)
self._state = {
"latitude": np.radians(self._origin_lat),
"longitude": np.radians(self._origin_lon),
"altitude": self._origin_alt,
"eph": 1.0,
"epv": 1.0,
"speed": 0.0,
"velocity_north": 0.0,
"velocity_east": 0.0,
"velocity_down": 0.0,
# Constant values
"fix_type": self._fix_type,
"eph": self._eph,
"epv": self._epv,
"cog": 0.0,
"sattelites_visible": self._sattelites_visible,
"latitude_gt": np.radians(self._origin_lat),
"longitude_gt": np.radians(self._origin_lon),
"altitude_gt": self._origin_alt,
}
@property
def state(self):
"""
(dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time
"""
return self._state
@Sensor.update_at_rate
def update(self, state: np.ndarray, dt: float):
"""Method that implements the logic of a gps. In this method we start by generating the GPS bias terms which are then
added to the real position of the vehicle, expressed in ENU inertial frame. This position affected by noise
is reprojected in order to obtain the corresponding latitude and longitude. Additionally, to the linear velocity, noise
is added.
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
(dict) A dictionary containing the current state of the sensor (the data produced by the sensor)
"""
# Update noise parameters
self._random_walk_gps[0] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn()
self._random_walk_gps[1] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn()
self._random_walk_gps[2] = self._gps_z_random_walk * np.sqrt(dt) * np.random.randn()
self._noise_gps_pos[0] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn()
self._noise_gps_pos[1] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn()
self._noise_gps_pos[2] = self._gps_z_noise_density * np.sqrt(dt) * np.random.randn()
self._noise_gps_vel[0] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn()
self._noise_gps_vel[1] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn()
self._noise_gps_vel[2] = self._gps_vz_noise_density * np.sqrt(dt) * np.random.randn()
# Perform GPS bias integration (using euler integration -> to be improved)
self._gps_bias[0] = (
self._gps_bias[0] + self._random_walk_gps[0] * dt - self._gps_bias[0] / self._gps_correlation_time
)
self._gps_bias[1] = (
self._gps_bias[1] + self._random_walk_gps[1] * dt - self._gps_bias[1] / self._gps_correlation_time
)
self._gps_bias[2] = (
self._gps_bias[2] + self._random_walk_gps[2] * dt - self._gps_bias[2] / self._gps_correlation_time
)
# reproject position with noise into geographic coordinates
pos_with_noise: np.ndarray = state.position + self._noise_gps_pos + self._gps_bias
latitude, longitude = reprojection(pos_with_noise, np.radians(self._origin_lat), np.radians(self._origin_lon))
# Compute the values of the latitude and longitude without noise (for groundtruth measurements)
latitude_gt, longitude_gt = reprojection(
state.position, np.radians(self._origin_lat), np.radians(self._origin_lon)
)
# Add noise to the velocity expressed in the world frame
velocity: np.ndarray = state.linear_velocity # + self._noise_gps_vel
# Compute the xy speed
speed: float = np.linalg.norm(velocity[:2])
# Course over ground (NOT heading, but direction of movement),
# 0.0..359.99 degrees. If unknown, set to: 65535 [cdeg] (type:uint16_t)
ve = velocity[0]
vn = velocity[1]
cog = np.degrees(np.arctan2(ve, vn))
if cog < 0.0:
cog = cog + 360.0
cog = cog * 100
# Add the values to the dictionary and return it
self._state = {
"latitude": np.degrees(latitude),
"longitude": np.degrees(longitude),
"altitude": state.position[2] + self._origin_alt - self._noise_gps_pos[2] + self._gps_bias[2],
"eph": 1.0,
"epv": 1.0,
"speed": speed,
# Conversion from ENU (standard of Isaac Sim to NED - used in GPS sensors)
"velocity_north": velocity[1],
"velocity_east": velocity[0],
"velocity_down": -velocity[2],
# Constant values
"fix_type": self._fix_type,
"eph": self._eph,
"epv": self._epv,
"cog": 0.0, # cog,
"sattelites_visible": self._sattelites_visible,
"latitude_gt": latitude_gt,
"longitude_gt": longitude_gt,
"altitude_gt": state.position[2] + self._origin_alt,
}
return self._state
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/imu.py | """
| File: imu.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Simulates an imu. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo)
"""
__all__ = ["IMU"]
import numpy as np
from scipy.spatial.transform import Rotation
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.sensors import Sensor
from pegasus.simulator.logic.rotations import rot_FLU_to_FRD, rot_ENU_to_NED
from pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR
class IMU(Sensor):
"""The class that implements the IMU sensor. This class inherits the base class Sensor.
"""
def __init__(self, config={}):
"""Initialize the IMU class
Args:
config (dict): A Dictionary that contains all teh parameters for configuring the IMU - it can be empty or only have some of the parameters used by the IMU.
Examples:
The dictionary default parameters are
>>> {"gyroscope": {
>>> "noise_density": 2.0 * 35.0 / 3600.0 / 180.0 * pi,
>>> "random_walk": 2.0 * 4.0 / 3600.0 / 180.0 * pi,
>>> "bias_correlation_time": 1.0e3,
>>> "turn_on_bias_sigma": 0.5 / 180.0 * pi},
>>> "accelerometer": {
>>> "noise_density": 2.0 * 2.0e-3,
>>> "random_walk": 2.0 * 3.0e-3,
>>> "bias_correlation_time": 300.0,
>>> "turn_on_bias_sigma": 20.0e-3 * 9.8
>>> },
>>> "update_rate": 1.0} # Hz
"""
# Initialize the Super class "object" attributes
super().__init__(sensor_type="IMU", update_rate=config.get("update_rate", 250.0))
# Orientation noise constant
self._orientation_noise: float = 0.0
# Gyroscope noise constants
self._gyroscope_bias: np.ndarray = np.zeros((3,))
gyroscope_config = config.get("gyroscope", {})
self._gyroscope_noise_density = gyroscope_config.get("noise_density", 0.0003393695767766752)
self._gyroscope_random_walk = gyroscope_config.get("random_walk", 3.878509448876288E-05)
self._gyroscope_bias_correlation_time = gyroscope_config.get("bias_correlation_time", 1.0E3)
self._gyroscope_turn_on_bias_sigma = gyroscope_config.get("turn_on_bias_sigma", 0.008726646259971648)
# Accelerometer noise constants
self._accelerometer_bias: np.ndarray = np.zeros((3,))
accelerometer_config = config.get("accelerometer", {})
self._accelerometer_noise_density = accelerometer_config.get("noise_density", 0.004)
self._accelerometer_random_walk = accelerometer_config.get("random_walk", 0.006)
self._accelerometer_bias_correlation_time = accelerometer_config.get("bias_correlation_time", 300.0)
self._accelerometer_turn_on_bias_sigma = accelerometer_config.get("turn_on_bias_sigma", 0.196)
# Auxiliar variable used to compute the linear acceleration of the vehicle
self._prev_linear_velocity = np.zeros((3,))
# Save the current state measured by the IMU
self._state = {
"orientation": np.array([1.0, 0.0, 0.0, 0.0]),
"angular_velocity": np.array([0.0, 0.0, 0.0]),
"linear_acceleration": np.array([0.0, 0.0, 0.0]),
}
@property
def state(self):
"""
(dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time
"""
return self._state
@Sensor.update_at_rate
def update(self, state: State, dt: float):
"""Method that implements the logic of an IMU. In this method we start by generating the random walk of the
gyroscope. This value is then added to the real angular velocity of the vehicle (FLU relative to ENU inertial frame
expressed in FLU body frame). The same logic is followed for the accelerometer and the accelerations. After this step,
the angular velocity is rotated such that it expressed a FRD body frame, relative to a NED inertial frame, expressed
in the FRD body frame. Additionally, the acceleration is also rotated, such that it becomes expressed in the body
FRD frame of the vehicle. This sensor outputs data that follows the PX4 adopted standard.
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
(dict) A dictionary containing the current state of the sensor (the data produced by the sensor)
"""
# Gyroscopic terms
tau_g: float = self._accelerometer_bias_correlation_time
# Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt
sigma_g_d: float = 1 / np.sqrt(dt) * self._gyroscope_noise_density
sigma_b_g: float = self._gyroscope_random_walk
# Compute exact covariance of the process after dt [Maybeck 4-114]
sigma_b_g_d: float = np.sqrt(-sigma_b_g * sigma_b_g * tau_g / 2.0 * (np.exp(-2.0 * dt / tau_g) - 1.0))
# Compute state-transition
phi_g_d: float = np.exp(-1.0 / tau_g * dt)
# Simulate gyroscope noise processes and add them to the true angular rate.
angular_velocity: np.ndarray = np.zeros((3,))
for i in range(3):
self._gyroscope_bias[i] = phi_g_d * self._gyroscope_bias[i] + sigma_b_g_d * np.random.randn()
angular_velocity[i] = state.angular_velocity[i] + sigma_g_d * np.random.randn() + self._gyroscope_bias[i]
# Accelerometer terms
tau_a: float = self._accelerometer_bias_correlation_time
# Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt
sigma_a_d: float = 1.0 / np.sqrt(dt) * self._accelerometer_noise_density
sigma_b_a: float = self._accelerometer_random_walk
# Compute exact covariance of the process after dt [Maybeck 4-114].
sigma_b_a_d: float = np.sqrt(-sigma_b_a * sigma_b_a * tau_a / 2.0 * (np.exp(-2.0 * dt / tau_a) - 1.0))
# Compute state-transition.
phi_a_d: float = np.exp(-1.0 / tau_a * dt)
# Compute the linear acceleration from diferentiating the velocity of the vehicle expressed in the inertial frame
linear_acceleration_inertial = (state.linear_velocity - self._prev_linear_velocity) / dt
linear_acceleration_inertial = linear_acceleration_inertial - GRAVITY_VECTOR
# Update the previous linear velocity for the next computation
self._prev_linear_velocity = state.linear_velocity
# Compute the linear acceleration of the body frame, with respect to the inertial frame, expressed in the body frame
linear_acceleration = np.array(Rotation.from_quat(state.attitude).inv().apply(linear_acceleration_inertial))
# Simulate the accelerometer noise processes and add them to the true linear aceleration values
for i in range(3):
self._accelerometer_bias[i] = phi_a_d * self._accelerometer_bias[i] + sigma_b_a_d * np.random.rand()
linear_acceleration[i] = (
linear_acceleration[i] + sigma_a_d * np.random.randn()
) #+ self._accelerometer_bias[i]
# TODO - Add small "noisy" to the attitude
# --------------------------------------------------------------------------------------------
# Apply rotations such that we express the IMU data according to the FRD body frame convention
# --------------------------------------------------------------------------------------------
# Convert the orientation to the FRD-NED standard
attitude_flu_enu = Rotation.from_quat(state.attitude)
attitude_frd_enu = attitude_flu_enu * rot_FLU_to_FRD
attitude_frd_ned = rot_ENU_to_NED * attitude_frd_enu
# Convert the angular velocity from FLU to FRD standard
angular_velocity_frd = rot_FLU_to_FRD.apply(angular_velocity)
# Convert the linear acceleration in the body frame from FLU to FRD standard
linear_acceleration_frd = rot_FLU_to_FRD.apply(linear_acceleration)
# Add the values to the dictionary and return it
self._state = {
"orientation": attitude_frd_ned.as_quat(),
"angular_velocity": angular_velocity_frd,
"linear_acceleration": linear_acceleration_frd,
}
return self._state
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/interface/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .pegasus_interface import PegasusInterface
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/interface/pegasus_interface.py | """
| File: pegasus_interface.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Definition of the PegasusInterface class (a singleton) that is used to manage the Pegasus framework.
"""
__all__ = ["PegasusInterface"]
# Importing Lock in ordef to have a multithread safe Pegasus singleton that manages the entire Pegasus extension
import gc
import yaml
import asyncio
import os
from threading import Lock
# NVidia API imports
import carb
import omni.kit.app
from omni.isaac.core.world import World
from omni.isaac.core.utils.stage import clear_stage, create_new_stage_async, update_stage_async
from omni.isaac.core.utils.viewports import set_camera_view
import omni.isaac.core.utils.nucleus as nucleus
# Pegasus Simulator internal API
from pegasus.simulator.params import DEFAULT_WORLD_SETTINGS, SIMULATION_ENVIRONMENTS, CONFIG_FILE
from pegasus.simulator.logic.vehicle_manager import VehicleManager
class PegasusInterface:
"""
PegasusInterface is a singleton class (there is only one object instance at any given time) that will be used
to
"""
# The object instance of the Vehicle Manager
_instance = None
_is_initialized = False
# Lock for safe multi-threading
_lock: Lock = Lock()
def __init__(self):
"""
Initialize the PegasusInterface singleton object (only runs once at a time)
"""
# If we already have an instance of the PegasusInterface, do not overwrite it!
if PegasusInterface._is_initialized:
return
carb.log_info("Initializing the Pegasus Simulator Extension")
PegasusInterface._is_initialized = True
# Get a handle to the vehicle manager instance which will manage which vehicles are spawned in the world
# to be controlled and simulated
self._vehicle_manager = VehicleManager()
# Initialize the world with the default simulation settings
self._world_settings = DEFAULT_WORLD_SETTINGS
self._world = None
#self.initialize_world()
# Initialize the latitude, longitude and altitude of the simulated environment at the (0.0, 0.0, 0.0) coordinate
# from the extension configuration file
self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config()
# Get the px4_path from the extension configuration file
self._px4_path: str = self._get_px4_path_from_config()
self._px4_default_airframe: str = self._get_px4_default_airframe_from_config()
carb.log_info("Default PX4 path:" + str(self._px4_path))
@property
def world(self):
"""The current omni.isaac.core.world World instance
Returns:
omni.isaac.core.world: The world instance
"""
return self._world
@property
def vehicle_manager(self):
"""The instance of the VehicleManager.
Returns:
VehicleManager: The current instance of the VehicleManager.
"""
return self._vehicle_manager
@property
def latitude(self):
"""The latitude of the origin of the simulated world in degrees.
Returns:
float: The latitude of the origin of the simulated world in degrees.
"""
return self._latitude
@property
def longitude(self):
"""The longitude of the origin of the simulated world in degrees.
Returns:
float: The longitude of the origin of the simulated world in degrees.
"""
return self._longitude
@property
def altitude(self):
"""The altitude of the origin of the simulated world in meters.
Returns:
float: The latitude of the origin of the simulated world in meters.
"""
return self._altitude
@property
def px4_path(self):
"""A string with the installation directory for PX4 (if it was setup). Otherwise it is None.
Returns:
str: A string with the installation directory for PX4 (if it was setup). Otherwise it is None.
"""
return self._px4_path
@property
def px4_default_airframe(self):
"""A string with the PX4 default airframe (if it was setup). Otherwise it is None.
Returns:
str: A string with the PX4 default airframe (if it was setup). Otherwise it is None.
"""
return self._px4_default_airframe
def set_global_coordinates(self, latitude=None, longitude=None, altitude=None):
"""Method that can be used to set the latitude, longitude and altitude of the simulation world at the origin.
Args:
latitude (float): The latitude of the origin of the simulated world in degrees. Defaults to None.
longitude (float): The longitude of the origin of the simulated world in degrees. Defaults to None.
altitude (float): The altitude of the origin of the simulated world in meters. Defaults to None.
"""
if latitude is not None:
self._latitude = latitude
if longitude is not None:
self._longitude = longitude
if self.altitude is not None:
self._altitude = altitude
carb.log_warn("New global coordinates set to: " + str(self._latitude) + ", " + str(self._longitude) + ", " + str(self._altitude))
def initialize_world(self):
"""Method that initializes the world object
"""
self._world = World(**self._world_settings)
#asyncio.ensure_future(self._world.initialize_simulation_context_async())
def get_vehicle(self, stage_prefix: str):
"""Method that returns the vehicle object given its 'stage_prefix', i.e., the name the vehicle was spawned with in the simulator.
Args:
stage_prefix (str): The name the vehicle will present in the simulator when spawned.
Returns:
Vehicle: Returns a vehicle object that was spawned with the given 'stage_prefix'
"""
return self._vehicle_manager.vehicles[stage_prefix]
def get_all_vehicles(self):
"""
Method that returns a list of vehicles that are considered active in the simulator
Returns:
list: A list of all vehicles that are currently instantiated.
"""
return self._vehicle_manager.vehicles
def get_default_environments(self):
"""
Method that returns a dictionary containing all the default simulation environments and their path
"""
return SIMULATION_ENVIRONMENTS
def generate_quadrotor_config_from_yaml(self, file: str):
"""_summary_
Args:
file (str): _description_
Returns:
_type_: _description_
"""
# Load the quadrotor configuration data from the given yaml file
with open(file) as f:
data = yaml.safe_load(f)
return self.generate_quadrotor_config_from_dict(data)
def clear_scene(self):
"""
Method that when invoked will clear all vehicles and the simulation environment, leaving only an empty world with a physics environment.
"""
# If the physics simulation was running, stop it first
if self.world is not None:
self.world.stop()
# Clear the world
if self.world is not None:
self.world.clear_all_callbacks()
self.world.clear()
# Clear the stage
clear_stage()
# Remove all the robots that were spawned
self._vehicle_manager.remove_all_vehicles()
# Call python's garbage collection
gc.collect()
# Re-initialize the physics context
asyncio.ensure_future(self._world.initialize_simulation_context_async())
carb.log_info("Current scene and its vehicles has been deleted")
async def load_environment_async(self, usd_path: str, force_clear: bool=False):
"""Method that loads a given world (specified in the usd_path) into the simulator asynchronously.
Args:
usd_path (str): The path where the USD file describing the world is located.
force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False.
It should be set to True only if the method is invoked from an App (GUI mode).
"""
# Reset and pause the world simulation (only if force_clear is true)
# This is done to maximize the support between running in GUI as extension vs App
if force_clear == True:
# Create a new stage and initialize (or re-initialized) the world
await create_new_stage_async()
self._world = World(**self._world_settings)
await self._world.initialize_simulation_context_async()
self._world = World.instance()
await self.world.reset_async()
await self.world.stop_async()
# Load the USD asset that will be used for the environment
try:
self.load_asset(usd_path, "/World/layout")
except Exception as e:
carb.log_warn("Could not load the desired environment: " + str(e))
carb.log_info("A new environment has been loaded successfully")
def load_environment(self, usd_path: str, force_clear: bool=False):
"""Method that loads a given world (specified in the usd_path) into the simulator. If invoked from a python app,
this method should have force_clear=False, as the world reset and stop are performed asynchronously by this method,
and when we are operating in App mode, we want everything to run in sync.
Args:
usd_path (str): The path where the USD file describing the world is located.
force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False.
"""
asyncio.ensure_future(self.load_environment_async(usd_path, force_clear))
def load_nvidia_environment(self, environment_asset: str = "Hospital/hospital.usd"):
"""
Method that is used to load NVidia internally provided USD stages into the simulaton World
Args:
environment_asset (str): The name of the nvidia asset inside the /Isaac/Environments folder. Default to Hospital/hospital.usd.
"""
# Get the nvidia assets root path
nvidia_assets_path = nucleus.get_assets_root_path()
# Define the environments path inside the NVidia assets
environments_path = "/Isaac/Environments"
# Get the complete usd path
usd_path = nvidia_assets_path + environments_path + "/" + environment_asset
# Try to load the asset into the world
self.load_asset(usd_path, "/World/layout")
def load_asset(self, usd_asset: str, stage_prefix: str):
"""
Method that will attempt to load an asset into the current simulation world, given the USD asset path.
Args:
usd_asset (str): The path where the USD file describing the world is located.
stage_prefix (str): The name the vehicle will present in the simulator when spawned.
"""
# Try to check if there is already a prim with the same stage prefix in the stage
if self._world.stage.GetPrimAtPath(stage_prefix):
raise Exception("A primitive already exists at the specified path")
# Create the stage primitive and load the usd into it
prim = self._world.stage.DefinePrim(stage_prefix)
success = prim.GetReferences().AddReference(usd_asset)
if not success:
raise Exception("The usd asset" + usd_asset + "is not load at stage path " + stage_prefix)
def set_viewport_camera(self, camera_position, camera_target):
"""Sets the viewport camera to given position and makes it point to another target position.
Args:
camera_position (list): A list with [X, Y, Z] coordinates of the camera in ENU inertial frame.
camera_target (list): A list with [X, Y, Z] coordinates of the target that the camera should point to in the ENU inertial frame.
"""
# Set the camera view to a fixed value
set_camera_view(eye=camera_position, target=camera_target)
def set_world_settings(self, physics_dt=None, stage_units_in_meters=None, rendering_dt=None):
"""
Set the current world settings to the pre-defined settings. TODO - finish the implementation of this method.
For now these new setting will never override the default ones.
"""
# Set the physics engine update rate
if physics_dt is not None:
self._world_settings["physics_dt"] = physics_dt
# Set the units of the simulator to meters
if stage_units_in_meters is not None:
self._world_settings["stage_units_in_meters"] = stage_units_in_meters
# Set the render engine update rate (might not be the same as the physics engine)
if rendering_dt is not None:
self._world_settings["rendering_dt"] = rendering_dt
def _get_px4_path_from_config(self):
"""
Method that reads the configured PX4 installation directory from the extension configuration file
Returns:
str: A string with the path to the px4 configuration directory or empty string ''
"""
px4_dir = ""
# Open the configuration file. If it fails, just return the empty path
try:
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
px4_dir = os.path.expanduser(data.get("px4_dir", None))
except:
carb.log_warn("Could not retrieve px4_dir from: " + str(CONFIG_FILE))
return px4_dir
def _get_px4_default_airframe_from_config(self):
"""
Method that reads the configured PX4 default airframe from the extension configuration file
Returns:
str: A string with the path to the PX4 default airframe or empty string ''
"""
px4_default_airframe = ""
# Open the configuration file. If it fails, just return the empty path
try:
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
px4_default_airframe = os.path.expanduser(data.get("px4_default_airframe", None))
except:
carb.log_warn("Could not retrieve px4_default_airframe from: " + str(CONFIG_FILE))
return px4_default_airframe
def _get_global_coordinates_from_config(self):
"""Method that reads the default latitude, longitude and altitude from the extension configuration file
Returns:
(float, float, float): A tuple of 3 floats with the latitude, longitude and altitude to use as the origin of the world
"""
latitude = 0.0
longitude = 0.0
altitude = 0.0
# Open the configuration file. If it fails, just return the empty path
try:
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
# Try to read the coordinates from the configuration file
global_coordinates = data.get("global_coordinates", {})
latitude = global_coordinates.get("latitude", 0.0)
longitude = global_coordinates.get("longitude", 0.0)
altitude = global_coordinates.get("altitude", 0.0)
except:
carb.log_warn("Could not retrieve the global coordinates from: " + str(CONFIG_FILE))
return (latitude, longitude, altitude)
def set_px4_path(self, path: str):
"""Method that allows a user to save a new px4 directory in the configuration files of the extension.
Args:
absolute_path (str): The new path of the px4-autopilot installation directory
"""
# Save the new path for current use during this simulation
self._px4_path = os.path.expanduser(path)
# Save the new path in the configurations file for the next simulations
try:
# Open the configuration file and the all the configurations that it contains
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
# Open the configuration file. If it fails, just warn in the console
with open(CONFIG_FILE, 'w') as f:
data["px4_dir"] = path
yaml.dump(data, f)
except:
carb.log_warn("Could not save px4_dir to: " + str(CONFIG_FILE))
carb.log_warn("New px4_dir set to: " + str(self._px4_path))
def set_px4_default_airframe(self, airframe: str):
"""Method that allows a user to save a new px4 default airframe for the extension.
Args:
absolute_path (str): The new px4 default airframe
"""
# Save the new path for current use during this simulation
self._px4_default_airframe = airframe
# Save the new path in the configurations file for the next simulations
try:
# Open the configuration file and the all the configurations that it contains
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
# Open the configuration file. If it fails, just warn in the console
with open(CONFIG_FILE, 'w') as f:
data["px4_default_airframe"] = airframe
yaml.dump(data, f)
except:
carb.log_warn("Could not save px4_default_airframe to: " + str(CONFIG_FILE))
carb.log_warn("New px4_default_airframe set to: " + str(self._px4_default_airframe))
def set_default_global_coordinates(self):
"""
Method that sets the latitude, longitude and altitude from the pegasus interface to the
default global coordinates specified in the extension configuration file
"""
self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config()
def set_new_default_global_coordinates(self, latitude: float=None, longitude: float=None, altitude: float=None):
# Set the current global coordinates to the new default global coordinates
self.set_global_coordinates(latitude, longitude, altitude)
# Update the default global coordinates in the configuration file
try:
# Open the configuration file and the all the configurations that it contains
with open(CONFIG_FILE, 'r') as f:
data = yaml.safe_load(f)
# Open the configuration file. If it fails, just warn in the console
with open(CONFIG_FILE, 'w') as f:
if latitude is not None:
data["global_coordinates"]["latitude"] = latitude
if longitude is not None:
data["global_coordinates"]["longitude"] = longitude
if altitude is not None:
data["global_coordinates"]["altitude"] = altitude
# Save the updated configurations
yaml.dump(data, f)
except:
carb.log_warn("Could not save the new global coordinates to: " + str(CONFIG_FILE))
carb.log_warn("New global coordinates set to: latitude=" + str(latitude) + ", longitude=" + str(longitude) + ", altitude=" + str(altitude))
def __new__(cls):
"""Allocates the memory and creates the actual PegasusInterface object is not instance exists yet. Otherwise,
returns the existing instance of the PegasusInterface class.
Returns:
VehicleManger: the single instance of the VehicleManager class
"""
# Use a lock in here to make sure we do not have a race condition
# when using multi-threading and creating the first instance of the Pegasus extension manager
with cls._lock:
if cls._instance is None:
cls._instance = object.__new__(cls)
return PegasusInterface._instance
def __del__(self):
"""Destructor for the object. Destroys the only existing instance of this class."""
PegasusInterface._instance = None
PegasusInterface._is_initialized = False |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/backend.py | """
| File: backend.py
| Author: Marcelo Jacinto ([email protected])
| Description:
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
class Backend:
"""
This class defines the templates for the communication and control backend. Every vehicle can have at least one backend
at the same time. Every timestep, the methods 'update_state' and 'update_sensor' are called to update the data produced
by the simulation, i.e. for every time step the backend will receive teh current state of the vehicle and its sensors.
Additionally, the backend must provide a method named 'input_reference' which will be used by the vehicle simulation
to know the desired angular velocities to apply to the rotors of the vehicle. The method 'update' is called on every
physics step and can be use to implement some logic or send data to another interface (such as PX4 through mavlink or ROS2).
The methods 'start', 'stop' and 'reset' are callbacks that get called when the simulation is started, stoped and reset as the name implies.
"""
def __init__(self):
"""Initialize the Backend class
"""
self._vehicle = None
"""
Properties
"""
@property
def vehicle(self):
"""A reference to the vehicle associated with this backend.
Returns:
Vehicle: A reference to the vehicle associated with this backend.
"""
return self._vehicle
def initialize(self, vehicle):
"""A method that can be invoked when the simulation is starting to give access to the control backend
to the entire vehicle object. Even though we provide update_sensor and update_state callbacks that are called
at every physics step with the latest vehicle state and its sensor data, having access to the full vehicle
object may prove usefull under some circumstances. This is nice to give users the possibility of overiding
default vehicle behaviour via this control backend structure.
Args:
vehicle (Vehicle): A reference to the vehicle that this sensor is associated with
"""
self._vehicle = vehicle
def update_sensor(self, sensor_type: str, data):
"""Method that when implemented, should handle the receival of sensor data
Args:
sensor_type (str): A name that describes the type of sensor
data (dict): A dictionary that contains the data produced by the sensor
"""
pass
def update_state(self, state):
"""Method that when implemented, should handle the receival of the state of the vehicle using this callback
Args:
state (State): The current state of the vehicle.
"""
pass
def input_reference(self):
"""Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors
"""
return []
def update(self, dt: float):
"""Method that when implemented, should be used to update the state of the backend and the information being sent/received
from the communication interface. This method will be called by the simulation on every physics step
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
pass
def start(self):
"""Method that when implemented should handle the begining of the simulation of vehicle
"""
pass
def stop(self):
"""Method that when implemented should handle the stopping of the simulation of vehicle
"""
pass
def reset(self):
"""Method that when implemented, should handle the reset of the vehicle simulation to its original state
"""
pass
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .backend import Backend
from .mavlink_backend import MavlinkBackend, MavlinkBackendConfig
from .ros2_backend import ROS2Backend
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/ros2_backend.py | """
| File: ros2_backend.py
| Author: Marcelo Jacinto ([email protected])
| Description: File that implements the ROS2 Backend for communication/control with/of the vehicle simulation through ROS2 topics
| License: BSD-3-Clause. Copyright (c) 2024, Marcelo Jacinto. All rights reserved.
"""
import carb
from omni.isaac.core.utils.extensions import disable_extension, enable_extension
# Perform some checks, because Isaac Sim some times does not play nice when using ROS/ROS2
disable_extension("omni.isaac.ros_bridge")
enable_extension("omni.isaac.ros2_bridge")
# ROS2 imports
import rclpy
from std_msgs.msg import Float64
from geometry_msgs.msg import TransformStamped
from sensor_msgs.msg import Imu, MagneticField, NavSatFix, NavSatStatus
from geometry_msgs.msg import PoseStamped, TwistStamped, AccelStamped
# TF imports
from tf2_ros.static_transform_broadcaster import StaticTransformBroadcaster
from tf2_ros.transform_broadcaster import TransformBroadcaster
from pegasus.simulator.logic.backends.backend import Backend
class ROS2Backend(Backend):
def __init__(self, vehicle_id: int, num_rotors=4, config: dict = {}):
"""Initialize the ROS2 Camera class
Args:
camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path
config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera.
Examples:
The dictionary default parameters are
>>> {"namespace": "drone" # Namespace to append to the topics
>>> "pub_pose": True, # Publish the pose of the vehicle
>>> "pub_twist": True, # Publish the twist of the vehicle
>>> "pub_twist_inertial": True, # Publish the twist of the vehicle in the inertial frame
>>> "pub_accel": True, # Publish the acceleration of the vehicle
>>> "pub_imu": True, # Publish the IMU data
>>> "pub_mag": True, # Publish the magnetometer data
>>> "pub_gps": True, # Publish the GPS data
>>> "pub_gps_vel": True, # Publish the GPS velocity data
>>> "pose_topic": "state/pose", # Position and attitude of the vehicle in ENU
>>> "twist_topic": "state/twist", # Linear and angular velocities in the body frame of the vehicle
>>> "twist_inertial_topic": "state/twist_inertial" # Linear velocity of the vehicle in the inertial frame
>>> "accel_topic": "state/accel", # Linear acceleration of the vehicle in the inertial frame
>>> "imu_topic": "sensors/imu", # IMU data
>>> "mag_topic": "sensors/mag", # Magnetometer data
>>> "gps_topic": "sensors/gps", # GPS data
>>> "gps_vel_topic": "sensors/gps_twist", # GPS velocity data
"""
# Save the configurations for this backend
self._id = vehicle_id
self._num_rotors = num_rotors
self._namespace = config.get("namespace", "drone" + str(vehicle_id))
# Start the actual ROS2 setup here
rclpy.init()
self.node = rclpy.create_node("vehicle_" + str(vehicle_id))
# Create publishers for the state of the vehicle in ENU
if config.get("pub_pose", True):
self.pose_pub = self.node.create_publisher(PoseStamped, self._namespace + str(self._id) + "/" + config.get("pose_topic", "state/pose"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_twist", True):
self.twist_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("twist_topic", "state/twist"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_twist_inertial", True):
self.twist_inertial_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("twist_inertial_topic", "state/twist_inertial"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_accel", True):
self.accel_pub = self.node.create_publisher(AccelStamped, self._namespace + str(self._id) + "/" + config.get("accel_topic", "state/accel"), rclpy.qos.qos_profile_sensor_data)
# Create publishers for some sensor data
if config.get("pub_imu", True):
self.imu_pub = self.node.create_publisher(Imu, self._namespace + str(self._id) + "/" + config.get("imu_topic", "sensors/imu"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_mag", True):
self.mag_pub = self.node.create_publisher(MagneticField, self._namespace + str(self._id) + "/" + config.get("mag_topic", "sensors/mag"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_gps", True):
self.gps_pub = self.node.create_publisher(NavSatFix, self._namespace + str(self._id) + "/" + config.get("gps_topic", "sensors/gps"), rclpy.qos.qos_profile_sensor_data)
if config.get("pub_gps_vel", True):
self.gps_vel_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("gps_vel_topic", "sensors/gps_twist"), rclpy.qos.qos_profile_sensor_data)
# Subscribe to vector of floats with the target angular velocities to control the vehicle
# This is not ideal, but we need to reach out to NVIDIA so that they can improve the ROS2 support with custom messages
# The current setup as it is.... its a pain!!!!
self.rotor_subs = []
for i in range(self._num_rotors):
self.rotor_subs.append(self.node.create_subscription(Float64, self._namespace + str(self._id) + "/control/rotor" + str(i) + "/ref", lambda x: self.rotor_callback(x, i),10))
# Setup zero input reference for the thrusters
self.input_ref = [0.0 for i in range(self._num_rotors)]
# Initiliaze the static tf broadcaster for the sensors
self.tf_static_broadcaster = StaticTransformBroadcaster(self.node)
# Initialize the static tf broadcaster for the base_link transformation
self.send_static_transforms()
# Initialize the dynamic tf broadcaster for the position of the body of the vehicle (base_link) with respect to the inertial frame (map - ENU) expressed in the inertil frame (map - ENU)
self.tf_broadcaster = TransformBroadcaster(self.node)
def send_static_transforms(self):
# Create the transformation from base_link FLU (ROS standard) to base_link FRD (standard in airborn and marine vehicles)
t = TransformStamped()
t.header.stamp = self.node.get_clock().now().to_msg()
t.header.frame_id = self._namespace + '_' + 'base_link'
t.child_frame_id = self._namespace + '_' + 'base_link_frd'
# Converts from FLU to FRD
t.transform.translation.x = 0.0
t.transform.translation.y = 0.0
t.transform.translation.z = 0.0
t.transform.rotation.x = 1.0
t.transform.rotation.y = 0.0
t.transform.rotation.z = 0.0
t.transform.rotation.w = 0.0
self.tf_static_broadcaster.sendTransform(t)
# Create the transform from map, i.e inertial frame (ROS standard) to map_ned (standard in airborn or marine vehicles)
t = TransformStamped()
t.header.stamp = self.node.get_clock().now().to_msg()
t.header.frame_id = "map"
t.child_frame_id = "map_ned"
# Converts ENU to NED
t.transform.translation.x = 0.0
t.transform.translation.y = 0.0
t.transform.translation.z = 0.0
t.transform.rotation.x = -0.7071068
t.transform.rotation.y = -0.7071068
t.transform.rotation.z = 0.0
t.transform.rotation.w = 0.0
self.tf_static_broadcaster.sendTransform(t)
def update_state(self, state):
"""
Method that when implemented, should handle the receivel of the state of the vehicle using this callback
"""
pose = PoseStamped()
twist = TwistStamped()
twist_inertial = TwistStamped()
accel = AccelStamped()
# Update the header
pose.header.stamp = self.node.get_clock().now().to_msg()
twist.header.stamp = pose.header.stamp
twist_inertial.header.stamp = pose.header.stamp
accel.header.stamp = pose.header.stamp
pose.header.frame_id = "map"
twist.header.frame_id = self._namespace + "_" + "base_link"
twist_inertial.header.frame_id = "map"
accel.header.frame_id = "map"
# Fill the position and attitude of the vehicle in ENU
pose.pose.position.x = state.position[0]
pose.pose.position.y = state.position[1]
pose.pose.position.z = state.position[2]
pose.pose.orientation.x = state.attitude[0]
pose.pose.orientation.y = state.attitude[1]
pose.pose.orientation.z = state.attitude[2]
pose.pose.orientation.w = state.attitude[3]
# Fill the linear and angular velocities in the body frame of the vehicle
twist.twist.linear.x = state.linear_body_velocity[0]
twist.twist.linear.y = state.linear_body_velocity[1]
twist.twist.linear.z = state.linear_body_velocity[2]
twist.twist.angular.x = state.angular_velocity[0]
twist.twist.angular.y = state.angular_velocity[1]
twist.twist.angular.z = state.angular_velocity[2]
# Fill the linear velocity of the vehicle in the inertial frame
twist_inertial.twist.linear.x = state.linear_velocity[0]
twist_inertial.twist.linear.y = state.linear_velocity[1]
twist_inertial.twist.linear.z = state.linear_velocity[2]
# Fill the linear acceleration in the inertial frame
accel.accel.linear.x = state.linear_acceleration[0]
accel.accel.linear.y = state.linear_acceleration[1]
accel.accel.linear.z = state.linear_acceleration[2]
# Publish the messages containing the state of the vehicle
self.pose_pub.publish(pose)
self.twist_pub.publish(twist)
self.twist_inertial_pub.publish(twist_inertial)
self.accel_pub.publish(accel)
# Update the dynamic tf broadcaster with the current position of the vehicle in the inertial frame
t = TransformStamped()
t.header.stamp = pose.header.stamp
t.header.frame_id = "map"
t.child_frame_id = self._namespace + '_' + 'base_link'
t.transform.translation.x = state.position[0]
t.transform.translation.y = state.position[1]
t.transform.translation.z = state.position[2]
t.transform.rotation.x = state.attitude[0]
t.transform.rotation.y = state.attitude[1]
t.transform.rotation.z = state.attitude[2]
t.transform.rotation.w = state.attitude[3]
self.tf_broadcaster.sendTransform(t)
def rotor_callback(self, ros_msg: Float64, rotor_id):
# Update the reference for the rotor of the vehicle
self.input_ref[rotor_id] = float(ros_msg.data)
def update_sensor(self, sensor_type: str, data):
"""
Method that when implemented, should handle the receival of sensor data
"""
if sensor_type == "IMU":
self.update_imu_data(data)
elif sensor_type == "GPS":
self.update_gps_data(data)
elif sensor_type == "Magnetometer":
self.update_mag_data(data)
else:
pass
def update_imu_data(self, data):
msg = Imu()
# Update the header
msg.header.stamp = self.node.get_clock().now().to_msg()
msg.header.frame_id = self._namespace + '_' + "base_link_frd"
# Update the angular velocity (NED + FRD)
msg.angular_velocity.x = data["angular_velocity"][0]
msg.angular_velocity.y = data["angular_velocity"][1]
msg.angular_velocity.z = data["angular_velocity"][2]
# Update the linear acceleration (NED)
msg.linear_acceleration.x = data["linear_acceleration"][0]
msg.linear_acceleration.y = data["linear_acceleration"][1]
msg.linear_acceleration.z = data["linear_acceleration"][2]
# Publish the message with the current imu state
self.imu_pub.publish(msg)
def update_gps_data(self, data):
msg = NavSatFix()
msg_vel = TwistStamped()
# Update the headers
msg.header.stamp = self.node.get_clock().now().to_msg()
msg.header.frame_id = "map_ned"
msg_vel.header.stamp = msg.header.stamp
msg_vel.header.frame_id = msg.header.frame_id
# Update the status of the GPS
status_msg = NavSatStatus()
status_msg.status = 0 # unaugmented fix position
status_msg.service = 1 # GPS service
msg.status = status_msg
# Update the latitude, longitude and altitude
msg.latitude = data["latitude"]
msg.longitude = data["longitude"]
msg.altitude = data["altitude"]
# Update the velocity of the vehicle measured by the GPS in the inertial frame (NED)
msg_vel.twist.linear.x = data["velocity_north"]
msg_vel.twist.linear.y = data["velocity_east"]
msg_vel.twist.linear.z = data["velocity_down"]
# Publish the message with the current GPS state
self.gps_pub.publish(msg)
self.gps_vel_pub.publish(msg_vel)
def update_mag_data(self, data):
msg = MagneticField()
# Update the headers
msg.header.stamp = self.node.get_clock().now().to_msg()
msg.header.frame_id = "base_link_frd"
msg.magnetic_field.x = data["magnetic_field"][0]
msg.magnetic_field.y = data["magnetic_field"][1]
msg.magnetic_field.z = data["magnetic_field"][2]
# Publish the message with the current magnetic data
self.mag_pub.publish(msg)
def input_reference(self):
"""
Method that is used to return the latest target angular velocities to be applied to the vehicle
Returns:
A list with the target angular velocities for each individual rotor of the vehicle
"""
return self.input_ref
def update(self, dt: float):
"""
Method that when implemented, should be used to update the state of the backend and the information being sent/received
from the communication interface. This method will be called by the simulation on every physics step
"""
# In this case, do nothing as we are sending messages as soon as new data arrives from the sensors and state
# and updating the reference for the thrusters as soon as receiving from ROS2 topics
# Just poll for new ROS 2 messages in a non-blocking way
rclpy.spin_once(self.node, timeout_sec=0)
def start(self):
"""
Method that when implemented should handle the begining of the simulation of vehicle
"""
# Reset the reference for the thrusters
self.input_ref = [0.0 for i in range(self._num_rotors)]
def stop(self):
"""
Method that when implemented should handle the stopping of the simulation of vehicle
"""
# Reset the reference for the thrusters
self.input_ref = [0.0 for i in range(self._num_rotors)]
def reset(self):
"""
Method that when implemented, should handle the reset of the vehicle simulation to its original state
"""
# Reset the reference for the thrusters
self.input_ref = [0.0 for i in range(self._num_rotors)] |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/mavlink_backend.py | """
| File: mavlink_backend.py
| Author: Marcelo Jacinto ([email protected])
| Description: File that implements the Mavlink Backend for communication/control with/of the vehicle simulation
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
__all__ = ["MavlinkBackend", "MavlinkBackendConfig"]
import carb
import time
import numpy as np
from pymavlink import mavutil
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.backends.backend import Backend
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
from pegasus.simulator.logic.backends.tools.px4_launch_tool import PX4LaunchTool
class SensorSource:
""" The binary codes to signal which simulated data is being sent through mavlink
Atribute:
| ACCEL (int): mavlink binary code for the accelerometer (0b0000000000111 = 7)
| GYRO (int): mavlink binary code for the gyroscope (0b0000000111000 = 56)
| MAG (int): mavlink binary code for the magnetometer (0b0000111000000=448)
| BARO (int): mavlink binary code for the barometer (0b1101000000000=6656)
| DIFF_PRESS (int): mavlink binary code for the pressure sensor (0b0010000000000=1024)
"""
ACCEL: int = 7
GYRO: int = 56
MAG: int = 448
BARO: int = 6656
DIFF_PRESS: int = 1024
class SensorMsg:
"""
An auxiliary data class where we write all the sensor data that is going to be sent through mavlink
"""
def __init__(self):
# IMU Data
self.new_imu_data: bool = False
self.received_first_imu: bool = False
self.xacc: float = 0.0
self.yacc: float = 0.0
self.zacc: float = 0.0
self.xgyro: float = 0.0
self.ygyro: float = 0.0
self.zgyro: float = 0.0
# Baro Data
self.new_bar_data: bool = False
self.abs_pressure: float = 0.0
self.pressure_alt: float = 0.0
self.temperature: float = 0.0
# Magnetometer Data
self.new_mag_data: bool = False
self.xmag: float = 0.0
self.ymag: float = 0.0
self.zmag: float = 0.0
# Airspeed Data
self.new_press_data: bool = False
self.diff_pressure: float = 0.0
# GPS Data
self.new_gps_data: bool = False
self.fix_type: int = 0
self.latitude_deg: float = -999
self.longitude_deg: float = -999
self.altitude: float = -999
self.eph: float = 1.0
self.epv: float = 1.0
self.velocity: float = 0.0
self.velocity_north: float = 0.0
self.velocity_east: float = 0.0
self.velocity_down: float = 0.0
self.cog: float = 0.0
self.satellites_visible: int = 0
# Vision Pose
self.new_vision_data: bool = False
self.vision_x: float = 0.0
self.vision_y: float = 0.0
self.vision_z: float = 0.0
self.vision_roll: float = 0.0
self.vision_pitch: float = 0.0
self.vision_yaw: float = 0.0
self.vision_covariance = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
# Simulation State
self.new_sim_state: bool = False
self.sim_attitude = [1.0, 0.0, 0.0, 0.0] # [w, x, y, z]
self.sim_acceleration = [0.0, 0.0, 0.0] # [x,y,z body acceleration]
self.sim_angular_vel = [0.0, 0.0, 0.0] # [roll-rate, pitch-rate, yaw-rate] rad/s
self.sim_lat = 0.0 # [deg]
self.sim_lon = 0.0 # [deg]
self.sim_alt = 0.0 # [m]
self.sim_ind_airspeed = 0.0 # Indicated air speed
self.sim_true_airspeed = 0.0 # Indicated air speed
self.sim_velocity_inertial = [0.0, 0.0, 0.0] # North-east-down [m/s]
class ThrusterControl:
"""
An auxiliary data class that saves the thrusters command data received via mavlink and
scales them into individual angular velocities expressed in rad/s to apply to each rotor
"""
def __init__(
self,
num_rotors: int = 4,
input_offset=[0, 0, 0, 0],
input_scaling=[0, 0, 0, 0],
zero_position_armed=[100, 100, 100, 100],
):
"""Initialize the ThrusterControl object
Args:
num_rotors (int): The number of rotors that the actual system has 4.
input_offset (list): A list with the offsets to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0].
input_scaling (list): A list with the scaling to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0].
zero_position_armed (list): Another list of offsets to apply to the rotor values received via mavlink. Defaults to [100, 100, 100, 100].
"""
self.num_rotors: int = num_rotors
# Values to scale and offset the rotor control inputs received from PX4
assert len(input_offset) == self.num_rotors
self.input_offset = input_offset
assert len(input_scaling) == self.num_rotors
self.input_scaling = input_scaling
assert len(zero_position_armed) == self.num_rotors
self.zero_position_armed = zero_position_armed
# The actual speed references to apply to the vehicle rotor joints
self._input_reference = [0.0 for i in range(self.num_rotors)]
@property
def input_reference(self):
"""A list of floats with the angular velocities in rad/s
Returns:
list: A list of floats with the angular velocities to apply to each rotor, expressed in rad/s
"""
return self._input_reference
def update_input_reference(self, controls):
"""Takes a list with the thrust controls received via mavlink and scales them in order to generated
the equivalent angular velocities in rad/s
Args:
controls (list): A list of ints with thrust controls received via mavlink
"""
# Check if the number of controls received is correct
if len(controls) < self.num_rotors:
carb.log_warn("Did not receive enough inputs for all the rotors")
return
# Update the desired reference for every rotor (and saturate according to the min and max values)
for i in range(self.num_rotors):
# Compute the actual velocity reference to apply to each rotor
self._input_reference[i] = (controls[i] + self.input_offset[i]) * self.input_scaling[
i
] + self.zero_position_armed[i]
def zero_input_reference(self):
"""
When this method is called, the input_reference is updated such that every rotor is stopped
"""
self._input_reference = [0.0 for i in range(self.num_rotors)]
class MavlinkBackendConfig:
"""
An auxiliary data class used to store all the configurations for the mavlink communications.
"""
def __init__(self, config={}):
"""
Initialize the MavlinkBackendConfig class
Args:
config (dict): A Dictionary that contains all the parameters for configuring the Mavlink interface - it can be empty or only have some of the parameters used by this backend.
Examples:
The dictionary default parameters are
>>> {"vehicle_id": 0,
>>> "connection_type": "tcpin",
>>> "connection_ip": "localhost",
>>> "connection_baseport": 4560,
>>> "px4_autolaunch": True,
>>> "px4_dir": "PegasusInterface().px4_path",
>>> "px4_vehicle_model": "gazebo-classic_iris",
>>> "enable_lockstep": True,
>>> "num_rotors": 4,
>>> "input_offset": [0.0, 0.0, 0.0, 0.0],
>>> "input_scaling": [1000.0, 1000.0, 1000.0, 1000.0],
>>> "zero_position_armed": [100.0, 100.0, 100.0, 100.0],
>>> "update_rate": 250.0
>>> }
"""
# Configurations for the mavlink communication protocol (note: the vehicle id is sumed to the connection_baseport)
self.vehicle_id = config.get("vehicle_id", 0)
self.connection_type = config.get("connection_type", "tcpin")
self.connection_ip = config.get("connection_ip", "localhost")
self.connection_baseport = config.get("connection_baseport", 4560)
# Configure whether to launch px4 in the background automatically or not for every vehicle launched
self.px4_autolaunch: bool = config.get("px4_autolaunch", True)
self.px4_dir: str = config.get("px4_dir", PegasusInterface().px4_path)
self.px4_vehicle_model: str = config.get("px4_vehicle_model", "gazebo-classic_iris")
# Configurations to interpret the rotors control messages coming from mavlink
self.enable_lockstep: bool = config.get("enable_lockstep", True)
self.num_rotors: int = config.get("num_rotors", 4)
self.input_offset = config.get("input_offset", [0.0, 0.0, 0.0, 0.0])
self.input_scaling = config.get("input_scaling", [1000.0, 1000.0, 1000.0, 1000.0])
self.zero_position_armed = config.get("zero_position_armed", [100.0, 100.0, 100.0, 100.0])
# The update rate at which we will be sending data to mavlink (TODO - remove this from here in the future
# and infer directly from the function calls)
self.update_rate: float = config.get("update_rate", 250.0) # [Hz]
class MavlinkBackend(Backend):
""" The Mavlink Backend used to receive the vehicle's state and sensor data in order to send to PX4 through mavlink. It also
receives via mavlink the thruster commands to apply to each vehicle rotor.
"""
def __init__(self, config=MavlinkBackendConfig()):
"""Initialize the MavlinkBackend
Args:
config (MavlinkBackendConfig): The configuration class for the MavlinkBackend. Defaults to MavlinkBackendConfig().
"""
# Initialize the Backend object
super().__init__()
# Setup the desired mavlink connection port
# The connection will only be created once the simulation starts
self._vehicle_id = config.vehicle_id
self._connection = None
self._connection_port = (
config.connection_type
+ ":"
+ config.connection_ip
+ ":"
+ str(config.connection_baseport + config.vehicle_id)
)
# Check if we need to autolaunch px4 in the background or not
self.px4_autolaunch: bool = config.px4_autolaunch
self.px4_vehicle_model: str = config.px4_vehicle_model # only needed if px4_autolaunch == True
self.px4_tool: PX4LaunchTool = None
self.px4_dir: str = config.px4_dir
# Set the update rate used for sending the messages (TODO - remove this hardcoded value from here)
self._update_rate: float = config.update_rate
self._time_step: float = 1.0 / self._update_rate # s
self._is_running: bool = False
# Vehicle Sensor data to send through mavlink
self._sensor_data: SensorMsg = SensorMsg()
# Vehicle Rotor data received from mavlink
self._rotor_data: ThrusterControl = ThrusterControl(
config.num_rotors, config.input_offset, config.input_scaling, config.zero_position_armed
)
# Vehicle actuator control data
self._num_inputs: int = config.num_rotors
self._input_reference: np.ndarray = np.zeros((self._num_inputs,))
self._armed: bool = False
self._input_offset: np.ndarray = np.zeros((self._num_inputs,))
self._input_scaling: np.ndarray = np.zeros((self._num_inputs,))
# Select whether lockstep is enabled
self._enable_lockstep: bool = config.enable_lockstep
# Auxiliar variables to handle the lockstep between receiving sensor data and actuator control
self._received_first_actuator: bool = False
self._received_actuator: bool = False
# Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation
self._received_first_hearbeat: bool = False
self._last_heartbeat_sent_time = 0
# Auxiliar variables for setting the u_time when sending sensor data to px4
self._current_utime: int = 0
def update_sensor(self, sensor_type: str, data):
"""Method that is used as callback for the vehicle for every iteration that a sensor produces new data.
Only the IMU, GPS, Barometer and Magnetometer sensor data are stored to be sent through mavlink. Every other
sensor data that gets passed to this function is discarded.
Args:
sensor_type (str): A name that describes the type of sensor
data (dict): A dictionary that contains the data produced by the sensor
"""
if sensor_type == "IMU":
self.update_imu_data(data)
elif sensor_type == "GPS":
self.update_gps_data(data)
elif sensor_type == "Barometer":
self.update_bar_data(data)
elif sensor_type == "Magnetometer":
self.update_mag_data(data)
# If the data received is not from one of the above sensors, then this backend does
# not support that sensor and it will just ignore it
else:
pass
def update_imu_data(self, data):
"""Gets called by the 'update_sensor' method to update the current IMU data
Args:
data (dict): The data produced by an IMU sensor
"""
# Acelerometer data
self._sensor_data.xacc = data["linear_acceleration"][0]
self._sensor_data.yacc = data["linear_acceleration"][1]
self._sensor_data.zacc = data["linear_acceleration"][2]
# Gyro data
self._sensor_data.xgyro = data["angular_velocity"][0]
self._sensor_data.ygyro = data["angular_velocity"][1]
self._sensor_data.zgyro = data["angular_velocity"][2]
# Signal that we have new IMU data
self._sensor_data.new_imu_data = True
self._sensor_data.received_first_imu = True
def update_gps_data(self, data):
"""Gets called by the 'update_sensor' method to update the current GPS data
Args:
data (dict): The data produced by an GPS sensor
"""
# GPS data
self._sensor_data.fix_type = int(data["fix_type"])
self._sensor_data.latitude_deg = int(data["latitude"] * 10000000)
self._sensor_data.longitude_deg = int(data["longitude"] * 10000000)
self._sensor_data.altitude = int(data["altitude"] * 1000)
self._sensor_data.eph = int(data["eph"])
self._sensor_data.epv = int(data["epv"])
self._sensor_data.velocity = int(data["speed"] * 100)
self._sensor_data.velocity_north = int(data["velocity_north"] * 100)
self._sensor_data.velocity_east = int(data["velocity_east"] * 100)
self._sensor_data.velocity_down = int(data["velocity_down"] * 100)
self._sensor_data.cog = int(data["cog"] * 100)
self._sensor_data.satellites_visible = int(data["sattelites_visible"])
# Signal that we have new GPS data
self._sensor_data.new_gps_data = True
# Also update the groundtruth for the latitude and longitude
self._sensor_data.sim_lat = int(data["latitude_gt"] * 10000000)
self._sensor_data.sim_lon = int(data["longitude_gt"] * 10000000)
self._sensor_data.sim_alt = int(data["altitude_gt"] * 1000)
def update_bar_data(self, data):
"""Gets called by the 'update_sensor' method to update the current Barometer data
Args:
data (dict): The data produced by an Barometer sensor
"""
# Barometer data
self._sensor_data.temperature = data["temperature"]
self._sensor_data.abs_pressure = data["absolute_pressure"]
self._sensor_data.pressure_alt = data["pressure_altitude"]
# Signal that we have new Barometer data
self._sensor_data.new_bar_data = True
def update_mag_data(self, data):
"""Gets called by the 'update_sensor' method to update the current Vision data
Args:
data (dict): The data produced by an Vision sensor
"""
# Magnetometer data
self._sensor_data.xmag = data["magnetic_field"][0]
self._sensor_data.ymag = data["magnetic_field"][1]
self._sensor_data.zmag = data["magnetic_field"][2]
# Signal that we have new Magnetometer data
self._sensor_data.new_mag_data = True
def update_vision_data(self, data):
"""Method that 'in the future' will get called by the 'update_sensor' method to update the current Vision data
This callback is currently not being called (TODO in a future simulator version)
Args:
data (dict): The data produced by an Vision sensor
"""
# Vision or MOCAP data
self._sensor_data.vision_x = data["x"]
self._sensor_data.vision_y = data["y"]
self._sensor_data.vision_z = data["z"]
self._sensor_data.vision_roll = data["roll"]
self._sensor_data.vision_pitch = data["pitch"]
self._sensor_data.vision_yaw = data["yaw"]
# Signal that we have new vision or mocap data
self._sensor_data.new_vision_data = True
def update_state(self, state: State):
"""Method that is used as callback and gets called at every physics step with the current state of the vehicle.
This state is then stored in order to be sent as groundtruth via mavlink
Args:
state (State): The current state of the vehicle.
"""
# Get the quaternion in the convention [x, y, z, w]
attitude = state.get_attitude_ned_frd()
# Rotate the quaternion to the mavlink standard
self._sensor_data.sim_attitude[0] = attitude[3]
self._sensor_data.sim_attitude[1] = attitude[0]
self._sensor_data.sim_attitude[2] = attitude[1]
self._sensor_data.sim_attitude[3] = attitude[2]
# Get the angular velocity
ang_vel = state.get_angular_velocity_frd()
self._sensor_data.sim_angular_vel[0] = ang_vel[0]
self._sensor_data.sim_angular_vel[1] = ang_vel[1]
self._sensor_data.sim_angular_vel[2] = ang_vel[2]
# Get the acceleration
acc_vel = state.get_linear_acceleration_ned()
self._sensor_data.sim_acceleration[0] = int(acc_vel[0] * 1000)
self._sensor_data.sim_acceleration[1] = int(acc_vel[1] * 1000)
self._sensor_data.sim_acceleration[2] = int(acc_vel[2] * 1000)
# Get the latitude, longitude and altitude directly from the GPS
# Get the linear velocity of the vehicle in the inertial frame
lin_vel = state.get_linear_velocity_ned()
self._sensor_data.sim_velocity_inertial[0] = int(lin_vel[0] * 100)
self._sensor_data.sim_velocity_inertial[1] = int(lin_vel[1] * 100)
self._sensor_data.sim_velocity_inertial[2] = int(lin_vel[2] * 100)
# Compute the air_speed - assumed indicated airspeed due to flow aligned with pitot (body x)
body_vel = state.get_linear_body_velocity_ned_frd()
self._sensor_data.sim_ind_airspeed = int(body_vel[0] * 100)
self._sensor_data.sim_true_airspeed = int(np.linalg.norm(lin_vel) * 100) # TODO - add wind here
self._sensor_data.new_sim_state = True
def input_reference(self):
"""Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors
"""
return self._rotor_data.input_reference
def __del__(self):
"""Gets called when the MavlinkBackend object gets destroyed. When this happens, we make sure
to close any mavlink connection open for this vehicle.
"""
# When this object gets destroyed, close the mavlink connection to free the communication port
try:
self._connection.close()
self._connection = None
except:
carb.log_info("Mavlink connection was not closed, because it was never opened")
def start(self):
"""Method that handles the begining of the simulation of vehicle. It will try to open the mavlink connection
interface and also attemp to launch px4 in a background process if that option as specified in the config class
"""
# If we are already running the mavlink interface, then ignore the function call
if self._is_running == True:
return
# If the connection no longer exists (we stoped and re-started the stream, then re_intialize the interface)
if self._connection is None:
self.re_initialize_interface()
# Set the flag to signal that the mavlink transmission has started
self._is_running = True
# Launch the PX4 in the background if needed
if self.px4_autolaunch and self.px4_tool is None:
carb.log_info("Attempting to launch PX4 in background process")
self.px4_tool = PX4LaunchTool(self.px4_dir, self._vehicle_id, self.px4_vehicle_model)
self.px4_tool.launch_px4()
def stop(self):
"""Method that when called will handle the stopping of the simulation of vehicle. It will make sure that any open
mavlink connection will be closed and also that the PX4 background process gets killed (if it was auto-initialized)
"""
# If the simulation was already stoped, then ignore the function call
if self._is_running == False:
return
# Set the flag so that we are no longer running the mavlink interface
self._is_running = False
# Close the mavlink connection
self._connection.close()
self._connection = None
# Close the PX4 if it was running
if self.px4_autolaunch and self.px4_autolaunch is not None:
carb.log_info("Attempting to kill PX4 background process")
self.px4_tool.kill_px4()
self.px4_tool = None
def reset(self):
"""For now does nothing. Here for compatibility purposes only
"""
return
def re_initialize_interface(self):
"""Auxiliar method used to get the MavlinkInterface to reset the MavlinkInterface to its initial state
"""
self._is_running = False
# Restart the sensor data
self._sensor_data = SensorMsg()
# Restart the connection
self._connection = mavutil.mavlink_connection(self._connection_port)
# Auxiliar variables to handle the lockstep between receiving sensor data and actuator control
self._received_first_actuator: bool = False
self._received_actuator: bool = False
# Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation
self._received_first_hearbeat: bool = False
self._last_heartbeat_sent_time = 0
def wait_for_first_hearbeat(self):
"""
Responsible for waiting for the first hearbeat. This method is locking and will only return
if an hearbeat is received via mavlink. When this first heartbeat is received poll for mavlink messages
"""
carb.log_warn("Waiting for first hearbeat")
result = self._connection.wait_heartbeat(blocking=False)
if result is not None:
self._received_first_hearbeat = True
carb.log_warn("Received first hearbeat")
def update(self, dt):
"""
Method that is called at every physics step to send data to px4 and receive the control inputs via mavlink
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
# Check for the first hearbeat on the first few iterations
if not self._received_first_hearbeat:
self.wait_for_first_hearbeat()
return
# Check if we have already received IMU data. If not, start the lockstep and wait for more data
if self._sensor_data.received_first_imu:
while not self._sensor_data.new_imu_data and self._is_running:
# Just go for the next update and then try to check if we have new simulated sensor data
# DO not continue and get mavlink thrusters commands until we have simulated IMU data available
return
# Check if we have received any mavlink messages
self.poll_mavlink_messages()
# Send hearbeats at 1Hz
if (time.time() - self._last_heartbeat_sent_time) > 1.0 or self._received_first_hearbeat == False:
self.send_heartbeat()
self._last_heartbeat_sent_time = time.time()
# Update the current u_time for px4
self._current_utime += int(dt * 1000000)
# Send sensor messages
self.send_sensor_msgs(self._current_utime)
# Send the GPS messages
self.send_gps_msgs(self._current_utime)
def poll_mavlink_messages(self):
"""
Method that is used to check if new mavlink messages were received
"""
# If we have not received the first hearbeat yet, do not poll for mavlink messages
if self._received_first_hearbeat == False:
return
# Check if we need to lock and wait for actuator control data
needs_to_wait_for_actuator: bool = self._received_first_actuator and self._enable_lockstep
# Start by assuming that we have not received data for the actuators for the current step
self._received_actuator = False
# Use this loop to emulate a do-while loop (make sure this runs at least once)
while True:
# Try to get a message
msg = self._connection.recv_match(blocking=needs_to_wait_for_actuator)
# If a message was received
if msg is not None:
# Check if it is of the type that contains actuator controls
if msg.id == mavutil.mavlink.MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS:
self._received_first_actuator = True
self._received_actuator = True
# Handle the control of the actuation commands received by PX4
self.handle_control(msg.time_usec, msg.controls, msg.mode, msg.flags)
# Check if we do not need to wait for an actuator message or we just received actuator input
# If so, break out of the infinite loop
if not needs_to_wait_for_actuator or self._received_actuator:
break
def send_heartbeat(self, mav_type=mavutil.mavlink.MAV_TYPE_GENERIC):
"""
Method that is used to publish an heartbear through mavlink protocol
Args:
mav_type (int): The ID that indicates the type of vehicle. Defaults to MAV_TYPE_GENERIC=0
"""
carb.log_info("Sending heartbeat")
# Note: to know more about these functions, go to pymavlink->dialects->v20->standard.py
# This contains the definitions for sending the hearbeat and simulated sensor messages
self._connection.mav.heartbeat_send(mav_type, mavutil.mavlink.MAV_AUTOPILOT_INVALID, 0, 0, 0)
def send_sensor_msgs(self, time_usec: int):
"""
Method that when invoked, will send the simulated sensor data through mavlink
Args:
time_usec (int): The total time elapsed since the simulation started
"""
carb.log_info("Sending sensor msgs")
# Check which sensors have new data to send
fields_updated: int = 0
if self._sensor_data.new_imu_data:
# Set the bit field to signal that we are sending updated accelerometer and gyro data
fields_updated = fields_updated | SensorSource.ACCEL | SensorSource.GYRO
self._sensor_data.new_imu_data = False
if self._sensor_data.new_mag_data:
# Set the bit field to signal that we are sending updated magnetometer data
fields_updated = fields_updated | SensorSource.MAG
self._sensor_data.new_mag_data = False
if self._sensor_data.new_bar_data:
# Set the bit field to signal that we are sending updated barometer data
fields_updated = fields_updated | SensorSource.BARO
self._sensor_data.new_bar_data = False
if self._sensor_data.new_press_data:
# Set the bit field to signal that we are sending updated diff pressure data
fields_updated = fields_updated | SensorSource.DIFF_PRESS
self._sensor_data.new_press_data = False
try:
self._connection.mav.hil_sensor_send(
time_usec,
self._sensor_data.xacc,
self._sensor_data.yacc,
self._sensor_data.zacc,
self._sensor_data.xgyro,
self._sensor_data.ygyro,
self._sensor_data.zgyro,
self._sensor_data.xmag,
self._sensor_data.ymag,
self._sensor_data.zmag,
self._sensor_data.abs_pressure,
self._sensor_data.diff_pressure,
self._sensor_data.pressure_alt,
self._sensor_data.altitude,
fields_updated,
)
except:
carb.log_warn("Could not send sensor data through mavlink")
def send_gps_msgs(self, time_usec: int):
"""
Method that is used to send simulated GPS data through the mavlink protocol.
Args:
time_usec (int): The total time elapsed since the simulation started
"""
carb.log_info("Sending GPS msgs")
# Do not send GPS data, if no new data was received
if not self._sensor_data.new_gps_data:
return
self._sensor_data.new_gps_data = False
# Latitude, longitude and altitude (all in integers)
try:
self._connection.mav.hil_gps_send(
time_usec,
self._sensor_data.fix_type,
self._sensor_data.latitude_deg,
self._sensor_data.longitude_deg,
self._sensor_data.altitude,
self._sensor_data.eph,
self._sensor_data.epv,
self._sensor_data.velocity,
self._sensor_data.velocity_north,
self._sensor_data.velocity_east,
self._sensor_data.velocity_down,
self._sensor_data.cog,
self._sensor_data.satellites_visible,
)
except:
carb.log_warn("Could not send gps data through mavlink")
def send_vision_msgs(self, time_usec: int):
"""
Method that is used to send simulated vision/mocap data through the mavlink protocol.
Args:
time_usec (int): The total time elapsed since the simulation started
"""
carb.log_info("Sending vision/mocap msgs")
# Do not send vision/mocap data, if not new data was received
if not self._sensor_data.new_vision_data:
return
self._sensor_data.new_vision_data = False
try:
self._connection.mav.global_vision_position_estimate_send(
time_usec,
self._sensor_data.vision_x,
self._sensor_data.vision_y,
self._sensor_data.vision_z,
self._sensor_data.vision_roll,
self._sensor_data.vision_pitch,
self._sensor_data.vision_yaw,
self._sensor_data.vision_covariance,
)
except:
carb.log_warn("Could not send vision/mocap data through mavlink")
def send_ground_truth(self, time_usec: int):
"""
Method that is used to send the groundtruth data of the vehicle through mavlink
Args:
time_usec (int): The total time elapsed since the simulation started
"""
carb.log_info("Sending groundtruth msgs")
# Do not send vision/mocap data, if not new data was received
if not self._sensor_data.new_sim_state or self._sensor_data.sim_alt == 0:
return
self._sensor_data.new_sim_state = False
try:
self._connection.mav.hil_state_quaternion_send(
time_usec,
self._sensor_data.sim_attitude,
self._sensor_data.sim_angular_vel[0],
self._sensor_data.sim_angular_vel[1],
self._sensor_data.sim_angular_vel[2],
self._sensor_data.sim_lat,
self._sensor_data.sim_lon,
self._sensor_data.sim_alt,
self._sensor_data.sim_velocity_inertial[0],
self._sensor_data.sim_velocity_inertial[1],
self._sensor_data.sim_velocity_inertial[2],
self._sensor_data.sim_ind_airspeed,
self._sensor_data.sim_true_airspeed,
self._sensor_data.sim_acceleration[0],
self._sensor_data.sim_acceleration[1],
self._sensor_data.sim_acceleration[2],
)
except:
carb.log_warn("Could not send groundtruth through mavlink")
def handle_control(self, time_usec, controls, mode, flags):
"""
Method that when received a control message, compute the forces simulated force that should be applied
on each rotor of the vehicle
Args:
time_usec (int): The total time elapsed since the simulation started - Ignored argument
controls (list): A list of ints which contains the thrust_control received via mavlink
flags: Ignored argument
"""
# Check if the vehicle is armed - Note: here we have to add a +1 since the code for armed is 128, but
# pymavlink is return 129 (the end of the buffer)
if mode == mavutil.mavlink.MAV_MODE_FLAG_SAFETY_ARMED + 1:
carb.log_info("Parsing control input")
# Set the rotor target speeds
self._rotor_data.update_input_reference(controls)
# If the vehicle is not armed, do not rotate the propellers
else:
self._rotor_data.zero_input_reference()
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/tools/px4_launch_tool.py | """
| File: px4_launch_tool.py
| Author: Marcelo Jacinto ([email protected])
| Description: Defines an auxiliary tool to launch the PX4 process in the background
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
# System tools used to launch the px4 process in the brackground
import os
import tempfile
import subprocess
class PX4LaunchTool:
"""
A class that manages the start/stop of a px4 process. It requires only the path to the PX4 installation (assuming that
PX4 was already built with 'make px4_sitl_default none'), the vehicle id and the vehicle model.
"""
def __init__(self, px4_dir, vehicle_id: int = 0, px4_model: str = "gazebo-classic_iris"):
"""Construct the PX4LaunchTool object
Args:
px4_dir (str): A string with the path to the PX4-Autopilot directory
vehicle_id (int): The ID of the vehicle. Defaults to 0.
px4_model (str): The vehicle model. Defaults to "iris".
"""
# Attribute that will hold the px4 process once it is running
self.px4_process = None
# The vehicle id (used for the mavlink port open in the system)
self.vehicle_id = vehicle_id
# Configurations to whether autostart px4 (SITL) automatically or have the user launch it manually on another
# terminal
self.px4_dir = px4_dir
self.rc_script = self.px4_dir + "/ROMFS/px4fmu_common/init.d-posix/rcS"
# Create a temporary filesystem for px4 to write data to/from (and modify the origin rcS files)
self.root_fs = tempfile.TemporaryDirectory()
# Set the environement variables that let PX4 know which vehicle model to use internally
self.environment = os.environ
self.environment["PX4_SIM_MODEL"] = px4_model
def launch_px4(self):
"""
Method that will launch a px4 instance with the specified configuration
"""
self.px4_process = subprocess.Popen(
[
self.px4_dir + "/build/px4_sitl_default/bin/px4",
self.px4_dir + "/ROMFS/px4fmu_common/",
"-s",
self.rc_script,
"-i",
str(self.vehicle_id),
"-d",
],
cwd=self.root_fs.name,
shell=False,
env=self.environment,
)
def kill_px4(self):
"""
Method that will kill a px4 instance with the specified configuration
"""
if self.px4_process is not None:
self.px4_process.kill()
self.px4_process = None
def __del__(self):
"""
If the px4 process is still running when the PX4 launch tool object is whiped from memory, then make sure
we kill the px4 instance so we don't end up with hanged px4 instances
"""
# Make sure the PX4 process gets killed
if self.px4_process:
self.kill_px4()
# Make sure we clean the temporary filesystem used for the simulation
self.root_fs.cleanup()
# ---- Code used for debugging the px4 tool ----
def main():
px4_tool = PX4LaunchTool(os.environ["HOME"] + "/PX4-Autopilot")
px4_tool.launch_px4()
import time
time.sleep(60)
if __name__ == "__main__":
main()
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/vehicle.py | """
| File: vehicle.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Definition of the Vehicle class which is used as the base for all the vehicles.
"""
# Numerical computations
import numpy as np
from scipy.spatial.transform import Rotation
# Low level APIs
import carb
from pxr import Usd, Gf
# High level Isaac sim APIs
import omni.usd
from omni.isaac.core.world import World
from omni.isaac.core.utils.prims import define_prim, get_prim_at_path
from omni.usd import get_stage_next_free_path
from omni.isaac.core.robots.robot import Robot
# Extension APIs
from pegasus.simulator.logic.state import State
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
from pegasus.simulator.logic.vehicle_manager import VehicleManager
def get_world_transform_xform(prim: Usd.Prim):
"""
Get the local transformation of a prim using omni.usd.get_world_transform_matrix().
See https://docs.omniverse.nvidia.com/kit/docs/omni.usd/latest/omni.usd/omni.usd.get_world_transform_matrix.html
Args:
prim (Usd.Prim): The prim to calculate the world transformation.
Returns:
A tuple of:
- Translation vector.
- Rotation quaternion, i.e. 3d vector plus angle.
- Scale vector.
"""
world_transform: Gf.Matrix4d = omni.usd.get_world_transform_matrix(prim)
rotation: Gf.Rotation = world_transform.ExtractRotation()
return rotation
class Vehicle(Robot):
def __init__(
self,
stage_prefix: str,
usd_path: str = None,
init_pos=[0.0, 0.0, 0.0],
init_orientation=[0.0, 0.0, 0.0, 1.0],
):
"""
Class that initializes a vehicle in the isaac sim's curent stage
Args:
stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to "quadrotor".
usd_path (str): The USD file that describes the looks and shape of the vehicle. Defaults to "".
init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.0].
init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0].
"""
# Get the current world at which we want to spawn the vehicle
self._world = PegasusInterface().world
self._current_stage = self._world.stage
# Save the name with which the vehicle will appear in the stage
# and the name of the .usd file that contains its description
self._stage_prefix = get_stage_next_free_path(self._current_stage, stage_prefix, False)
self._usd_file = usd_path
# Get the vehicle name by taking the last part of vehicle stage prefix
self._vehicle_name = self._stage_prefix.rpartition("/")[-1]
# Spawn the vehicle primitive in the world's stage
self._prim = define_prim(self._stage_prefix, "Xform")
self._prim = get_prim_at_path(self._stage_prefix)
self._prim.GetReferences().AddReference(self._usd_file)
# Initialize the "Robot" class
# Note: we need to change the rotation to have qw first, because NVidia
# does not keep a standard of quaternions inside its own libraries (not good, but okay)
super().__init__(
prim_path=self._stage_prefix,
name=self._stage_prefix,
position=init_pos,
orientation=[init_orientation[3], init_orientation[0], init_orientation[1], init_orientation[2]],
articulation_controller=None,
)
# Add this object for the world to track, so that if we clear the world, this object is deleted from memory and
# as a consequence, from the VehicleManager as well
self._world.scene.add(self)
# Add the current vehicle to the vehicle manager, so that it knows
# that a vehicle was instantiated
VehicleManager.get_vehicle_manager().add_vehicle(self._stage_prefix, self)
# Variable that will hold the current state of the vehicle
self._state = State()
# Motor that is given as reference
self._motor_speed = []
# Add a callback to the physics engine to update the current state of the system
self._world.add_physics_callback(self._stage_prefix + "/state", self.update_state)
# Add the update method to the physics callback if the world was received
# so that we can apply forces and torques to the vehicle. Note, this method should
# be implemented in classes that inherit the vehicle object
self._world.add_physics_callback(self._stage_prefix + "/update", self.update)
# Set the flag that signals if the simulation is running or not
self._sim_running = False
# Add a callback to start/stop of the simulation once the play/stop button is hit
self._world.add_timeline_callback(self._stage_prefix + "/start_stop_sim", self.sim_start_stop)
def __del__(self):
"""
Method that is invoked when a vehicle object gets destroyed. When this happens, we also invoke the
'remove_vehicle' from the VehicleManager in order to remove the vehicle from the list of active vehicles.
"""
# Remove this object from the vehicleHandler
VehicleManager.get_vehicle_manager().remove_vehicle(self._stage_prefix)
"""
Properties
"""
@property
def state(self):
"""The state of the vehicle.
Returns:
State: The current state of the vehicle, i.e., position, orientation, linear and angular velocities...
"""
return self._state
@property
def vehicle_name(self) -> str:
"""Vehicle name.
Returns:
Vehicle name (str): last prim name in vehicle prim path
"""
return self._vehicle_name
"""
Operations
"""
def sim_start_stop(self, event):
"""
Callback that is called every time there is a timeline event such as starting/stoping the simulation.
Args:
event: A timeline event generated from Isaac Sim, such as starting or stoping the simulation.
"""
# If the start/stop button was pressed, then call the start and stop methods accordingly
if self._world.is_playing() and self._sim_running == False:
self._sim_running = True
self.start()
if self._world.is_stopped() and self._sim_running == True:
self._sim_running = False
self.stop()
def apply_force(self, force, pos=[0.0, 0.0, 0.0], body_part="/body"):
"""
Method that will apply a force on the rigidbody, on the part specified in the 'body_part' at its relative position
given by 'pos' (following a FLU) convention.
Args:
force (list): A 3-dimensional vector of floats with the force [Fx, Fy, Fz] on the body axis of the vehicle according to a FLU convention.
pos (list): _description_. Defaults to [0.0, 0.0, 0.0].
body_part (str): . Defaults to "/body".
"""
# Get the handle of the rigidbody that we will apply the force to
rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part)
# Apply the force to the rigidbody. The force should be expressed in the rigidbody frame
self._world.dc_interface.apply_body_force(rb, carb._carb.Float3(force), carb._carb.Float3(pos), False)
def apply_torque(self, torque, body_part="/body"):
"""
Method that when invoked applies a given torque vector to /<rigid_body_name>/"body" or to /<rigid_body_name>/<body_part>.
Args:
torque (list): A 3-dimensional vector of floats with the force [Tx, Ty, Tz] on the body axis of the vehicle according to a FLU convention.
body_part (str): . Defaults to "/body".
"""
# Get the handle of the rigidbody that we will apply a torque to
rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part)
# Apply the torque to the rigidbody. The torque should be expressed in the rigidbody frame
self._world.dc_interface.apply_body_torque(rb, carb._carb.Float3(torque), False)
def update_state(self, dt: float):
"""
Method that is called at every physics step to retrieve and update the current state of the vehicle, i.e., get
the current position, orientation, linear and angular velocities and acceleration of the vehicle.
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
# Get the body frame interface of the vehicle (this will be the frame used to get the position, orientation, etc.)
body = self._world.dc_interface.get_rigid_body(self._stage_prefix + "/body")
# Get the current position and orientation in the inertial frame
pose = self._world.dc_interface.get_rigid_body_pose(body)
# Get the attitude according to the convention [w, x, y, z]
prim = self._world.stage.GetPrimAtPath(self._stage_prefix + "/body")
rotation_quat = get_world_transform_xform(prim).GetQuaternion()
rotation_quat_real = rotation_quat.GetReal()
rotation_quat_img = rotation_quat.GetImaginary()
# Get the angular velocity of the vehicle expressed in the body frame of reference
ang_vel = self._world.dc_interface.get_rigid_body_angular_velocity(body)
# The linear velocity [x_dot, y_dot, z_dot] of the vehicle's body frame expressed in the inertial frame of reference
linear_vel = self._world.dc_interface.get_rigid_body_linear_velocity(body)
# Get the linear acceleration of the body relative to the inertial frame, expressed in the inertial frame
# Note: we must do this approximation, since the Isaac sim does not output the acceleration of the rigid body directly
linear_acceleration = (np.array(linear_vel) - self._state.linear_velocity) / dt
# Update the state variable X = [x,y,z]
self._state.position = np.array(pose.p)
# Get the quaternion according in the [qx,qy,qz,qw] standard
self._state.attitude = np.array(
[rotation_quat_img[0], rotation_quat_img[1], rotation_quat_img[2], rotation_quat_real]
)
# Express the velocity of the vehicle in the inertial frame X_dot = [x_dot, y_dot, z_dot]
self._state.linear_velocity = np.array(linear_vel)
# The linear velocity V =[u,v,w] of the vehicle's body frame expressed in the body frame of reference
# Note that: x_dot = Rot * V
self._state.linear_body_velocity = (
Rotation.from_quat(self._state.attitude).inv().apply(self._state.linear_velocity)
)
# omega = [p,q,r]
self._state.angular_velocity = Rotation.from_quat(self._state.attitude).inv().apply(np.array(ang_vel))
# The acceleration of the vehicle expressed in the inertial frame X_ddot = [x_ddot, y_ddot, z_ddot]
self._state.linear_acceleration = linear_acceleration
def start(self):
"""
Method that should be implemented by the class that inherits the vehicle object.
"""
pass
def stop(self):
"""
Method that should be implemented by the class that inherits the vehicle object.
"""
pass
def update(self, dt: float):
"""
Method that computes and applies the forces to the vehicle in
simulation based on the motor speed. This method must be implemented
by a class that inherits this type and it's called periodically by the physics engine.
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
pass
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotor.py | """
| File: multirotor.py
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
| Description: Definition of the Multirotor class which is used as the base for all the multirotor vehicles.
"""
import numpy as np
# The vehicle interface
from pegasus.simulator.logic.vehicles.vehicle import Vehicle
# Mavlink interface
from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend
# Sensors and dynamics setup
from pegasus.simulator.logic.dynamics import LinearDrag
from pegasus.simulator.logic.thrusters import QuadraticThrustCurve
from pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
class MultirotorConfig:
"""
A data class that is used for configuring a Multirotor
"""
def __init__(self):
"""
Initialization of the MultirotorConfig class
"""
# Stage prefix of the vehicle when spawning in the world
self.stage_prefix = "quadrotor"
# The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia)
self.usd_file = ""
# The default thrust curve for a quadrotor and dynamics relating to drag
self.thrust_curve = QuadraticThrustCurve()
self.drag = LinearDrag([0.50, 0.30, 0.0])
# The default sensors for a quadrotor
self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()]
# The default graphs
self.graphs = []
# The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations)
# [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend
# or your own custom Backend implementation!
self.backends = [MavlinkBackend()]
class Multirotor(Vehicle):
"""Multirotor class - It defines a base interface for creating a multirotor
"""
def __init__(
self,
# Simulation specific configurations
stage_prefix: str = "quadrotor",
usd_file: str = "",
vehicle_id: int = 0,
# Spawning pose of the vehicle
init_pos=[0.0, 0.0, 0.07],
init_orientation=[0.0, 0.0, 0.0, 1.0],
config=MultirotorConfig(),
):
"""Initializes the multirotor object
Args:
stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to "quadrotor".
usd_file (str): The USD file that describes the looks and shape of the vehicle. Defaults to "".
vehicle_id (int): The id to be used for the vehicle. Defaults to 0.
init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.07].
init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0].
config (_type_, optional): _description_. Defaults to MultirotorConfig().
"""
# 1. Initiate the Vehicle object itself
super().__init__(stage_prefix, usd_file, init_pos, init_orientation)
# 2. Initialize all the vehicle sensors
self._sensors = config.sensors
for sensor in self._sensors:
sensor.initialize(PegasusInterface().latitude, PegasusInterface().longitude, PegasusInterface().altitude)
# Add callbacks to the physics engine to update each sensor at every timestep
# and let the sensor decide depending on its internal update rate whether to generate new data
self._world.add_physics_callback(self._stage_prefix + "/Sensors", self.update_sensors)
# 3. Initialize all the vehicle graphs
self._graphs = config.graphs
for graph in self._graphs:
graph.initialize(self)
# 4. Setup the dynamics of the system
# Get the thrust curve of the vehicle from the configuration
self._thrusters = config.thrust_curve
self._drag = config.drag
# 5. Save the backend interface (if given in the configuration of the multirotor)
# and initialize them
self._backends = config.backends
for backend in self._backends:
backend.initialize(self)
# Add a callbacks for the
self._world.add_physics_callback(self._stage_prefix + "/mav_state", self.update_sim_state)
def update_sensors(self, dt: float):
"""Callback that is called at every physics steps and will call the sensor.update method to generate new
sensor data. For each data that the sensor generates, the backend.update_sensor method will also be called for
every backend. For example, if new data is generated for an IMU and we have a MavlinkBackend, then the update_sensor
method will be called for that backend so that this data can latter be sent thorugh mavlink.
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
# Call the update method for the sensor to update its values internally (if applicable)
for sensor in self._sensors:
sensor_data = sensor.update(self._state, dt)
# If some data was updated and we have a mavlink backend or ros backend (or other), then just update it
if sensor_data is not None:
for backend in self._backends:
backend.update_sensor(sensor.sensor_type, sensor_data)
def update_sim_state(self, dt: float):
"""
Callback that is used to "send" the current state for each backend being used to control the vehicle. This callback
is called on every physics step.
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
for backend in self._backends:
backend.update_state(self._state)
def start(self):
"""
Intializes the communication with all the backends. This method is invoked automatically when the simulation starts
"""
for backend in self._backends:
backend.start()
def stop(self):
"""
Signal all the backends that the simulation has stoped. This method is invoked automatically when the simulation stops
"""
for backend in self._backends:
backend.stop()
def update(self, dt: float):
"""
Method that computes and applies the forces to the vehicle in simulation based on the motor speed.
This method must be implemented by a class that inherits this type. This callback
is called on every physics step.
Args:
dt (float): The time elapsed between the previous and current function calls (s).
"""
# Get the articulation root of the vehicle
articulation = self._world.dc_interface.get_articulation(self._stage_prefix)
# Get the desired angular velocities for each rotor from the first backend (can be mavlink or other) expressed in rad/s
if len(self._backends) != 0:
desired_rotor_velocities = self._backends[0].input_reference()
else:
desired_rotor_velocities = [0.0 for i in range(self._thrusters._num_rotors)]
# Input the desired rotor velocities in the thruster model
self._thrusters.set_input_reference(desired_rotor_velocities)
# Get the desired forces to apply to the vehicle
forces_z, _, rolling_moment = self._thrusters.update(self._state, dt)
# Apply force to each rotor
for i in range(4):
# Apply the force in Z on the rotor frame
self.apply_force([0.0, 0.0, forces_z[i]], body_part="/rotor" + str(i))
# Generate the rotating propeller visual effect
self.handle_propeller_visual(i, forces_z[i], articulation)
# Apply the torque to the body frame of the vehicle that corresponds to the rolling moment
self.apply_torque([0.0, 0.0, rolling_moment], "/body")
# Compute the total linear drag force to apply to the vehicle's body frame
drag = self._drag.update(self._state, dt)
self.apply_force(drag, body_part="/body")
# Call the update methods in all backends
for backend in self._backends:
backend.update(dt)
def handle_propeller_visual(self, rotor_number, force: float, articulation):
"""
Auxiliar method used to set the joint velocity of each rotor (for animation purposes) based on the
amount of force being applied on each joint
Args:
rotor_number (int): The number of the rotor to generate the rotation animation
force (float): The force that is being applied on that rotor
articulation (_type_): The articulation group the joints of the rotors belong to
"""
# Rotate the joint to yield the visual of a rotor spinning (for animation purposes only)
joint = self._world.dc_interface.find_articulation_dof(articulation, "joint" + str(rotor_number))
# Spinning when armed but not applying force
if 0.0 < force < 0.1:
self._world.dc_interface.set_dof_velocity(joint, 5 * self._thrusters.rot_dir[rotor_number])
# Spinning when armed and applying force
elif 0.1 <= force:
self._world.dc_interface.set_dof_velocity(joint, 100 * self._thrusters.rot_dir[rotor_number])
# Not spinning
else:
self._world.dc_interface.set_dof_velocity(joint, 0)
def force_and_torques_to_velocities(self, force: float, torque: np.ndarray):
"""
Auxiliar method used to get the target angular velocities for each rotor, given the total desired thrust [N] and
torque [Nm] to be applied in the multirotor's body frame.
Note: This method assumes a quadratic thrust curve. This method will be improved in a future update,
and a general thrust allocation scheme will be adopted. For now, it is made to work with multirotors directly.
Args:
force (np.ndarray): A vector of the force to be applied in the body frame of the vehicle [N]
torque (np.ndarray): A vector of the torque to be applied in the body frame of the vehicle [Nm]
Returns:
list: A list of angular velocities [rad/s] to apply in reach rotor to accomplish suchs forces and torques
"""
# Get the body frame of the vehicle
rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + "/body")
# Get the rotors of the vehicle
rotors = [self._world.dc_interface.get_rigid_body(self._stage_prefix + "/rotor" + str(i)) for i in range(self._thrusters._num_rotors)]
# Get the relative position of the rotors with respect to the body frame of the vehicle (ignoring the orientation for now)
relative_poses = self._world.dc_interface.get_relative_body_poses(rb, rotors)
# Define the alocation matrix
aloc_matrix = np.zeros((4, self._thrusters._num_rotors))
# Define the first line of the matrix (T [N])
aloc_matrix[0, :] = np.array(self._thrusters._rotor_constant)
# Define the second and third lines of the matrix (\tau_x [Nm] and \tau_y [Nm])
aloc_matrix[1, :] = np.array([relative_poses[i].p[1] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)])
aloc_matrix[2, :] = np.array([-relative_poses[i].p[0] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)])
# Define the forth line of the matrix (\tau_z [Nm])
aloc_matrix[3, :] = np.array([self._thrusters._rolling_moment_coefficient[i] * self._thrusters._rot_dir[i] for i in range(self._thrusters._num_rotors)])
# Compute the inverse allocation matrix, so that we can get the angular velocities (squared) from the total thrust and torques
aloc_inv = np.linalg.pinv(aloc_matrix)
# Compute the target angular velocities (squared)
squared_ang_vel = aloc_inv @ np.array([force, torque[0], torque[1], torque[2]])
# Making sure that there is no negative value on the target squared angular velocities
squared_ang_vel[squared_ang_vel < 0] = 0.0
# ------------------------------------------------------------------------------------------------
# Saturate the inputs while preserving their relation to each other, by performing a normalization
# ------------------------------------------------------------------------------------------------
max_thrust_vel_squared = np.power(self._thrusters.max_rotor_velocity[0], 2)
max_val = np.max(squared_ang_vel)
if max_val >= max_thrust_vel_squared:
normalize = np.maximum(max_val / max_thrust_vel_squared, 1.0)
squared_ang_vel = squared_ang_vel / normalize
# Compute the angular velocities for each rotor in [rad/s]
ang_vel = np.sqrt(squared_ang_vel)
return ang_vel
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .vehicle import Vehicle
from .multirotor import Multirotor, MultirotorConfig
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotors/iris.py | # Copyright (c) 2023, Marcelo Jacinto
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig
# Sensors and dynamics setup
from pegasus.simulator.logic.dynamics import LinearDrag
from pegasus.simulator.logic.thrusters import QuadraticThrustCurve
from pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS
# Mavlink interface
from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend
# Get the location of the IRIS asset
from pegasus.simulator.params import ROBOTS
class IrisConfig(MultirotorConfig):
def __init__(self):
# Stage prefix of the vehicle when spawning in the world
self.stage_prefix = "quadrotor"
# The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia)
self.usd_file = ROBOTS["Iris"]
# The default thrust curve for a quadrotor and dynamics relating to drag
self.thrust_curve = QuadraticThrustCurve()
self.drag = LinearDrag([0.50, 0.30, 0.0])
# The default sensors for a quadrotor
self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()]
# The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations)
# [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend
# or your own custom Backend implementation!
self.backends = [MavlinkBackend()]
class Iris(Multirotor):
def __init__(self, id: int, world, init_pos=[0.0, 0.0, 0.07, init_orientation=[0.0, 0.0, 0.0, 1.0]], config=IrisConfig()):
super.__init__(config.stage_prefix, config.usd_file, id, world, init_pos, init_orientation, config=config) |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/__init__.py | """
| Author: Marcelo Jacinto ([email protected])
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from .drag import Drag
from .linear_drag import LinearDrag
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/drag.py | """
| File: drag.py
| Author: Marcelo Jacinto ([email protected])
| Description: Base interface used to implement forces that should actuate on a rigidbody such as linear drag
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
from pegasus.simulator.logic.state import State
class Drag:
"""
Class that serves as a template for the implementation of Drag forces that actuate on a rigid body
"""
def __init__(self):
"""
Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants
"""
@property
def drag(self):
"""The drag force to be applied on the body frame of the vehicle
Returns:
list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference
frame, expressed in Newton (N) [dx, dy, dz]
"""
return [0.0, 0.0, 0.0]
def update(self, state: State, dt: float):
"""Method that should be implemented to update the drag force to be applied on the body frame of the vehicle
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference
"""
return [0.0, 0.0, 0.0]
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/linear_drag.py | """
| File: linear_drag.py
| Author: Marcelo Jacinto ([email protected])
| Description: Computes the forces that should actuate on a rigidbody affected by linear drag
| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.
"""
import numpy as np
from pegasus.simulator.logic.dynamics.drag import Drag
from pegasus.simulator.logic.state import State
class LinearDrag(Drag):
"""
Class that implements linear drag computations afftecting a rigid body. It inherits the Drag base class.
"""
def __init__(self, drag_coefficients=[0.0, 0.0, 0.0]):
"""
Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants
Args:
drag_coefficients (list[float]): The constant linear drag coefficients to used to compute the total drag forces
affecting the rigid body. The linear drag is given by diag(dx, dy, dz) * [v_x, v_y, v_z] where the velocities
are expressed in the body frame of the rigid body (using the FRU frame convention).
"""
# Initialize the base Drag class
super().__init__()
# The linear drag coefficients of the vehicle's body frame
self._drag_coefficients = np.diag(drag_coefficients)
# The drag force to apply on the vehicle's body frame
self._drag_force = np.array([0.0, 0.0, 0.0])
@property
def drag(self):
"""The drag force to be applied on the body frame of the vehicle
Returns:
list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference
frame, expressed in Newton (N) [dx, dy, dz]
"""
return self._drag_force
def update(self, state: State, dt: float):
"""Method that updates the drag force to be applied on the body frame of the vehicle. The total drag force
applied on the body reference frame (FLU convention) is given by diag(dx,dy,dz) * R' * v
where v is the velocity of the vehicle expressed in the inertial frame and R' * v = velocity_body_frame
Args:
state (State): The current state of the vehicle.
dt (float): The time elapsed between the previous and current function calls (s).
Returns:
list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference
"""
# Get the velocity of the vehicle expressed in the body frame of reference
body_vel = state.linear_body_velocity
# Compute the component of the drag force to be applied in the body frame
self._drag_force = -np.dot(self._drag_coefficients, body_vel)
return self._drag_force
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/tests/__init__.py | # Copyright (c) 2023, Marcelo Jacinto
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
from .test_hello_world import *
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/tests/test_hello_world.py | # NOTE:
# omni.kit.test - std python's unittest module with additional wrapping to add suport for async/await tests
# For most things refer to unittest docs: https://docs.python.org/3/library/unittest.html
import omni.kit.test
# Extnsion for writing UI tests (simulate UI interaction)
import omni.kit.ui_test as ui_test
# Import extension python module we are testing with absolute import path, as if we are external user (other extension)
import pegasus.simulator
# Having a test class dervived from omni.kit.test.AsyncTestCase declared on the root of module will make it auto-discoverable by omni.kit.test
class Test(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
pass
# After running each test
async def tearDown(self):
pass
# Actual test, notice it is "async" function, so "await" can be used if needed
async def test_hello_public_function(self):
result = pegasus.simulator.some_public_function(4)
self.assertEqual(result, 256)
async def test_window_button(self):
# Find a label in our window
label = ui_test.find("My Window//Frame/**/Label[*]")
# Find buttons in our window
add_button = ui_test.find("My Window//Frame/**/Button[*].text=='Add'")
reset_button = ui_test.find("My Window//Frame/**/Button[*].text=='Reset'")
# Click reset button
await reset_button.click()
self.assertEqual(label.widget.text, "empty")
await add_button.click()
self.assertEqual(label.widget.text, "count: 1")
await add_button.click()
self.assertEqual(label.widget.text, "count: 2")
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/assets/Robots/Flying Cube/cube.usda | #usda 1.0
(
defaultPrim = "Root"
upAxis = "Z"
)
def Xform "Root"
{
def Xform "vehicle"
{
token ui:displayGroup = "Material Graphs"
token ui:displayName = "vehicle"
int ui:order = 1024
float3 xformOp:rotateXYZ = (0, -0, 0)
float3 xformOp:scale = (1, 1, 1)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
def Xform "body" (
apiSchemas = ["PhysicsMassAPI", "PhysicsRigidBodyAPI", "PhysxRigidBodyAPI", "PhysicsArticulationRootAPI", "PhysxArticulationAPI"]
)
{
rel material:binding = </Root/vehicle/body/Looks/Carpet_Gray> (
bindMaterialAs = "weakerThanDescendants"
)
point3f physics:centerOfMass = (0, 0, 0)
float3 physics:diagonalInertia = (0.029125, 0.029125, 0.055225)
bool physics:kinematicEnabled = 0
float physics:mass = 1.5
bool physics:rigidBodyEnabled = 1
float physxRigidBody:angularDamping = 0
float physxRigidBody:maxAngularVelocity = 10000
float physxRigidBody:maxContactImpulse = 0.1
bool primvars:doNotCastShadows = 0
quatf xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (1.0000000000000009, 1.0000000000000009, 1)
float3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
def Scope "Looks"
{
def Material "Carpet_Gray"
{
token outputs:mdl:displacement.connect = </Root/vehicle/body/Looks/Carpet_Gray/Shader.outputs:out>
token outputs:mdl:surface.connect = </Root/vehicle/body/Looks/Carpet_Gray/Shader.outputs:out>
token outputs:mdl:volume.connect = </Root/vehicle/body/Looks/Carpet_Gray/Shader.outputs:out>
def Shader "Shader"
{
reorder properties = ["inputs:diffuse_color_constant", "inputs:diffuse_texture", "inputs:albedo_desaturation", "inputs:albedo_add", "inputs:albedo_brightness", "inputs:diffuse_tint", "inputs:reflection_roughness_constant", "inputs:reflection_roughness_texture_influence", "inputs:reflectionroughness_texture", "inputs:metallic_constant", "inputs:metallic_texture_influence", "inputs:metallic_texture", "inputs:specular_level", "inputs:enable_ORM_texture", "inputs:ORM_texture", "inputs:ao_to_diffuse", "inputs:ao_texture", "inputs:enable_emission", "inputs:emissive_color", "inputs:emissive_color_texture", "inputs:emissive_mask_texture", "inputs:emissive_intensity", "inputs:enable_opacity", "inputs:opacity_texture", "inputs:opacity_constant", "inputs:enable_opacity_texture", "inputs:opacity_mode", "inputs:opacity_threshold", "inputs:bump_factor", "inputs:normalmap_texture", "inputs:detail_bump_factor", "inputs:detail_normalmap_texture", "inputs:flip_tangent_u", "inputs:flip_tangent_v", "inputs:project_uvw", "inputs:world_or_object", "inputs:uv_space_index", "inputs:texture_translate", "inputs:texture_rotate", "inputs:texture_scale", "inputs:detail_texture_translate", "inputs:detail_texture_rotate", "inputs:detail_texture_scale"]
uniform token info:implementationSource = "sourceAsset"
uniform asset info:mdl:sourceAsset = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray.mdl@
uniform token info:mdl:sourceAsset:subIdentifier = "Carpet_Gray"
float inputs:albedo_add = 0 (
customData = {
float default = 0
dictionary soft_range = {
float max = 1
float min = -1
}
}
displayGroup = "Albedo"
displayName = "Albedo Add"
doc = "Adds a constant value to the diffuse color "
hidden = false
)
float inputs:albedo_brightness = 1 (
customData = {
float default = 1
dictionary soft_range = {
float max = 1
float min = 0
}
}
displayGroup = "Albedo"
displayName = "Albedo Brightness"
doc = "Multiplier for the diffuse color "
hidden = false
)
float inputs:albedo_desaturation = 0 (
customData = {
float default = 0
dictionary soft_range = {
float max = 1
float min = 0
}
}
displayGroup = "Albedo"
displayName = "Albedo Desaturation"
doc = "Desaturates the diffuse color"
hidden = false
)
asset inputs:ao_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "AO"
displayName = "Ambient Occlusion Map"
doc = "The ambient occlusion texture for the material"
hidden = false
)
float inputs:ao_to_diffuse = 0 (
customData = {
float default = 0
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "AO"
displayName = "AO to diffuse"
doc = "Controls the amount of ambient occlusion multiplied against the diffuse color channel"
hidden = false
)
float inputs:bump_factor = 0.75 (
customData = {
float default = 0.75
dictionary soft_range = {
float max = 1
float min = 0
}
}
displayGroup = "Normal"
displayName = "Normal Strength"
doc = "Strength of normal map"
hidden = false
)
float inputs:detail_bump_factor = 0.3 (
customData = {
float default = 0.3
dictionary soft_range = {
float max = 1
float min = 0
}
}
displayGroup = "Normal"
displayName = "Detail Normal Strength"
doc = "Strength of the detail normal"
hidden = false
)
asset inputs:detail_normalmap_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "Normal"
displayName = "Detail Normal Map"
hidden = false
)
float inputs:detail_texture_rotate = 0 (
customData = {
float default = 0
}
displayGroup = "UV"
displayName = "Detail Texture Rotate"
doc = "Rotates angle of the detail texture in degrees."
hidden = false
)
float2 inputs:detail_texture_scale = (1, 1) (
customData = {
float2 default = (1, 1)
}
displayGroup = "UV"
displayName = "Detail Texture Scale"
doc = "Larger numbers increase the size of the detail texture"
hidden = false
)
float2 inputs:detail_texture_translate = (0, 0) (
customData = {
float2 default = (0, 0)
}
displayGroup = "UV"
displayName = "Detail Texture Translate"
doc = "Controls the position of the detail texture."
hidden = false
)
color3f inputs:diffuse_color_constant = (0.5, 0.5, 0.5) (
customData = {
float3 default = (0.5, 0.5, 0.5)
}
displayGroup = "Albedo"
displayName = "Albedo Color"
doc = "This is the albedo base color"
hidden = false
)
asset inputs:diffuse_texture = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_BaseColor.png@ (
colorSpace = "sRGB"
customData = {
asset default = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_BaseColor.png@
}
displayGroup = "Albedo"
displayName = "Albedo Map"
hidden = false
)
color3f inputs:diffuse_tint = (0.096565746, 0.097755775, 0.10126585) (
customData = {
float3 default = (1, 1, 1)
}
displayGroup = "Albedo"
displayName = "Color Tint"
doc = "When enabled, this color value is multiplied over the final albedo color"
hidden = false
)
color3f inputs:emissive_color = (1, 1, 1) (
customData = {
float3 default = (1, 1, 1)
}
displayGroup = "Emissive"
displayName = "Emissive Color"
doc = "The emission color"
hidden = false
)
asset inputs:emissive_color_texture = @@ (
colorSpace = "auto"
customData = {
asset default = @@
}
displayGroup = "Emissive"
displayName = "Emissive Color map"
doc = "The emissive color texture"
hidden = false
)
float inputs:emissive_intensity = 0 (
customData = {
float default = 0
}
displayGroup = "Emissive"
displayName = "Emissive Intensity"
doc = "Intensity of the emission"
hidden = false
)
asset inputs:emissive_mask_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "Emissive"
displayName = "Emissive Mask map"
doc = "The texture masking the emissive color"
hidden = false
)
bool inputs:enable_emission = 0 (
customData = {
bool default = 0
}
displayGroup = "Emissive"
displayName = "Enable Emission"
doc = "Enables the emission of light from the material"
hidden = false
)
bool inputs:enable_opacity = 0 (
customData = {
bool default = 0
}
displayGroup = "Opacity"
displayName = "Enable Opacity"
doc = "Enables the use of cutout opacity"
hidden = false
)
bool inputs:enable_opacity_texture = 0 (
customData = {
bool default = 0
}
displayGroup = "Opacity"
displayName = "Enable Opacity Texture"
doc = "Enables or disables the usage of the opacity texture map"
hidden = false
)
bool inputs:enable_ORM_texture = 1 (
customData = {
bool default = 1
}
displayGroup = "Reflectivity"
displayName = "Enable ORM Texture"
doc = "The ORM texture will be used to extract the Occlusion, Roughness and Metallic textures from R,G,B channels"
hidden = false
)
bool inputs:excludeFromWhiteMode = 0 (
customData = {
bool default = 0
}
displayGroup = "Material Flags"
displayName = "Exclude from White Mode"
hidden = false
)
bool inputs:flip_tangent_u = 0 (
customData = {
bool default = 0
}
displayGroup = "Normal"
displayName = "Normal Map Flip U Tangent"
hidden = false
)
bool inputs:flip_tangent_v = 1 (
customData = {
bool default = 1
}
displayGroup = "Normal"
displayName = "Normal Map Flip V Tangent"
hidden = false
)
float inputs:metallic_constant = 0 (
customData = {
float default = 0
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Reflectivity"
displayName = "Metallic Amount"
doc = "Metallic Material"
hidden = false
)
asset inputs:metallic_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "Reflectivity"
displayName = "Metallic Map"
hidden = false
)
float inputs:metallic_texture_influence = 1 (
customData = {
float default = 1
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Reflectivity"
displayName = "Metallic Map Influence"
doc = "Blends between the constant value and the lookup of the metallic texture"
hidden = false
)
asset inputs:normalmap_texture = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_Normal.png@ (
colorSpace = "raw"
customData = {
asset default = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_Normal.png@
}
displayGroup = "Normal"
displayName = "Normal Map"
hidden = false
)
float inputs:opacity_constant = 1 (
customData = {
float default = 1
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Opacity"
displayName = "Opacity Amount"
doc = "Opacity value between 0 and 1, when Opacity Map is not valid"
hidden = false
)
int inputs:opacity_mode = 1 (
customData = {
int default = 1
}
displayGroup = "Opacity"
displayName = "Opacity Mono Source"
doc = "Determines how to lookup opacity from the supplied texture. mono_alpha, mono_average, mono_luminance, mono_maximum"
hidden = false
renderType = "::base::mono_mode"
sdrMetadata = {
string __SDR__enum_value = "mono_average"
string options = "mono_alpha:0|mono_average:1|mono_luminance:2|mono_maximum:3"
}
)
asset inputs:opacity_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "Opacity"
displayName = "Opacity Map"
hidden = false
)
float inputs:opacity_threshold = 0 (
customData = {
float default = 0
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Opacity"
displayName = "Opacity Threshold"
doc = "If 0, use fractional opacity values 'as is'; if > 0, remap opacity values to 1 when >= threshold and to 0 otherwise"
hidden = false
)
asset inputs:ORM_texture = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_ORM.png@ (
colorSpace = "raw"
customData = {
asset default = @http://omniverse-content-production.s3-us-west-2.amazonaws.com/Materials/Base/Carpet/Carpet_Gray/Carpet_Gray_ORM.png@
}
displayGroup = "Reflectivity"
displayName = "ORM Map"
doc = "Texture that has Occlusion, Roughness and Metallic maps stored in their respective R, G and B channels"
hidden = false
)
bool inputs:project_uvw = 0 (
customData = {
bool default = 0
}
displayGroup = "UV"
displayName = "Enable Project UVW Coordinates"
doc = "When enabled, UV coordinates will be generated by projecting them from a coordinate system"
hidden = false
)
float inputs:reflection_roughness_constant = 0 (
customData = {
float default = 0
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Reflectivity"
displayName = "Roughness Amount"
doc = "Higher roughness values lead to more blurry reflections"
hidden = false
)
float inputs:reflection_roughness_texture_influence = 1 (
customData = {
float default = 1
dictionary range = {
float max = 1
float min = 0
}
}
displayGroup = "Reflectivity"
displayName = "Roughness Map Influence"
doc = "Blends between the constant value and the lookup of the roughness texture"
hidden = false
)
asset inputs:reflectionroughness_texture = @@ (
colorSpace = "raw"
customData = {
asset default = @@
}
displayGroup = "Reflectivity"
displayName = "Roughness Map"
hidden = false
)
float inputs:specular_level = 0.5 (
customData = {
float default = 0.5
dictionary soft_range = {
float max = 1
float min = 0
}
}
displayGroup = "Reflectivity"
displayName = "Specular"
doc = "The specular level (intensity) of the material"
hidden = false
)
float inputs:texture_rotate = 0 (
customData = {
float default = 0
}
displayGroup = "UV"
displayName = "Texture Rotate"
doc = "Rotates angle of texture in degrees."
hidden = false
)
float2 inputs:texture_scale = (1, 1) (
customData = {
float2 default = (1, 1)
}
displayGroup = "UV"
displayName = "Texture Scale"
doc = "Larger number increases size of texture."
hidden = false
)
float2 inputs:texture_translate = (0, 0) (
customData = {
float2 default = (0, 0)
}
displayGroup = "UV"
displayName = "Texture Translate"
doc = "Controls position of texture."
hidden = false
)
int inputs:uv_space_index = 0 (
customData = {
int default = 0
dictionary range = {
int max = 3
int min = 0
}
}
displayGroup = "UV"
displayName = "UV Space Index"
doc = "UV Space Index."
hidden = false
)
bool inputs:world_or_object = 0 (
customData = {
bool default = 0
}
displayGroup = "UV"
displayName = "Enable World Space"
doc = "When enabled, uses world space for projection, otherwise object space is used"
hidden = false
)
token outputs:out (
renderType = "material"
)
}
}
}
def Cube "body" (
apiSchemas = ["PhysicsCollisionAPI", "PhysxCollisionAPI"]
)
{
float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
bool physics:collisionEnabled = 1
double size = 1
quatd xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (0.32, 0.48, 0.1)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
}
}
def Xform "rotor0" (
apiSchemas = ["PhysicsMassAPI", "PhysicsRigidBodyAPI", "PhysxRigidBodyAPI"]
)
{
rel material:binding = </Root/vehicle/rotor0/Looks/Linen_Blue> (
bindMaterialAs = "weakerThanDescendants"
)
float3 physics:diagonalInertia = (9.75e-7, 0.000273104, 0.000274004)
bool physics:kinematicEnabled = 0
float physics:mass = 0.005
bool physics:rigidBodyEnabled = 1
float physxRigidBody:angularDamping = 0
bool physxRigidBody:disableGravity = 0
bool physxRigidBody:enableCCD = 0
float physxRigidBody:maxAngularVelocity = 10000
float physxRigidBody:maxContactImpulse = 0.1
bool primvars:doNotCastShadows = 0
quatf xformOp:orient = (0.70710677, 0, 0, 0.70710677)
double3 xformOp:scale = (1.0000000000000009, 1.0000000000000009, 1)
float3 xformOp:translate = (0.13, -0.22, 0.06)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
def Cube "Cube"
{
float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
double size = 1
quatd xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (0.01, 0.01, 0.01)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
}
def PhysicsRevoluteJoint "RevoluteJoint"
{
uniform token physics:axis = "Z"
rel physics:body0 = </Root/vehicle/body>
rel physics:body1 = </Root/vehicle/rotor0>
float physics:breakForce = inf
float physics:breakTorque = inf
point3f physics:localPos0 = (0.13, -0.22, 0.06)
point3f physics:localPos1 = (2.7755576e-17, 0, 0)
quatf physics:localRot0 = (0.70710677, 0, 0, 0.70710677)
quatf physics:localRot1 = (1, 0, 0, -1.1852224e-7)
}
}
def Xform "rotor1" (
apiSchemas = ["PhysicsMassAPI", "PhysicsRigidBodyAPI", "PhysxRigidBodyAPI"]
)
{
point3f physics:centerOfMass = (0, 0, 0)
float3 physics:diagonalInertia = (9.75e-7, 0.000273104, 0.000274004)
bool physics:kinematicEnabled = 0
float physics:mass = 0.005
bool physics:rigidBodyEnabled = 1
float physxRigidBody:angularDamping = 0
float physxRigidBody:maxAngularVelocity = 10000
float physxRigidBody:maxContactImpulse = 0.1
quatf xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (1.0000000000000009, 1.0000000000000009, 1)
float3 xformOp:translate = (-0.13, 0.2, 0.06)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
def Mesh "Cube"
{
float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
int[] faceVertexCounts = [4, 4, 4, 4, 4, 4]
int[] faceVertexIndices = [0, 1, 3, 2, 0, 4, 5, 1, 1, 5, 6, 3, 2, 3, 6, 7, 0, 2, 7, 4, 4, 7, 6, 5]
normal3f[] normals = [(0, -1, 0), (0, -1, 0), (0, -1, 0), (0, -1, 0), (0, 0, -1), (0, 0, -1), (0, 0, -1), (0, 0, -1), (1, 0, 0), (1, 0, 0), (1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, 1), (0, 0, 1), (0, 0, 1), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)] (
interpolation = "faceVarying"
)
point3f[] points = [(-0.5, -0.5, -0.5), (0.5, -0.5, -0.5), (-0.5, -0.5, 0.5), (0.5, -0.5, 0.5), (-0.5, 0.5, -0.5), (0.5, 0.5, -0.5), (0.5, 0.5, 0.5), (-0.5, 0.5, 0.5)]
float2[] primvars:st = [(1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (1, 1), (0, 1), (0, 0)] (
interpolation = "faceVarying"
)
uniform token subdivisionScheme = "none"
quatd xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (0.01, 0.01, 0.01)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
}
def PhysicsRevoluteJoint "RevoluteJoint"
{
uniform token physics:axis = "Z"
rel physics:body0 = </Root/vehicle/body>
rel physics:body1 = </Root/vehicle/rotor1>
float physics:breakForce = inf
float physics:breakTorque = inf
point3f physics:localPos0 = (-0.13, 0.2, 0.06)
point3f physics:localPos1 = (0, 2.7755576e-17, 0)
quatf physics:localRot0 = (1, 0, 0, 0)
quatf physics:localRot1 = (1, 0, 0, 0)
}
}
def Xform "rotor2" (
apiSchemas = ["PhysicsMassAPI", "PhysicsRigidBodyAPI", "PhysxRigidBodyAPI"]
customData = {
dictionary physics = {
bool localSpaceVelocities = 1
}
}
)
{
point3f physics:centerOfMass = (0, 0, 0)
float3 physics:diagonalInertia = (9.75e-7, 0.000273104, 0.000274004)
bool physics:kinematicEnabled = 0
float physics:mass = 0.005
bool physics:rigidBodyEnabled = 1
float physxRigidBody:angularDamping = 0
float physxRigidBody:contactSlopCoefficient = 0
bool physxRigidBody:disableGravity = 0
bool physxRigidBody:enableGyroscopicForces = 1
int physxRigidBody:lockedPosAxis = 0
int physxRigidBody:lockedRotAxis = 0
float physxRigidBody:maxAngularVelocity = 10000
float physxRigidBody:maxContactImpulse = 0.1
bool physxRigidBody:solveContact = 1
quatf xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (1.0000000000000009, 1.0000000000000009, 1)
float3 xformOp:translate = (0.13, 0.22, 0.06)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
def Cube "Cube"
{
float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
double size = 1
quatd xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (0.01, 0.01, 0.01)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
}
def PhysicsRevoluteJoint "RevoluteJoint"
{
uniform token physics:axis = "Z"
rel physics:body0 = </Root/vehicle/body>
rel physics:body1 = </Root/vehicle/rotor2>
float physics:breakForce = inf
float physics:breakTorque = inf
point3f physics:localPos0 = (0.13, 0.22, 0.06)
point3f physics:localPos1 = (0, 0, 0)
quatf physics:localRot0 = (1, 0, 0, 0)
quatf physics:localRot1 = (1, 0, 0, 0)
}
}
def Xform "rotor3" (
apiSchemas = ["PhysicsMassAPI", "PhysicsRigidBodyAPI", "PhysxRigidBodyAPI"]
)
{
point3f physics:centerOfMass = (0, 0, 0)
float3 physics:diagonalInertia = (9.75e-7, 0.000273104, 0.000274004)
bool physics:kinematicEnabled = 0
float physics:mass = 0.005
bool physics:rigidBodyEnabled = 1
float physxRigidBody:maxContactImpulse = 0.1
quatf xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (1.0000000000000009, 1.0000000000000009, 1)
float3 xformOp:translate = (-0.13, -0.2, 0.06)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
def Cube "Cube"
{
float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
double size = 1
quatd xformOp:orient = (1, 0, 0, 0)
double3 xformOp:scale = (0.01, 0.01, 0.01)
double3 xformOp:translate = (0, 0, 0)
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
}
def PhysicsRevoluteJoint "RevoluteJoint"
{
uniform token physics:axis = "Z"
rel physics:body0 = </Root/vehicle/body>
rel physics:body1 = </Root/vehicle/rotor3>
float physics:breakForce = inf
float physics:breakTorque = inf
point3f physics:localPos0 = (-0.13, -0.2, 0.06)
point3f physics:localPos1 = (0, -2.7755576e-17, 0)
quatf physics:localRot0 = (1, 0, 0, 0)
quatf physics:localRot1 = (1, 0, 0, 0)
}
}
}
}
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.0.0"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["Marcelo Jacinto"]
# The title and description fields are primarily for displaying extension info in UI
title = "Pegasus Simulator"
description="Extension providing the main framework interfaces for simulating aerial vehicles using PX4, Python or ROS 2 as a backend"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# One of categories for UI.
category = "Simulation"
# Keywords for the extension
keywords = ["drone", "quadrotor", "multirotor", "UAV", "px4", "sitl", "robotics"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file).
# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
# Use omni.ui to build simple UI
[dependencies]
"omni.ui" = {}
"omni.usd" = {}
"omni.kit.uiapp" = {}
"omni.isaac.core" = {}
"omni.ui.scene" = {}
"omni.kit.window.viewport" = {}
# Main python module this extension provides, it will be publicly available as "import pegasus.simulator".
[[python.module]]
name = "pegasus.simulator"
[python.pipapi]
requirements = ["numpy", "scipy", "pymavlink", "pyyaml"]
use_online_index = true
[[test]]
# Extra dependencies only to be used during test run
dependencies = [
"omni.kit.ui_test" # UI testing extension
]
|
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/configs.yaml | global_coordinates:
altitude: 90.0
latitude: 38.736832
longitude: -9.137977
px4_dir: ~/PX4-Autopilot
px4_default_airframe: gazebo-classic_iris # Change to 'iris' if using PX4 version lower than v1.14 |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.0.0] - 2023-02-17
- Initial version of Pegasus Simulator extension
### Added
- A widget GUI to spawn a limited set of simulation environments and drones using the PX4-bakend.
- A powerful sensors, drag, thrusters, control and vehicle API.
- Barometer, IMU, magnetometer and GPS sensors.
- Linear drag model.
- Quadratic thrust curve model.
- Multirotor model.
- The 3DR Iris quadrotor simulation model.
- MAVLink communications control support.
- ROS 2 communications control support (needs fixing).
- A library for implementing rotations from NED to ENU and FLU to FRD frame conventions.
- Examples on how to use the framework in standalone scripting mode.
- Demo with a nonlinear controller implemented in python.
- A PX4 tool for automatically launching PX4 in SITL mode when provided with the PX4-Autopilot installation directory.
- A paper describing the motivation for this framework and its inner-workings.
- Basic documentation generation using sphinx. |
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/README.md | # Pegasus Simulator
Pegasus Simulator is a framework built on top of NVIDIA
Omniverse and Isaac
Sim. It is designed to provide an easy, yet powerfull way of simulating the dynamics of vehicles. It provides a simulation interface for PX4 integration as well as a custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions.
## Contributing
The developers of the Pegasus simulator welcome any positive contributions and ideas from the robotics comunity to make
in order to allow this extension to mature. If you think you have a nice contribution to make or just a simple suggestion,
feel free to create bug reports, feature requests or open pull requests for direct code contributions.
## Acknowledgement
NVIDIA Isaac Sim is available freely under https://www.nvidia.com/en-us/omniverse/download/.
Pegasus Simulator is released under BSD-3 License.
The license files of its dependencies and assets are present in the docs/licenses directory.
## Citation
Please cite if you use this extension in your work:
```
@misc{jacinto2023pegasus,
author = {Marcelo Jacinto and Rita Cunha},
title = {Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation},
year = {2023},
eprint = {},
}
```
## Main Developer Team
This simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027.
* Project Founder
* Marcelo Jacinto], under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon)
* Architecture
* Marcelo Jacinto
* João Pinto
* Multirotor Dynamic Simulation and Control
* Marcelo Jacinto
* Example Applications
* Marcelo Jacinto
* João Pinto
* Paper Writting and Revision
* Marcelo Jacinto
* João Pinto
* Rita Cunha
* António Pascoal |
PegasusSimulator/PegasusSimulator/docs/make.bat | @ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=.
set BUILDDIR=_build
set LINKCHECKDIR=_build/linkcheck
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.http://sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
:checklinks
%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %LINKCHECKDIR%
:end
popd
|
PegasusSimulator/PegasusSimulator/docs/requirements.txt | sphinx==5.3.0
autodocsumm==0.2.10
myst-parser==0.18.1
sphinx-rtd-theme==1.2.0
sphinx_mdinclude==0.5.3
myst-parser==0.18.1
sphinxcontrib-bibtex==2.5.0
sphinxcontrib-youtube==1.2.0 |
PegasusSimulator/PegasusSimulator/docs/index.rst | Pegasus Simulator
#################
Overview
========
**Pegasus Simulator** is a framework built on top of `NVIDIA
Omniverse <https://docs.omniverse.nvidia.com/>`__ and `Isaac
Sim <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html>`__. It is designed to provide an easy yet
powerful way of simulating the dynamics of multirotors vehicles. It provides a simulation interface for `PX4 <https://px4.io/>`__
integration as well as custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions.
.. raw:: html
<p align = "center">
<a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="_static/pegasus_cover.png" alt="Pegasus Simulator image" align="center" height="50"/></a>
<a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="_static/mini demo.gif" alt="Pegasus Simulator gif" align="center" height="50"/></a>
</p>
If you find ``Pegasus Simulator`` useful in your academic work, please cite the paper below. It is also available `here <https://arxiv.org/abs/2307.05263>`_.
.. code-block:: bibtex
@misc{jacinto2023pegasus,
title={Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation},
author={Marcelo Jacinto and João Pinto and Jay Patrikar and John Keller and Rita Cunha and Sebastian Scherer and António Pascoal},
year={2023},
eprint={2307.05263},
archivePrefix={arXiv},
primaryClass={cs.RO}
}
Developer Team
~~~~~~~~~~~~~~
This simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027.
- Project Founder
- `Marcelo Jacinto <https://github.com/MarceloJacinto>`__, under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon)
- Architecture
- `Marcelo Jacinto <https://github.com/MarceloJacinto>`__
- `João Pinto <https://github.com/jschpinto>`__
- Multirotor Dynamic Simulation and Control
- `Marcelo Jacinto <https://github.com/MarceloJacinto>`__
- Example Applications
- `Marcelo Jacinto <https://github.com/MarceloJacinto>`__
- `João Pinto <https://github.com/jschpinto>`__
.. toctree::
:maxdepth: 2
:caption: Getting Started
source/setup/installation
source/setup/developer
.. toctree::
:maxdepth: 1
:caption: Tutorials
source/tutorials/run_extension_mode
source/tutorials/create_standalone_application
source/tutorials/create_standalone_simulation
source/tutorials/create_custom_backend
.. toctree::
:maxdepth: 2
:caption: Features
source/features/environments
source/features/vehicles
source/features/px4_integration
.. toctree::
:maxdepth: 2
:caption: Source API
source/api/index
.. toctree::
:maxdepth: 1
:caption: References
source/references/contributing
source/references/known_issues
source/references/changelog
source/references/roadmap
source/references/license
source/references/bibliography
.. automodule::"pegasus_isaac"
:platform: Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
:exclude-members: contextmanager
Other Simulation Frameworks
===========================
In this section, we acknowledge the nobel work of those who came before us and inspired this work:
- :cite:p:`gazebo` Gazebo simulator
- :cite:p:`rotorS` RotorS simulation plugin for gazebo
- :cite:p:`px4` PX4-SITL simulation plugin for gazebo
- :cite:p:`airsim` Microsoft Airsim project for Unreal Engine
- :cite:p:`flightmare` Flightmare simulator for Unity
- :cite:p:`jmavsim` jMAVSim java simulator
*"If I have seen further than others, it is by standing upon the shoulders of giants."*, Sir Isaac Newton
Project Sponsors
================
- Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS).
- Instituto Superior Técnico, Universidade de Lisboa
The work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para as Ciências e Tecnologias (FCT).
.. raw:: html
<p float="left" align="center">
<img src="_static/dsor_logo.png" width="90" align="center" />
<img src="_static/logo_isr.png" width="200" align="center"/>
<img src="_static/larsys_logo.png" width="200" align="center"/>
<img src="_static/ist_logo.png" width="200" align="center"/>
<img src="_static/logo_fct.png" width="200" align="center"/>
</p>
|
PegasusSimulator/PegasusSimulator/docs/conf.py | # Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# This section is responsible for auto-generating the API documentation
import os
import sys
sys.path.insert(0, os.path.abspath("../extensions/pegasus.simulator"))
sys.path.insert(0, os.path.abspath("../extensions/pegasus.simulator/pegasus/simulator"))
# -- Project information -----------------------------------------------------
project = "Pegasus Simulator"
copyright = "2023, Marcelo Jacinto"
author = "Marcelo Jacinto"
version = "1.0.0"
# -- General configuration ---------------------------------------------------
extensions = [
"sphinx.ext.duration",
"sphinx.ext.doctest",
"sphinx.ext.autodoc",
"autodocsumm",
'sphinx.ext.napoleon',
#"sphinx.ext.autosummary",
"sphinx.ext.intersphinx",
"myst_parser",
"sphinx.ext.mathjax",
"sphinxcontrib.bibtex",
"sphinx.ext.todo",
"sphinx.ext.githubpages",
"sphinx.ext.autosectionlabel",
"sphinxcontrib.youtube",
"myst_parser"
]
intersphinx_mapping = {
"rtd": ("https://docs.readthedocs.io/en/stable/", None),
"python": ("https://docs.python.org/3/", None),
"sphinx": ("https://www.sphinx-doc.org/en/master/", None),
}
# mathjax hacks
mathjax3_config = {
"tex": {
"inlineMath": [["\\(", "\\)"]],
"displayMath": [["\\[", "\\]"]],
},
}
intersphinx_disabled_domains = ["std"]
# supported file extensions for source files
#source_suffix = {
# ".rst": "restructuredtext"
#}
templates_path = ["_templates"]
suppress_warnings = ["myst.header", "autosectionlabel.*"]
# -- Options for EPUB output
epub_show_urls = "footnote"
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "README.md", "licenses/*"]
# --- Automatic API documentation generation
# put type hints inside the description instead of the signature (easier to read)
autodoc_typehints = "description"
autodoc_typehints_description_target = "documented"
# document class *and* __init__ methods
autoclass_content = "class" #
# separate class docstring from __init__ docstring
autodoc_class_signature = "separated"
# sort members by source order
autodoc_member_order = "groupwise"
# default autodoc settings
autodoc_default_options = {
"autosummary": True,
}
# BibTeX configuration
bibtex_bibfiles = ["bibliography.bib"]
# Generate documentation for __special__ methods
napoleon_include_special_with_doc = True
# Mock out modules that are not available on RTD
autodoc_mock_imports = [
"np",
"torch",
"numpy",
"scipy",
"carb",
"pxr",
"omni",
"omni.kit",
"omni.usd",
"omni.isaac.core.utils.nucleus",
"omni.client",
"pxr.PhysxSchema",
"pxr.PhysicsSchemaTools",
"omni.replicator",
"omni.isaac.core",
"omni.isaac.kit",
"omni.isaac.cloner",
"gym",
"stable_baselines3",
"rsl_rl",
"rl_games",
"ray",
"h5py",
"hid",
"prettytable",
"pyyaml",
"pymavlink",
"rclpy",
"std_msgs",
"sensor_msgs",
"geometry_msgs"
]
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages.
html_theme = "sphinx_rtd_theme"
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ["_static"]
html_logo = "_static/logo.png"
html_theme_options = {
'logo_only': True,
'display_version': False,
'style_nav_header_background': '#FFD700'
}
html_show_copyright = True
html_show_sphinx = False
# The master toctree document.
master_doc = "index"
|
PegasusSimulator/PegasusSimulator/docs/licenses/assets/iris-license.rst | | **Author:** Lorenz Meier ([email protected]) and Thomas Gubler
| **Description:** The original model has been created by Thomas Gubler. The original model can be found at `PX4 SITL Gazebo <https://github.com/PX4/PX4-SITL_gazebo-classic/>`__.
.. code-block:: text
BSD 3-Clause License
Copyright (c) 2012 - 2023, PX4 Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_application.rst | Create a Standalone Application
===============================
This tutorial introduces how to create a standalone python script to set up an empty scene.
It introduces the main class used by ``Isaac Sim`` simulator, :class:`SimulationApp`, as well as the :class:`timeline`
concept that helps to launch and control the simulation timeline. In this tutorial we do **NOT** expose the
``Pegasus API`` yet.
1. Code
-------
The tutorial corresponds to the ``0_template_app.py`` example in the ``examples`` directory.
.. literalinclude:: ../../../examples/0_template_app.py
:language: python
:emphasize-lines: 11-16,35-54,85-102
:linenos:
2. Explanation
--------------
The first step, when creating a ``standalone application`` with ``Isaac Sim`` is to instantiate the :class:`SimulationApp`
object, and it takes a dictionary of parameters that can be used to configure the application. This
object will be responsible for opening a ``bare bones`` version of the simulator. The ``headless`` parameter
selects whether to launch the GUI window or not.
.. literalinclude:: ../../../examples/0_template_app.py
:language: python
:lines: 11-16
:linenos:
:lineno-start: 11
.. note::
You can **NOT** import other omniverse modules before instantiating the :class:`SimulationApp`, otherwise the simulation crashes
before the window it's even open. For a deeper understanding on how the :class:`SimulationApp` works, check
`NVIDIA's offical documentation <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.kit/docs/index.html#simulation-application-omni-isaac-kit>`__.
In order to create a `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__,
we resort to the `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__,
and provides already some default parameters for setting up a simulation for us. You can pass as arguments the physics
time step and rendering time step (in seconds). The rendering and physics can be set to run at different rates. For now let's use the defaults: 60Hz for both rendering and physics.
After creating the `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__, we will
take advantage of its ``callback system`` to declare that some functions defined by us should be called at every physics iteration,
render iteration or every time there is a timeline event, such as pressing the start/stop button. In this case, the
``physics_callback`` method will be invoked at every physics step, the ``render_callback`` at every render step and
``timeline_callback`` every time there is a timeline event. You can add as many callbacks as you want. After having all your
callbacks defined, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing
robot joints (in this case there is none) to their default state.
.. literalinclude:: ../../../examples/0_template_app.py
:language: python
:lines: 35-54
:linenos:
:lineno-start: 35
To start the actual simulation, we invoke the timeline's ``play()`` method. This is necessary in order to ensure that
every previously defined callback gets invoked. In order for the ``Isaac Sim`` app to remain responsive, we need to create
a ``while loop`` that invokes ``world.step(render=True)`` to make sure that the UI get's rendered.
.. literalinclude:: ../../../examples/0_template_app.py
:language: python
:lines: 85-102
:linenos:
:lineno-start: 85
As you may have noticed, our ``infinite loop`` is very clean. In this work, similarly to the ROS 2 standard,
we prefer to perform all the logic by resorting to function callbacks instead of cramming all the logic inside
the while loop. This structure allows our code to be more organized and more modular. As you will learn in the following
tutorials, the ``Pegasus Simulator API`` is built on top of this idea of ``callbacks``.
3. Execution
------------
Now let's run the Python script:
.. code:: bash
ISAACSIM_PYTHON examples/0_template_app.py
This should open a stage with a blue ground-plane. The simulation should start playing automatically and the stage being rendered.
To stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal.
.. note::
Notice that the window will only close when pressing the ``STOP button``, because we defined a method called
``timeline_callback`` that get's invoked for every ``timeline event``, such as pressing the ``STOP button``. |
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_simulation.rst | Your First Simulation
=====================
In this tutorial, you will create a standalone Python application to perform a simulation using 1 vehicle and ``PX4-Autopilot``.
The end result should be the equivalent to the :ref:`Run in Extension Mode (GUI)` tutorial. To achieve this, we will cover the
basics of the Pegasus Simulator :ref:`API Reference`.
0. Preparation
--------------
Before you proceed, make sure you have read the :ref:`Installing the Pegasus Simulator` section first and that your system
is correctly configured. Also, we will assume that you already followed the :ref:`Create a Standalone Application` tutorial, as in this tutorial
we will resort to concepts introduced in it.
Additionally, you will also be required to have ``QGroundControl`` installed to operate the simulated vehicle. If you haven't
already, follow the Preparation section in the :ref:`Run in Extension Mode (GUI)` tutorial.
1. Code
--------
The tutorial corresponds to the ``1_px4_single_vehicle.py`` example in the ``examples`` directory.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:emphasize-lines: 24-29,47-48,55-56,58-77,79-80
:linenos:
2. Explanation
---------------
In order to start using the functionalities provided by the ``Pegasus Simulator``, we import some of the most commonly
used classes from the ``pegasus.simulator.logic`` module, which contains all the core APIs. To check all the classes and
methods currently provided, please refer to the :ref:`API Reference` section.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 24-29
:linenos:
:lineno-start: 24
.. note::
Some APIs may not be documented in the :ref:`API Reference` section. This means one of three things:
i) they are not meant for public use; ii) under development (untested); iii) or just deprecated and about to be replaced.
Next, we initialize the :class:`PegasusInterface` object. This is a singleton, which means that there exists only one
:class:`PegasusInterface` in memory at any time. This interface creates a `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__
internally, so you do not need to declare your own manually when using this API. By default, when physics engine is set to run
at ``250 Hz`` and the render engine at ``60Hz``.
The :class:`PegasusInterface` provides methods to set the simulation environment, define the geographic coordinates of the origin of the world, setting the default path for the PX4-Autopilot installation and much more. To learn more about this class, refer to the :ref:`Pegasus Interface` API section.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 47-48
:linenos:
:lineno-start: 47
Next, we load the 3D world environment. For this purpose, we provide the auxiliary method ``load_environment(usd_file)`` for
loading pre-made environments stored in `Universal Scene Description (.usd) <https://developer.nvidia.com/usd>`__ files. In this
example, we load one of the simulation environments already provided by NVIDIA, whose path in stored in the ``SIMULATION_ENVIRONMENTS``
dictionary. To known all provided environments, check the :ref:`Params` API section.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 55-56
:linenos:
:lineno-start: 55
The next step is to create a multirotor vehicle object. For that we start by creating a ``MultirotorConfig``, which contains
by default a :class:`QuadraticThrustCurve`, :class:`Linear Drag` model, a list of ``Sensors`` composed of a :class:`GPS`,
:class:`IMU`, :class:`Magnetometer` and :class:`Barometer`, and a list of control :class:`Backend`.
In this tutorial, we whish to control the vehicle via ``MAVLink``, ``PX4-Autopilot`` and ``QGroundControl``. Therefore,
we create a ``MAVLink`` control backend configured to also launch ``PX4-Autopilot`` in SITL mode in the background.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 58-68
:linenos:
:lineno-start: 58
To create the actual ``Multirotor`` object, we must specify the ``stage_path``, i.e. the name that the vehicle will have inside
the simulation tree and the ``usd_path`` which defines where the 3D model of the vehicle is stored. Once again, to known all
provided vehicle models, check the :ref:`Params` API section. Additionally, we can provide the original position and orientation
of the vehicle, according to an East-North-DOWN (ENU) convention.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 70-77
:linenos:
:lineno-start: 70
After the simulation is setup, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing
robot joints (the multirotor rotor joints) to their default state.
.. literalinclude:: ../../../examples/1_px4_single_vehicle.py
:language: python
:lines: 79-80
:linenos:
:lineno-start: 79
3. Execution
------------
Now let's run the Python script:
.. code:: bash
ISAACSIM_PYTHON examples/1_px4_single_vehicle.py
This should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered.
PX4-Autopilot will start running automatically in the background, receiving data from the simulated sensors and sending
target angular velocities for the vehicle rotors. You can now play with the vehicle using ``QGroundControl`` similarly to
what was shown in :ref:`Run in Extension Mode (GUI)` tutorial.
To stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal.
|
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_custom_backend.rst | Create a Custom Controller
==========================
In this tutorial, you will learn how to create a custom ``control backend`` that receives the current state of the vehicle and
its sensors and computes the control inputs to give to the rotors of the drone. The control laws implemented in this tutorial
and the math behind them are well described in :cite:p:`Pinto2021`, :cite:p:`mellinger_kumar`.
In this tutorial we will endup with a simulation that does **NOT** use ``PX4-Autopilot`` , and instead will use a custom nonlinear
controller to make the vehicle follow a pre-determined trajectory, written in just a few lines of pure Python code.
.. note::
The Control Backend API is what was used to implement the MAVLink/PX4 backend. This interface is very powerful as it not only allows
the user to create custom communication protocols (such as ROS) for controlling the vehicle, as well as defining and testing new
control algorithms directly in pure Python code. This is specially usefull for conducting MATLAB-like simulations,
as we can implement and test algorithms directly in a 3D environment by writing a few lines of Python code without having to deal
with `Mavlink`, `PX4` or `ROS` like in other simulators.
0. Preparation
--------------
This tutorial assumes that you have followed the :ref:`Your First Simulation` section first.
1. Code
-------
The tutorial corresponds to the ``4_python_single_vehicle.py`` example in the ``examples`` directory.
.. literalinclude:: ../../../examples/4_python_single_vehicle.py
:language: python
:emphasize-lines: 30-31,68-75
:linenos:
The next code section corresponds to the ``nonlinear_controller.py`` in the ``examples/utils`` directory.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:emphasize-lines: 18,24-44,114-117,121-124,143-151,154-160,168-174,177-183
:linenos:
2. Explanation
--------------
To start a pre-programed simulation using a different control backend other than ``MAVLink`` we include our custom
``control backend`` module written in pure Python.
.. literalinclude:: ../../../examples/4_python_single_vehicle.py
:language: python
:lines: 30-31
:linenos:
:lineno-start: 30
We now create a multirotor configuration and set the multirotor backend to be our ``NonlinearController`` object. That's it!
It is that simple! Instead of using the `MAVLink/PX4`` control we will use a pure Python controller written by us. The rest
of the script is the same as in the previous tutorial.
.. literalinclude:: ../../../examples/4_python_single_vehicle.py
:language: python
:lines: 68-75
:linenos:
:lineno-start: 68
Now, let's take a look on how the ``NonlinearControl`` class is structured and how you can build your own. We must start by
including the ``Backend`` class found in the ``pegasus.simulator.logic.backends`` API. To explore all the functionalities
offered by this class, check the :ref:`Backend` API reference page.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 18
:linenos:
:lineno-start: 18
Next, we define a class that inherits the `Backend`` class. This class must implement a few methods to be compliant
with the ``Multirotor`` API. In this example we will implement an "hard-coded" nonlinear geometrical controller for the
multirotor to track a pre-defined trajectory.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 24-44
:linenos:
:lineno-start: 24
The first method that should be implemented is ``start()`` . This method gets invoked by
the vehicle when the simulation starts. You should perform any initialization of your algorithm or communication protocol
here.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 114-117
:linenos:
:lineno-start: 114
The ``stop()`` method gets invoked by
the vehicle when the simulation stops. You should perform any cleanup here.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 121-124
:linenos:
:lineno-start: 121
The ``update_sensor(sensor_type: str, data)`` method gets invoked by the vehicle at every physics step iteration (it is used as a callback) for
each sensor that generated output data. It receives as input a string which describes the type of sensor and the data produced by that sensor.
It is up to you to decide on how to parse the sensor data and use it. In this case we are not going to use the data produced
by the simulated sensors for our controller. Instead we will get the state of the vehicle directly from the simulation and
use that to feedback into our control law.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 143-151
:linenos:
:lineno-start: 143
.. note::
You can take a look on how the ``MavlinkBackend`` is implemented to check on how to parse sensor data produced by IMU, GPS, etc.
A simple strategy is to use an if-statement to check for which sensor we are receive the data from and parse it accordingly, for example:
.. code:: Python
if sensor_type == "imu":
# do something
elif sensor_type == "gps":
# do something else
else:
# some sensor we do not care about, so ignore
Check the Sensors :ref:`API Reference` to check what type of data each sensor generates. For most cases, it will be a dictionary.
The ``update_state(state: State)`` method is called at every physics steps with the most up-to-date ``State`` of the vehicle. The state
object contains:
- **position** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame;
- **attitude** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame;
- **linear velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame;
- **linear body-velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame;
- **angular velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame;
- **linear acceleration** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame.
All of this data is filled adopting a **East-North-Down (ENU)** convention for the Inertial Reference Frame and a **Front-Left-Up (FLU)**
for the vehicle's body frame of reference.
.. note::
In case you need to adopt other conventions, the ``State`` class also provides methods to return the state of the vehicle in
North-East-Down (NED) and Front-Right-Down (FRD) conventions, so you don't have to make those conversions manually. Check
the :ref:`State` API reference page for more information.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 154-160
:linenos:
:lineno-start: 154
The ``input_reference()`` method is called at every physics steps by the vehicle to retrieve from the controller a list of floats
with the target angular velocities in [rad/s] to use as reference to apply to each vehicle rotor. The list of floats
returned by this method should have the same length as the number of rotors of the vehicle.
.. note::
In order to have a general controller, you might not want to hard-code the number of rotors of the vehicle in the controller.
To take this into account, the :ref:`Backend` object is initialized with a reference to the :ref:`Vehicle` object
when this gets instantiated. Therefore, it will access to all of its attributes, such as the number of rotors and methods
to convert torques and forces in the body-frame to target rotor angular velocities!
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 168-174
:linenos:
:lineno-start: 168
The ``update(dt: float)`` method gets invoked at every physics step by the vehicle. It receives as argument the amount of time
elapsed since the last update (in seconds). This is where you should define your controller/communication layer logic and
update the list of reference angular velocities for the rotors.
.. literalinclude:: ../../../examples/utils/nonlinear_controller.py
:language: python
:lines: 177-183
:linenos:
:lineno-start: 177
3. Execution
------------
Now let's run the Python script:
.. code:: bash
ISAACSIM_PYTHON examples/4_python_single_vehicle.py
This should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered.
The vehicle will automatically start flying and performing a very fast relay maneuvre. If you miss it, you can just hit the stop/play
button again to repeat it.
Notice now, that unlike the previous tutorial, if you open ``QGroundControl`` you won't see the vehicle. This is normal, because
now we are not using the ``MAVLink`` control backend, but instead our custom ``NonlinearControl`` backend. |
PegasusSimulator/PegasusSimulator/docs/source/tutorials/run_extension_mode.rst | Run in Extension Mode (GUI)
=======================================
This tutorial introduces how to interface with the Pegasus Simulator working in extension mode, i.e. with an interactive GUI.
This means that ``ISAACSIM`` will be launched as a standard application and the Pegasus Simulator extension should be
enabled from the extension manager.
0. Preparation
--------------
Before you proceed, check the :ref:`Installing the Pegasus Simulator` section first, if you haven't already. You will
also require `QGroundControl <http://qgroundcontrol.com/>`__ to control the vehicle. You haven't download it yet, you can
do it `here <https://docs.qgroundcontrol.com/master/en/getting_started/download_and_install.html>`__ or follow these steps:
1. Open a new terminal and run:
.. code:: bash
sudo usermod -a -G dialout $USER
sudo apt-get remove modemmanager -y
sudo apt install gstreamer1.0-plugins-bad gstreamer1.0-libav gstreamer1.0-gl -y
sudo apt install libqt5gui5 -y
sudo apt install libfuse2 -y
2. Download the `QGroundControl App Image <https://d176tv9ibo4jno.cloudfront.net/latest/QGroundControl.AppImage>`__.
3. Make the App image executable
.. code:: bash
chmod +x ./QGroundControl.AppImage
4. Execute QGroundControl by double-clicking or running:
.. code:: bash
./QGroundControl.AppImage
1. Simulation Steps
-------------------
1. Open ``ISAACSIM``, either by using the Omniverse Launcher or the terminal command:
.. code:: bash
ISAACSIM
2. Make sure the Pegasus Simulator Extension is enabled.
.. image:: /_static/pegasus_inside_extensions_menu.png
:width: 600px
:align: center
:alt: Enable the Pegasus Simulator extension inside Isaac Sim
3. On the Pegasus Simulator tab in the bottom-right corner, click on the ``Load Scene`` button.
.. image:: /_static/tutorials/load_scene.png
:width: 600px
:align: center
:alt: Load a 3D Scene
4. Again, on the Pegasus Simulator tab, click on the ``Load Vehicle`` button.
.. image:: /_static/tutorials/load_vehicle.png
:width: 600px
:align: center
:alt: Load the vehicle
5. Press the ``play`` button on the simulator's control bar on the left corner.
.. image:: /_static/tutorials/play.png
:width: 600px
:align: center
:alt: Start the simulation environment
6. On QGroundControl, an arrow representing the vehicle should pop-up. You can now perform a take-off, but pressing the
``take-off`` button on top-left corner of QGroundControl.
.. image:: /_static/tutorials/take_off.png
:width: 600px
:align: center
:alt: Perform a take-off with the drone
7. On QGroundControl, left-click on a place on the map, press ``Go to location`` and slide at the bottom of the screen
to confirm the target waypoint for the drone to follow.
.. image:: /_static/tutorials/go_to_location.png
:width: 600px
:align: center
:alt: Perform a go-to waypoint with the drone
Congratulations 🎉️🎉️🎉️ ! You have just completed your first tutorial and you should now see the vehicle moving on the screen.
A short video of this tutorial is also available `here <https://youtu.be/_11OCFwf_GE>`__.
.. youtube:: _11OCFwf_GE
:width: 100%
:align: center
:privacy_mode:
.. note::
Everything that you can do using the provided GUI can also be achieved by the Pegasus Simulator API in Python. In the next
tutorials we will cover how to create standalone Python scripts to perform simulations. |
PegasusSimulator/PegasusSimulator/docs/source/setup/installation.rst | Installation
============
Installing NVIDIA Isaac Sim
---------------------------
.. image:: https://img.shields.io/badge/IsaacSim-2023.1.1-brightgreen.svg
:target: https://developer.nvidia.com/isaac-sim
:alt: IsaacSim 2023.1.1
.. image:: https://img.shields.io/badge/PX4--Autopilot-1.14.1-brightgreen.svg
:target: https://github.com/PX4/PX4-Autopilot
:alt: PX4-Autopilot 1.14.1
.. image:: https://img.shields.io/badge/Ubuntu-22.04LTS-brightgreen.svg
:target: https://releases.ubuntu.com/22.04/
:alt: Ubuntu 22.04
.. note::
We have tested Pegasus Simulator with Isaac Sim 2023.1.1 release on Ubuntu 22.04LTS with NVIDIA driver 545.23.08. The PX4-Autopilot used during development was v.14.1. Older versions Ubuntu and PX4-Autopilot were not tested. This extension was not tested on Windows.
In order to install Isaac Sim on linux, download the `Omniverse AppImage here <https://install.launcher.omniverse.nvidia.com/installers/omniverse-launcher-linux.AppImage>`__ or run the following line on the terminal:
.. code:: bash
wget https://install.launcher.omniverse.nvidia.com/installers/omniverse-launcher-linux.AppImage
A short video with the installation guide for Pegasus Simulator is also available `here <https://youtu.be/YCp5E8nazag>`__.
.. youtube:: YCp5E8nazag
:width: 100%
:align: center
:privacy_mode:
Configuring the environment variables
-------------------------------------
NVIDIA provides Isaac Sim with its own Python interpreter along with some basic extensions such as numpy and pytorch. In
order for the Pegasus Simulator to work, we require the user to use the same python environment when starting a simulation
from python scripts. As such, we recommend setting up a few custom environment variables to make this process simpler.
.. note::
Although it is possible to setup a virtual environment following the
instructions `here <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/install_python.html>`__, this
feature was not tested.
Start by locating the `Isaac Sim installation <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/install_python.html>`__
by navigating to Isaac Sim's root folder. Typically, in Linux, this folder can be found under ``${HOME}/.local/share/ov/pkg/isaac_sim-*``,
where the ``*`` is the version number.
Add the following lines to your ``~/.bashrc`` or ``~/.zshrc`` file.
.. code:: bash
# Isaac Sim root directory
export ISAACSIM_PATH="${HOME}/.local/share/ov/pkg/isaac_sim-*"
# Isaac Sim python executable
alias ISAACSIM_PYTHON="${ISAACSIM_PATH}/python.sh"
# Isaac Sim app
alias ISAACSIM="${ISAACSIM_PATH}/isaac-sim.sh"
If you only have one version of Isaac Sim installed, you can leave the ``*``, otherwise you will have to replace it by the
version that you desire to use. In the remaining of the documentation, we will refer to the Isaac Sim's path as ``ISAACSIM_PATH`` ,
the provided python interpreter as ``ISAACSIM_PYTHON`` and the simulator itself as ``ISAACSIM`` .
Running Isaac Sim
~~~~~~~~~~~~~~~~~
At this point, you are expected to have NVIDIA Isaac Sim fully installed and working. To make sure you have everything setup correctly,
open a new terminal window (**Ctrl+Alt+T**), and test the following commands:
- Check that the simulator app can be launched
.. code:: bash
# Run the simulator with the --help argument to see all available options
ISAACSIM --help
# Run the simulator. A new window should open
ISAACSIM
- Check that you can launch the simulator from a python script (standalone mode)
.. code:: bash
# Run the bundled python interpreter and see if it prints on the terminal "Hello World."
ISAACSIM_PYTHON -c "print('Hello World.')"
# Run the python interpreter and check if we can run a script that starts the simulator and adds cubes to the world
ISAACSIM_PYTHON ${ISAACSIM_PATH}/standalone_examples/api/omni.isaac.core/add_cubes.py
If you were unable to run the commands above successfuly, then something is incorrectly configured.
Please do not proceed with this installation until you have everything setup correctly.
Addtional Isaac Sim resources:
- `Troubleshooting documentation <https://docs.omniverse.nvidia.com/app_isaacsim/prod_kit/linux-troubleshooting.html>`__
Installing the Pegasus Simulator
--------------------------------
Clone the `Pegasus Simulator <https://www.github.com/PegasusSimulator/PegasusSimulator.git>`__:
.. code:: bash
# Option 1: With HTTPS
git clone https://github.com/PegasusSimulator/PegasusSimulator.git
# Option 2: With SSH (you need to setup a github account with ssh keys)
git clone [email protected]:PegasusSimulator/PegasusSimulator.git
The Pegasus Simulator was originally developed as an Isaac Sim extension with an interactive GUI, but also provides a powerfull
API that allows it to run as a standalone app, i.e. by creating python scritps (as shown in the examples directory of this repository).
To be able to use the extension in both modes, follow these steps:
1. Launch ``ISAACSIM`` application.
2. Open the Window->extensions on the top menubar inside Isaac Sim.
.. image:: /_static/extensions_menu_bar.png
:width: 600px
:align: center
:alt: Extensions on top menubar
3. On the Extensions manager menu, we can enable or disable extensions. By pressing the settings button, we can
add a path to the Pegasus-Simulator repository.
.. image:: /_static/extensions_widget.png
:width: 600px
:align: center
:alt: Extensions widget
4. The path inserted should be the path to the repository followed by ``/extensions``.
.. image:: /_static/ading_extension_path.png
:width: 600px
:align: center
:alt: Adding extension path to the extension manager
5. After adding the path to the extension, we can enable the Pegasus Simulator extension on the third-party tab.
.. image:: /_static/pegasus_inside_extensions_menu.png
:width: 600px
:align: center
:alt: Pegasus Extension on the third-party tab
When enabling the extension for the first time, the python requirements should be install automatically for the build in
``ISAACSIM_PYTHON`` , and after a few seconds, the Pegasus widget GUI should pop-up.
6. The Pegasus Simulator window should appear docked to the bottom-right section of the screen.
.. image:: /_static/pegasus_gui_example.png
:width: 600px
:align: center
:alt: Pegasus Extension GUI after install
Installing the extension as a library
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In order to be able to use the Pegasus Simulator API from python scripts and standalone apps, we must install this
extension as a ``pip`` python module for the built-in ``ISAACSIM_PYTHON`` to recognize. For that, run:
.. code:: bash
# Go to the repository of the pegasus simulator
cd PegasusSimulator
# Go into the extensions directory
cd extensions
# Run the pip command using the built-in python interpreter
ISAACSIM_PYTHON -m pip install --editable pegasus.simulator
We use the ``--editable`` flag so that the content of the extension is linked instead of copied. After this step, you
should be able to run the python standalone examples inside the ``examples`` folder.
Installing PX4-Autopilot
------------------------
In this first version of the Pegasus Simulator (in extension mode), the GUI widget provided is only usefull if you intend to use the PX4-Autopilot.
To install PX4-Autopilot, follow the following steps:
1. Install the dependencies (to be able to compile PX4-Autopilot):
.. code:: bash
# Linux packages
sudo apt install git make cmake python3-pip
# Python packages
pip install kconfiglib jinja2 empy jsonschema pyros-genmsg packaging toml numpy future
2. Clone the `PX4-Autopilot <https://github.com/PX4/PX4-Autopilot>`__:
.. code:: bash
# Option 1: With HTTPS
git clone https://github.com/PX4/PX4-Autopilot.git
# Option 2: With SSH (you need to setup a github account with ssh keys)
git clone [email protected]:PX4/PX4-Autopilot.git
3. Checkout to the stable version 1.14.1 and compile the code for software-in-the-loop (SITL) mode:
.. code:: bash
# Go to the PX4 directory
cd PX4-Autopilot
# Checkout to the latest stable release
git checkout v1.14.1
# Initiate all the submodules. Note this will download modules such as SITL-gazebo which we do not need
# but this is the safest way to make sure that the PX4-Autopilot and its submodules are all checked out in
# a stable and well tested release
git submodule update --init --recursive
# Compile the code in SITL mode
make px4_sitl_default none
Note: If you are installing a version of PX4 prior to v1.14.1, you may need to go to change the default airframe to
be used by PX4. This can be achieved by:
.. code:: bash
# Go inside the config folder of the pegasus simulator extension
cd PegasusSimulator/extensions/pegasus/simulator/config
# Open the file configs.yaml
nano configs.yaml
# And change the line:
px4_default_airframe: iris
You can also set the PX4 installation path inside the Pegasus Simulator GUI, as shown in the next section, or by editing
the file ``PegasusSimulator/extensions/pegasus/simulator/config/config.yaml`` and setting the ``px4_dir`` field to the correct path.
Setting the PX4 path inside the Pegasus Simulator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The simulator provides a feature to auto-launch PX4-Autopilot for every vehicle that is spawned in the simulation world.
For this feature to work, we need to tell the Pegasus Simulator extension where the PX4-Autopilot directory can be found.
For that, edit the ``PX4 Path`` text field if is not correct by default and press the ``Make Default`` button. This
field supports relative paths to the home directory, which means that you can use ``~`` to represent the home directory
without hard-coding it.
.. image:: /_static/pegasus_GUI_px4_dir.png
:width: 600px
:align: center
:alt: Pegasus GUI with px4 directory highlighted
By default, the extension assumes that PX4-Autopilot is installed at ``~/PX4-Autopilot`` .
|
PegasusSimulator/PegasusSimulator/docs/source/setup/developer.rst | Development
===========
We developed this extension using `Visual Studio Code <https://code.visualstudio.com/>`__, the
recommended tool on NVIDIA's Omniverse official documentation. To setup Visual Studio Code with hot-reloading features, follow
the additional documentation pages:
* `Isaac Sim VSCode support <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/manual_standalone_python.html#isaac-sim-python-vscode>`__
* `Debugging with VSCode <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/tutorial_advanced_python_debugging.html>`__
To enable a better developer experience when contributing or modifying this extension, and have access to features such as
autocomplete, we recommend linking the Pegasus Simulator repository to the current installation of ``ISAACSIM`` . For that, please
run the following script provided with the framework:
.. code:: bash
./link_app.sh --path $ISAACSIM_PATH
This script will create a symbolic link to ``ISAACSIM`` inside the repository. After this step, you can also launch the
``ISAACSIM`` with the extension enabled (without using the GUI presented in Section :ref:`Installing the Pegasus Simulator`), by running:
.. code:: bash
./app/isaac-sim.sh --ext-folder extensions --enable pegasus.simulator
Code structure
--------------
This simulation framework is strucuture according to the following tree:
.. code:: bash
PegasusSimulator:
├── .vscode
├── docs
├── examples
├── tools
├── extensions
│ ├── pegasus.simulator
│ │ ├── config
│ │ ├── data
│ │ ├── docs
│ │ ├── setup.py
│ │ ├── pegasus.simulator
│ │ │ │ ├── __init__.py
│ │ │ │ ├── params.py
│ │ │ │ ├── extension.py
│ │ │ │ ├── assets
│ │ │ │ ├── logic
│ │ │ │ ├── ui
The extensions directory contains the source code for the PegasusSimulator API and interactive GUI while the
examples directory contains the a set of python scripts to launch standalone applications and pre-programed simulations.
As explained in NVIDIA's documentation, extensions are the standard way of developing on top of Isaac Sim and other Omniverse
tools. The core of our extension is developed in the ``logic`` and the ``ui`` modules. The ``logic`` API is exposed to the users
and is used both when operating the Pegasus Simulator in GUI widget/extension mode and via standalone python applications.
The ``ui`` API is **not exposed/documented** as it is basically defines the widget to call functionalities provided by
the ``logic`` module.
|
PegasusSimulator/PegasusSimulator/docs/source/api/vehicles.vehicle_manager.rst | Vehicle Manager
===============
.. automodule:: pegasus.simulator.logic.vehicle_manager
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/sensors.sensor.rst | Sensor
======
.. automodule:: pegasus.simulator.logic.sensors.sensor
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/vehicles.vehicle.rst | Vehicle
=======
.. automodule:: pegasus.simulator.logic.vehicles.vehicle
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/state.rst | State
=====
.. automodule:: pegasus.simulator.logic.state
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/dynamics.drag.rst | Drag
====
.. automodule:: pegasus.simulator.logic.dynamics.drag
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/sensors.magnetometer.rst | Magnetometer
============
To simulate the measurements produced by a magnetometer, we resort to the same declination D,
nclination I angles, and magnetic strength S pre-computed tables provided in PX4-SITL :cite:p:`px4`,
obtained from the World Magnetic Model (WMM) from 2018 :cite:p:`compute_mag_components`.
.. automodule:: pegasus.simulator.logic.sensors.magnetometer
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/dynamics.linear_drag.rst | Linear Drag
===========
.. automodule:: pegasus.simulator.logic.dynamics.linear_drag
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/backends.backend.rst | Backend
=======
.. automodule:: pegasus.simulator.logic.backends.backend
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/params.rst | Params
======
.. automodule:: pegasus.simulator.params
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/backends.ros2_backend.rst | ROS2 Backend
============
.. automodule:: pegasus.simulator.logic.backends.ros2_backend
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/sensors.imu.rst | Imu
===
The IMU is composed of a gyroscope and an accelerometer, which measure
the angular velocity and acceleration of the vehicle in the body frame, respectively.
The bias/drift of the imu is given by a slowly varying random walk processes of
diffusion, as described in :cite:p:`kalibr`, :cite:p:`maybeck`.
.. automodule:: pegasus.simulator.logic.sensors.imu
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/vehicles.multirotor.rst | Multirotor
==========
.. automodule:: pegasus.simulator.logic.vehicles.multirotor
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/thrusters.quadratic_thrust_curve.rst | Quadratic Thrust Curve
======================
.. automodule:: pegasus.simulator.logic.thrusters.quadratic_thrust_curve
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/api/graphs.ros2_camera.rst | ROS2 Camera
===========
.. automodule:: pegasus.simulator.logic.graphs.ros2_camera
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/sensors.gps.rst | GPS
===
In order to guarantee full compatibility with the PX4 navigation system, the projection from
local to global coordinate system, i.e., latitude and longitude is performed by transforming
the vehicle position, to the geographic coordinate system using the azymuthal equidistant
projection in accordance with the World Geodetic System (WGS84) :cite:p:`azimuthal_projection`,
:cite:p:`Snyder1987`.
.. automodule:: pegasus.simulator.logic.sensors.gps
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/sensors.barometer.rst | Barometer
=========
This sensor follows the International Standard Atmosphere (ISA) model :cite:p:`baromter_implementation` .
.. automodule:: pegasus.simulator.logic.sensors.barometer
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/graphs.graph.rst | Graph
======
.. automodule:: pegasus.simulator.logic.graphs.graph
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/backends.mavlink_backend.rst | Mavlink Backend
===============
.. automodule:: pegasus.simulator.logic.backends.mavlink_backend
:members:
:undoc-members:
:show-inheritance:
|
PegasusSimulator/PegasusSimulator/docs/source/api/index.rst | API Reference
=============
Sensors
-------
.. toctree::
:maxdepth: 2
sensors.sensor
sensors.barometer
sensors.gps
sensors.imu
sensors.magnetometer
Graphs
------
.. toctree::
:maxdepth: 2
graphs.graph
graphs.ros2_camera
Dynamics
--------
.. toctree::
:maxdepth: 2
dynamics.drag
dynamics.linear_drag
Thruster
--------
.. toctree::
:maxdepth: 2
thrusters.quadratic_thrust_curve
Control Backends
----------------
.. toctree::
:maxdepth: 2
backends.backend
backends.mavlink_backend
backends.ros2_backend
Vehicle
-------
.. toctree::
:maxdepth: 2
state
vehicles.vehicle
vehicles.vehicle_manager
vehicles.multirotor
Pegasus Interace
----------------
.. toctree::
:maxdepth: 2
pegasus_interface
Default Params
--------------
.. toctree::
:maxdepth: 2
params |
PegasusSimulator/PegasusSimulator/docs/source/api/pegasus_interface.rst | Pegasus Interface
=================
.. automodule:: pegasus.simulator.logic.interface.pegasus_interface
:members:
:undoc-members:
:show-inheritance: |
PegasusSimulator/PegasusSimulator/docs/source/features/vehicles.rst | Vehicles
========
In this first version of the Pegasus Simulator we only provide the implementation for a generic ``Multirotor`` Vehicles
and a 3D asset for the ``3DR Iris quadrotor`` . Please check the :ref:`Roadmap` section for future plans regarding new vehicles
topologies and the :ref:`Contributing` section to contribute if you have a new vehicle model that you would like to be added.
To create a Multirotor object from scratch, consider the following example code:
.. code:: Python
from pegasus.simulator.params import ROBOTS
from pegasus.simulator.logic.dynamics import LinearDrag
from pegasus.simulator.logic.thrusters import QuadraticThrustCurve
from pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS
from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig
# Auxiliary scipy import to set the rotation of the vehicle in quaternion
from scipy.spatial.transform import Rotation
# Create a multirotor configuration object
multirotor_config = MultirotorConfig()
multirotor_config.stage_prefix="quadrotor"
multirotor_config.usd_file = ""
# The default thrust curve for a quadrotor and dynamics relating to drag
multirotor_config.thrust_curve = QuadraticThrustCurve()
multirotor_config.drag = LinearDrag([0.50, 0.30, 0.0])
# Set the sensors for a quadrotor
# For each sensor we are using the default parameters, but you can also pass in a dictionary
# to configure them. Check the Sensors API documentation for more information.
multirotor_config.sensors = [Barometer(), IMU(), Magnetometer(), GPS()]
# The backends for actually sending commands to the vehicle.
# By default use mavlink (with default mavlink configurations).
# It can also be your own custom Control Backend implementation!
#
# Note: you can have multiple backends (this is usefull for creating backends
# for logging purposes) but only the first backend in the list will be used
# to send commands to the vehicles. The others will just be used to receive the
# current state of the vehicle and the data produced by the sensors
multirotor_config.backends = [MavlinkBackend()]
# Create and spawn the multirotor object in the scene
Multirotor(
stage_prefix="/World/quadrotor",
# The path to the multirotor USD file
usd_file=ROBOTS['Iris'],
vehicle_id=0,
init_pos=[0.0, 0.0, 0.07],
init_orientation=Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(),
config=config_multirotor,
)
To define and use a custom multirotor frame, you must adhere to the adopted convention. Therefore, a vehicle
must be made in a USD file and have a ``/body`` and multiple ``/rotor<id>`` Xform objects. Each rotor ``/rotor<id>``
must have inside a Revolut Joint named ``/rotor<id>`` where the ``<id>`` of the joint must coincide with the Xform name.
An example tree of the 3DR Iris quadrotor is presented bellow.
.. image:: /_static/features/vehicle_standard.png
:width: 600px
:align: center
:alt: Vehicle standard for defining the frames
Additionally, you should set the mass and moments of inertial of the materials the compose the vehicle directly in the USD file,
as well as the physics colliders. |
PegasusSimulator/PegasusSimulator/docs/source/features/px4_integration.rst | PX4 Integration
===============
The ``PX4-Autopilot`` support is provided by making use of the ``Control Backends API`` , and implementing a custom
``MavlinkBackend`` which contains a built-in tool to launch and kill PX4 in SITL mode automatically.
To instantiate a ``MavlinkBackend`` via Python scripting, consider the following example:
.. code:: Python
# Import the Mavlink backend module
from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend, MavlinkBackendConfig
# Create the multirotor configuration
# In this example we are showing the default parameters that are used if you do not specify them
mavlink_config = MavlinkBackendConfig({"vehicle_id": 0,
"connection_type": "tcpin",
"connection_ip": "localhost",
# The actual port that gets used = "connection_baseport" + "vehicle_id"
"connection_baseport": 4560,
"enable_lockstep": True,
"num_rotors": 4,
"input_offset": [0.0, 0.0, 0.0, 0.0],
"input_scaling": [1000.0, 1000.0, 1000.0, 1000.0],
"zero_position_armed": [100.0, 100.0, 100.0, 100.0],
"update_rate": 250.0,
# Settings for automatically launching PX4
# If px4_autolaunch==False, then "px4_dir" and "px4_vehicle_model" are unused
"px4_autolaunch": True,
"px4_dir": "PegasusInterface().px4_path",
"px4_vehicle_model": "iris",
})
config_multirotor.backends = [MavlinkBackend(mavlink_config)]
.. note::
In general, the Pegasus Simulator does not need to know where you have PX4 running to simulate the vehicle and send data
through ``MAVLink`` . However, if you intend to use the provided ``PX4 auto-launch`` feature, you must inform Pegasus Simulator
where you have your local install of PX4.
By default, the simulator expects PX4 to be located at ``~/PX4-Autopilot`` directory. You can set the default
path for the ``PX4-Autopilot`` by either:
1. Using the GUI of the Pegasus Simulator when operating in extension mode.
.. image:: /_static/pegasus_GUI_px4_dir.png
:width: 600px
:align: center
:alt: Setting the PX4 path
2. Use the methods provided by :class:`PegasusInterface`, i.e:
.. code:: Python
from pegasus.simulator.params import SIMULATION_ENVIRONMENTS
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
# Start the Pegasus Interface
pg = PegasusInterface()
# Set the default PX4 installation path used by the simulator
# This will be saved for future runs
pg.set_px4_path("path_to_px4_directory")
|
PegasusSimulator/PegasusSimulator/docs/source/features/environments.rst | Environments
============
At the moment, we only provide in the :ref:`Params` API a dictionary named ``SIMULATION_ENVIRONMENTS``
which stores the path to ``Isaac Sim`` pre-made worlds. As we update this simulation framework, expect
the list of default simulation environments to grow.
List of provided simulation environments
----------------------------------------
.. table::
:widths: 25 17
+----------------------------+--------------------------+
| World | Name |
+============================+==========================+
| |default_environment| | Default Environment |
+----------------------------+--------------------------+
| |black_gridroom| | Black Gridroom |
+----------------------------+--------------------------+
| |curved_gridroom| | Curved Gridroom |
+----------------------------+--------------------------+
| |hospital| | Hospital |
+----------------------------+--------------------------+
| |office| | Office |
+----------------------------+--------------------------+
| |simple_room| | Simple Room |
+----------------------------+--------------------------+
| |warehouse| | Warehouse |
+----------------------------+--------------------------+
| |warehouse_with_forklifts| | Warehouse with Forklifts |
+----------------------------+--------------------------+
| |warehouse_with_shelves| | Warehouse with Shelves |
+----------------------------+--------------------------+
| |full_warehouse| | Full Warehouse |
+----------------------------+--------------------------+
| |flat_plane| | Flat Plane |
+----------------------------+--------------------------+
| |rought_plane| | Rough Plane |
+----------------------------+--------------------------+
| |slope_plane| | Slope Plane |
+----------------------------+--------------------------+
| |stairs_plane| | Stairs Plane |
+----------------------------+--------------------------+
To spawn one of the provided environments when using the Pegasus Simulator
in standalone application mode, you can just add to your code:
.. code:: Python
from pegasus.simulator.params import SIMULATION_ENVIRONMENTS
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
# Start the Pegasus Interface
pg = PegasusInterface()
# Load the environment
pg.load_environment(SIMULATION_ENVIRONMENTS["Curved Gridroom"])
To index the dictionary of pre-made simulation environments, just use the names of the columns table.
.. note::
In this initial version it is not possible to spawn a custom 3D USD world using the Pegasus Simulator GUI.
If you use the Pegasus Simulator in extension mode and want to use your custom worlds, for now you need
manually drag and drop the assets into the viewport like a cavemen 👌️. This is for sure a feature in the :ref:`Roadmap`.
However, when using the Pegasus Simulator in standalone application mode, i.e. Python scripting,
you can load your own custom USD files using the ``load_environment(usd_path)`` method.
.. Definition of the image alias
.. |default_environment| image:: /_static/worlds/Default\ Environment.png
.. |black_gridroom| image:: /_static/worlds/Black\ Gridroom.png
.. |curved_gridroom| image:: /_static/worlds/Curved\ Gridroom.png
.. |hospital| image:: /_static/worlds/Hospital.png
.. |office| image:: /_static/worlds/Office.png
.. |simple_room| image:: /_static/worlds/Simple\ Room.png
.. |warehouse| image:: /_static/worlds/Warehouse.png
.. |warehouse_with_forklifts| image:: /_static/worlds/Warehouse\ with\ Forklifts.png
.. |warehouse_with_shelves| image:: /_static/worlds/Warehouse\ with\ Shelves.png
.. |full_warehouse| image:: /_static/worlds/Full\ Warehouse.png
.. |flat_plane| image:: /_static/worlds/Flat\ Plane.png
.. |rought_plane| image:: /_static/worlds/Rough\ Plane.png
.. |slope_plane| image:: /_static/worlds/Slope\ Plane.png
.. |stairs_plane| image:: /_static/worlds/Stairs\ Plane.png
Setting the Map Global Coordinates
----------------------------------
By default, the latitude, longitude and altitude of the origin of the simulated world
is set to the geographic coordinates of `Instituto Superior Técnico, Lisbon (Portugal)`, i.e.:
- **latitude=** 90.0 (º)
- **longitude=** 38.736832 (º)
- **altitude=** -9.137977 (m)
You can change the default coordinates by either:
1. Using the GUI of the Pegasus Simulator when operating in extension mode.
.. image:: /_static/features/setting_geographic_coordinates.png
:width: 600px
:align: center
:alt: Setting the geographic coordinates
2. Use the methods provided by :class:`PegasusInterface`, i.e:
.. code:: Python
from pegasus.simulator.params import SIMULATION_ENVIRONMENTS
from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface
# Start the Pegasus Interface
pg = PegasusInterface()
# Change only the global coordinates for this instance of the code
# Future code runs will keep the same default coordinates
pg.set_global_coordinates(latitude, longitude, altitude)
# Change the default global coordinates for the simulator
# This will be saved for future runs
pg.set_new_global_coordinates(latitude, longitude, altitude) |
PegasusSimulator/PegasusSimulator/docs/source/references/roadmap.rst | Roadmap
=======
In this section a basic feature roadmap is presented. The features in this roadmap are subject to
changes. There are no specific delivery dates nor priority table. Some of the unchecked features
might already be implemented but not yet documented.
If there is some feature missing that you would like to see added, please check the :ref:`Contributing` section.
* Supported sensors
* |check_| Baromter
* |check_| GPS
* |check_| IMU (Accelerometer + Gyroscope)
* |check_| Magnetometer
* |check_| Camera (Implemented as a Graph Node)
* |uncheck_| UDP Camera
* Supported actuators
* |check_| Quadratic Thrust Curve
* |uncheck_| Gimbal Control
* Base vehicles
* |check_| 3DR Iris
* |uncheck_| Typhoon
* |uncheck_| Fixed-wing plane
* |uncheck_| VTOL
* API backends
* |check_| Mavlink (with direct PX4 integration)
* |check_| Direct ROS 2 interface
* |uncheck_| Python backend for Reinforcement Learning (RL)
* UI
* |check_| Select from NVIDIA samples worlds
* |check_| Select from Pegasus sample vehicles
* |uncheck_| Support for custom vehicles in the UI dropdown
* |uncheck_| Support for custom worlds in the UI dropdown
* |uncheck_| Add an option to clone and compile PX4-Autopilot directly from the Pegasus Simulator UI
.. |check| raw:: html
<input checked="" type="checkbox">
.. |check_| raw:: html
<input checked="" disabled="" type="checkbox">
.. |uncheck| raw:: html
<input type="checkbox">
.. |uncheck_| raw:: html
<input disabled="" type="checkbox">
|
PegasusSimulator/PegasusSimulator/docs/source/references/changelog.rst | Changelog
=========
All notable changes to this project are documented in this file. The format is based on `Keep a Changelog <https://keepachangelog.com/en/1.0.0/>`__.
The changelog for the Pegasus Simulator is located in the ``docs`` directory of the extension. If you propose any changes to the project via Pull Requests, please also update the changelog file accordingly. Check the :ref:`Contributing` section for more informations.
.. include:: ../../../extensions/pegasus.simulator/docs/CHANGELOG.md
:parser: myst_parser.sphinx_
:start-line: 3 |
PegasusSimulator/PegasusSimulator/docs/source/references/known_issues.rst | Known Issues
============
ROS 2 control backend not-working properly
------------------------------------------
At the moment, the Isaac Sim support for ROS 2 Humble (Ubuntu 22.04LTS) is still a little bit shaky. Since this extension
was developed on Ubuntu 22.04LTS, I was not able to fully test this functionality yet. Therefore, ROS 2 control backend was
temporarily disabled in the GUI and the only control backend available when using Pegasus Simulator in extension mode is the PX4/MAVLink
one. This functionality will be re-activated as soon as it becomes stable. For the meantime, you can use the `ROS 2 interface
provided by the PX4 team <https://docs.px4.io/main/en/ros/ros2_comm.html>`__. |
PegasusSimulator/PegasusSimulator/docs/source/references/bibliography.rst | Bibliography
============
.. bibliography:: |
PegasusSimulator/PegasusSimulator/docs/source/references/license.rst | License
=======
Pegasus Simulator License
-------------------------
| The Pegasus Simulator is an open-source framework that follows a `BSD-3 Clause License <https://opensource.org/licenses/BSD-3-Clause/>`__.
| **Author and lead developer:** Marcelo Jacinto ([email protected])
.. code-block:: text
BSD 3-Clause License
Copyright (c) 2023, Pegasus Simulator, Marcelo Jacinto
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This framework is built on top of `NVIDIA Omniverse <https://docs.omniverse.nvidia.com/>`__ and `Isaac
Sim <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html>`__ which is made available for free under the
individual license. The license files for all the NVIDIA assets used in this framework are available in NVIDIA's `documentation <https://docs.omniverse.nvidia.com/app_isaacsim/common/licenses.html>`_.
3DR Iris Asset
--------------
.. include:: /licenses/assets/iris-license.rst |
PegasusSimulator/PegasusSimulator/docs/source/references/contributing.rst | Contributing
============
The Pegasus Simulator is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was
created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect
this repository to be mantained by me directly, hopefully until 2027.
With that said, it is very likely that you will stumble upon bugs on the code or missing features. Information on how
to contribute with code, documentation or suggestions for the project roadmap can be found in the following sections.
Issues, Bug Reporting and Feature Requests
------------------------------------------
- **Bug reports:** Report bugs you find in the Github Issue tab.
- **Feature requests:** Suggest new features you would like to see in the Github Discussions tab.
- **Code contributions:** Submit a Github Pull Request (read the next section).
Branch and Version Model
------------------------
This project uses a two-branch Git model:
- **main:** By default points to the latest stable tag version of the project.
- **dev:** Corresponds to an unstable versions of the code that are not well tested yet.
In this project, we avoid performing merges and give preference to a fork/pull-request structure. All code contributions
have to be made under the permissive BSD 3-clause license and all code must not impose any further constraints on the use.
Contributing with Code
----------------------
Please follow these steps to contribute with code:
1. Create an issue in Github issue tab to discuss new changes or additions to the code.
2. `Fork <https://docs.github.com/en/get-started/quickstart/fork-a-repo>`__ the repository.
3. `Create a new branch <https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-and-deleting-branches-within-your-repository>`__ for your changes.
4. Make your changes.
5. Run pre-commit on all files to make sure the code is well formated (check :ref:`Code Style` section).
6. Commit the changes following the guide in the :ref:`Commit Messages` section.
7. Update the documentation accordingly (check :ref:`Contributing with Documentation` section).
8. Push your changes to your forked repository.
9. `Submit a pull request <https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork>`__ to the main branch of this project.
10. Ensure all the checks on the pull request are successful.
After sending a pull request, the developer team will review your code, provide feedback.
.. note::
Ensure that your code is well-formatted, documented and working.
Commit Messages
~~~~~~~~~~~~~~~
Each commit message should be short and provide a good description of what is being changed or added to the code. As such,
we suggest that every commit message start by:
* ``feat``: For new features.
* ``fix``: For bug fixes.
* ``rem``: For removing code or features.
* ``doc``: For adding or changing documentation.
* ``chore``: When none of the above are a good fit.
Here is an example of a "good" commit:
.. code:: bash
git commit -m "feat: new vehicle thurster dynamics"
.. note::
We do not enforce strictly this commit policy, but it is highly recommended.
Pull Requests
~~~~~~~~~~~~~
The description of the Pull Request should include:
- An overview of what is adding, changing or removing; enough to understand the broad purpose of the code
- Links to related issues, supporting information or research papers (if useful).
- Information about what code testing has been conducted.
Code Style
~~~~~~~~~~
The inline code documentation follows the `Google Style Guides <https://google.github.io/styleguide/pyguide.html>`__ while the Python code follows the `PEP guidelines <https://peps.python.org/pep-0008/>`__. We use
the `pre-commit <https://pre-commit.com/>`__ tool tools for maintaining code quality and consistency over the codebase.
You can install ``pre-commit`` by running:
.. code:: bash
pip install pre-commit
If you do not want to polute your python environment, please use
`venv <https://docs.python.org/3/library/venv.html>`__ or `conda <https://docs.conda.io/en/latest/>`__.
To run ``pre-commit`` over the entire repository, execute:
.. code:: bash
pre-commit run --all-files
Contributing with Documentation
-------------------------------
I know, everyone hates to write documentation - its boring... but it is needed. That's why we tried
to make it easy to contribute to it.
All the source files for the documentation are located in the ``docs`` directory. The documentation is written in
`reStructuredText <https://www.sphinx-doc.org/en/master/>`__ format. We use Sphinx with the
`Read the Docs Theme <https://readthedocs.org/projects/sphinx/>`__ for generating the documentation. Sending a pull
request for the documentation is the same as sending a pull request for the codebase. Please follow the steps
mentioned in the :ref:`Contributing with Code` section.
To build the documentation, you need to install a few python
dependencies. If you do not want to polute your python environment, please use
`venv <https://docs.python.org/3/library/venv.html>`__ or `conda <https://docs.conda.io/en/latest/>`__.
To generate the html documentation, execute the following commands:
1. Enter the ``docs`` directory.
.. code:: bash
# (relative to the root of the repository)
cd docs
2. Install the python dependencies.
.. code:: bash
pip install -r requirements.txt
3. Build the documentation.
.. code:: bash
make html
4. Open the documentation in a browser.
.. code:: bash
xdg-open _build/html/index.html
Contributing with Assets
------------------------
Creating 3D models is an hard and time consuming task. We encourage people to share models that they feel will be usefull
for the community, as long as:
1. The assets are appropriately licensed.
2. They can be distributed in an open-source repository.
.. note::
Currently, we still do not have a standard approach for submitting open-source assets to be incorporated into Pegasus Simulator,
but a possible solution in the future might lie either on hosting small sized ones on this repository and large
worlds in a nucleus server. If you have a great idea regarding this subject, share it with us on the Github Issues tab!
Sponsor the project
-------------------
If you want to be a part of this project, or sponsor my work with some graphics cards, jetson developer boards and other development
material, please reach out to me directly at ``[email protected]``.
Current sponsors:
- Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS).
- Instituto Superior Técnico, Universidade de Lisboa
The work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para as Ciências e Tecnologias (FCT).
.. raw:: html
<p float="left" align="center">
<img src="../../_static/dsor_logo.png" width="90" align="center" />
<img src="../../_static/logo_isr.png" width="200" align="center"/>
<img src="../../_static/larsys_logo.png" width="200" align="center"/>
<img src="../../_static/ist_logo.png" width="200" align="center"/>
<img src="../../_static/logo_fct.png" width="200" align="center"/>
</p>
|
Conv-AI/ov_extension/CHANGELOG.md | # Changelog
All notable changes to this project will be documented in this file.
# Release 1.0.3
**Fixed**
- Extension failed to install on latest Omniverse apps.
# Release 1.0.2
**Improved**
- Action Graph for the demo stage.
# Release 1.0.1
**Fixed**
- UI bug preventing Convai window from appearing.
# Release 1.0.0
**Added**
- GRPC streaming for reduced latency.
- Demo stage with Nvidia character.
# Release 0.1.0-alpha
- Added REST APIs integration. |
Conv-AI/ov_extension/README.md | # Convai Omniverse Extension
## Introduction
The Convai Omniverse Extension provides seamless integration between [Convai](https://convai.com/) API and Omniverse, allowing users to connect their 3D character assets with intelligent conversational agents. With this extension, users can define their character's backstory and voice at Convai and easily connect the character using its character ID.
## Installation
To install the Convai Omniverse Extension, follow these steps:
1. Clone the latest version of the repo.
2. Open Omniverse app of your choice (e.g Code) and from the `Window` menu click `Extensions`.
3. In the extensions tab, click the gear icon in the top right.
<p align="left">
<img height="350" src="images/extensions.png?raw=true">
</p>
4. Click the green plus icon in the `Edit` column and add the absolute path to the `exts` folder found in the repository directory.
<p align="left">
<img height="350" src="images/SearchPath.png?raw=true">
</p>
5. Select the `Third Party` tab and search for `Convai` in the top left search bar, make sure to check `Enabled`.
<p align="left">
<img height="250" src="images/ConvaiSearch.png?raw=true">
</p>
6. The Convai window should appear, drag it and dock it in any suitable area of the UI.
7. If the Convai window does not appear, go to the `Window` menu and select `Convai` from the list.
## Configuration
To add your API Key and Character ID, follow these steps:
1. Sign up at [Convai](https://convai.com/).
2. On the website click the gear icon in the top-right corner of the playground then copy and paste the API key into the `Convai API Key` field in the Convai extension window.
3. Go to the [Dashboard](https://convai.com/pipeline/dashboard) and on the left panel and either create a new character or select a sample one.
4. Copy the Character ID and paste it in the `Character ID` field in the extension window.
## Actions:
Actions can be used to trigger events with the same name as the action in the `Action graph`. They can be used to run animations based on the action received. To try out actions:
1. Add a few comma seperated actions to `Comma seperated actions` field (e.g jump, kick, dance, etc.).
2. The character will select one of the actions based on the conversation and run any event with the same name as the action in the `Action Graph`.
## Running the Demo
1. Open your chosen Omniverse app (e.g., Code).
2. Go to `File->Open` and navigate to the repo directory.
3. Navigate to `<repo directory>/ConvaiDemoStage/ConvaiDemo.usd` and click `open it.
4. Click the `play` button from the `Toolbar` menu on the left.
<p align="left">
<img height="350" src="images/PlayToolbar.png?raw=true">
</p>
5. Click `Start Talking` in the `Convai` window to talk to the character then click `Stop` to send the request.
## Notes
- The extension is tested in Omniverse Code, but you are welcome to try it out in other apps as well.
- The demo stage includes only talk and idle animations. However, it is possible to add more animations and trigger them using the action selected by the character. More on that in the future. |
Conv-AI/ov_extension/exts/convai/convai/extension.py | import math, os
import asyncio
import numpy as np
import omni.ext
import carb.events
import omni.ui as ui
import configparser
import pyaudio
import grpc
from .rpc import service_pb2 as convai_service_msg
from .rpc import service_pb2_grpc as convai_service
from .convai_audio_player import ConvaiAudioPlayer
from typing import Generator
import io
from pydub import AudioSegment
import threading
import traceback
import time
from collections import deque
import random
from functools import partial
__location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 12000
def log(text: str, warning: bool =False):
print(f"[convai] {'[Warning]' if warning else ''} {text}")
class ConvaiExtension(omni.ext.IExt):
WINDOW_NAME = "Convai"
MENU_PATH = f"Window/{WINDOW_NAME}"
def on_startup(self, ext_id: str):
self.IsCapturingAudio = False
self.on_new_frame_sub = None
self.channel_address = None
self.channel = None
self.SessionID = None
self.channelState = grpc.ChannelConnectivity.IDLE
self.client = None
self.ConvaiGRPCGetResponseProxy = None
self.PyAudio = pyaudio.PyAudio()
self.stream = None
self.Tick = False
self.TickThread = None
self.ConvaiAudioPlayer = ConvaiAudioPlayer(self._on_start_talk_callback, self._on_stop_talk_callback)
self.LastReadyTranscription = ""
self.ResponseTextBuffer = ""
self.OldCharacterID = ""
self.response_UI_Label_text = ""
self.action_UI_Label_text = "<Action>"
self.transcription_UI_Label_text = ""
# self.response_UI_Label_text = "<Response will apear here>"
self.response_UI_Label_text = "" # Turn off response text due to unknown crash
self.StartTalking_Btn_text = "Start Talking"
self.StartTalking_Btn_state = True
self.UI_Lock = threading.Lock()
self.Mic_Lock = threading.Lock()
self.UI_update_counter = 0
self.on_new_update_sub = None
ui.Workspace.set_show_window_fn(ConvaiExtension.WINDOW_NAME, partial(self.show_window, None))
ui.Workspace.show_window(ConvaiExtension.WINDOW_NAME)
# # Put the new menu
editor_menu = omni.kit.ui.get_editor_menu()
if editor_menu:
self._menu = editor_menu.add_item(
ConvaiExtension.MENU_PATH, self.show_window, toggle=True, value=True
)
# self.show_window(None, True)
self.read_channel_address_from_config()
self.create_channel()
log("ConvaiExtension started")
def setup_UI(self):
self._window = ui.Window(ConvaiExtension.WINDOW_NAME, width=300, height=300)
self._window.set_visibility_changed_fn(self._visiblity_changed_fn)
with self._window.frame:
with ui.VStack():
with ui.HStack(height = ui.Length(30)):
l = ui.Label("Convai API key")
self.APIKey_input_UI = ui.StringField()
ui.Spacer(height=5)
with ui.HStack(height = ui.Length(30)):
l = ui.Label("Character ID")
self.CharID_input_UI = ui.StringField()
ui.Spacer(height=5)
# with ui.HStack(height = ui.Length(30)):
# l = ui.Label("Session(Leave empty for 1st time)")
# self.session_input_UI = ui.StringField()
# ui.Spacer(height=5)
with ui.HStack(height = ui.Length(30)):
l = ui.Label("Comma seperated actions")
self.actions_input_UI = ui.StringField()
self.actions_input_UI.set_tooltip("e.g. Dances, Jumps")
ui.Spacer(height=5)
# self.response_UI_Label = ui.Label("", height = ui.Length(60), word_wrap = True)
# self.response_UI_Label.alignment = ui.Alignment.CENTER
self.action_UI_Label = ui.Label("<Action>", height = ui.Length(30), word_wrap = False)
self.action_UI_Label.alignment = ui.Alignment.CENTER
ui.Spacer(height=5)
self.StartTalking_Btn = ui.Button("Start Talking", clicked_fn=lambda: self.on_start_talking_btn_click(), height = ui.Length(30))
self.transcription_UI_Label = ui.Label("", height = ui.Length(60), word_wrap = True)
self.transcription_UI_Label.alignment = ui.Alignment.CENTER
if self.on_new_update_sub is None:
self.on_new_update_sub = (
omni.kit.app.get_app()
.get_update_event_stream()
.create_subscription_to_pop(self._on_UI_update_event, name="convai new UI update")
)
self.read_UI_from_config()
return self._window
def _on_UI_update_event(self, e):
if self.UI_update_counter>1000:
self.UI_update_counter = 0
self.UI_update_counter += 1
if self._window is None:
return
if self.UI_Lock.locked():
log("UI_Lock is locked", 1)
return
with self.UI_Lock:
# self.response_UI_Label.text = str(self.response_UI_Label_text)
self.action_UI_Label.text = str(self.action_UI_Label_text)
self.transcription_UI_Label.text = str(self.transcription_UI_Label_text)
self.StartTalking_Btn.text = self.StartTalking_Btn_text
self.StartTalking_Btn.enabled = self.StartTalking_Btn_state
def start_tick(self):
if self.Tick:
log("Tick already started", 1)
return
self.Tick = True
self.TickThread = threading.Thread(target=self._on_tick)
self.TickThread.start()
def stop_tick(self):
if self.TickThread and self.Tick:
self.Tick = False
self.TickThread.join()
def read_channel_address_from_config(self):
config = configparser.ConfigParser()
config.read(os.path.join(__location__, 'convai.env'))
self.channel_address = config.get("CONVAI", "CHANNEL")
def read_UI_from_config(self):
config = configparser.ConfigParser()
config.read(os.path.join(__location__, 'convai.env'))
api_key = config.get("CONVAI", "API_KEY")
self.APIKey_input_UI.model.set_value(api_key)
character_id = config.get("CONVAI", "CHARACTER_ID")
self.CharID_input_UI.model.set_value(character_id)
actions_text = config.get("CONVAI", "ACTIONS")
self.actions_input_UI.model.set_value(actions_text)
def save_config(self):
config = configparser.ConfigParser()
config.read(os.path.join(__location__, 'convai.env'))
config.set("CONVAI", "API_KEY", self.APIKey_input_UI.model.get_value_as_string())
config.set("CONVAI", "CHARACTER_ID", self.CharID_input_UI.model.get_value_as_string())
config.set("CONVAI", "ACTIONS", self.actions_input_UI.model.get_value_as_string())
# config.set("CONVAI", "CHANNEL", self.channel_address)
with open(os.path.join(__location__, 'convai.env'), 'w') as file:
config.write(file)
def create_channel(self):
if (self.channel):
log("gRPC channel already created")
return
self.channel = grpc.secure_channel(self.channel_address, grpc.ssl_channel_credentials())
# self.channel.subscribe(self.on_channel_state_change, True)
log("Created gRPC channel")
def close_channel(self):
if (self.channel):
self.channel.close()
self.channel = None
log("close_channel - Closed gRPC channel")
else:
log("close_channel - gRPC channel already closed")
def on_start_talking_btn_click(self):
if (self.IsCapturingAudio):
# Change UI
with self.UI_Lock:
self.StartTalking_Btn_text = "Processing..."
# self.StartTalking_Btn_text = "Start Talking"
self.StartTalking_Btn_state = False
# Reset response UI text
self.response_UI_Label_text = ""
# Do one last mic read
self.read_mic_and_send_to_grpc(True)
# time.sleep(0.01)
# Stop Mic
self.stop_mic()
else:
# Reset Session ID if Character ID changes
if self.OldCharacterID != self.CharID_input_UI.model.get_value_as_string():
self.OldCharacterID = self.CharID_input_UI.model.get_value_as_string()
self.SessionID = ""
with self.UI_Lock:
# Reset transcription UI text
self.transcription_UI_Label_text = ""
self.LastReadyTranscription = ""
# Change Btn text
self.StartTalking_Btn_text = "Stop"
# Open Mic stream
self.start_mic()
# Stop any on-going audio
self.ConvaiAudioPlayer.stop()
# Save API key, character ID and session ID
self.save_config()
# Create gRPC stream
self.ConvaiGRPCGetResponseProxy = ConvaiGRPCGetResponseProxy(self)
def on_shutdown(self):
self.clean_grpc_stream()
self.close_channel()
self.stop_tick()
if self._menu:
self._menu = None
if self._window:
self._window.destroy()
self._window = None
# Deregister the function that shows the window from omni.ui
ui.Workspace.set_show_window_fn(ConvaiExtension.WINDOW_NAME, None)
log("ConvaiExtension shutdown")
def start_mic(self):
if self.IsCapturingAudio == True:
log("start_mic - mic is already capturing audio", 1)
return
self.stream = self.PyAudio.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
self.IsCapturingAudio = True
self.start_tick()
log("start_mic - Started Recording")
def stop_mic(self):
if self.IsCapturingAudio == False:
log("stop_mic - mic has not started yet", 1)
return
self.stop_tick()
if self.stream:
self.stream.stop_stream()
self.stream.close()
else:
log("stop_mic - could not close mic stream since it is None", 1)
self.IsCapturingAudio = False
log("stop_mic - Stopped Recording")
def clean_grpc_stream(self):
if self.ConvaiGRPCGetResponseProxy:
self.ConvaiGRPCGetResponseProxy.Parent = None
del self.ConvaiGRPCGetResponseProxy
self.ConvaiGRPCGetResponseProxy = None
# self.close_channel()
def on_transcription_received(self, Transcription: str, IsTranscriptionReady: bool, IsFinal: bool):
'''
Called when user transcription is received
'''
self.UI_Lock.acquire()
self.transcription_UI_Label_text = self.LastReadyTranscription + " " + Transcription
self.UI_Lock.release()
if IsTranscriptionReady:
self.LastReadyTranscription = self.LastReadyTranscription + " " + Transcription
def on_data_received(self, ReceivedText: str, ReceivedAudio: bytes, SampleRate: int, IsFinal: bool):
'''
Called when new text and/or Audio data is received
'''
self.ResponseTextBuffer += str(ReceivedText)
if IsFinal:
with self.UI_Lock:
self.response_UI_Label_text = self.ResponseTextBuffer
self.transcription_UI_Label_text = self.ResponseTextBuffer
self.ResponseTextBuffer = ""
self.ConvaiAudioPlayer.append_to_stream(ReceivedAudio)
return
def on_actions_received(self, Action: str):
'''
Called when actions are received
'''
# Action.replace(".", "")
self.UI_Lock.acquire()
for InputAction in self.parse_actions():
# log (f"on_actions_received: {Action} - {InputAction} - {InputAction.find(Action)}")
if Action.find(InputAction) >= 0:
self.action_UI_Label_text = InputAction
self.fire_event(InputAction)
self.UI_Lock.release()
return
self.action_UI_Label_text = "None"
self.UI_Lock.release()
def on_session_ID_received(self, SessionID: str):
'''
Called when new SessionID is received
'''
self.SessionID = SessionID
def on_finish(self):
'''
Called when the response stream is done
'''
self.ConvaiGRPCGetResponseProxy = None
with self.UI_Lock:
self.StartTalking_Btn_text = "Start Talking"
self.StartTalking_Btn_state = True
self.clean_grpc_stream()
log("Received on_finish")
def on_failure(self, ErrorMessage: str):
'''
Called when there is an unsuccessful response
'''
log(f"on_failure called with message: {ErrorMessage}", 1)
with self.UI_Lock:
self.transcription_UI_Label_text = "ERROR: Please double check API key and the character ID - Send logs to [email protected] for further assistance."
self.stop_mic()
self.on_finish()
def _on_tick(self):
while self.Tick:
time.sleep(0.1)
if self.IsCapturingAudio == False or self.ConvaiGRPCGetResponseProxy is None:
continue
self.read_mic_and_send_to_grpc(False)
def _on_start_talk_callback(self):
self.fire_event("start")
log("Character Started Talking")
def _on_stop_talk_callback(self):
self.fire_event("stop")
log("Character Stopped Talking")
def read_mic_and_send_to_grpc(self, LastWrite):
with self.Mic_Lock:
if self.stream:
data = self.stream.read(CHUNK)
else:
log("read_mic_and_send_to_grpc - could not read mic stream since it is none", 1)
data = bytes()
if self.ConvaiGRPCGetResponseProxy:
self.ConvaiGRPCGetResponseProxy.write_audio_data_to_send(data, LastWrite)
else:
log("read_mic_and_send_to_grpc - ConvaiGRPCGetResponseProxy is not valid", 1)
def fire_event(self, event_name):
def registered_event_name(event_name):
"""Returns the internal name used for the given custom event name"""
n = "omni.graph.action." + event_name
return carb.events.type_from_string(n)
reg_event_name = registered_event_name(event_name)
message_bus = omni.kit.app.get_app().get_message_bus_event_stream()
message_bus.push(reg_event_name, payload={})
def parse_actions(self):
actions = ["None"] + self.actions_input_UI.model.get_value_as_string().split(',')
actions = [a.lstrip(" ").rstrip(" ") for a in actions]
return actions
def show_window(self, menu, value):
# with self.UI_Lock:
if value:
self.setup_UI()
self._window.set_visibility_changed_fn(self._visiblity_changed_fn)
else:
if self._window:
self._window.visible = False
def _visiblity_changed_fn(self, visible):
# with self.UI_Lock:
# Called when the user pressed "X"
self._set_menu(visible)
if not visible:
# Destroy the window, since we are creating new window
# in show_window
asyncio.ensure_future(self._destroy_window_async())
def _set_menu(self, value):
"""Set the menu to create this window on and off"""
editor_menu = omni.kit.ui.get_editor_menu()
if editor_menu:
editor_menu.set_value(ConvaiExtension.MENU_PATH, value)
async def _destroy_window_async(self):
# with self.UI_Lock:
# wait one frame, this is due to the one frame defer
# in Window::_moveToMainOSWindow()
await omni.kit.app.get_app().next_update_async()
if self._window:
self._window.destroy()
self._window = None
class ConvaiGRPCGetResponseProxy:
def __init__(self, Parent: ConvaiExtension):
self.Parent = Parent
self.AudioBuffer = deque(maxlen=4096*2)
self.InformOnDataReceived = False
self.LastWriteReceived = False
self.client = None
self.NumberOfAudioBytesSent = 0
self.call = None
self._write_task = None
self._read_task = None
# self._main_task = asyncio.ensure_future(self.activate())
self.activate()
log("ConvaiGRPCGetResponseProxy constructor")
def activate(self):
# Validate API key
if (len(self.Parent.APIKey_input_UI.model.get_value_as_string()) == 0):
self.Parent.on_failure("API key is empty")
return
# Validate Character ID
if (len(self.Parent.CharID_input_UI.model.get_value_as_string()) == 0):
self.Parent.on_failure("Character ID is empty")
return
# Validate Channel
if self.Parent.channel is None:
log("grpc - self.Parent.channel is None", 1)
self.Parent.on_failure("gRPC channel was not created")
return
# Create the stub
self.client = convai_service.ConvaiServiceStub(self.Parent.channel)
threading.Thread(target=self.init_stream).start()
def init_stream(self):
log("grpc - stream initialized")
try:
for response in self.client.GetResponse(self.create_getGetResponseRequests()):
if response.HasField("audio_response"):
log("gRPC - audio_response: {} {} {}".format(response.audio_response.audio_config, response.audio_response.text_data, response.audio_response.end_of_response))
log("gRPC - session_id: {}".format(response.session_id))
self.Parent.on_session_ID_received(response.session_id)
self.Parent.on_data_received(
response.audio_response.text_data,
response.audio_response.audio_data,
response.audio_response.audio_config.sample_rate_hertz,
response.audio_response.end_of_response)
elif response.HasField("action_response"):
log(f"gRPC - action_response: {response.action_response.action}")
self.Parent.on_actions_received(response.action_response.action)
elif response.HasField("user_query"):
log(f"gRPC - user_query: {response.user_query}")
self.Parent.on_transcription_received(response.user_query.text_data, response.user_query.is_final, response.user_query.end_of_response)
else:
log("Stream Message: {}".format(response))
time.sleep(0.1)
except Exception as e:
if 'response' in locals() and response is not None and response.HasField("audio_response"):
self.Parent.on_failure(f"gRPC - Exception caught in loop: {str(e)} - Stream Message: {response}")
else:
self.Parent.on_failure(f"gRPC - Exception caught in loop: {str(e)}")
traceback.print_exc()
return
self.Parent.on_finish()
def create_initial_GetResponseRequest(self)-> convai_service_msg.GetResponseRequest:
action_config = convai_service_msg.ActionConfig(
classification = 'singlestep',
context_level = 1
)
action_config.actions[:] = self.Parent.parse_actions()
action_config.objects.append(
convai_service_msg.ActionConfig.Object(
name = "dummy",
description = "A dummy object."
)
)
log(f"gRPC - actions parsed: {action_config.actions}")
action_config.characters.append(
convai_service_msg.ActionConfig.Character(
name = "User",
bio = "Person playing the game and asking questions."
)
)
get_response_config = convai_service_msg.GetResponseRequest.GetResponseConfig(
character_id = self.Parent.CharID_input_UI.model.get_value_as_string(),
api_key = self.Parent.APIKey_input_UI.model.get_value_as_string(),
audio_config = convai_service_msg.AudioConfig(
sample_rate_hertz = RATE
),
action_config = action_config
)
if self.Parent.SessionID and self.Parent.SessionID != "":
get_response_config.session_id = self.Parent.SessionID
return convai_service_msg.GetResponseRequest(get_response_config = get_response_config)
def create_getGetResponseRequests(self)-> Generator[convai_service_msg.GetResponseRequest, None, None]:
req = self.create_initial_GetResponseRequest()
yield req
# for i in range(0, 10):
while 1:
IsThisTheFinalWrite = False
GetResponseData = None
if (0): # check if this is a text request
pass
else:
data, IsThisTheFinalWrite = self.consume_from_audio_buffer()
if len(data) == 0 and IsThisTheFinalWrite == False:
time.sleep(0.05)
continue
# Load the audio data to the request
self.NumberOfAudioBytesSent += len(data)
# if len(data):
# log(f"len(data) = {len(data)}")
GetResponseData = convai_service_msg.GetResponseRequest.GetResponseData(audio_data = data)
# Prepare the request
req = convai_service_msg.GetResponseRequest(get_response_data = GetResponseData)
yield req
if IsThisTheFinalWrite:
log(f"gRPC - Done Writing - {self.NumberOfAudioBytesSent} audio bytes sent")
break
time.sleep(0.1)
def write_audio_data_to_send(self, Data: bytes, LastWrite: bool):
self.AudioBuffer.append(Data)
if LastWrite:
self.LastWriteReceived = True
log(f"gRPC LastWriteReceived")
# if self.InformOnDataReceived:
# # Inform of new data to send
# self._write_task = asyncio.ensure_future(self.write_stream())
# # Reset
# self.InformOnDataReceived = False
def finish_writing(self):
self.write_audio_data_to_send(bytes(), True)
def consume_from_audio_buffer(self):
Length = len(self.AudioBuffer)
IsThisTheFinalWrite = False
data = bytes()
if Length:
data = self.AudioBuffer.pop()
# self.AudioBuffer = bytes()
if self.LastWriteReceived and Length == 0:
IsThisTheFinalWrite = True
else:
IsThisTheFinalWrite = False
if IsThisTheFinalWrite:
log(f"gRPC Consuming last mic write")
return data, IsThisTheFinalWrite
def __del__(self):
self.Parent = None
# if self._main_task:
# self._main_task.cancel()
# if self._write_task:
# self._write_task.cancel()
# if self._read_task:
# self._read_task.cancel()
# if self.call:
# self.call.cancel()
log("ConvaiGRPCGetResponseProxy Destructor")
|
Conv-AI/ov_extension/exts/convai/convai/__init__.py | from .extension import *
|
Conv-AI/ov_extension/exts/convai/convai/convai_audio_player.py | # from .extension import ConvaiExtension, log
# from test import ConvaiExtension, log
import pyaudio
from pydub import AudioSegment
import io
class ConvaiAudioPlayer:
def __init__(self, start_taking_callback, stop_talking_callback):
self.start_talking_callback = start_taking_callback
self.stop_talking_callback = stop_talking_callback
self.AudioSegment = None
self.pa = pyaudio.PyAudio()
self.pa_stream = None
self.IsPlaying = False
def append_to_stream(self, data: bytes):
segment = AudioSegment.from_wav(io.BytesIO(data)).fade_in(100).fade_out(100)
if self.AudioSegment is None:
self.AudioSegment = segment
else:
self.AudioSegment._data += segment._data
self.play()
def play(self):
if self.IsPlaying:
return
print("ConvaiAudioPlayer - Started playing")
self.start_talking_callback()
self.pa_stream = self.pa.open(
format=pyaudio.get_format_from_width(self.AudioSegment.sample_width),
channels=self.AudioSegment.channels,
rate=self.AudioSegment.frame_rate,
output=True,
stream_callback=self.stream_callback
)
self.IsPlaying = True
def pause(self):
'''
Pause playing
'''
self.IsPlaying = False
def stop(self):
'''
Pause playing and clear audio
'''
self.pause()
self.AudioSegment = None
def stream_callback(self, in_data, frame_count, time_info, status_flags):
if not self.IsPlaying:
frames = bytes()
else:
frames = self.consume_frames(frame_count)
if self.AudioSegment and len(frames) < frame_count*self.AudioSegment.frame_width:
print("ConvaiAudioPlayer - Stopped playing")
self.stop_talking_callback()
self.IsPlaying = False
return frames, pyaudio.paComplete
else:
return frames, pyaudio.paContinue
def consume_frames(self, count: int):
if self.AudioSegment is None:
return bytes()
FrameEnd = self.AudioSegment.frame_width*count
if FrameEnd > len(self.AudioSegment._data):
return bytes()
FramesToReturn = self.AudioSegment._data[0:FrameEnd]
if FrameEnd == len(self.AudioSegment._data):
self.AudioSegment._data = bytes()
else:
self.AudioSegment._data = self.AudioSegment._data[FrameEnd:]
# print("self.AudioSegment._data = self.AudioSegment._data[FrameEnd:]")
return FramesToReturn
if __name__ == '__main__':
import time
import pyaudio
import grpc
from rpc import service_pb2 as convai_service_msg
from rpc import service_pb2_grpc as convai_service
from typing import Generator
import io
from pydub import AudioSegment
import configparser
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
RECORD_SECONDS = 3
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
audio_player = ConvaiAudioPlayer(None)
def start_mic():
global stream
stream = PyAudio.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
print("start_mic - Started Recording")
def stop_mic():
global stream
if stream:
stream.stop_stream()
stream.close()
else:
print("stop_mic - could not close mic stream since it is None")
return
print("stop_mic - Stopped Recording")
def getGetResponseRequests(api_key: str, character_id: str, session_id: str = "") -> Generator[convai_service_msg.GetResponseRequest, None, None]:
action_config = convai_service_msg.ActionConfig(
classification = 'multistep',
context_level = 1
)
action_config.actions[:] = ["fetch", "jump", "dance", "swim"]
action_config.objects.append(
convai_service_msg.ActionConfig.Object(
name = "ball",
description = "A round object that can bounce around."
)
)
action_config.objects.append(
convai_service_msg.ActionConfig.Object(
name = "water",
description = "Liquid found in oceans, seas and rivers that you can swim in. You can also drink it."
)
)
action_config.characters.append(
convai_service_msg.ActionConfig.Character(
name = "User",
bio = "Person playing the game and asking questions."
)
)
action_config.characters.append(
convai_service_msg.ActionConfig.Character(
name = "Learno",
bio = "A medieval farmer from a small village."
)
)
get_response_config = convai_service_msg.GetResponseRequest.GetResponseConfig(
character_id = character_id,
api_key = api_key,
audio_config = convai_service_msg.AudioConfig(
sample_rate_hertz = 16000
),
action_config = action_config
)
# session_id = "f50b7bf00ad50f5c2c22065965948c16"
if session_id != "":
get_response_config.session_id = session_id
yield convai_service_msg.GetResponseRequest(
get_response_config = get_response_config
)
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
yield convai_service_msg.GetResponseRequest(
get_response_data = convai_service_msg.GetResponseRequest.GetResponseData(
audio_data = data
)
)
stream.stop_stream()
stream.close()
print("* recording stopped")
config = configparser.ConfigParser()
config.read("exts\convai\convai\convai.env")
api_key = config.get("CONVAI", "API_KEY")
character_id = config.get("CONVAI", "CHARACTER_ID")
channel_address = config.get("CONVAI", "CHANNEL")
channel = grpc.secure_channel(channel_address, grpc.ssl_channel_credentials())
client = convai_service.ConvaiServiceStub(channel)
for response in client.GetResponse(getGetResponseRequests(api_key, character_id)):
if response.HasField("audio_response"):
print("Stream Message: {} {} {}".format(response.session_id, response.audio_response.audio_config, response.audio_response.text_data))
audio_player.append_to_stream(response.audio_response.audio_data)
else:
print("Stream Message: {}".format(response))
p.terminate()
# start_mic()
time.sleep(10)
# while 1:
# audio_player = ConvaiAudioPlayer(None)
# # data = stream.read(CHUNK)
# # _, data = scipy.io.wavfile.read("F:/Work/Convai/Tests/Welcome.wav")
# f = open("F:/Work/Convai/Tests/Welcome.wav", "rb")
# data = f.read()
# print(type(data))
# audio_player.append_to_stream(data)
# time.sleep(0.2)
# break
# # stop_mic()
# time.sleep(2)
# with keyboard.Listener(on_press=on_press,on_release=on_release):
# while(1):
# time.sleep(0.1)
# continue
# print("running") |
Conv-AI/ov_extension/exts/convai/convai/rpc/service_pb2.py | # -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: service.proto
"""Generated protocol buffer code."""
from google.protobuf.internal import builder as _builder
from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rservice.proto\x12\x07service\"(\n\x0b\x41udioConfig\x12\x19\n\x11sample_rate_hertz\x18\x01 \x01(\x05\"\x87\x02\n\x0c\x41\x63tionConfig\x12\x0f\n\x07\x61\x63tions\x18\x01 \x03(\t\x12\x33\n\ncharacters\x18\x02 \x03(\x0b\x32\x1f.service.ActionConfig.Character\x12-\n\x07objects\x18\x03 \x03(\x0b\x32\x1c.service.ActionConfig.Object\x12\x16\n\x0e\x63lassification\x18\x04 \x01(\t\x12\x15\n\rcontext_level\x18\x05 \x01(\x05\x1a&\n\tCharacter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0b\n\x03\x62io\x18\x02 \x01(\t\x1a+\n\x06Object\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\"a\n\nSTTRequest\x12,\n\x0c\x61udio_config\x18\x01 \x01(\x0b\x32\x14.service.AudioConfigH\x00\x12\x15\n\x0b\x61udio_chunk\x18\x02 \x01(\x0cH\x00\x42\x0e\n\x0crequest_type\"\x1b\n\x0bSTTResponse\x12\x0c\n\x04text\x18\x01 \x01(\t\"\xc4\x03\n\x12GetResponseRequest\x12L\n\x13get_response_config\x18\x01 \x01(\x0b\x32-.service.GetResponseRequest.GetResponseConfigH\x00\x12H\n\x11get_response_data\x18\x02 \x01(\x0b\x32+.service.GetResponseRequest.GetResponseDataH\x00\x1a\xb9\x01\n\x11GetResponseConfig\x12\x14\n\x0c\x63haracter_id\x18\x02 \x01(\t\x12\x0f\n\x07\x61pi_key\x18\x03 \x01(\t\x12\x12\n\nsession_id\x18\x04 \x01(\t\x12*\n\x0c\x61udio_config\x18\x05 \x01(\x0b\x32\x14.service.AudioConfig\x12,\n\raction_config\x18\x06 \x01(\x0b\x32\x15.service.ActionConfig\x12\x0f\n\x07speaker\x18\x07 \x01(\t\x1aJ\n\x0fGetResponseData\x12\x14\n\naudio_data\x18\x01 \x01(\x0cH\x00\x12\x13\n\ttext_data\x18\x02 \x01(\tH\x00\x42\x0c\n\ninput_typeB\x0e\n\x0crequest_type\"\x84\x01\n\x18GetResponseRequestSingle\x12\x34\n\x0fresponse_config\x18\x01 \x01(\x0b\x32\x1b.service.GetResponseRequest\x12\x32\n\rresponse_data\x18\x02 \x01(\x0b\x32\x1b.service.GetResponseRequest\"\x8f\x04\n\x13GetResponseResponse\x12\x12\n\nsession_id\x18\x01 \x01(\t\x12\x46\n\x0f\x61\x63tion_response\x18\x02 \x01(\x0b\x32+.service.GetResponseResponse.ActionResponseH\x00\x12\x44\n\x0e\x61udio_response\x18\x03 \x01(\x0b\x32*.service.GetResponseResponse.AudioResponseH\x00\x12\x13\n\tdebug_log\x18\x04 \x01(\tH\x00\x12\x41\n\nuser_query\x18\x05 \x01(\x0b\x32+.service.GetResponseResponse.UserTranscriptH\x00\x1a{\n\rAudioResponse\x12\x12\n\naudio_data\x18\x01 \x01(\x0c\x12*\n\x0c\x61udio_config\x18\x02 \x01(\x0b\x32\x14.service.AudioConfig\x12\x11\n\ttext_data\x18\x03 \x01(\t\x12\x17\n\x0f\x65nd_of_response\x18\x04 \x01(\x08\x1a \n\x0e\x41\x63tionResponse\x12\x0e\n\x06\x61\x63tion\x18\x01 \x01(\t\x1aN\n\x0eUserTranscript\x12\x11\n\ttext_data\x18\x01 \x01(\t\x12\x10\n\x08is_final\x18\x02 \x01(\x08\x12\x17\n\x0f\x65nd_of_response\x18\x03 \x01(\x08\x42\x0f\n\rresponse_type\"\x1c\n\x0cHelloRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\" \n\rHelloResponse\x12\x0f\n\x07message\x18\x01 \x01(\t2\xf8\x02\n\rConvaiService\x12\x38\n\x05Hello\x12\x15.service.HelloRequest\x1a\x16.service.HelloResponse\"\x00\x12\x42\n\x0bHelloStream\x12\x15.service.HelloRequest\x1a\x16.service.HelloResponse\"\x00(\x01\x30\x01\x12?\n\x0cSpeechToText\x12\x13.service.STTRequest\x1a\x14.service.STTResponse\"\x00(\x01\x30\x01\x12N\n\x0bGetResponse\x12\x1b.service.GetResponseRequest\x1a\x1c.service.GetResponseResponse\"\x00(\x01\x30\x01\x12X\n\x11GetResponseSingle\x12!.service.GetResponseRequestSingle\x1a\x1c.service.GetResponseResponse\"\x00\x30\x01\x62\x06proto3')
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'service_pb2', globals())
if _descriptor._USE_C_DESCRIPTORS == False:
DESCRIPTOR._options = None
_AUDIOCONFIG._serialized_start=26
_AUDIOCONFIG._serialized_end=66
_ACTIONCONFIG._serialized_start=69
_ACTIONCONFIG._serialized_end=332
_ACTIONCONFIG_CHARACTER._serialized_start=249
_ACTIONCONFIG_CHARACTER._serialized_end=287
_ACTIONCONFIG_OBJECT._serialized_start=289
_ACTIONCONFIG_OBJECT._serialized_end=332
_STTREQUEST._serialized_start=334
_STTREQUEST._serialized_end=431
_STTRESPONSE._serialized_start=433
_STTRESPONSE._serialized_end=460
_GETRESPONSEREQUEST._serialized_start=463
_GETRESPONSEREQUEST._serialized_end=915
_GETRESPONSEREQUEST_GETRESPONSECONFIG._serialized_start=638
_GETRESPONSEREQUEST_GETRESPONSECONFIG._serialized_end=823
_GETRESPONSEREQUEST_GETRESPONSEDATA._serialized_start=825
_GETRESPONSEREQUEST_GETRESPONSEDATA._serialized_end=899
_GETRESPONSEREQUESTSINGLE._serialized_start=918
_GETRESPONSEREQUESTSINGLE._serialized_end=1050
_GETRESPONSERESPONSE._serialized_start=1053
_GETRESPONSERESPONSE._serialized_end=1580
_GETRESPONSERESPONSE_AUDIORESPONSE._serialized_start=1326
_GETRESPONSERESPONSE_AUDIORESPONSE._serialized_end=1449
_GETRESPONSERESPONSE_ACTIONRESPONSE._serialized_start=1451
_GETRESPONSERESPONSE_ACTIONRESPONSE._serialized_end=1483
_GETRESPONSERESPONSE_USERTRANSCRIPT._serialized_start=1485
_GETRESPONSERESPONSE_USERTRANSCRIPT._serialized_end=1563
_HELLOREQUEST._serialized_start=1582
_HELLOREQUEST._serialized_end=1610
_HELLORESPONSE._serialized_start=1612
_HELLORESPONSE._serialized_end=1644
_CONVAISERVICE._serialized_start=1647
_CONVAISERVICE._serialized_end=2023
# @@protoc_insertion_point(module_scope)
|
Conv-AI/ov_extension/exts/convai/convai/rpc/service_pb2_grpc.py | # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
from . import service_pb2 as service__pb2
class ConvaiServiceStub(object):
"""Missing associated documentation comment in .proto file."""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.Hello = channel.unary_unary(
'/service.ConvaiService/Hello',
request_serializer=service__pb2.HelloRequest.SerializeToString,
response_deserializer=service__pb2.HelloResponse.FromString,
)
self.HelloStream = channel.stream_stream(
'/service.ConvaiService/HelloStream',
request_serializer=service__pb2.HelloRequest.SerializeToString,
response_deserializer=service__pb2.HelloResponse.FromString,
)
self.SpeechToText = channel.stream_stream(
'/service.ConvaiService/SpeechToText',
request_serializer=service__pb2.STTRequest.SerializeToString,
response_deserializer=service__pb2.STTResponse.FromString,
)
self.GetResponse = channel.stream_stream(
'/service.ConvaiService/GetResponse',
request_serializer=service__pb2.GetResponseRequest.SerializeToString,
response_deserializer=service__pb2.GetResponseResponse.FromString,
)
self.GetResponseSingle = channel.unary_stream(
'/service.ConvaiService/GetResponseSingle',
request_serializer=service__pb2.GetResponseRequestSingle.SerializeToString,
response_deserializer=service__pb2.GetResponseResponse.FromString,
)
class ConvaiServiceServicer(object):
"""Missing associated documentation comment in .proto file."""
def Hello(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def HelloStream(self, request_iterator, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def SpeechToText(self, request_iterator, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GetResponse(self, request_iterator, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GetResponseSingle(self, request, context):
"""Missing associated documentation comment in .proto file."""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_ConvaiServiceServicer_to_server(servicer, server):
rpc_method_handlers = {
'Hello': grpc.unary_unary_rpc_method_handler(
servicer.Hello,
request_deserializer=service__pb2.HelloRequest.FromString,
response_serializer=service__pb2.HelloResponse.SerializeToString,
),
'HelloStream': grpc.stream_stream_rpc_method_handler(
servicer.HelloStream,
request_deserializer=service__pb2.HelloRequest.FromString,
response_serializer=service__pb2.HelloResponse.SerializeToString,
),
'SpeechToText': grpc.stream_stream_rpc_method_handler(
servicer.SpeechToText,
request_deserializer=service__pb2.STTRequest.FromString,
response_serializer=service__pb2.STTResponse.SerializeToString,
),
'GetResponse': grpc.stream_stream_rpc_method_handler(
servicer.GetResponse,
request_deserializer=service__pb2.GetResponseRequest.FromString,
response_serializer=service__pb2.GetResponseResponse.SerializeToString,
),
'GetResponseSingle': grpc.unary_stream_rpc_method_handler(
servicer.GetResponseSingle,
request_deserializer=service__pb2.GetResponseRequestSingle.FromString,
response_serializer=service__pb2.GetResponseResponse.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'service.ConvaiService', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
# This class is part of an EXPERIMENTAL API.
class ConvaiService(object):
"""Missing associated documentation comment in .proto file."""
@staticmethod
def Hello(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(request, target, '/service.ConvaiService/Hello',
service__pb2.HelloRequest.SerializeToString,
service__pb2.HelloResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def HelloStream(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/service.ConvaiService/HelloStream',
service__pb2.HelloRequest.SerializeToString,
service__pb2.HelloResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def SpeechToText(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/service.ConvaiService/SpeechToText',
service__pb2.STTRequest.SerializeToString,
service__pb2.STTResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def GetResponse(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/service.ConvaiService/GetResponse',
service__pb2.GetResponseRequest.SerializeToString,
service__pb2.GetResponseResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def GetResponseSingle(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(request, target, '/service.ConvaiService/GetResponseSingle',
service__pb2.GetResponseRequestSingle.SerializeToString,
service__pb2.GetResponseResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
Conv-AI/ov_extension/exts/convai/convai/rpc/__init__.py | |
Conv-AI/ov_extension/exts/convai/config/extension.toml | [python.pipapi]
# Commands passed to pip install before extension gets enabled. Can also contain flags, like `--upgrade`, `--no--index`, etc.
# Refer to: https://pip.pypa.io/en/stable/reference/requirements-file-format/
requirements = [
"scipy",
"wavio",
"sounddevice",
"requests",
"googleapis-common-protos",
"grpcio==1.51.1",
"grpcio-tools==1.51.1",
"protobuf==4.21.10",
"PyAudio==0.2.12",
"pydub==0.25.1"
]
# Allow going to online index. Required to be set to true for pip install call.
use_online_index = true
# Ignore import check for modules.
ignore_import_check = false
[package]
# Semantic Versionning is used: https://semver.org/
version = "1.0.3"
# The title and description fields are primarily for displaying extension info in UI
title = "Convai"
description="Integrate Convai API with Omniverse."
icon = "data/icon.png"
preview_image = "data/preview.png"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
feature = true
# URL of the extension source repository.
repository = "https://github.com/Conv-AI/ov_extension"
# One of categories for UI.
category = "Convai"
# Keywords for the extension
keywords = ["kit", "convai", "chatgpt", "chatbot"]
# Use omni.ui to build simple UI
[dependencies]
"omni.kit.uiapp" = {}
"omni.anim.graph.bundle" = {}
# Main python module this extension provides, it will be publicly available as "import convai".
[[python.module]]
name = "convai"
|
Conv-AI/ov_extension/exts/convai/docs/README.md | # Convai Omniverse Extension
## Introduction
The Convai Omniverse Extension provides seamless integration between [Convai](https://convai.com/) API and Omniverse, allowing users to connect their 3D character assets with intelligent conversational agents. With this extension, users can define their character's backstory and voice at Convai and easily connect the character using its character ID.
## Installation
To install the Convai Omniverse Extension, follow these steps:
1. Clone the latest version of the repo.
2. Open Omniverse app of your choice (e.g Code) and from the `Window` menu click `Extensions`.
3. In the extensions tab, click the gear icon in the top right.
<p align="left">
<img height="350" src="images/extensions.png?raw=true">
</p>
4. Click the green plus icon in the `Edit` column and add the absolute path to the `exts` folder found in the repository directory.
<p align="left">
<img height="350" src="images/SearchPath.png?raw=true">
</p>
5. Select the `Third Party` tab and search for `Convai` in the top left search bar, make sure to check `Enabled` - Note: This will freeze Omniverse for a 1-2 minutes.
<p align="left">
<img height="250" src="images/ConvaiSearch.png?raw=true">
</p>
6. The Convai window should appear, drag it and dock it in any suitable area of the UI.
7. If the Convai window does not appear, go to the `Window` menu and select `Convai` from the list.
## Configuration
To add your API Key and Character ID, follow these steps:
1. Sign up at [Convai](https://convai.com/).
2. On the website click the gear icon in the top-right corner of the playground then copy and paste the API key into the `Convai API Key` field in the Convai extension window.
3. Go to the [Dashboard](https://convai.com/pipeline/dashboard) and on the left panel and either create a new character or select a sample one.
4. Copy the Character ID and paste it in the `Character ID` field in the extension window.
## Actions:
Actions can be used to trigger events with the same name as the action in the `Action graph`. They can be used to run animations based on the action received. To try out actions:
1. Add a few comma seperated actions to `Comma seperated actions` field (e.g jump, kick, dance, etc.).
2. The character will select one of the actions based on the conversation and run any event with the same name as the action in the `Action Graph`.
## Running the Demo
1. Open your chosen Omniverse app (e.g., Code).
2. Go to `File->Open` and navigate to the repo directory.
3. Navigate to `<repo directory>/ConvaiDemoStage/ConvaiDemo.usd` and click `open it.
4. Click the `play` button from the `Toolbar` menu on the left.
<p align="left">
<img height="350" src="images/PlayToolbar.png?raw=true">
</p>
5. Click `Start Talking` in the `Convai` window to talk to the character then click `Stop` to send the request.
## Notes
- The extension is tested in Omniverse Code, but you are welcome to try it out in other apps as well.
- The demo stage includes only talk and idle animations. However, it is possible to add more animations and trigger them using the action selected by the character. More on that in the future. |
Steigner/Isaac-ur_rtde/isaac_rtde.py | # MIT License
# Copyright (c) 2023 Fravebot
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Author: Martin Juříček
# Isaac Sim app library
from omni.isaac.kit import SimulationApp
simulation_app = SimulationApp({"headless": False})
# Isaac Sim extenstions + core libraries
from omni.isaac.motion_generation.lula import RmpFlow
from omni.isaac.motion_generation import ArticulationMotionPolicy
from omni.isaac.core.robots import Robot
from omni.isaac.core.objects import cuboid
from omni.isaac.core import World
from omni.isaac.core.utils.stage import add_reference_to_stage
from omni.isaac.core.utils.nucleus import get_assets_root_path
from omni.isaac.motion_generation.interface_config_loader import (
load_supported_motion_policy_config,
)
# ur rtde communication
import rtde_control
import rtde_receive
import numpy as np
import argparse
import sys
parser = argparse.ArgumentParser()
parser.add_argument(
"--robot-ip",
type=str,
default="127.0.0.1",
help="IP adress of robot Real world UR Polyscope or VM UR Polyscope",
)
arg = parser.parse_args()
# set up paths and prims
robot_name = "UR5e"
prim_path = "/UR5e"
usd_path = get_assets_root_path() + "/Isaac/Robots/UniversalRobots/ur5e/ur5e.usd"
# set references to staget in isaac
add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
# add world
my_world = World(stage_units_in_meters=1.0)
my_world.scene.add_default_ground_plane()
# add robot to world
robot = my_world.scene.add(Robot(prim_path=prim_path, name=robot_name))
# The load_supported_motion_policy_config() function is currently the simplest way to load supported robots.
# In the future, Isaac Sim will provide a centralized registry of robots with Lula robot description files
# and RMP configuration files stored alongside the robot USD.
rmp_config = load_supported_motion_policy_config(robot_name, "RMPflow")
# Initialize an RmpFlow object and set up
rmpflow = RmpFlow(**rmp_config)
physics_dt = 1.0/60
articulation_rmpflow = ArticulationMotionPolicy(robot, rmpflow, physics_dt)
articulation_controller = robot.get_articulation_controller()
# Make a target to follow
target_cube = cuboid.VisualCuboid(
"/World/target", position=np.array([0.5, 0, 0.5]), color=np.array([1.0, 0, 0]), size=0.1, scale=np.array([0.5,0.5,0.5])
)
# Make an obstacle to avoid
ground = cuboid.VisualCuboid(
"/World/ground", position=np.array([0.0, 0, -0.0525]), color=np.array([0, 1.0, 0]), size=0.1, scale=np.array([40,40,1])
)
rmpflow.add_obstacle(ground)
# prereset world
my_world.reset()
# IP adress of robot Real world UR Polyscope or VM UR Polyscope
try:
rtde_r = rtde_receive.RTDEReceiveInterface(arg.robot_ip)
rtde_c = rtde_control.RTDEControlInterface(arg.robot_ip)
robot.set_joint_positions(np.array(rtde_r.getActualQ()))
except:
print("[ERROR] Robot is not connected")
# close isaac sim
simulation_app.close()
sys.exit()
while simulation_app.is_running():
# on step render
my_world.step(render=True)
if my_world.is_playing():
# first frame -> reset world
if my_world.current_time_step_index == 0:
my_world.reset()
# set target to RMP Flow
rmpflow.set_end_effector_target(
target_position=target_cube.get_world_pose()[0], target_orientation=target_cube.get_world_pose()[1]
)
# Parameters
velocity = 0.1
acceleration = 0.1
dt = 1.0/500 # 2ms
lookahead_time = 0.1
gain = 300
# jointq = get joints positions
joint_q = robot.get_joint_positions()
# time start period
t_start = rtde_c.initPeriod()
# run servoJ
rtde_c.servoJ(joint_q, velocity, acceleration, dt, lookahead_time, gain)
rtde_c.waitPeriod(t_start)
# Query the current obstacle position
rmpflow.update_world()
actions = articulation_rmpflow.get_next_articulation_action()
articulation_controller.apply_action(actions)
# get actual q from robot and update isaac model
robot.set_joint_positions(np.array(rtde_r.getActualQ()))
# rtde control stop script and disconnect
rtde_c.servoStop()
rtde_c.stopScript()
rtde_r.disconnect()
# close isaac sim
simulation_app.close() |
Steigner/Isaac-ur_rtde/README.md | # Nvidia Isaac Universal Robots RTDE communication
## Introduction
This example was created in collaboration with [Fravebot](https://www.fravebot.com/) company. This example is a simple demonstration of using Nvidia's Isaac Sim software to control a collaborative robot UR5e from Universal Robots.
```javascript
Software
------------------------------------
| Nvidia Isaac Sim version 2022.2.0
| Isaac Python version 3.7
| - ur-rtde 1.5.5
```
1) [Nvidia Isaac Requirements](https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/requirements.html)
2) [Nvidia Omniverse Isaac Instalation](https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/install_workstation.html)
3) Install [ur_rtde](https://gitlab.com/sdurobotics/ur_rtde) (Check docs Win/Lin). After install python bindings:
```console
user@user-pc:~/.../isaac_sim-2022.2.0$ ./python.sh -m pip install ur_rtde
```
## How-to-Start
1) Go to workspace Nvidia Omniverse Isaac
2) Clone repository
3) Run VM Polyscope or Real Robot.
4) Run command (robot-ip is ip adress of robot VM or Real):
```console
user@user-pc:~/.../isaac_sim-2022.2.0$ ./python.sh test_fravebot/isaac_rtde.py --robot-ip 192.168.200.135
```
## Video!
<p align="center">
<a href="https://www.youtube.com/watch?v=L3BNDRvnJjo"><img src="https://upload.wikimedia.org/wikipedia/commons/0/09/YouTube_full-color_icon_%282017%29.svg" alt="Nvidia Isaac Sim Universal Robots UR5e RTDE"/></a>
</p>
## :information_source: Contacts
:mailbox: [email protected]
|
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/README.md | ## Adding This Extension
1. Download the package.
2. Go into the local address where you install Omniverse apps (code or create).
3. Just put the whole folder into "exts" or "extscache" folders where other extensions are installed. Both folders are OK.
## Using This Extension
An exploded view is very useful to show the details of products in many fields like architecture and mechanical engineering...
This extension provides an easy and reliable way to make exploded view in Omniverse.
### Step1: Match the formats
* Because of the core algorithm reads and manipulates the transform: translate and xformOp: translate: pivot attribute of prims,
before selecting, every single item needs to have a proper pivot coordinate around its geometric center,
as well as the parent group if you want to choose it immediately.
If the formats do not match, change the model in DCC, or directly change their properties if already imported in Omniverse.
### Step2: Create the Exploded Model
1. Select a group or all items at once and click the "Select Prims" button.
2. Change the X, Y, and Z ratio to control the explosion distance in different directions.
3. Change the coordinates of Pivot to control the explosion centre.
* All items in the Exploded_Model will change dynamically with the change of X, Y, Z ratio and Pivot.
### Step3: Edit the Exploded Model
1. Select prims and click the "Add" or "Remove" button to add or remove them into or from the existed Exploded_Model.
2. Select prims and click the "Bind" button if you want to keep the relative distances of selected items during explosion.
3. Select a group and click the "Unbind" button to unleash their relative distances during explosion.
* The Pivot of the Exploded_Model will change dynamically with adding or removing prims.
### Other Functions
1. Click the "Axono" button and adjust the distance of the camera if you want an axonometric view.
2. Click the "Eye" button to hide or show the ORIGINAL prims.
3. Click the "Reset" button to reset the X, Y, Z ratio and Pivot.
4. Click the "Clear" button to delete the Exploded_Model.
### Future Development
* Add some animation functions to show the process of explosion.
* Improve the running speed and manipulation logic.
If you have any other questions about this extension, welcome to send the message or contact [email protected].
|
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/exploded_view.py | from .utils import get_name_from_path, get_pure_list
import omni.usd
import omni.kit.commands
from pxr import Usd, Sdf, Gf
# ----------------------------------------------------SELECT-------------------------------------------------------------
def select_explode_Xform(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
# Get current stage and active prim_paths
stage = omni.usd.get_context().get_stage()
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not selected_prim_path:
return
# A: If the whole group is selected
if len(selected_prim_path) == 1:
# Test members
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
group_prim = stage.GetPrimAtPath(selected_prim_path[0])
children_prims_list = group_prim.GetChildren()
# If no members
if len(children_prims_list) <= 1:
print("Please select a valid group or all items at once!")
return
else:
original_path = selected_prim_path
item_count = len(children_prims_list)
omni.kit.commands.execute('CopyPrim',
path_from= selected_prim_path[0],
path_to='/World/Exploded_Model',
exclusive_select=False)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
# print(selected_prim_path[-1])
# sub_group_prim = stage.GetPrimAtPath(selected_prim_path[0])
# sub_children_prims_list = group_prim.GetChildren()
# original_path = selected_prim_path
# item_count = len(selected_prim_path)
# for i in sub_children_prim_list:
# name = get_name_from_path(i)
# name_list.append(name)
omni.kit.commands.execute('SelectPrims',
old_selected_paths=selected_prim_path,
new_selected_paths=[selected_prim_path[-1]],
expand_in_stage=True)
# B: If multiple prims are selected separately
else:
original_path = selected_prim_path
item_count = len(selected_prim_path)
name_list = []
group_list = []
for i in selected_prim_path:
name = get_name_from_path(i)
name_list.append(name)
# Copy
omni.kit.commands.execute('CopyPrim',
path_from = i,
path_to ='/World/item_01',
exclusive_select=False)
if selected_prim_path.index(i)<= 8:
group_list.append(f'/World/item_0{selected_prim_path.index(i)+1}')
else:
group_list.append(f'/World/item_{selected_prim_path.index(i)+1}')
# Group
omni.kit.commands.execute('GroupPrims',
prim_paths=group_list)
# Change group name
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
omni.kit.commands.execute('MovePrims',
paths_to_move={selected_prim_path[0]: '/World/Exploded_Model'})
# obj = stage.GetObjectAtPath(selected_prim_path[0])
# default_pivot = obj.GetAttribute('xformOp:translate:pivot').Get()
# Change members names back
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
group_prim = stage.GetPrimAtPath(selected_prim_path[0])
children_prims_list = group_prim.GetChildren()
# Move members out of the group
for i in children_prims_list:
ind = children_prims_list.index(i)
if ind <= 8:
omni.kit.commands.execute('MovePrims',
paths_to_move={f"{selected_prim_path[0]}/item_0{ind+1}": f"{selected_prim_path[0]}/" + name_list[ind]})
else:
omni.kit.commands.execute('MovePrims',
paths_to_move={f"{selected_prim_path[0]}/item_{ind+1}": f"{selected_prim_path[0]}/" + name_list[ind]})
# Choose Exploded_Model and get current path,count,pivot
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
current_model_path = selected_prim_path
obj = stage.GetObjectAtPath(selected_prim_path[0])
default_pivot = obj.GetAttribute('xformOp:translate:pivot').Get()
print(obj)
print(default_pivot)
# Get origin translate_list
outer_group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list = outer_group_prim.GetChildren()
item_list0 = children_prims_list
translate_list0 = []
for i in children_prims_list:
sub_children_prim_list = i.GetChildren()
if len(sub_children_prim_list) <= 1:
translate = i.GetAttribute('xformOp:translate').Get()
else:
translate = i.GetAttribute('xformOp:translate:pivot').Get()
translate_list0.append(translate)
# print("--------------------------------------------")
# print(original_path)
# print(current_model_path)
# print(item_count)
# print(default_pivot)
# print(item_list0)
# print(translate_list0)
# print("--------------------------------------------")
# Create Explosion_Centre
omni.kit.commands.execute('CreatePrimWithDefaultXform',
prim_type='Xform',
attributes={})
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
world_pivot_path = selected_prim_path
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{world_pivot_path[0]}" + ".xformOp:translate"),
value=Gf.Vec3d(default_pivot[0], default_pivot[1], default_pivot[2]),
prev=Gf.Vec3d(0, 0, 0))
obj1 = stage.GetObjectAtPath(selected_prim_path[0])
default_pivot = obj1.GetAttribute('xformOp:translate').Get()
omni.kit.commands.execute('MovePrims',
paths_to_move={f"{world_pivot_path[0]}": f"{current_model_path[0]}/" + "Explosion_Centre"})
# Set_default_button_value
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
x_ratio.model.set_value(0)
y_ratio.model.set_value(0)
z_ratio.model.set_value(0)
# End
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
#------------------------------------------------------REMOVE-----------------------------------------------------------
def remove_item(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not selected_prim_path:
return
# Remove correct items
for i in selected_prim_path:
path = str(i)
name = get_name_from_path(path)
if path != f"{current_model_path[0]}/" + "Explosion_Centre":
if path != current_model_path[0] and path.find(current_model_path[0]) != -1:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj0 = stage.GetObjectAtPath(selected_prim_path[0])
children_prims_list_z0 = obj0.GetChildren()
new_count = len(children_prims_list_z0)
if new_count == 2:
print("Cannot remove the only item in Exploded_Model!")
return
else:
# Restore values to 0 to record the postions
x = x_ratio.model.get_value_as_float()
y = y_ratio.model.get_value_as_float()
z = z_ratio.model.get_value_as_float()
# If 0，pass
if x == 0.0 and y== 0.0 and z == 0.0:
pass
# If not, set 0
else:
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
omni.kit.commands.execute('MovePrim',
path_from = path,
path_to = "World/" + name)
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Please select a valid item to remove!")
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Cannot remove Explosion_Centre!")
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
children_prims_list_z = obj.GetChildren()
new_count2 = len(children_prims_list_z) -1
# If any item is removed
if new_count2 < item_count:
# Refresh item_count
item_count = new_count2
obj = stage.GetObjectAtPath(selected_prim_path[0])
# Refresh item_list0 and translate_list0
outer_group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = outer_group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
item_list0 = children_prims_list
translate_list0 = []
for i in children_prims_list:
sub_children_prim_list = i.GetChildren()
if len(sub_children_prim_list) <= 1:
translate = i.GetAttribute('xformOp:translate').Get()
else:
translate = i.GetAttribute('xformOp:translate:pivot').Get()
translate_list0.append(translate)
# Refresh pivot
group_list = []
name_list = []
for i in item_list0:
item_path = str(i.GetPath())
name = get_name_from_path(item_path)
name_list.append(name)
group_list.append(item_path)
# S1 group
omni.kit.commands.execute('GroupPrims',
prim_paths=group_list)
# change group name
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
omni.kit.commands.execute('MovePrims',
paths_to_move={selected_prim_path[0]: f"{current_model_path[0]}/Sub_Exploded_Model"})
# S2 Get new pivot by group
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f"{current_model_path[0]}/Sub_Exploded_Model"],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
default_pivot = obj.GetAttribute('xformOp:translate:pivot').Get()
# S3 Move members out of the group
group_path = selected_prim_path
outer_group_prim = stage.GetPrimAtPath(group_path[0])
children_prims_list = outer_group_prim.GetChildren()
for i in children_prims_list:
index = children_prims_list.index(i)
name = name_list[index]
omni.kit.commands.execute('MovePrim',
path_from = f"{group_path[0]}/{name_list[index]}",
path_to = f"{current_model_path[0]}/{name_list[index]}")
# S4 Delete the group
omni.kit.commands.execute('DeletePrims',
paths=[f"{current_model_path[0]}/Sub_Exploded_Model"])
# S5 Change pivot
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{current_model_path[0]}/Explosion_Centre" + ".xformOp:translate"),
value=Gf.Vec3d(default_pivot[0], default_pivot[1], default_pivot[2]),
prev=Gf.Vec3d(0, 0, 0))
# Restore_default_panel
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
if x == 0.0 and y== 0.0 and z == 0.0:
pass
else:
x_ratio.model.set_value(x)
y_ratio.model.set_value(y)
z_ratio.model.set_value(z)
# Select
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
# If no remove actions，return
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
except:
print("Create a model to explode at first!")
return
#---------------------------------------------------------ADD-----------------------------------------------------------
def add_item(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not selected_prim_path:
return
# Add correct items
for i in selected_prim_path:
path = str(i)
name = get_name_from_path(path)
if path.find(current_model_path[0]) == -1:
# Restore values to 0 to record the postions
x = x_ratio.model.get_value_as_float()
y = y_ratio.model.get_value_as_float()
z = z_ratio.model.get_value_as_float()
# If 0, pass
if x == 0.0 and y== 0.0 and z == 0.0:
pass
# If not, set 0
else:
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
omni.kit.commands.execute('MovePrim',
path_from = path,
path_to = f"{current_model_path[0]}/" + name)
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("The selected item already existed in the model!")
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
children_prims_list_z = obj.GetChildren()
new_count2 = len(children_prims_list_z) - 1
# print(new_count2)
# If any items is added
if new_count2 > item_count:
# Refresh item_count
item_count = new_count2
obj = stage.GetObjectAtPath(selected_prim_path[0])
# Refresh item_list0 and translate_list0
outer_group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = outer_group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
item_list0 = children_prims_list
translate_list0 = []
for i in children_prims_list:
sub_children_prim_list = i.GetChildren()
if len(sub_children_prim_list) <= 1:
translate = i.GetAttribute('xformOp:translate').Get()
else:
translate = i.GetAttribute('xformOp:translate:pivot').Get()
translate_list0.append(translate)
# Refresh pivot
group_list = []
name_list = []
for i in item_list0:
item_path = str(i.GetPath())
name = get_name_from_path(item_path)
name_list.append(name)
group_list.append(item_path)
# S1 Group
omni.kit.commands.execute('GroupPrims',
prim_paths=group_list)
# Change group name
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
omni.kit.commands.execute('MovePrims',
paths_to_move={selected_prim_path[0]: f"{current_model_path[0]}/Sub_Exploded_Model"})
# S2 Get new pivot by group
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f"{current_model_path[0]}/Sub_Exploded_Model"],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
default_pivot = obj.GetAttribute('xformOp:translate:pivot').Get()
print(default_pivot)
# S3 Move members out of the group
group_path = selected_prim_path
outer_group_prim = stage.GetPrimAtPath(group_path[0])
children_prims_list = outer_group_prim.GetChildren()
for i in children_prims_list:
index = children_prims_list.index(i)
name = name_list[index]
omni.kit.commands.execute('MovePrim',
path_from= f"{group_path[0]}/{name_list[index]}",
path_to=f"{current_model_path[0]}/{name_list[index]}")
# S4 Delete the group
omni.kit.commands.execute('DeletePrims',
paths=[f"{current_model_path[0]}/Sub_Exploded_Model"])
# S5 Change pivot
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{current_model_path[0]}/Explosion_Centre" + ".xformOp:translate"),
value=Gf.Vec3d(default_pivot[0], default_pivot[1], default_pivot[2]),
prev=Gf.Vec3d(0, 0, 0))
# Restore_default_panel
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
if x == 0.0 and y== 0.0 and z == 0.0:
pass
else:
x_ratio.model.set_value(x)
y_ratio.model.set_value(y)
z_ratio.model.set_value(z)
# Select
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
# If no add actions，return
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
except:
print("Create a model to explode at first!")
return
#--------------------------------------------------------BIND-----------------------------------------------------------
def bind_item(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not selected_prim_path:
return
if len(selected_prim_path) < 2:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Bind at least 2 items in the model!")
return
group_list = []
for i in selected_prim_path:
path = str(i)
name = get_name_from_path(path)
if path != f"{current_model_path[0]}/" + "Explosion_Centre":
if path.find(current_model_path[0]) != -1:
group_list.append(i)
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Cannot bind the Explosion_Centre!")
# Restore values to 0 to bind
x = x_ratio.model.get_value_as_float()
y = y_ratio.model.get_value_as_float()
z = z_ratio.model.get_value_as_float()
# If 0，pass
if x == 0.0 and y== 0.0 and z == 0.0:
pass
# If not，set 0
else:
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
# Bind items
omni.kit.commands.execute('GroupPrims',
prim_paths=group_list)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
group_path = selected_prim_path[0]
# print(group_path)
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
children_prims_list_z = obj.GetChildren()
new_count2 = len(children_prims_list_z) - 1
# print(new_count2)
# If bind actions
if new_count2 < item_count:
# Refresh item_count
item_count = new_count2
obj = stage.GetObjectAtPath(selected_prim_path[0])
# Refresh item_list0 and translate_list0
outer_group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = outer_group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
item_list0 = children_prims_list
translate_list0 = []
for i in children_prims_list:
sub_children_prim_list = i.GetChildren()
if len(sub_children_prim_list) <= 1:
translate = i.GetAttribute('xformOp:translate').Get()
else:
translate = i.GetAttribute('xformOp:translate:pivot').Get()
translate_list0.append(translate)
# Refresh pivot
default_pivot = default_pivot
# Restore_default_panel
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
if x == 0.0 and y== 0.0 and z == 0.0:
pass
else:
x_ratio.model.set_value(x)
y_ratio.model.set_value(y)
z_ratio.model.set_value(z)
# Select
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
# If no bind，return
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
except:
print("Create a model to explode at first!")
return
#------------------------------------------------------UNBIND-----------------------------------------------------------
def unbind_item(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not selected_prim_path:
return
# Test valid group
for i in selected_prim_path:
path0 = str(i)
if path0 != current_model_path[0] and path0.find(current_model_path[0]) != -1:
outer_group_prim = stage.GetPrimAtPath(path0)
children_prims_list0 = outer_group_prim.GetChildren()
if len(children_prims_list0) < 1:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Please select a valid group!")
return
else:
if selected_prim_path.index(i) == 0:
# Restore values to 0 to unbind
x = x_ratio.model.get_value_as_float()
y = y_ratio.model.get_value_as_float()
z = z_ratio.model.get_value_as_float()
# If 0，pass
if x == 0.0 and y== 0.0 and z == 0.0:
pass
# If not，set 0
else:
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
for j in children_prims_list0:
path = str(j.GetPath())
name = get_name_from_path(path)
omni.kit.commands.execute('MovePrims',
paths_to_move={path: f"{current_model_path[0]}/{name}"})
# Delete group
omni.kit.commands.execute('DeletePrims',
paths=[path0])
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
print("Please unbind a valid group!")
return
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
obj = stage.GetObjectAtPath(selected_prim_path[0])
children_prims_list_z = obj.GetChildren()
new_count2 = len(children_prims_list_z) - 1
# print(new_count2)
# If unbind actions
if new_count2 >= item_count:
# Refresh item_count
item_count = new_count2
obj = stage.GetObjectAtPath(selected_prim_path[0])
# Refresh item_list0 and translate_list0
outer_group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = outer_group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
item_list0 = children_prims_list
translate_list0 = []
for i in children_prims_list:
sub_children_prim_list = i.GetChildren()
if len(sub_children_prim_list) <= 1:
translate = i.GetAttribute('xformOp:translate').Get()
else:
translate = i.GetAttribute('xformOp:translate:pivot').Get()
translate_list0.append(translate)
# Refresh pivot
default_pivot = default_pivot
# Restore_default_panel
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
if x == 0.0 and y== 0.0 and z == 0.0:
pass
else:
x_ratio.model.set_value(x)
y_ratio.model.set_value(y)
z_ratio.model.set_value(z)
# Select
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
# If no unbind，return
else:
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
return
except:
print("Create a model to explode at first!")
return
#------------------------------------------------------ONCHANGE----------------------------------------------------------
def on_pivot_change(x_coord, y_coord, z_coord, x_button, y_button, z_button, a:float):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
# Select Model
if not current_model_path:
print("Please select items to explode at first")
return
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
# Get x,y,z value
x_position = x_coord.model.get_value_as_float()
y_position = y_coord.model.get_value_as_float()
z_position = z_coord.model.get_value_as_float()
# print(x_position, y_position, z_position)
# Change pivot
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(f"{current_model_path[0]}/" + "Explosion_Centre"),
new_translation=Gf.Vec3d(x_position, y_position, z_position),
old_translation=Gf.Vec3d(0, 0, 0))
# Get new pivot
obj2 = stage.GetObjectAtPath(f"{current_model_path[0]}/" + "Explosion_Centre")
pivot = obj2.GetAttribute('xformOp:translate').Get()
# Get x,y,z ratio
x_ratio = x_button.model.get_value_as_float()
y_ratio = y_button.model.get_value_as_float()
z_ratio = z_button.model.get_value_as_float()
# Calculate each item
group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
# Move each item
for item in children_prims_list:
sub_children_prim_list = item.GetChildren()
index = children_prims_list.index(item)
translate = translate_list0[index]
# print(translate)
item_path = item.GetPrimPath()
# print(item_path)
if len(sub_children_prim_list) <= 1:
# If single item
x_distance = (translate[0] - pivot[0]) * x_ratio
y_distance = (translate[1] - pivot[1]) * y_ratio
z_distance = (translate[2] - pivot[2]) * z_ratio
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(item_path),
new_translation=Gf.Vec3d(translate[0] + x_distance, translate[1] + y_distance, translate[2] + z_distance),
old_translation=translate)
else:
# If group item
x_distance = (translate[0] - pivot[0]) * x_ratio
y_distance = (translate[1] - pivot[1]) * y_ratio
z_distance = (translate[2] - pivot[2]) * z_ratio
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(item_path),
new_translation=Gf.Vec3d(x_distance, y_distance, z_distance),
old_translation=translate)
# End
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f"{current_model_path[0]}/" + "Explosion_Centre"],
expand_in_stage=True)
except:
x_coord.model.set_value(0.0)
y_coord.model.set_value(0.0)
z_coord.model.set_value(0.0)
x_button.model.set_value(0.0)
y_button.model.set_value(0.0)
z_button.model.set_value(0.0)
print("Create a model to explode at first!")
return
def on_ratio_change(x_button, y_button, z_button, x_coord, y_coord, z_coord, a:float):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
stage = omni.usd.get_context().get_stage()
# Select Model
if not current_model_path:
print("Please select items to explode at first")
return
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f'{current_model_path[0]}'],
expand_in_stage=True)
# Get x,y,z value
x_position = x_coord.model.get_value_as_float()
y_position = y_coord.model.get_value_as_float()
z_position = z_coord.model.get_value_as_float()
# print(x_position, y_position, z_position)
# Change pivot
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(f"{current_model_path[0]}/" + "Explosion_Centre"),
new_translation=Gf.Vec3d(x_position, y_position, z_position),
old_translation=Gf.Vec3d(0, 0, 0))
# Get new pivot
obj = stage.GetObjectAtPath(f"{current_model_path[0]}/" + "Explosion_Centre")
pivot = obj.GetAttribute('xformOp:translate').Get()
# Get x,y,z ratio
x_ratio = x_button.model.get_value_as_float()
y_ratio = y_button.model.get_value_as_float()
z_ratio = z_button.model.get_value_as_float()
# Calculate each item
group_prim = stage.GetPrimAtPath(current_model_path[0])
children_prims_list0 = group_prim.GetChildren()
children_prims_list = get_pure_list(children_prims_list0)
# Move each item
for item in children_prims_list:
sub_children_prim_list = item.GetChildren()
index = children_prims_list.index(item)
translate = translate_list0[index]
item_path = item.GetPrimPath()
if len(sub_children_prim_list) <= 1:
# If single item
x_distance = (translate[0] - pivot[0]) * x_ratio
y_distance = (translate[1] - pivot[1]) * y_ratio
z_distance = (translate[2] - pivot[2]) * z_ratio
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(item_path),
new_translation=Gf.Vec3d(translate[0] + x_distance, translate[1] + y_distance, translate[2] + z_distance),
old_translation=translate)
else:
# If group item
x_distance = (translate[0] - pivot[0]) * x_ratio
y_distance = (translate[1] - pivot[1]) * y_ratio
z_distance = (translate[2] - pivot[2]) * z_ratio
omni.kit.commands.execute('TransformPrimSRT',
path=Sdf.Path(item_path),
new_translation=Gf.Vec3d(x_distance, y_distance, z_distance),
old_translation=translate)
# End
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=[f"{current_model_path[0]}/" + "Explosion_Centre"],
expand_in_stage=True)
except:
x_coord.model.set_value(0.0)
y_coord.model.set_value(0.0)
z_coord.model.set_value(0.0)
x_button.model.set_value(0.0)
y_button.model.set_value(0.0)
z_button.model.set_value(0.0)
print("Create a model to explode at first!")
return
#-------------------------------------------------SECONDARY FUNCTION------------------------------------------------------
def hide_unhide_original_model():
try:
global original_path
global item_count
stage = omni.usd.get_context().get_stage()
visible_count = 0
for i in original_path:
obj = stage.GetObjectAtPath(i)
visual_attr = obj.GetAttribute('visibility').Get()
# print(type(visual_attr))
# print(visual_attr)
if visual_attr == "inherited":
visible_count += 1
# print(original_path)
# print(visible_count)
# print(item_count)
# All light
if visible_count == 1:
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{original_path[0]}.visibility"),
value='invisible',
prev=None)
# All light
elif visible_count < item_count:
for i in original_path:
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{i}.visibility"),
value='inherited',
prev=None)
# All dark
elif visible_count == item_count:
for i in original_path:
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path(f"{i}.visibility"),
value='invisible',
prev=None)
return
except:
print("Cannot find ORIGINAL prims to hide or show!")
return
def set_camera():
stage = omni.usd.get_context().get_stage()
world = stage.GetObjectAtPath('/World')
children_refs = world.GetChildren()
for i in children_refs:
path = str(i)
if path.find('/World/Axonometric_View') != -1:
print("Axonometric camera already existed!")
omni.kit.commands.execute('SelectPrims',
old_selected_paths=[],
new_selected_paths=['/World/Axonometric_View'],
expand_in_stage=True)
return
omni.kit.commands.execute('DuplicateFromActiveViewportCameraCommand',
viewport_name='Viewport')
omni.kit.commands.execute('CreatePrim',
prim_path='/World/Camera',
prim_type='Camera')
selected_prim_path = omni.usd.get_context().get_selection().get_selected_prim_paths()
camera_path = selected_prim_path
omni.kit.commands.execute('MovePrims',
paths_to_move={camera_path[0]: '/World/Axonometric_View'})
omni.kit.commands.execute('MovePrim',
path_from=camera_path[0],
path_to='/World/Axonometric_View',
time_code=Usd.TimeCode.Default(),
keep_world_transform=True)
omni.kit.commands.execute('ChangeProperty',
prop_path=Sdf.Path('/World/Axonometric_View.focalLength'),
value=500.0,
prev=0)
return
def reset_model(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global default_pivot
x_coord.model.set_value(default_pivot[0])
y_coord.model.set_value(default_pivot[1])
z_coord.model.set_value(default_pivot[2])
x = x_ratio.model.get_value_as_float()
y = y_ratio.model.get_value_as_float()
z = z_ratio.model.get_value_as_float()
# If 0，pass
if x == 0.0 and y== 0.0 and z == 0.0:
pass
# If not, set 0
else:
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
return
except:
print("Create a model to explode at first!")
return
def clear(x_coord, y_coord, z_coord, x_ratio, y_ratio, z_ratio):
try:
global original_path
global current_model_path
global item_count
global default_pivot
global item_list0
global translate_list0
omni.kit.commands.execute('DeletePrims',
paths=[current_model_path[0]])
original_path = None
current_model_path = None
item_count = None
default_pivot = None
item_list0 = None
translate_list0 = None
x_coord.model.set_value(0.0)
y_coord.model.set_value(0.0)
z_coord.model.set_value(0.0)
x_ratio.model.set_value(0.0)
y_ratio.model.set_value(0.0)
z_ratio.model.set_value(0.0)
print("All data clear")
return
except:
print("Create a model to explode at first!")
return
|
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/extension.py | import omni.ext
import omni.usd
from .exploded_view_ui import Cretae_UI_Framework
class Main_Entrance(omni.ext.IExt):
def on_startup(self, ext_id):
Cretae_UI_Framework(self)
def on_shutdown(self):
print("[hnadi.tools.exploded_view] shutdown")
self._window.destroy()
self._window = None
stage = omni.usd.get_context().get_stage() |
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/__init__.py | from .extension import *
|
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/utils.py | def get_name_from_path(path:str):
reverse_str = list(reversed(path))
num = len(reverse_str)-((reverse_str.index("/"))+1)
name = path[num+1:]
return name
def get_pure_list(list:list):
new_list = []
for i in list:
full_path0 = i.GetPrimPath()
full_path = str(full_path0)
if get_name_from_path(full_path) != "Explosion_Centre":
new_list.append(i)
# print(new_list)
return new_list |
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/exploded_view_style.py | # Copyright (c) 2022, HNADIACE. All rights reserved.
__all__ = ["HNADI_window_style"]
from omni.ui import color as cl
from omni.ui import constant as fl
from omni.ui import url
import omni.kit.app
import omni.ui as ui
import pathlib
EXTENSION_FOLDER_PATH = pathlib.Path(
omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
)
##颜色预设##
#主题色
main_color = cl.hnadi_color = cl("#F5B81B")
#主字体色
white = cl.hnadi_text_color = cl("#DADADA") # 最浅色
#窗口
cl.window_label_bg = cl("#0F0F0F") # 窗口标题背景色
cl.window_bg = cl("#252525") # 窗口背景色，60~90%透明度（透明度不知道定义）
#折叠框架
cl.clloapsible_bg_label = cl("#252525")
#按钮
cl.button_bg = cl("#252525") # 常规背景色+边框#9393939，1px
cl.button_bg_hover = cl("#98999C")
cl.button_bg_click = cl("#636363")
cl.button_label = cl("#939393") # 按钮常规字体颜色
cl.button_label_hover = cl("#383838") # 按钮悬停时字体颜色
cl.button_label_click = cl("#DADADA")
#下拉框
cl.combobox_bg = cl("#252525")
cl.combobox_label = cl("#939393")
cl.combobox_bg_hover = cl("#0F0F0F")
cl.combobox_label_hover = cl("#AFAFAF")
#勾选框/还原按钮
cl.revert_arrow_enabled = cl("#AFAFAF") # 启用状态
cl.revert_arrow_disabled = cl("#383838") # 禁用状态
cl.checkbox_hover = cl("#DADADA")
cl.checkbox_click = cl("#F5B81B")
#边界线框
border_color = cl.border = cl("#636363") # 1px-2px厚度
#滑块
cl.slider_fill = cl("#F5B81B") # 滑块填充色，主题色
cl.slider_bg = cl("#252525")
cl.floatslider_sele = cl("#BB8E1A") # 滑块点击效果
cl.slider_text_color = cl("98999C")
#还原按钮
cl.revert_arrow_enabled = cl("#F5B81B") # 启用状态
cl.revert_arrow_disabled = cl("#383838") # 禁用状态
#好像用不到的
cl.transparent = cl(0, 0, 0, 0)
# HC Color
black = cl("#252525")
white = cl("#FFFFFF")
cls_temperature_gradient = [cl("#fe0a00"), cl("#f4f467"), cl("#a8b9ea"), cl("#2c4fac"), cl("#274483"), cl("#1f334e")]
## 间距预设 ##
fl.window_attr_hspacing = 8 # 文字与功能框间距（全部）
fl.window_attr_spacing = 4 # 纵向间距
fl.group_spacing = 4 # 组间间距
fl.spacing = 4
fl.border_radius = 4
fl.border_width = 1
## 字体大小 ##
fl.window_title_font_size = 18
fl.collapsable_font_size = 16
fl.text_font_size = 14
## 链接 ##
url.icon_achiview = f"{EXTENSION_FOLDER_PATH}/image/achi_view.png"
url.icon_achiview_click = f"{EXTENSION_FOLDER_PATH}/image/achi_view_click.png"
url.icon_bowlgenerator = f"{EXTENSION_FOLDER_PATH}/image/bowl_generator.png"
url.icon_bowlgenerator_click = f"{EXTENSION_FOLDER_PATH}/image/bowl_generator_click.png"
url.icon_buildingblock = f"{EXTENSION_FOLDER_PATH}/image/building_block.png"
url.icon_buildingblock_click = f"{EXTENSION_FOLDER_PATH}/image/building_blockc_click.png"
url.icon_draincurve = f"{EXTENSION_FOLDER_PATH}/image/drain_curve.png"
url.icon_draincurve_click = f"{EXTENSION_FOLDER_PATH}/image/drain_curve_click.png"
url.icon_explodedview = f"{EXTENSION_FOLDER_PATH}/image/exploded_view.png"
url.icon_explodedview_click = f"{EXTENSION_FOLDER_PATH}/image/exploded_view_click.png"
url.icon_isochronouscircle = f"{EXTENSION_FOLDER_PATH}/image/isochronouscircle.png"
url.icon_isochronouscircle_click = f"{EXTENSION_FOLDER_PATH}/image/isochronouscircle_click.png"
url.icon_light_studio = f"{EXTENSION_FOLDER_PATH}/image/light_studio.png"
url.icon_lightstudio_click = f"{EXTENSION_FOLDER_PATH}/image/light_studio_click.png"
url.icon_solarpanel = f"{EXTENSION_FOLDER_PATH}/image/solar_panel.png"
url.icon_solarpanel_click = f"{EXTENSION_FOLDER_PATH}/image/solar_panel_click.png"
url.closed_arrow_icon = f"{EXTENSION_FOLDER_PATH}/image/closed.svg"
url.radio_btn_on_icon = f"{EXTENSION_FOLDER_PATH}/image/Slice 3.png"
url.radio_btn_off_icon = f"{EXTENSION_FOLDER_PATH}/image/Slice 1.png"
url.radio_btn_hovered_icon = f"{EXTENSION_FOLDER_PATH}/image/Slice 2.png"
## Style格式说明 ##
"""
"Button":{"border_width":0.5} # 1———为一类控件指定样式,直接"WidgetType":{}
"Button::B1":{XXXX} # 2———为一类控件下的某个实例指定特殊样式,"WidgetType::InstanceName":{}
"Button::B1:hovered/pressed":{XXXX} # 3———为一类控件的某个实例的某个状态指定样式,"WidgetType::InstanceName:State":{}
"Button.Label::B1":{} # 3———为一类控件的某个实例的某种属性指定样式,"WidgetType.AttributeName::InstanceName":{}
"""
HNADI_window_style = {
# 属性字体 attribute_name
"Label::attribute_name": {
"alignment": ui.Alignment.RIGHT_CENTER,
"margin_height": fl.window_attr_spacing,
"margin_width": fl.window_attr_hspacing,
"color": cl.button_label,
},
"Label::attribute_name:hovered": {"color": cl.hnadi_text_color},
# 可折叠标题
# 可折叠标题文字 collapsable_name
"Label::collapsable_name": {
"alignment": ui.Alignment.LEFT_CENTER,
"color": cl.hnadi_text_color,
"font_size": fl.collapsable_font_size,
},
# 可折叠标题命名（间隔属性） group
"CollapsableFrame::group": {"margin_height": fl.group_spacing},
# HeaderLine 线
"HeaderLine": {"color": cl(.5, .5, .5, .5)},
# 滑杆
"Slider": {
"border_radius": fl.border_radius,
"color": cl.slider_text_color,
"background_color": cl.slider_bg,
"secondary_color": cl.slider_fill,
"secondary_selected_color": cl.floatslider_sele,
"draw_mode": ui.SliderDrawMode.HANDLE,
},
# FloatSlider attribute_float
"Slider::attribute_float": {"draw_mode": ui.SliderDrawMode.FILLED},
"Slider::attribute_float:hovered": {
"color": cl.slider_text_color,
"background_color": cl.slider_bg
},
"Slider::attribute_float:pressed": {"color": cl.slider_text_color},
# IntSlider attribute_int
"Slider::attribute_int": {
"secondary_color": cl.slider_fill,
"secondary_selected_color": cl.floatslider_sele,
},
"Slider::attribute_int:hovered": {"color": cl.slider_text_color},
"Slider::attribute_float:pressed": {"color": cl.slider_text_color},
# 按钮 tool_button
"Button::tool_button": {
"background_color": cl.button_bg,
"border_width": fl.border_width,
"border_color": cl.border,
"border_radius": fl.border_radius,
},
"Button::tool_button:hovered": {"background_color": cl.button_bg_hover},
"Button::tool_button:pressed": {"background_color": cl.button_bg_click},
"Button::tool_button:checked": {"background_color": cl.button_bg_click},
"Button::tool_button:pressed": {"background_color": cl.slider_fill},
"Button.Label::tool_button:hovered": {"color": cl.button_label_hover},
"Button.Label::tool_button:pressed": {"color": white},
"Button.Label::tool_button": {"color": cl.button_label},
# # 图片按钮 image_button
# "Button::image_button": {
# "background_color": cl.transparent,
# "border_radius": fl.border_radius,
# "fill_policy": ui.FillPolicy.PRESERVE_ASPECT_FIT,
# },
# "Button.Image::image_button": {
# "image_url": url.icon_achiview,
# "alignment": ui.Alignment.CENTER_TOP,
# "border_radius": fl.border_radius,
# },
# "Button.Image::image_button:checked": {"image_url": url.icon_achiview_click},
# "Button::image_button:hovered": {"background_color": cl.button_bg_hover},
# "Button::image_button:pressed": {"background_color": cl.button_bg_click},
# "Button::image_button:checked": {"background_color": cl.imagebutton_bg_click},
# Field attribute_field
"Field": {
"background_color": cl.slider_bg,
"border_radius": fl.border_radius,
"border_color": cl.border,
"border_width": fl.border_width,
},
"Field::attribute_field": {
"corner_flag": ui.CornerFlag.RIGHT,
"font_size": fl.text_font_size,
},
"Field::attribute_field:hovered":{"background_color": cl.combobox_bg_hover},
"Field::attribute_field:pressed":{"background_color": cl.combobox_bg_hover},
# cl.slider_fill
# # 下拉框
"Rectangle::box": {
"background_color": cl.slider_fill,
"border_radius": fl.border_radius,
"border_color": cl.slider_fill,
"border_width": 0,
"color": cl.combobox_label,
},
# "ComboBox::dropdown_menu":{
# "background_color": cl.combobox_bg,
# "secondary_color": 0x0,
# "font_size": fl.text_font_size,
# },
# "ComboBox::dropdown_menu:hovered":{
# "color": cl.combobox_label_hover,
# "background_color": cl.combobox_bg_hover,
# "secondary_color": cl.combobox_bg_hover,
# },
# "ComboBox::dropdown_menu:pressed":{
# "background_color": cl.combobox_bg_hover,
# "border_color": cl.border,
# },
# "Rectangle::combobox_icon_cover": {"background_color": cl.field_bg},
# RadioButtion
# "Button::radiobutton":{
# "background_color":cl.transparent,
# "image_url": url.radio_btn_off_icon,
# },
# "Button::radiobutton:pressed":{"image_url": url.radio_btn_on_icon},
# "Button::radiobutton:checked":{"image_url": url.radio_btn_on_icon},
#图片
# "Image::radio_on": {"image_url": url.radio_btn_on_icon},
# "Image::radio_off": {"image_url": url.radio_btn_off_icon},
# "Image::collapsable_opened": {"color": cl.example_window_text, "image_url": url.example_window_icon_opened},
# "Image::collapsable_closed": {"color": cl.example_window_text, "image_url": url.example_window_icon_closed},
# "Image::collapsable_closed": {
# "color": cl.collapsible_header_text,
# "image_url": url.closed_arrow_icon,
# },
# "Image::collapsable_closed:hovered": {
# "color": cl.collapsible_header_text_hover,
# "image_url": url.closed_arrow_icon,
# },
}
|
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/hnadi/tools/exploded_view/exploded_view_ui.py | from os import path
from data.image_path import image_path
from functools import partial
import omni.ui as ui
from .exploded_view import select_explode_Xform, on_ratio_change, on_pivot_change, remove_item, add_item, bind_item, unbind_item, hide_unhide_original_model, reset_model, clear, set_camera
from .exploded_view_style import HNADI_window_style, main_color, white, border_color
# Connect to Extension
class Cretae_UI_Framework(ui.Window):
def __init__(self, transformer) -> None:
self = transformer
spacer_distance = distance = 6
overall_width = 380
overall_height = 395
self._window = ui.Window("Exploded View", width=overall_width, height=overall_height)
with self._window.frame:
with ui.VStack(style=HNADI_window_style):
# Column1 Main Functions UI
with ui.HStack(height = 170):
# two big buttons
ui.Spacer(width=6)
with ui.VStack(width = 120):
ui.Spacer(height = distance - 1)
select_button = create_button_type1(name="Select Prims", tooltip="Select a group or all items at once to explode.", pic=image_path.select, height=102, spacing=-45)
ui.Spacer(height = 4)
camera_button = create_button_type1_1(name="Axono", tooltip="Set an axonometirc camera.", pic=image_path.Axono, height=53, spacing=-20)
ui.Spacer(width = 10)
# four main control sliders
with ui.VStack():
ui.Spacer(height = distance+2)
x_button = create_floatfield_ui(label="X ratio", tooltip="Explosion distance ratio in X direction", max=100.0)
ui.Spacer(height = 2)
y_button = create_floatfield_ui(label="Y ratio", tooltip="Explosion distance ratio in Y direction", max=100.0)
ui.Spacer(height = 2)
z_button = create_floatfield_ui(label="Z ratio", tooltip="Explosion distance ratio in Z direction", max=100.0)
ui.Spacer(height = 2)
ui.Spacer(height = 4)
with ui.HStack():
ui.Label("Pivot", name="attribute_name", width = 40, height=25, tooltip="Coordinates of the Explosion_Centre")
ui.Spacer(width=10)
with ui.HStack():
x_coord = create_coord_ui(name="X", color=0xFF5555AA)
ui.Spacer(width=10)
y_coord = create_coord_ui(name="Y", color=0xFF76A371)
ui.Spacer(width=10)
z_coord = create_coord_ui(name="Z", color=0xFFA07D4F)
ui.Spacer(width=6)
# Column2 Edit Functions UI
with ui.CollapsableFrame("Edit Exploded Model", name="group", build_header_fn=_build_collapsable_header):
with ui.VStack():
with ui.HStack():
ui.Spacer(width=6)
add_button = create_button_type2(name="Add", tooltip="Add items into the Exploded_Model.", pic=image_path.add1, spacing=-85)
ui.Spacer(width=1)
bind_button = create_button_type2(name="Bind", tooltip="Bind items together to keep their relative distances during explosion.", pic=image_path.bind, spacing=-75)
ui.Spacer(width=6)
with ui.HStack():
ui.Spacer(width=6)
remove_button = create_button_type2(name="Remove", tooltip="Remove items from the Exploded_Model", pic=image_path.remove1, spacing=-85)
ui.Spacer(width=1)
unbind_button = create_button_type2(name="Unbind", tooltip="Unbind items.", pic=image_path.unbind, spacing=-75)
ui.Spacer(width=6)
ui.Spacer(height = 5)
ui.Spacer(height = 6)
# Column3 Other Functions UI
with ui.HStack():
ui.Spacer(width=6)
hideorshow_button = create_button_type3(tooltip="Hide or show the ORIGINAL prims.", pic=image_path.hide_show)
reset_button = create_button_type3(tooltip="Reset the Exploded_Model.", pic=image_path.reset)
clear_button = create_button_type3(tooltip="Delete the Exploded_Model and all data.", pic=image_path.clear)
ui.Spacer(width=6)
# Connect functions to button
select_button.set_clicked_fn(partial(select_explode_Xform, x_coord, y_coord, z_coord, x_button, y_button, z_button))
camera_button.set_clicked_fn(set_camera)
x_button.model.add_value_changed_fn(partial(on_ratio_change, x_button, y_button, z_button, x_coord, y_coord, z_coord))
y_button.model.add_value_changed_fn(partial(on_ratio_change, x_button, y_button, z_button, x_coord, y_coord, z_coord))
z_button.model.add_value_changed_fn(partial(on_ratio_change, x_button, y_button, z_button, x_coord, y_coord, z_coord))
x_coord.model.add_value_changed_fn(partial(on_pivot_change, x_coord, y_coord, z_coord, x_button, y_button, z_button))
y_coord.model.add_value_changed_fn(partial(on_pivot_change, x_coord, y_coord, z_coord, x_button, y_button, z_button))
z_coord.model.add_value_changed_fn(partial(on_pivot_change, x_coord, y_coord, z_coord, x_button, y_button, z_button))
add_button.set_clicked_fn(partial(add_item, x_coord, y_coord, z_coord, x_button, y_button, z_button))
remove_button.set_clicked_fn(partial(remove_item, x_coord, y_coord, z_coord, x_button, y_button, z_button))
bind_button.set_clicked_fn(partial(bind_item, x_coord, y_coord, z_coord, x_button, y_button, z_button))
unbind_button.set_clicked_fn(partial(unbind_item, x_coord, y_coord, z_coord, x_button, y_button, z_button))
hideorshow_button.set_clicked_fn(hide_unhide_original_model)
reset_button.set_clicked_fn(partial(reset_model, x_coord, y_coord, z_coord, x_button, y_button, z_button))
clear_button.set_clicked_fn(partial(clear, x_coord, y_coord, z_coord, x_button, y_button, z_button))
def _build_collapsable_header(collapsed, title):
"""Build a custom title of CollapsableFrame"""
with ui.VStack():
ui.Spacer(height=5)
with ui.HStack():
ui.Label(title, name="collapsable_name")
if collapsed:
image_name = "collapsable_opened"
else:
image_name = "collapsable_closed"
ui.Image(name=image_name, width=10, height=10)
ui.Spacer(height=5)
ui.Line(style_type_name_override="HeaderLine")
# UI button style
def create_coord_ui(color:str, name:str):
with ui.ZStack(width=13, height=25):
ui.Rectangle(name="vector_label", width=15, style={"background_color":main_color, "border_radius":3})
ui.Label(name, alignment=ui.Alignment.CENTER, style={"color":white})
coord_button =ui.FloatDrag(min=-99999999.9, max=99999999.9)
return coord_button
def create_floatfield_ui(label:str, max:float, tooltip:str, min=0.0):
with ui.HStack():
ui.Label(label, name="attribute_name", width=40, height=25, tooltip=tooltip)
ui.Spacer(width=1.5)
button = ui.FloatField(min=min, max=max, height=25)
button.model.set_value(0.0)
return button
def create_button_type1(name, tooltip, pic, height, spacing=-45):
style = {
"Button":{"stack_direction":ui.Direction.TOP_TO_BOTTOM},
"Button.Label":{"alignment":ui.Alignment.CENTER_BOTTOM},
# "border_width": 0.1,
# "border_color": border_color,
"border_radius": 4,
"Button.Image":{# "color":0xffFFFFFF,
"image_url":pic,
"alignment":ui.Alignment.CENTER_BOTTOM,},
":hovered":{
"background_gradient_color":main_color,
"background_color":0X500066FF}}
button = ui.Button(name, height=height, width=120, tooltip=tooltip, style=style)
button.spacing = spacing
return button
def create_button_type1_1(name, tooltip, pic, height, spacing=-20):
style = {
"Button":{"stack_direction":ui.Direction.LEFT_TO_RIGHT},
"Button.Image":{# "color":0xffFFFFFF,
"image_url":pic,
"alignment":ui.Alignment.CENTER_BOTTOM,},
"Button.Label":{"alignment":ui.Alignment.CENTER},
"border_radius": 4,
":hovered":{
"background_gradient_color":main_color,
"background_color":0X500066FF}}
button = ui.Button(name, height=height, width=120, tooltip=tooltip, style=style)
button.spacing = spacing
return button
def create_button_type2(name, tooltip, pic, height=40, spacing=-75):
style={
"Button":{"stack_direction":ui.Direction.LEFT_TO_RIGHT},
"Button.Image":{# "color":0xffFFFFFF,
"image_url":pic,
"alignment":ui.Alignment.CENTER,},
"Button.Label":{"alignment":ui.Alignment.CENTER},
"background_color":0x10CCCCCC,
":hovered":{
"background_gradient_color":0X500066FF,
"background_color":main_color},
"Button:pressed:":{"background_color":0xff000000}}
button = ui.Button(name, height=height, tooltip=tooltip, style=style)
button.spacing = spacing
return button
def create_button_type3(tooltip, pic, height=50):
style = {
"Button":{"stack_direction":ui.Direction.TOP_TO_BOTTOM},
"Button.Image":{# "color":0xffFFFFFF,
"image_url":pic,
"alignment":ui.Alignment.CENTER,},
"Button.Label":{"alignment":ui.Alignment.CENTER},
"border_radius": 4,
":hovered":{
"background_gradient_color":main_color,
"background_color":0X500066FF}}
button = ui.Button("", height = height, style = style, tooltip = tooltip)
return button |
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/config/extension.toml | [package]
# Semantic Versionning is used: https://semver.org/
version = "1.1.0"
# The title and description fields are primarily for displaying extension info in UI
title = "exploded view"
description="This extension provides an easy and reliable way to create exploded view for selected prims."
# Path (relative to the root) or content of readme markdown file for UI.
icon = "data/title.png"
preview_image = "data/1.png"
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
# URL of the extension source repository.
# repository = "https://github.com"
# One of categories for UI.
category = "Other"
# Keywords for the extension
keywords = ["kit", "Layout Authoring", "Omni.ui", "Exploded View", "HNADI", "HC"]
# Use omni.ui to build simple UI
[dependencies]
"omni.kit.uiapp" = {}
# Main python module this extension provides, it will be publicly available as "import omni.tools.quick_array".
[[python.module]]
name = "hnadi.tools.exploded_view" |
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/docs/README.md | ## Adding This Extension
1. Download the package.
2. Go into the local address where you install Omniverse apps (code or create).
3. Just put the whole folder into "exts" or "extscache" folders where other extensions are installed. Both folders are OK.
## Using This Extension
An exploded view is very useful to show the details of products in many fields like architecture and mechanical engineering...
This extension provides an easy and reliable way to make exploded view in Omniverse.
### Step1: Match the formats
* Because of the core algorithm reads and manipulates the transform: translate and xformOp: translate: pivot attribute of prims,
before selecting, every single item needs to have a proper pivot coordinate around its geometric center,
as well as the parent group if you want to choose it immediately.
If the formats do not match, change the model in DCC, or directly change their properties if already imported in Omniverse.
### Step2: Create the Exploded Model
1. Select a group or all items at once and click the "Select Prims" button.
2. Change the X, Y, and Z ratio to control the explosion distance in different directions.
3. Change the coordinates of Pivot to control the explosion centre.
* All items in the Exploded_Model will change dynamically with the change of X, Y, Z ratio and Pivot.
### Step3: Edit the Exploded Model
1. Select prims and click the "Add" or "Remove" button to add or remove them into or from the existed Exploded_Model.
2. Select prims and click the "Bind" button if you want to keep the relative distances of selected items during explosion.
3. Select a group and click the "Unbind" button to unleash their relative distances during explosion.
* The Pivot of the Exploded_Model will change dynamically with adding or removing prims.
### Other Functions
1. Click the "Axono" button and adjust the distance of the camera if you want an axonometric view.
2. Click the "Eye" button to hide or show the ORIGINAL prims.
3. Click the "Reset" button to reset the X, Y, Z ratio and Pivot.
4. Click the "Clear" button to delete the Exploded_Model.
### Future Development
* Add some animation functions to show the process of explosion.
* Improve the running speed and manipulation logic.
If you have any other questions about this extension, welcome to send the message or contact [email protected]. |
HC2ER/OmniverseExtension-hnadi.tools.exploded_view/data/image_path.py | from os import path
class image_path:
D = path.dirname(__file__)
add1 = D + "/add1.png"
Axono = D + "/Axono.png"
bind = D + "/bind.png"
clear = D + "/clear.png"
hide_show = D + "/hide&show.png"
preview = D + "/preview.png"
remove1 = D + "/remove1.png"
reset = D + "/reset.png"
select = D + "/select.png"
title = D + "/title.png"
unbind = D + "/unbind.png"
|
gazebosim/gz-omni/PACKAGE-INFO.yaml | Package : ignition-conection
Version : 000-linux-x86_64
Maintainers : N/A
Description : N/A
Repository : https://github.com/ignitionrobotics/ign-omni
Branch : main
|
gazebosim/gz-omni/prebuild.sh | #!/bin/bash
set -e
SCRIPT_DIR=$(dirname ${BASH_SOURCE})
# inject "-p linux-x86_64" as the default if no target platform is specified
for i in "$@"
do
case $i in
-p=*|--platform-target=*|-p|--platform-target)
PLATFORM_TARGET_SET=1
;;
esac
done
ARGS_ARRAY=("$@")
if [ -z "$PLATFORM_TARGET_SET" ]; then
ARGS_ARRAY+=("-p linux-x86_64")
fi
ARGS_ARRAY_FLATTENED="${ARGS_ARRAY[@]}"
source "$SCRIPT_DIR/tools/packman/python.sh" "$SCRIPT_DIR/tools/repoman/build.py" --generateprojects-only ${ARGS_ARRAY_FLATTENED[@]} || exit $?
source "$SCRIPT_DIR/tools/packman/python.sh" "$SCRIPT_DIR/tools/repoman/filecopy.py" ${ARGS_ARRAY_FLATTENED[@]} "$SCRIPT_DIR/tools/buildscripts/pre_build_copies.json" || exit $?
|
gazebosim/gz-omni/CHANGELOG.md |