This file contains some links and some videos for OFB usage in Libre/Open office graphic programming, code generation for C(++) and test

[title="BandpassFilter_FBgl_srcC-en"

FBcl means 'Function Block Connection Language' which is the textual description of the graphic. The idea comes from ~2018.

OFB means 'Object oriented Function Block graphic'.

Graphical programming of function blocks has been common practice for decades. The automation control, for example Simatic-S7 or Codesys, use it with its "FBD" language (Function Block Diagrams). Another representative is Simulink © Mathworks. There are some more similar tools for that. But for these Function Block programming solutions ObjectOrientation is missing. It is also non-conform to UML. The OFB closes this missing relation with some enhancements in concept, using of Aggregations (UML like), and also a event control system for execution.

What is the approach? Drawing the software with graphic and code generation in C/++ (maybe later also in Rust, or in Java) so that the functionality is seen and understandable by everybody with physic knowlege, obviously, no code lines. But the code lines are generated and follows guaranteed the graphic. Graphical software development does not save effort (money) for development. It improves the documentation! That’s the benefit. The basis for the graphics should be an available, proven tool (without basic costs, usable by anyone at any time). LibreOffice was chosen for this purpose. It is well-known and easy to use for this approach of graphics. The translation is an algorithm written in Java, which reads the graphic data and have capabilities for Code generation.

1. Resources

Of course the current version needs to be improved, and some small things are seen immediately. But if it is not offered in a definitive time, it is never offered. Procrastination is usual not the best idea.

You can write feedbacks and questions to info (at) vishia.org

1.1. download zip and tools

The zipfile does contain the examples shown in the videos. It does not contain the tools itself. The tools are downloaded with the unpacked zip if you call (on Windows)

OFB_presentation/src/load_tools/+checkAndLoadTools.bat

with a MD5 check code from this web page. See also Hints Handling load, file tree

1.2. call the first test, translate all

To start a test whether all is translatable, translate it calling

OFB_presentation/src/TestAll/makeScripts/testAll.bat

Note: Go to this directory (with Explorer or recommended Total Commander or similar) and double click. Then all examples are translated. To store the generated sources, for all examples a symbolic link (= JUNCTION in MS-Windows) is created. It works on the usual used NTFS File systems.

The JUNCTION makes a symbolic link from ⇒ to

OFB_presentation\src\<EXAMPLE>\cpp\genSrc => %TMP%\OFB_presentation\<EXAMPLE>\genSrc

It means the generated sources are stored in the temp folder of your computer. It is temporary, can be deleted again after the session. I use (recommended) a RAM disk for the whole MS-Windows temporary stuff, that works. The computer is faster and the SSD is spared. But after making any JUNCTION a pause is programmed, you need to "press any key to continue" As you see, some small problems are in the source, especially ExmplWaveAvg is not yet ready. But the videos are made with this version.

1.3. Where to store generated sources, JUNCTIONs or symbolic linked directories

There is a decision where to create the folder for the generated sources. I see three possibilities which advantages and disadvantages:

  • a) Do not create this JUNCTIONs or linked folders, write the sources immediately in …​\<EXAMPLE>\cpp\genSrc.

    Disadvantage: It is immediately a part of the sources in the src/tree though it is generated. Any new generation writes on SSD or the hard disk.

  • b) Write the generated sources outside the source tree to OFB_Presentation\build\<EXAMPLE>\cpp\genSrc Advantage: The generated sources are outside of the primary sources. This will be done in fact because a symbolic link or JUNCTION in MS-Windows is created from ⇒ to

    OFB_Presentation\build => %TMP%\OFB_presentation\

    and hence the sources are seen also there.
    Disadvantage: Taking the sources from …​/build/…​ in a IDE project is a little bit more confusing. It is better, sources are beside together. (Is it a disadvantage).

  • c) Write the generated sources to …​/build/…​ but without symbolic links or JUNCTIONs:

    Hm, symbolic links are a proper possibility known in UNIX from the 1970th. But for some people they may be confusing.

Have experience and fun.

1.4. Compare newly generated sources with the versions before

This is a proper approach also for the daily work: Compare the just generated sources with the versions last generated to see which is changed. Intrinsic it is also a possibility to test the translator itself, without changed input, but with the changed translator.

The sources before (or the given sources in this zip) are stored in

OFB_presentation/src/<EXAMPLE>/cmpGen/genSrcCmp/*

Any translation script calls after translation the script

call ..\Organize_OFB\fdiff.bat cpp\genSrc cmpGen\genSrcCmp

The fdiff.bat should be adapted to call the view diff tool according to your preference. It is presetted to

c:\Programs\WinMerge-2.16.41\WinMergeU.exe %1 %2

It means, if you take winmerge: https://winmerge.org/downloads/ and copy it to this location, it runs. I prefer using the winmerge-2.16.50-exe.zip to download. It is a 32-bit Windows version as 'portable' or just 'copy deployment'. It runs also under Linux using wine.

1.5. Linux?

There is no reason that this tools cannot used under Linux. Only the scripts should be prepared. LibreOffice runs, Java runs, Linux has some possibilities for IDEs (Integrated Development Environment) to compile the generated stuff.

The next zip file will be have Linux scripts.

1.6. older zip files to download

Hint: Use the newer file to test whether all features are ok, use the older one as fall back if you know that in the older version a detail has worked, to compare with the new one.

1.7. Documentation

Note: Use two-page view if you have a larger monitor (1980 x 1020 or more). The documentation is page-oriented. The odd page should be on right side ('book view'), but because usual the Browser-pdf view don’t support the book view an empty left page is introduced for that.

1.8. source repositories, Gitlab

New created on 2025-March-27: Git repository on Gitlab. (The repository itself is grown since 2019):

1.9. Javadoc for sources

Javadoc html of the converting tool

2. The current (new) version 2025-07-25:

The new version comes in comparison to the April version with a lot of new features. As the versions in 2024, the April version may seen only as start. This version is now suitable for professional use.

2.1. Changes since 2025-April

Some important news are:

  • The access to data with operations and return values are now supported. The older versions were oriented, as usual also in ordinary C programming, only to (public) data. Working with operations and hence encapsulate data are a proper decision. inline operations also in C language does not enforce additional calculation time on machine level. Also usage of reference variables for return values is possible. What is not clarified: Return of a reference is intrinsically an association in UML thinking, and should be handled in exact that way. Function block graphics do not deal with references, only with data flow. But usage of references is usual in C/++ programming. This should be basically proper clarified for the Object Oriented Function Block (OFB) concept.

  • In opposite to this feature, also public access to structured data works, sometimes necessary for embedded applications. Inner variables well structured can be declared as outputs to immediately access from outside.

  • Defining and usage of module input and output pins is improved (as result of the changes above).

  • Usage of non determined types are supported. This is sometimes necessary if a library module is written first independent of usage in a float or int environment. The graphic is the same. The usage and code generation decides about the numeric, with unchanged graphic.

  • The fix point arithmetic is improved and tested, with automatic conversion from and to float with dedicated given 'number of fractional bits'. Also using saturation arithmetic is supported. It is not yet tested elaborately in embedded hardware, but the system for that is established.

  • The concept of predefined FBlocks and the alias are improved. The name of a struct in C language is determined only on code generation, not already in the graphic diagrams. The mapping is done with an extra text file (-cfg:), see video below. Used names in the graphic diagrams are more independent of target implementation stuff.

  • logs and comments are improved to see how and why the code is generated in the given result.

  • The translation from the graphic to target code can now be started also from LibreOffice in the toolbar, using a macro in LibreOffice, which calls the used batch file (or todo: shell script for Linux). See video below. Also executing the target code build process and start execution can be done in this kind, but is not done yet. This would be a faster way from the graphic to execution results.

All in all, some tests on living examples are done, a lot of fine tuning was done. A list of details of changes can be seen in the version history: https://gitlab.com/jzhartmut/srcJava_vishiaFBcl. Of course the documentation is improved step by step.

2.2. Videos showing the new features and working with OFB

There are some videos showing the new features and showing how working with OFB. The video is linked by clicking on the image on the right. It is an mp4 file hosted on my website.

2.2.1. Working with alias and determine the struct names in target code

Alias and Headerfiles
Figure 1. Alias_and_Headerfiles

This video (18 min) shows how alias designations are used and how the header files are determined from the graphic content.

It includes also the explanation how the graphic definition of FBlocks is related to the given (legacy) target code.

2.2.2. Module output possibilities, return by value, value reference variables, operation access

OutputRetRefOper
Figure 2. Module output possibilities

This video (26 min) shows possibilities of the outputs of the module as also as called function blocks also written in target language.

Operation access is the recommended style for encapsulated Object oriented programming. But beside this, for embedded C, as usual, also the public access also to structured data is supportet.

The video discusses also the possibility to use pointer access. But this is a question of associations (UML thinking), and some questions are open regarding code style, public access, const access. Associations are not yet ready to use handled in the version 2025-07, should be added in the next time. Then this video is still valid, and a second video using associations will be offered in parallel.

2.2.3. PID control - with different numeric data types

PIDctrlN
Figure 3. Explain PID ctrl with numeric DTypes

This video (21 min) shows the example ''Position control with PID'' which is implemented with float, int32 and int16 arithmetic. It shows more details about controlling effects, especially the D-Part in PID controlling, than details of the OFB concept. But may be interesting as application example.

SelectNumericTypePIDctrlPos
Figure 4. How select the numeric DTypes

This second video (11 min) for the same diagrams now shows, how the numeric data types are selected in code generation and from the given (legacy) core C codes.

2.2.4. Integer and saturation arithmetic, using fractional bits

IntegerArithmSaturation
Figure 5. IntegerArithmSaturation

This video (26 min) shows how integer artithmetic with dedicated number of fractional bits is used beside float arithmetic, with automatic conversion between, and especially how saturation for integer arithmetic is possible and works. Hint: The video has some technical hanging effects especially on end. It should be replaced by a new version.

2.2.5. How insert an icon and macro in LibreOffice draw for the translation

Macro OFBwr
Figure 6. Macro_OFBwr

This video (8 min) shows how to insert a macro in the LibreOffice toolbar to fast start the OFB translation from LibreOffice (after saving the file).

The translation itself is controlled by a batch file (TODO offer also a shell script for linux) from the stored file.odg content. The macro does the same as start the batch file from outside. But it is faster to handle.

2.2.6. Fix a problem with hanging socket on CurveView

SocketHangingProblem
Figure 7. SocketHangingProblem

Not all is perfect. The current version of the CurveViewApplication has the problem that sometimes (rarely) it is not correct closed, and the used socket remains open. This problem should be fixed in the CurveViewAppl, which is only used here as helper. But it is not fixed yet in the moment. If it occurs, "a new boot is good", booting the PC helps. But to fix the problem also only the hanging process can be killed, using the TaskManager (of Windows). This video (8 min) shows the problem, and show how to find the blocked socket in the ResourceMonitor on Windows and kill the process. The process-ID is written to the socket in the Resource Monitor. But it is unfortunately not written in the standard view of the task manager, only in the "Details" view on the task manager.

3. Presentation on Linux-Day in Augsburg, Germany

My presentation in German language has shown the OFB-Converter only as example how to use indirect styles in documentation and graphic. The topic there was LibreOffice, not the OFB-Converter. But nevertheless the presentation may show some hints on usage also for the OFB topic:

https://www.luga.de/static/LIT-2025/talks/nutzung_von_styles_in_libreoffice_draw_zur_semantischen_kennzeichnung_von_elementen/

https://youtu.be/CfxPV5skklM The presentation itself, German.

4. New version 2025-04-02:

Hint: The videos below are also valid for the current version, only small changes in implementation are different. The approach and system is not generally changed.

Many details are improved in the last year, in the work is also current in progress. But new versions has run also in the past with changed versions. The base is stable.

My own main focus should now be on improving the comprehensibility of the sources (programmed in Java) All tagged or downloadable versions are (and should be in the future) tested and fulfill the examples shown. The second effort should go into the documentation. The state machines are not yet available, but are in progress. Follow the videos. They show what is available.

../deploy/OFB_presentation-2025-04-02.zip

4.1. Unpack zip file, use code generation

OFB presentation 2025 04 02
Figure 8. OFB_presentation-2025-04-02.zip

This video right side on the image shows how to unpack and start test with the new zip file from 2025-april-02. It is a short presentation, 6min with ~43 MByte

4.2. Detail explaination with example BandpassFilter

ExmplBandpassFilter
Figure 9. OFB_presentation-2025-04-02.zip

This video (in German language) right side on the image is an introduction to the new zip file from 2025-april-02. It is a longer presentation, 1h10min. The resolution is reduced (to save a little bit our world), it uses only ~200 MByte space on the server and for traffic.

5. Older content from ~2024

Older zip file to download:

The following videos are the old ones, still valid exclusive small details. They will be replaced step by step by videos with the newer versions if necessary.

A documentation can be viewed or downloaded, see start of this page.

Older and not complete documentation:

5.1. First example from 2024, goal of graphic in Libre/Open office

CopyTplFirstModule
Figure 10. CopyTplFirstModule

This first video (12 min) shows how to copy and use the template in LibreOffice for a first simple own UFBgl-diagram. It shows the general approach drawing UFBgl diagrams.

UFBgl 2 CodeGenerationFirst
Figure 11. UFBgl-2-CodeGenerationFirst

This second video (16 min) shows the code generation for this first example,

5.2. Comprehensive example: Bandpass Filter for 50 Hz electrical grid

BandpassFilter FBgl srcC en
Figure 12. BandpassFilter_FBgl_srcC-en

This video (8 min) explains a more comprehensive module or graphical model. It is the first video for that example and shows the approach how to deal really with graphical modelling.

BandpassFilter Test Scope en
Figure 13. BandpassFilter_Test_Scope-en

This video (13 min) shows how test results are output in a curve view, and how the functionality can be designed, tested and improved in the graphic module, with help of execution the generated code.

CodeGeneration Scope en
Figure 14. CodeGeneration_Scope-en

In this video (10 min) it is shown how the code generation for this specific scope program is done, with preparing of an ethernet telegram to the scope "Curve View" application, inclusively generation of the configuration of the code generation script

5.3. Details about running mode

UFBgl 3 VisitDebugTheCode
Figure 15. UFBgl-3-VisitDebugTheCode

In this third video (6 min) it is shown in single step in the generated code how the initialization works. It is also the concept of ../../emC/index.html[emC] for the phases constructor, initialization and run.

UFBgl 4.AggregationInCtor
Figure 16. UFBgl-4.AggregationInCtor

This video (8 min) enhances the example in the video above with the possibility to assign the aggregation between the classes in the constructor instead in the init…​() routine. Both is possible.

Also the possibility of vice-versa aggregations are explained. But not full completely. The topic is, vise-versa aggregations in the constructor are not possible if allocated memory is used. Because the other instance does not exists if it is necessary for referencing in the constructor. That’s why aggregations can also be assigned in the init, after construction of all instances. This topic should be explained in an extra video, yet todo

6. Hints Handling load, file tree

Also handling with "load tools"

Hint for the file tree in the examples: The generally approaches for the file tree are described in ../../SwEng/html/srcFileTree.html.

It means here:

Working_tree_where_zip_is_unpacked
 +-tools           This is created after src/load_tools
 +-IDE             This is created after executing a +spawn_IDE_....bat
 |  +-Example_Component
 |     +-CB        for Codeblocks projects to execute and test
 |     +-MSC       for Visual Studio projects to execute and test
 +-src             The sources, only this directory is contained in the zip
    +-load_toos    To load the translation tools for UFBgl from vishia page
    +-src_emC      Version of used sources from emC (embedded multiplatform C/++)
    +-Templates_odg contains the odg template file, and makescripts to create onw stuff
    +-Example_Component
    |  +-IDE...        The IDE files to spawn it.
    |  +-+spawn_IDE_....bat click it to spawn
    |  +-odg           Here is the odg file for this example
    |  +-cpp           Some C/++ files
    |  |  +-genSrc     This are the destination for generated C/++-Files
    |  +-cmpGen        This directory contains the versions from older generations, to compare
    |  +-curveView     Files for the CurveView toool
    |  +-makeScripts   Files to translate the module.
    +-ExmplBandpass    It is such an example
       +-IDE
       +-odg           ... etc.