Those examples were "stateless", meaning that the operations depended only on the arguments passed to them (a and b in (a, b) => <expression>). In the real world, however, logic rarely exists in a vacuum. Functions often need context: thresholds, configuration values, or system parameters that aren't part of the function arguments themselves.

#include <iostream>

int main() 
{
    int scale = 10;
    
    // Capture by value (copy)
    auto scaleByValue = (int a, int b) { return (a + b) * scale; };

    // Capture by reference (observes changes)
    auto scaleByRef = (int a, int b) { return (a + b) * scale; };

    scale = 20;

    std::cout << scaleByValue(1, 2) << std::endl; // 30 (uses original scale = 10)
    std::cout << scaleByRef(1, 2) << std::endl;   // 60 (uses updated scale = 20)

    return 0;
}

1. Function blocks with state - storing context as member variables
2. Fluent interfaces - chainable methods that configure and return the function block

The fluent interface approach is particularly elegant, as it allows us to configure operations inline, similar to how we'd use closures in modern languages.

Approach 1: Direct Configuration

{attribute 'no_explicit_call' := 'calling this function block directly is not allowed'}
FUNCTION_BLOCK FB_SumIfInRangeFunction IMPLEMENTS I_BiFunction
    VAR_INPUT
        nLowerThreshold,
        nUpperThreshold : INT;
    END_VAR

    METHOD Apply : INT
        VAR_INPUT
            nA, nB : INT;
        END_VAR

        // Only add nB if it's within the range
        IF nB >= nLowerThreshold AND nB <= nUpperThreshold THEN
            Apply := nA + nB;
        ELSE
            Apply := nA;
        END_IF
    END_METHOD
END_FUNCTION_BLOCK

Example Usage

PROGRAM P_Example2_Direct
VAR
    arNumbers       : ARRAY OF INT := ;
    fbSum           : FB_SumIfInRangeFunction;
    nFilteredSum    : INT;
END_VAR

// Configure the thresholds
fbSum.nLowerThreshold := 10;
fbSum.nUpperThreshold := 20;

// Apply operation
nFilteredSum := P_Operations.Aggregate(arNumbers, fbSum);
// Result: 15 + 12 + 19 = 46 (8 and 23 are excluded)

Approach 2: Fluent Interface (Method Chaining)

A fluent interface allows us to chain method calls together, configuring the function block inline. The key is that configuration methods return a reference to the function block itself (THIS^), enabling multiple calls to be chained together.

INTERFACE I_GreaterThanCondition
    METHOD AnyGreaterThan : I_BiFunction
        VAR_INPUT
            nThreshold : INT;
        END_VAR
    END_METHOD
END_INTERFACE

INTERFACE I_LessThanCondition
    METHOD AnyLessThan : I_BiFunction
        VAR_INPUT
            nThreshold : INT;
        END_VAR
    END_METHOD
END_INTERFACE

INTERFACE I_InRangeCondition
    METHOD AnyInBetween : I_BiFunction
        VAR_INPUT
            nLowerThreshold, nUpperThreshold : INT;
        END_VAR
    END_METHOD
END_INTERFACE

{attribute 'no_explicit_call' := 'calling this function block directly is not allowed'}
FUNCTION_BLOCK FB_SumFunction 
IMPLEMENTS I_BiFunction, I_GreaterThanCondition, I_LessThanCondition, I_InRangeCondition
    VAR_STAT CONSTANT
        _nMIN_INT : INT := -32768;
        _nMAX_INT : INT := 32767;
    END_VAR
    VAR
        _nLowerThreshold : INT := _nMIN_INT;
        _nUpperThreshold : INT := _nMAX_INT;;
    END_VAR
    
    // Sets the minimum threshold (inclusive)
    // Values must be GREATER THAN OR EQUAL to this threshold
    METHOD AnyGreaterThan : I_BiFunction
        VAR_INPUT
            nThreshold : INT;
        END_VAR
        AnyGreaterThan   := THIS^;

        _nLowerThreshold := nThreshold;
        _nUpperThreshold := _nMAX_INT;
    END_METHOD

    // Sets the maximum threshold (inclusive)
    // Values must be LESS THAN OR EQUAL to this threshold
    METHOD AnyLessThan : I_BiFunction
        VAR_INPUT
            nThreshold : INT;
        END_VAR
        AnyLessThan      := THIS^;

        _nLowerThreshold := _nMIN_INT;
        _nUpperThreshold := nThreshold;
    END_METHOD

    // Sets the lower and upper threshold (inclusive)
    // Values must be BETWEEN these thresholds
    METHOD AnyInBetween : I_BiFunction
        VAR_INPUT
            nLowerThreshold, nUpperThreshold : INT;
        END_VAR
        AnyInBetween     := THIS^;

        _nLowerThreshold := nLowerThreshold;
        _nUpperThreshold := nUpperThreshold;
    END_METHOD

    // Resets the configuration so that all values are allowed
    METHOD Everything : I_BiFunction
        VAR_INPUT
        END_VAR
        Everything := THIS^;

        _nLowerThreshold := _nMIN_INT;
        _nUpperThreshold := _nMAX_INT;
    END_METHOD

    METHOD Apply : INT
        VAR_INPUT
            nA, nB : INT;
        END_VAR
        // Only add nB if it's within the configured range
        IF nB >= _nLowerThreshold AND nB <= _nUpperThreshold THEN 
            Apply := nA + nB;
        ELSE
            Apply := nA;
        END_IF
    END_METHOD
END_FUNCTION_BLOCK

Example Usage

ROGRAM P_Example2_Fluent
VAR
    arNumbers        : ARRAY OF INT := ;
    fbSum            : FB_SumFunction;
    nFilteredSum1,
    nFilteredSum2,
    nFilteredSum3    : INT;
END_VAR

// Configure and apply operations inline
nFilteredSum1 := P_Operations.Aggregate(arNumbers, fbSum.AnyLessThan(20));
// Result: 15 + 8 + 12 + 19 = 54 (23 is excluded)

nFilteredSum2 := P_Operations.Aggregate(arNumbers, fbSum.AnyGreaterThan(10));
// Result: 15 + 23 + 12 + 19 = 69 (8 is excluded)

nFilteredSum3 := P_Operations.Aggregate(arNumbers, fbSum.AnyInBetween(10, 20));
// Result: 15 + 12 + 19 = 46 (8 and 23 are excluded)

nSum          := P_Operations.Aggregate(arNumbers, fbSum.Everything());
// Result: 15 + 8 + 23 + 12 + 19 = 77 (all values are included)

Benefits of the Fluent Approach

Data Transformation & Mapping

// Transform raw ADC values to engineering units with calibration offset
fCalibratedTemps := P_DataTransform.Map(
    nRawSensorData,
    fbADCToTemp.WithOffset(nZeroOffset).WithGain(fCalibrationGain)
);

Filtering & Selection

// Select production batches exceeding quality threshold
nCount := P_DataFilter.Filter(
    arAllBatches,
    fbQualityCheck
        .AnyGreaterThan(nPremiumThreshold)
        .WithMargin(fSafetyMargin),
    arPremiumBatches
);

// Find active alarms above critical severity
nCount := P_DataFilter.Filter(
    arAlarmList,
    fbAlarmFilter
        .AnyGreaterThan(E_Severity.High)
        .IsActive()
        .NotAcknowledged(),
    arCriticalAlarms
);

Validation & Predicates

// Verify all safety sensors are within safe range
bSystemSafe := P_SafetyCheck.Every(
    arSafetySensors,
    fbSafetyValidator
        .AnyInBetween(nSafeMin, nSafeMax)
        .WithHysteresis(nHysteresisBand)
);

Sorting & Ranking

// Sort machines by efficiency, excluding standby units
P_EquipmentSort.Sort(
    arMachines,
    fbEfficiencyCompare.AnyGreaterThan(nMinEfficiency).ByDescending()
);

// Rank production runs by yield within quality band
P_BatchSort.Sort(
    arProductionRuns,
    fbYieldCompare.AnyInBetween(nMinQuality, nMaxQuality).ByYield()
);

Search & Analysis

// Find first sensor reading exceeding alarm threshold
ipFirstAlarm := P_DataSearch.Find(
    arSensorReadings,
    fbThresholdCheck.AnyGreaterThan(nAlarmThreshold).Confirmed(T#2s)
);

// Identify optimal batch by cost-to-quality ratio
ipBestBatch := P_BatchAnalysis.FindOptimal(
    arBatches,
    fbCostAnalysis.AnyGreaterThan(nMinYield).WithQualityWeight(0.6)
);

Statistical Aggregation

// Calculate weighted average excluding statistical outliers
fWeightedAvg := P_Statistics.Aggregate(
    arMeasurements,
    fbWeightedAvg
        .AnyInBetween(fMean - 3*fStdDev, fMean + 3*fStdDev)
        .WithWeights(arWeights)
);

// Compute RMS vibration in bearing frequency range
fBearingVibration := P_VibrationAnalysis.Aggregate(
    arFFTData,
    fbRMS
        .AnyInBetween(fBearingFreqLow, fBearingFreqHigh)
        .WithHanningWindow()
);

Many modern programming languages, like Rust, Java, Python, or C#, have what is known as first-class functions. These are functions that can be passed around just like variables, meaning they can be assigned to variables, passed as arguments to other functions, or even returned as values from functions. This flexibility allows for more dynamic and reusable code. This is the fundamental concept behind lambdas, closures, and anonymous functions, which are compact ways to define behaviour on the fly without needing to declare a full function or method. By embedding logic directly where it’s needed, they allow developers to write cleaner, more concise, and more modular code.

Here’s an example of an anonymous function in C# that reduces a list of numbers:

using System;
using System.Linq;

int[] numbers = {2, 1, 3, 5, 4};

// Using an anonymous function to sum the array
int sum = numbers.Aggregate((a, b) => a + b);

// Using an anonymous function to get the product of the array
int product = numbers.Aggregate((a, b) => a * b);

// Output: 15
Console.WriteLine(sum);

// Output: 120
Console.WriteLine(product);

In this example, the Aggregate method uses a lambda expression to define how two numbers should be combined, either summing ((a, b) => a + b) or multiplying ((a, b) => a * b) the values. The power here is that the Aggregate method itself is decoupled from the specific operation. It doesn’t care whether you’re summing or multiplying numbers. This makes the logic highly reusable and flexible, allowing the function to process data in different ways based on the behaviour you pass in.

Unfortunately, Structured Text (ST) doesn’t have first-class functions (sort of...), but we can still introduce some of these principles through functional interfaces. Although ST doesn’t support lambdas, closures, or anonymous functions, functional interfaces can give us a way to mimic some of this functionality.

What is a Functional Interface?

A functional interface is an interface that contains exactly one abstract method. This single-method contract allows for a concise and focused interaction between components, making it ideal for situations where you need to define a single behaviour or action. While functional interfaces can have other members like default methods or constants (these aren't supported in ST), they are designed around the core idea of one abstract method, ensuring they remain lightweight and purpose-driven.

Here's an example of a functional interface in Java:

@FunctionalInterface
public interface BiFunction<T, U, R> {
     R apply(T t, U u); 
}

This BiFunction interface represents a function that accepts two arguments (T  and U ) and returns a result (R). The Apply method is the single abstract method that makes this a functional interface.

Here's an example of using this interface:

import java.util.function.BiFunction;

public class Main
{
    public static void main(String[] args) {
        // Define a BiFunction that adds two integers
        BiFunction<Integer, Integer, Integer> foo = (a, b) -> a + b;

        // Invoke the BiFunction to add two integers
        Integer result = foo.apply(2, 3);

        // Output: 5
        System.out.println(result);
    }
}

In this example, we create a BiFunction to add two integers. The lambda expression (a, b) => a + b defines the behaviour, and the apply method calls the function with the specified arguments.

Application in Industrial Automation

In automation systems, functional interfaces can be used to define well-scoped behaviours that can be applied across different components or modules. By encapsulating specific functionality within a clear, single-purpose interface, functional interfaces help make systems easier to maintain, extend, and understand. This modularity also enables greater flexibility when it comes to introducing new behaviours or modifying existing ones without affecting the overall system.

In this section, I’ll walk you through a simple example that demonstrate the use of functional interfaces in Codesys/TwinCAT's implementation of the IEC 61131-3 Structured Text language. I’ll be replicating the aggregate function discussed earlier to perform operations like summing and finding the maximum in an array of numbers.

Define the Functional Interface

First, let's define the I_BiFunction interface that will serve as a blueprint for any function that performs an operation on two integers and returns an integer result:

INTERFACE I_BiFunction
    METHOD Apply : INT 
    VAR_INPUT 
        nA, nB : INT;
    END_VAR 
END_INTERFACE

This interface contains a single method, Apply , which takes two integers as inputs (nA , nB ) and returns an integer result.

Implement a Method that Utilises the Functional Interface

Next, we’ll create the P_Operations  program that contains a method called Aggregate. This method will iterate over an array of integers and apply the operation defined by the I_BiFunction interface to aggregate the values in the supplied array.

{attribute 'no_explicit_call' := 'calling this program directly is not allowed'}
PROGRAM P_Operations
    METHOD Aggregate : INT
    VAR_IN_OUT CONSTANT
        {warning disable C0228}
        arNumbers : ARRAY  OF INT;
    END_VAR
    VAR_INPUT
        ipOperation : I_BiFunction;
    END_VAR
    VAR
        i : __XINT;
    END_VAR

    // Exit the function call if the operation is not supplied.
    IF ipOperation = 0 THEN RETURN; END_IF

    // Initialise the result with the first element of the array.
    Aggregate := arNumbers;

    // Loop through the array and apply the operation defined by the interface.
    FOR i := LOWER_BOUND(arNumbers, 1) + 1 TO UPPER_BOUND(arNumbers, 1) DO
        Aggregate := ipOperation.Apply(Aggregate, arNumbers);
    END_FOR

    END_METHOD
END_PROGRAM

Explanation:

• The ipOperations  input parameter is an instance of the I_BiFunction interface, which defines the operation to be applied (such as summing or multiplying).

• The method initialises the result (Aggregate) with the first element of the array.

• It then iterates through the rest of the array, applying the operation (via ipOperations.Apply(...)) to the running result and each element of the array.

Implementing the Operations

Now, let’s implement specific operations by creating function blocks that implement the I_BiFunction interface. We will use these to perform different actions on the array elements.

Product Operation

{attribute 'no_explicit_call' := 'calling this function block directly is not allowed'}
FUNCTION_BLOCK FB_ProductFunction IMPLEMENTS I_BiFunction
    METHOD Apply : INT
    VAR_INPUT
        nA, nB : INT;
    END_VAR

    // Return the product of two values
    Apply := nA * nB;

    END_METHOD
END_FUNCTION_BLOCK

Maximum Value Operation

{attribute 'no_explicit_call' := 'calling this function block directly is not allowed'}
FUNCTION_BLOCK FB_MaximumValueFunction IMPLEMENTS I_BiFunction
    METHOD Apply : INT
    VAR_INPUT
        nA, nB : INT;
    END_VAR

    // Return the maximum of two values
    Apply := MAX(nA, nB);

    END_METHOD
END_FUNCTION_BLOCK

Example Usage

Now that we've defined the functional interface and its implementations, we can use the P_Operations program to apply different operations to an array of numbers.

PROGRAM P_Example1
VAR
    nProduct, 
    nLargest    : INT;
    arNumbers   : ARRAY OF INT := ;
    fbProduct   : FB_ProductFunction;
    fbLargest   : FB_MaximumValueFunction;
END_VAR

nProduct := P_Operations.Aggregate(arNumbers, fbProduct);
nLargest := P_Operations.Aggregate(arNumbers, fbLargest);

Real World Applications

// Transform sensor data through different conversion functions
fCelsius    := P_DataTransform.Map(nRawSensorData, fbADCToCelsius);
fFahrenheit := P_DataTransform.Map(nRawSensorData, fbADCToFahrenheit);

// Apply different operations to production batches
bAllPassed := P_BatchProcessor.Every(arQualityChecks, fbMeetsStandard);
bAnyFailed := P_BatchProcessor.Some(arQualityChecks, fbBelowThreshold);

// Filter arrays based on different validation criteria
// Filter(<source>, <predicate>, <destination>) -> <Count>
nCount := P_DataFilter.Filter(arSensorData, fbWithinTolerance, arValidReadings);
nCount := P_DataFilter.Filter(arSensorData, fbOutsideExpected, arOutliers);
nCount := P_DataFilter.Filter(arAlarms, fbHighSeverity, arCritical);

// Sort machine data by different criteria
P_DataSort.Sort(arMachines, fbByEfficiency);
P_DataSort.Sort(arMachines, fbByUptime);
P_DataSort.Sort(arMachines, fbByProductionCount);

The key advantage here is that the processing logic (Aggregate, Map, Filter, etc.) remains unchanged while the behaviour is completely customisable through different function block implementations.

Conclusion

Functional interfaces bring a powerful abstraction mechanism to Structured Text programming. While ST lacks first-class functions, lambdas, and closures, functional interfaces allow us to:

1. Decouple algorithms from operations: The Aggregate method doesn't know or care whether it's summing, multiplying, or finding maximums. It just applies the provided operation.

2. Increase code reusability: Write the processing logic once, then reuse it with countless different behaviors by simply implementing new function blocks.

3. Improve testability: Each operation is encapsulated in its own function block, making it easy to test in isolation.

4. Enhance maintainability: Changes to specific operations don't affect the core processing logic, and vice versa.

5. Create more expressive code: The intent becomes clear when you read P_Operations.Aggregate(arNumbers, fbProduct) versus a hardcoded multiplication loop.

While we've focused on simple, stateless operations in this part, functional interfaces become even more powerful when combined with context and state. In Part 2, we'll explore how to add context and capturing to our functional interfaces, allowing operations to carry configuration and state-mimicking the closure behaviour found in modern programming languages.

Probably a much simpler solution

This guide will walk you through the best Witch leveling build for PoE 2, offering a detailed look at skills, passive tree progression, gear recommendations, and general tips for efficient leveling. By following this guide, you'll be able to speed through the early stages of the game, progress quickly through Acts, and lay the foundation for an effective Witch build in the late game.

Overview of the Witch Class in PoE 2

The Witch is a powerful spellcaster who specializes in intelligence-based skills, manipulating elemental forces, summoning minions, and manipulating arcane energy. In Path of Exile 2, the Witch's versatility is one of her standout features. Her skill tree offers various paths, including Fire, Cold, Lightning, and Necromancy, which all provide unique playstyles for leveling and endgame content.

While other classes may focus on brute force or tanking, the Witch excels at dealing massive elemental damage, summoning hordes of minions to do her bidding, and providing versatile defensive mechanics through shields or energy. When leveling your Witch, your goal will be to balance damage output, survivability, and movement speed to clear content efficiently.

Choosing the Best Witch Leveling Build in PoE 2

When deciding on the best Witch build for leveling, it's crucial to pick a build that combines damage with speed to clear early content. While you can branch out into more specialized builds later in the game, starting with something that scales well throughout the acts will ensure you don't hit roadblocks in your progress.

Poe 2 trade was amazing. He made my deal go seamlessly. He was professional and friendly. Would absolutely buy from again! You can also purchase it at MMOEXP.com

MMOexp.com provides high quality and cheap D4 gold Softcore/Hardcore with fast delivery and 24/7 online. Welcome to buy Diablo IV gold/Items for sale to enhance your adven.

1. Kevin De Bruyne (OVR 91)

It's hard to discuss central midfielders in EA FC 26 without mentioning Kevin De Bruyne. The Belgian playmaker is a consistent performer in the game and is arguably one of the most complete midfielders in the game. With 91 overall, his vision, passing, and dribbling are exceptional, and he is a maestro in the middle of the park. De Bruyne's passing range is phenomenal, able to thread through balls to your forwards with pinpoint accuracy. His ability to dictate the tempo and create chances makes him a must-have for teams with ambitions of winning the league or even the Champions League.

In Career Mode, he's a great addition if you're looking for a player who can control the game and provide assists, though his age (32) and high price tag (around £60 million) mean he may be a more feasible option for bigger clubs rather than lower-league teams.

Key Stats: Passing 92, Vision 91, Dribbling 87, Stamina 77

2. Luka Modrić (OVR 88)

Luka Modrić is another seasoned veteran who is still a master in the central midfield role. Though he is now in his 30s (he's 39 in EA FC 26), his technical ability and vision remain top-notch. As a player, Modrić offers everything you'd want from a deep-lying playmaker. His ball control and passing are phenomenal, and he is able to transition play quickly from defense to attack with his incredible vision and decision-making.

Though his physicality has slightly decreased due to his age, his intelligence on the ball more than compensates for it. In Career Mode, you'll find him at a relatively low cost compared to De Bruyne, making him a viable option for teams looking to add experience and creativity to the midfield without breaking the bank.

Key Stats: Passing 91, Vision 88, Dribbling 86, Stamina 70

FC 26 coins serve as a virtual currency within the game. Players can use FC 26 coins to buy in-game items such as player packs, consumables, and other virtual. so you can buy FC FUT Coins at mmoexp.com

we’re currently running a TwinCAT 3.1 project (version 4026) with Git as our version control system, and we’ve run into a workflow issue that we can’t seem to solve.

Setup:

• 3 developers working in parallel

• Multi-PLC project (separate PLC task for each developer)

• One “main” development PC where the hardware configuration is activated

• Each colleague clones the project from Git and works on their PLC

• The goal is that all of us can be logged into our own PLC at the same time and perform Online Changes

The problem:

After the hardware config is activated on the main PC and we all pull the project from Git, TwinCAT refuses Online Change on the other machines.
We get an error saying that the mapping does not match or is invalid, even though nothing has been changed in the I/O configuration.

It seems like TwinCAT thinks the project is different from what’s running on the target, although everything (in theory) is identical – same commit, same configuration, same PLC code.

What we tried:

• Full rebuild on every workstation → no effect

• Deleting the .compileinfo, .tmc, and generated build folders before building → no effect

• Re-activating hardware locally on every PC → works, but then every developer ends up committing different hardware GUIDs to Git → merge chaos

• Using “PLC only” activation → same mapping error when trying Online Change

What we think is happening:

TwinCAT stores some hardware-related GUIDs / internal hashes locally, and after cloning the project, they don't match the target runtime, even if the code is identical.
As soon as one person re-activates the solution, the others can no longer do Online Change.

Question:

Has anyone found a clean workflow for multi-developer TwinCAT projects with Git, where multiple people can:

• clone the repo

• go online with their PLC

• do Online Change

• without everyone having to re-activate the I/O tree individually?

Is there a recommended “.gitignore” setup to avoid committing machine-specific files?
Or is TwinCAT simply not made for true parallel development with shared hardware config?

Any best practices, workarounds, or real-world experiences are highly appreciated!

Thanks in advance!

Note: English is not my native language, so I used ChatGPT to help write this post. Hopefully everything is understandable – feel free to correct me if something sounds unclear.

Did you try this ?

DateTime:= FILETIME64_TO_DT(F_GetSystemTime());

I have a very simple task that I am struggling with. 

I need to write systemtime to a var type DT.

I try using F_GetSystemtime(); but I can not figure out how to convert the UNLINT to DT. 

DateTime:= ULINT_TO_DT(F_GetSystemTime()) gives me a very strange result.