We’ve picked up some pointers while helping clients migrate their existing WinCC projects. These are our best practices for navigating that transition, with practical tips and tricks to make the process as smooth as possible.

Why Upgrade from Comfort to Unified?

Comfort is Phasing Out: As WinCC Comfort is gradually being retired, moving to WinCC Unified will ensure that your projects remain supported and functional.

Scarcity of Technology and Hardware: Comfort hardware will become increasingly rare, making upgrading worthwhile to maintain project viability and avoid future headaches.

While this blog isn’t a full-blown tutorial on WinCC Unified, it focuses on providing useful tips, tricks, and common pitfalls you might encounter when converting your projects. Our primary focus is on version 18 of Unified, though many of these insights are relevant for earlier versions like V16 and V17, which come with their own set of challenges, and also future versions.

Using the Data2Unified Conversion Tool

The Data2Unified Conversion Tool from Siemens is a great starting point for converting your projects. This tool handles about 50%-90% of the conversion process for you, depending on what elements are present in your project.

How to Use the Tool:

1. Install the Data2Unified Conversion Tool.
2. In Portal, ensure you’ve added a Unified panel to your original Comfort project.
3. Right-click on your Comfort panel in the project, find the Data2Unified tool in the context menu, and select “Start.” The tool will begin processing your project.

4. Once your project loads, you’ll choose what you want to convert. Be sure to select the Unified panel as your target. Update the file name and path if needed, and then click “Save file.” For larger projects, this process might take a while, so it can be a good idea to run it overnight.

Limitations to Keep in Mind:

• Basic Navigation: The tool often produces basic navigation outputs that may need refinement.
• Faceplates: These aren’t converted automatically, so they’ll need manual attention.
• Displays and Lists: Alarm lists, trend displays, graphic displays, and similar elements require manual adjustment.
• VBA Scripts: Review and convert these scripts manually if necessary.
• Artifacts: Be on the lookout for issues like blinking elements or rotated vertical text.

Advantages of WinCC Unified

1. Improved Navigation:

• Screen Windows: WinCC Unified allows you to design screens larger than your display and embed them in smaller windows, which automatically adds scroll bars. This feature helps keep your project organized and user-friendly. In the below example, notice the scroll bar at the bottom of the zone section that lets you slide between different zones.

• Consistent Navigation: Set up a main screen with different windows for the header, content, and navigation. This setup creates a cohesive user experience and makes navigation more intuitive.

2. Simplified Popup Architecture:

• Faceplate Popups: You can use scripting to open faceplates as popups. This reduces the number of screens you need and simplifies your project. However, if you need to handle multilingual text, be aware that the OpenFaceplateInPopup function doesn’t support text arguments in multiple languages.

Tips for Converting Faceplates

When moving faceplates from Comfort to Unified, direct copying won’t work. Here’s a step-by-step approach to make the conversion easier:

1. Copy Visual Elements: Move elements from the faceplate definition to a blank screen.
2. Run the Conversion Tool: Use the tool on this new screen to convert sizes, positions, fonts, and colors (all aesthetic properties).
3. Create a New Faceplate: Group select all objects from the conversion tool, and create a new faceplate.
4. Re-link Dynamics: Manually update dynamizations and tag linking.
5. Event Interface: Configure it as needed.

If your faceplates are complex, this approach can save a lot of time, as the conversion tool will handle all visual properties, allowing programmers to focus on quickly re-linking tags.

Leveraging JavaScript Scripting in Unified

WinCC Unified supports JavaScript, adding a new level of flexibility. You can use it to enhance screens, events, and object properties, making your HMI more powerful and customizable.

1. Nested Faceplates:

• Benefits: Nested faceplates allow for advanced graphics and cleaner architecture.
• Cautions: Avoid overusing nested faceplates and complex scripts to prevent performance issues. Efficiently manage variables and use Global Definitions to keep your code organized and avoid artifacts in the HMI simulator.

Additional Resources

For further reading and detailed guidance, check out these resources:

• SIMATIC WinCC Unified Tips and Tricks for Scripting (JavaScript)
• Data2Unified Tool Documentation
• “Getting Started with WinCC Unified”
• Developing Unified JavaScript with VSCode

Upgrading from WinCC Comfort to Unified might seem like a big task, but with the right approach and tools, you can handle the transition smoothly.

Are you looking to upgrade your existing systems to WinCC Unified? DMC’s team of Automation engineers have extensive experience and can help with conversions and migrations of any size. Contact us today to discuss your project needs.

The post Upgrading from WinCC Comfort to WinCC Unified appeared first on DMC, Inc..

This blog will demonstrate the best way to leverage the animations in FactoryTalk View ME to achieve these visualizations. More specifically, this blog will show tricks to animate parameters such as position, scale, and rotation in FactoryTalk View ME. We will use the example of a planet orbiting a star as a baseline for creating more elegant animations.

Desired Result

The planet is represented by the red and blue circle. The side of the planet closest to the star will be colored red to represent a higher temperature. The star, represented by a red circle, sits in the center. The dotted and dashed circle shows the desired path of the planet. Finally, the entire planet will have parameters for the width and height, so its appearance can be changed dynamically via the PLC. Images of the desired end result can be seen below. 

As the planet rotates, it will stay on the path of the orbit, and the red part of the planet will follow the star. The planet's width and height can also be dynamically controlled via the PLC to effectively stretch it. 

To achieve this effect, every parameter will be calculated and controlled by the PLC. In this example, the position will be calculated in terms of pixels for both the x and y coordinates. To maintain consistent units, this article will employ a trick to convert the scale (usually in terms of percentage) to pixels as well. This will make it easier to design the HMI more precisely. For example, a width of 50 will correspond to 50 pixels across instead of a more arbitrary 50% by default. 

Getting Started

To start, create a star in the center of the screen. In this case, the screen has a resolution of 800 pixels across and 600 pixels high. Because the anchor point of the ellipse is at the top-left corner and not the center, the coordinates must be shifted accordingly. The circle is shifted half the diameter, 25 pixels in this case, up and to the left. This is because HMIs have their origin in the top-left corner of the screen where the +x direction is to the right and the +y direction is downward. This results in an offset as shown below. 

A second circle can be added to show the path of the planet. In this case, the orbit outline will have a diameter of 200, or radius of 100 to keep the math simple. To achieve the same aesthetic as shown in the example, the Back style is set to Transparent, and the Line style is set to Dash-Dot. 

Adding the Planet

Now that the stationary background has been set up, it is time to add the planet which will be animated. Add a circle to the HMI that will represent the planet. Assign a height and width of 100 so that 100% scale corresponds with 100 pixels. This will be helpful when changing the scale from the PLC, as the percentage values will directly correspond with their width and height in pixels.

Next, remove any positional offset by setting both the top and left position to 0. The animated position will be controlled by the PLC, so any non-zero number in the HMI's position field will add an extra offset. With the position and scale normalized, it becomes much easier to control the appearance of the circle from calculations in the PLC.

At this point, a gradient can be added to the planet. In this example, a vertical gradient with red and blue colors is chosen to indicate which side of the planet is closest to the star. 

The PLC Program

Now, transitioning to the PLC program, it is time to create parameters to control the animations on the HMI. Because the planet is going to orbit on its own with time, variables are created to increment each scan of the PLC as seen below. 

This tag “r_inc” will be used to calculate the x position, y position, and rotation so that they all move in sync. Because the planet will be orbiting in a circle, SIN and COS can be used to calculate the planet’s position over time. Do this by adding CPT instructions for the x and y positions. 

In both equations shown above, the first term represents the distance to the exact middle of the screen; in this case 400 pixels in the x-direction and 300 pixels in the y-direction. The second term is added to make the ellipse oscillate back and forth.

The trig functions are multiplied by 100 to make the ellipse oscillate 100 pixels in either direction. Finally, the third term is used to shift the ellipse up and to the left based on the width and height. As mentioned before, ellipses in FTView have their anchor points at the top-left corner, so the ellipse must be shifted to put its center on the orbiting path.

By using variables for the width and height, "r_width" and "r_height" in this case, the ellipse can be stretched during runtime while maintaining its orbiting position. 

One final rung is used to calculate the angle of the ellipse as it travels around its orbit to keep the red side of the gradient facing the center star. Because "r_inc" was directly inputted to the trig functions to calculate the x and y positions, some conversions are required to determine the angle. This is because the trig functions take in Radian values, but the HMI expects a rotation in degrees.

A modulus instruction (MOD) is added first. This will constrain the rotation to 2 PI radians (1 full rotation), which will be helpful when configuring the position in the HMI. FTView will expect the angle as a range with a minimum and maximum value. In the example below 6.283 is used to approximate 2 PI.

Next, a compute instruction (CPT) is added to convert the new constrained Radian value to degrees. This concludes the PLC program. 

Animating the Planet

Now it is time to animate the planet in FTView ME. To do so, right click on the planet and navigate to "Animation" > "Horizontal Position…" .

In this window, select the tag that will be used for the x coordinate. 

For the expression range, select "Use constant" and enter minimum and maximum values that include all potential positions. In this case, -100 is used as the minimum because the planet shouldn't be 100 pixels to the left of the screen. 900 is selected for the max value because it is 100 pixels to the right of the screen (which has a width of 800 pixels). Now enter the same minimum and maximum values respectively for the horizontal offset. This will prevent the values from scaling and moving unexpectedly, resulting in PLC coordinates that correspond with pixels. 

Then, navigate to the "Vertical Position" tab and follow the same format. Here, the maximum value is set to 700. The screen has a height of only 600, so this allows for objects to move 100 pixels below the screen. 

Now, navigate to the "Width" tab. Link the width tag, "r_width". Then, set the min. and max. expression range to 0 and 100 respectively and match the horizontal change (percent). Again, making these match, coupled with the ellipse having dimensions of 100×100, ensures that the PLC value corresponds with exact pixel values. Finally, make sure to select "Left" for the anchor point to match the math done in the PLC. This anchor point determines where the ellipse scales from. 

In the "Height" tab, follow the same steps. For the anchor point, select "Top". 

Finally, for the rotation, set the expression range and rotation (degrees) bounds to -100 and 1000 as shown below. The actual value in degrees is bound between 0 and 360 due to the modulus instruction in the PLC, but having the extra wiggle room will not cause any problems. The center of rotation can be left at the center position. 

After applying these animations, all that is left to do is to run the PLC and HMI. Once both are running, the planet should begin orbiting the star, following the orbit path. Changing the width and height of the planet should also automatically adjust the position. 

Other Applications

While the example above shows how to make a planet orbit a star, the same concepts can be used to show the position of a pallet on a track, the position of a machine part, and much more.

For more complex examples, piece-wise functions can be used for more refined motions. For example, let's explore a pallet moving on a pill-shaped track with two straight sections and two curved sections as shown in the image below. 

If each straight section and curved section of track has a unique section number and the position of a pallet along a given section is known, then it is possible to calculate a pallet's location from the track section number and track position. In this example, a case statement can check what section of track the pallet is on. The sections and positions can be seen below.

Note: The positions are arbitrarily represented as a value from 0-100. Actual hardware may return a distance from the start of the track section.

If the pallet is on a straight section of track, then only the horizontal position will need to be animated with the vertical position set at a fixed location. If the pallet is on a curved section of track, the pallet position will be based on sinusoidal functions, similar to what was demonstrated with the orbiting planet example.

Once this math that converts track sections and positions to x and y-coordinates is set up, a global object can be created in FactoryTalk View ME to represent the pallet. This pallet, with the underlying math, can then be duplicated for every physical pallet in the system.

Overall, animating objects on an HMI can make a machine’s operation clearer. This insight can be used for faster operation and easier control. 

Learn more about DMC's expertise in Rockwell FactoryTalk and contact us for your next project.

The post Animation in FactoryTalk View ME appeared first on DMC, Inc..

I recently got to work on a project programming a 7-station inspection and filling machine using a Keyence PLC and HMI. The project involved motion control, vision, and interfacing with a variety of IO. Here are some things I learned along the way that might help you get started programming with Keyence’s KV Studio.

KV Studio is Keyence’s PLC programming software. While Keyence offers a variety of PLCs, this article will focus on their KV-8000A PLC (Figure 1).

Figure 1

To get started, open KV Studio and hit File > New Project in the top left corner.

Figure 2

In the resulting popup, enter a project name and select the PLC model. In this example, we will use the KV-8000A.

Figure 3

After hitting “OK”, a new popup will ask if you want to automatically set the operation recorder setting. This feature can be helpful for debugging logic, but will not be covered in the scope of this blog. Hit “Set later”, and then hit “Yes” in the new “Setup unit setting info now” popup. This will bring up the Unit Editor window, where the hardware configuration is shown. Here, we can see the PLC that we added to the project, modify device settings such as IP addresses, and add new units such as IO units.

Figure 4

This article will focus on programming of the PLC, so hit “OK” to close the Unit Editor. The resulting window is where the programming will take place. Explanations of the different window areas can be found on page 45 of the version 11 user manual.

Getting started 

When creating a program from scratch, navigate to the “Program” section of the project tree. Right click on “Program” and click “New” to create a new routine. The following window should pop up, allowing further specification of the program name and type. 

Figure 5

After creating routines, right click on “Program” again and select “setup module execute sequence” to specify the order that the routines should run in a given scan. 

There is also a section in the project tree called “Function Block” that allows users to create reusable logic. To do this, right click on this field and hit “New.” In the resulting popup, specify the type of program. Common options are functions and function blocks. The main difference between these two options is that function blocks have internal memory, while functions do not. The internal memory in function blocks allows for instructions such as timers to be used that operate over multiple scans. 

To start adding logic, expand the “Program” section in the project tree and double click any of the programs, functions, or function blocks. This will open a grid editor where logic can be added. After highlighting any cell, it is possible to type in a Rockwell instruction acronym followed by the required parameters for said instruction. Keyence will automatically interpret this text (as seen in Figure 6) and insert the correct instruction into the project (as seen in Figure 7). This can be seen in the image below with instructions such as XICs.

Figure 6

Figure 7

Instructions such as OSR in Rockwell (as seen in Figure 8) get interpreted by Keyence as DIFU, Differential Up (as seen in Figure 9). 

Figure 8

Figure 9

If an instruction in KV Studio appears to act differently than an instruction in Rockwell, highlighting the instruction and hitting F1 will bring up a help document explaining the instructions function. 

Double clicking a cell also brings up more options to search for instructions via the Instruction pallet window. The bottom of this window contains a ‘Help’ button, which further sorts the instructions. 

Figure 10

To complete a rung, the following buttons can be used to create or remove vertical or horizontal connections. 

Figure 11

Some logic such as For loops, While loops, and math expressions, are easier to create with structured text. This can be added by right clicking on a cell and selecting one of the following boxed options. 

Figure 12

The area type will fill an entire row as seen in example 1, while the box type works in line with a network as seen in example 2. 

Figure 13

Helpful Hotkeys and Buttons

• Ctrl + Enter adds a comment. 

  • Ctrl + Enter/Esc can be used to finalize comments (rather than creating a new line with the Enter key).

• bShift + Enter adds new blank rung.

• Ctrl + Tab extends rung connection to the end of the page. 

• F11 pushes changes to simulator or PLC. 

• There are two ways to edit parameters for an instruction:

  • Double clicking-brings up a large menu.

Figure 14

• Hitting Enter brings up a more concise menu.

Figure 15

• Ctrl + Space will show and hide tag comments. 

• When highlighting an instruction, hitting "/" can behave in the following two ways:

  • It can change the datatype the instruction expects. For example, if an ADD instruction is selected, hitting "/" will cycle between the following types:

Figure 16

• It can also change the instruction itself (such as turning an XIC to an XIO).

• Ctrl + Q can be used to disable rungs, which essentially comments them out, while Ctrl + W can enable rungs. Disabled rungs show up as dotted lines. 

• Compile code by hitting "Convert."

Figure 17

• Ctrl + Shift + F8 creates a loopback ladder (Figure 18). 

Figure 18

In the above example, the tag “example” is red because it hasn’t been initialized yet. To initialize this so the code will compile, right click on the tag and hit “Register to local variable(1)” or “Register to global variable(2).”

Figure 19

Now that the tag has been created, it is possible to find the tag in the Variable table (where the tag can also be created).

Figure 20

Program Modes

Editor Mode

When developing code independently, it is easiest to do so in editor mode. You can change the modes from the following input field in the tool bar: 

Figure 21

When working in Editor mode, it is not necessary to be connected to the PLC.  

Selecting “Monitor” will connect the user to the PLC. If there are differences between the PLC project and local project, KV Studio will ask the user to Read from the PLC, Transfer to the PLC, or Verify changes. Reading from the PLC will overwrite the local project copy with the PLC project. Transferring to the PLC will overwrite the PLC project with the local project. Finally, verifying changes will allow the user to selectively read and write individual routines. The option to verify changes can also be found in the following menu:

Figure 22

After going online with the PLC, a prompt will appear with regards to recording the PLC real-time changes. This feature can record the moments before and after a tag change and store them on an SD card in the PLC. This feature is helpful for debugging, which can be seen in the Replay mode, where users can view PLC bits on a scan by scan basis.

Online Edit Mode

Online edit mode allows the user to make changes to the PLC program while online with the PLC. If multiple users are online editing logic, they should avoid modifying the same routines. This will make the verify/synchronize process much easier. 

Simulator Mode

The simulator mode can be used to test logic without being connected to a PLC by simulating the effects of running the logic on a PLC. Thus, simulator edit mode is similar to online edit mode.  

Learn more about DMC’s PLC Programming services and contact us for your next project. 

The post Tips and Tricks for Programming with Keyence KV Studio  appeared first on DMC, Inc..