Embedded Systems Visual programming for rapid application development

Lawaflow is visual programming method enabling software designers to create programs using software component symbols representing program functions and the flow of data between these. The system has strong support for flow based programming principals and parralell event driven program execution.

Lawaflow Visual Programming

Embedded Systems Visual Programming Online

All editing and Lawaflow program development is done online and the ready code can be deployed on any supported device connected to the system. The target device can be locally connected by the user’s computer or through remote IP connectivity. The Lawaflow software only need a Java enabled web browser to work.

The software creation process starts with creating a project and at least one schematic. On the schematic canvas, function elements are placed representing the different software functions. The inputs and outputs of the elements are connected representing the data and event flow. During run time the elements are executed based on the event states of its inputs and priority condition. When the elements execute they generate new events and data that is input for other elements in the system.

An often used or complex set of elements can be stored as a macro schematic and represented by a macro element. Both re-usability of code and high abstraction level is then achieved.

A project can have any number of schematics and macros, only limited by the memory and execution capabilities of the target system. The schematics are useful to separate different program functionalities and modules but all are considered for execution in parallel at run time.


Components and Libraries

A large library of pre-made functions can be complemented by user built function libraries. The software execution is based on data event driven execution with event logic and priority resolution controlling each elements execution, giving the developer full control of the software execution. Full macro function support allows for graphical macro elements being created from element schematics enabling easy reuse and inheritance of created functionalities. Macro elements allow a high abstraction level of complexity in schematics.

The system can output result in different formats supporting most user needs. Supporting the gcc compiler the run time code can be deployed on many bare metal processors or integrated with other software running on OS or RTOS. Pure ANSI C code can be generated.

Lawaflow Visual Programming Component

Create your own components

Lawaflow allows the user to create their own software components and integrate them to the users library for reuse and sharing with other users. Components can be created in C code or as macro components besed on existing schematics.


Lawaflow Embedded Platform deployment

Easily deploy programs to platforms

A Lawaflow program is easily deployed to the platforms that are connected to the system, either through Internet or local connectivity. The system can also generate executable code to be flashed to the terget.



Program execution

A Lawaflow program executes on a parallel and event driven flow based concept. For a component element to execute, an event must appear on at least one of its inputs. When the elements event logic condition is fulfilled and the element is first in the priority queue, it will execute and produce events and data on its outputs. A Lawaflow component element always generates event data on its outputs when executed. In this way the events and data will “flow” in parallel through the system and trigger element executions. A Lawaflow project consisting of one or more schematics with macro elements are not themselves executed as entities but instead at code generation all schematics and macros are resolved into the individual component elements that are all processed in parallel and executed based on event execution logic and priority conditions. This model ensures a parallel and secure execution of the application software.

Execution model

The execution model for the component elements in the execution pipeline is round robin style with priority evaluation and aging. For time critical systems the execution of schematics be set for interrupt driven execution. This has to be supported by the target system. Lawaflow also supports integration with RTOS with different integration models.

Component event logic

For an component element to be able to run, the execution event logic condition must be set true. The condition is usually a logical AND or OR. Specific logic conditions can be set for user created elements. When the event logic condition is fulfilled for an element it is placed in the execution pipeline and evaluated for priority and aging condition.

Components, Macro and Schematics priority conditions

Component elements can be given 2 types of priorities. The execution priority that can be set by the user and the aging priority that is set by the system. By default all element have the same execution priority. This can be changed by the user for each element. The aging priority allows an element in the execution queue to get an increased priority the longer it remains in the queue.

All Schematics in a Lawaflow project are given by default the same priority, these settings can be changed by the user so that the whole schematic has a higher priority, thereby all elements in the schematic are given a priority change proportional to the Schematics. The same is applicable for macro components.