Table of Contents

1. Installation
2. Configuration
3. Workloads and Packages
4. Conclusion

TwinCAT Package Manager is Beckhoff’s new innovative way of managing packages within the TwinCAT environment. Released with their latest build 4026, Package Manager allows for quick and easy downloads of TwinCAT versions and workloads (collections of one or more packages), as well as individual packages. Let’s get started with some of the key features of the TwinCAT Package Manager.

Installation

Download the latest version of the TwinCAT Package Manager from the Beckhoff website. This blog will use the full installation, which includes the UI. If you would prefer the command-line-only install, some common commands are available on Beckhoff Infosys.

Follow the installation procedure to install TwinCAT Package Manager.  

Configuration

Once TwinCAT Package Manager is installed successfully, open it. If this is your first time launching Package Manager, you should be greeted with the Introduction screen. If you have previously launched Package Manager, but want to follow along, you can access this screen with the Settings button (gear icon) in the bottom left.

Introduction

If you’re installing Package Manager on a system with a previous build of TwinCAT already installed, there will be a migration tab instead of a location tab. We will deal with that in a later section. Click Next.

Feeds

The next section is for configuring the feeds for Package Manager. Click the “Add new feed” button to add one of these feeds.

By default, Beckhoff provides three feeds: the stable feed, the outdated feed, and the testing feed. The stable feed contains officially released Beckhoff products and is typically the main feed for most workloads and packages. Select the URL that ends with “/stable” to add the stable feed. The feed name should auto-populate, but can be changed. Enter your valid myBeckhoff account credentials and click Save to add the feed. You can create your own myBeckhoff account if you don’t already one.

You’re also able to create your own feed, which you can access here. This would allow you to easily share custom libraries with other developers on your team. We won’t go in depth on how to do that in this blog, but the Beckhoff community GitHub repo has an example structure.

You should now see the feed added. You’re able to disable, edit, or delete the feed from this view if needed.

The outdated feed contains previous TwinCAT builds. If you used TwinCAT prior to build 4026, this is essentially the new version of Remote Manager. The testing feed contains test versions of workloads and packages. It’s most commonly used if you need access to an unreleased feature or are testing packages with Beckhoff engineers.

Follow the steps above for the stable feed to add the outdated and testing feeds, making sure to use their respective URLs.

Once you add the outdated and testing feeds, your Feeds tab should look like the one above. You can reorder the feed priorities using the up and down arrows on the right side. It’s recommended to keep the stable feed as priority 1 since it contains the officially released packages. If you reordered the feeds, click the save button in the top right. If you click next with unsaved changes, you will get this warning.

If you see this warning, click “Yes” to save changes. Click “Next.”

Integration

The next screen asks which versions of TwinCAT XAE to install. Since TwinCAT XAE is built on Visual Studio, it requires the same Visual Studio version (32-bit or 64-bit) to be installed. If you’re working on a project in build 4026 or newer, it’s recommended to use the 64-bit version when possible. If you’re working on a project in a build prior to 4026 or on a 32-bit computer system, the 32-bit version of TwinCAT XAE is the only option. You can always add or remove these XAE versions later, so for now, let’s install both. Click “Next.”

Migration

If you had a previous build of TwinCAT, you will be prompted to complete a Migration screen. If you did not have a previous build of TwinCAT, feel free to skip to the Location section.

The migration tool will attempt to capture existing user settings on previous versions of TwinCAT, uninstall previous versions, install the latest versions, and reapply the user settings. Let’s click “Start Migration” to get started.

When getting to step 2 of the preparation screen, you may see a notification that you need to install the MigrateCli package. Click “Yes” to continue.

Once the migration tool is installed, click “Start Simulation.”

Once the migration simulation runs, you should see a list of all existing products in the system and how TwinCAT Package Manager plans to upgrade them to packages and workloads.

Assuming all the products can be upgraded to packages and workloads, we are ready to start the migration. Click Start Migration.

Depending on the products you have installed, you may need to reboot your system. Press Ok and the TwinCAT Package Manager should automatically start up after rebooting and continue the migration.

Once the migration is complete, click Finish. You should see all the latest versions of the products you had previously installed on the system.

Location

If you did not have a previous version of TwinCAT installed, the final screen asks where to install TwinCAT. The default location is fine unless you have a reason to install it elsewhere. Click Finish.

Workloads and Packages

The workload view should be the default view when opening Package Manager for the first time. It can be navigated to by hovering over the package icon with a W in the bottom right and selecting workloads.

Workloads

Workloads are groupings of packages that closely align with Beckhoff’s licensing structure. For example, if you’re planning on using Beckhoff XTS in your solution, you can search for “XTS” to find the TF5850 | TwinCAT 3 XTS workload. This will install the necessary packages to work with XTS. If you are using XTS in your solution, check out our blog series on XTS to help get started!

The workloads in the general section are the ones we should install first. Let’s start by installing the latest version of TwinCAT Standard Engineering and the latest versions of TwinCAT XAE Shell 32-bit and 64-bit. If you’re installing the latest version, simply click on the blue download button associated with that workload.

You’ll see the planned installations added to the right side of Package Manager under selected products. Click Apply Modifications to start the installation.

Some workloads will require a restart. The TwinCAT Standard installation is one of them. Click Accept to continue.

If a pop-up appears asking you to allow the TwinCAT Package Manager to make changes to your device, click “Yes.”

The installation may take a few minutes, but Package Manager will give you a download and installation status.

Once the installation completes, Package Manager will show a check mark next to the workloads that were successfully installed.

We didn’t explicitly install TwinCAT Standard Remote Manager or TE9000 | TwinCAT 3 Safety Editor. Why are they showing as installed? TwinCAT Package Manager will install all dependencies needed to install the selected workloads! These workloads are dependencies for TwinCAT Standard and are automatically installed for us.

Workloads (Other Versions)

One of the nice things about TwinCAT Package Managers is the ability to access prior versions of all the workloads. Each workload has an ellipsis on the right side. Clicking on this provides the option to select other versions.

Click on the other versions option for TwinCAT Standard.

We can see that the latest version is currently installed and can be uninstalled here if needed. If we wanted to install a previous version, say 4026.21.2, we could click the icon next to that version. That icon is the downgrade icon. This would uninstall 4026.22.0 and downgrade TwinCAT Standard to 4026.21.2.  However, TwinCAT Standard Remote Manager can be used when working on multiple solutions across different versions.

Click the triple-dot icon next to TwinCAT Standard Remote Manager, then select other versions.

The icons here are install icons instead of downgrade icons, even though we already have the latest version installed. This is because the TwinCAT Standard Remote Manager supports multiple versions, as indicated by the AllowMultiple attribute in the top left. Installing from here will allow both versions to coexist on the same system. To illustrate this, I’ll install version 4026.21.2.

The Package Manager workload for TwinCAT Standard Remote Manager now shows a [ + 1 ] to indicate multiple builds are installed.

When opening TwinCAT XAE, we now have multiple builds to select from!

Installing Pre-4026 Builds

If you haven’t already, make sure you’re connected to the Beckhoff outdated feed. You can configure your feeds by clicking on the settings icon in the bottom left.

Once you have the outdated feed configured, hover over the package icon with the database in the bottom right. Select the “Beckhoff Outdated Feed.”

The only workload associated with the Beckhoff Outdated Feed is the TwinCAT Standard Remote Manager. From the outdated feed, we can install pre-4026 builds of TwinCAT.

I’ll install build 4024.75.4 to illustrate.

After installing build 4024.75.4 on TwinCAT Package Manager, it is now selectable in the build dropdown.

*NOTE: This is only available in the 32-bit XAE. The 64-bit version of XAE only supports builds 4026 and newer.

Packages

So far, we’ve been dealing with Workloads. Workloads are groupings of packages that TwinCAT organizes primarily according to Beckhoff’s licensing structure. TwinCAT projects reference packages directly. Let’s open a new TwinCAT XAE project to see this.

In the References folder of a brand new TwinCAT project, there are the Tc2_Standard, Tc2_System, and Tc3_Module packages.

Let’s switch back to the package manager. On the left, you should be able to go to the package view menu and select Packages.

This will show the individual packages that are available and installed on the system. Let’s search for Tc2_Standard.

We can see that Tc2_Standard is installed.

How To Deal with a Missing Package

If you have a missing package on a TwinCAT project, you will be greeted with a warning sign that looks something like this:

The package with the warning symbol next to it is missing from the project. Double-clicking on the package shows that the library is not available and does not have an effective version listed.

Right-click on the missing package and open the properties window. The resolution will show the version of the package that the TwinCAT PLC project is expecting.

If we go back to Package Manager and search for the Tc2_System package, we can see that although it is installed, it is not the same version the PLC project expects.

Click the ellipses next to the package, then select other versions.

Similar to Workloads, Packages have multiple versions that can be installed onto the same system. In this scenario, we have Tc2_System v3.10.1 installed already, but do not have v3.9.1. Tc2_System allows for multiple versions to be installed, indicated by the AllowMultiple tag. Let’s install v3.9.1 and see if that resolves our issue. Click the download button next to v3.9.1 and click “Apply modifications.”

If you see a message about “TwinCAT XAE / Visual Studio stop required,” be sure to close all open XAE windows before clicking Accept. Once the package is installed successfully, we can check the previously missing package.

The library is now available and has an effective version of v3.9.1. We have installed our missing package through Package Manager!

Conclusion

The TwinCAT Package Manager is a huge improvement in how engineers can manage the various Packages and Workloads that make up a TwinCAT solution. TwinCAT Package Manager is just the start of the improvements that TwinCAT build 4026 brings to development. A complete list of changes is offered on the Beckhoff website. If you’re starting a project in 4026 or upgrading an existing solution to 4026, reach out to DMC and see how we can help! We have extensive experience with upgrading and developing across all TwinCAT builds.

The post Getting Started with Beckhoff TwinCAT Package Manager appeared first on DMC, Inc..

This blog will continue to use the Beckhoff XTS_Base GitHub and the large XTS starter kit. 

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 2 – Setting Up a Physical XTS System
• Part 3 – Simulation and PLC Logic
• Part 4 – Movers
• Part 5 – Stations
• Part 6 – Position Triggers

Customizing the Logic

Let’s update this logic to customize our system a bit more. For my system, I’m going to have stations and position triggers at the following places:

Update the Station and Position Trigger Positions

Remove the existing station and position trigger definitions on lines 108-117 and replace it with the following:

// Initialize station positions
Station[0].Position := 5;
Station[1].Position := 3200;
Station[2].Position := 3300;
Station[3].Position := 3400;
Station[4].Position := 3500;

PositionTrigger[0].Position := 1500;
PositionTrigger[1].Position := 2000;

This will define the stations and position triggers as shown above.

Updating the Station and Position Trigger Logic

Next, we need to update the logic of these stations and position triggers to get them to behave as we want. For this application, let’s have the mover run at high velocity across the top rail, then go down to the low velocity around the bend. Once it clears the bend, it can go back up to the medium velocity until it reaches the next station. Once we have a mover in each of the four bottom left stations, send them all back to station 0. Replacing lines 210-265 with the following code will do that:

// Station 0 Logic
IF Station[0].MoverInPosition THEN
    StationTimer[0](IN := TRUE, PT := T#1000MS);
    IF StationTimer[0].Q THEN
        Station[0].CurrentMover.MoveVelocity(highVelocity);
    END_IF
ELSE
    StationTimer[0](IN := FALSE);
END_IF
    // Position Trigger 0 Logic
IF PositionTrigger[0].MoverPassedPosition THEN
    PositionTrigger[0].CurrentMover.SetVelocity(lowVelocity);
    PositionTrigger[0].MuteCurrent();
END_IF
    // Position Trigger 1 Logic
IF PositionTrigger[1].MoverPassedPosition THEN
    PositionTrigger[1].CurrentMover.SetVelocity(mediumVelocity);
    PositionTrigger[1].CurrentMover.MoveToStation(Station[nextStation]);
    nextStation := nextStation – 1;
    IF nextStation = 0 THEN
        nextStation := 4;
    END_IF
    PositionTrigger[1].MuteCurrent();
END_IF

// Group of Stations 1, 2, 3, and 4 Logic
IF Station[1].MoverInPosition AND Station[2].MoverInPosition AND Station[3].MoverInPosition AND Station[4].MoverInPosition THEN
    StationTimer[1](IN := TRUE, PT := T#750MS);
    IF StationTimer[1].Q THEN
        StationTimer[1](IN := FALSE);
        Station[1].CurrentMover.MoveToStation(Station[0]);
        Station[2].CurrentMover.MoveToStation(Station[0]);
        Station[3].CurrentMover.MoveToStation(Station[0]);
        Station[4].CurrentMover.MoveToStation(Station[0]);
    END_IF
END_IF

Execute the New Code

Save the new code and activate the configuration. After logging in, you should be able to open the Controls visualization, press the Enable button, and then the Start button to start seeing the movers follow the new logic.

This is just an example of the many customizations you can make to your XTS system. There’s even more functionality that comes with this starter project, though. In the next entry in this blog series, we will go over zones and add those to our custom logic.

If you’d like help with the next steps for your XTS system, DMC is proud to be a Beckhoff System Integrator and has worked on multiple XTS projects and applications.

The post Beckhoff XTS Part 7: Customizing Logic appeared first on DMC, Inc..

This blog will continue to use the Beckhoff XTS_Base GitHub and the large XTS starter kit. 

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 2 – Setting Up a Physical XTS System
• Part 3 – Simulation and PLC Logic
• Part 4 – Movers
• Part 5 – Stations
• Part 7 – Customizing Logic

Position Triggers

Position triggers are defined positions along the XTS track that know when movers pass by. This can allow for on-the-fly redirections or changes in velocity.

Declaring a Position Trigger

In MAIN, in the variable declaration we already have an array of position triggers defined with the line

PositionTrigger : ARRAY[0..2] OF PositionTrigger;

PositionTrigger : ARRAY[0..2] OF PositionTrigger;

This defines 3 position triggers to use. If you want to use more, you can increase the array bounds. It’s also likely worth using a global constant similar to how the stations are defined.

Configuring Position Triggers

The existing starter project already has 3 position triggers configured, shown below.

Similarly to the stations, the position definition for these position triggers is in the MS_INTIIALIZING_OBJECTIVES section of the MAIN state machine, which is at line 115.

PositionTrigger[0].Position := 1500;
PositionTrigger[1].Position := 2000;
PositionTrigger[2].Position := 3500; 

PositionTrigger[0].Position := 1500;
PositionTrigger[1].Position := 2000;
PositionTrigger[2].Position := 3500; 

We can see that the position triggers are given positions (in mm) around the track that line up with the picture above. Changing these positions will change where along the track the position triggers exist.

These position triggers also have CyclicLogic methods that must be called every scan and are already called for us at line 419.

PositionTrigger[0].Cyclic();
PositionTrigger[1].Cyclic();
PositionTrigger[2].Cyclic();

PositionTrigger[0].Cyclic();
PositionTrigger[1].Cyclic();
PositionTrigger[2].Cyclic();

If you add more position triggers, make sure to call their CyclicLogic methods as well.

The stations also make sure to unregister movers on stopping or disabling. This happens on lines 332 and 367 by calling the UnregisterAll method for each position trigger.

FOR i := 0 TO SIZEOF(PositionTrigger) / SIZEOF(PositionTrigger[0]) - 1 DO
  PositionTrigger[i].UnregisterAll();
END_FOR

FOR i := 0 TO SIZEOF(PositionTrigger) / SIZEOF(PositionTrigger[0]) - 1 DO
  PositionTrigger[i].UnregisterAll();
END_FOR

Position Trigger Logic

The existing starter project already has some position trigger logic. The logic for these position triggers is in the MS_RUN section of the MAIN state machine, which starts at line 250. There’s a few methods and properties about the position triggers that are useful to describe to interpret this code:

MoverPassedPosition

MoverPassedPosition is a property of the position trigger object. It goes TRUE when a mover passed the configured position trigger’s position. This will allow for logic based on the position trigger to affect the mover passing by.

MuteCurrent

MuteCurrent is a method of the position trigger object. It will set MoverPassedPosition to FALSE and clear out the mover being tracked by the position trigger. This can be used to indicate the position trigger logic is done and a new mover can be handled.

With these properties and methods, let’s see what the current position triggers are doing.

// Position Trigger 0 Logic
IF PositionTrigger[0].MoverPassedPosition THEN
  PositionTrigger[0].CurrentMover.SetVelocity(lowVelocity);
  PositionTrigger[0].MuteCurrent();
END_IF

// Position Trigger 1 Logic
IF PositionTrigger[1].MoverPassedPosition THEN
  PositionTrigger[1].CurrentMover.SetVelocity(highVelocity);
  PositionTrigger[1].MuteCurrent();
END_IF

// Position Trigger 2 Logic
IF PositionTrigger[2].MoverPassedPosition THEN
  PositionTrigger[2].CurrentMover.SetVelocity(lowVelocity);
  PositionTrigger[2].CurrentMover.MoveToStation(Station[0]);
  PositionTrigger[2].MuteCurrent();
END_IF

// Position Trigger 0 Logic
IF PositionTrigger[0].MoverPassedPosition THEN
  PositionTrigger[0].CurrentMover.SetVelocity(lowVelocity);
  PositionTrigger[0].MuteCurrent();
END_IF

// Position Trigger 1 Logic
IF PositionTrigger[1].MoverPassedPosition THEN
  PositionTrigger[1].CurrentMover.SetVelocity(highVelocity);
  PositionTrigger[1].MuteCurrent();
END_IF

// Position Trigger 2 Logic
IF PositionTrigger[2].MoverPassedPosition THEN
  PositionTrigger[2].CurrentMover.SetVelocity(lowVelocity);
  PositionTrigger[2].CurrentMover.MoveToStation(Station[0]);
  PositionTrigger[2].MuteCurrent();
END_IF

Position triggers 0 and 1 are doing similar things. They both wait for a mover to pass their position and then change the velocity of the mover. Position trigger 0 changes to low velocity and position trigger 1 changes to high velocity. They then both call the MuteCurrent methods to clear out the mover from the position trigger. Note that neither of these position triggers are sending a command to the mover, just changing its velocity. The mover is still obeying the MoveVelocity command from station 4.

Position trigger 2 waits for a mover to pass its position, sets the velocity low, and then commands the mover to move to station 0. This will override the move velocity command from station 4 and so the mover will next stop at station 0. The logic then calls MuteCurrent to signal the position trigger has processed the mover.

Now that we’ve reviewed movers, stations, and positions triggers we can not only understand the existing starter project logic but also write our own custom logic. In the next entry in this blog series, we will go over writing some custom logic for our XTS application.

If you’d like help with the next steps for your XTS system, DMC is proud to be a Beckhoff System Integrator and has worked on multiple XTS projects and applications.

The post Beckhoff XTS Part 6: Position Triggers appeared first on DMC, Inc..

This blog will go over the Beckhoff XTS Station block that comes with the base starter project. We will see how to configure the stations properly and what methods we have at our disposal to use with our system. This blog will continue to use the Beckhoff XTS_Base GitHub and the large XTS starter kit.

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 2 – Setting Up a Physical XTS System
• Part 3 – Simulation and PLC Logic
• Part 4 – Movers
• Part 6 – Position Triggers
• Part 7 – Customizing Logic

Stations

Stations are defined positions along the XTS track where movers will stop until commanded to do something else. This allows for a mover to reach the station, have some actions performed on it while stationary, then to be sent elsewhere on the track.

Declaring Stations

In MAIN, in the variable declaration we already have an array of stations declared with the line

Station : ARRAY[0..GVL.NUM_STATIONS - 1] OF Station;

Station : ARRAY[0..GVL.NUM_STATIONS - 1] OF Station;

If you want to add more stations, you can change the value of NUM_STATIONS in the GVL file. There’s advantages and disadvantages to having your stations in an array. The advantages are that they’re all stored in one place, the name is consistent across various stations, and it’s easy to iterate through all the stations if needed. Additionally, adding stations between two existing stations is as easy as shifting the other stations in the array up an index. The disadvantage is that the station names are not going to be as descriptive as they could be if they were individually named. For this blog, we’re going to continue using the array of stations.

Configuring Stations

The existing starter project already has 5 stations configured, shown below:

The position definition for these stations is in the MS_INTIIALIZING_OBJECTIVES section of the MAIN state machine, which is at line 109.

Station[0].Position := 5;
Station[1].Position := 750;
Station[2].Position := 1200;
Station[3].Position := 1300;
Station[4].Position := 1400;

Station[0].Position := 5;
Station[1].Position := 750;
Station[2].Position := 1200;
Station[3].Position := 1300;
Station[4].Position := 1400;

We can see that the stations are given positions (in mm) around the track that line up with the picture above. Changing these positions will change where along the track the stations exist.

We also need to make sure to call the CyclicLogic method of the station object. This is already done for us in line 414.

FOR i := 0 TO GVL.NUM_STATIONS - 1 DO
  Station[i].Cyclic();
END_FOR

FOR i := 0 TO GVL.NUM_STATIONS - 1 DO
  Station[i].Cyclic();
END_FOR

One other thing these stations are already configured to do is to unregister movers on stopping or disabling. This will make sure that no movers are “trapped” at stations when the system starts back up. This is done in lines 327 and 362 by calling the UnregisterAll method for each station.

FOR i := 0 TO GVL.NUM_STATIONS - 1 DO
  Station[i].UnregisterAll();
END_FOR

FOR i := 0 TO GVL.NUM_STATIONS - 1 DO
  Station[i].UnregisterAll();
END_FOR

Station Logic

The existing starter project already has some stations logic. The logic for these stations is in the MS_RUN section of the MAIN state machine, which starts at line 212. There’s a couple methods and properties about the station objects that are useful to describe to interpret this code.

MoverInPosition

MoverInPosition is a property of the station object. This property is true if a mover has arrived at the station. This is important to check before trying to do anything with a station’s mover because if there is no mover in the station, the code will try to command an invalid mover reference.

CurrentMover

CurrentMover is a property of the station object. This property is a reference to the mover that is currently at the station. This allows commands to the movers to go through the stations so logic can be configured on a station level rather than on a mover level.

With these methods and properties, we can better understand what the existing stations are doing.

// Station 0 Logic
IF Station[0].MoverInPosition THEN
  StationTimer[0](IN := TRUE, PT := T#1000MS);
  IF StationTimer[0].Q THEN
    Station[0].CurrentMover.SetVelocity(mediumVelocity);
    Station[0].CurrentMover.MoveToStation(Station[1]);
  END_IF
ELSE
  StationTimer[0](IN := FALSE);
END_IF

// Station 0 Logic
IF Station[0].MoverInPosition THEN
  StationTimer[0](IN := TRUE, PT := T#1000MS);
  IF StationTimer[0].Q THEN
    Station[0].CurrentMover.SetVelocity(mediumVelocity);
    Station[0].CurrentMover.MoveToStation(Station[1]);
  END_IF
ELSE
  StationTimer[0](IN := FALSE);
END_IF

Station 0 is straightforward. Once a mover arrives, the logic waits for 1 second before setting the velocity to medium velocity and sending the mover to station 1.

// Station 1 Logic
IF Station[1].MoverInPosition THEN
  StationTimer[1](IN := TRUE, PT := T#250MS);
  IF StationTimer[1].Q THEN
    Station[1].CurrentMover.SetVelocity(mediumVelocity);
    Station[1].CurrentMover.MoveToStation(Station[nextStation]);
    nextStation := nextStation - 1;
    IF nextStation = 1 THEN
      nextStation := 4;
    END_IF
  END_IF
ELSE
  StationTimer[1](IN := FALSE);
END_IF

// Station 1 Logic
IF Station[1].MoverInPosition THEN
  StationTimer[1](IN := TRUE, PT := T#250MS);
  IF StationTimer[1].Q THEN
    Station[1].CurrentMover.SetVelocity(mediumVelocity);
    Station[1].CurrentMover.MoveToStation(Station[nextStation]);
    nextStation := nextStation - 1;
    IF nextStation = 1 THEN
      nextStation := 4;
    END_IF
  END_IF
ELSE
  StationTimer[1](IN := FALSE);
END_IF

Station 1 has some similar logic. It only waits for 250 milliseconds and then rotates through sending to station 4, then station 3, then station 2, then back to station 4. This is a great example of how you can use the XTS system to multi-task with processes that have higher cycle times.

// Group of Stations 2, 3, and 4 Logic
IF Station[2].MoverInPosition AND Station[3].MoverInPosition AND Station[4].MoverInPosition THEN
  StationTimer[2](IN := TRUE, PT := T#750MS);
  IF StationTimer[2].Q THEN
    StationTimer[2](IN := FALSE);

    Station[2].CurrentMover.MoveVelocity(500);
    Station[3].CurrentMover.MoveVelocity(500);
    Station[4].CurrentMover.MoveVelocity(500);
  END_IF
END_IF

// Group of Stations 2, 3, and 4 Logic
IF Station[2].MoverInPosition AND Station[3].MoverInPosition AND Station[4].MoverInPosition THEN
  StationTimer[2](IN := TRUE, PT := T#750MS);
  IF StationTimer[2].Q THEN
    StationTimer[2](IN := FALSE);

    Station[2].CurrentMover.MoveVelocity(500);
    Station[3].CurrentMover.MoveVelocity(500);
    Station[4].CurrentMover.MoveVelocity(500);
  END_IF
END_IF

Stations 2 through 4 have their logic combined since they’re intended to be parallel processes. Once a mover has arrived in each of the three stations, the logic waits for 750 milliseconds before commanding all three movers to move at 500mm/s.

If we’re commanding these movers to move at 500mm/s until they receive another command, how will they ever stop? The first answer is that they have collision avoidance, so the movers will stop if they would run into a mover ahead of them. The second answer is that we have position triggers further along the track to give them new commands. In the next blog in this series, we will go over position triggers.

If you’d like help with the next steps for your XTS system, DMC is proud to be a Beckhoff System Integrator and has worked on multiple XTS projects and applications.

The post Beckhoff XTS Part 5: Stations appeared first on DMC, Inc..

This blog will go over the Beckhoff XTS mover blocks that comes with the base starter project. We will see how to configure the movers properly and what methods we have at our disposal to use with our system. This blog will continue to use the Beckhoff XTS_Base GitHub and the large XTS starter kit. 

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 2 – Setting Up a Physical XTS System
• Part 3 – Simulation and PLC Logic
• Part 5 – Stations
• Part 6 – Position Triggers
• Part 7 – Customizing Logic

Movers

Movers are the software representation of the physical XTS movers. The mover object built into the base project is a great starting point since it comes with a lot of useful methods for controlling the mover behavior. 

Declaring Movers

In the previous entry in this blog series, we made sure to update the number of movers to match the physical movers in our system. In the MAIN program, we can see that the movers are declared with the line.

Mover : ARRAY[0..GVL.NUM_MOVERS - 1] OF Mover;

Mover : ARRAY[0..GVL.NUM_MOVERS - 1] OF Mover;

As mentioned in the previous section, this NUM_MOVERS should be exactly equal to the number of physical movers in the XTS system. Additionally, the axis references of these mover objects should be linked to the motion axes. If you haven’t already done that see this section. 

Configuring Movers

Like most drives, the movers need to have a set of parameters and to go through an enable process before they can run. The base project already does both things for us. In the MAIN program the code starting at line 52 is where the parameter set is applied to all of the movers configured in our system. 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].MotionParameters := ParameterSet;
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].MotionParameters := ParameterSet;
END_FOR

The lines starting at line 46 define the parameter set, which includes acceleration, deceleration, jerk, velocity, and direction. 

ParameterSet.Jerk     := 1E5; // mm/s3
ParameterSet.Acceleration := 1E4; // mm/s2
ParameterSet.Deceleration := 1E4; // mm/s2
ParameterSet.Velocity   := 1E3; // mm/s
ParameterSet.Direction   := mcDirectionPositive;

ParameterSet.Jerk     := 1E5; // mm/s3
ParameterSet.Acceleration := 1E4; // mm/s2
ParameterSet.Deceleration := 1E4; // mm/s2
ParameterSet.Velocity   := 1E3; // mm/s
ParameterSet.Direction   := mcDirectionPositive;

Line 72 is where the movers are enabled 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Enable();
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Enable();
END_FOR

and a few lines down in line 87 is where their Ready property is checked to see if they got enabled properly. 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  IF Mover[i].Ready = FALSE THEN
    allMoversEnabled := FALSE;
  END_IF
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  IF Mover[i].Ready = FALSE THEN
    allMoversEnabled := FALSE;
  END_IF
END_FOR

Additionally, the movers must be assigned to a track. This happens starting at line 144 by calling ActivateTrack and passing in the track the mover is to be assigned to. 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].ActivateTrack(Track[1]);
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].ActivateTrack(Track[1]);
END_FOR

For the basic starter project, all movers are assigned to track 1. If your application has multiple tracks, this is where you can specify which movers belong to which track. A few lines down at line 153 is where the logic checks the mover’s IsTrackReady property to make sure they’re properly assigned to their track. 

allMoverTracksEnabled := TRUE;
FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  IF (NOT Mover[i].IsTrackReady) THEN
    allMoverTracksEnabled := FALSE;
  END_IF;
END_FOR

allMoverTracksEnabled := TRUE;
FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  IF (NOT Mover[i].IsTrackReady) THEN
    allMoverTracksEnabled := FALSE;
  END_IF;
END_FOR

To stop the movers, the logic will need to call the Halt method. This is already implemented in line 286 of the base starter project. 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Halt();
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Halt();
END_FOR

Once the movers are stopped, they can be disabled using the Disable method. Again, this is already implemented in line 348. 

FOR i := 0 TO GVL.NUM_MOVERS DO
  Mover[i].Disable();
END_FOR

FOR i := 0 TO GVL.NUM_MOVERS DO
  Mover[i].Disable();
END_FOR

It’s worth noting that if you have a vertically mounted track, disabling the movers will often let them succumb to gravity. It could be worth implementing something that gets the movers off the curved sections before disabling them. 

Many of these XTS library objects have methods named Cyclic or CyclicLogic that need to be called every scan in order to function properly, so check those are getting called correctly if any issues come up. For our movers, this happens at line 408. 

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Cyclic(GroupRef);
  Mover[i].AxisReference.ReadStatus();
END_FOR;

FOR i := 0 TO GVL.NUM_MOVERS - 1 DO
  Mover[i].Cyclic(GroupRef);
  Mover[i].AxisReference.ReadStatus();
END_FOR;

The logic also calls the ReadStatus method of the mover’s internal axis reference to ensure the status values are up to date. 

Now we’ve gone over a lot of the configuration that these movers need. We can enable them, assign a parameter set to them, assign them to tracks, stop them and disable them. We’re also calling the Cyclic method that ensures our commands get processed properly. Now it’s time for the fun part, getting the movers to move around the track. 

Mover Logic

The mover objects come with four main methods that will help control their movement throughout the track. Here’s a quick description of each of the methods. 

SetVelocity

SetVelocity is a method of the mover object. It will immediately change the velocity of the mover to the commanded velocity (in mm/s).

MoveVelocity

MoveVelocity is a method of the mover object. It will command a mover to run at the commanded velocity (in mm/s) until it receives another command.

MoveToStation

MoveToStation is a method of the mover object. It will command a mover to go to the commanded station. Note that there’s no velocity input for this method, so the mover will go at its existing velocity, which was likely last given by SetVelocity or MoveVelocity. The mover will stop once it reaches the commanded station.

MoveToPosition

MoveToPosition is a method of the mover object. It will command a mover to go to the inputted position (in mm). Similar to MoveToStation, there is no velocity input so this will use the mover’s existing velocity.

The MoveToStation function is particularly useful, but first we have to understand what a station is. We will go over stations in the next entry in this blog series.

If you’d like help with the next steps for your XTS system, DMC is proud to be a Beckhoff System Integrator and has worked on multiple XTS projects and applications.

The post Beckhoff XTS Part 4: Movers appeared first on DMC, Inc..

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 2 – Setting Up a Physical XTS System
• Part 4 – Movers
• Part 5 – Stations
• Part 6 – Position Triggers
• Part 7 – Customizing Logic

Setting Up an XTS Simulation 

Start the XTS Simulator 

XTS has a built-in simulator that you can start through the XTS simulation builder. This is the gear icon with a blue arrow. 

Start the XTS Simulation Builder

This starts the XTS simulation builder. You can select from a few template projects, but modifying the base project will give you the most control over the XTS system being set up. To do this, click the pencil next to modify base project. 

Configure XTS Modules

The first tab of the simulation builder is to configure the modules. Here you can add XTS track modules to build your track. In the top bar, you can select from the catalog of XTS modules and hovering over each module will give you the part number. To add a module, either select the module and click the add module plus button or double click on the module. 

The last four digits of each module’s part number represent its length in millimeters. There are some modules that look the same but have different lengths, so be sure to select the correct length of each part for your application. Below is a simulation track for the XTS larger starter kit. It uses two AT2002-0250, 2 AT2050-0250, and 10 AT2000-0250 modules to form a 4m loop. 

Configure XTS Movers 

Next, navigate to the Movers tab. 

Here you can add movers to the XTS track. Similar to the modules, at the top you can select which mover from the Beckhoff XTS catalog you’d like to add to the track. To add a mover, select the type and then click the add mover plus button. Below are the simulation movers for the XTS large starter kit. It uses 10 AT9014-0070 movers. 

Configure Parts, Tracks, and Stations 

For this example, we’re not going to be using any parts, tracks, or stations. Here’s a quick rundown of what each of them are with links to the Beckhoff documentation for more detail. 

• Parts – Groupings of modules. Since our large starter kit is a loop, we only have the one part which was added by default. 
• Tracks – A route that can be used by movers that is made up of one or multiple parts. Since our large starter kit is a loop with only one part, we also only use the single default track. 
• Stations – A station in this configurator is still in the beta phase and is currently purely cosmetic. Stations will display in the XTS tool window, but the movers cannot use these stations in their logic. We will set up stations in the PLC logic later, so we don’t have to set any up here. 

Configure XTS Real-Time Settings 

Lastly, we need to set the real-time settings for the XTS system. This is functionally the same as going to SYSTEM > Real-Time, but it’s conveniently here in the configurator as well. First, navigate to the System tab and click the download button to sync the number of cores on your target to the configurator. 

Say “yes” to the popup that asks if you want to overwrite the current CPU config. 

The XTS Task 1 has to be configured onto an isolated CPU by itself with a 250μs base time and 1 cycle tick. Isolated cores are represented by an orange rectangle on the right side of the core. You can select which cores are being used with the checkbox on the left side and move tasks around using the up and down arrows on each task. The remaining tasks on the system can be set up to fit your system’s needs, but the XTS Task 1 should be configured like the image below. 

If you’re simulating on your engineering computer, keep in mind that all tasks must be on isolated cores, not just the XTS Task 1. The image above has all tasks on isolated cores for this reason. 

Finish the XTS Simulation Builder 

Click the next button a couple times and the XTS simulation builder should process the information to add the XTS system to your solution. This may take a few minutes, but afterwards the simulation builder should close. To start sending movers around the track, go to step 5. 

Adding Logic to the XTS System 

This section assumes that you’re using the XTS_Base code provided on Beckhoff’s GitHub. It’s highly recommended to use this since it provides well-tested code for commonly used XTS tools like movers, stations, zones, position triggers, etc. 

Check IdDetectionMode 

Under SYSTEM > TcCOM Object > XTS ProcessingUnit 1, go to the Parameter (Init) tab. Under the section for Mover ID Detection, we will want to set IdDetectionMode to the correct detection mode for our system. 

If you’re simulating an XTS system, the IdDetectionMode should be set to Standard. If you’re working with a physical XTS system, then it depends on your movers. Some movers are identified with mover 1 magnet plates. If you have no mover 1 magnet plates, set IdDetectionMode to Standard. With one mover 1 magnet plate, set the IdDetectionMode to Mover1. With multiple mover 1 magnet plates, set the IdDetectionMode to MultipleMover1. 

Setting the GVL Parameters

Under the Main Project, open GVLs > GVL. In this global variable list, you’ll need to set the following variables 

• NUM_MOVERS – This should be the number of movers in your XTS system. In our case, 10. 
• NUM_STATIONS – This should be set to a number greater than or equal to the number of stations you’ll add to your system. In our case, we will keep it at 10. 
• TRACK_LENGTH – This should be the length of the track in your XTS system in millimeters. In our case, 4000mm. If you don’t know the track length, you can find it under SYSTEM > TcCOM Object > XTS ProcessingUnit 1 > Track 1 in the Parameter (Online) tab. The Length parameter should show an online value which should be entered for TRACK_LENGTH. 
• NUM_TRACKS – This should be set to the number of tracks in your system. In our case, 1. 

Update the Track OTCID in MAIN 

In the MAIN program inside the POUs folder, on line 138 there is an assignment to Track[1].OTCID. This will likely need to be changed. 

You can find your track’s OTCID under SYSTEM > TcCOM Objects > XTS ProcessingUnit 1 > Track 1 in the Object tab. 

You can then copy this value and assign it to Track[1].OTCID in MAIN. Make sure to change the “0x” prefix to a “16#” to match structured text formatting for hexadecimal numbers. 

Link the Mover Axes 

Rebuild the solution first by going to the top toolbar and selecting Build > Rebuild Solution. This makes sure that our change to NUM_MOVERS regenerated the correct number of AXIS_REFs to link to. After rebuilding, go to MOTION > NC SAF > Axes and you’ll see a list of axes that are in our solution. They should already be linked to their I/O components, which should be Mover Controllers. The next step is to link them to their PLC AXIS_REFs. Select all the axes using Shift + Click, then right click to select Change Axis PLC Links. 

You should see the mover axis references show up. Click each reference to link all the movers to their NC axes. The linking should look like the image below afterwards. 

Run the Program 

We can now activate our configuration. Do this by clicking the icon shown below. 

Click OK in the next popup. 

If you haven’t already purchased licenses from Beckhoff, you’ll likely get a popup asking if you want to activate trial licenses. Click yes and follow the steps to get a free 7-day trial license. Once you deploy the code onto a production machine, make sure to get a license from your local Beckhoff sales representative. 

After activating configuration, the target device should switch into run mode, which is indicated by the green gear icon next to the activate configuration button being highlighted instead of the blue one. Once in run mode, we can enable and start the movers. 

Start the Movers 

The solution we pulled from the Beckhoff GitHub already has a simple HMI to get the movers started. Let’s log in by clicking the green door with the arrow pointing towards it. 

After logging in, open the visualization under Main Project > VISUs > Controls.

This provides four buttons for interacting with the XTS system. 

• Enable – Will run the enable sequence for the movers, which initializes their order and assigns movers to tracks. 
• Start – Once the movers are enabled, this will start running the station logic for the movers, 
• Stop – This will stop the movers but will keep them enabled. 
• Disable – This will remove the movers from their tracks, which allows for errors to be reset. If your track is mounted vertically, it’s worth noting that this will depower the movers and they will succumb to gravity. 

Click the enable button. Then click the start button. If you have a physical XTS system, you should see the movers start to move. Both physical and simulation systems can take advantage of the XTS tool window to see a live view of the track. 

Live Monitor the XTS Track 

Go back to the XTS tool window. You should be able to click the live view button to see the current state of the movers on the XTS track. 

At this point, you should see the movers going around the track according to the station logic that was already in the code we downloaded from Beckhoff’s GitHub. 

This should help get your physical or simulated XTS system moving. However, all XTS systems are different and this default station logic likely isn’t going to work for your application. Next time, we will explore how to set up stations, position triggers, zones, and other things that can help customize the XTS system further.

The post Beckhoff XTS Part 3 – Simulation and PLC Logic appeared first on DMC, Inc..

Note: This blog and all its images are from TwinCAT XAE build 3.1.4024.62. Since XTS is one of Beckhoff’s newer offerings, they are consistently providing more features so some aspects may look different in newer versions, especially in builds 3.1.4026.XX and beyond. As a reminder, this blog series is utilizing the XTS_Base code provided on Beckhoff’s GitHub. 

Beckhoff XTS Series

• Part 1 – Downloads and Starter Project
• Part 3 – Simulation and PLC Logic
• Part 4 – Movers
• Part 5 – Stations
• Part 6 – Position Triggers
• Part 7 – Customizing Logic

Setting Up a Physical XTS System 

This blog will be using the large XTS starter kit, though the steps should be similar for any XTS track and mover configuration. 

Scan in IO 

Before we can set up the XTS system, we have to bring the XTS hardware into the TwinCAT solution. To do this, go down to I/O, right click on Devices, and select Scan. If you’re not able to scan, it’s likely your target is in run mode. You’ll have to switch it into config mode by clicking the blue icon with the gear in it before scanning devices in. 

If you get a popup saying that not all types of devices can be found automatically, click OK. The XTS tracks and movers should be found automatically. Select Yes for both the scan for boxes and the activate free run popups.

If the hardware is connected to the PLC correctly and powered on, you will see a popup similar to the one below. Make sure to select the RT-Ethernet Adapter and the EtherCAT devices. In the image below its devices 4, 9, 10, and 11.

After clicking OK, the software will take some time to scan in the hardware. After it scans, you should see all the devices you have connected to the PLC appear in the IO tree. For example, the large XTS starter kit IO looks like the image below.

Note: the movers are not included in the IO tree. That will come later.

Start the XTS Configurator

Go back to the XTS tool window and start the XTS configurator. This is the gear icon with a green arrow.

Configure XTS Parts

You’ll be presented with a popup for the XTS configurator. Click past the first screen to get to the screen for configuring parts. You’ll see a warning towards the bottom that says no modules have been added yet. Right above that, click the plus button to add some modules.

After clicking the plus button, you should see the devices with XTS parts available for selection. The image below is what the large XTS starter kit scans in as. Select all the devices by using Shift+Click and click OK. 

After clicking OK, the modules should be displayed in the bottom left where the “no modules” warning used to be. These can be adjusted relative to each other by selecting a module and using the up/down arrows to adjust its relative location. Note that the track shape is displayed in the main window to help orient the track to its physical setup. Once you’re done adding parts, select the right arrow in the bottom right corner.

Configure XTS Tracks

See Beckhoff’s information page on XTS tracks for a complete definition. Generally, tracks are groupings of XTS parts that have minimal or no overlap in movers and/or parts. The large XTS starter kit has only one track and it is a loop, so we will check the box for is closed. 

If your system has multiple tracks, you can add them through the plus button in the top bar and configure each individually by selecting each track under the XTS ProcessingUnit and adding the parts that are associated with that track. Click to the next section of the configurator once you’re done configuring tracks.

Configure XTS Stations

XTS stations in this configurator are still in the beta phase and are currently purely cosmetic. They will display in the XTS tool window, but the movers cannot use these stations in their logic. If you want to set up cosmetic stations, you can add them with the plus button in the top bar. These can be useful for visualizing your XTS stations but can often be misleading since they’re not directly tied to mover logic. In this example, we won’t use these cosmetic stations, but feel free to add them if it’s useful in your application.

Click to the next section of the configurator once you’re done configuring stations.

Configuring XTS Movers

Before adding any movers, make sure to select the mover type and magnet plate type that you’re using in your application. If needed, you can reference the Beckhoff XTS catalog to verify which mover type you have.

Once the mover type and magnet plate type are selected, click the plus button until you have added the same number of movers as the physical system. In the large XTS starter kit, we have 10 AT9011_0070 movers with magnet plates AT9001_0550, so that’s what the image below shows.

Click to the next section of the configurator once you’re done configuring movers.

Configuring Control Areas

Control areas can be defined to allow different parameter sets to be used for different track segments. For example, if our XTS starter kit was mounted vertically, we might want different PID control for the movers while they’re sliding with/against gravity. For this example, we will not set up any control areas. Click to the next section of the configurator once you’re done configuring control areas.

Configuring XTS Real-Time Settings

Lastly, we need to set the real-time settings for the XTS system. This is functionally the same as going to SYSTEM > Real-Time, but it’s conveniently here in the configurator as well. First, navigate to the System tab and click the download button to sync the number of cores on your target to the configurator.

Say yes to the popup that asks if you want to overwrite the current CPU config.

The XTS Task 1 has to be configured onto an isolated CPU by itself with a 250μs base time and 1 cycle tick. Isolated cores are represented by an orange rectangle on the right side of the core. You can select which cores are being used with the checkbox on the left side and move tasks around using the up and down arrows on each task. The remaining tasks on the system can be set up to fit your system’s needs, but the XTS Task 1 should be configured like the image below.

Finish the XTS Configurator

Click the next button a couple times and the XTS configurator should process the information to add the XTS system to your solution. This may take a few minutes, but afterwards the configurator should close.

Our physical XTS system has now been set up. The next blog in this series will go over how to set up a simulated version of your XTS system and how to update the PLC logic to start sending movers around the track.

Beckhoff XTS Series

Part 1 – Downloads and Starter Project
Part 3 – Simulation and PLC Logic

The post Beckhoff XTS Part 2 – Setting Up a Physical XTS System appeared first on DMC, Inc..

Beckhoff XTS Series

• Part 2 – Setting Up a Physical XTS System
• Part 3 – Simulation and PLC Logic
• Part 4 – Movers
• Part 5 – Stations
• Part 6 – Position Triggers
• Part 7 – Customizing Logic

Table of Contents

Why Beckhoff XTS?
Download and Installation
  Download
  Installation
Setting Up Base Project
  Open the XTS Tool Window
  Clear Out the Existing XTS System

Why Beckhoff XTS?

The eXtended Transport System (XTS) is Beckhoff’s linear product transport solution. Linear transport systems allow for smart product transportation. Since products are on individual movers, it allows for easy diverting of rejected products or parallelization of duplicated stations to reduce cycle time. Since the movers can be programmed to stop at stations, this allows for parts to be manipulated directly on the movers, which can greatly reduce the amount of time it takes to move products from station to station. Additionally, a linear transport system often reduces the footprint on the factory floor as compared to traditional conveyor belt solutions. 

XTS is unique from other linear transport systems because it utilizes the EtherCAT framework and TwinCAT Motion libraries to produce a plug-and-play solution for many applications. There’s also a wide variety of options to customize your XTS system from no-cable technology (NCT) allowing you to power electronics on each individual mover to hygienic solutions that are IP69K rated.  

Beckhoff XTS can be the right solution for a wide variety of applications, and this blog series on getting started with XTS is going to help give you the tools to effectively utilize this innovative technology. We’ll start with installing the right packages and setting up a base project today. 

Download and Installation

Download

First, download TF5850 and TF5410 from the Beckhoff website. The installers are located in Documentation and Downloads > Software and Tools. 

Installation

Once downloaded, you will need to run the two .EXE files on both the engineering computer and on the PLC. To download onto the PLC, the simplest way is to move the .EXE files onto a USB and plug this into the PLC. Once the USB is plugged in, you can either remote into the PLC (Remote Desktop Connection) or connect a monitor and mouse using any of the outputs on the PLC. Once connected, run the .EXE files on the PLC and install the software.

Note: You will have to restart the engineering computer and PLC after running the installers, so make sure the PLC’s system is in a state to do so.

Open TwinCAT XAE

Once installation is complete, open TwinCAT XAE. This blog will use the XTS_Base code provided on Beckhoff’s GitHub since it provides a lot of reusable code to interact with movers and set up stations. Downloading this project will give a great starting point for the rest of this blog series, but you should be able to follow along in your own TwinCAT solution if desired. If you haven’t already installed TwinCAT XAE or configured your Beckhoff IPC yet, check out our setup blog on how to get started and then come back to step 3.

Setting Up Base Project

Open the XTS Tool Window

In the top bar of the XAE solution, go to TwinCAT > XTS > XTS Tool Window to open the XTS tool window.

This is where we can configure our XTS track, movers, and ultimately go online to monitor the XTS system. The XTS_Base project this blog starts with already has an XTS track configured. Let’s clear out that track so we can set it up ourselves. 

Clear Out the Existing XTS System

There are three main places where XTS components are stored. They are SYSTEM > TcCOM Objects, MOTION > NC SAF > Axes, and I/O > Devices. This blog series will go into more detail about each of these sections later on, but for now we will want to clear out everything under these sections to remove the existing XTS system. Namely, remove XtsProcessingUnit 1, Mover Axis 1-6, and Device 1 and Device 3. We also need to remove SYSTEM > Tasks > XTS Task 1.

Once all those objects have been removed, go back to the XTS tool window and click the refresh button. The XTS track and movers should disappear.

With that, the downloads and starter project are set up for our XTS project. We are now ready to set up our own XTS system. The next blog in this series will go over how to set up a physical XTS system.

The post Beckhoff XTS Part 1 – Downloads and Starter Project appeared first on DMC, Inc..

1. Download and Installation
2. Adding the Database Project to a TwinCAT 3 Solutions
3. Writing Code to Write to the Database Server
4. Testing the Database Connection

Being able to store long term data is one of the most crucial parts of a manufacturing or testing environment. Having access to this data can allow a team to track long term trends of their systems. For instance, one team could track the uptimes of the various production lines to find where the bottlenecks in the process flow are. Another team could use their motor’s speed data to track when it needs maintenance.

Beckhoff TwinCAT 3 offers the ability to run a database server directly on the IPC using their TF6420 module. This module allows you to send data up to most types of databases, though this blog will provide specific examples by using a PostgreSQL database since it is free to use, open source, and uses structured query language (SQL).

1. Download and Installation

1.1. Download

First, Download TF6420 from the Beckhoff website. The installer is located in Documentation and Downloads > Software and Tools.

1.2. Installation

Once downloaded you will need to run the .EXE on both the engineering computer and on the PLC. To download onto the PLC, the simplest way is to move the .EXE onto a USB and plug this into the PLC. Once the USB is plugged in, you can either remote into the PLC (Remote Desktop Connection) or connect a monitor and mouse using any of the outputs on the PLC. Once connected, run the .EXE on the PLC and install the software.

1.3. Open TwinCAT XAE

Once the installer is complete, open the TwinCAT XAE solution in which the database connection should be installed. If you haven’t already installed TwinCAT XAE or configured your Beckhoff IPC yet, check out our setup blog on how to get started and then come back to step 2.

2. Adding the Database Project to a TwinCAT 3 Solution

2.1. Add New Database Server Project

Within the project, right-click on the project solution -> Add -> New Project

In the window that opens, select TwinCAT Connectivity and then choose “Empty TwinCAT Database Server Project”

2.2. Add and Configure the Database

Once the new project is added, there should be a default TcDbServer already added under the project. There is currently no database in the project, but this can be done by right-clicking TcDbServer -> Add New Database

You will then see a new DB server appear under TcDbServer. The server can be configured by double-clicking the DB. This will bring up the configuration window. Currently the window is empty, but this can be fixed by selecting the database type pictured below. For this example, a PostgreSQL database will be used.

Once the database type is selected, the settings will appear and can be configured there. For PostgreSQL, the first few settings are Host, Database, and Port. The next option is Authentication which contains a drop down with different kinds of authentication. The example below is going to use Username/Password.

Note: The password used here is encrypted and is not stored in plain text anywhere on the PLC

2.3. Set Target AMS Net ID

Once all the information is added, the connection is not quite ready to be tested. The AMS Net ID must be set up first. To do this, go back to TcDbServer and double click the tab. Once the server settings window is open, there is a dropdown menu in the top left where all the options for Ams Net Ids appear.

For testing on a local machine select <Local>.

If this is running on a PLC and you are connected to the PLC, the name of the PLC will be on this menu and you can choose that instead.

2.4. TF6420 License

Before checking the connection to the server, the TF6420 license must be activated. For now, a trial license can be generated. First start by going to the Manage License tab at the top of the window that has opened. Next scroll all the way down to TF6420 TC3 Database Server and check the box next to it that says cpu license.

After this box is checked, go back to the main license screen and into the Order Information (Runtime) tab. Once here go down to the 7 Days Trial License and click on that. A small screen will then appear in which you will type a short captcha. Once this is typed, hit Ok and the license will be generated.

2.5. Activate Database Configuration

Next, activate the configuration of the database connection by right-clicking the DB and selecting Activate Configuration.

(Optional) The database server toolbar is optional, but will be beneficial moving forward. At the top of the screen on the task bar, right-click and select TwinCAT Database Server. This will add a new set of tools at the top that can be used with the databases (one of them being activate configuration).

Here is what the toolbar will look like when added:

2.6. Check Database Connection

After activating configuration, check this connection by going back to the DB page. At the bottom, there will be 2 options, CREATE and CHECK. Select CHECK.

If everything went well, you should see a pop up that says the check succeeded. If not, verify all database information is correct and go back to step 8.

2.7. Add Database to Configuration Pool

Once the database is configured, it needs to be added to the DB configuration pool. This can be done by right-clicking on the DB and hitting the Add to DB Configuration Pool tab.

3. Writing Code to Write to the Database Server

3.1. Installing Reference Libraries

Once added to the DB Configuration Pool, there are a few basic functions to test the connection and write a few queries. In order to use these, we will need to install 2 additional libraries. To do this, go to the PLC project that the database will be called in. Then go to the references tab in the project tree pictured below. Right-click this and then select Add library.

This will open a library window where the 2 libraries needed for database are located. Tc3_Database and Tc3_EventLogger.

3.2. Example Code

We can now use the built-in TwinCAT functions to send a basic SQL command. Again, for this example we’re using PostgreSQL functions and syntax. Under POUs, open MAIN and put the following code in the variable declaration section:

VAR 
    nStep, nNextStep : INT; 
    sQuery : STRING; 
    fbDatabase : FB_SQLDatabaseEvt(sNetID := '', tTimeout := T#5S); 
    fbSqlCommand : FB_SQLCommandEvt(sNetID := '', tTimeout := T#5S); 
    tcMessage : I_TcMessage;  
END_VAR

VAR 
    nStep, nNextStep : INT; 
    sQuery : STRING; 
    fbDatabase : FB_SQLDatabaseEvt(sNetID := '', tTimeout := T#5S); 
    fbSqlCommand : FB_SQLCommandEvt(sNetID := '', tTimeout := T#5S); 
    tcMessage : I_TcMessage;  
END_VAR

Here is a brief explanation of each variable:

• nStep and nNextStep are used to drive a state machine.
• sQuery is the raw string for the query we want to send to the database
• FB_SQLDatabaseEvt is responsible for connecting, disconnecting and overall communication with the database.
• FB_SQLCommandEvt is responsible for generating a SQL command to be sent via the FB_SQLDatabaseEvt. Note: A standard STRING will not work if being sent through FB_SQLDatabaseEvt, even if the syntax is correct.
• I_TcMessage will store any messages sent back from the database server. This will be helpful for identifying errors if there are any.

In the code execution section of MAIN, add the following basic state machine:

//Generate the query string.
//Change TableName to your table's name.
//Change column1 and column2 to the column names (include any other columns your table has, separated by ,).
//Change $'value1$' and $'value2$' to the values you wish to send.
//Note: $ is an escape character for a single quote. Single quotes indicate a string.

sQuery := 'INSERT INTO TableName (column1, column2) values ($'value1$', $'value2$')';

CASE nStep OF
    0:
        //Connect to the database at database ID 1
        IF fbDatabase.Connect(1) THEN
            nNextStep := 10;
        END_IF
    10:
        //Move the database message result to tcMessage
        tcMessage := fbDatabase.ipTcResult;
        //Go to disconnect step if there's an error
        IF fbDatabase.bError THEN
            nNextStep := 99;
        END_IF
        //Create a SQL command
        IF fbDatabase.CreateCmd(ADR(fbSqlCommand)) THEN
            nNextStep := 20;
        END_IF
    20:
        //Execute the SQL command of sQuery
        IF fbSQLCommand.Execute(ADR(sQuery), SIZEOF(sQuery)) >= 0 THEN
            tcMessage := fbSQLCommand.ipTcResult;
            nNextStep := 99;
        END_IF
    99:
        //Disconnect from the database
        IF fbDatabase.Disconnect() THEN
            nNextStep := 0;
        END_IF
END_CASE
 
//Advance the state machine step
nStep := nNextStep;

//Generate the query string.
//Change TableName to your table's name.
//Change column1 and column2 to the column names (include any other columns your table has, separated by ,).
//Change $'value1$' and $'value2$' to the values you wish to send.
//Note: $ is an escape character for a single quote. Single quotes indicate a string.

sQuery := 'INSERT INTO TableName (column1, column2) values ($'value1$', $'value2$')';

CASE nStep OF
    0:
        //Connect to the database at database ID 1
        IF fbDatabase.Connect(1) THEN
            nNextStep := 10;
        END_IF
    10:
        //Move the database message result to tcMessage
        tcMessage := fbDatabase.ipTcResult;
        //Go to disconnect step if there's an error
        IF fbDatabase.bError THEN
            nNextStep := 99;
        END_IF
        //Create a SQL command
        IF fbDatabase.CreateCmd(ADR(fbSqlCommand)) THEN
            nNextStep := 20;
        END_IF
    20:
        //Execute the SQL command of sQuery
        IF fbSQLCommand.Execute(ADR(sQuery), SIZEOF(sQuery)) >= 0 THEN
            tcMessage := fbSQLCommand.ipTcResult;
            nNextStep := 99;
        END_IF
    99:
        //Disconnect from the database
        IF fbDatabase.Disconnect() THEN
            nNextStep := 0;
        END_IF
END_CASE
 
//Advance the state machine step
nStep := nNextStep;

The state machine will do the following:

• Connect to the database with database ID 1. If you have multiple databases, you can change the database ID input to point to a specific database. You can find this ID by going back to the database configuration page (where you typed in the IP address, port number, etc.) and checking what the DBID is in the top left corner.
• Create the SQL command.
• Execute the SQL command according to sQuery
• Disconnect from the database

You can activate the configuration for the PLC project to start sending queries to the database!

4. Testing the Database Connection

4.1. Open TF6420 Configurator

After activating the configuration, the state machine should be looping through and inserting data into our table. We can check this by opening up the TF6420 Configurator application.

The database server and configuration should already be added from our steps to install the database server. If not, refer to the Adding the Database Project to a TwinCAT 3 Solution section.

4.2. Execute a SQL Select Query

Open the SQL Query Editor.

You should see a list of the SQL databases available from the DB configuration pool. You can click the refresh button if there are no databases currently connected. If that doesn’t work, make sure you’ve gone through the above steps and the configuration is activated.

Drop down the database to see all the available tables. You can right click on the table you’re writing to and click Select.

You can see that TF6420 has auto-generated a select statement for you. If you press the FB_SQLCommandEvt.ExecuteDataReturn button, you should see datasets populate in the results field to the right.

If these are the values you’re sending to the database then the database server is communicating properly!

For more information on some of the topics covered in this blog, please see the following:

• TF6420 Database Server Infosys Page
• SQL Expert Mode Function Block Infosys Page
• PostgreSQL Documentation
• Getting Started with a Beckhoff PLC

For information that was not discussed directly in this blog but could be good next steps, please see the following:

• MS SQL Stored Procedures Directly from Beckhoff TwinCAT PLC
• Getting Started with OPC UA in Beckhoff TwinCAT 3
• SQL Server Performance Troubleshooting
• NoSQL Expert mode Function Block Infosys Page

The post Getting Started with Database Server in Beckhoff TwinCAT 3 appeared first on DMC, Inc..