Support PLC Engine Collect Logic Tables
You can create logic tables with the wizards integrated in the configuration software.
This text presents logic tables which are too short or too special for a wizard. Or an wizard will need to many parameters.
For your bigger jobs the extendable WizardScript is available also.
All examples are basing on memory variables. But all can run on controller or OPC variables also.
PLC Engine Collect version 1.9 has been used for the creation of the examples. The examples can be used in newer versions also.
Overview: Counters, numbers and times, multiple trigger, subroutines, CSV file write, CSV file read, create structure , create structure array, decode structure array, sequence chains, program call, multiple database results, simple statistic.
In a timer running once a second a variable named Counter is read, one is added, the result is written back
to the same counter variable.
Download the example: Counter.table.
Often parts only from a number are needed.
Digits before or after the dot are created with the round element. The common rules from mathematics will be used.
Parts of numbers are results from divisions. The portent can be removed with the absolute element.
The parts of a number under 100 in a big number are removed by a divison with 100, after this multiply the result with 100.
Mostly it is the wrong way using parts of a number after calling the reinterpret for a translation into a byte array. This is possible from the technical side but complex.
Download the example: Numbers.table.
The timestamp is delivered from the system time. This time contains date and time up to milliseconds.
This example converts the time into a string. After this with the help of the large text formatting functions: Day, month and hour will be extracted. The result will be converted into a number again. The number can be used later for other things (this simple example does not doing so).
Additionally the name of the time zone will be presented. Note that the text of the time zone is obtained from the operating system, it can vary from system to system. The system language may affect the result also.
The next value is the difference in seconds of the time zone. If you are in a time zone which knows summertime (this is true in Germany) then the difference in summer is 3600 (one hour). In winter time it becomes zero.
The offset to the Universal Time Zone UTC is the next element. In summer it is 7200s = two hours, in winter 3600s = one hour.
If yo need a consecutively time - a documentation can not have two entries with the same time - please use UTC. Otherwise in the night in fall with the time switched back will result in two times logging the same between 2 am and 3 am.
Download the example: DateTime.table.
Sometimes a value need to be handled if it will change, but if it does not change in a specified period it need to be handled also.
This logic table is using two triggers: The value change trigger and the time trigger. The value will be handled if it is changing or after the timeout.
The trigger reset will initialize the time trigger also.
Download the example: ChangeOrTime.table.
A CSV file (Comma Separated File) is a text file containing multiple lines of coherent values.
CSV files can be used for multiple things. Microsoft Excel and OpenOffice Calc and lot of more programs accept CSV files as input and output.
This example adds a line to the CSV file each time the variable Counter 1/s is changing. If this becomes true the actual time is added also.
This example uses the semicolon for the value separator and the Windows line end.
Download the example: WriteCSV.table.
This example checks for new files beginning with the name prefix of "Datafile*.*". If this becomes true the file content will be read.
It will be assumed that the file content is in csv file style and will contain three numbers. The numbers are read from the file content and will be written into the plant. On success the file will be removed.
On case of a PLC writing error an error bit will be set.
If all of this will be programmed in one big logoc table it will work - but it is not easily to read and understand.
Download the example: ReadCSV.table.
Such logic can be better realized in a sequence chain. This will require some local variables, but it is much easier to start up in the plant.
One step checks for the new file with the correct name prefix. The name will be written in a variable, other files are ignored.
The next step reads the file, decodes its content and writes the data into the plant. The file name is taken from the local vaiable.
The last step will remove the file if no error did occur.
Any error management can be realized in more steps. Possibly it will be waited here for an user reaction. The file name can be displayed to the user. In this example the error steps are mostly empty, they only are switching to the next step.
Download the example: ReadCSVChain.table.
If the implementation uses subroutines it increases the view of sight. So the file content decoding and the delivering of the results can be realized in a subroutine. The logic can be used in multiple logic tables
The ProducedPieces counter is read. If its value will change the new value is given into the structure Plant statistics. Additionally the current timestamp is added. Additionally the good pieces value is calculated and written into the structure. The created structure is stored.
Beispiel Logiktabelle herunterladen: StructureCreate.table.
Download the example: StructureCreate.table.
The opposite function for the structure creation exists also, it separates the single values back from a structure. If stacked structures are used the structure creation or structure decode need to be used more than once.
Structures can be more complex. This example fills a structure containing a list of plant stati. The result will be stored in a variable
Download the example: StructureArrayCreate.table.
This example gets some values back from the structure creation array example above.
Download the example: StructureArrayDecode.table.
Sequence chains are simplifying processes. In a sequence chain one step is active only.
This example uses the bit trigger vor handling the result of comparisons.
All steps of a sequence chain need to me in the same group. Other groups con contain more sequence chains.
The initial step, mostly this is the first step. The prerequisites of the sequence chain are initialized here.
Here it will be waited for the machine becoming ready.
Now the machine does its job and handles the product. This example waits for the machine status becoming success only. Normally here and in further steps the machine is handled.
The last step combines all paths together again. Sometomes the counter of produced pieces is incremented here.
It can be usefully havong an error step. This exampe does nothing special for errors.
Download the example: SimpleSequenceChain.table.
In the logic tables external programs can be called. Mostly this are scripts (called "Batch" under Windows).
The external programs are called at system level.
Parameters can be given to the called program. On standard no return data can be handled. So this example uses a file for returning data from the called program. But other mechanism can be used also: Sockets, OPC UA and more.
A simple script is called. Two parameters are handled - a text and a filename. The script writes something into the file. After the program returns the logic table reads the content of the file.
In this logic test table the given filename is for a Linux example. On Windows the file name example is c:\users\public\documents\tani\scriptreturndata.txt
Put the script file to a location which can be reaced by PLC Engine Collect. On Linux this is /etc/Tani, under Windows c:\users\public\documents\tani\
Download the example: ScriptCall.table.
Download the scripts for Windows and Linux.
A database select can return more than one result. This example is showing a handling of two results.
The number of results is checked, so the table will continue if no or one result only are returned.
On handle multiple results it may be more handy using sequence chains. Within this the saved result counter will be counted down. The result counter can be used as an array index also.
The error handling can be done in a specific step.
Download the example: MultipleDatabaseResults.table.
A test logic table generates some test data and puts them into a database. This is realized with a minute counter which counts from 0 to 40.
The real statistic calculation uses a bigger database call. This call is something more complex, it need to be entered as the true database call.
INSERT INTO `hour_values` (`timestamp`, `value_avg`, `value_min`, `value_max`)
SELECT DATE_SUB(DATE_FORMAT(NOW(), "%Y-%m-%d %H:00:00"), INTERVAL 1 HOUR), AVG(`value`), MIN(`value`), MAX(`value`)
WHERE `timestamp` >= DATE_SUB(DATE_FORMAT(NOW(), "%Y-%m-%d %H:00:00"), INTERVAL 1 HOUR)
AND `timestamp` < DATE_FORMAT(NOW(), "%Y-%m-%d %H:00:00");
Such more complex database things can be realized as a stored procedure in the database also. This example calls the database call directly.
The database call will be called in the first minute after a new hour. This is done by reading the system time, convert it into a string. Then the minute value will be cutted out. Compared to 01 the trigger is made.
The call will read the values from the collecting database table from the last hour. Then the minimal, maximal and average value will be calculated. The result will be written in another database table. Databases are offering many functions for calculations.
If more statistics are needed as week or month overviews more logic tables can generate them. This can be done directly in this database call also. But for saving calculation time this schould be done further logic tables are the better solution.
First the dummy for the generation of test statistic data.
Now the logic table which will calculate the statistics. This example is made for MySql/Mariadb.
Download the example: CollectDataOverTime.table.