Author: Oreste Bernardi, Infineon Technologies AG<\/p>\n
Increasingly complex libraries are being developed for microcontrollers to accommodate the rising performance levels of microcontroller peripherals and applications. The usual configuration methods using #defines and\/or data structures can be time-consuming and result in configuration errors. A graphical user interface coupled with a configuration generator offers a number of advantages here. Besides the obvious readability and parameter description benefits, a GUI could check and validate user input in real time. Unfortunately, GUI programming know-how is beyond the usual sphere of competence of microcontroller developers and acquiring this knowledge could be time-consuming. This article explores a novel approach to creating a user interface and a code generator to support the configuration of source code libraries. This approach is suitable for developers who do not have GUI programming expertise as it implements a new UI execution model that simplifies development and debugging.<\/strong><\/p>\n New silicon technology is enabling more and more complex SOCs. This is evident also in microcontroller developments: we are seeing more flexible peripherals, more peripheral instances and more pins. A good example is Infineon\u2019s XMC4500 microcontroller. This microcontroller can be used for motor control and power conversion and is not particularly complex. Its reference manual describes more than 7050 register bit fields (the number doesn\u2019t include duplicate register bit fields due to multiple instances of the same peripheral).<\/p>\n As a result, software libraries that support microcontrollers such as these are becoming more complex and difficult to configure given the number of parameters. The majority of microcontroller libraries are developed in C. Typically the user configures the library in two stages: during compilation using the\u00a0#define<\/em>\u00a0pre-processor macro and during runtime by activating configuration functions with appropriate arguments. However, these methods are not suitable for large and complex software development projects.<\/p>\n Code generators with a graphical user interface are already used to generate configuration macros and initialization functions. Examples include DAVE\u2122, the Vector AUTOSAR ECU configuration tool, STM32Cube and Processor Expert. Usually, the GUI of these tools also checks the consistency of user settings, providing pictures and tool tips to clarify the meaning of configuration parameters and guide the user in how to set them.<\/p>\n Hence a C library should ideally be provided with a GUI-based configuration tool. Developers of deep-embedded C libraries do not typically have a good knowledge of GUI programming.<\/p>\n We experienced this issue directly when developing Apps for DAVE\u2122 v3. DAVE\u2122 is a free IDE and code generator developed by Infineon to support its XMC industrial microcontroller family. The code generator is based on the concept of Apps. A DAVE\u2122 App essentially combines:<\/p>\n DAVE\u2122 also comes with a DAVE\u2122 SDK to develop Apps.<\/p>\n The App concept was introduced in DAVE\u2122 v3 but our developers had difficulty developing complex GUIs because they are specialized in deeply embedded code and not in GUI programming. The GUI design process was very easy thanks to our WYSIWYG tool but GUI logic implementation was slow and error-prone. In DAVE\u2122 v3, we used typical UI programming methods based on call-backs. The developer can register a call-back for each event of a widget UI; if an event fires (i.e. user enters a value in a widget), the registered call-back is executed.<\/p>\n The most important limitations that we experienced were:<\/p>\n The same variable can be accessed by multiple call-backs and this makes it more difficult to debug and understand the code. By way of example, assume that a variable has a wrong value and the developer would like to review the code that affects the target variable. In this case, the developer has to inspect all code that could access this variable.<\/p>\n It is quite easy for App developers to create hidden states that are sensitive to the order of user inputs. A simple example of this scenario is shown in figure 1 (see\u00a0PDF<\/a>).<\/p>\n There are two checkboxes with two different call-backs that assign two different values to the same variable. Obviously, the user can create the same configuration for the checkbox with two different mouse click streams \u2013 but the result is completely different. This issue is very relevant for one important feature of DAVE\u2122: project upgrades to the latest App versions. Project upgrades are performed by creating a new project, adding the latest Apps and then copying the configuration parameters from the old project to the new one. In cases such as that described, DAVE\u2122 v3 was not able to correctly upgrade the project because it had no understanding of the JavaScript code used to define the call-backs and it was not recording the order of user operations.<\/p>\n These are just some of the issues typically encountered with traditional GUI programming.[1][2] For this reason, GUI programming requires discipline and experience. However, our developers spend 90% of their time developing efficient C libraries and can only dedicate a small window to user interface programming.<\/p>\n In our search for a solution, we came across the Reactive Programming (RP) paradigm. This paradigm focuses on the propagation of changes and data flow.[3] Every day, millions of people use a tool based on this paradigm: the common spreadsheet.<\/p>\n In a spreadsheet, a cell contains a value or a formula that defines its value. As soon as this value is changed by the user, all cells that contain a formula directly or indirectly affected by the modified cell are updated.<\/p>\n The spreadsheet concept (Reactive Programming) thus had the potential to solve our problems. Let\u2019s call the cells\/variables that contain constant values only\u00a0free variables\u00a0<\/em>(cells A1, B1 and C1 in fig. 2) and the cells\/variables that have been assigned a function\u00a0not free variables<\/em>\u00a0(cells A2 and B3 in fig.2, see\u00a0PDF<\/a>). The\u00a0free variables<\/em>\u00a0can be considered as the GUI inputs and the\u00a0not free variables<\/em>\u00a0together with their formulae as the GUI logic. Debugging a GUI developed according to this concept is very easy. One\u00a0not free variable<\/em>\u00a0is associated only with one formula or code, the execution of which only affects the assigned variable. So if its value is wrong, the developer has just to inspect the code linked to this variable. If it is correct, the developer checks the code linked to the input variable and so on \u2013 right down to the user inputs.<\/p>\n This also solves the problem of hidden states. In fact, the state of UIs based on this concept is defined by the value of the\u00a0free variables.<\/em>\u00a0For the programmer, it is impossible to create a GUI\/spreadsheet where the results depend on the order of the inputs.<\/p>\n There are other advantages of the reactive paradigm\/spreadsheet concept. In fact, a dependency graph [5] can be built in such a way that it is possible to:<\/p>\n In DAVE\u2122 v4, we used this simple concept to accelerate development and improve the quality of our Apps. DAVE\u2122 v4 App developers essentially write a simple Groovy [4] class. We chose Groovy over other Domain Specific Languages (DSL) for the following reasons:<\/p>\n Every time a user adds an instance of an App, the constructor of the class is executed and it configures the UI by assigning functions to variables that represent the different properties of the GUI widgets.<\/p>\n Figure 2 (see\u00a0PDF<\/a>) shows a very simple user interface with a DAVE\u2122 App. The developer wants to show the message \u201cSpeed too high<\/em>\u201d if the motor speed settings exceed 100.<\/p>\n Essentially the developer assigns one function to the\u00a0visible<\/em>\u00a0property of the\u00a0high_speed_msg<\/em>\u00a0widget. As soon as the value of\u00a0motor_speed<\/em>\u00a0changes, the function is evaluated and the returned value assigned to the\u00a0visible<\/em>\u00a0property.<\/p>\n The Groovy compiler parses the MF (Manifest Function) definitions; it extracts the input variables and it modifies the code so DAVE\u2122 is able to build the dependency tree at runtime. Moreover, the compiler checks that the MF code doesn\u2019t contain any assignments to variables that are not locally declared. This ensures that there are no side effects (or hidden states) during the execution of MF code.<\/p>\n After the development of around 100 Apps with the DAVE\u2122 v4 SDK, our programmers confirmed that they had reduced development time and encountered fewer bugs during testing. Moreover, they were able to program more complex GUI implementations relative to DAVE\u2122 v3. An empirical study confirmed these quality improvements and greater programming abilities.[6]<\/p>\n If C programmers want to design a GUI-based configurator for any library, the advanced methodologies implemented in DAVE\u2122 and the DAVE\u2122 SDK are ideal. These tools can be downloaded from\u00a0www.infineon.com\/dave<\/a>. Using the video tutorials provided, programmers can rapidly develop their own graphical library configurator.<\/p>\n However Reactive Programming is an emerging trend in desktop and mobile UI programming [7] [8] and also relevant to certain safety-critical embedded software development projects[9]. In the opinion of the author, this paradigm will expand its reach to embedded software development \u2013 especially to UI programming.<\/p>\n Complex microcontroller libraries should be provided with a configuration tool that simplifies correct configuration. However, developers of deeply embedded code have little experience in complex UI programming. For this reason, the DAVE\u2122 v4 SDK has implemented a Reactive Programming concept. The aim is to improve the quality and speed of GUI development. After developing around 100 DAVE\u2122 Apps, our programmers confirmed the advantages of functional Reactive Programming over traditional GUI programming. DAVE\u2122 v4 and the DAVE\u2122 SDK can be downloaded free of charge and used by developers interested in exploring easy, safe GUI programming.<\/p>\n [1] Jonathan Edwards. 2009. Coherent reaction. In\u00a0Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications<\/em>\u00a0(OOPSLA ’09). ACM, New York, NY, USA, 925-932. DOI=10.1145\/1639950.1640058\u00a0https:\/\/doi.acm.org\/10.1145\/1639950.1640058<\/a><\/strong><\/p>\n [2] Martin S\u00fastrik\u00a0https:\/\/250bpm.com\/blog:24<\/a><\/p>\n [3] Wikipedia\u00a0https:\/\/en.wikipedia.org\/wiki\/Reactive_programming<\/a><\/p>\n [4]\u00a0https:\/\/www.groovy-lang.org\/<\/a><\/p>\n [5]\u00a0https:\/\/en.wikipedia.org\/wiki\/Dependency_graph<\/a><\/p>\n [6] Guido Salvaneschi, Sven Amann, Sebastian Proksch, and Mira Mezini. 2014.\u00a0An empirical study on program comprehension with reactive programming<\/em>. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014). ACM, New York, NY, USA, 564-575. DOI=https:\/\/dx.doi.org\/10.1145\/2635868.2635895<\/p>\n [7]\u00a0https:\/\/www.infoq.com\/news\/2013\/08\/reactive-programming-emerging<\/a><\/p>\n [8]\u00a0https:\/\/www.gartner.com\/doc\/2560015<\/a><\/p>\n [9]\u00a0https:\/\/en.wikipedia.org\/wiki\/Lustre_(programming_language)<\/a><\/p>\n Beitrag als PDF downloaden<\/strong><\/a><\/p>\n Wollen Sie sich auf den aktuellen Stand der Technik bringen?<\/strong><\/p>\n Dann informieren Sie sich\u00a0hier<\/strong>\u00a0<\/a>zu Schulungen\/ Seminaren\/ Trainings\/ Workshops und individuellen Coachings von MircoConsult zum Thema Implementierung \/Embedded- und Echtzeit-Softwareentwicklung.<\/p>\n Training & Coaching zu den weiteren Themen unseren Portfolios finden Sie\u00a0hier<\/a>.<\/strong><\/p>\n Wertvolles Fachwissen zum Thema Implementierung\/\u00a0Embedded- und Echtzeit-Softwareentwicklung steht\u00a0hier\u00a0<\/strong><\/a>f\u00fcr Sie zum kostenfreien Download bereit.<\/p>\nDAVE\u2122v3<\/h2>\n
\n
\n
Scattered Code<\/h2>\n
Hidden States<\/h2>\n
Reactive Programming – Think Spreadsheet!<\/h2>\n
\n
DAVE\u2122 Implementation<\/h2>\n
\n
Example<\/h2>\n
Developer Experience<\/h2>\n
Beyond DAVE\u2122<\/h2>\n
Conclusion<\/h2>\n
References<\/h2>\n
\nImplementierung – unsere Trainings & Coachings<\/h2>\n
\nImplementierung – Fachwissen<\/h2>\n