<?xml version="1.0" encoding="utf-8"?>
<UANodeSet xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns="http://opcfoundation.org/UA/2011/03/UANodeSet.xsd">
  <NamespaceUris>
    <Uri>ArchitectureOrganique</Uri>
    <Uri>http://opcfoundation.org/UA/DI/</Uri>
    <Uri>http://opcfoundation.org/UA/Robotics/</Uri>
  </NamespaceUris>
  <Models>
    <Model ModelUri="ArchitectureOrganique" PublicationDate="2022-01-17T15:44:15.200+01:00" Version="1.0.0">
      <RequiredModel ModelUri="http://opcfoundation.org/UA/" PublicationDate="2020-07-15T00:00:00Z" Version="1.04.7"/>
      <RequiredModel ModelUri="http://opcfoundation.org/UA/DI/" PublicationDate="2020-06-02T00:00:00Z" Version="1.02.2"/>
      <RequiredModel ModelUri="http://opcfoundation.org/UA/Robotics/" PublicationDate="2019-01-23T00:00:00Z" Version="0.93"/>
    </Model>
  </Models>
  <Aliases>
    <Alias Alias="HasComponent">i=47</Alias>
    <Alias Alias="Enumeration">i=29</Alias>
    <Alias Alias="HasTypeDefinition">i=40</Alias>
    <Alias Alias="Double">i=11</Alias>
    <Alias Alias="FolderType">i=61</Alias>
    <Alias Alias="EUInformation">i=887</Alias>
    <Alias Alias="Boolean">i=1</Alias>
    <Alias Alias="HasProperty">i=46</Alias>
    <Alias Alias="AxisMotionProfileEnumeration">ns=3;i=3008</Alias>
    <Alias Alias="LocalizedText">i=21</Alias>
    <Alias Alias="HasSubtype">i=45</Alias>
    <Alias Alias="Organizes">i=35</Alias>
  </Aliases>
  <UAObject BrowseName="3:MotionDevices" NodeId="ns=1;i=1001" ParentNodeId="ns=1;i=1000">
    <DisplayName>MotionDevices</DisplayName>
    <Description>Contains any kinematic or motion device which is part of the motion device system.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">FolderType</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1000</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1002</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="3:Axes" NodeId="ns=1;i=1003" ParentNodeId="ns=1;i=1002">
    <DisplayName>Axes</DisplayName>
    <Description>Axes is a container for one or more instances of the AxisType</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">FolderType</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1002</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1006</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1019</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1032</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1045</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1058</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1071</Reference>
    </References>
  </UAObject>
  <UADataType BrowseName="1:AxisStateEnumeration" NodeId="ns=1;i=1004">
    <DisplayName>AxisStateEnumeration</DisplayName>
    <References>
      <Reference IsForward="false" ReferenceType="HasSubtype">Enumeration</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1005</Reference>
    </References>
    <Definition Name="NewAxisStateEnumeration">
      <Field Name="JOINT_SHUTTING_DOWN_MODE" Value="236"/>
      <Field Name="JOINT_PART_D_CALIBRATION_MODE" Value="237"/>
      <Field Name="JOINT_BACKDRIVE_MODE" Value="238"/>
      <Field Name="JOINT_POWER_OFF_MODE" Value="239"/>
      <Field Name="JOINT_NOT_RESPONDING_MODE" Value="245"/>
      <Field Name="JOINT_MOTOR_INITIALISATION_MODE" Value="246"/>
      <Field Name="JOINT_BOOTING_MODE" Value="247"/>
      <Field Name="JOINT_PART_D_CALIBRATION_ERROR_MODE" Value="248"/>
      <Field Name="JOINT_BOOTLOADER_MODE" Value="249"/>
      <Field Name="JOINT_CALIBRATION_MODE" Value="250"/>
      <Field Name="JOINT_FAULT_MODE" Value="252"/>
      <Field Name="JOINT_RUNNING_MODE" Value="253"/>
      <Field Name="JOINT_IDLE_MODE" Value="255"/>
    </Definition>
  </UADataType>
  <UAVariable BrowseName="EnumStrings" NodeId="ns=1;i=1005" ParentNodeId="ns=1;i=1004" AccessLevel="3" ArrayDimensions="0" DataType="LocalizedText" ValueRank="1">
    <DisplayName>EnumStrings</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasProperty">ns=1;i=1004</Reference>
    </References>
    <Value>
			<ListOfLocalizedText
				xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_SHUTTING_DOWN_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_PART_D_CALIBRATION_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_BACKDRIVE_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_POWER_OFF_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_NOT_RESPONDING_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_MOTOR_INITIALISATION_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_BOOTING_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_PART_D_CALIBRATION_ERROR_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_BOOTLOADER_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_CALIBRATION_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_FAULT_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_RUNNING_MODE</Text>
				</LocalizedText>
				<LocalizedText>
					<Locale>
					</Locale>
					<Text>JOINT_IDLE_MODE</Text>
				</LocalizedText>
			</ListOfLocalizedText>
		</Value>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1007" ParentNodeId="ns=1;i=1006">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1006</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1008</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1008" ParentNodeId="ns=1;i=1007" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1007</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1009</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1009" ParentNodeId="ns=1;i=1008" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1008</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1010" ParentNodeId="ns=1;i=1006" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1006</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1011" ParentNodeId="ns=1;i=1006">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1006</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1012</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1014</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1016</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1018</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1012" ParentNodeId="ns=1;i=1011" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1011</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1013</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1013" ParentNodeId="ns=1;i=1012" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1012</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1014" ParentNodeId="ns=1;i=1011" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1011</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1015</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1015" ParentNodeId="ns=1;i=1014" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1014</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1016" ParentNodeId="ns=1;i=1011" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1011</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1017</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1017" ParentNodeId="ns=1;i=1016" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1016</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1018" ParentNodeId="ns=1;i=1011" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1011</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1020" ParentNodeId="ns=1;i=1019">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1019</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1021</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1021" ParentNodeId="ns=1;i=1020" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1020</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1022</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1022" ParentNodeId="ns=1;i=1021" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1021</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1023" ParentNodeId="ns=1;i=1019" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1019</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1024" ParentNodeId="ns=1;i=1019">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1019</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1025</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1027</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1029</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1031</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1025" ParentNodeId="ns=1;i=1024" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1024</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1026</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1026" ParentNodeId="ns=1;i=1025" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1025</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1027" ParentNodeId="ns=1;i=1024" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1024</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1028</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1028" ParentNodeId="ns=1;i=1027" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1027</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1029" ParentNodeId="ns=1;i=1024" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1024</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1030</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1030" ParentNodeId="ns=1;i=1029" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1029</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1031" ParentNodeId="ns=1;i=1024" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1024</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1033" ParentNodeId="ns=1;i=1032">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1032</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1034</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1034" ParentNodeId="ns=1;i=1033" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1033</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1035</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1035" ParentNodeId="ns=1;i=1034" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1034</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1036" ParentNodeId="ns=1;i=1032" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1032</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1037" ParentNodeId="ns=1;i=1032">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1032</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1038</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1040</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1042</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1044</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1038" ParentNodeId="ns=1;i=1037" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1037</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1039</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1039" ParentNodeId="ns=1;i=1038" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1038</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1040" ParentNodeId="ns=1;i=1037" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1037</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1041</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1041" ParentNodeId="ns=1;i=1040" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1040</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1042" ParentNodeId="ns=1;i=1037" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1037</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1043</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1043" ParentNodeId="ns=1;i=1042" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1042</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1044" ParentNodeId="ns=1;i=1037" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1037</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1046" ParentNodeId="ns=1;i=1045">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1045</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1047</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1047" ParentNodeId="ns=1;i=1046" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1046</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1048</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1048" ParentNodeId="ns=1;i=1047" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1047</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1049" ParentNodeId="ns=1;i=1045" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1045</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1050" ParentNodeId="ns=1;i=1045">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1045</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1051</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1053</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1055</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1057</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1051" ParentNodeId="ns=1;i=1050" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1050</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1052</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1052" ParentNodeId="ns=1;i=1051" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1051</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1053" ParentNodeId="ns=1;i=1050" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1050</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1054</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1054" ParentNodeId="ns=1;i=1053" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1053</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1055" ParentNodeId="ns=1;i=1050" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1050</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1056</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1056" ParentNodeId="ns=1;i=1055" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1055</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1057" ParentNodeId="ns=1;i=1050" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1050</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1059" ParentNodeId="ns=1;i=1058">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1058</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1060</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1060" ParentNodeId="ns=1;i=1059" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1059</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1061</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1061" ParentNodeId="ns=1;i=1060" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1060</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1062" ParentNodeId="ns=1;i=1058" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1058</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1063" ParentNodeId="ns=1;i=1058">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1058</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1064</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1066</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1068</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1070</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1064" ParentNodeId="ns=1;i=1063" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1063</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1065</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1065" ParentNodeId="ns=1;i=1064" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1064</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1066" ParentNodeId="ns=1;i=1063" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1063</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1067</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1067" ParentNodeId="ns=1;i=1066" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1066</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1068" ParentNodeId="ns=1;i=1063" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1063</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1069</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1069" ParentNodeId="ns=1;i=1068" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1068</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1070" ParentNodeId="ns=1;i=1063" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1063</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:AdditionalLoad" NodeId="ns=1;i=1072" ParentNodeId="ns=1;i=1071">
    <DisplayName>AdditionalLoad</DisplayName>
    <Description>The additional load which is mounted on this axis. E.g. for process-need a transformer for welding.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1018</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1071</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1073</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:Mass" NodeId="ns=1;i=1073" ParentNodeId="ns=1;i=1072" AccessLevel="3" DataType="Double">
    <DisplayName>Mass</DisplayName>
    <Description>The weight of the load mounted on one mounting point.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1072</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1074</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1074" ParentNodeId="ns=1;i=1073" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1073</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotionProfile" NodeId="ns=1;i=1075" ParentNodeId="ns=1;i=1071" AccessLevel="3" DataType="AxisMotionProfileEnumeration">
    <DisplayName>MotionProfile</DisplayName>
    <Description>The kind of axis motion as defined with the AxisMotionProfileEnumeration.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1071</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1076" ParentNodeId="ns=1;i=1071">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1071</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1077</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1079</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1081</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1083</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:ActualSpeed" NodeId="ns=1;i=1077" ParentNodeId="ns=1;i=1076" AccessLevel="3" DataType="Double">
    <DisplayName>ActualSpeed</DisplayName>
    <Description>The axis speed on load side (after gear/spindle) inclusive Unit.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1076</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1078</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1078" ParentNodeId="ns=1;i=1077" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1077</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualPosition" NodeId="ns=1;i=1079" ParentNodeId="ns=1;i=1076" AccessLevel="3" DataType="Double">
    <DisplayName>ActualPosition</DisplayName>
    <Description>The axis position inclusive Unit and RangeOfMotion.&lt;/</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1076</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1080</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1080" ParentNodeId="ns=1;i=1079" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1079</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:ActualAcceleration" NodeId="ns=1;i=1081" ParentNodeId="ns=1;i=1076" AccessLevel="3" DataType="Double">
    <DisplayName>ActualAcceleration</DisplayName>
    <Description>The ActualAcceleration variable provides the axis acceleration. Applicable acceleration limits of the axis shall be provided by the EURange property of the AnalogUnitType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1076</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1082</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1082" ParentNodeId="ns=1;i=1081" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1081</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="1:AxisState" NodeId="ns=1;i=1083" ParentNodeId="ns=1;i=1076" AccessLevel="3" DataType="ns=1;i=1004">
    <DisplayName>AxisState</DisplayName>
    <Description>The AxisStateEnumVariable variable provides the axis State, it is not a part of CS Robotics.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1076</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="Wrist2" NodeId="ns=1;i=1045" ParentNodeId="ns=1;i=1003">
    <DisplayName>Wrist2</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1046</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1049</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1050</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="Base" NodeId="ns=1;i=1058" ParentNodeId="ns=1;i=1003">
    <DisplayName>Base</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1059</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1062</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1063</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="Elbow" NodeId="ns=1;i=1006" ParentNodeId="ns=1;i=1003">
    <DisplayName>Elbow</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1007</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1010</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1011</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="Shoulder" NodeId="ns=1;i=1032" ParentNodeId="ns=1;i=1003">
    <DisplayName>Shoulder</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1033</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1036</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1037</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="Wrist1" NodeId="ns=1;i=1019" ParentNodeId="ns=1;i=1003">
    <DisplayName>Wrist1</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1020</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1023</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1024</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="Wrist3" NodeId="ns=1;i=1071" ParentNodeId="ns=1;i=1003">
    <DisplayName>Wrist3</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16601</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1072</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1075</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1076</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="3:PowerTrains" NodeId="ns=1;i=1084" ParentNodeId="ns=1;i=1002">
    <DisplayName>PowerTrains</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">FolderType</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1002</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1085</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1092</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1099</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1106</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1113</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1120</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1087" ParentNodeId="ns=1;i=1086">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1086</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1088</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1090</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1088" ParentNodeId="ns=1;i=1087" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1087</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1089</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1089" ParentNodeId="ns=1;i=1088" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1088</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1090" ParentNodeId="ns=1;i=1087" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1087</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1091</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1091" ParentNodeId="ns=1;i=1090" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1090</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1086" ParentNodeId="ns=1;i=1085">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1085</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1087</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1094" ParentNodeId="ns=1;i=1093">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1093</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1095</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1097</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1095" ParentNodeId="ns=1;i=1094" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1094</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1096</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1096" ParentNodeId="ns=1;i=1095" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1095</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1097" ParentNodeId="ns=1;i=1094" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1094</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1098</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1098" ParentNodeId="ns=1;i=1097" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1097</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1093" ParentNodeId="ns=1;i=1092">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1092</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1094</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1101" ParentNodeId="ns=1;i=1100">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1100</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1102</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1104</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1102" ParentNodeId="ns=1;i=1101" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1101</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1103</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1103" ParentNodeId="ns=1;i=1102" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1102</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1104" ParentNodeId="ns=1;i=1101" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1101</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1105</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1105" ParentNodeId="ns=1;i=1104" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1104</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1100" ParentNodeId="ns=1;i=1099">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1099</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1101</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1108" ParentNodeId="ns=1;i=1107">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1107</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1109</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1111</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1109" ParentNodeId="ns=1;i=1108" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1108</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1110</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1110" ParentNodeId="ns=1;i=1109" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1109</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1111" ParentNodeId="ns=1;i=1108" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1108</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1112</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1112" ParentNodeId="ns=1;i=1111" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1111</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1107" ParentNodeId="ns=1;i=1106">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1106</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1108</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1115" ParentNodeId="ns=1;i=1114">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1114</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1116</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1118</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1116" ParentNodeId="ns=1;i=1115" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1115</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1117</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1117" ParentNodeId="ns=1;i=1116" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1116</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1118" ParentNodeId="ns=1;i=1115" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1115</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1119</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1119" ParentNodeId="ns=1;i=1118" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1118</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1114" ParentNodeId="ns=1;i=1113">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1113</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1115</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1122" ParentNodeId="ns=1;i=1121">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1121</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1123</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1125</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="3:MotorTemperature" NodeId="ns=1;i=1123" ParentNodeId="ns=1;i=1122" AccessLevel="3" DataType="Double">
    <DisplayName>MotorTemperature</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1122</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1124</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1124" ParentNodeId="ns=1;i=1123" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1123</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="3:MotorIntensity" NodeId="ns=1;i=1125" ParentNodeId="ns=1;i=1122" AccessLevel="3" DataType="Double">
    <DisplayName>MotorIntensity</DisplayName>
    <Description>The motor temperature provides the temperature of the motor. If there is no temperature sensor the value is set to &quot;null&quot;.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=17497</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1122</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1126</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="EngineeringUnits" NodeId="ns=1;i=1126" ParentNodeId="ns=1;i=1125" AccessLevel="3" DataType="EUInformation">
    <DisplayName>EngineeringUnits</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1125</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="3:MotorIdentifier" NodeId="ns=1;i=1121" ParentNodeId="ns=1;i=1120">
    <DisplayName>MotorIdentifier</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1019</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1120</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1122</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerTrainBase" NodeId="ns=1;i=1106" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerTrainBase</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1107</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerWrist1" NodeId="ns=1;i=1085" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerWrist1</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1086</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerTrainWrist3" NodeId="ns=1;i=1099" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerTrainWrist3</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1100</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerTrainWrist2" NodeId="ns=1;i=1113" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerTrainWrist2</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1114</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerTrainElbow" NodeId="ns=1;i=1120" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerTrainElbow</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1121</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="powerTrainShoulder" NodeId="ns=1;i=1092" ParentNodeId="ns=1;i=1084">
    <DisplayName>powerTrainShoulder</DisplayName>
    <Description>PowerTrains is a container for one or more instances of the PowerTrainType.</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=16794</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1093</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="2:ParameterSet" NodeId="ns=1;i=1127" ParentNodeId="ns=1;i=1002">
    <DisplayName>ParameterSet</DisplayName>
    <Description>Flat list of Parameters</Description>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1002</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1128</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1129</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1130</Reference>
      <Reference ReferenceType="HasProperty">ns=1;i=1131</Reference>
    </References>
  </UAObject>
  <UAVariable BrowseName="RobotIntensity" NodeId="ns=1;i=1128" ParentNodeId="ns=1;i=1127" AccessLevel="3" DataType="Double">
    <DisplayName>RobotIntensity</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasProperty">ns=1;i=1127</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="isPowerButtonPressed" NodeId="ns=1;i=1129" ParentNodeId="ns=1;i=1127" AccessLevel="3" DataType="Boolean">
    <DisplayName>isPowerButtonPressed</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasProperty">ns=1;i=1127</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="isTeachButtonPressed" NodeId="ns=1;i=1130" ParentNodeId="ns=1;i=1127" AccessLevel="3" DataType="Boolean">
    <DisplayName>isTeachButtonPressed</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasProperty">ns=1;i=1127</Reference>
    </References>
  </UAVariable>
  <UAVariable BrowseName="isPowerOnRobot" NodeId="ns=1;i=1131" ParentNodeId="ns=1;i=1127" AccessLevel="3" DataType="Boolean">
    <DisplayName>isPowerOnRobot</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
      <Reference IsForward="false" ReferenceType="HasProperty">ns=1;i=1127</Reference>
    </References>
  </UAVariable>
  <UAObject BrowseName="robot_UR_5_CB3" NodeId="ns=1;i=1002" ParentNodeId="ns=1;i=1001">
    <DisplayName>robot_UR_5_CB3</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1004</Reference>
      <Reference IsForward="false" ReferenceType="HasComponent">ns=1;i=1001</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1003</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1084</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1127</Reference>
    </References>
  </UAObject>
  <UAObject BrowseName="MotionDeviceSystem" NodeId="ns=1;i=1000">
    <DisplayName>MotionDeviceSystem</DisplayName>
    <References>
      <Reference ReferenceType="HasTypeDefinition">ns=3;i=1002</Reference>
      <Reference ReferenceType="HasComponent">ns=1;i=1001</Reference>
      <Reference IsForward="false" ReferenceType="Organizes">ns=2;i=5001</Reference>
    </References>
  </UAObject>
</UANodeSet>