Informational Sessions and Hands-on Demonstrations

Elizabeth Hill Reed, one of the attendees, attended several info sessions to learn about Rockwell’s upcoming products, but she was most excited about their recent merger with Plex Systems.

“Rockwell acquired Plex Systems to add to their stack of integrations,” Reed said. “They’re focusing, not only on having an automation layer with the PLC and HMI, but focusing on industry 4.0 and interconnectivity with having a system that can store all the data, analyze it, and give you a feedback loop to improve the process. They have an out-of-the-box MES platform that can be quickly spun up and provide value to clients a lot sooner, so you can use Plex to try out concepts quickly and then scale it out.”

Reed believes that this merger will cause them to see more Plex Systems.

“I think we’ll start to see more Plex Systems out there. It was interesting to see what it’s been used for in the past,” Reed said. “I’m more excited for how it’s going to scale out with the merger with Rockwell.”

Keith Janson, another DMCer who attended the conference, focused more on Rockwell’s Distributed Control System (DCS), PlantPAX – something he’s excited to implement in future projects.

“Rockwell’s product piggybacks off their PLC infrastructure – which is fairly unique for the industry,” Janson said. “It leverages itself nicely in the market as being a lower barrier to entry, but, from DMC’s perspective, it’s a lower barrier for us to operate in that space and to leverage those assets Rockwell puts out there. PlantPAX is something DMC could leverage and is an active focus we’re trying to implement. I’m really looking to build and expand our competency with it.”

While they focused on different areas, what made both DMCers excited was Rockwell’s new Optix HMI; Janson and Reed got to get a sneak peek of the Optix software in a breakout session where Rockwell demonstrated the new functionality.

“Getting to see [Optix] firsthand and what they were doing was one of the most interesting things for me,” Janson said. “[Rockwell] is going to a web-based solution which is where the rest of the industry is going. We were probably some of the first hands-on experience with it.”

New Products and Technologies

Another highlight for Janson was learning more about containerized DCS solutions.

“Something Rockwell had in place for a while is this concept of containerizing these implementations. Currently, the options for download are non-customizable, so — while you can download a Batch server or PASS server — there’s still quite a bit of configuration to get it integrated and up and running. The goal for the future is to get to the point where you essentially ‘build’ these machines in a wizard and it spits out a tailor-made solution,” Janson said.

If he ever needs a batch server or an engineering workstation, Janson says she could essentially go to a Rockwell website and enter in the names and all the information to get one

“It spits out those virtual machines, I throw them into the hypervisor, and we’re off to the races.  It should be as close to plug-and-play as possible,” Janson said. “It’s not at that point now, but that’s the goal. That’s very exciting.”

Hello Orlando!

While DMCers attended the conference during the day, they took the opportunity at night to explore the area around Universal Studios, which wasn’t far from the conference.

“Keith and I went to dinner outside of the park every night,” Elizabeth said.

Meanwhile, Keith stayed an extra day to visit Universal Studios.

“I went to Universal’s Islands of Adventures,” Janson said. “I was excited to try Hagrid’s Wonderful Creatures Motorcycle ride. Highly recommend!”

Janson was greeted by this robot when exiting the elevator.

Learn about DMC’s Rockwell Automation expertise.

The post DMC Attended Rockwell’s ROKLive 2022 appeared first on DMC, Inc..

Our application had some lag when loading new screens because of the large amount of tags required to populate the screens. FTV SE can pull up to about 200 tags from a Micro 850 per second; with larger PLC programs taking more time to send tags.

For smaller HMI/PLC applications, all of the PLC tags from a Micro 850 can easily be pulled quickly while loading a screen. For larger applications, there may be some delay after opening a screen before all of the tags on a screen are loaded from the PLC and ready to populate their indicators.

However, FactoryTalk lets you load screens snappily, even when talking to smaller PLCs or when large amounts of data need to be loaded.

A few tips and tricks are below!

1. Decrease Maximum Tag Update Rate (per Screen) – This rate controls the shortest possible time it will take the FactoryTalk application to acquire or send a tag. This is important for buttons and indicators that need to have a fast response, as well as for loading screens quickly.
   1. To access this setting, right-click on a screen, select Display Settings, and under the Properties window, select the drop-down for Maximum Tag Update Rate. The default setting is 1 second; this may appear slow for most applications. A rate of 0.25 or 0.1 seconds will usually allow the screen to react without visible lag.
      
   2. This may have different levels of impact with different PLC platforms – this should be a good solution for fast performance with the Logix line of processors. We found that additional steps were needed with the smaller Micro800 line.
   3. Keep in mind that your application may not be able to keep up with faster Tag Update Rate setpoints. This is dependent on the number of tags you have on the screen and the number of tags that are being fetched in the background (read on to learn more about background fetching!)
2. Add Screen Caching – FactoryTalk View Site Edition's default behavior is to close any screens that aren't actively being displayed. This minimizes PC resource usage and allows you to edit screens in an active application (one of my favorite features). However, you can individually configure each screen to be cached, so that the screen is kept in memory even when it isn't shown on the screen. This greatly improves behavior for laggy screens.
   1. To access this setting, right-click on a screen, select Display Settings, and under the Properties window, choose Yes for Cache After Displaying.
   2. You also have the option to select whether the screen is Always Updating or not. Always Updating is a good selection for screens that don't populate immediately even when cached – we found this was the best choice for most of our larger screens with lots of tags. Keep in mind that if the screen is Always Updating, it will always be polling tags from the PLC. This may influence the update rate of tags on other screens in your application.
      
3. Add Screen Pre-Caching – If Screen Caching improved your application's performance, you may also want to consider Pre-Caching your screens! Pre-Caching pre-loads the screens while the application is starting up, without displaying them on the PC. Cached screens without pre-caching may still be slow to load the first time they're displayed; pre-caching makes the display pull from an already cached screen the first time that it's loaded.
   1. This can be done via a Startup Macro. Create a macro in the Explorer pane under Logic and Control > Macros. Right-click to create a New Macro.
      
   2. In the Macro editor, add a call to the "Display" function for each screen that you'd like to precache. Use the \Z flag to cache a screen without marking it as Always Updating. Use the \ZA flag to cache a screen and set the screen to Always Update. (A full description of this function and possible flags is available in the FTV help files as "FactoryTalk View Site Edition Help > FactoryTalk View commands > Graphics commands > Display")
      
   3. When launching or creating your FTV SE Client with the FactoryTalk View SE Client Wizard, include your macro as the Startup Macro.
      

If you follow these tips, you should have a fast and snappy HMI!

Learn more about DMC's Rockwell Programming Services.

The post Maximizing FactoryTalk View Site Edition Performance appeared first on DMC, Inc..

With these newer models, you can easily create configurable tag-based alarms in Logix Designer, which can handle all the logic that was previously contained within the program’s ladder logic. This includes debounce timers, deadbands, and much more. Tag-based alarms also do not contribute to scan time like ALMA and ALMD instructions do, so it is advisable to use them if your PLC and firmware version permit it.

Adding and Configuring Individual Alarms

To add a tag-based alarm for a specific single tag browse under the proper scope, right-click RealAlarm and select “Add Alarm for “[Tag Name].”

This menu should pop up next: 

From here, you can configure the following properties:

• Name: Set the name for the alarm as it will appear in the Logix Designer ‘Alarms’ page and the ‘Alarm Name’ column of the View Designer Alarm Summary object. Note: Alarm names do not have to be unique between two separate owners, but a single owner cannot have multiple alarms with the same name.
• Input: This is the tag associated with the alarm, which is triggered based on this tag’s value in relation to the defined expression.
• Condition: Here you use the “Expression” and “Limit” to determine the conditions under which the alarm is triggered. I’ve set it to trigger when the value of RealAlarm is more than, or equal to, 4800. The “Type” category is mostly just used for organization and clarity for operators. It will be displayed in the Condition column and does not affect the behavior of the alarm.
• On/Off Delay: Configure debounce timers for the alarm to trigger and deactivate respectively. Values are entered in milliseconds and must be divisible by 500.
• Deadband: This is the minimum difference between the input and trigger values that must be met before the alarm can be deactivated. For example, if I set my deadband to 300, then the input would have to fall to 4500 before the alarm can be turned off.
• Severity: Severity ranges from 1 to 1000 and higher values indicate more severe alarms. More severe alarms will be displayed more prominently in alarm-viewing objects and various icons will be used to indicate severity.
• Message: This is the message that will be displayed along with the alarm when activated. This can be a static message, or you can use the editor to tie tags to your message. This allows for a richer and more dynamic display of information (more on this later).
• Associated Tags: Here you can add up to four tags that are relevant to your alarm, which you can use in your message text.
• Shelving: Shelving is sort of like hitting the snooze button on your alarm. Here, you can set the shelve duration and the maximum duration for which it can be shelved.

To better demonstrate the functionality of the message editor and dynamic texts, let’s go through a quick example where I add an associated tag and integrate it into our message. To add an associated tag, hover over “Name” and click the button with an ellipsis.

This menu should pop up: 

Select the tag you would like to associate with your alarm. Once added, you’ll see it in the “Associated Tags” menu. For my example, I’ve added a bool that indicates when a valve to the tank is open.

Additionally, you can create an entirely new tag and link it to your alarm by clicking the “New Tag” button in the alarm configuration menu. Now that we’ve added our associated tag, let’s use it in our alarm message. Click the button next to the message text box that says “Editor.” It should bring up a menu that looks like this:

Under the variable dropdown menu, you can select the alarm’s input, any associated tags, or other parameters related to the alarm—and then add them to your message by clicking “<- Add.” I’ve set my alarm to display “Level Exceed High High Limit [Current Level] >= [Configured Limit] Infeed Valve Open [Valve State].” This tells the user that the alarm is triggered, by how much the current value exceeds the alarm trigger value, and whether the infeed valve is open. As you can see, this editor allows for highly configurable and dynamic error messages to be set. Additionally, if someone were to change the limit that triggers the alarm, the message would update automatically.

Once an alarm has been made and configured, you can edit it by going to the alarms page under “Alarm Manager” -> “Alarms” in the controller organizer. You can also directly add alarms from this page by right-clicking anywhere and selecting “Add Alarm.”

Below is an example photo of the alarm summary graphic in View Designer. Higher priority alarms are indicated by a red circle with two exclamation points.

Adding Alarm Definitions

Oftentimes, adding individual alarms can be cumbersome because of the large volume your project requires. In this case, you can save a great deal of time by writing modularized code that makes use of user-defined types (UDTs) and AOIs then configuring alarm definitions based on these. An alarm definition is an alarm linked to the definition of an AOI or a defined datatype, such as a UDT. Whenever an AOI or a defined datatype is created, then alarms will be added for each alarm definition.

There are some exceptions, however. When an InOut parameter, safety tag, or alias tag uses an AOI or a UDT with associated alarm definitions, then alarms will not be generated. This is because alarms are not supported on InOut parameters, safety tags, or alias tags.

It should also be noted that you cannot create an alarm that’s directly linked to a tag from an instance of UDT or AOI. In other words, if you want to have an alarm tied to a tag in an AOI or UDT, then you need to either use an alarm definition or use a separate tag with the original tag’s value and use that for the alarm.

To create alarm definitions, click on the corresponding tab in the controller organizer under “Alarm Manager” > “Alarm Definitions.” Right-click anywhere within this window and select “Add Alarm Definition,” and it will bring up a menu nearly identical to the menu for configuring individual alarms:

From here, you configure the alarms just like you did for the individual tag-based alarms, but with one slight difference. When you click the ellipsis button to assign an input, rather than choosing a specific tag instantiated in your program, you will select a tag from the definition of an AOI or a defined type. When selecting a tag from an AOI, only inputs and outputs to the AOI will be accessible—InOuts and local tags cannot be used here. The selection menu should look like this:

As an example, we’ll make a few alarm definitions using this SCP AOI. This AOI takes in pre-scale and post-scale min and max values, along with an input value to be processed, then scales and outputs that value accordingly. We call this AOI from inside our analog input processing AOI, so any instance of aoiDvc_AnalogInput will trigger the creation of these SCP alarms. Here’s what we have after making a few alarms for SCP’s output.

Now if we instantiate the SCP or aoiDvc_AnalogInput AOIs anywhere in the code, these four alarms will be created for each instance. As an example, I’ve added an aoiDvc_AnalogInput in the Controller Tags and Main Program Tags and an SCP instance in the Controller Tags. We get the following result on our Alarms page:

(Note that because “Required” was not checked off in our alarm definition, the “Use” column is not checked off for any of the created alarms. Always remember to check off “Use” for any alarms you want active in your system.)

Even though these alarms are all identical upon instantiation, we can still edit them after they’re created without affecting the alarm definition. For instance, maybe you want AI_2’s high alarm limit to be 80 instead of 90. Simply double-click the alarm and adjust the limit from the configuration menu.

If you need to make changes to your alarm definition after you’ve created it, then you should be aware that changes to some properties, but not all, will be pushed to related instantiated alarms. Changes to the name, type, expression sign, message, and associated tags will be pushed to existing alarm instances. Changes to the limit, on and off delays, dead band, severity, and shelving durations will not be pushed to existing alarms and each alarm must be edited individually. Lastly, the input tag used for an alarm definition cannot be edited at all after creating the alarm definition.

Accessing Properties of Alarms

Another advantage of tag-based alarms is that many of the associated properties can be accessed from your program. This utility has many benefits like using your alarm’s status, fault state, or another property in your controls, or adjusting properties like the on/off delay, limit, or enabled/disabled state from the HMI. When planning out your program, it is important to remember that properties for tag-based alarms that are local within an AOI will not be accessible outside of that AOI’s logic. However, they will still be accessible from the HMI (provided they are configured for external access). The syntax for accessing these properties is as follow:

[Tag Name].@Alarms.[Alarm Name].[Property]

If an owner has alarms that were generated via alarm definitions, then it will also have a set of properties related to its collection of alarms, like the number of unacknowledged alarms or the name and type of its highest severity alarm. For these properties, the syntax is as follows:

[Tag Name].@AlarmSet.[Property]

Other Configurable Alarm Properties

So far, we have only discussed the items within the ‘General’ tab of the alarm configuration menu. There are still three tabs, which I’ll give a brief overview of:

The “Class/Group” tab lets you define classes and groups for your alarms. These are mainly just used to help organize your alarms based on function, type of alarm, what piece of equipment the alarm is related to, or practically any categorization that fits your application. Classes and groups can help organize your alarms during both design and runtime.

The “Advanced” tab allows you to configure some key properties that affect the behavior of your alarms. The “FactoryTalk View Command” is a command that is executed when someone selects the alarm on an alarm viewing graphic then clicks a button to execute the command. From this tab, you can also choose whether an alarm latches or requires acknowledgment before it will go away. For more on how to set these commands, I recommend checking out Rockwell’s guide to Alarm and Event Configuration

From the “Status” tab you can see various statistics related to an alarm. Additionally, you can acknowledge, shelve, disable, or reset an alarm from Logix Designer.

Conclusion

Tag-based alarms can be an extremely useful tool to save you time programming and reduce the scan time of your program. However, there are a few key things to consider when implementing them:

• Tag-based alarms are only usable with newer models of PLCs. You’ll need at least firmware V31 and one of the following products:
  • Compact GuardLogic 5380
  • CompactLogix 5380
  • CompactLogix 5480
  • ControlLogix 5580
  • GuardLogix 5580
• Alarm-definition alarms will not be created for InOut parameters, safety tags, or alias tags.
• When making alarm definitions for an AOI, only inputs and outputs can be tied to alarms.
  • InOuts and local tags will not be accessible for use as the alarm input
• Tag-based alarms cannot be configured for an individual component tag of an AOI or UDT.
  • You must create an alarm definition for the AOI or UDT
• The properties of tag-based alarms can be read and written in your program and HMI, provided external access has been set appropriately.

Learn more about DMC’s Rockwell PLC and HMI programming expertise and contact us to get started on your next project. 

The post Utilizing Tag-Based Alarms in Logix Designer appeared first on DMC, Inc..

In this blog, I’ll walk you through writing XML code to generate ladder logic in Rockwell. Using these techniques, you can write scripts, macros, and other tools to create .L5X files that can be directly imported into your Rockwell program. You can create data types, tags, rungs, routines, or even entire programs, all from your favorite text-based program.

To see how this technique can be used to buffer IO, check out Brandon’s Blog!

To start, let’s look at the bare bones of a .L5X file and the required structure. It has a nested structure, with the controller at the highest level and rung content at the lowest. In order for Studio 5000 to recognize the file, you must keep this structure. In this example, I’ll write a “rung” import file, but it’s easy to adapt to generate routines or entire programs. 

Here’s a skeleton of a .L5X file:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<RSLogix5000Content
    SchemaRevision="1.0"
    SoftwareRevision="28.00"
    TargetType="Rung"
    TargetCount="1"
    ContainsContext="true"
    Owner="DMC"
    ExportDate="Mon May 20 15:46:14 2019"
    ExportOptions="
        References
        NoRawData
        L5KData
        DecoratedData
        Context
        Dependencies
        ForceProtectedEncoding
        AllProjDocTrans">

    <Controller Use="Context">

        <DataTypes Use="Context">
        </DataTypes>

        <Tags Use="Context">
        </Tags>

        <Programs Use="Context">

            <Program Use="Context">

                <Routines Use="Context">

                    <Routine Use="Context">

                        <RLLContent Use="Context">
                        </RLLContent>

                    </Routine>

                </Routines>

            </Program>

        </Programs>

    </Controller>

</RSLogix5000Content>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<RSLogix5000Content
    SchemaRevision="1.0"
    SoftwareRevision="28.00"
    TargetType="Rung"
    TargetCount="1"
    ContainsContext="true"
    Owner="DMC"
    ExportDate="Mon May 20 15:46:14 2019"
    ExportOptions="
        References
        NoRawData
        L5KData
        DecoratedData
        Context
        Dependencies
        ForceProtectedEncoding
        AllProjDocTrans">

    <Controller Use="Context">

        <DataTypes Use="Context">
        </DataTypes>

        <Tags Use="Context">
        </Tags>

        <Programs Use="Context">

            <Program Use="Context">

                <Routines Use="Context">

                    <Routine Use="Context">

                        <RLLContent Use="Context">
                        </RLLContent>

                    </Routine>

                </Routines>

            </Program>

        </Programs>

    </Controller>

</RSLogix5000Content>

Let’s use this skeleton to create a simple rung to turn on the red light if the red button is pressed. While this is clearly overkilled for this one rung, it would be very useful if you had 100 button/light combinations. 

We’ll need to add code for the tags, the rung logic, and the rung comment. First, let’s create the two boolean tags used in this rung. Between the lines <Tags Use="Context"> and </Tags>, insert the following lines. These tell the import tool to make new tags of type bool with the proper names. The line <![CDATA[0]]> sets the initial value of the tag to 0. I often use this feature to initialize values of a user defined type.

<Tag Name="bInRedButtonPressed" TagType="Base" DataType="BOOL" Radix="Decimal" Constant="false" ExternalAccess="Read/Write">
<Data Format="L5K">
<![CDATA[0]]>
</Data>
<Data Format="Decorated">
<DataValue DataType="BOOL" Radix="Decimal" Value="0"/>
</Data>
</Tag>
<Tag Name="bOutRedLightOn" TagType="Base" DataType="BOOL" Radix="Decimal" Constant="false" ExternalAccess="Read/Write">
<Data Format="L5K">
<![CDATA[0]]>
</Data>
<Data Format="Decorated">
<DataValue DataType="BOOL" Radix="Decimal" Value="0"/>
</Data>
</Tag>

<Tag Name="bInRedButtonPressed" TagType="Base" DataType="BOOL" Radix="Decimal" Constant="false" ExternalAccess="Read/Write">
<Data Format="L5K">
<![CDATA[0]]>
</Data>
<Data Format="Decorated">
<DataValue DataType="BOOL" Radix="Decimal" Value="0"/>
</Data>
</Tag>
<Tag Name="bOutRedLightOn" TagType="Base" DataType="BOOL" Radix="Decimal" Constant="false" ExternalAccess="Read/Write">
<Data Format="L5K">
<![CDATA[0]]>
</Data>
<Data Format="Decorated">
<DataValue DataType="BOOL" Radix="Decimal" Value="0"/>
</Data>
</Tag>

You can continue to add more tags as needed, change their properties, and their initial values. Next, let’s add logic for the rung. Between the lines <RLLContent Use="Context"> and </RLLContent>, add the following lines.

<Rung Use="Target" Number="1" Type="N">

    <Comment>
        <![CDATA[
        Turn on the Red Light when the Red Button is pressed.
        ]]>
    </Comment>

    <Text>
        <![CDATA[
        XIC(bInRedButtonPressed) OTE(bOutRedLightOn);
        ]]>
    </Text>

</Rung>

<Rung Use="Target" Number="1" Type="N">

    <Comment>
        <![CDATA[
        Turn on the Red Light when the Red Button is pressed.
        ]]>
    </Comment>

    <Text>
        <![CDATA[
        XIC(bInRedButtonPressed) OTE(bOutRedLightOn);
        ]]>
    </Text>

</Rung>

The “text” section is where you add the code for your rung. For something simple like this, it’s fairly easy to do (just XIC and OTE instructions). However, if you’re unsure of the “text version” of your ladder logic, just double click on the rung number in the ladder editor, and it will display the text.

And that’s all you need to do! You can add more rungs just by repeating the pattern. Be sure to edit the targetcount on line 2 to match the number of rungs you’re making. Save the file with a .L5X extension and import it directly into your routine!

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<RSLogix5000Content
    SchemaRevision="1.0"
    SoftwareRevision="28.00"
    TargetType="Rung"
    TargetCount="1"
    ContainsContext="true"
    Owner="DMC"
    ExportDate="Mon May 20 15:46:14 2019">

    <Controller Use="Context">

        <DataTypes Use="Context">
        </DataTypes>

        <Tags Use="Context">

            <Tag
                Name="bInRedButtonPressed"
                TagType="Base"
                DataType="BOOL"
                Radix="Decimal"
                Constant="false"
                ExternalAccess="Read/Write">

                <Data Format="L5K"><![CDATA[0]]></Data>

                <Data Format="Decorated">
                    <DataValue
                        DataType="BOOL"
                        Radix="Decimal"
                        Value="0"/>
                </Data>
            </Tag>

            <Tag
                Name="bOutRedLightOn"
                TagType="Base"
                DataType="BOOL"
                Radix="Decimal"
                Constant="false"
                ExternalAccess="Read/Write">

                <Data Format="L5K"><![CDATA[0]]></Data>

                <Data Format="Decorated">
                    <DataValue
                        DataType="BOOL"
                        Radix="Decimal"
                        Value="0"/>
                </Data>
            </Tag>

        </Tags>

        <Programs Use="Context">
            <Program Use="Context">

                <Routines Use="Context">
                    <Routine Use="Context">

                        <RLLContent Use="Context">

                            <Rung Use="Target"
                                  Number="1"
                                  Type="N">

                                <Comment>
                                    <![CDATA[
                                    Turn on the Red Light when the Red Button is pressed.
                                    ]]>
                                </Comment>

                                <Text>
                                    <![CDATA[
                                    XIC(bInRedButtonPressed)
                                    OTE(bOutRedLightOn);
                                    ]]>
                                </Text>

                            </Rung>

                        </RLLContent>

                    </Routine>
                </Routines>

            </Program>
        </Programs>

    </Controller>

</RSLogix5000Content>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<RSLogix5000Content
    SchemaRevision="1.0"
    SoftwareRevision="28.00"
    TargetType="Rung"
    TargetCount="1"
    ContainsContext="true"
    Owner="DMC"
    ExportDate="Mon May 20 15:46:14 2019">

    <Controller Use="Context">

        <DataTypes Use="Context">
        </DataTypes>

        <Tags Use="Context">

            <Tag
                Name="bInRedButtonPressed"
                TagType="Base"
                DataType="BOOL"
                Radix="Decimal"
                Constant="false"
                ExternalAccess="Read/Write">

                <Data Format="L5K"><![CDATA[0]]></Data>

                <Data Format="Decorated">
                    <DataValue
                        DataType="BOOL"
                        Radix="Decimal"
                        Value="0"/>
                </Data>
            </Tag>

            <Tag
                Name="bOutRedLightOn"
                TagType="Base"
                DataType="BOOL"
                Radix="Decimal"
                Constant="false"
                ExternalAccess="Read/Write">

                <Data Format="L5K"><![CDATA[0]]></Data>

                <Data Format="Decorated">
                    <DataValue
                        DataType="BOOL"
                        Radix="Decimal"
                        Value="0"/>
                </Data>
            </Tag>

        </Tags>

        <Programs Use="Context">
            <Program Use="Context">

                <Routines Use="Context">
                    <Routine Use="Context">

                        <RLLContent Use="Context">

                            <Rung Use="Target"
                                  Number="1"
                                  Type="N">

                                <Comment>
                                    <![CDATA[
                                    Turn on the Red Light when the Red Button is pressed.
                                    ]]>
                                </Comment>

                                <Text>
                                    <![CDATA[
                                    XIC(bInRedButtonPressed)
                                    OTE(bOutRedLightOn);
                                    ]]>
                                </Text>

                            </Rung>

                        </RLLContent>

                    </Routine>
                </Routines>

            </Program>
        </Programs>

    </Controller>

</RSLogix5000Content>

This blog was inspired by a new Excel tool I wrote to help us write sequences for one of our large Oil and Gas clients. These sequences were often very similar, so having a tool to auto-generate them made a lot of sense. Our engineers can now fill out the system parameters in Excel, and a macro generates all the rungs and data required for the program.

What used to take us a few hours can now be done in a matter of minutes! You can learn more about the project and the customer benefits here.

If you need help with Rockwell Programming or any other automation tasks, let us know!

The post Writing Rockwell Ladder Logic in XML appeared first on DMC, Inc..

Beyond just allowing for code to be exported and imported between projects or Rockwell editors, it also allows for external code generation. In fact, a whole project could be created using a text editor and then imported into RSLogix5000 or Studio5000. While this might not be a practical method of creating an entire project, the ability to generate text-based code has several benefits.

In a recent project, DMC used an Excel Macro to generate the buffering routines for an Allen Bradley project. Rather than manually creating an input routine for each of the hundreds of tags, in one click, a simple Macro generated files that could be imported into Rockwell.

In the following example, we will work with a simple program that has three inputs and outputs as shown in Figure1. This information can easily be compiled from the wiring info or electrical schematics.

Figure 1: List of IO Information

Rockwell’s text-based code is saved in a file format with an L5X extension. However, this is just a .txt file with a different extension. From Rockwell, you can export a routine, and if you open the L5X file with a text editor, you can see how the code translates to text.

Generating the Text File

One of the easiest ways to generate a text file from Excel is to use a Macro written in VBScript. Open the Visual Basic editor from the Developer tab to bring up the VBScript editor.

In the Visual Basics editor, we will create a new module. Right click on the excel document that you are using and insert a new module. Each module acts like a function.

As your code gets more complicated, subfunctions can be separated to make the code more modular. For our purpose, the code is simple enough that we will only need one module.

Sub CreateBufferingFiles()

End Sub

As mentioned, the first thing to do in our macro is to generate our files. VBScript uses a helper object to create the actual file. Next, we create our file through our file path string. This can be changed to whatever location you want the file to end up. Then, we create our file as a text file.

'Create File
Dim fso As Object
    	Set fso = CreateObject("Scripting.FileSystemObject")


Dim myInputFilePath As String
	myInputFilePath = "C:\Documents\ExampleProject\MapInputs.L5X"
Dim myInputFile As Object
Set myInputFile = fso.createTextFile(myInputFilePath)
    	
Dim myOutputFilePath As String
    	myOutputFilePath = "C:\Docuements\ExampleProject\MapOutputs.L5X"
	Dim myOutputFile As Object
	Set myOutputFile = fso.createTextFile(myOutputFilePath)

'Create File
Dim fso As Object
    	Set fso = CreateObject("Scripting.FileSystemObject")


Dim myInputFilePath As String
	myInputFilePath = "C:\Documents\ExampleProject\MapInputs.L5X"
Dim myInputFile As Object
Set myInputFile = fso.createTextFile(myInputFilePath)
    	
Dim myOutputFilePath As String
    	myOutputFilePath = "C:\Docuements\ExampleProject\MapOutputs.L5X"
	Dim myOutputFile As Object
	Set myOutputFile = fso.createTextFile(myOutputFilePath)

Creating Lines of Code

Once we have created our file, we can use the writeLine command to create lines of code. The first thing we need to create is the header information for the device. This specifies the version number, PLC name, and scope of things in the project. This information doesn’t need to match exactly since we can import directly to a program, but the formatting needs to be consistent.

The easiest way is to export a file and then copy the header lines into our VBScript, add the object.writeLine command and then format it to be a string. The program below would be an example of a way to create header information. This would need to be done for both the input and output mapping routines.

‘======================================== Input ===============================
‘Input Mapping Header
'Create Header Information
myInputFile.writeLine "<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>"
myInputFile.writeLine "<RSLogix5000Content SchemaRevision=""1.0"" SoftwareRevision=""31.00"" TargetName=""State_RunOut"" TargetType=""Routine"" TargetSubType=""RLL"" ContainsContext=""true"" Owner=""AB-Rockwell, DMC"" ExportDate=""Thu Dec 06 14:42:07 2018"" ExportOptions=""References NoRawData L5KData DecoratedData Context Dependencies ForceProtectedEncoding AllProjDocTrans"">"
myInputFile.writeLine "<Controller Use=""Context"" Name=""TigrisThermalSystems"">"
    
 'Begin Controller scope rungs and tags
 myInputFile.writeLine "<Programs Use=""Context"">"
 myInputFile.writeLine "<Program Use=""Context"" Name=""HydronicLoop"">"
  
 'Create Controller Tags
    
 'Create rungs
 myInputFile.writeLine "<Routines Use=""Context"">"
 myInputFile.writeLine "<Routine Use=""Target"" Name=""MapInputs"" Type=""RLL"">"
 myInputFile.writeLine "<RLLContent>"

‘======================================== Input ===============================
‘Input Mapping Header
'Create Header Information
myInputFile.writeLine "<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>"
myInputFile.writeLine "<RSLogix5000Content SchemaRevision=""1.0"" SoftwareRevision=""31.00"" TargetName=""State_RunOut"" TargetType=""Routine"" TargetSubType=""RLL"" ContainsContext=""true"" Owner=""AB-Rockwell, DMC"" ExportDate=""Thu Dec 06 14:42:07 2018"" ExportOptions=""References NoRawData L5KData DecoratedData Context Dependencies ForceProtectedEncoding AllProjDocTrans"">"
myInputFile.writeLine "<Controller Use=""Context"" Name=""TigrisThermalSystems"">"
    
 'Begin Controller scope rungs and tags
 myInputFile.writeLine "<Programs Use=""Context"">"
 myInputFile.writeLine "<Program Use=""Context"" Name=""HydronicLoop"">"
  
 'Create Controller Tags
    
 'Create rungs
 myInputFile.writeLine "<Routines Use=""Context"">"
 myInputFile.writeLine "<Routine Use=""Target"" Name=""MapInputs"" Type=""RLL"">"
 myInputFile.writeLine "<RLLContent>"

And for the Output:

	‘======================================== Output ===============================
‘Output Mapping Header
'Create Header Information
myOutputFile.writeLine "<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>"
myOutputFile.writeLine "<RSLogix5000Content SchemaRevision=""1.0"" SoftwareRevision=""31.00"" TargetName=""State_RunOut"" TargetType=""Routine"" TargetSubType=""RLL"" ContainsContext=""true"" Owner=""AB-Rockwell, DMC"" ExportDate=""Thu Dec 06 14:42:07 2018"" ExportOptions=""References NoRawData L5KData DecoratedData Context Dependencies ForceProtectedEncoding AllProjDocTrans"">"
myOutputFile.writeLine "<Controller Use=""Context"" Name=""TigrisThermalSystems"">"
    
 'Begin Controller scope rungs and tags
 myOutputFile.writeLine "<Programs Use=""Context"">"
 myOutputFile.writeLine "<Program Use=""Context"" Name=""HydronicLoop"">"
  
 'Create Controller Tags
    
 'Create rungs
 myOutputFile.writeLine "<Routines Use=""Context"">"
 myOutputFile.writeLine "<Routine Use=""Target"" Name=""MapOutputs"" Type=""RLL"">"
 myOutputFile.writeLine "<RLLContent>"

	‘======================================== Output ===============================
‘Output Mapping Header
'Create Header Information
myOutputFile.writeLine "<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>"
myOutputFile.writeLine "<RSLogix5000Content SchemaRevision=""1.0"" SoftwareRevision=""31.00"" TargetName=""State_RunOut"" TargetType=""Routine"" TargetSubType=""RLL"" ContainsContext=""true"" Owner=""AB-Rockwell, DMC"" ExportDate=""Thu Dec 06 14:42:07 2018"" ExportOptions=""References NoRawData L5KData DecoratedData Context Dependencies ForceProtectedEncoding AllProjDocTrans"">"
myOutputFile.writeLine "<Controller Use=""Context"" Name=""TigrisThermalSystems"">"
    
 'Begin Controller scope rungs and tags
 myOutputFile.writeLine "<Programs Use=""Context"">"
 myOutputFile.writeLine "<Program Use=""Context"" Name=""HydronicLoop"">"
  
 'Create Controller Tags
    
 'Create rungs
 myOutputFile.writeLine "<Routines Use=""Context"">"
 myOutputFile.writeLine "<Routine Use=""Target"" Name=""MapOutputs"" Type=""RLL"">"
 myOutputFile.writeLine "<RLLContent>"

Setting Up the Worksheet

Once we have created the header info, we can set up the information that will go through the worksheet and create a rung for each tag. This loop looks at the value of the first column and continues until it finds a blank cell upon which it ends the loop. We also need to keep track of how many rungs we have created to number our rungs correctly.

'loop through input tags to create rungs
    
Dim i As Integer
i = 2 'Set at the row value of the first tag

Dim inputRungNumber, outputRungNumber As Integer
inputRungNumber = 1
outputRungNumber = 1

'check the contents of the first cell
Dim tagName As Range
Set tagName = Worksheets("Sheet1").Cells(i, 1)
Do While Not IsEmpty(tagName.Value)

'loop through input tags to create rungs
    
Dim i As Integer
i = 2 'Set at the row value of the first tag

Dim inputRungNumber, outputRungNumber As Integer
inputRungNumber = 1
outputRungNumber = 1

'check the contents of the first cell
Dim tagName As Range
Set tagName = Worksheets("Sheet1").Cells(i, 1)
Do While Not IsEmpty(tagName.Value)

Creating Rungs

Finally, we can create our rungs. By looking at the tag type column, we determine whether it is an input or output and whether it is analog or digital. For a digital value, we use an open contact and coil. These are the XIC and OTE instructions. For an analog value, we use the move function, MOV.

'Read Tag Type
        Dim tagType As String
        tagType = Worksheets("Sheet1").Cells(i, 2).Value

        'Read Module info
        Dim module, slot, channel, point As Range
        Set module = Worksheets("Sheet1").Cells(i, 3)
        Set slot = Worksheets("Sheet1").Cells(i, 4)
        Set channel = Worksheets("Sheet1").Cells(i, 5)
        Set point = Worksheets("Sheet1").Cells(i, 6)
        
        'Create Digital Input Rung
        If tagType = "DI" Then
            inputRungNumber = inputRungNumber + 1
            myInputFile.writeLine "<Rung Number=""" & inputRungNumber & """ Type=""N"">"
            myInputFile.writeLine "<Text>"
            myInputFile.writeLine "<![CDATA[XIC(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ")OTE(" & tagName.Value & ");]]>"
            myInputFile.writeLine "</Text>"
            myInputFile.writeLine "</Rung>"
        
        'Create Digital Output Rung
        ElseIf tagType = "DO" Then
            outputRungNumber = outputRungNumber + 1
            myOutputFile.writeLine "<Rung Number=""" & outputRungNumber & """ Type=""N"">"
            myOutputFile.writeLine "<Text>"
            myOutputFile.writeLine "<![CDATA[XIC(" & tagName.Value & ")OTE(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ");]]>"
            myOutputFile.writeLine "</Text>"
            myOutputFile.writeLine "</Rung>"
            
        'Create Analog Input Rung
        ElseIf tagType = "AI" Then
            inputRungNumber = inputRungNumber + 1
            myInputFile.writeLine "<Rung Number=""" & inputRungNumber & """ Type=""N"">"
            myInputFile.writeLine "<Text>"
            myInputFile.writeLine "<![CDATA[MOV(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & "," & tagName.Value & ");]]>"
            myInputFile.writeLine "</Text>"
            myInputFile.writeLine "</Rung>"
        
        'Create Analog Output Rung
        ElseIf tagType = "AO" Then
            outputRungNumber = outputRungNumber + 1
            myOutputFile.writeLine "<Rung Number=""" & outputRungNumber & """ Type=""N"">"
            myOutputFile.writeLine "<Text>"
            myOutputFile.writeLine "<![CDATA[MOV(" & tagName.Value & "," & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ");]]>"
            myOutputFile.writeLine "</Text>"
            myOutputFile.writeLine "</Rung>"
        End If
      
        i = i + 1
        Set tagName = Worksheets("Sheet1").Cells(i + 1, 1)

'Read Tag Type
        Dim tagType As String
        tagType = Worksheets("Sheet1").Cells(i, 2).Value

        'Read Module info
        Dim module, slot, channel, point As Range
        Set module = Worksheets("Sheet1").Cells(i, 3)
        Set slot = Worksheets("Sheet1").Cells(i, 4)
        Set channel = Worksheets("Sheet1").Cells(i, 5)
        Set point = Worksheets("Sheet1").Cells(i, 6)
        
        'Create Digital Input Rung
        If tagType = "DI" Then
            inputRungNumber = inputRungNumber + 1
            myInputFile.writeLine "<Rung Number=""" & inputRungNumber & """ Type=""N"">"
            myInputFile.writeLine "<Text>"
            myInputFile.writeLine "<![CDATA[XIC(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ")OTE(" & tagName.Value & ");]]>"
            myInputFile.writeLine "</Text>"
            myInputFile.writeLine "</Rung>"
        
        'Create Digital Output Rung
        ElseIf tagType = "DO" Then
            outputRungNumber = outputRungNumber + 1
            myOutputFile.writeLine "<Rung Number=""" & outputRungNumber & """ Type=""N"">"
            myOutputFile.writeLine "<Text>"
            myOutputFile.writeLine "<![CDATA[XIC(" & tagName.Value & ")OTE(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ");]]>"
            myOutputFile.writeLine "</Text>"
            myOutputFile.writeLine "</Rung>"
            
        'Create Analog Input Rung
        ElseIf tagType = "AI" Then
            inputRungNumber = inputRungNumber + 1
            myInputFile.writeLine "<Rung Number=""" & inputRungNumber & """ Type=""N"">"
            myInputFile.writeLine "<Text>"
            myInputFile.writeLine "<![CDATA[MOV(" & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & "," & tagName.Value & ");]]>"
            myInputFile.writeLine "</Text>"
            myInputFile.writeLine "</Rung>"
        
        'Create Analog Output Rung
        ElseIf tagType = "AO" Then
            outputRungNumber = outputRungNumber + 1
            myOutputFile.writeLine "<Rung Number=""" & outputRungNumber & """ Type=""N"">"
            myOutputFile.writeLine "<Text>"
            myOutputFile.writeLine "<![CDATA[MOV(" & tagName.Value & "," & module.Value & ":" & slot.Value & ":" & channel.Value & "." & point.Value & ");]]>"
            myOutputFile.writeLine "</Text>"
            myOutputFile.writeLine "</Rung>"
        End If
      
        i = i + 1
        Set tagName = Worksheets("Sheet1").Cells(i + 1, 1)

Closing the Files

Once we have looped through all our values, we can end the loop and create the footer information. The final step is to close the files and release the files by setting our variables to nothing.

Loop

    '=============INPUT==============
    'Close the routine and program
    myInputFile.writeLine "</RLLContent>"
    myInputFile.writeLine "</Routine>"
    myInputFile.writeLine "</Routines>"
    myInputFile.writeLine "</Program>"
    myInputFile.writeLine "</Programs>"
    
    'Create footer information
    myInputFile.writeLine "</Controller>"
    myInputFile.writeLine "</RSLogix5000Content>"
    
    '=============OUTPUT==============
    'Close the routine and program
    myOutputFile.writeLine "</RLLContent>"
    myOutputFile.writeLine "</Routine>"
    myOutputFile.writeLine "</Routines>"
    myOutputFile.writeLine "</Program>"
    myOutputFile.writeLine "</Programs>"
    
    'Create footer information
    myOutputFile.writeLine "</Controller>"
    myOutputFile.writeLine "</RSLogix5000Content>"
    
    'Close File and set to nothing
    myInputFile.Close
    Set myInputFile = Nothing
    myOutputFile.Close
    Set myOutputFile = Nothing
	End Sub

Loop

    '=============INPUT==============
    'Close the routine and program
    myInputFile.writeLine "</RLLContent>"
    myInputFile.writeLine "</Routine>"
    myInputFile.writeLine "</Routines>"
    myInputFile.writeLine "</Program>"
    myInputFile.writeLine "</Programs>"
    
    'Create footer information
    myInputFile.writeLine "</Controller>"
    myInputFile.writeLine "</RSLogix5000Content>"
    
    '=============OUTPUT==============
    'Close the routine and program
    myOutputFile.writeLine "</RLLContent>"
    myOutputFile.writeLine "</Routine>"
    myOutputFile.writeLine "</Routines>"
    myOutputFile.writeLine "</Program>"
    myOutputFile.writeLine "</Programs>"
    
    'Create footer information
    myOutputFile.writeLine "</Controller>"
    myOutputFile.writeLine "</RSLogix5000Content>"
    
    'Close File and set to nothing
    myInputFile.Close
    Set myInputFile = Nothing
    myOutputFile.Close
    Set myOutputFile = Nothing
	End Sub

This method of creating buffering routines requires some overhead to set up, but once the macro is created, it will generate the routines for any number of tabs. If massive changes need to be made, this workbook can be edited and then the routine can be reimported. This type of macro has advantages beyond buffering and can be used to generate any amount of code with repetition.

Leveraging tools like these is one of the ways that DMC makes our programming more efficient and robust. Using Excel Macros in Rockwell programming can save time from writing tedious code and will allow the programmer to focus on more important issues.

Learn more about DMC’s Allen Bradley PLC Programming expertise.

Learn more about DMC’s Manufacturing Automation & Intelligence Services and contact us for any project inquiries.

The post Generating Buffering Routines on an Allen Bradley PLC Using Excel Macros appeared first on DMC, Inc..

In this tutorial, I will show you how to set up a simple control valve as a Global Object which links to a pop-up faceplate using Tag Substitution. The final result will allow us to input just three parameters to generate a new valve on the HMI. I will be showing the development for FactoryTalk View Site Edition (SE), but also applies to Machine Edition (ME).

Global Objects use a special type of display which allows you to link back to the parent when used in a ‘normal’ display screen. They are more powerful than a simple template for a group of objects; any formatting or animation changes made to the Global Object propagate to all its instances in the project. Another advantage of Global Objects is that they are particularly suited for coordination in the PLC through User-Defined Data Types (UDTs) and Add-On Instructions (AOIs), which allow for consistent tag structure and modular logic.
 

Basic Setup

First off, I have developed a simple PLC program which utilizes the UDT ‘udtValve’ to track what is going on with our valve called ‘HMI_CYL’. The members of the UDT will be used on the HMI to display status animations for the valve. There is also an AOI on the PLC side which handles the logic and makes it easy for me to instantiate new valves into my PLC project. 

User defined data type ‘udtValve’. 

Now that the PLC side is set, let’s move over to the HMI project. Go to ‘Graphics’ -> ‘Global Objects’ -> [Right Click] ‘New’ to create a new global object display in FactoryTalk Studio. I’ve drawn an object group for the valve and set up color animation for the valve to show green when open, gray when closed, and red when faulted. In my PLC code, the ‘.Status’ member of udtValve outputs a number for each of these states.
 
This is where global objects are extremely helpful — we do not want to copy/paste into each animation if we need to create many valves in a project! We can insert a placeholder parameter instead of a direct PLC tag in the animation so that we can make the global object generic. Use ‘#1’ then ‘.(name of UDT 
member)’ to access a specific tag member of the UDT. We could create other tag placeholders that are different UDTs or just normal tags by referencing ‘#2’, ‘#3’, etc., up to ‘#500’.  

Global Object Animation

Next, we need to set up a definition for the parameter we just referenced. Right-click on the object (make sure all of the drawing objects are grouped together) and navigate to ‘Global Object Parameter Definitions’. For each placeholder you reference, you must list here with the # and number. 

Global object parameter definition

Now we are ready to create an instance of the global object into our desired runtime screen. Simply copy/paste the global object group, then right click -> ‘Global Object Parameter Values’. This is where we link the PLC instance name of the particular valve we want to reference to those placeholders we put in the animation. The result will concatenate to get the whole tag ‘[PLC]HMI_CYL.Status’ in runtime.

Global object parameter values

Beyond the Basics

Alright, we’ve created a simple global object! We have a valve that changes color based on the feedback from the PLC logic. There’s a few other things we can do to give the users of our HMI application more information and control of the valve. I’m going to add a pop-up that displays when we click on the valve and a placeholder to show the name of each valve instance.  
 
Let’s start with the valve name placeholder. Add a text box to the valve global object. In its text properties, click ‘Insert Variable’ -> ‘String..’  then choose ‘Literal string’ and input ‘#2’ to create a new placeholder. The code generated should look something like this (depending on the options you choose in the dialogue box): 

Tag substitution using literal string  

Edit the global object parameter definitions again to account for the ‘#2’ placeholder we just added. Drag a new instance of the global object to your display screen and open its parameter values. Because we chose ‘Literal string’, we can now input normal text to display with our global object, instead of linking to a PLC tag. If you do want it to link to a string tag in the PLC, then choose ‘Tag’ when you Insert Variable into the text box setup.  

Global object parameter values using string for tag name

Finally, we are going to create a pop-up which displays when you click on the valve. For this we will use a normal display instead of a global object display, but will reference it from our global object. Our pop-up will also use tag substitution — it doesn’t just apply to global objects!
 
I’ve created a display called ‘CV_Faceplate’ which shows additional valve statuses and has buttons which can be used to open and close the valve if it is in manual mode. Each of the tags use a ‘#1’ placeholder with ‘.(Name of UDT member)’ just like the global object. I’ve also added the ‘#2’ placeholder for the valve name and additionally I’ve added a ‘#3’ literal string placeholder for a valve description.  

Control valve faceplate / pop-up using tag substitution  

Now we are going to go back to the global object. I want the pop-up I created to display when the valve is clicked on, so I will add a Touch animation, which uses the display command, and /T to invoke tag substitution. Add ‘#3’ to the global object parameter definitions. Take note that #3 is not used in the global object itself, it is passed to the pop-up display only!

Display faceplate/pop-up from global object

Important Note: Because we are using the global object to tag substitute to the pop-up display, we are also putting #1, #2, and #3 in the display command which are linked to our global object parameter values. We could also put direct tag references in the display command which correspond to each of tag placeholders in the pop-up display if we wanted to call the pop-up outside of a global object. In that case, our Touch animation would look like: ‘Display CV_Faceplate /T {[PLC]Another_Valve} {CV-150} {‘CV-150 Description’} /cc’. 
 
We’ve created a valve which displays a status pop-up without having to change any background code to create a new instance. To create new valves, all we need to do is copy the global object and fill in its three input parameters! Here are a few views in runtime:

Animated control valve global object and faceplate / pop-up example 1

Animated control valve global object and faceplate / pop-up example 2

Animated control valve global object and faceplate / pop-up example 3

Tips

• To test your global object, make sure you generate an actual client for runtime. Switching your screen to ‘Test Display’ may make it look like your global object is not working correctly.
• You can create multiple global objects in one global object display screen. Each group of objects can have separate parameter definitions and be dragged into displays individually.
• If you want to modify an instance of a global object separately from the parent, you can ‘Break Link’ by right-clicking on the instance in the display. It is also useful if you do want to use a global object as a graphic template, or you don’t want changes to the global object to propagate to the children. 

Tools which create modular, reusable code like Global Objects, Tag Substitution, User-Defined Data Types (UDT), and Add-On-Instructions (AOI) greatly reduce your development time and makes your implementation much easier to get up and running. DMC focuses on these strategies for both PLC and HMI/SCADA in order to deliver efficient, high-performance applications to our customers across many development platforms. See this blog, Linking PLC UDT Tags to HMI Faceplates and Pop-ups in TIA Portal V13 SP1, for similar tips in the Siemens platform. 

Contact DMC for assistance on your next PLC project.

Learn more about DMC’s HMI and SCADA programming solutions.

The post Rockwell FactoryTalk Studio Basics: Global Objects and Tag Substitution appeared first on DMC, Inc..

Since protecting intellectual property or touchy algorithms while opening up some of the code for modification or troubleshooting is pretty common, I thought I’d share some of the info I found and provide a few easy steps to locking down your code. Incidentally, while I’ll walk you through configuring an AOI for source protection, you can use the same approach to protect routines as well.

Note that all of the information below can be found in various forms in two useful documents published by Rockwell Automation that I would highly recommend you download for reference:

• Logix5000 Controllers Add-On Instructions
• Logix5000 Controllers Security

Enabling Source Protection

Out of the box, source code protection is not enabled in RSLogix 5000. So if you have never used it, chances are good that its never been activated. To check, open up the project you are working on and look under Tools >> Security. If you don’t see an option for “Configure Source Protection,” then you will need to enable it.

I would assume that you really only need to make a quick registry change, but its even easier than that as Rockwell provides a free tool you can download and run to take care of it for you. Allen Bradley provides some good instructions for the process that outline the different methods for different revs of RSLogix in Logix5000 Controllers Security. In my case, using rev 20, I needed to download Allen Bradley’s Source Protection Tool. To find it, I started at their software download page and searched RSLogix Downloads. You should see it listed as “RSLogix 5000 Source Protection Tool.” This is a quick download. After running, restart RSLogix and you should see a new option under Tools >> Security: Configure Source Protection.

Ok, after enabling, you can choose your newly available option and you will now be prompted to specify a Source Key File location. Go ahead and choose a location. If you don’t have a source key file in the specified directory, you will be asked if you would like to create one. This source key file will contain your keys for any protection you establish. This file can be moved from computer to computer, or it can be built locally by adding the keys you create. Go ahead and create a new one; once you’ve done so, you’re ready to lock down your code.

Protecting an AOI

For a quick demo, I created a new project with a single Routine called ‘MyRoutine’ and a single AOI, ‘MyAddOnInstruction.’ Once you open up Source Protection Configuration from Tools >> Security, you will see that your programs and Add-On Instructions will be available. You can configure different keys and settings for each program and AOI, but lets just walk through configuration of ‘MyAddOnInstruction.’ Take a look and notice that there are currently no Source Keys defined.

Select your AOI you would like to protect and choose “Protect.” A Source Key dialog will open allowing you to select or create a source key to apply to your selected component (in this case, our AOI). I’m going to create a new one, “MyKey” and name it DMC. If you choose not to show the key (characters will not be shown on the screen) you will need to confirm the key a second time. I prefer to just see what I’m typing. You can also define a Source Key Name. This is really just a friendly name to associate with your key (think of user name::password, key name::key) that will be shown in the Source Protection Dialog to protect your key from prying eyes.

The checkbox in this dialog is worth discussing in a little more detail. You have two choices for the level of protection you are enabling. Leaving this check box unchecked will completely lock and hide the code source code from anyone without the key. Anyone viewing the project (or any project containing this AOI) without the key will not be able to view, access, or edit the source code for the instruction. Selecting the checkbox will allow a user to view, but not to modify the source code, in effect making it read-only. Of course with either selection, if you have the key, you have full access.

It should be noted that in addition to protecting any sensitive code, this can also be used as a method of source or version control and can be a great way to prevent unauthorized or unintended edits to sections of source code that have been validated or released.

Getting back to our walkthrough, let’s go ahead and leave the checkbox unchecked and select OK. This will bring us back to the Source Protection Configuration dialog again, but you will now see that the key “DMC” has been added to our AOI and it is not selected as viewable for anyone without the key.

We’re done here. Choose “Close” to exit the dialog and take a look at your project tree. You shouldn’t notice any changes. You can still expand and see both Tags and Logic for the AOI we just protected. However, to see what it looks like to someone without the key, I’m going to save the project, exit RSLogix, and delete my key file. Now, after reopening the project we can see that I am not able to expand the AOI – there is no access to the Tags or Logic for the instruction.

If we dig a little deeper and open up the Source Protection Configuration dialog again, we will see that ‘MyAddOnInstruction’ is protected and has an unknown source key. Selecting the AOI and choosing “Protect” will bring us back to the Apply Source Key dialog. Attempting to apply a new source key other than the one we already created for this instruction will give an error and will not allow us to unlock it. However, I luckily grabbed a screenshot of the earlier showing me that I used the key ‘MyKey.’ Sure enough, entering this key will unlock the AOI and allow access to the source code again.

It is also worth taking the time here to export our AOI. Normally, an exported AOI will be saved in human readable text in an XML type format (try it!). However, when source protection has been enabled, this exported file is encrypted.

Before I wrap this up, I want to get back to one more point. I touched upon this earlier, but it’s worth mentioning that there are many reasons one may want to use Source Protection within their project. In addition to protecting proprietary code, it can also be a useful method of source control. A good example may be a custom motor implementation in a large project. Once development and testing have been completed on the instruction or routine, the code could be locked by the creator to prevent any accidental changes by others. By locking and then exporting to a library, other developers can then use the instruction and be guaranteed that the source code has not been modified.

This, combined with the version information available for each AOI and routine, can be a great way to manage a shared library of reusable code. DMC strives to make code as reusable as possible as a means to decrease development time (and cost), increase reliability, and provide for scalability and modularity. Combining this with versioning software such as SVN provides for an easy way to maintain a library for all our engineers to share.

Finally, a quick disclaimer about security. I personally haven’t delved into how encrypted or hidden this method of source code protection is, but it will probably serve for the majority of purposes. In the case of extremely valuable intellectual property, I would always strongly recommend consulting with experts before trusting that this is bulletproof. DMC has acquired a wealth of experience in the past years protecting valuable information and has the experts available should this be the case.

Contact DMC with any questions or to get started on your next project.

Learn more about DMC’s Allen Bradley PLC programming services.

The post Source Code Protection in Studio 5000 Logix Designer appeared first on DMC, Inc..

On the higher end of their PLC lines, the programming environments to use are:

• Siemens – Step 7 Simatic Manager for S7-300 and 400 level PLCs
• Allen-Bradley (AB) – RSLogix 5000 for the Control Logix and Compact Logix PLCs

As someone who uses both platforms regularly, I would like to compare one of the key differences between them – function blocks.

What’s a function block?

Siemens uses the term Function Block (FB) for program routines that can have internal memory, as opposed to Function Calls (FC) that have only temporary internal memory. Function blocks are a fundamental concept in the Siemens platform, which give them a significant advantage for large, modular applications.

In AB’s RSLogix 5000 version 16 and higher, reusable function blocks are called Add-On Instructions (AOI) and can be defined with interface parameters and local tags. Since this feature was only added in 2007, it is often overlooked and doesn’t fit as seamlessly into the overall environment.

Why use function blocks, you ask? You must read the DMC blog: “IEC 61131-3 Function Blocks – Unleash the Power!“

It is worth mentioning that both platforms adhere to the IEC-61131-3 standard, which means that function blocks are available and can be written in any of the standard’s languages.

Interfacing to an instance of a function block

The way you interface to a function block is critical for program efficiency, readability, and development time. The point of a reusable function block is to wrap up complex or repetitive code and make a simple and easy to use interface in order to use that code. For example, when I visit a fast food drive-thru, I don’t need to tell them how to make a burger. They have made billions before mine. I just want to give my order, watch my burger come out the window, and then be on my way.

In AB: Parameters in ladder have to be referenced independently from the function block call

If the function block instance is called in ladder, the input parameters can only be assigned with the block call if they are constants. Variable inputs must be assigned to input parameters in preceding ladder rungs. Outputs must be referenced in ladder rungs following the function block call. If calling the function block instance in FBD (function block diagram), then variables can be directly assigned to input and output parameters.

Disadvantage: More rungs of ladder to maintain. If called in FBD instead, then there are restrictions on instance declaration (see below) and simple Boolean logic is more complicated because you must use the FBD function boxes instead of contacts and coils.

In Siemens: Parameters are directly interfaced in both ladder and FBD

Function block instances that are called in ladder and FBD are essentially the same. Even in ladder, variables can be assigned directly to input parameters. Boolean input parameters can also be assigned to the result of ladder logic operations. Function block outputs can be assigned directly to variables in the same rung of ladder.

Note that function block input and output parameters can also be accessed symbolically from other rungs in ladder logic (just like the AB example above), but Siemens has the additional advantage of directly assigning input and output parameters in the same rung as the function block call.

Advantage: All input and output parameter assignment for a function block instance can be consolidated in one rung and not spread out on separate rungs or throughout the program.

Declaring an instance of a function block

In AB: Limited to program tag file. If using FBD, cannot reside in a UDT

Instances of AOIs are most commonly declared in the “Program Tags” file of a program folder. Even for very modular programs, all function blocks are listed in this one common location. Instances can be declared within UDTs (user-defined types), but not if you want to use them in the FBD environment.

Advantage: Simplicity. One location to look through for each program folder.

In Siemens: Memory resides in an instance data block, but is declared within parent function blocks.

Most program logic, not just reusable logic, is located within function blocks. “Parent” function blocks are assigned an instance data block. All reusable function block instances can be declared within the parent function block’s static memory.

Advantage: Modularity. Instances are declared within the function block that they are called.

Summary

In summary, Siemens seems to offer a little more flexibility in how function blocks are interfaced and instantiated. We have seen, however, that both Allen Bradley and Siemens offer solutions for reusable function blocks on their higher-end PLCs. Both Function Blocks in Siemens and Add-On Instructions in Allen Bradley will enhance the modularity and maintainability of your PLC program. Contact us to get started on your next PLC Programming project. 

Learn more about DMC’s Siemens PLC and Allen-Bradley PLC programming expertise.

The post Siemens vs Allen-Bradley: Function Blocks appeared first on DMC, Inc..