/**
* The last will message of the mobile robot. Has to be sent with retain flag. Once the
* mobile robot comes online, it has to send this message on its connect topic, with the
* connectionState enum set to "ONLINE". The last will message is to be configured with the
* connection state set to "CONNECTIONBROKEN".
* Thus, if the mobile robot disconnects from the broker, fleet control gets notified via
* the topic "connection". If the mobile robot is disconnecting in an orderly fashion (e.g.
* shutting down, sleeping), the mobile robot is to publish a message on this topic with the
* connectionState set to "DISCONNECTED".
*/
export interface Connection {
/**
* ONLINE: connection between mobile robot and broker is active. OFFLINE: connection between
* mobile robot and broker has gone offline in a coordinated way. HIBERNATING: connection
* between mobile robot and broker is active, but mobile robot does not state messages. This
* mode is intended for power-saving or communication reduction. The mobile robot can resume
* to ONLINE when instructed. CONNECTION_BROKEN: The connection between mobile robot and
* broker has unexpectedly ended.
*/
connectionState: ConnectionState;
/**
* Header ID of the message. The headerId is defined per topic and incremented by 1 with
* each sent (but not necessarily received) message.
*/
headerId: number;
/**
* Manufacturer of the mobile robot.
*/
manufacturer: string;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
[property: string]: any;
}
/**
* ONLINE: connection between mobile robot and broker is active. OFFLINE: connection between
* mobile robot and broker has gone offline in a coordinated way. HIBERNATING: connection
* between mobile robot and broker is active, but mobile robot does not state messages. This
* mode is intended for power-saving or communication reduction. The mobile robot can resume
* to ONLINE when instructed. CONNECTION_BROKEN: The connection between mobile robot and
* broker has unexpectedly ended.
*/
export declare enum ConnectionState {
ConnectionBroken = "CONNECTION_BROKEN",
Hibernating = "HIBERNATING",
Offline = "OFFLINE",
Online = "ONLINE"
}
/**
* The factsheet provides basic information about a specific mobile robot type series. This
* information allows comparison of different mobile robot types and can be applied for the
* planning, dimensioning and simulation of a mobile robot system. The factsheet also
* includes information about mobile robot communication interfaces which are required for
* the integration of a mobile robot type series into a VD[M]A-5050-compliant fleet control.
*/
export interface Factsheet {
/**
* Header ID of the message. The headerId is defined per topic and incremented by 1 with
* each sent (but not necessarily received) message.
*/
headerId: number;
/**
* Abstract specification of load capabilities
*/
loadSpecification: LoadSpecification;
/**
* Manufacturer of the mobile robot
*/
manufacturer: string;
mobileRobotConfiguration?: MobileRobotConfiguration;
/**
* Detailed definition of mobile robot geometry
*/
mobileRobotGeometry: MobileRobotGeometry;
/**
* These parameters specify the basic physical properties of the mobile robot
*/
physicalParameters: PhysicalParameters;
/**
* Supported features of VDA5050 protocol
*/
protocolFeatures: ProtocolFeatures;
/**
* This JSON-object describes the protocol limitations of the mobile robot. If a parameter
* is not defined or set to zero then there is no explicit limit for this parameter.
*/
protocolLimits: ProtocolLimits;
/**
* Serial number of the mobile robot
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* These parameters generally specify the class and the capabilities of the mobile robot
*/
typeSpecification: TypeSpecification;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
[property: string]: any;
}
/**
* Abstract specification of load capabilities
*/
export interface LoadSpecification {
/**
* List of load positions / load handling devices. This lists contains the valid values for
* the parameter “state.loads[].loadPosition” and for the action parameter “lhd” of the
* actions pick and drop. If this list doesn’t exist or is empty, the mobile robot has no
* load handling device.
*/
loadPositions?: string[];
/**
* List of load-sets that can be handled by the mobile robot
*/
loadSets?: LoadSet[];
[property: string]: any;
}
export interface LoadSet {
/**
* Bounding box reference as defined in parameter loads[] in state-message
*/
boundingBoxReference?: LoadSetBoundingBoxReference;
/**
* Free text description of the load handling set
*/
description?: string;
/**
* Approximate time for dropping the load
*/
dropTime?: number;
loadDimensions?: LoadSetLoadDimensions;
/**
* List of load positions btw. load handling devices, this load-set is valid for. If this
* parameter does not exist or is empty, this load-set is valid for all load handling
* devices on this mobile robot.
*/
loadPositions?: string[];
/**
* Type of load e.g., EPAL, XLT1200, ….
*/
loadType: string;
/**
* Maximum allowed acceleration for this load-type and –weight
*/
maximumAcceleration?: number;
/**
* Maximum allowed deceleration for this load-type and –weight
*/
maximumDeceleration?: number;
/**
* Maximum allowed depth for this load-type and –weight. references to boundingBoxReference
*/
maximumLoadhandlingDepth?: number;
/**
* Maximum allowed height for handling of this load-type and –weight. references to
* boundingBoxReference
*/
maximumLoadhandlingHeight?: number;
/**
* Maximum allowed tilt for this load-type and –weight
*/
maximumLoadhandlingTilt?: number;
/**
* Maximum allowed speed for this load-type and –weight
*/
maximumSpeed?: number;
/**
* Maximum weight of loadtype
*/
maximumWeight?: number;
/**
* Minimum allowed depth for this load-type and –weight. references to boundingBoxReference
*/
minimumLoadhandlingDepth?: number;
/**
* Minimum allowed height for handling of this load-type and –weight. References to
* boundingBoxReference
*/
minimumLoadhandlingHeight?: number;
/**
* Minimum allowed tilt for this load-type and –weight
*/
minimumLoadhandlingTilt?: number;
/**
* Approximate time for picking up the load
*/
pickTime?: number;
/**
* Unique name of the load set, e.g., DEFAULT, SET1, ...
*/
setName: string;
[property: string]: any;
}
/**
* Bounding box reference as defined in parameter loads[] in state-message
*/
export interface LoadSetBoundingBoxReference {
/**
* Orientation of the loads bounding box. Important for tugger trains, etc.
*/
theta?: number;
/**
* X-coordinate of the point of reference.
*/
x: number;
/**
* Y-coordinate of the point of reference.
*/
y: number;
/**
* Z-coordinate of the point of reference.
*/
z: number;
[property: string]: any;
}
export interface LoadSetLoadDimensions {
/**
* Absolute height of the load´s bounding box. Optional: Set value only if known.
*/
height?: number;
/**
* Absolute length (along the mobile robot’s coordinate system’s x-axis) of the load's
* bounding box in meters.
*/
length: number;
/**
* Absolute width (along the mobile robot’s coordinate system’s y-axis) of the load's
* bounding box in meters.
*/
width: number;
[property: string]: any;
}
export interface MobileRobotConfiguration {
/**
* Information about battery charging parameters.
*/
"batteryCharging "?: BatteryCharging;
/**
* Information about the mobile robot's network connection. The listed information shall not
* be updated while the mobile robot is operating.
*/
network?: Network;
/**
* Array containing various hardware and software versions running on the mobile robot.
*/
versions?: Version[];
[property: string]: any;
}
/**
* Information about battery charging parameters.
*/
export interface BatteryCharging {
/**
* Specifies the critical charging level in percent at or below which the fleet control
* should only send orders that command the mobile robot to a charging station.
*/
criticalLowChargingLevel?: number;
/**
* Specifies the maximum desired charging level in percent.
*/
maximumDesiredChargingLevel?: number;
/**
* Specifies the desired minimum charging time in seconds.
*/
minimumChargingTime?: number;
/**
* Specifies the minimum desired charging level in percent.
*/
minimumDesiredChargingLevel?: number;
[property: string]: any;
}
/**
* Information about the mobile robot's network connection. The listed information shall not
* be updated while the mobile robot is operating.
*/
export interface Network {
/**
* Default gateway used by the mobile robot.
*/
defaultGateway?: string;
/**
* List of DNS servers used by the mobile robot.
*/
dnsServers?: string[];
/**
* A priori assigned IP address of the mobile robot used to communicate with the MQTT
* broker. Note that this IP address should not be modified/changed during operations.
*/
localIpAddress?: string;
/**
* Network subnet mask.
*/
netmask?: string;
/**
* List of NTP servers used by the mobile robot.
*/
ntpServers?: string[];
[property: string]: any;
}
export interface Version {
/**
* The key of the version.
*/
key: string;
/**
* The value of the version.
*/
value: string;
[property: string]: any;
}
/**
* Detailed definition of mobile robot geometry
*/
export interface MobileRobotGeometry {
envelopes2d?: Envelopes2D[];
/**
* List of mobile robot envelope curves in 3D (german: „Hüllkurven“)
*/
envelopes3d?: Envelopes3D[];
/**
* List of wheels, containing wheel-arrangement and geometry
*/
wheelDefinitions?: WheelDefinition[];
[property: string]: any;
}
export interface Envelopes2D {
/**
* Free text: description of envelope curve set
*/
description?: string;
/**
* Identifier of the envelope curve set.
*/
envelope2dId: string;
/**
* The envelope curve in defined as a polygon. It shall be assumed as closed. Only simple
* polygons shall be used.
*/
vertices: Envelopes2DVertex[];
[property: string]: any;
}
export interface Envelopes2DVertex {
/**
* X-position of polygon-point
*/
x: number;
/**
* Y-position of polygon-point
*/
y: number;
[property: string]: any;
}
export interface Envelopes3D {
/**
* 3D-envelope curve data, format specified in ‚format‘
*/
data?: {
[key: string]: any;
};
/**
* Free text: description of envelope curve set
*/
description?: string;
/**
* Identifier of the envelope curve set.
*/
envelope3dId: string;
/**
* Format of data, e.g., DXF
*/
format: string;
/**
* Protocol and url-definition for downloading the 3D-envelope curve data, e.g.,
* ftp://xxx.yyy.com/ac4dgvhoif5tghji
*/
url?: string;
[property: string]: any;
}
export interface WheelDefinition {
/**
* Nominal displacement of the wheel’s center to the rotation point (necessary for caster
* wheels). If the parameter is not defined, it is assumed to be 0
*/
centerDisplacement?: number;
/**
* Free text: can be used by the manufacturer to define constraints
*/
constraints?: string;
/**
* Nominal diameter of wheel
*/
diameter: number;
/**
* True: wheel is actively driven
*/
isActiveDriven: boolean;
/**
* True: wheel is actively steered
*/
isActiveSteered: boolean;
position: Position;
/**
* Wheel type. Extensible enum: DRIVE, CASTER, FIXED, MECANUM
*/
type: string;
/**
* Nominal width of wheel
*/
width: number;
[property: string]: any;
}
export interface Position {
/**
* Orientation of wheel in mobile robot coordinate system Necessary for fixed wheels
*/
theta?: number;
/**
* X-position in mobile robot coordinate system
*/
x: number;
/**
* Y-position in mobile robot coordinate system
*/
y: number;
[property: string]: any;
}
/**
* These parameters specify the basic physical properties of the mobile robot
*/
export interface PhysicalParameters {
/**
* Length of the mobile robot
*/
length: number;
/**
* Maximum acceleration with maximum load
*/
maximumAcceleration: number;
/**
* Maximum rotation speed of the mobile robot
*/
maximumAngularSpeed?: number;
/**
* Maximum deceleration with maximum load
*/
maximumDeceleration: number;
/**
* Maximum height of mobile robot
*/
maximumHeight: number;
/**
* Maximum speed of the mobile robot
*/
maximumSpeed: number;
/**
* Minimal controlled continuous rotation speed of the mobile robot
*/
minimumAngularSpeed?: number;
/**
* Minimum height of mobile robot
*/
minimumHeight: number;
/**
* Minimal controlled continuous speed of the mobile robot
*/
minimumSpeed: number;
/**
* Width of the mobile robot
*/
width: number;
[property: string]: any;
}
/**
* Supported features of VDA5050 protocol
*/
export interface ProtocolFeatures {
/**
* List of all actions with parameters supported by this mobile robot. This includes
* standard actions specified in VDA 5050 and manufacturer-specific actions
*/
mobileRobotActions: MobileRobotAction[];
/**
* List of supported and/or required optional parameters. Optional parameters, that are not
* listed here, are assumed to be not supported by the mobile robot.
*/
optionalParameters: OptionalParameter[];
[property: string]: any;
}
export interface MobileRobotAction {
/**
* Free text: description of the action
*/
actionDescription?: string;
/**
* Kist of parameters. if not defined, the action has no parameters
*/
actionParameters?: MobileRobotActionActionParameter[];
/**
* Free text: description of the result
*/
actionResult?: string;
/**
* List of allowed scopes for using this action-type. INSTANT: usable as instantAction,
* NODE: usable on nodes, EDGE: usable on edges, ZONE: usable as zone action.
*/
actionScopes: ActionScope[];
/**
* Unique actionType corresponding to action.actionType
*/
actionType: string;
/**
* Array of possible blocking types for defined action.
*/
blockingTypes?: BlockingTypeElement[];
/**
* True: action can be cancelled via cancelOrder. False: action cannot be cancelled.
*/
cancelAllowed: string;
/**
* True: action can be paused via startPause. False: action cannot be paused.
*/
pauseAllowed: string;
[property: string]: any;
}
export interface MobileRobotActionActionParameter {
/**
* Free text: description of the parameter
*/
description?: string;
/**
* True: optional parameter
*/
isOptional?: boolean;
/**
* Key-String for Parameter
*/
key: string;
/**
* Data type of Value, possible data types are: BOOL, NUMBER, INTEGER, STRING, OBJECT, ARRAY
*/
valueDataType: ValueDataType;
[property: string]: any;
}
/**
* Data type of Value, possible data types are: BOOL, NUMBER, INTEGER, STRING, OBJECT, ARRAY
*/
export declare enum ValueDataType {
Array = "ARRAY",
Bool = "BOOL",
Integer = "INTEGER",
Number = "NUMBER",
Object = "OBJECT",
String = "STRING"
}
export declare enum ActionScope {
Edge = "EDGE",
Instant = "INSTANT",
Node = "NODE",
Zone = "ZONE"
}
/**
* Regulates if the action is allowed to be executed during movement and/or parallel to
* other actions. NONE: allows driving and other actions; SINGLE: allows driving but no
* other actions; SOFT: allows other actions but not driving; HARD: is the only allowed
* action at that time.
*/
export declare enum BlockingTypeElement {
Hard = "HARD",
None = "NONE",
Single = "SINGLE",
Soft = "SOFT"
}
export interface OptionalParameter {
/**
* Free text. Description of optional parameter. E.g., reason, why the optional parameter
* ‚direction‘ is necessary for this mobile robot type and which values it can contain. The
* parameter ‘nodeMarker’ must contain unsigned interger-numbers only. Nurbs-Support is
* limited to straight lines and circle segments.
*/
description?: string;
/**
* Full name of optional parameter, e.g., “order.nodes.nodePosition.allowedDeviationTheta”
*/
parameter: string;
/**
* Type of support for the optional parameter, the following values are possible: SUPPORTED:
* optional parameter is supported like specified. REQUIRED: optional parameter is required
* for proper mobile robot operation.
*/
support: Support;
[property: string]: any;
}
/**
* Type of support for the optional parameter, the following values are possible: SUPPORTED:
* optional parameter is supported like specified. REQUIRED: optional parameter is required
* for proper mobile robot operation.
*/
export declare enum Support {
Required = "REQUIRED",
Supported = "SUPPORTED"
}
/**
* This JSON-object describes the protocol limitations of the mobile robot. If a parameter
* is not defined or set to zero then there is no explicit limit for this parameter.
*/
export interface ProtocolLimits {
/**
* Maximum lengths of arrays
*/
maximumArrayLengths: MaximumArrayLengths;
/**
* Maximum lengths of strings
*/
maximumStringLengths: MaximumStringLengths;
/**
* Timing information
*/
timing: Timing;
[property: string]: any;
}
/**
* Maximum lengths of arrays
*/
export interface MaximumArrayLengths {
/**
* Maximum number of parameters per action processable by the mobile robot
*/
"actions.actionsParameters"?: number;
/**
* Maximum number of actions per edge processable by the mobile robot
*/
"edge.actions"?: number;
/**
* Maximum number of error references sent by the mobile robot for each error
*/
"error.errorReferences"?: number;
/**
* Maximum number of info references sent by the mobile robot for each information
*/
"information.infoReferences"?: number;
/**
* Maximum number of instant actions per message processable by the mobile robot
*/
instantActions?: number;
/**
* Maximum number of actions per node processable by the mobile robot
*/
"node.actions"?: number;
/**
* Maximum number of edges per order processable by the mobile robot
*/
"order.edges"?: number;
/**
* Maximum number of nodes per order processable by the mobile robot
*/
"order.nodes"?: number;
/**
* Maximum number of actionStates sent by the mobile robot
*/
"state.actionStates"?: number;
/**
* Maximum number of edgeStates sent by the mobile robot, maximum number of edges in base of
* mobile robot
*/
"state.edgeStates"?: number;
/**
* Maximum number of errors sent by the mobile robot in one state-message
*/
"state.errors"?: number;
/**
* Maximum number of information objects sent by the mobile robot in one state-message
*/
"state.information"?: number;
/**
* Maximum number of instantActionStates sent by the mobile robot
*/
"state.instantActionStates"?: number;
/**
* Maximum number of load-objects sent by the mobile robot
*/
"state.loads"?: number;
/**
* Maximum number of nodeStates sent by the mobile robot, maximum number of nodes in base of
* mobile robot
*/
"state.nodeStates"?: number;
/**
* Maximum number of zoneActionStates sent by the mobile robot
*/
"state.zoneActionStates"?: number;
/**
* Maximum number of control points per trajectory processable by the mobile robot
*/
"trajectory.controlPoints"?: number;
/**
* Maximum number of knots per trajectory processable by the mobile robot
*/
"trajectory.knotVector"?: number;
/**
* Maximum number of zones per zoneSet processable by the mobile robot
*/
"zoneSet.zones"?: number;
[property: string]: any;
}
/**
* Maximum lengths of strings
*/
export interface MaximumStringLengths {
/**
* If true ID-strings need to contain numerical values only
*/
idNumericalOnly?: boolean;
/**
* Maximum length of ID-Strings. Affected parameters: order.orderId, node.nodeId,
* nodePosition.mapId, action.actionId, edge.edgeId
*/
maximumIdLength?: number;
/**
* Maximum length of loadId Strings
*/
maximumLoadIdLength?: number;
/**
* Maximum MQTT Message length
*/
maximumMessageLength?: number;
/**
* Maximum length of all other parts in MQTT-topics. Affected parameters: order.timestamp,
* order.version, order.manufacturer, instantActions.timestamp, instantActions.version,
* instantActions.manufacturer, state.timestamp, state.version, state.manufacturer,
* visualization.timestamp, visualization.version, visualization.manufacturer,
* connection.timestamp, connection.version, connection.manufacturer
*/
maximumTopicElementLength?: number;
/**
* Maximum length of serial-number part in MQTT-topics. Affected Parameters:
* order.serialNumber, instantActions.serialNumber, state.SerialNumber,
* visualization.serialNumber, connection.serialNumber
*/
maximumTopicSerialLength?: number;
[property: string]: any;
}
/**
* Timing information
*/
export interface Timing {
/**
* Default interval for sending state-messages if not defined, the default value from the
* main document is used
*/
defaultStateInterval?: number;
/**
* Minimum interval sending order messages to the mobile robot
*/
minimumOrderInterval: number;
/**
* Minimum interval for sending state-messages
*/
minimumStateInterval: number;
/**
* Default interval for sending messages on visualization topic
*/
visualizationInterval?: number;
[property: string]: any;
}
/**
* These parameters generally specify the class and the capabilities of the mobile robot
*/
export interface TypeSpecification {
/**
* Simplified description of localization type.
*/
localizationTypes: string[];
/**
* Maximum loadable mass
*/
maximumLoadMass: number;
/**
* Simplified description of mobile robot class. Extensible enum: FORKLIFT, CONVEYOR,
* TUGGER, CARRIER
*/
mobileRobotClass: string;
/**
* Simplified description of mobile robots kinematics-type. Extensible enum: DIFFERENTIAL,
* OMNIDIRECTIONAL, THREE_WHEEL
*/
mobileRobotKinematics?: string;
/**
* List of path planning types supported by the mobile robot, sorted by priority
*/
navigationTypes: string[];
/**
* Free text human readable description of the mobile robot type series
*/
seriesDescription?: string;
/**
* Free text generalized series name as specified by manufacturer
*/
seriesName: string;
/**
* Array of zone types supported by the mobile robot.
*/
supportedZones?: ZoneType[];
mobileRobotKinematic: any;
[property: string]: any;
}
/**
* Zone category.
*/
export declare enum ZoneType {
Action = "ACTION",
Bidirected = "BIDIRECTED",
Blocked = "BLOCKED",
CoordinatedReplanning = "COORDINATED_REPLANNING",
Directed = "DIRECTED",
LineGuided = "LINE_GUIDED",
Penalty = "PENALTY",
Priority = "PRIORITY",
Release = "RELEASE",
SpeedLimit = "SPEED_LIMIT"
}
/**
* JSON Schema for publishing instantActions that the mobile robot is to execute as soon as
* they arrive.
*/
export interface InstantActions {
actions: InstantActionsAction[];
/**
* headerId of the message. The headerId is defined per topic and incremented by 1 with each
* sent (but not necessarily received) message.
*/
headerId: number;
/**
* Manufacturer of the mobile robot
*/
manufacturer: string;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
[property: string]: any;
}
/**
* Describes an action that the mobile robot can perform.
*/
export interface InstantActionsAction {
/**
* Additional information on the action.
*/
actionDescriptor?: string;
/**
* Unique ID to identify the action and map them to the actionState in the state.
* Suggestion: Use UUID.
*/
actionId: string;
/**
* Action parameters for the indicated action, e.g., deviceId, loadId, external Triggers.
*/
actionParameters?: PurpleActionParameter[];
/**
* Name of action. Identifies the function of the action.
*/
actionType: string;
/**
* The blocking type of an instant action is always NONE: action can happen in parallel with
* others, including movement.
*/
blockingType: PurpleBlockingType;
[property: string]: any;
}
export interface PurpleActionParameter {
/**
* The key of the action parameter.
*/
key: string;
/**
* The value of the action parameter
*/
value: any[] | boolean | number | number | {
[key: string]: any;
} | string;
[property: string]: any;
}
/**
* The blocking type of an instant action is always NONE: action can happen in parallel with
* others, including movement.
*/
export declare enum PurpleBlockingType {
None = "NONE"
}
/**
* The message schema to communicate orders from fleet control to the mobile robot.
*/
export interface Order {
/**
* Directional connection between two nodes. Array of edge objects to be traversed for
* fulfilling the order. One node is enough for a valid order. Leave edge list empty for
* that case.
*/
edges: Edge[];
/**
* headerId of the message. The headerId is defined per topic and incremented by 1 with each
* sent (but not necessarily received) message.
*/
headerId: number;
/**
* Manufacturer of the mobile robot
*/
manufacturer: string;
/**
* Array of nodes objects to be traversed for fulfilling the order. One node is enough for a
* valid order. Leave edge list empty for that case.
*/
nodes: Node[];
/**
* Additional human-readable information only for visualization purposes; this shall not be
* used for any logical processes.
*/
orderDescription?: string;
/**
* Order Identification. This is to be used to identify multiple order messages that belong
* to the same order.
*/
orderId: string;
/**
* Order update identification. It is unique per orderId, starting at 0 for a new order. If
* an order update is rejected, this field shall be passed in the rejection message.
*/
orderUpdateId: number;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
[property: string]: any;
}
export interface Edge {
/**
* Array of action objects with detailed information.
*/
actions: EdgeAction[];
corridor?: Corridor;
/**
* Sets direction at junctions for line-guided or wire-guided mobile robots, to be defined
* initially (mobile robot-individual).
*/
direction?: string;
/**
* Additional information on the edge.
*/
edgeDescriptor?: string;
/**
* Identifier of the edge. May not be unique among the edges of the same order.
*/
edgeId: string;
/**
* Distance of the path from the start node to the end node in meters. Optional: This value
* is used by line-guided mobile robots to decrease their speed before reaching a stop
* position.
*/
length?: number;
/**
* Permitted maximum height of the mobile robot, including the load, on edge in meters.
*/
maximumMobileRobotHeight?: number;
/**
* Permitted maximum speed on the edge in m/s. Speed is defined by the fastest measurement
* of the mobile robot.
*/
maximumSpeed?: number;
/**
* Maximum rotation speed in rad/s. Optional: No limit, if not set.
*/
maxRotationSpeed?: number;
/**
* Permitted minimal height of the load handling device on the edge in meters
*/
minimumLoadHandlingDeviceHeight?: number;
/**
* Orientation of the mobile robot on the edge. The value orientationType defines if it has
* to be interpreted relative to the global project specific map coordinate system or
* tangential to the edge. In case of interpreted tangential to the edge 0.0 = forwards and
* PI = backwards. Example: orientation Pi/2 rad will lead to a rotation of 90 degrees. If
* mobile robot starts in different orientation, rotate the mobile robot on the edge to the
* desired orientation if rotationAllowed is set to True. If rotationAllowed is False,
* rotate before entering the edge. If that is not possible, reject the order. If no
* trajectory is defined, apply the rotation to the direct path between the two connecting
* nodes of the edge. If a trajectory is defined for the edge, apply the orientation to the
* trajectory.
*/
orientation?: number;
/**
* Enum {GLOBAL, TANGENTIAL}: GLOBAL: relative to the global project specific map coordinate
* system; TANGENTIAL: tangential to the edge. If not defined, the default value is
* TANGENTIAL.
*/
orientationType?: string;
/**
* True: Desired edge orientation shall be reached before entering the edge. False: Mobile
* robot can rotate into the desired orientation on the edge. Default: False.
*/
reachOrientationBeforeEntering?: boolean;
/**
* True indicates that the edge is part of the base. False indicates that the edge is part
* of the horizon.
*/
released: boolean;
/**
* Number to track the sequence of nodes and edges in an order and to simplify order
* updates. The sequenceId is shared between nodes and edges and defines the sequence of
* traversal.
*/
sequenceId: number;
/**
* Trajectory JSON-object for this edge as a NURBS. Defines the curve, on which the mobile
* robot should move between the start node and the end node. Optional: Can be omitted, if
* mobile robot cannot process trajectories or if mobile robot plans its own trajectory.
*/
trajectory?: Trajectory;
[property: string]: any;
}
/**
* Describes an action that the mobile robot can perform.
*/
export interface EdgeAction {
/**
* Additional information on the action.
*/
actionDescriptor?: string;
/**
* Unique ID to identify the action and map them to the actionState in the state.
* Suggestion: Use UUIDs.
*/
actionId: string;
/**
* Action parameters for the indicated action, e.g., deviceId, loadId, external Triggers.
*/
actionParameters?: FluffyActionParameter[];
/**
* Name of the action. Identifies the function of the action.
*/
actionType: string;
/**
* Regulates if the action is allowed to be executed during movement and/or parallel to
* other actions. NONE: allows driving and other actions; SINGLE: allows driving but no
* other actions; SOFT: allows other actions but not driving; HARD: is the only allowed
* action at that time.
*/
blockingType: BlockingTypeElement;
/**
* True: action can enter RETRIABLE state if it fails. False: action enters FAILED state
* directly after it fails. Default: false.
*/
retriable?: boolean;
[property: string]: any;
}
export interface FluffyActionParameter {
/**
* The key of the action parameter.
*/
key: string;
/**
* The value of the action parameter
*/
value: any[] | boolean | number | number | {
[key: string]: any;
} | string;
[property: string]: any;
}
/**
* Definition of boundaries in which a mobile robot can deviate from its trajectory, e. g.
* to avoid obstacles.
*/
export interface Corridor {
/**
* Defines whether the boundaries are valid for the kinematic center or the contour of the
* mobile robot.
*/
corridorReferencePoint?: CorridorReferencePoint;
/**
* Defines the width of the corridor in meters to the left related to the trajectory of the
* mobile robot.
*/
leftWidth: number;
/**
* Defines how the robot shall behave in case its release of a corridor expires or gets
* revoked by the fleet control. Default: STOP
*/
releaseLossBehavior?: ReleaseLossBehavior;
/**
* Optional flag that indicates if the robot must request approval from the fleet control.
* If not defined, no release is required.
*/
releaseRequired?: boolean;
/**
* Defines the width of the corridor in meters to the right related to the trajectory of the
* mobile robot.
*/
rightWidth: number;
[property: string]: any;
}
/**
* Defines whether the boundaries are valid for the kinematic center or the contour of the
* mobile robot.
*/
export declare enum CorridorReferencePoint {
Contour = "CONTOUR",
KinematicCenter = "KINEMATIC_CENTER"
}
/**
* Defines how the robot shall behave in case its release of a corridor expires or gets
* revoked by the fleet control. Default: STOP
*/
export declare enum ReleaseLossBehavior {
Return = "RETURN",
Stop = "STOP"
}
/**
* Trajectory JSON-object for this edge as a NURBS. Defines the curve, on which the mobile
* robot should move between the start node and the end node. Optional: Can be omitted, if
* mobile robot cannot process trajectories or if mobile robot plans its own trajectory.
*
* Reports the trajectory that has been defined a priori within a layout or was sent for
* this edge as part of the order.
*/
export interface Trajectory {
/**
* List of JSON controlPoint objects defining the control points of the NURBS, which
* includes the beginning and end point.
*/
controlPoints: ControlPoint[];
/**
* Degree of the NURBS curve defining the trajectory. If not defined, the default value is 1.
*/
degree?: number;
/**
* Sequence of parameter values that determines where and how the control points affect the
* NURBS curve.
*/
knotVector?: number[];
[property: string]: any;
}
export interface ControlPoint {
/**
* The weight, with which this control point pulls on the curve. When not defined, the
* default will be 1.0.
*/
weight?: number;
/**
* X coordinate described in the world coordinate system.
*/
x: number;
/**
* Y coordinate described in the world coordinate system.
*/
y: number;
[property: string]: any;
}
export interface Node {
/**
* Array of actions to be executed on a node. Empty array, if no actions required.
*/
actions: EdgeAction[];
/**
* Additional information on the node.
*/
nodeDescriptor?: string;
/**
* Identifier of the node. May not be unique among the nodes of the same order.
*/
nodeId: string;
/**
* Defines the position on a map in a global project-specific world coordinate system. Each
* floor has its own map. All maps must use the same project specific global origin.
* Optional for mobile robot-types that do not require the node position (e.g., line-guided
* mobile robots).
*/
nodePosition?: NodeNodePosition;
/**
* True indicates that the node is part of the base. False indicates that the node is part
* of the horizon.
*/
released: boolean;
/**
* Number to track the sequence of nodes and edges in an order and to simplify order
* updates. The main purpose is to distinguish between a node which is passed more than once
* within one orderId. The sequenceId is shared between nodes and edges and defines the
* sequence of traversal.
*/
sequenceId: number;
[property: string]: any;
}
/**
* Defines the position on a map in a global project-specific world coordinate system. Each
* floor has its own map. All maps must use the same project specific global origin.
* Optional for mobile robot-types that do not require the node position (e.g., line-guided
* mobile robots).
*/
export interface NodeNodePosition {
/**
* Indicates how big the deviation of theta angle can be. The lowest acceptable angle is
* theta - allowedDeviationTheta and the highest acceptable angle is theta +
* allowedDeviationTheta.
*/
allowedDeviationTheta?: number;
/**
* Indicates how precisely a mobile robot shall match the position of a node for it to be
* considered traversed. If a = b= 0.0: no deviation is allowed, which means the mobile
* robot shall reach or pass the node position with the mobile robot control point as
* precisely as is technically possible for the mobile robot. This applies also if
* allowedDeviationXY is smaller than what is technically viable for the mobile robot. If
* the mobile robot supports this attribute, but it is not defined for this node by fleet
* control the mobile robot shall assume the value of a and b as 0.0. The coordinates of the
* node defines the center of the ellipse.
*/
allowedDeviationXY?: AllowedDeviationXY;
/**
* Unique identification of the map in which the position is referenced.
*/
mapId: string;
/**
* Absolute orientation of the mobile robot on the node. Optional: mobile robot can plan the
* path by itself. If defined, the mobile robot has to assume the theta angle on this node.
* If previous edge disallows rotation, the mobile robot must rotate on the node. If
* following edge has a differing orientation defined but disallows rotation, the mobile
* robot is to rotate on the node to the edges desired rotation before entering the edge.
*/
theta?: number;
/**
* X-position on the map in reference to the map coordinate system. Precision is up to the
* specific implementation.
*/
x: number;
/**
* Y-position on the map in reference to the map coordinate system. Precision is up to the
* specific implementation.
*/
y: number;
[property: string]: any;
}
/**
* Indicates how precisely a mobile robot shall match the position of a node for it to be
* considered traversed. If a = b= 0.0: no deviation is allowed, which means the mobile
* robot shall reach or pass the node position with the mobile robot control point as
* precisely as is technically possible for the mobile robot. This applies also if
* allowedDeviationXY is smaller than what is technically viable for the mobile robot. If
* the mobile robot supports this attribute, but it is not defined for this node by fleet
* control the mobile robot shall assume the value of a and b as 0.0. The coordinates of the
* node defines the center of the ellipse.
*/
export interface AllowedDeviationXY {
/**
* Length of the ellipse semi-major axis in meters
*/
a: number;
/**
* Length of the ellipse semi-minor axis in meters
*/
b: number;
/**
* Rotation angle in radians
*/
theta: number;
[property: string]: any;
}
/**
* Responses from fleet control to mobile robot's requests.
*/
export interface Responses {
/**
* Header ID of the message. The headerId is defined per topic and incremented by 1 with
* each sent (but not necessarily received) message.
*/
headerId: number;
/**
* Manufacturer of the mobile robot.
*/
manufacturer: string;
/**
* Array of zone response objects.
*/
responses: Response[];
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp (ISO 8601, UTC); YYYY-MM-DDTHH:mm:ss.fffZ (e.g., '2017-04-15T11:40:03.123Z').
*/
timestamp: string;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
[property: string]: any;
}
export interface Response {
/**
* Enum {'GRANTED','QUEUED','REVOKED','REJECTED'}. 'GRANTED': fleet control grants request.
* 'REVOKED': fleet control revokes previously granted request. 'REJECTED': fleet control
* rejects a request. 'QUEUED': Acknowledge the mobile robot's request to the fleet control,
* but no permission is given yet. Request was added to some sort of a queue.
*/
grantType: GrantType;
/**
* Timestamp (ISO 8601, UTC); YYYY-MM-DDTHH:mm:ss.fffZ (e.g., '2017-04-15T11:40:03.123Z').
*/
leaseExpiry?: string;
/**
* Unique per mobile robot identifier within all active requests.
*/
requestId: string;
[property: string]: any;
}
/**
* Enum {'GRANTED','QUEUED','REVOKED','REJECTED'}. 'GRANTED': fleet control grants request.
* 'REVOKED': fleet control revokes previously granted request. 'REJECTED': fleet control
* rejects a request. 'QUEUED': Acknowledge the mobile robot's request to the fleet control,
* but no permission is given yet. Request was added to some sort of a queue.
*/
export declare enum GrantType {
Granted = "GRANTED",
Queued = "QUEUED",
Rejected = "REJECTED",
Revoked = "REVOKED"
}
/**
* State of the mobile robot.
*/
export interface State {
/**
* Array of the current actions and the actions which are yet to be finished. This may
* include actions from previous nodes that are still in progress
* When an action is completed, an updated state message is published with actionStatus set
* to finished and if applicable with the corresponding resultDescriptor. The actionStates
* are kept until a new order is received.
*/
actionStates: ActionState[];
/**
* Used by line guided vehicles to indicate the distance it has been driving past the
* lastNodeId. Distance is in meters.
*/
distanceSinceLastNode?: number;
/**
* True: indicates that the mobile robot is driving and/or rotating. Other movements of the
* mobile robot (e.g., lift movements) are not included here.
* False: indicates that the mobile robot is neither driving nor rotating
*/
driving: boolean;
/**
* Array of edgeRequest objects that are currently active on the mobile robot. Empty array
* if no edge requests are active.
*/
edgeRequests?: EdgeRequest[];
/**
* Array of edgeState-Objects, that need to be traversed for fulfilling the order, empty
* list if idle.
*/
edgeStates: EdgeState[];
/**
* Array of error-objects. All active errors of the mobile robot should be in the list. An
* empty array indicates that the mobile robot has no active errors.
*/
errors: Error[];
/**
* headerId of the message. The headerId is defined per topic and incremented by 1 with each
* sent (but not necessarily received) message.
*/
headerId: number;
/**
* Array of info-objects. An empty array indicates, that the mobile robot has no
* information. This should only be used for visualization or debugging – it must not be
* used for logic in fleet control.
*/
information?: Info[];
/**
* Array of all instant action states that the mobile robot received. Empty array if the
* mobile robot has not received any instant actions. Instant actions are kept in the state
* until restart or action clearInstantActions is executed.
*/
instantActionStates: ActionState[];
intermediatePath?: IntermediatePath;
/**
* Node ID of last reached node or, if mobile robot is currently on a node, current node
* (e.g., "node7"). Empty string ("") if no lastNodeId is available.
*/
lastNodeId: string;
/**
* sequenceId of the last reached node or, if the mobile robot is currently on a node,
* sequenceId of current node. 0 if no lastNodeSequenceId is available.
*/
lastNodeSequenceId: number;
/**
* Loads, that are currently handled by the mobile robot. Optional: If mobile robot cannot
* determine load state, leave the array out of the state. If the mobile robot can determine
* the load state, but the array is empty, the mobile robot is considered unloaded.
*/
loads?: Load[];
/**
* Manufacturer of the mobile robot
*/
manufacturer: string;
/**
* Array of map-objects that are currently stored on the mobile robot.
*/
maps?: Map[];
mobileRobotPosition?: MobileRobotPosition;
/**
* True: mobile robot is almost at the end of the base and will reduce speed if no new base
* is transmitted. Trigger for fleet control to send new base
* False: no base update required.
*/
newBaseRequest?: boolean;
/**
* Array of nodeState-Objects, that need to be traversed for fulfilling the order. Empty
* list if idle.
*/
nodeStates: NodeState[];
/**
* Current operating mode of the mobile robot.
*/
operatingMode: OperatingMode;
/**
* Unique order identification of the current order or the previous finished order. The
* orderId is kept until a new order is received. Empty string ("") if no previous orderId
* is available.
*/
orderId: string;
/**
* Order Update Identification to identify that an order update has been accepted by the
* mobile robot. 0 if no previous orderUpdateId is available.
*/
orderUpdateId: number;
/**
* True: mobile robot is currently in a paused state, either because of the push of a
* physical button on the mobile robot or because of an instantAction. The mobile robot can
* resume the order.
* False: The mobile robot is currently not in a paused state.
*/
paused?: boolean;
plannedPath?: PlannedPath;
powerSupply: PowerSupply;
safetyState: SafetyState;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* The mobile robot's velocity in mobile robot coordinates
*/
velocity?: StateVelocity;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
/**
* Array of all zone actions that are in an end state or are currently running; sharing
* upcoming actions is optional. Zone action states are kept in the state message until
* restart or action clearZoneActions is executed.
*/
zoneActionStates?: ActionState[];
/**
* Array of zoneRequest objects that are currently active on the mobile robot. Empty array
* if no zone requests are active.
*/
zoneRequests?: ZoneRequest[];
/**
* Array of zoneSet objects that are currently stored on the mobile robot.
*/
zoneSets?: ZoneSetElement[];
[property: string]: any;
}
export interface ActionState {
/**
* A user-defined, human-readable name or descriptor.
*/
actionDescriptor?: string;
/**
* Unique actionId
*/
actionId: string;
/**
* Description of the result, e.g., the result of a RFID-read. Errors will be transmitted in
* errors.
*/
actionResult?: string;
/**
* WAITING: waiting for the trigger (passing the mode, entering the edge); INITIALIZING:
* Action was triggered, preparatory measures are initiated; RUNNING: The action is running;
* RETRIABLE: Actions that failed, but can be retried; PAUSED: paused by instantAction or
* external trigger; FINISHED: The action is finished; FAILED: action could not be performed.
*/
actionStatus: ActionStatus;
/**
* actionType of the action. Optional: Only for informational or visualization purposes.
* Order knows the type.
*/
actionType?: string;
[property: string]: any;
}
/**
* WAITING: waiting for the trigger (passing the mode, entering the edge); INITIALIZING:
* Action was triggered, preparatory measures are initiated; RUNNING: The action is running;
* RETRIABLE: Actions that failed, but can be retried; PAUSED: paused by instantAction or
* external trigger; FINISHED: The action is finished; FAILED: action could not be performed.
*/
export declare enum ActionStatus {
Failed = "FAILED",
Finished = "FINISHED",
Initializing = "INITIALIZING",
Paused = "PAUSED",
Retriable = "RETRIABLE",
Running = "RUNNING",
Waiting = "WAITING"
}
/**
* Edge request information sent by the mobile robot to fleet control.
*/
export interface EdgeRequest {
/**
* Globally unique identifier referencing the edge the request is related to.
*/
edgeId: string;
/**
* Unique per mobile robot identifier across all active requests.
*/
requestId: string;
/**
* When stating a request, this is set to REQUESTED. After response or update from fleet
* control set to GRANTED or REVOKED. If lease time expires set to EXPIRED.
*/
requestStatus: RequestStatus;
/**
* Enum specifying the type of edge the request relates to.
*/
requestType: EdgeRequestRequestType;
/**
* Tracking number for sequence of edge within order. Required to uniquely identify the
* referenced edge within the order.
*/
sequenceId: number;
[property: string]: any;
}
/**
* When stating a request, this is set to REQUESTED. After response or update from fleet
* control set to GRANTED or REVOKED. If lease time expires set to EXPIRED.
*
* When stating a request, this is set to REQUESTED. After response or update from fleet
* control set to GRANTED or REVOKED. If lease time expires, shall be to EXPIRED.
*/
export declare enum RequestStatus {
Expired = "EXPIRED",
Granted = "GRANTED",
Requested = "REQUESTED",
Revoked = "REVOKED"
}
/**
* Enum specifying the type of edge the request relates to.
*/
export declare enum EdgeRequestRequestType {
Corridor = "CORRIDOR"
}
export interface EdgeState {
/**
* A user-defined, human-readable name or descriptor.
*/
edgeDescriptor?: string;
/**
* Unique edge identification
*/
edgeId: string;
/**
* True indicates that the edge is part of the base. False indicates that the edge is part
* of the horizon.
*/
released: boolean;
/**
* Sequence ID to differentiate between multiple edges with the same edgeId
*/
sequenceId: number;
/**
* Reports the trajectory that has been defined a priori within a layout or was sent for
* this edge as part of the order.
*/
trajectory?: Trajectory;
[property: string]: any;
}
export interface Error {
/**
* Verbose description providing details and possible causes of the error.
*/
errorDescription?: string;
/**
* Array of translations of the error description.
*/
errorDescriptionTranslations?: Translation[];
/**
* Hint on how to approach or solve the reported error.
*/
errorHint?: string;
/**
* Array of translations of the error hint.
*/
errorHintTranslations?: Translation[];
/**
* WARNING: No immediate attention required, mobile robot is able to continue active and
* accept new order. URGENT: Immediate attention required, mobile robot is able to continue
* active and accept new order. CRITICAL: Immediate attention required, mobile robot is
* unable to continue active order, but can accept new order. FATAL: User intervention is
* required, mobile robot is unable to continue active or accept new order.
*/
errorLevel: ErrorLevel;
errorReferences?: ErrorReference[];
/**
* Error type, extensible enumeration including the following predefined values.
*/
errorType: string;
[property: string]: any;
}
/**
* Translation of a text for a given language code.
*/
export interface Translation {
/**
* Specifies the language of the translation according to ISO 639-1.
*/
translationKey: string;
/**
* Translation in language of translation key.
*/
translationValue: string;
[property: string]: any;
}
/**
* WARNING: No immediate attention required, mobile robot is able to continue active and
* accept new order. URGENT: Immediate attention required, mobile robot is able to continue
* active and accept new order. CRITICAL: Immediate attention required, mobile robot is
* unable to continue active order, but can accept new order. FATAL: User intervention is
* required, mobile robot is unable to continue active or accept new order.
*/
export declare enum ErrorLevel {
Critical = "CRITICAL",
Fatal = "FATAL",
Urgent = "URGENT",
Warning = "WARNING"
}
/**
* Array of references (e.g. nodeId, edgeId, orderId, actionId, etc.) to provide more
* information related to the error.
*/
export interface ErrorReference {
/**
* Specifies the type of reference used (e.g. nodeId, edgeId, orderId, actionId, etc.).
*/
referenceKey: string;
/**
* The value that belongs to the reference key. For example, the id of the node where the
* error occurred.
*/
referenceValue: string;
[property: string]: any;
}
export interface Info {
/**
* A user-defined, human-readable name or descriptor.
*/
infoDescriptor?: string;
/**
* DEBUG: used for debugging. INFO: used for visualization.
*/
infoLevel: InfoLevel;
infoReferences?: InfoReference[];
/**
* Type/name of information.
*/
infoType: string;
[property: string]: any;
}
/**
* DEBUG: used for debugging. INFO: used for visualization.
*/
export declare enum InfoLevel {
Debug = "DEBUG",
Info = "INFO"
}
/**
* Array of references.
*/
export interface InfoReference {
/**
* References the type of reference (e.g., headerId, orderId, actionId, etc.).
*/
referenceKey: string;
/**
* References the value, which belongs to the reference key.
*/
referenceValue: string;
[property: string]: any;
}
/**
* Represents the estimated time of arrival at closer waypoints that the mobile robot is
* able to perceive with its sensors.
*/
export interface IntermediatePath {
/**
* Array of end points of segments of a polyline.
*/
polyline: Polyline[];
[property: string]: any;
}
/**
* Endpoint of a segment within a defined polyline.
*/
export interface Polyline {
/**
* Estimated time of arrival/traversal. Formatted as a timestamp (ISO 8601, UTC);
* YYYY-MM-DDTHH:mm:ss.fffZ (e.g., '2017-04-15T11:40:03.123Z').
*/
eta: string;
/**
* Absolute orientation of the mobile robot in the project-specific coordinate system.
*/
theta?: number;
/**
* X-coordinate described in the project-specific coordinate system.
*/
x: number;
/**
* Y-coordinate described in the project-specific coordinate system.
*/
y: number;
[property: string]: any;
}
/**
* Load object that describes the load if the mobile robot has information about it.
*/
export interface Load {
/**
* Point of reference for the location of the bounding box. The point of reference is always
* the center of the bounding box bottom surface (at height = 0) and is described in
* coordinates of the mobile robot coordinate system.
*/
boundingBoxReference?: LoadBoundingBoxReference;
/**
* Dimensions of the loads bounding box in meters.
*/
loadDimensions?: LoadLoadDimensions;
/**
* Unique identification number of the load (e.g., barcode or RFID). Empty field, if the
* mobile robot can identify the load, but did not identify the load yet. Optional, if the
* mobile robot cannot identify the load.
*/
loadId?: string;
/**
* Indicates, which load handling/carrying unit of the mobile robot is used, e.g., in case
* the mobile robot has multiple spots/positions to carry loads. Optional for vehicles with
* only one loadPosition.
*/
loadPosition?: string;
/**
* Type of load.
*/
loadType?: string;
/**
* Absolute weight of the load measured in kg.
*/
weight?: number;
[property: string]: any;
}
/**
* Point of reference for the location of the bounding box. The point of reference is always
* the center of the bounding box bottom surface (at height = 0) and is described in
* coordinates of the mobile robot coordinate system.
*/
export interface LoadBoundingBoxReference {
/**
* Orientation of the loads bounding box. Important for tugger, trains, etc.
*/
theta?: number;
x: number;
y: number;
z: number;
[property: string]: any;
}
/**
* Dimensions of the loads bounding box in meters.
*/
export interface LoadLoadDimensions {
/**
* Absolute height of the loads bounding box in meter.
* Optional:
* set value only if known.
*/
height?: number;
/**
* Absolute length (along the mobile robot’s coordinate system's x-axis) of the load's
* bounding box in meters.
*/
length: number;
/**
* Absolute width (along the mobile robot’s coordinate system's y-axis) of the load's
* bounding box in meters.
*/
width: number;
[property: string]: any;
}
export interface Map {
/**
* A user-defined, human-readable name or descriptor
*/
mapDescriptor?: string;
/**
* ID of the map describing a defined area of the mobile robot's workspace.
*/
mapId: string;
/**
* Information on the status of the map indicating, if a map version is currently used on
* the mobile robot. ENABLED: Indicates this map is currently active / used on the mobile
* robot. At most one map with the same mapId can have its status set to
* ENABLED.
DISABLED: Indicates this map version is currently not enabled on the mobile
* robot and thus could be enabled or deleted by request.
*/
mapStatus: Status;
/**
* Version of the map.
*/
mapVersion: string;
[property: string]: any;
}
/**
* Information on the status of the map indicating, if a map version is currently used on
* the mobile robot. ENABLED: Indicates this map is currently active / used on the mobile
* robot. At most one map with the same mapId can have its status set to
* ENABLED.
DISABLED: Indicates this map version is currently not enabled on the mobile
* robot and thus could be enabled or deleted by request.
*
* ENABLED: Indicates this zone set is currently active / used on the mobile robot. At most
* one zone set for each map can have its status set to ENABLED. DISABLED: Indicates this
* zone set is currently not enabled on the mobile robot and thus could be enabled or
* deleted by fleet control.
*/
export declare enum Status {
Disabled = "DISABLED",
Enabled = "ENABLED"
}
/**
* Defines the position on a map in world coordinates. Each floor has its own map.
*/
export interface MobileRobotPosition {
/**
* Value for position deviation range in meters. Optional for vehicles that cannot estimate
* their deviation, e.g., grid-based localization. Only for logging and visualization
* purposes.
*/
deviationRange?: number;
/**
* Describes the quality of the localization and therefore, can be used, e.g., by SLAM
* mobile robot to describe how accurate the current position information is.
* 0.0: position unknown
* 1.0: position known
* Optional for vehicles that cannot estimate their localization score.
* Only for logging and visualization purposes
*/
localizationScore?: number;
/**
* True: mobile robot is localized. x, y, and theta can be trusted. False: mobile robot is
* not localized. x, y, and theta cannot be trusted.
*/
localized: boolean;
/**
* Unique identification of the map.
*/
mapId: string;
theta: number;
x: number;
y: number;
[property: string]: any;
}
export interface NodeState {
/**
* A user-defined, human-readable name or descriptor.
*/
nodeDescriptor?: string;
/**
* Unique node identification
*/
nodeId: string;
/**
* Node position. Optional: Fleet control has this information. Can be sent additionally,
* e.g., for debugging purposes.
*/
nodePosition?: NodeStateNodePosition;
/**
* True: indicates that the node is part of the base. False: indicates that the node is part
* of the horizon.
*/
released: boolean;
/**
* Sequence ID to discern multiple nodes with same nodeId.
*/
sequenceId: number;
[property: string]: any;
}
/**
* Node position. Optional: Fleet control has this information. Can be sent additionally,
* e.g., for debugging purposes.
*/
export interface NodeStateNodePosition {
mapId: string;
theta?: number;
x: number;
y: number;
[property: string]: any;
}
/**
* Current operating mode of the mobile robot.
*/
export declare enum OperatingMode {
Automatic = "AUTOMATIC",
Intervened = "INTERVENED",
Manual = "MANUAL",
Semiautomatic = "SEMIAUTOMATIC",
Service = "SERVICE",
Startup = "STARTUP",
TeachIn = "TEACH_IN"
}
/**
* Represents a path within the robot's currently active order as NURBS.
*/
export interface PlannedPath {
trajectory: Trajectory;
/**
* Array of nodeIds as communicated in the currently executed order that are traversed
* within the shared planned path.
*/
traversedNodes?: string[];
[property: string]: any;
}
/**
* Contains all battery-related information.
*/
export interface PowerSupply {
/**
* Battery current in Ampere (A)
*/
batteryCurrent?: number;
/**
* State of health in percent.
*/
batteryHealth?: number;
/**
* Battery voltage
*/
batteryVoltage?: number;
/**
* True: charging in progress. False: mobile robot is currently not charging.
*/
charging: boolean;
/**
* Estimated reach with current State of Charge in meter.
*/
range?: number;
/**
* State of Charge in %: If mobile robot only provides values for good or bad battery
* levels, these will be indicated as 20% (bad) and 80% (good).
*/
stateOfCharge: number;
[property: string]: any;
}
/**
* Contains all safety-related information.
*/
export interface SafetyState {
/**
* EmergencyStop-Types: MANUAL: e-stop shall be acknowledged manually at the mobile robot.
* REMOTE: facility e-stop shall be acknowledged remotely. NONE: no e-stop activated.
*/
activeEmergencyStop: ActiveEmergencyStop;
/**
* Protective field violation. True: field is violated. False: field is not violated.
*/
fieldViolation: boolean;
[property: string]: any;
}
/**
* EmergencyStop-Types: MANUAL: e-stop shall be acknowledged manually at the mobile robot.
* REMOTE: facility e-stop shall be acknowledged remotely. NONE: no e-stop activated.
*/
export declare enum ActiveEmergencyStop {
Manual = "MANUAL",
None = "NONE",
Remote = "REMOTE"
}
/**
* The mobile robot's velocity in mobile robot coordinates
*/
export interface StateVelocity {
/**
* The mobile robot's turning speed around its z axis.
*/
omega?: number;
/**
* The mobile robot's velocity in its x direction
*/
vx?: number;
/**
* The mobile robot's velocity in its y direction
*/
vy?: number;
[property: string]: any;
}
/**
* Zone information sent by the mobile robot to fleet control.
*/
export interface ZoneRequest {
/**
* Unique per mobile robot identifier within all active requests.
*/
requestId: string;
/**
* When stating a request, this is set to REQUESTED. After response or update from fleet
* control set to GRANTED or REVOKED. If lease time expires, shall be to EXPIRED.
*/
requestStatus: RequestStatus;
/**
* Enum specifying the type of zone the request relates to. Feasible values are ACCESS or
* REPLANNING.
*/
requestType: ZoneRequestRequestType;
trajectory?: Trajectory;
/**
* Locally (within the zone set) unique identifier referencing the zone the request is
* related to.
*/
zoneId: string;
/**
* Due to the zoneId only being unique to a zoneSet, the zoneSetId is part of the request.
*/
zoneSetId: string;
[property: string]: any;
}
/**
* Enum specifying the type of zone the request relates to. Feasible values are ACCESS or
* REPLANNING.
*/
export declare enum ZoneRequestRequestType {
Access = "ACCESS",
Replanning = "REPLANNING"
}
export interface ZoneSetElement {
/**
* Identifier of the corresponding map.
*/
mapId: string;
/**
* Unique identifier of the zone set that is currently enabled for the map.
This field
* shall be left empty only if the mobile robot has no zones defined for the corresponding
* map.
*/
zoneSetId: string;
/**
* ENABLED: Indicates this zone set is currently active / used on the mobile robot. At most
* one zone set for each map can have its status set to ENABLED. DISABLED: Indicates this
* zone set is currently not enabled on the mobile robot and thus could be enabled or
* deleted by fleet control.
*/
zoneSetStatus: Status;
[property: string]: any;
}
/**
* Mobile robot position and/or velocity for visualization purposes. Can be published at a
* higher rate if wanted. Since bandwidth may be expensive depening on the update rate for
* this topic, all fields are optional.
*/
export interface Visualization {
/**
* headerId of the message. The headerId is defined per topic and incremented by 1 with each
* sent (but not necessarily received) message.
*/
headerId: number;
intermediatePath?: IntermediatePath;
/**
* Manufacturer of the mobile robot
*/
manufacturer: string;
mobileRobotPosition?: MobileRobotPosition;
plannedPath?: PlannedPath;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
velocity?: VisualizationVelocity;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
referenceStateHeaderId: any;
[property: string]: any;
}
/**
* The mobile robot's velocity in mobile robot's coordinates
*/
export interface VisualizationVelocity {
/**
* The mobile robot's turning speed around its Z-axis.
*/
omega?: number;
/**
* The mobile robot's velocity in its X-direction.
*/
vx?: number;
/**
* The mobile robot's velocity in its Y-direction.
*/
vy?: number;
[property: string]: any;
}
/**
* Zone set detailing a dedicated map.
*/
export interface ZoneSet {
/**
* headerId of the message. The headerId is defined per topic and incremented by 1 with each
* sent (but not necessarily received) message.
*/
headerId: number;
/**
* Manufacturer of the mobile robot.
*/
manufacturer: string;
/**
* Serial number of the mobile robot.
*/
serialNumber: string;
/**
* Timestamp in ISO8601 format (YYYY-MM-DDTHH:mm:ss.fffZ).
*/
timestamp: string;
/**
* Version of the protocol [Major].[Minor].[Patch]
*/
version: string;
zoneSet: ZoneSetZoneSet;
[property: string]: any;
}
export interface ZoneSetZoneSet {
/**
* Globally unique identifier of the map the zone set particularizes.
*/
mapId: string;
/**
* Array of zone objects.
*/
zones: Zone[];
/**
* A user-defined, human-readable name or descriptor.
*/
zoneSetDescriptor?: string;
/**
* Globally unique identifier of the zone set.
*/
zoneSetId: string;
[property: string]: any;
}
export interface Zone {
/**
* Array of vertices (in x-y-coordinates) defining the geometrical shape of the zone.
*/
vertices: ZoneVertex[];
/**
* User-defined human-readable name or descriptor.
*/
zoneDescriptor?: string;
/**
* Locally (within the zone set) unique identifier.
*/
zoneId: string;
/**
* Zone category.
*/
zoneType: ZoneType;
[property: string]: any;
}
export interface ZoneVertex {
/**
* X-coordinate described in the project specific coordinate system.
*/
x: number;
/**
* Y-coordinate described in the project specific coordinate system.
*/
y: number;
[property: string]: any;
}