The web license file (with the extension: .key) have to be located in the Experior installation folder (which is usually C:\Xcelgo\Xcelgo Experior…).   When Experior is started, it contacts the Xcelgo web license server to investigate whether the license is valid and whether a license seat is available. If the investigation is successful, a seat checkout is performed and the usage of Experior is granted.    When Experior is closed: Depending on the customer and license setup, Experior might give the user the option to contact the Xcelgo web license server for a check in of the license seat – or to keep it reserved for the user for later use. If checking in the license seat, the seat is available for checkout for other users with access to the same license.   The communication between Experior and the Xcelgo web license server is a bit different depending on the Experior version:   • Experior 5.x, Experior 6.0 and Experior 6.1 (prior to and including release Experior 6.1.19245) need access to port 8080 at ‘license.xcelgo.com’. They use a proprietary protocol for the license server communication.   • Experior 6.1 (from and including release Experior 6.1.19246) as well as Experior 7 need access to port 443 at ‘https://licenseapi.xcelgo.com’ for license server communication. They use a TCP protocol for the license server communication.   So: in order to check out or check in an Experior web license seat, access to and communication with the Xcelgo web license server is required. If this access is unavailable due to personal or company network restrictions and the access cannot be provided, then it is recommended to use a USB dongle licence instead.

If a public class that extends the Core.Motor.Electric class exists in a catalog or plug-in then Experior will pick it up and make it visible from the Assembly context menu.   This means that you can put your own motor onto a conveyor or use it anywhere else.   To control the type that has to be listed in the context menu you can use the Menu.Motors.Add method.   The standard motors in Experior (Surface, Vector, Eccentric and Rotation) are only listed in the context menu if you explicit asks for it by calling:   Menu.Motors.Add(typeof(Core.Motors.Surface));   Menu.Motors.Add(typeof(Core.Motors.Vector));   Menu.Motors.Add(typeof(Core.Motors.Eccentric));   Menu.Motors.Add(typeof(Core.Motors.Rotation));   If your motor is derived from the Core.Motors.Surface class then by adding Menu.Motors.Add(typeof(Core.Motors.Surface)) all surface motors and all derived motor type will listed in the context menu.   If your assembly accepts all motors then just put in: Menu.Motors.Add(typeof(Core.Motors.Electric));   But remember this not includes the standard motors (Surface, Vector, Eccentric and Rotation).   In the example we have two motors that are derived directly from Core.Motors.Electric. To list the standard surface motor and at the same time accept motors derived from Core.Motors.Electric the two line below has to be added to your assembly: Menu.Motors.Add(typeof(Core.Motors.Surface)); Menu.Motors.Add(typeof(Core.Motors.Electric));   When the user then creates a new motor by clicking on the New menu item the InsertMotor method is called on the selected assembly. The only argument in the InsertMotor method is an instance of the motor just created.   Note: It makes no sense to have the motors listed in the context menu unless InsertMotor is overridden (Experior will not list the motors unless the assembly is overriding the InsertMotor method).  

Download the required version of Experior Go to the Release folder, open the folder containing needed Experior version and download the setup file. Double click the Experior install file. On the License Agreement screen, select I Agree.   If you want a custom installation path click the Options button. Otherwise click the Install button.   The program will now install, if a User Account Control window appears click YES. Once the installation is complete, click CLOSE to finish.

Minimum PC Requirements:   CPU – Intel Core i7-37xx Quad, 2.5GHz or AMD equivalent   Graphics card – DirectX 9.0c compatible Nvidia Cuda compatible graphics card, minimum 2048MB (GTX 6xx, Quadro) (NVIDIA CUDA is used by the graphics card to accelerate the physics calculations. “Rigid” bodies are not supported at this time, but having a CUDA enabled graphics card is recommended. CUDA is a very common technology and supported by the majority of NVIDIA graphics cards, however, if the device being used is not CUDA compatible it’s ok as there is little to no difference compared to other graphics cards.) https://www.nvidia.co.uk/object/what_is_cuda_new_uk.html   Memory – 8GB RAM (32 bit: 3GB RAM)   Disk space – 900MB   Operating System – Windows 7/8/10/11 (32 or 64 bit) Administrative user rights on PC/operation system is preferred. The user should be familiar with normal PC and Windows functionality

Before you start, make sure you have the Universal Robots Experior catalogs: • Experior.Catalog.UniversalRobots.dll • UniversalRobotsCommunication.dll   Afterward, follow these steps   Robot controller connection The following steps will connect the Experior URX assembly to the robot controller in URSim.   1. Place the Experior UR catalog (.dll) files in the Experior 6 installation folder (usually C:\Xcelgo\Xcelgo Experior 6).   2. Download and unpack/install the following: a. UR Non-Linux Offline simulator virtual machine (URSim):  b. VMware Workstation Player    3. Open VMware Workstation. Open the URSim virtual machine (Player-File-Open, then browse the file explorer to where you unpacked the files from 2.a., then select the .vmx file).    4. When the virtual machine is running, open the file with the name of the robot that you want to simulate. Then, turn the virtual robot on using the button on the bottom left. Then click ON and START.   5. Open Experior 6.0. Make sure the UniversalRobots catalog is selected in the catalog selector. Drag and drop the desired robot from the Catalogs panel to the model.   6. Go to URSim and open the robot settings.   In the settings menu, select System-Network. Note the URSim IP address.   7. Connect URSim to Experior. Do this by going to your Experior model, selecting the robot, and writing the URSim IP address in the IP Address field, under Robot connection. 7.1 Afterward, right-click on the robot and select Connect to robot controller. After this, the robot in Experior will snap into the position of the robot in URSim.       After this, the robot in Experior will replicate the trajectory of the robot in URSim.   Connecting robot I/O through Modbus TCP The following steps show how to connect the robot I/O through the URSim Modbus server and the Experior Modbus client.   1. In URSim, go to Installation- Fieldbus- Modbus- Add a new signal. (Initially, the variable list will be empty) In the dropdown menu, select the variable type: Digital Input/Output, Register (byte) Input/Output. Rename the variable (this is the name that will be used in the UR programming interface)   2. Assign the memory address for the variable. For this, you need to take into account that all the addresses have specific uses (see here).   3. In Experior, add the Modbus client by right-clicking the Communication panel, and selecting Modbus.     4. Select the Modbus client, and in the Properties panel, write the URSim IP address in the IP Address field, under Communication.     5. Assign Input/Output variables to the desired components. To do this, first set the Connection id to the id corresponding to the Modbus client. Then, assign the memory address of the Modbus server (assigned in step 2) in the Address field for the specific Input/Output. Modify the Register value, depending on the variable type defined in step 2. For Register Inputs/Outputs, Modify the Size value to UInt16 (WORD).   6. After all the memory addresses have been set in Experior, right-click on the Modbus client and click connect. While the connection is active, you won´t be able to modify the associated I/O in Experior.     After this, the variable values will be represented in the Experior model.   (This example was made with the Display assembly, found in the Advanced catalog)   

The Catalogs window contains the developed assemblies that you can use to to build a layout/model    

The Control Panel is only available in Physics mode.   Buttons and switches, used to control elements within the working area, can be added.   To add a control, right click and select the desired item from the pop-out menu.   The alignment of the Control Panels can now be set to Top, Right or Left. Right click on the tabs and go down to Alignment. In the pop out menu Top, Right or Left can be selected.     Depending on the alignment of the tabs they can either be moved left to right or up and down.   To do this, right click on the Control Panel tab and select the option as shown below.   The Control Panels can be copied by right clicking on the appropriate tab and selecting the Copy command.   

The following section shows how to use the Siemens Fetch and Write protocol to program and run the basic psychics model example.   Click on the Communications tab on the right of the Experior window, just below the Catalogs tab Now right click on the first line and select Siemens and then click Fetch   Next, on the second line down, do the same again only this time select Write   Now it is time to configure the two communications devices Select the Fetch device first and fill out the Properties like so   Next select the Write device and configure the Properties like so   Now to setup the I/O for the devices that require it. For the moment just the addresses will be used The I/O is laid out below along with the associated items: INPUTS 1.1 Motor Control “Switch” 1.2 Feed Load “Button” & Feed Load “Sensor” (2nd Sensor in system) 1.3 Load In System “Sensor” (1st Sensor in system) OUTPUTS 1.1 Motor Drive Control 1.2 Feeder “Feed Load” Control 1.3 Load In System “Lamp” Let’s set up the Inputs first Select the switch called Motor Control in the Control Panel In the Properties panel, below PLC Input expand the properties by clicking the arrow to the left of where it says On/Off    Enter the Byte No. as 1 and the Bit No. as 1 Now select the push button Feed Load In the Properties scroll down to PLC Input and expand the section by clicking the arrow to the left of where it says Pushed   Enter the Byte No. as 1 and the Bit No. as 2 Now select the second sensor that was added to the model earlier In the Properties scroll down to PLC Input and expand the section by clicking the arrow to the left of where it says Blocked   Enter the Byte No. as 1 and the Bit No. as 2 Now select the first sensor that was added to the model As before scroll down to PLC Input in the Properties and expand the section called Blocked by clicking on the arrow   Enter the Byte No. as 1 and the Bit No. as 3 Now, if the Inputs tab at the bottom of the screen is selected, the list of the inputs in the model can be viewed   Now to add the Outputs to the system Select the Motor by clicking any of the red arrows in the model In the Properties scroll down to where it says Operations and expand the section for Forward (Output) by clicking on the arrow to the left of it   Enter the Byte No. as 1 and the Bit No. As 1 Now select the Feeder, that is the triangle/arrow located on the first straight that was added to the model Scroll down the Properties to the section PLC Output and expand the section for Feed by clicking on the arrow to the left of it   Enter the Byte No. as 1 and the Bit No. As 2 Lastly select the Lamp in the Control Panel In the Properties scroll down to PLC Output and expand the properties under Lighting by clicking the arrow to the left of it   Enter the Byte No. as 1 and the Bit No. As 3 Now if the Outputs tab at the bottom of the screen is selected the list of the outputs in the model can be viewed  

Step 1:   Make a C# project where the main class extends the Experior.Core.Controller or Experior.Core.Logic class. Experior.Core.Controller is for making controllers that interacts with a model running in the discrete event engine and Experior.Core.Logic is for controllers interacting with a model running in the physics engine.     Step 2:   To start Experior directly within Visual Studio set Start external program. Then you can insert break points in the controller code and debug the source code.     Step 3:   Make sure the output path is the same as Experior     Step 4:     Now build the model you want to control and link the compiled controller with the model.   You can add multiple controllers disable/enable a linked controller or unload an existing controller.  

With a developer license for Experior 6 it is possible to create custom components, catalog, controllers, plugins and more in your Experior model. We have three different templates you can download and use, as long as you have Experior 6 installed.   You can download the templates attached in this article.   Setting up templates for use in visual studio To set up the templates you first need to copy the template in the C# visual studio template folder. The standard path for this is: C:\Users\ your username \Documents\Visual Studio 20XX\Templates\ProjectTemplates\Visual C# Sometimes you can experience problems with Visual Studios cache, that will fail to refresh the templates and display them in the browser, it is necessary to open the Visual Studio command prompt, which is located in following folder: C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio 20XX\Visual Studio Tools Run the ‘Developer Command  Prompt for VS 20XX’ as administrator and write: devenv /installvstemplates   Please note Due to changes in the Experior API will the plugins not compile without a reference to Experior.Common.dll. Setting this reference is done by right clicking ‘References’ in the Visual Studio solution explorer, pressing ‘add reference’ and choosing Experior.Common.dll from the list. If the  dll is not found on the list, press browse and choose the dll from the Experior install directory.  

The Communications window is located in the same area as the Catalogs pane but on a different tab.   PLC controls and Communications protocols can be added – for instance to connect to Siemens S7 series or Beckhoff PLCs.  

It is possible to extend the functionality of Experior with custom communication protocols. This is done by creating your own plugin and extending Experior.Core.Communication.PLC.Connection.   In case your connection is TCP/IP based you can extend from Experior.Core.Communication.PLC.TCPIP.Connection.   Experior.Core.Communication.PLC.Connection In attached memcom communication plugin a custom connection is made that doesn’t use the network to communicate but instead uses a memory stream. This plugin can be used to quickly test your Input/Output driven components. You do this by connecting an input and an output through the same address of the memcom connection.   For example link the Pushed PLC Input symbol of a button to Byte 1 Bit 0 of the memcom connection and also connect the Lighting PLC output to Byte 1 Bit 0 of the memcom connection. When pressing the button the lamp will light up:   The custom connection uses a memory stream to achieve this because a memory stream has similar behavior as a regular network stream.   The source code contains some notes explaining how to achieve the same functionality without the memory stream (and just share the data buffer).   Whenever the user assigns an input/output from a component to a PLC connection then this input/output is assigned to a PLC Buffer (Experior.Core.Communication.PLC.Buffers.Input/Experior.Core.Communication.PLC.Buffers.Output). These buffers maintain an array of bytes and grows/shrinks whenever new inputs/outputs are added/removed.   So in the constructor of the connection we create the buffers and subscribe to the events that are triggered when their size should change or when new inputs/outputs are assigned to them.   It is possible to have multiple buffers in a connection. Therefore we distinguish between them in a connection using a unique key (string) the Source.   In the example plugin only 1 Input buffer and 1 Output buffer is used, each with a default Source name equal to “0”.   In the constructor we also restore the saved buffer in case it exists. public MemConnection(MemConnectionInfo info) : base(info) { input = new Core.Communication.PLC.Buffers.Input(); // first restore the saved outputbuffer if it exists if (info.outputs != null && info.outputs.Count > 0) { output = info.outputs[outslot]; } else output = new Core.Communication.PLC.Buffers.Output(); //give the input and output buffer a unique slot name input.Source = inpslot; output.Source = outslot; // subscribe to the different events to react upon data changes or to properly allocate the buffers output.BufferChanged += new Core.Communication.PLC.Buffers.Output.BufferChangedEvent(OutputDataUpdated); input.BufferChanged += new Core.Communication.PLC.Buffers.Input.BufferChangedEvent(InputDataUpdated); Experior.Core.Communication.PLC.Connection.Inputs.LengthChanged += new Inputs.LengthChangedEvent(Inputs_LengthChanged); Experior.Core.Communication.PLC.Connection.Outputs.LengthChanged += new Outputs.LengthChangedEvent(Outputs_LengthChanged); Experior.Core.Communication.PLC.Connection.Outputs.ConnectionedAssigned += new Outputs.OutputEvent(Outputs_ConnectionedAssigned); Experior.Core.Communication.PLC.Connection.Outputs.ConnectionedUnAssigned += new Outputs.OutputEvent(Outputs_ConnectionedUnAssigned); Experior.Core.Communication.PLC.Connection.Inputs.ConnectionedAssigned += new Inputs.InputEvent(Inputs_ConnectionedAssigned); Experior.Core.Communication.PLC.Connection.Inputs.ConnectionedUnAssigned += new Inputs.InputEvent(Inputs_ConnectionedUnAssigned); // add sources to the connection AddSource(input); AddSource(output); Experior.Core.Environment.Scene.Loaded += new Core.Environment.Scene.Event(Scene_Loaded); }   When the user assigns an Input/Output to the connection it triggers the Experior.Core.Communication.PLC.Connection.Inputs.ConnectionedAssigned and  Experior.Core.Communication.PLC.Connection.Outputs.ConnectionedAssigned events.   In the example we only use this to set the Source property of the Input/Output private void Inputs_ConnectionedAssigned(Input sender, Core.Communication.PLC.Connection connection) { if (this != connection) return; // here you can react upon the sender being added to this connection // in our case we just want to ensure the proper Source is set sender.Source = inpslot; }   Due to the nature of the example connection it is crucial that the Input and Output buffer have the same size so a big part of the source code is related to this.   When assigning Inputs/Outputs to a connection Experior verifies whether the buffer size should change and in those cases triggers the Experior.Core.Communication.PLC.Connection.Inputs.LengthChanged or Experior.Core.Communication.PLC.Connection.Outputs.LengthChanged events.   At all times you ask the minimum and maximum used byte of a input/output buffer by providing the connection and the Source of the buffer: int max = Experior.Core.Communication.PLC.Connection.Inputs.MaxSize(this, inpslot); int offset = Experior.Core.Communication.PLC.Connection.Inputs.MinSize(this, inpslot);   If the buffer is not large enough anymore you can allocate sufficient bytes: // allocate (max-offset) bytes for the input buffer starting from offset input.Allocate(max - offset, offset, Experior.Core.Communication.PLC.Buffers.Buffer.Units.SINT);   Note: Experior.Core.Communication.PLC.Buffers.Buffer.Units.INT is used to indicate that the given size should be measured in bytes. In case Experior.Core.Communication.PLC.Buffers.Buffer.Units.SINT is used the size will be measured in words of 16 bits.   After the allocation the input.Data property will be an array of bytes with the proper size. When the user tries to connect the connection the EstablishConnection() method is called. When he tries to disconnect the Disconnect() method is called. In our example we override both methods and set the proper state of the connection (Core.Communication.State). When establishing the connection we make sure that the Input/Output buffers are allocated with the same size. In case we use a memorystream we also start listening on the stream (similar as we would be on a networkstream).   When the states of the Input/Outputs are changed this is immediately reflected in changes of the corresponding Input/Output buffers of the associated connection and the BufferChanged events are triggered. In our example we write the changed buffer to the memorystream. A different thread reads the memory stream and when the byte array is received it calls the byte[] DataReceived(string source, byte[] data) method of the connection to indicate that the given source has received the given data. int l = memStream.Read(incoming, 0, incoming.Length); if (l > 0) { DataReceived(inpslot, incoming); }   This triggers the proper events on the changed Inputs/Outputs. In the example without the memorystream we simply share the Data of the buffer and directly call the DataReceived method.   Experior.Core.Communication.PLC.TCPIP.Connection This connection class inherits from Experior.Core.Communication.PLC.Connection and mainly adds some TCPIP specific properties like Port, IP address and distinction between server and client connection: string IP: This getter property is used to get / or set the IPv4 address used by this connection. For a server connection this is 127.0.0.1 (localhost).   int Port: This property is used to get or set the port number for the TCPIP connection.   bool Server: Getter property to indicate whether this connection is used as server or client.

Before starting to build your first Assembly please read Assembly Configuration   Please have a look at the attached presentation that shows how easy it is to create an assembly.   You can download the attached zip file that includes a Visual Studio Project with the assembly created in the presentation

  Overview   When you build an assembly the Assembly Configuration object can automatically handle: Rendering of parts, measures and other assemblies (sub-assemblies) Disposing of parts and sub-assemblies Picking User movement and rotation with the mouse Locking and unlocking Selecting and deselecting   If you want to manually handle some of these methods you must override the according method (or property) in the Assembly class:   public virtual void Move(Vector3 delta) public virtual float Yaw public virtual Vector3 Position public virtual void Lock() public virtual void UnLock() public virtual PickResult Pick(Vector3 rayStart, Vector3 rayDirection) public virtual void Render() public virtual void Select() public virtual void DeSelect() public virtual void Dispose()   This part of the wiki will explain how to: Add a part, a measure or another assembly to the assembly Position, rotate and move parts using local coordinates Use movement and angular movements of parts Use the coordinate systems   All examples in this document refer to the assemblies in the DeveloperSamples catalog. Naming the coordinates   When referring to an assembly’s local coordinates the coordinate system on the blue conveyor in Figure 1 is being referred to. These coordinates will always follow the assembly.   The Global coordinates always refer to the coordinate system of the 3D environment with axis names: X, Y, Z, also illustrated in Figure 1. This coordinate system is never moved.   The third coordinate system, placed in the blue cube in Figure 1, is the parts own coordinate system. This coordinate system is not as important as the two others and is mainly used when using a LocalRotationPoint.   Figure 1   Classes, methods and properties   The Assembly Configuration object is not accessed directly. But it is used indirectly when using the following methods and properties in the RigidPart, Assembly and Measure classes.   For the RigidPart class the involved methods and properties are: public Vector3 LocalPosition public float LocalYaw public float LocalPitch public float LocalRoll public Vector3 LocalRotationPoint public void LocalMovement(Vector3 localVelocity, float lengthToMove) public void LocalMovement(Vector3 localVelocity, float lengthToMove, float rampUpLength, float rampDownLength) public void LocalAngularMovement(Vector3 angularVelocity, Vector3 radiansToRotate) public event FinishedMoving LocalMovingFinished; public event FinishedRotating LocalRotationFinished; public CoordinateSystem LocalCoordinateSystem   For the Assembly class the involved methods are: protected RigidPart Add(RigidPart part) protected RigidPart Add(RigidPart part, Vector3 localPosition) protected RigidPart Add(string name, RigidPart part) protected RigidPart Add(string name, RigidPart part, Vector3 localPosition) protected Assembly Add(Assembly assembly, Vector3 localPosition) protected Assembly Add(Assembly assembly, Vector3 localPosition, bool visible) protected Core.Dialog.Measure Add(Core.Dialog.Measure Measure) protected CoordinateSystem Add(CoordinateSystem c) protected bool Remove(RigidPart part) protected bool Remove(Core.Dialog.Measure measure) protected bool Remove(Assembly assembly) public Vector3 LocalPosition public float LocalYaw public float LocalPitch public float LocalRoll   For the Measure class the involved methods are: public Vector3 LocalStartPosition public Vector3 LocalEndPosition   Note that all methods and properties begins with Add, Remove or Local. Add parts, measures and assemblies Adding parts   Adding a part to an assembly is done by the method Add(RigidPart part).   Example: (See Sample0.cs for full source code) Add(new Cube(Color.Wheat, 0.5f, 0.5f, 0.5f));   Figure 2 Without further code the cube can now be selected, deselected, locked, unlocked, picked, moved and rotated.   To remove the part from the assembly: protected bool Remove(RigidPart part) Note: this does not dispose the part.   Positioning of parts using LocalPosition In Sample1.cs it is shown how to add 100 cubes and position them using the LocalPosition property. Example: (See Sample1.cs for full source code) for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { Add(new Cube(Color.Wheat, 0.5f, 0.5f, 0.5f), new Vector3(0, i, j)); } } Figure 3   When a part is added to an assembly it is recommended that the part is positioned using the LocalPosition property.    The property called Position always refers to a part’s global position.   Rotating parts using LocalYaw, LocalPitch and LocalRoll   In Sample2.cs two cubes are added. The LocalPitch value of the blue cube has been set to 0.56f.   Default values for LocalYaw, LocalPitch and LocalRoll are 0 and the units are radians.   Figure 4 Note: If a part is not added to an assembly, the properties Yaw, Pitch and Roll will refer to the global orientation.   When a part is added to an assembly these values refer to the rotation in the parts own coordinate system. See also the section about LocalRotationPoint.   Adding another assembly and a measure   It can be useful to add another assembly and treat it as a part (or as a sub-assembly). This can be done with the method:  protected Assembly Add(Assembly assembly, Vector3 localPosition)   When the assembly has been added it can be positioned and rotated with the following methods: public Vector3 LocalPosition public float LocalYaw public float LocalPitch public float LocalRoll LocalPosition, LocalYaw, LocalPitch and LocalRoll all use the coordinate values of the assembly that the sub-assembly has been added to.   To add a measure use the following method: protected Core.Dialog.Measure Add(Core.Dialog.Measure Measure)   When constructing the measure a start position and an end position must be provided. Local coordinates must be used for these values as they are used when adding the measure to the assembly as the LocalStartPosition and LocalEndPosition.   If later on these values need changing use the following measure methods: public Vector3 LocalStartPosition public Vector3 LocalEndPosition Figure 5   The file Sample3.cs contains an example on how to add an existing conveyor and a measure as illustrated in Figure 5.   To remove the assembly or the measures use the following methods: protected bool Remove(Assembly assembly) protected bool Remove(Core.Dialog.Measure measure) Note: this does not dispose of the assembly.   Linear and angular movement (Physics mode) LocalMovement and LocalAngularMovement   To create a movement of a part it is always possible to override the void Step(float deltatime) method in the Assembly and use this time-step to move the parts.   The Assembly Configuration gives you two methods to create movements without overriding the Step method.   One for a straight movement: public void LocalMovement(Vector3 localVelocity, float lengthToMove)   One for an angular movement: public void LocalAngularMovement(Vector3 angularVelocity, Vector3 radiansToRotate)   These methods are available for the RigidPart class as well as the CoordinateSystem class (see later section) but not for the Assembly class.   The parameter Vector3 angularVelocity has the form:   (Local yaw Velocity, Local pitch velocity, Local roll velocity) It uses the units radians/second.   The parameter Vector3 radiansToRotate has the form: (Delta yaw, Delta pitch, Delta roll) It uses radians as units.   Note: if using a positive Local yaw Velocity a positive Delta yaw must be used as a stop condition, because the rotation is around the local Y-axis in positive direction. Likewise, if using a negative Local yaw Velocity a negative Delta yaw must be used.   To know when the movement has finished the following events can be subscribed to: public event FinishedMoving LocalMovingFinished; public event FinishedRotating LocalRotationFinished; Example: (See Sample4.cs for full source code)   The method: LocalMovement(new Vector3(1, 0, 0), 1); This will create a movement with velocity (1,0,0) in local coordinates which stops after 1 meter. Note that the length must always be positive, otherwise the movement is ignored.   The method: LocalAngularMovement(new Vector3(1, 0, 0), new Vector3((float)Math.PI, 0, 0)); This will create a rotation which rotates around the local Y-axis with velocity 1 radian/second which stops when it has rotated PI degrees.   The method: LocalAngularMovement(new Vector3(-1, 0, 0), new Vector3(-(float)Math.PI, 0, 0)); This will create a rotation which rotates around the local Y-axis with velocity -1 radian/second which stops when it has rotated -PI degrees.   How to use coordinate systems When more advanced movements are created it can be useful to have several coordinate systems. This is, for example, the case when constructing a robot as the one in the Robot class in the DeveloperSamples catalog. When using more than one coordinate system a hierarchy of coordinate systems can be used, meaning that a coordinate system can have a subsystem and a parent system. The top most coordinate system (the one having no parent system) is used as the local coordinate system of the assembly.   Robot class In the Robot class in the DeveloperSamples catalog we use 5 coordinate systems as illustrated in Figure 8. The coordinate systems have been placed where the robot is able to move or rotate.   If the coordinate systems have been constructed and added to the assembly using the following method: protected CoordinateSystem AddCoordinateSystem(CoordinateSystem c)   Then parts can be added to the coordinate system. This can be done with either: coordinate0.AddPart(link0, new Vector3(-0.17f, 0.15f, 0));   or: link0.LocalCoordinateSystem = coordinate0; link0.LocalPosition = new Vector3(-0.17f, 0.15f, 0); When a part has been added to a coordinate system the LocalPosition property of the part will refer to that coordinate system. Figure 8   The coordinate system axes have the same colors as the coordinate system axes of the 3D environment of Experior, the X-axis is green, Y-axis is red and Z-axis is blue.   Constructing the Coordinate System The coordinate system class has the following constructor: public CoordinateSystem(CoordinateSystem SubSystem, Vector3 SubSystemPosition)   Here it can be specified which coordinate system should be the subsystem and where it should be placed SubSystemPosition. The subsystem will automatically be assigned to the coordinate system which will function as its parent system.   If the coordinate system should not have any subsystem use the constructor:   CoordinateSystem(null, Vector3.Empty); Linear and Angular Movement of Coordinate Systems   The CoordinateSystem class has some of the same methods and events as the IRigidPart class: public void LocalMovement(Vector3 localVelocity, float lengthToMove) public void LocalMovement(Vector3 localVelocity, float lengthToMove, float RampUpLength, float RampDownLength) public void LocalAngularMovement(Vector3 angularVelocity, Vector3 radiansToRotate) public event FinishedMoving LocalMovingFinished public event FinishedRotating LocalRotationFinished When these methods are used the coordinate system will rotate or move any parts that are added to the coordinate system.   Rotating a coordinate system relative its parent system   To rotate a coordinate system use the following method:   public void RotateRelativeParent(float deltaYaw, float deltaPitch, float deltaRoll) This will also rotate its subsystem if there is any.

The Experior.Core.Motors.Motor class is used in Experior to model motors. The motors are used to initiate movements of loads, parts or assemblies. The main class deriving from Experior.Core.Motors.Motor is the class Experior.Core.Motors.Electric. The Experior.Core.Motors.Electric class is the main motor used in in discrete mode.   Motors that interact with the PLC are typically of the class Experior.Core.Motors.ElectricExtended which derives from the Electric motor class   There are several classes deriving from the ElectricExtended class.   Experior.Core.Motors.Surface: This class represents a surface motor that is used to move a load and this motor is typically added to a ConveyorBelt part. Experior.Core.Motors.Vector: This represents a Vector motor used to move a part/assembly in a certain direction determined by the VectorDirection property. Experior.Core.Motors.Rotation: This represents a Rotation motor used to rotate an assembly/part in the horizontal plane. Experior.Core.Motors.EccentricLinear: This represents an eccentric motor where the attached parts/assembly will move linearly up/down Experior.Core.Motors.EccentricRotation: This represents an eccentric motor where the attached parts/assembly will rotate up/down   Main methods/properties of an ElectricMotor:   Backward(): This will put the motor in Backward mode. This method does not start the motor if it wasn’t running yet. It only sets the current running direction. If the motor was in Forward mode before the call of this method then the DirectionChanged event is triggered. Forward(): This will put the motor in Forward mode. This method does not start the motor if it wasn’t running yet. It only sets the current running direction. If the motor was in Backward mode before the call of this method then the DirectionChanged event is triggered. Start(): This will start an idle motor. It does not change the direction. Stop(): This method will stop a running motor. SwitchDirection(): This method will change the direction of the motor. If it was forward the new direction will become backward, and if it was backward the new direction will become forward. event MotorEvent DirectionChanged: This event is triggered when the direction of the motor is changed (from forward to backward or vice versa). The delegate contains the motor as only argument. event MotorEvent Started: This event is triggered when the motor is started. The delegate contains the motor as only argument event MotorEvent Stopped: This event is triggered when a running motor is stopped. The delegate contains the motor as only argument. bool Running: This getter property returns true if the motor is started and running, false otherwise. float Speed: This property returns/sets the  nominal speed of the motor. float CurrentSpeed: This getter property returns the current speed of the motor. Note that this can be different from the nominal speed in case the motor is accelerating/decelerating , when frequency encoder is used, when alternate speed is used. Directions Direction: This getter returns the current direction of the motor. Possible values are Experior.Core.Motors.Motor.Directions.Backward and Experior.Core.Motors.Motor.Directions.Forward. Reset(): This method resets the motor. bool Enabled: This getter/setter property controls whether the current motor is enabled (value equals true) or disabled (false). In case the motor is disabled it can’t be started.

File handling: New project: Ctrl + N Open project: Ctrl + O Save project: Ctrl + S   Assembly editing: Copy (selected assembly/assemblies): Ctrl + C Cut (selected assembly/assemblies): Ctrl + X Paste (copied or cut assembly/assemblies): Ctrl + V Snap two assemblies together: Drag assembly and press Ctrl when the assemblies’ snap points overlaps Unsnap two snapped assemblies : Press Ctrl and drag one assembly away from the other Alter assembly size (only certain assemblies): Shift + drag with mouse Multiple selection of assemblies: Shift + select with mouse Group assemblies (multiple selected assemblies): Ctrl + G Ungroup selected assemblies: Ctrl + U Delete all assemblies: Multiple select + delete Lock/Unlock selected assembly/assemblies: Ctrl + L Undo (only certain assemblies): Ctrl + Z Redo (only certain assemblies): Ctrl + Y   Assembly control: Activate (only certain assemblies, must be selected): + Deactivate (only certain assemblies, must be selected): – Release loads where cursor points: F (run mode only)   Load control: Stop/Release a load on a track: S Release a load (already stopped): R Jump back 100 mm an release (A load stopped on an Action Point): J Ungroup (release a selected load that are a part of a group): Shift + Space Enable/Disable a load : Space   Run control: Pause/Start: P Reset model (delete all loads): Ctrl + R Start/stop motors: select and press + (or double-click motors) Alter motor direction: Ctrl + left mouse click. When motor is selected: – (minus button)   Scene / viewing: Default camera view: F5 Save camera views: Ctrl + Shift + 1-9 Jump to saved views: Shift + 1-9 Fly to saved views: 1-9 Toggle orthogonal / isometric view: F12 Toggle full screen: F11 Zoom in and out: +/- (or roll mouse wheel) Follow a load: Select a load and press: F Alter the centre of the 3D scene: Position cursor in new centre + Ctrl + right click   Scene / details: Lock/unlock 3D scene: Ctrl + L Show/hide motors: Ctrl + M Toggle labels: Ctrl + E Toggle primitives: Ctrl + P Toggle shadow: Ctrl + Q Debug (developer license only): Ctrl + D

This section provides a brief overview of the available Communications Protocols, what they are and how to use and configure them.   To insert a Communications Protocol, right click on the Communications pane and select it from the pop-up context menu.   There are 8 different main communication protocols.   Depending on the supplied Experior license, different low level communication protocols can be set up for use within Experior.   The following 5 protocols are generally used for direct connections to PLCs and allow Experior to use/respond to PLC symbolics, ladder logic code etc.   Siemens (which itself is split down into 2 different protocol types, Fetch & Write – which are generally used together – and S7 Functions) Ethernet/IP – CIP OPC Serial (RAW) Beckhoff ADS   These last 3 protocols are for configuring systems to allow Experior to send and receive system telegrams and messages.   STX/ETX (contains options for configuring Serial and TCP/IP connections) 3964R (contains options for configuring Serial and TCP/IP connections) RFC1006   Auto Connect   Under the Properties for each communications protocol is the option to Auto Connect when the model is loaded.   When set to True the communications protocol will try and automatically connect when the model is loaded.   The Delay property allows the user to define a time for the communications protocol to wait before it tries to automatically connect.  

A plugin can be used to add custom functionality to Experior and you can also use it to extend the GUI by adding menu items and/or adding your own forms. A plugin is a dll that will be automatically loaded by Experior (provided the dll can be found in the installation directory of Experior). You can create your own plugin by creating a separate Visual Studio project where your plugin class derives from Experior.Core.Plugin.    Toolbar.Button To extend the GUI you can create a Button (Core.Environment.UI.Toolbar.Button) and add it to a toolbar.   In the example below a button is created and added to Model Toolbar in a Tab with name TestPlugin : Core.Environment.UI.Toolbar.Button IOButton = new Core.Environment.UI.Toolbar.Button("SensorOutputs", btnIOToggle_Click); IOButton.Tooltip = "Show outputs from sensors"; // add the button to the Model toolbar in a Tab with name "TestPlugin" Core.Environment.UI.Toolbar.Add(IOButton, "TestPlugin");   This will look as follows:   When the example SensorOutputs button is clicked it will trigger the associated btnIOToggle_Click method.   In this example this will update a custom form.   Experior.Core.Forms.Form Experior allows to add your own forms. You create your form similar to a normal System.Windows.Forms.Form.   However if you want to have a form that behaves similar to other Experior forms and is dockable, the created form should derive from Experior.Core.Forms.Form instead.   Also the FormType property has to be overridden. public override Core.Forms.Docking.DockContent.FormTypes FormType { get { return Core.Forms.Docking.DockContent.FormTypes.Permanent; } }   In attached example is a custom form that contains a datagrid will info of all Outputs for the sensors in your model. The form looks as follows when it is docked:   You can download the complete plugin attached to this article

Routes are used in Experior to move loads following a track (linear, curve) without usage of the physics engine. Therefore routes are mainly used in discrete event mode. Routes are implemented in Experior using the abstract base class Experior.Core.Routes.Route. A straight route is implemented by the Experior.Core.Routes.Linear class, while a curved route is implemented by the Experior.Core.Routes.Curve class.   Routes may contain Action Points which typically represent destination points or decision points. By connecting routes Experior calculates the routing graph based on the nodes (action points) in the network. This routing graph can be used to calculate the shortest path to a new destination (Action Point ).   To incorporate routes in the working area and other components they are usually encapsulated in a TransportSection assembly. The TransportSection assemblies themselves are used as building blocks in the different Track assemblies.   A Route keeps track of the loads that are moving on it and of the Action Points it contains.   Note: In discrete event mode loads are always on a Route or on an Action Point. (Loads that are Deletable will be automatically deleted by Experior when they are not on a Route or Action Point).   Main properties: List ActionPoints: Getter property that returns all action points on this route.   LinkedList Loads: Getter property that returns all loads on this route.   Load First: Getter property returning the first load on this route.   Load Last: Getter property returning the last load on this route.   bool Bidirectional: Property that indicates whether Experior should consider this route as bidirectional or not when constructing the routing graph. Suppose the route between action points AP1 and AP2 is bidirectional than this means that the routing graph will have two edges between the vertices AP1 and AP2. In case the bidirectional property is false only 1 directed edge from AP1 to AP2 is available. Setting the bidirectional property has no impact on the actual movement of the loads: the developer still has to ensure that a load can move in opposite direction.   Motor Motor: Property that gets/sets the Motor used to control the movements of the loads on this Route. Changing the speed of the motor will change the speed by which loads move on its route and changing the speed sign will make the loads move in opposite direction.   Vector3 Start: Property that gets/sets the global position of the startpoint of the route.   Vector3 End: Property that gets/sets the global position of the endpoint of the route.   float Yaw: Getter property that returns the global Yaw of this route.   float Length: Property that gets/sets the total length of this route   bool Vertical: Property that gets or sets whether the route is vertical or not. This has an impact on how loads are positioned on the route.   bool Visible: Gets or sets a value indicating whether this Experior.Core.Routes.Route is visible.   float Yaw: Getter property that returns the global Yaw of this route   Main events: event Route.ArrivedEvent Arrived: This event is raised when a load arrives. This is not synchronized with the discrete event execution.   event Route.LoadAddedEvent LoadAdded: This event is raised when a load is added to the route.   event Route.LoadRemovedEvent LoadRemoved: This event is raised when a load is removed from the route.   static event Route.UpdatedEvent Updated: This event is raised when the routing graph is updated.   Main methods: void Add(Load load): This method will add the given load to the start of this Route.   void Add(Load load, float distance): This method will add the given load to this Route at the given distance from the start.   void Remove(Load load): This method will remove the given load from this Route.   ActionPoint InsertActionPoint(float distance): This method will create and return an actionpoint and position it at the given distance from the start of this route.   void RemoveActionPoint(ActionPoint ap): This method will remove the given actionpoint ap from this route.   void ClearLoads(): This method will remove all loads from this route.   Main static methods: static ActionPoint FindNextActionPoint(ActionPoint ap): Given an actionpoint ap this method will return the next axtionpoint on the route (returns null if no actionpoint is found).   static ActionPoint FindNextActionPoint(Route route): Given a Route route this static method will return the first actionpoint on that route.   static ActionPoint FindNextActionPoint(ActionPoint ap, out float distance): Given an actionpoint ap this static method will return the next actionpoint on the route (if any) and put the distance between the two actionpoints in the distance out parameter. static ActionPoint FindPreviousActionPoint(ActionPoint ap, out float distance): Given an actionpoint ap this static method will return the previous actionpoint on the route of ap and put the distance between the two actionpoints in the distance out parameter. If the route of ap does not have a previous actionpoint then the previous route is looked at to find the previous actionpoint.   static float ShortestDistanceToActionPoint(Load load, string destination): Given a load and the name of an actionpoint this static method will return shortest distance from the current position of the load to the actionpoint by following the shortest path on the linked routes. If no path can be found float.PositiveInfinity is returned and a warning is logged.   static float ShortestDistanceToActionPoint(string sourceAP, string destinationAP): Given the name of a source actionpoint  and the name of a destination actionpoint this static method will return shortest distance between the two actionpoints by following the shortest path on the linked routes. If no path can be found float.PositiveInfinity is returned and a warning is logged.   static void Update(): This static method will result in the updating of the routing graph. (This is also called when a user deletes or adds an actionpoint)   Example: float distance = Route.ShortestDistanceToActionPoint(load, "AP3"); if (float.IsInfinity(distance)) { Experior.Core.Environment.Log.Write("No path found from load " + load.Identification + " to actionpoint AP3"); } else { Experior.Core.Environment.Log.Write("Distance from load " + load.Identification + "to actionpoint AP3=" + distance); } distance = Route.ShortestDistanceToActionPoint("AP2", "AP3"); if (float.IsInfinity(distance)) { Experior.Core.Environment.Log.Write("No path found between AP2 and AP3"); } else { Experior.Core.Environment.Log.Write("Distance from AP2 to AP3=" + distance); }

Please note that if you are creating a custom catalog or plugin for Experior 6 in Visual Studio 2022, you will get an error message when trying to compile the .dll. This is because Visual Studio 2022 will not be able to locate experior.build.dll. The reason it can’t locate the file, is because it is 32 bit and Visual Studio 2022 (or newer) is 64 bit.   You will be able to compile a catalog/plugin with previous versions of Visual Studio, for example 2019 is confirmed working with Experior 6.   Are you experiencing this issue and need help, feel free to contact us on email experior.support@se.com