Data processing processes
You do not need to know programming languages to create processing processes on your own and extract from that data most important to you and your production plant. The ETL (Extraction, Transformation and Load) wizard will help you, in which you can create process on your own (or with the support of our experts) using elements (the so-called processing nodes) that operate on the basis of drag & drop. You can also use ready-made templates built into the IPLAS system.
After starting the process from the incoming industrial data streams, you will receive what is most important to you – knowledge that will allow you to improve production in your plant. This is where you can create an individual alarm and notification system, verify and aggregate data. What if at some point you find that you would like to analyse something else in one process? Absolutely no problem! You can flexibly modify it. See how it works.
Example of building ETL process
See how we have built a simple ETL process that generates and consecutively saves to the database the totals of manufactured items as part of a shift for a specific machine.
A few words of explanation for the video above:
- Input data
- Used nodes and their application
- Effect
Variable with the number of items produced in certain periods.
Node 1. Input channel, specifies the input data and the source thereof, transfers the variables on the basis of which the rest of the processing is created.
Node 2. Time stamp, the user specifies additional variables based on the frame generation time. The node adds time variables to the processing.
Node 3. Work shifts, the working hours of individual shifts are determined therein, and the result variables that relate to them are selected. Generates new variables that allow you to specify change data.
Node 4. Grouping, selecting the type of aggregation and grouping variables that divide data into certain groups, e.g. the sum of variable values for the given shift numbers.
Node 5. Output table, here you define the database, destination and assign variables to specific columns. Based on the data stored in the database, analyses are generated.
The result is the processed values in the database that are needed to create the analysis. The data presents the sum of the items produced for each shift.
The data generated by the ETL process can be presented in the analysis, which was shown in the video.
Documentation
In the graphic ETL wizard, you select and then drag elements to the workspace from which you create your own data processing. All these “blocks”, “squares” or whatever else you define them, are called processing nodes. They can be divided into 4 categories by action: input nodes, filters, transforms, and output nodes. Below you will find a description, available options and an example of how to use each of them. If something is still unclear, please do not hesitate to write to us: iplas@spiid.pl.
- Input nodes
- Filters
- Transformations
- Output nodes
Input nodes (Input channel) are responsible for introducing input variables to the processing process.

Input channel
DESCRIPTION:
The “Input Channel” node is used to introduce frames with variables to the processing. It allows you to select the installation, channel and specific variables. The node is required for all processing.
EXAMPLE OF APPLICATION:
In order to correctly configure the “Input channel” node, in the first step, select the installation, in this case “Production_lines” and the channel, e.g. “Line_no._1”. Then it is required to select the variables needed by the user in the further processing, here – Pieces and Product_code. After saving the configuration, the frames with the variables Pieces and Product_code will be sent to the next node.
OPTIONS:
Name | Description |
---|---|
Installations | Logical mapping of the location where connections are established between a data source (e.g. a PLC controller). |
Channel | Connection between the data source and the installation on the IPLAS server through which the data is transferred. |
Frames | Not listed in the node. The data is sent for processing using frames containing variables with specific values. |
Variables | Processing elements that store specific values. Frame components. |
Filters (Last Frames, Required Values) allow you to keep only the current data, optimize processing.

Required
DESCRIPTION:
The “Required” filter allows you to specify the variables that determine the passing of data to subsequent nodes.
Any data frame with missing values in the required columns (in any specified variable) will be rejected by the filter. This denotes that the entire frame will not be passed on to the next nodes.
In the node configuration it is possible to reverse the described operation. In this case, frames in which no values have been specified for the required variables will be forwarded to the next processing nodes.
EXAMPLE OF APPLICATION:
If we set the required variables A and B in the filter, then any frame that will not have the specified value of A or B will be rejected by the filter. Its value or its absence in the C variable will not affect the filter performance.
Turning on the reverse mode will cause that each frame without the specified value of A and B will be transferred to the next node. Otherwise, it will not be passed on. Its value or its absence in the C variable will not affect the filter performance.
OPTIONS:
Name | Description |
---|---|
Input variables | If we select a variable that will send data, the filter will allow all other variables to pass to the next block. Otherwise, it will not miss any value. |
Reverse mode enabled | A checkbox used to reverse the situation – the block will forward the variables only if the selected variable has no value. |

Old frames
DESCRIPTION:
The “Old Frames” filter allows you to filter frames based on the frame lifetime specified by the user in the node configuration. If the time difference between the current clock time and the time stamp of the frame being processed is greater than the frame lifetime given at the node, the frame will be discarded.
The essence of the “old frames” filter is to pass only the current frames. The filter is used wherever it is necessary to visualize current data. An example of use can be a gauge which shows the temperature of the furnace at a given moment. Then the data from ten minutes ago is not relevant to illustrate the analysis of this reading.
EXAMPLE OF APPLICATION:
Old frames with variables A, B, and C will be forwarded to subsequent processing nodes only if they are not older than the current time by more than one minute.
OPTIONS:
Name | Description |
---|---|
Input variables | Only those frames for which the difference between them and the current time is less than the “frame lifetime” will be forwarded to the next processing node. |
Frame lifetime limit | Text field specifying the maximum time difference between the current and previous frame in a specific unit of time. |
Definition of the unit of time | Millisecond, Second, Minute, Hour, Day |

Last frames
DESCRIPTION:
The “Last Frames” filter allows you to filter out the number of frames specified in the node configuration. From the frame packet that go to the node, the user defines the number of the most recent frames to be transferred to the next processing nodes.
The filter also has the option to activate or deactivate – the “Filter enabled” checkbox.
The filter is used to optimize the processing. It allows you to limit the amount of data on which we operate in the processing process in order to increase its efficiency.
EXAMPLE OF APPLICATION:
Only the last 15 frames with the variable A will be forwarded to the next node. If we uncheck the “Filter enabled” checkbox, the filter will be deactivated and all frames will be forwarded. The filter is used in processing used to feed analyses presenting the current situation, e.g. a meter showing the current temperature.
OPTIONS:
Name | Description |
---|---|
Last frames | The number of frames that are passed to the next processing node |
Input variables | Activates or deactivates the filter |
Transformations (Grouping, Determining Increments), process data, generate new variables on the basis of input variables.

Heartbeat generator
DESCRIPTION:
The “HeartBeat Generator” node is used to maintain information about the processing activity. In the case where data frames appear infrequently, the node generates frames with no variable values. The configuration should define the delay – the time interval between the present time and the moment of generating the frame, the interval – the time interval between the generated frames, the unit for which the delay was defined, and the interval. Additionally, you can select the “Adaptive delay” option, which will allow you to automatically adjust the delay size based on the data about the frequency of appearance of subsequent data frames, the delay will never be smaller than that specified by the user.
“Failmode” – In the event that frames containing data arrive with a delay greater than the predicted delay for generated heartbeats (empty frames), processing will stop. With this option disabled, the processing will continue, but the frame generation times will be artificially changed in order to keep the chronology of the readings.
EXAMPLE OF APPLICATION:
In the example shown, a Delay of 5, an interval of 1 and a unit of minute are defined. This denotes that when no frame has appeared in the last five minutes, the node will generate an empty frame with the generation time delayed five minutes from the current time. It will do this every minute, unless a data frame is provided for processing. Then the cycle will start all over again.
Checked “Adaptive delay” option will affect the time of generating frames without value. As an example, empty frames will start to appear no earlier than 5 minutes after the last frame containing a value appears. The function will cause that in case of greater delay in data delivery, the waiting time for late frames will be longer, then when they start arriving in a shorter time, the adaptive delay will gradually shorten to the user-defined delay value.
If the “failmode” option is selected, the processing will stop if there is a problem with determining the chronology of data frames and empty frames. Such a situation may arise when, for some reason, data frames are delivered with a delay greater than the scheduled empty frame generation delay time.
OPTIONS:
Name | Description |
---|---|
Delay | Integer, the time at which empty frames are to be generated relative to the current time, the time unit is selected in the unit section. |
Adaptive delay | Functionality that allows to automatically extend or shorten the delay in relation to the current time, depending on the delay with which the frames are delivered. This delay will never be less than the user-defined delay. |
Interval | The time interval between generated frames, the time unit is selected in the unit section. |
Failmode | It stops processing if there is a problem with determining the chronology of the frames. |
Unit | The unit of time within which the interval and delay were given. The available units are: millisecond, second, minute, hour, day. |

Grouping
DESCRIPTION:
The “Grouping” node allows to designate new variables based on the input variables in some user-defined groups, for example days/months/production line. For the correct configuration of the node, at least two variables are needed – aggregate and grouping.
EXAMPLE OF APPLICATION:
According to the example given, 4 variables will be transferred to the next node. Variables AVG, COUNT, MAX and hours. The AVG, COUNT, MAX variables will be calculated for specific values of the variable hour. This denotes that the values of the variables will change within each hour (this results in a separate mean/sum/different type of aggregation for each hour).
OPTIONS:
Name | Description |
---|---|
Input variables | A node needs at least two input variables – for aggregation and for grouping. The user selects the input variable, then the aggregate function and the name of the resulting variable to be derived from the input variable. |
Aggregation | The user selects the input variable, then the aggregate function and the name of the resulting variable to be derived from the input variable. |
Average | It counts the average of the incoming variables in the frameset, the result variable is always a floating-point number. The function is available when the data type of the variable is an integer or a floating-point number. |
Count | It counts the number of incoming frames in the package. The result variable is always an integer. Available for any type of data. |
First value | The outgoing frame contains the first variable value that was received in the frameset. The result variables will be of the same data type as the input variables. |
Last value | The outgoing frame contains the first variable value that was received in the frame packet. The result variables will be of the same data type as the input variables. |
Maximum value | The outgoing frame contains the largest variable value in the delivered frame package. For text, the first value in alphabetical order is the largest value. The function is not available for input variables with logical value and array data types. |
Minimum value | The outgoing frame contains the smallest variable value in the delivered frame packet. For text, the last value in alphabetical order is the smallest value. The function is not available for input variables with logical value and array data types. |
Sum | It adds the values of incoming variables in a frame packet. The result variables will be of the same data type as the input variable. The function is available for variables of the integer and floating-point data types. |
The most common | The most frequent variable values in an incoming frame packet. Available for all data types. |
Grouping variables | Variables on the basis of which the grouping will be performed. They cannot be variables used for aggregation. |

Calculator
DESCRIPTION:
The “Calculator” node allows to perform calculations, process information or create new variables, which is why it has many applications.
EXAMPLE OF APPLICATION:
the input variables table allows to see all incoming variables in the frames and their data types.
AVAILABLE FUNCTIONS OF CALCULATOR:
The available functions of the calculator are a table containing ready-to-use functions in the “Formula definition area”, which, after selecting, can be placed at the cursor position using the “insert” button without the need to copy.
Math functions:
- math: round (value, scale) – rounds a number by the specified number of decimal places,
- math: power (value, exponent) – increases the number by the given exponent value.
Variable type conversions:
- string: toString (input) – converts a given numeric value to a text value,
- array: toString (array, separator) – converts an array to text,
- array: toJSON (array) – converts an array to JSON,
- array: toArray (string) – converts a text variable to an array of strings using the default separators “,;”,
- array: toArray (string, string) – converts a text variable to an array of strings using the given separators,
- array: toArray (string, separators, trimTokens, string) – converts a text variable to an array of strings using the given separators,
- date: parseDate (dateString, pattern) – returns the date created from a text variable according to the specified date format,
- date: parseTimestamp (timestampString, pattern) – returns a timestamp composed of a text variable according to the given format.
Operations on time variables:
- date: addDaysToDate (date, numberOfDays) – adds the number of days to the given date,
- date: addDaysToTimestamp (timestamp, numberOfDays) – adds the number of days to the given time stamp,
- date: addHoursToTimestamp (timestamp, numberOfHours) – adds the number of hours to the given time stamp,
- date: addMinutesToTimestamp (timestamp, numberOfMinutes) – adds the number of minutes to the given time stamp,
- date: addSecondsToTimestamp (timestamp, numberOfSeconds) – adds the number of seconds to the given time stamp,
- date: getYear (timestamp) – returns the year from the given timestamp,
- date: getMonth (timestamp) – returns the month from the given timestamp,
- date: getWeek (timestamp) – returns the week number from the given timestamp,
- date: getDay (timestamp) – returns the day from the given timestamp,
- date: getHour (timestamp) – returns the time from the given timestamp,
- date: getMinute (timestamp) – returns minutes from the given timestamp,
- date: getSecond (timestamp) – returns seconds from the given timestamp,
- date: getYear (date) – returns the year from a given date,
- date: getMonth (date) – returns the month of the given date,
- date: getWeek (date) – returns the week from a given date,
- date: getDay (date) – returns the day from a given date,
- date: truncateToDate (timestamp) – cuts the timestamp to date format,
- date: toDate (timestamp) – converts timestamp to date,
- date: diffTS (ts1, ts2) – calculates the time difference in milliseconds between the given time stamps,
- date: diffTSWithWeeklyBreaks (ts1, ts2, exclusionArray) – Calculates the time difference in milliseconds between the given timestamps, not including weekly breaks.
Time Variable Conversion Functions:
- date: formatDate (date) – converts date to text using the “yyyy-MM-dd” format,
- date: formatDate (date, format) – converts date to text using the specified format,
- date: formatTime (timestamp) – converts the timestamp to text using the “HH: mm: ss” format,
- date: formatTimestamp (timestamp) – converts timestamp to text using the format “yyyy-MM-dd HH: mm: ss”,
- date: formatDate (timestamp, format) – converts timestamp to text using the given format,
Data estimation:
- prod: estimateQty (startTime, endTime, actTime, soFar) – estimates the number of pieces produced after the specified period of time,
- prod: estimateEndTime (startTime, actTime, expectedQty, actualQty) – estimates the production end time,
- prod: avgProductionSpeed (startTime, endTime, quantity) – Estimates the average production speed in [pieces/hour].
Functions related to dictionaries:
- dict: checkKey (dicionaryId, key) – checks if the specified key exists in the dictionary,
- dict: get (dicionaryId, key) – returns the name for the given key,
- dict: get (dicionaryId, key, defaultValue) – returns the name for the given key, or the given default value if such a key does not exist in the dictionary.
Inserting special characters:
- string: cr () – returns “\r” (carriage return),
- string: lf () – returns “\n” (line feed),
- string: eol () – returns “\r\n” (end of line).
Base64 coding:
- string: encodeBase64 (string) – encodes a text variable to base64,
- string: decodeBase64 (input) – decodes base64 to a text variable type.
PROGRAMMING LANGUAGE:
The calculator programming language is similar to Java with a few exceptions:
- When defining a new variable, its type should not be given, the calculator automatically assigns its form.
- Do not use line break (eol)
- Available math operations: addition (“+”), subtraction (“-”), multiplication (“*”), division (“/”), and the remainder of the division (“%”). Note that the character “^” is not exponentiation, but a logical xor!
In the calculator, you can use short if (“condition? True: false”), but remember that the variables used must be defined in the previous nodes and are located in the “input variables” table.
In the above example, we can see the use of such an expression, if the number ofPulses will be equal to 10 then theText variable = “true”, if not theText variable = “false”
OPTIONS:
Name | Description |
---|---|
Input variables | The node forwards frames with input variables, making changes to them or adding user-defined variables (in a Java-like programming language). |
Result name | The name of the variable resulting from processing in the node. It must be unique throughout the processing. Otherwise an existing variable with this name will be overwritten. |
“Show” button | Expands the table containing the available functions for use. |
“Insert” button | It allows the functions from the table to be placed on the “Formula definition field” without copying. |
“Hide” button | Hides the table of available functions to facilitate the use of the calculator. |

Merge
data streams
DESCRIPTION:
The node “Merge data streams” requires connecting two nodes with different input variables to work properly. It connects the frames based on the first input. This allows, for example, to save two parallel processing operations to one result set. The names of the input variables in individual processes must be different from each other.
EXAMPLE OF APPLICATION:
Based on the first input, the node will generate frames containing columns from the second input. That is, when a frame from the second input is delivered and the frame from the first input cannot be matched to it, that frame will be skipped. Frames containing columns from both inputs will be passed as output variables.
The figure below presents three situations showing how frames with data from two inputs can be generated.
In the first case, the frames from both inputs arrive at similar time intervals, however, the frames from the second input are slightly delayed with respect to the frames from the second input. In this situation, the last frame from the first input will connect to the last frame from the second input.
Another case may be the situation when data frames will arrive with different frequency – as shown in the figure. When the frequency of generating frames from the second input is less frequent than from the first input. As a result of this data frame generation, successive frames from the first input will link to the last frame from the second input until a new frame is generated on the second input.
The opposite situation will take place when frames from the first input will be generated less frequently than frames from the second input. In that case, frames from the second input that were generated while no frame was delivered from the first input will not merge with other frames and will be skipped.
OPTIONS:
Name | Description |
---|---|
Input variables | Node requires connecting 2 nodes with input variables. |
Primary input | Based on its frames, frames with columns of both inputs will be generated. |
Secondary input | The second input containing frames with input variables, its frames are assigned to the frames of the first input. |
Result variables | Frames containing columns of both inputs, output frames are based on frames coming in the first input. |

Aggregation window
DESCRIPTION:
The “Aggregation window” node allows you to define a time window, determine new aggregated variables in a given window and group. As a result of using the node, the user may obtain various result variables (e.g., average, minimum value, counting frames with a given variable), within a defined time window (time backward from the current moment) and grouping variable. This allows for a detailed data analysis in a given period, such as day, month or hour (size of the time window) and in the context of, for example, Production line (grouping variable containing the line name). For correct configuration, it is required to define a time window and select an aggregated variable within the given time. Unlike the “Grouping” node, the “Aggregation Window” forwards all the input variables and the variables created as part of the aggregation.
EXAMPLE OF APPLICATION:
As a result of the operation of this node, the next node will receive all input variables and the AVG variable will appear, being the average of the A variables provided over the last day, the SUM variable – the result of adding B values from the last twenty minutes, and the SUM_5 variable containing the sum of A from the last five incoming frames.
The node also enables grouping operations. In this example, the Product variable has been selected as the grouping variable. This means that the average value for the AVG variable and the sum values for the SUM and SUM5 variables will be calculated within the same product.
OPTIONS:
Name | Description |
---|---|
Input variables | On their basis, the user will receive result variables with a value depending on the selected aggregate function. One variable is enough to correctly configure the block. |
Time window | Time taken into account when aggregating variables. |
Units in the time window | Milliseconds, seconds, minutes, hours, days, lines (frames). |
Aggregation | The user selects the input variable, then the aggregate function and the name of the resulting variable to be derived from the input variable. |
Average | It counts the average of the incoming variables in the frameset, the result variable is always a floating-point number. The function is available when the data type of the variable is an integer or a floating-point number. |
Count | It counts the number of incoming frames in the package. The result variable is always an integer. Available for any type of data. |
First value | The outgoing frame contains the first variable value that was received in the frameset. The result variable will be of the same data type as the input variable. |
Last value | The outgoing frame contains the first variable value that was received in the frame packet. The result field will be of the same data type as the input field. |
Maximum value | The outgoing frame contains the largest variable value in the delivered frame package. For text, the first value in alphabetical order is the largest value. The function is unavailable for input variables with logical value and array data types. |
Minimum value | The outgoing frame contains the smallest variable value in the delivered frame packet. For text, the last value in alphabetical order is the smallest value. The function is unavailable for input variables with logical value and array data types. |
Sum | It adds the values of incoming variables in a frame packet. The result variable will be of the same data type as the input variable. The function is available for variables of the integer and floating-point data types. |
Grouping | Variables on the basis of which the grouping will be performed. |

Machine
operating periods
DESCRIPTION:
The “Machine operating periods” node is used to obtain relevant data for the Gantt chart type analysis. It allows to specify the cycles in which the machine has worked and to define an alternative variable containing data on downtime. The node, on the basis of the frames with the variable selected as the “pulse variable”, generates and transmits to the subsequent nodes information about the date, series name, start and end time of the work period and the number of pulses.
The determination of the machine working time can be considered on two planes. In the case where the “Changes only” option is turned off, the work period will include all frames containing the pulse variable for which the difference between one and the next is within the time limit. Otherwise, for the variable to enter the period, apart from the necessity to meet the timeout condition, the value of the pulses variable must differ from the previous one recorded in the period.
The user also has the option to select the “split by date” option. After using this function, if the operation period will be at the turn of two dates, it will be split into two separate periods at 00:00:00, which will facilitate filtering based on dates later.
EXAMPLE OF APPLICATION:
According to the example given, two data series have been added. Pulse variables were selected for them – line_A and line_B, and then named – Machine_A, Machine_B. A time limit of 30 seconds has been set for the Machine_A series and the change only option is selected. This denotes that one work period will include the variables for which the time difference between the previous and the current frame is within thirty seconds and the value of the pulse variable in the current frame has changed in relation to the previous one in the given period. For the Machine_B series, the timeout is one minute, and the “changes only” option is disabled. Thus, the variables will only be counted as periods if the time difference between two consecutive frames is within one minute. Unlike the Machine_A series, the difference in the value of the pulse variable is irrelevant here.
The alternate series name “STOP” was selected. It will be displayed in the graph in case the pulse variables of both series fail to meet the conditions of the time difference or the value change (Machine_A).
The example also selects “Split by Date”. If one of the periods begins on one day and ends on the next, it will be divided into 2 periods, which will facilitate later filtering based on dates.
The last option selected is grouping. The grouping variable “day” has been selected here. This means that the generated variables will be counted within the individual values of the day variable.
According to the given example, the following variables will be generated: date (date), seriesName (text), startTS (timestamp), endTS (timestamp), pulses (integer). After assigning all the mentioned variables to the destination – using the “Result table” node, it is possible to create an analysis of the “Gantt chart” type.
OPTIONS:
Name | Description |
---|---|
Name of series | The name of the machine operating period for a given pulse variable |
Pulse variable | Variable treated as an impulse. Based on the time difference between the pulses, a work period is generated – if the difference is within the time limit. |
Changes only | Pulses will only be considered if the value of the pulses variable changes. |
Time limit | The maximum time from the delivery of the last frame with the pulse variable to the next one, counted for the same work period |
Unit of time | Millisecond, Second, Minute, Hour, Day |
Alternative series name | Name of the machine downtime period |
Split by date | In the event that the operation period begins on one day and ends on the next, the node will divide it into individual days. |
Grouping variables | Variables within which the variables generated by the node will be counted, e.g. line number, shift, team, date. Variables with names: date, seriesName, startTS, endTS, pulses cannot be used in grouping. |

Column
transformation
DESCRIPTION:
The “Column transformation” node allows to:
- rename existing columns,
- define constant values,
- and to set default values for existing columns.
Renaming a column updates its name and causes the column to appear under the new name given by the user in subsequent processing nodes. This procedure allows to easily personalize the names of variables within the created processing.
In the node, it is possible to define a new variable with a selected data type (logical value, integer, floating-point number or text) and assign it a constant value that will appear in the entire created processing.
The node also allows to add default values to the existing columns (with the data type boolean value, integer, floating point number or text). In a situation, when a new variable is added to the existing installation channel, then the data frames generated before adding it will be incomplete. By specifying the default values in the “Column transformation” node, in the frames where the selected variable has no value, the value specified by the user will be entered, which will allow the correct operation of the entire processing
EXAMPLE OF APPLICATION:
The configuration of the “Column transformation” node is divided into 3 sections. In the first one, it is possible to rename the existing columns. After selecting the variable from the previous node, the user provides a new name that will be valid in subsequent processing nodes. According to the presented example, the variable A_01 will be further processed under the name variable_1, variable C_03 under the name variable_3, and variable G_07 under the name variable_7.
In the next section, the user has the option to declare new variables with a selected data type and a fixed value of a constant. 4 data types are available – Boolean, Integer, Floating Point, or Text.
In the last section, the user can set default values for individual columns. This means that for frames with the above-mentioned variables, missing value will be replaced with the default value for both past and current frames. According to the presented example, in the case where the frames do not contain values in any of the variables (variable_A, variable_B, variable_C or variable_D), the lack of value will be replaced by the value specified by the user (respectively 9, 9.99, Product_C, false).
OPTIONS:
Name | Description |
---|---|
Renaming existing columns | |
Result name | Select the variable from the previous node to be renamed |
New name | User-established new column name that will appear within the processing being created |
Constant values | |
Name of the variable | Field to define the name of a new variable |
Type | Selecting one of the 4 data types to be assumed by the declared variable – logical value, integer, floating-point number or text. |
Value | The constant value to be assumed by the defined variable depending on the selected data type. In the case of a logical value, it is possible to enter a value – true/false, 0 or 1. Only integers should be given for integers, rational numbers for floating point numbers, and text values for text. |
Default values for existing columns | |
Name of the variable | Selection of the variable from the previous node for which the default values are to be added to the existing column. In case the variable name has already been changed within the configured node, it will appear in this field under the newly assigned name. |
Type | The field is completed automatically based on the selection made in the Variable name field. |
Value | Determining what default value is to be taken by the variable depending on the selected data type. In the case of a logical value, it is possible to enter a value – true/false, 0 or 1. Only integers should be given for integers, rational numbers for floating point numbers, and text values for text. |

Repeat Data
DESCRIPTION:
The “Repeat Data” node is used when the time between incoming frames is long enough that the analysis would not properly reflect the controlled process. By using the “Repeat data” node, it is possible to set an interval during which the node will repeat sending frames containing the last recorded value.
The “Repeat Data” node also includes the “HB mode” option which causes empty frames to be sent instead of duplicate frames. This informs the next processing nodes about the elapsed time.
EXAMPLE OF APPLICATION:
If an interval of 5 is set in a node, in the unit of minute, unless a newer data frame arrives, the previous frame will be repeated every 5 minutes.
Enabling “HB mode” will send empty frames instead of frames with repeated variable. Thanks to this, the other processing nodes will receive information about the expiration of time.
OPTIONS:
Name | Description |
---|---|
Input variables | The frame with the variable will be repeated every specified interval. |
Interval | The delay time in relation to the current time with which the frames will be generated. |
Unit | The unit in which the interval is defined (millisecond, second, minute, hour, day). |
HB mode – HeartBeat mode | This option changes the repeating frames with a variable to repeating empty frames (frames always contain the time in which they were created). In the case where the values would be counted/added up, it is better to repeat the frame without giving the next value for action. This will provide information about the passage of time without falsifying the result. |

Cycle time intervals
DESCRIPTION:
The “Cycle time intervals” node is used to obtain the appropriate data for the Gantt chart type analysis. The configuration of the node is very similar to “Machine Operation Times”, however, with cycle time intervals the aim is to represent the performance of a particular machine rather than showing its operating or idle times.
The node specifies:
- Pulse variable – based on the value of this variable in a given frame, it is determined whether the machine is working or idle.
- “Value change only” option – if the value of the pulse variable for two frames does not change, the second one will not be counted as working time.
- Split by date option After using this function, if the operation period will be at the turn of two dates, it will be split into two separate periods at 00:00:00, which will facilitate filtering based on dates later.
- Time limit and interval unit – the maximum time interval from the previous frame considered as the working time required to qualify for a given series.
- Interval code – the name of the series in the Gantt chart for the given interval.
- Alternative series name – the name of the series generated when the period between the delivery of frames is longer than the defined time limits – downtime.
- Grouping variables – input variables for which the result variables will be divided into groups.
On the basis of the entered data, the user receives variables containing information about the date, series name, start and end time of the work period and the number of pulses.
EXAMPLE OF APPLICATION:
In the given example, the pulse variable “Machine No. 1” was selected, the “Value change only” option was selected, and 3 ranges of intervals were added – High with a time limit of 20 seconds, Medium with a limit of 40 seconds and Low with a limit of 1 minute. This denotes that if consecutive frames are delivered with an interval shorter than 20 seconds and the value of the variable changes, they will be included in the “High” series, if the interval of 20 seconds is exceeded and the variable value changes, the frame goes to the Medium series, after after exceeding 40 seconds and changing the variable value will go to the Low series, and after exceeding the defined minute, an alternative series will be generated – “Downtime”.
If the value of the variable does not change in subsequent frames, they are treated as if they had not been delivered.
According to the given example, the following variables will be generated: date (date), seriesName (text), startTS (timestamp), endTS (timestamp), pulses (integer). After assigning all the mentioned variables to the destination – using the “Result table” node, it is possible to create an analysis of the “Gantt chart” type.
OPTIONS:
Name | Description |
---|---|
Input variables | List of variables transferred from the previous node, one of which will be chosen, based on which the time intervals will be determined. |
Column name | Selected variable for which time intervals are determined |
Value change only | The frame starts the shortest series only when the value of the pulse variable has changed from the previous one. |
Split by dates | In the event that the period of operation begins on one day and ends on the next, the node will divide it into individual days. |
Interval ranges | The section where the user defines the timeout, code (name), and unit for the timeout in a given interval. |
Interval code | Interval name |
Time limit | An integer that expresses the time limit within which the next frame must fit in a given series. |
Unit of time | Millisecond, Second, Minute, Hour, Day |
Alternative series name | Name of the machine downtime period |
Grouping variables | Variables within which the variables generated by the node will be counted, e.g. line number, shift, team, date. Variables with names: date, seriesName, startTS, endTS, pulses cannot be used in grouping. |

Empty Transformation
DESCRIPTION:
“Empty Transformation” node forwards the frames without making any changes to them.
EXAMPLE OF APPLICATION:
All incoming variables in frames and their data types can be seen there.
OPTIONS:
Name | Description |
---|---|
Input variables | The node forwards the frames without making any changes to them. |

Time Difference
DESCRIPTION:
The “Time Difference” node outputs a new variable specifying the millisecond time difference between each incoming frame. Moreover, the node enables grouping based on the designated input variables (time differences are divided into groups according to the value of the selected variable, differences are counted for frames belonging to the same group). The grouping function is not required for the correct operation of the node configuration.
EXAMPLE OF APPLICATION:
The time differences between frames within the value of Line_1 will be written to the result variable. Time differences are divided into groups – in this case they will be counted separately for each value of the Line_1 variable. For example, for the variable Line_1 equal to 4, the difference may be 3000 milliseconds, after changing the value of the variable Line_1 to 5, the difference will no longer be taken into account, because we start to calculate the difference for the variable Line_1 with the value 5.
If no variable is selected in the “Grouping Variables” section, then the time difference will be calculated for each subsequent frame relative to the previous frame.
OPTIONS:
Name | Description |
---|---|
Variable name | The user defines the name of the output variable containing the time difference between frames. Outgoing variable is an integer that specifies the number of milliseconds since the previous frame arrived at the current one. |
Input variables | Whole frames are considered in the node and the time difference is calculated on their basis. |
Grouping | The user selects a grouping variable whose values divide the frames into sets – time differences are calculated within a specific set. |

Time stamp
DESCRIPTION:
The “Time stamp” node allows to generate additional variables that define the time of frame registration. With its help, output variables such as minutes, seconds, timestamp, sequence or date can be obtained.
EXAMPLE OF APPLICATION:
The “Time Stamp” node finds practical application in a processing containing a “Operation change” node. For the correct operation of the “Operation change” node, a variable with the time stamp data type is needed, which can be obtained by selecting the “Date and time” option in the “Time stamp” node.
The “Time Stamp” node can be used when we want to know the exact time or compare data in a similar period.
The “Time Stamp” node can also be used in processing using grouping nodes by grouping a given variable or input variables into a selected time unit. In order to obtain the required time unit, an adequate output variable should be selected in the configuration.
In the example shown, the A variables counted will be grouped by days.
OPTIONS:
Name | Description |
---|---|
Input variables | Based on the time the frames were captured, user-selected output variables are generated containing accurate time information. |
Result name | The name of the variable resulting from processing in the node. It must be unique throughout the processing. |
Date | Date in the YYYY-MM-DD format. |
Date and time | Timestamp in the YYYY-MM-DD HH-MM-SS format. |
Year | Year as an integer. |
Month | Month as an integer. |
Day | Day as an integer. |
Hour | Hour as an integer. |
Minute | Minute as an integer. |
Second | Second as an integer. |
Sequence | The value is taken when more than one frame is captured at exactly the same time. By default it is 0, it takes higher values, depending on the number of frames registered at the same time. |
Time in milliseconds | Time in milliseconds as an integer. |

Union
DESCRIPTION:
The “Union” node is used to combine variables in frames coming from several streams.
EXAMPLE OF APPLICATION:
After connecting several channels to the “Union” node, all incoming variables in the frames and their data types from each of the connected channels are visible in it. The variables from the first input should be assigned the variables from the successive inputs so that their data types are the same. The order of inputs depends on the user, who can modify it in any way.
OPTIONS:
Name | Description |
---|---|
Input variables | Variables from the source selected first in the order of inputs should be assigned variables from other sources. The data types of the variables must match. |
Entry order | Order of ordering inputs. They can be freely modified using the arrows on the left side of the window. |

Delta transformation
DESCRIPTION:
The node “Delta transformation” determines new variables that determine the difference of values between the current and the previous frame. It allows to specify the maximum time interval between frames from which the values are calculated and for grouping based on the supplied variables.
EXAMPLE OF APPLICATION:
Increments of the value (difference between the previous and next value) of variable A within the value of the Hour variable will be written to the C variable. The increments are divided into groups – in this case they will be counted separately for each hour. At 11:59:59 the increment may be, for example, 30, at 12:00:00 the frame with the previous increment will no longer be taken into account, because we start to calculate the increments for the variable Hour with a value of 12. An additional condition for calculating the increments is the time difference between the current and the previous frame (in the same group), which cannot be more than 10 minutes.
OPTIONS:
Name | Description |
---|---|
Variables for delta evaluation | The user selects the variables from which he/she wants to obtain the increments, and then gives the result names to the variables containing the increments. |
Maximum time gap | User-defined interval on the basis of which frames are selected for which increments are calculated. The increment will be counted between the first and last frames in a given period from the current time. |
Available units of time | Seconds, minutes, hours, days. |
Grouping variables | Variables on the basis of which the grouping will be performed. |

Signal shape
DESCRIPTION:
The “Signal shape” node allows the user to analyse the changes in the signal shape. In particular, it allows to define the high and low value. On this basis, the node registers changes and informs about exceeding the set thresholds. Thanks to this, the user can, for example, monitor the number of times the machine process from which the data is collected has been fully performed.
EXAMPLE OF APPLICATION:
The “Signal shape” node can be used in a situation where the user is not able to specify the exact value, the exceeding of which would mean the execution of a full machine cycle. “Signal shape” makes it possible to count the number of cycles on the basis of exceeding the threshold values, from values– low, high or both of them, depending on the user’s needs.
In the presented example, the input variable A was selected, the low value – 10 and the high value – 20 were specified. In the first case (for the result name Number of Cycles), the signal shape was set to raisingand the result type – count. This denotes that the node will count the number of occurrences of situations in which it will register the exceeding of the high value (20), when the low value (10) was previously exceeded. However, in the second case (for the resulting name CycleMoment), the signal shape was set to falling and the result type – flag. This denotes that the node will return the value –1 every time the low value (10) is exceeded, when the high value (20) has been exceeded previously.
OPTIONS:
Name | Description |
---|---|
Input variables | Selection of a variable supplied from previous processing nodes |
Low value | Numerical value – the lower limit below which the declines of the variable are to be counted |
High value | Numerical value – the upper limit above which the increments of the variable are to be counted |
Signal shape | Rising, faling, both. Rising registers exceeding the high value, provided that the low value is exceeded earlier. Faling registers exceeding the low value, provided that the high value is exceeded earlier. Both records the values of both. |
Output variable | User-supplied name of the result variable. |
Type of result | The flag or sum, where the flag reflects the current situation, can be -1.0.1. The flag will return -1 when the lower threshold was recorded, provided the upper threshold was exceeded earlier. The flag will return 1 when the upper threshold has been exceeded, provided that the lower threshold has been exceeded earlier. The flag will return 0 any time it fails the 1 or -1 condition. The sum is the total number of inputs to the -1 or 1 state, depending on the signal edge selection. |

Shift transformation
DESCRIPTION:
The “Shift transformation” node allows to define a shift work pattern in a production plant. Based on a time stamp variable, the node sends frames containing user-specified details, such as the exact time, number, or shift start date.
EXAMPLE OF APPLICATION:
In order to properly configure the “Change of work” node, it is necessary to define the work shift scheme, entering the hours of their start. On this basis, the end times will be generated after clicking the “Calculate changes” button.
The user should select the variable containing the timestamp from the available variables.
The final step is to select and name the change result variables and save the node.
According to the presented example, on the basis of the provided frames, the node will generate two additional output variables, containing information about the start date and shift numbers. The output variables will match the shift pattern created.
OPTIONS:
Name | Description |
---|---|
Shifts schema | |
Shift start [h] | User-defined time. In order to add an hour that starts a given shift, the “Add new” button should be used, hour entered, and then confirmed with the button “Calculate shift” |
Shift end [h] | Automatically generated time based on user-specified shift start times. Appears after using the “Calculate shifts” button |
Select a variable identifying the time | |
Available variables | For the correct operation of the node, it is necessary to provide at least one time stamp variable. The user selects a variable with a time stamp from the variables supplied to the node. |
Shift output variables | |
Shift work date | A date type variable gives the start date of the change with accuracy to the day in the format YYYY-MM-DD |
Shift number | An integer that specifies the shift number based on a user-defined shift pattern |
Shift time stamp | Variable of time stamp type, gives the exact start time of the shift with millisecond precision in the format YYYY: MM: DD HH: MM: SS.MS |
End time stamp | Variable of the time stamp type, gives the exact end time of the shift with millisecond precision in the format YYYY: MM: DD HH: MM: SS.MS |
Start time (milliseconds) | An integer that provides the time from 01.01.1970 to the start of the shift in milliseconds (EPOCH) |
End time (milliseconds) | An integer that provides the time from 01.01.1970 to the start of the shift in milliseconds (EPOCH) |
Result nodes (Output table) are used to save the results of the processing.

Output table
DESCRIPTION:
The “Output table” node is one of the two exit nodes. It allows to select the database where the frames with variables are supposed to go.
The user has both an internal and external database at his/her disposal. In the first case, before starting the creation of the processing process, a destination for saving variables should be created or imported. However, when choosing an external database, remember to create an appropriate table (in the selected database) to which the frames with data will be sent. After selecting the destination, the user selects the variables to be saved and the columns to which they will be assigned. A variable can be marked as a key variable – the values of other variables will be updated for the same values of the key variable (e.g. the same month name or the same production line).
EXAMPLE OF APPLICATION:
In the given example, 3 variables (l_szt, code, date) will be entered into the database. They can be found in the analyses by selecting the destination Production_Katowice. The lines will be updated based on the product code and date. As a result, lines will be created with up-to-date information about products of a given type, manufactured on a given day (for each pair of different values of the variables, code and date, we will get a separate line). If the key variables were not indicated, we would get as many lines as there were saved frames. In the example, the “Quarter” data range has been selected. In the case of continuous processing, frames with data go to the database on a regular basis. However, if the processing is stopped and restarted, e.g. after an hour, only data from the last 15 minutes from the time of the last frame arrival will be taken into account.
OPTIONS:
Name | Description |
---|---|
Input variables | The delivered frames will go to the selected destination on the database. |
Destination | The database table to which the frames with the variables will go. |
Scope of data | In the event that old, irrelevant data is provided for the processing, it can be filtered by selecting the interesting period. |
Key variable | A variable within which values are counted. |
Data type | Variable Data Type – must match the column data type on the target. |
Variables saved to the destination | Table with the variables supplied to the result set during processing. |