Introduction to Programming in PLC IDE with Finder OPTA

Guide to get started programming Finder OPTA in Arduino PLC IDE.

Overview

This tutorial offers an introduction to PLC programming in Arduino PLC IDE with Finder OPTA. Within this guide, you will discover which programming languages are compatible with Arduino PLC IDE and how to use them effectively.

What You Will Need

Before starting, make sure you have:

• Finder OPTA PLC (x1)
• USB-C cable (x1)
• Arduino PLC IDE correctly installed on your computer.

If you have not yet activated the license for the Finder OPTA device, follow this guide to complete the activation.

This tutorial assumes you are already familiar with some basic concepts covered in the guide “First Steps with Finder OPTA and PLC IDE”. If you have not yet consulted it, we recommend doing so before proceeding: it will provide the necessary foundation to better understand the steps described below.

The IEC-61131-3 Standard

The IEC-61131-3 standard defines a framework for PLC programming, allowing developers to write code in a uniform format, regardless of the hardware manufacturer.

IEC-61131-3 includes five programming languages that can be used individually or combined within the same project:

• Structured Text (ST)
• Instruction List (IL)
• Ladder Diagram (LD)
• Sequential Function Chart (SFC)
• Functional Block Diagram (FBD)

Arduino PLC IDE supports all these languages, allowing them to be combined in the same project and interact using shared variables.

We will see practical examples for each language type, implementing the same counter function in each language. Before doing that, we need to create the variables that we will use to implement the counter.

Preparing Variables and Watch

In this tutorial, we will use global variables so that we don't have to recreate them for each language. If you want to learn more about global and local variables, follow this guide.

For the counter function, we will use two variables: one to serve as the counter that accumulates the count value, and the other to serve as a constant increment:

• cnt: variable with initial value 0, used to hold the updated counter value.
• addition: variable with initial value 1; the Attribute field must be set to CONSTANT to indicate that the value is constant.

To add the variables, go to Project > Global_vars. Set the initial value of the cnt variable to 0 by clicking on the corresponding field.

To insert a new variable, right-click and select on Insert.

A new row will appear in the table; modify the following values:

• Name: addition.
• Type: INT, it must be of integer type.
• Init Value: 1.
• Attribute: CONSTANT, indicates that the value is constant.

At this point, save your changes by clicking the Save button at the top left.

To monitor the counter variable and understand if its value is increasing, we need to prepare the Watch. If you want more information about this tool, follow this guide.

Show the Watch section by selecting View > Tool Windows > Watch.

To add the variable to the Watch, drag the cnt element from the list of global variables into the Watch area.

Alternatively, click on Insert New Item and choose the cnt variable from the list of proposed variables.

This way, we will have the Watch ready to monitor the cnt variable and check if the programs downloaded to Finder OPTA are working.

Structured Text (ST)

Structured Text (ST) is a textual programming language similar to C, designed to implement complex logic in a readable and structured way. The code that implements a counter in ST is as follows:

cnt := cnt + addition;

This instruction updates the cnt variable by adding a constant (or variable) addition to its current value. Copy the code and paste it into the main entry in the tree menu under the Project section.

Next, compile the code using the Compile PLC project button at the top left.

Now connect to the device and download the code to Finder OPTA by clicking the Download PLC code button.

You will be asked if you want to proceed with resetting the variables; click Yes to confirm.

Open the Watch window to verify that the counter value is increasing correctly. If the value is not visible, click on Start/Stop Watch.

If the value of cnt increments, it means that the counting program written in ST has been loaded correctly onto Finder OPTA and is running without errors.

Instruction List (IL)

Instruction List (IL) is a compact textual programming language, similar to Assembly. It is particularly suitable for sequential operations and simple logic, using direct commands and linear syntax.

An example of a counter in IL is as follows:

LD cnt
ADD addition
ST cnt

In detail:

• LD cnt loads the value of the cnt variable onto the logic unit’s stack.
• ADD addition adds to this value the value of the addition variable.
• ST cnt stores the result back into the cnt variable.

Before proceeding, delete the previous program to avoid conflicts with global variables: right-click on the previously created program and select Delete program.

You will be asked to confirm the deletion; click Yes.

Now add the new IL program: right-click on the project name and select Add > New Program.

Set the language to IL and assign the program to the Fast task type to increase the program’s execution frequency. If you want to know more about how tasks work, follow the guide “First Steps with Finder OPTA and PLC IDE”.

Copy the previous code and insert it into the main_IL entry in the tree menu under the Project section.

Now compile the program by clicking the Compile PLC project button at the top left.

Connect to Finder OPTA and download the program to the PLC by clicking the Download PLC code button.

At this point, the program is running on Finder OPTA; check the Watch as done previously and verify that the value of cnt is increasing.

If the counter updates as expected, the IL program has been loaded and executed correctly on Finder OPTA.

Ladder Diagram (LD)

Ladder Diagram (LD) is a programming language based on lines and blocks, used to represent control logic visually.

In a Ladder Diagram, each line represents a virtual current flow that moves from left to right. The flow must pass through all intermediate blocks, such as logic gates (AND, OR), before reaching the right side, where a coil is located.

If the flow successfully passes through all intermediate blocks, the coil is energized, executing the associated action, such as closing a Normally-Open (NO) contact or activating a relay.

In our case, to write a simple counting function, the contact and coil components are not needed. We will use an ADD block to which we will connect the operand variables and the result variable.

First, delete the previously created programs as shown above and create a new one in LD language, assigning it to a Fast task type. The new program will appear as shown in the following image.

Now we need to add a logic block; to do this, go to the Library Tree section. If you don't see it, click View > Tool Windows > Library Tree. Click on Operators and blocks, then on Arithmetic, and you will see various types of logic blocks.

To add a block to your program, click on the desired block name (ADD in our case) and drag it onto the contact component on the left in the program. Alternatively, you can right-click and select New Block, filter by Operators, and select the ADD block from the list.

Once the block is added, delete the contact and coil components by right-clicking on them and selecting Delete; as mentioned before, they are not needed for our example.

At this point, you need to associate the variables with the function block pins. For the ADD block, the input variables are on the left side of the block, and the output variable is on the right side. To connect the variables to the pins, click on the desired pin; a window will open with a Browse button indicated by three dots.

From the list, choose the variable to associate with the selected pin.

Once the association is complete, your LD program should look like the screenshot below. Remember to associate cnt and addition as inputs and cnt again as the output.

Save the project.

Proceed to compile the program by clicking the Compile PLC project button at the top left.

Connect to Finder OPTA and download the code to the PLC by clicking Download PLC code.

Open the Watch and monitor the value of the cnt variable.

If the counter updates as expected, the LD program has been loaded and executed correctly on Finder OPTA.

Sequential Function Chart (SFC)

SFC is a language that allows writing PLC programs visually, following a flowchart-like logic. SFC programs are composed of blocks that perform specific operations, followed by transitions that determine when to move to the next step.

It is important to note that the SFC language cannot interact directly with the device’s outputs. To control the outputs, actions must be used, which are scripts written in other languages.

In this section, we will see how to write a counter in SFC. First, delete the previously created programs and add a new one by setting the language to SFC and assigning it to the Fast task.

Creating an Action

An action is a block of code written in another language—such as ST—that is executed when triggered by a step in the SFC diagram.

To create a new action, right-click on the new program entry and select New Action.

At this point, select the language of interest—in our case, we will use ST—and name the new action.

To access the code of the newly created action, navigate to the SFC program entry in the menu, expand the Actions entry, and click on the action name.

This way, you can insert the ST code you prefer; for our example, we will insert the same code we saw previously in the ST language section. Copy the following code and insert it into the program as shown in the image.

cnt := cnt + addition;

After inserting it, save the project.

SFC Program

An SFC program follows a precise sequence:

Step0 → Transition0 → Step1 → Transition1 → … → Jump

• A Step represents an action to be executed.
• A Transition indicates when to move to the next step based on the result of the previous action.
• A Jump is used to connect to another step in the diagram. If you want to create a loop, use a Jump to return to the initial step called Init.

Before starting, right-click and ensure that the Auto-connect option is enabled. This function allows you to automatically connect blocks after adding them.

To add a transition, right-click and select Object > New > Transition. Alternatively, you can use the SFC toolbar, which is shown by selecting View > Toolbar > SFC.

Connect the transition to the output of the Init block. Transitions are required after each Step block; for our example, a simple transition set to True is sufficient.

Now add a Jump block; this block allows you to reconnect the flow to an already existing block.

Associate the new block with the Init block to allow the program to start over again.

In action blocks, you can set two execution modes:

• Code P (Pulse): the action is executed only once each time the block is activated.
• Code N (Normal not stored): the action is executed continuously, on every PLC cycle, as long as the block remains active.

In our example, we will use Code N, so we can observe the constant increment of the cnt value. To set this mode, select the Init block, add or modify the action, and assign Code N to it.

At this point, save, compile the project, connect to Finder OPTA, and download the code to the PLC using Download PLC code.

Open the Watch and start monitoring the cnt variable.

If the counter updates as expected, the SFC program has been loaded and executed correctly on Finder OPTA.

Functional Block Diagram (FBD)

FBD is a language that allows writing PLC programs using a graphical representation based on function blocks. In FBD, there is no rigid sequential flow: blocks are executed simultaneously on each PLC scan cycle, based on the connections between inputs and outputs.

Each block represents a specific logical or mathematical function. For example, by adding an Add block, the addition operation is performed on each execution cycle.

To implement a counter in FBD is very simple. Start by deleting the programs created in previous steps and adding a new one to the project by selecting the FBD language and assigning it to a Fast task.

At this point, the steps are very similar to those seen in the Ladder Diagram section. Add an ADD block by dragging it from the Library Tree section or by using the right-click menu.

Associate the variables of interest as seen previously: inputs cnt and addition on the left side of the block, output cnt on the right side of the block. To do this, simply double-click on the block connectors. Once configured, the pins will appear as shown below.

Now save, compile the project, connect to Finder OPTA, and download the code to the PLC using Download PLC code.

Open the Watch and start monitoring the cnt variable.

If the counter updates as expected, the FBD program has been loaded and executed correctly on Finder OPTA.

Integration with Arduino Sketches

In addition to standard languages, PLC IDE allows integrating Arduino sketches, enabling the combination of PLC programming with C++ code. This integration occurs through shared variables, which allow communication between IEC-61131-3 code and Arduino sketches.

This way, it is possible, for example, to reuse existing PLC logic and enhance it with C++ code to implement advanced features. This approach allows expanding an existing system without having to redesign the basic logic.

In this section, we will see how to make an Arduino sketch communicate with an ST program. We will write a counter in C++ that communicates with the ST code so that we can verify that the variable updates correctly.

Delete the previously written programs, create a new one in ST language and assign it to a Fast task. It is necessary to add a shared variable that can be accessed by both the sketch and the ST program. Shared variables are divided into two types:

• Input: input variables are used to pass a value from the PLC program to the sketch and are accessible with the prefix PLCIn.
• Output: output variables are used to pass a value from the sketch to the PLC program and are accessible with the prefix PLCOut.

In this case, we will need to use an output variable that is updated by the sketch. To add an output variable, go to the Resources section, expand Shared variables, and select the Outputs entry. A blank list will appear; click the Add button and rename the newly added variable as follows.

Now let's write the C++ code that implements the counter logic. First, define a constant variable — addition_cpp — used as the increment. Inside the loop() function, update the shared variable cnt_cpp by adding the value of addition_cpp each cycle. Remember that shared output variables are accessible from the sketch via the PLCOut prefix. Also, include a 1-second delay in the loop, so that the increment of the variable is easily observable during monitoring.

Copy the code below and paste it into the Sketch page under the Resources section.

const int addition_cpp = 1;

void setup()
{
}

void loop()
{
    PLCOut.cnt_cpp += addition_cpp;
    delay(1000);
}

At this point, all you need to do is write a simple ST program that replaces the value of the global variable cnt with the updated value of cnt_cpp. Below is the code to paste into the program, following the procedure indicated in the ST language section.

cnt := cnt_cpp;

Save the project, compile it, connect to Finder OPTA, and download the code to the PLC. Then open the Watch and start monitoring the cnt variable.

If the counter updates as expected, the sketch has been loaded and communicates correctly with the ST program.

Adding a Library to the Sketch

As mentioned earlier, PLC IDE allows combining PLC programming with C++ code.

If you want to add a library to the sketch, go to the Resources tab and click on Libraries under the Sketch entry.

With the Sketch Libraries window open, click Add, and a new row will be added to the list. Enter the library name and version manually, which can be found in the library’s documentation. In this example, we add the ArduinoHttpClient library; the version number and its documentation can be found at this link.

Once the library is added to the project, simply include it in the code by clicking on the Sketch entry in the Resources menu and inserting the following line at the top of the code:

#include <ArduinoHttpClient.h>

In this way, the library is usable throughout the sketch code.

Note: currently, PLC IDE can only include libraries publicly indexed on the Arduino website.

Conclusion

In this tutorial, we explored the capabilities of Arduino PLC IDE with Finder OPTA, showing how to configure global variables and create sample programs in the five IEC-61131-3 languages (ST, IL, LD, SFC, and FBD). We also demonstrated how to integrate an Arduino C++ sketch via shared variables, thereby extending the PLC’s functionality with C++ code.