Students Working Students, Internships and Bachelor / Master thesis projects:

Problem definition

CODESYS is a hardware-independent programming system for programmable logic controllers. The IEC 61131-3-compliant programming languages used are translated into processor-specific code, transferred to a CODESYS runtime system, and executed.

C integration in CODESYS allows for the integration of components developed in the C programming language. These are not compiled by the internal CODESYS compiler, but by an existing C compiler and toolchain for the target system. As the runtime system is available for many different architectures and operating systems, you usually need a cross-compiler that, for example, creates modules in Windows for Linux on ARM.

Practical experience has shown that setting up a suitable environment for compiling code for external target systems on Windows can be very complicated. We are looking for solutions to simplify this process. In this thesis, the candidate will study the use of virtualization with the help of Docker.

Objective of the thesis

CODESYS shall support the capability of accessing a build environment within a VM for the compilation of C code. Docker is the ideal solution for implementing this kind of solution. A VM shall be set up for a selected testing platform. Then a suitable extension for CODESYS shall be implemented, which controls the compiling process within the VM and transparently executes the data exchange for the user.
In addition, it would be advantageous to be able to provide users with a convenient way of configuring and managing the VM within CODESYS.

Duration: according to study regulations
Remuneration: yes
Hours per week: 40
Application reference: Docker student

Information and application:
CODESYS Group
Human Resources, Ms. Sabine Panzer
jobs @codesys.com

Problem definition

CODESYS is an independent programming system for programmable logic controllers. A CODESYS project consists of logic POUs programmed in one of the five IEC 61131-3 languages, as well as other types of POUs such as device configurations and HMI visualizations. All of these POUs are stored in a single project file, which is very convenient for distribution.

CODESYS SVN is a post-installable add-on product for CODESYS for managing these projects in a Subversion repository. Each POU corresponds to a file in the repository, so that one version history can be recorded for each POU. Furthermore, multiple developers can work on the same project simultaneously in the repository. All essential Subversion commands are integrated in the CODESYS programming system, as well as matching (in some cases graphical) diff views for comparing different POU revisions.  CODESYS SVN is one of the most successful add-ons in our product portfolio.

Since the market launch of CODESYS SVN, we have seen that the Git version control system has become increasingly important as compared to Subversion. This is not least due to functional advantages, the existence of GitHub, and the seamless integration in development environments such as Microsoft Visual Studio. Therefore, it is our aim to provide the existing add-on for Subversion with a Git integration with CODESYS.

Objective of the thesis

The development of an add-on for Git integration is divided into three parts.

1. The database-independent software layer for synchronizing a CODESYS project with a temporary working copy is currently part of CODESYS SVN, but it can also be used for CODESYS Git. A subgoal is to detach this layer from CODESYS SVN and make it available as a generic module.
2. This temporary working copy created by the generic synchronization module has to be synchronized with the Git repository by means of the Git command set. This subtask includes the search for and evaluation of a Git client library available on the market, which runs on .NET and is compatible with our license policy.
3. The most important Git commands have to be provided in the CODESYS programming interface as menu commands, in addition to the corresponding dialogs whose functionality shall be based on existing Git integrations (for example, TortoiseGit). The scope of this subtask can be modified depending on the remaining project duration.

If this topic is chosen as a master thesis, then the academic focus can be set on the following points:

• Systematic comparison between Git and Subversion
• Systematic comparison between different Git client libraries
• Systematic representation of the development process to refactor an existing complex software product in order to develop other products from it, together with risk and architecture analyses.

Duration: up to 6 months
Remuneration: yes
Hours per week: 40
Application reference: Git student

Problem definition

CODESYS is a hardware-independent programming system for programmable logic controllers. The IEC 61131-3-compliant programming languages used are translated into processor-specific code.
CODESYS Static Analysis is an add-on product for CODESYS for static code analysis of programs. This analysis examines the code to detect possible sources of error, stylistic flaws, violations of coding guidelines, and optimization potential.

A data flow analysis examines the dependency between the data of a program. This kind of analysis can be used for identifying optimization potential or possible errors in a program.

Example:
bTest1 := bTest;
IF bTest THEN
;
ELSIF bTest1 THEN
;    // unreachable code!
END_IF

A data flow analysis is able to detect the unreachable code in the ELSIF branch. Optimizing compilers use this information to simply cut out unreachable code. However, unreachable code is often only a symptom of a programming error. In this example, the test for the ELSIF case could be wrong.
Therefore, the situation described above should be reported as a warning.

Objective of the thesis

There are several options for data flow analysis. The work shall check which type of data flow analysis is suitable for the application of static code analysis. A data flow analysis for IEC 61131-3 projects shall be implemented and integrated into the static code analysis of CODESYS. The work shall examine which tests can be performed on the source code by means of this analysis, and these tests shall be integrated into the static code analysis. With the help of these tests, existing projects as well as the libraries of CODESYS shall be examined for errors and optimization potential. Selected projects will be used for measuring the improvements in code size and runtime of a project by restructuring the code.

Duration: up to 6 months
Remuneration: yes
Hours per week: 40
Application reference: Development student

Definition of problem

CODESYS is a hardware-independent programming system for programmable logic controllers. The IEC 61131-3-compliant programming languages used are translated into processor-specific code. There are currently code generator backends for more than 10 CPUs for CODESYS.

Today's CPUs have deep pipelines to load and process commands long before they are actually executed. In conditional jumps, these CPUs use simple heuristics to determine which path is the most likely to be processed.

Incorrect heuristics can lead to very poor performance because the pipeline may have to be completely purged and refilled.

An efficient compiler can exploit these properties of a CPU to generate faster code when the probability of a condition being met is known. It would be very helpful to implement a directive that allows the programmer to set the probability of a condition. For example, this kind of directive could look something like this:

IF (__UNLIKELY(x > 100000)) THEN
         LOG_Message(‘Variable too big’);
ELSIF (__LIKELY(x < 100)) THEN
          // do this
ELSE
         // do that
END_IF

In addition to IF-ELSIF statements, there are also conditional calls, conditional jumps, and conditional return statements in the graphical languages of IEC 61131-3. These should also be optimized with the __LIKELY directive.

Objective of the thesis

A directive as described above shall be implemented and integrated into the CODESYS compiler. Furthermore, the work shall investigate how this directive can be used on the different CPU architectures (Intel Pentium, ARM, PowerPC, possibly SH, MIPS, and others) and which performance enhancements can be achieved.

The bachelor thesis may be expanded into a master thesis by developing a runtime analysis that measures the rate at which a condition applies in order to optimize the code with __LIKELY / __UNLIKELY directives in a second compile run.

Duration: up to 6 months
Remuneration: yes
Hours per week: 40
Application reference: Compiler student