| Curcl::comm::BinParser | Handles a byte buffer and functionality to iteratively parse the content |
| Cmoodycamel::ReaderWriterQueue< T, MAX_BLOCK_SIZE >::Block | |
| Cmoodycamel::BlockingReaderWriterQueue< T, MAX_BLOCK_SIZE > | |
| Cmoodycamel::BlockingReaderWriterQueue< std::unique_ptr< T > > | |
| Cmoodycamel::BlockingReaderWriterQueue< std::unique_ptr< urcl::rtde_interface::DataPackage > > | |
| Cmoodycamel::BlockingReaderWriterQueue< std::unique_ptr< urcl::rtde_interface::RTDEPackage > > | |
| ▼Curcl::comm::IConsumer< T > | Parent class for for arbitrary consumers |
| Curcl::comm::MultiConsumer< T > | Consumer, that allows one product to be consumed by multiple arbitrary conusmers |
| Curcl::comm::ShellConsumer< T > | The ShellConsumer class is a simple consumer that writes a readable representation to the logging info channel |
| ▼Curcl::comm::IConsumer< primary_interface::PrimaryPackage > | |
| Curcl::CalibrationChecker | Consumes primary packages ignoring all but KinematicsInfo packages. These are then checked against the used kinematics to see if the correct calibration is used |
| ▼Curcl::comm::IConsumer< PrimaryPackage > | |
| Curcl::primary_interface::AbstractPrimaryConsumer | Base consumer for primary packages |
| Curcl::comm::IConsumer< urcl::rtde_interface::RTDEPackage > | |
| Curcl::comm::INotifier | Parent class for notifiers |
| ▼Curcl::comm::IProducer< T > | Parent class for arbitrary producers of packages |
| Curcl::comm::URProducer< T > | A general producer for URPackages. Implements funcionality to produce packages by reading and parsing from a byte stream |
| ▼Curcl::comm::IProducer< urcl::rtde_interface::RTDEPackage > | |
| Curcl::comm::URProducer< urcl::rtde_interface::RTDEPackage > | |
| Cmoodycamel::spsc_sema::LightweightSemaphore | |
| Curcl::Limited< T > | Helper class that represents a numeric value with a lower and an upper boundary |
| Curcl::Limited< float > | |
| Curcl::Limited< uint32_t > | |
| Curcl::Logger | |
| ▼Curcl::LogHandler | Inherit from this class to change the behavior when logging messages |
| Curcl::DefaultLogHandler | LogHandler object for default handling of logging messages. This class is used when no other LogHandler is registered |
| Curcl::primary_interface::PackageHeader | This class represents the header for primary packages |
| Curcl::rtde_interface::PackageHeader | This class represents the header for RTDE packages |
| Curcl::comm::PackageSerializer | A helper class to serialize packages. Contains methods for serializing all relevant datatypes |
| Curcl::comm::Parser< T > | The parser is a general paser. The namsepace rtde_interface and primary_interface both iclude classes which inherit from it (rtdeParser and primaryParser). The parser functionality also embodies a factory function taking in an uint8 |
| ▼Curcl::comm::Parser< PrimaryPackage > | |
| Curcl::primary_interface::PrimaryParser | The primary specific parser. Interprets a given byte stream as serialized primary packages and parses it accordingly |
| ▼Curcl::comm::Parser< RTDEPackage > | |
| Curcl::rtde_interface::RTDEParser | The RTDE specific parser. Interprets a given byte stream as serialized RTDE packages and parses it accordingly |
| Curcl::comm::Parser< urcl::rtde_interface::RTDEPackage > | |
| Curcl::comm::Pipeline< T > | The Pipepline manages the production and optionally consumption of packages. Cyclically the producer is called and returned packages are saved in a queue. This queue is then either also cyclically utilized by the registered consumer or can be externally used |
| Curcl::comm::Pipeline< urcl::rtde_interface::RTDEPackage > | |
| Cmoodycamel::ReaderWriterQueue< T, MAX_BLOCK_SIZE > | |
| Cmoodycamel::ReaderWriterQueue< std::unique_ptr< T >, 512 > | |
| Cmoodycamel::ReaderWriterQueue< std::unique_ptr< urcl::rtde_interface::DataPackage >, 512 > | |
| Cmoodycamel::ReaderWriterQueue< std::unique_ptr< urcl::rtde_interface::RTDEPackage >, 512 > | |
| Cmoodycamel::ReaderWriterQueue< T, MAX_BLOCK_SIZE >::ReentrantGuard | |
| Curcl::comm::ReverseInterface | Handles communication to the robot. It starts a server and waits for the robot to connect via its URCaps program |
| Curcl::rtde_interface::RTDEClient | Manages communication over the RTDE interface. It contains the RTDE handshake and read and write functionality to and from the robot |
| Curcl::rtde_interface::RTDEWriter | Offers an abstraction layer to send data to the robot via the RTDE interface. Several simple to use functions to create data packages to send exist, which are then sent to the robot in an additional thread |
| ▼Cruntime_error | |
| ▼Curcl::UrException | Our base class for exceptions. Specialized exceptions should inherit from those |
| Curcl::TimeoutException | A specialized exception representing that communication to the tool is not possible |
| ▼Curcl::VersionMismatch | A specialized exception representing detection of a not supported UR control version |
| Curcl::ToolCommNotAvailable | A specialized exception representing that communication to the tool is not possible |
| Curcl::comm::ScriptSender | Starts a TCPServer for a robot to connect to and waits for a request to receive a program. This program is then delivered to the requesting robot |
| ▼Cstatic_visitor | |
| Curcl::rtde_interface::DataPackage::ParseVisitor | |
| Curcl::rtde_interface::DataPackage::SerializeVisitor | |
| Curcl::rtde_interface::DataPackage::SizeVisitor | |
| Curcl::rtde_interface::DataPackage::StringVisitor | |
| Curcl::comm::TCPServer | Wrapper class for a TCP socket server |
| ▼Curcl::comm::TCPSocket | Class for TCP socket abstraction |
| CTCPServerTest::Client | |
| Curcl::comm::URStream< T > | The stream is an abstraction of the TCPSocket that offers reading a full UR data package out of the socket. This means, it has to have some knowledge about the package structure to peek at the field defining the package length. This is why it is templated with the package header type |
| Curcl::DashboardClient | This class is a wrapper around the dashboard server |
| Curcl::comm::URStream< urcl::rtde_interface::RTDEPackage > | |
| ▼CTest | |
| CTCPServerTest | |
| Curcl::ToolCommSetup | Class holding a tool communication configuration |
| Curcl::UrDriver | This is the main class for interfacing the driver |
| Curcl::comm::URPackage< HeaderT > | The URPackage a parent class. From that two implementations are inherited, one for the primary, one for the rtde interface (primary_interface::primaryPackage; rtde_interface::rtdePackage). The URPackage makes use of the template HeaderT |
| ▼Curcl::comm::URPackage< PackageHeader > | |
| ▼Curcl::primary_interface::PrimaryPackage | The PrimaryPackage is solely an abstraction level. It inherits form the URPackage and is also a parent class for primary_interface::RobotMessage, primary_interface::RobotState |
| ▼Curcl::primary_interface::RobotMessage | Parent class for the different received robot messages |
| Curcl::primary_interface::VersionMessage | Handles the version messages sent via the primary UR interface |
| ▼Curcl::primary_interface::RobotState | Base class for a RobotState data packages will be used directly |
| Curcl::primary_interface::KinematicsInfo | This messages contains information about the robot's calibration. The DH parameters are a combination between the perfect model parameters and the correction deltas as noted in the configuration files on the robot controller |
| ▼Curcl::rtde_interface::RTDEPackage | |
| Curcl::rtde_interface::ControlPackagePause | This class handles the robot's response to a requested stop in RTDE data package communication |
| Curcl::rtde_interface::ControlPackagePauseRequest | This class is used to request a stop in RTDE data package communication |
| Curcl::rtde_interface::ControlPackageSetupInputs | This class handles the robot's response to a requested input recipe setup |
| Curcl::rtde_interface::ControlPackageSetupInputsRequest | This class is used to setup the input recipe as part of the initial RTDE handshake |
| Curcl::rtde_interface::ControlPackageSetupOutputs | This class handles the robot's response to a requested output recipe setup |
| Curcl::rtde_interface::ControlPackageSetupOutputsRequest | This class is used to setup the output recipe as part of the initial RTDE handshake |
| Curcl::rtde_interface::ControlPackageStart | This class handles the robot's response to a requested start in RTDE data package communication |
| Curcl::rtde_interface::ControlPackageStartRequest | This class is used to request a stop in RTDE data package communication |
| Curcl::rtde_interface::DataPackage | Handles communication in the form of RTDE data packages both to and from the robot. It contains functionality to parse and serialize packages for arbitrary recipes |
| Curcl::rtde_interface::GetUrcontrolVersion | This class handles the package detailing the UR control version sent by the robot |
| Curcl::rtde_interface::GetUrcontrolVersionRequest | This class is used to request the used UR control version from the robot |
| Curcl::rtde_interface::RequestProtocolVersion | This class handles the robot's response after trying to set the used RTDE protocol version |
| Curcl::rtde_interface::RequestProtocolVersionRequest | This class handles producing a request towards the robot to use a specific RTDE protocol version |
| Curcl::rtde_interface::TextMessage | This class handles RTDE text messages sent by the robot |
| Curcl::VersionInformation | Struct containing a robot's version information |
| Cmoodycamel::WeakAtomic< T > | |
| Cmoodycamel::WeakAtomic< moodycamel::ReaderWriterQueue::Block * > | |
| Cmoodycamel::WeakAtomic< size_t > | |
| Cmoodycamel::WeakAtomic< ssize_t > | |