Whenever code for a Programmable Logic Unit (PLC) is generated using a model based approach there are multifarious possibilities for possible code generators. In order that the generated code is changeable and maintainable the code should have a low complexity. A high complexity complicates by hand changes that become necessary when the code generator is not available as well as it is a reason for high maintainability costs in general [1]. My research is the first to present an approach to compare between PLC implementations generated by different generators in terms of complexity using the example of a paper machine controller. Additionally the performance of the implementations is investigated and a preliminary evaluation of the generators selected is given.
Model-driven engineering is becoming increasingly popular, especially in the
automotive domain, as it can shorten the development time by as much as 50% [
The concept of model-driven engineering is presently also used in the PLC domain. PLCs are appliances used for the automation of technical processes. Programming PLCs is based on the IEC 61131-3 standard, which includes different languages. Code generators for many PLC compatible languages have become available over the last years; three of them can be found below:
C and CFC are both not included in the original IEC 61131-3 standard, but are suited as well and can be regarded as quasi standards.
Programmers that have to implement a model-based PLC application and wish to apply the concept of Model-driven engineering consequently have to choose between 3 distinct code generators that produce 3 implementations in different languages.
The aim of this research is to provide recommendations for which code generator is best. In a showcase, controller implementations in the three languages listed above are generated from a model of a paper machine controller. The implementations are then investigated and compared with regard to complexity and performance on a soft PLC. The conceptual approach is depicted in Fig. 1: This is the first work to compare among various PLC based implementations generated from the same model.
Prior work mainly deals with the quality assessment of standard computer
software, but does not explore characteristics of Model-driven engineering or the PLC
domain. [
[
This research especially builds upon [
The implementations were generated using a Simulink model of a paper machine controller. The model itself has no subsystems and uses 6 different kinds of blocks: Discrete PID controller, discrete transfer function, transport delay, sum, step and outport. There are two input signals and four output signals. Compressed in a subsystem the model looks as follows:
Delivering this subsystem as an input to the three code generators returns three implementations: The C-Code, ST-Code and the CFC block diagram are now subject to the following evaluation.
Measuring software quality in general implies using software metrics [
the style of
[
tual languages
graphical languages
LOC measures the number of code lines. It can be applied on both the ST- and
CCode, but naturally cannot be applied on the CFC block diagram. Like many
complexity metrics, the LOC metric is not clearly enough defined. Therefore the version
described in [
The McCabe metric measures the cyclomatic complexity. It is based on the control
flow graph of a program and determines the linear independent paths through the
graph. In this research the cyclomatic complexity is calculated according to [
The original Halstead metric [
To measure performance, the three controller implementations are integrated into the programming environment TWINCAT 2.11, compiled into a Soft PLC and their time response are simulated. It is desirable that the implementation time response is close to the time response of the model, because the more alike the time responses are, the better one can estimate the performance of software in advance. Therefore the time response of the model is also measured and compared to the implementations.
As an input a unit jump was impressed on the entries and received the step function response at the exits. The duration of record was 2000 data points or 2000 seconds at a step time of 1 second. 4
Applying the presented metrics on the three implementations of the paper machine model delivers the following results:
Metric ST-Code C-Code
CFC
LOC 238
According to the LOC metric the ST code performs better than the implementation in C because it requires fewer lines of code. The CFC block diagram has the lowest value for cyclomatic complexity (McCabe) and program volume (Halstead). The implementation in CFC should therefore be clearly preferred with regard to complexity.
While the implementations in C and ST do not show significant differences between the model, the time response of the CFC block diagram clearly differs from that of the model, which can be seen on the basis of the error depicted in Fig. 3:
To quantify this discrepancy the error in least squares sense was calculated: implementation
CFC 0.03775
ST 8.0666E-15
C 0
0 (as ref.)
The implementations in C and ST clearly perform the best, as the error function (nearly) equals zero. The performance of the CFC block diagram clearly is the worst in this assessment. Different execution orders of the Simulink and the CFC blocks are a likely reason for that. 5
This research presented an approach for the quality assessment of three different automatically generated controller implementations on a PLC. By Assessing complexity and performance of the implementations of the paper machine controller my work shows that Continuous Function Chart performs best in terms of complexity, whereby the implementations in C and ST have the best time response. What was showed exemplarily on a medium sized model with 60 blocks should also be done with other kinds and sizes of models to help validate my findings and extend it to a broader range of models.
Acknoledgements. I would like to thank Lindsay Bauer (Manhattan, New York City) for her patience and gratitude to revise my paper and giving me excellent advice on how to express my ideas.