RU2668738C1 - Method and system for visual creation of programs for computer devices - Google Patents

Abstract

FIELD: information technology.SUBSTANCE: invention relates to a method and system for visual creation of programs for computing devices. System comprises a graphical user interface through which an algoblock program for the computing device is created by selecting and the adding of algoblocks from the list of available algoblocks, and the creation of an algoblock program is performed by specifying a sequence of algoblocks and links between their inputs and outputs by setting a pre-fixed sequence of algoblocks for the settings of the algoblocks and the connections between their inputs and outputs, and executing the hardware and software environment that implements the algoblock program, which sequentially executes the algorithm after the algoblock, choosing from their first list (array) their codes and links – references to the data for this algoblock – in the second list (array), and the executing environment operates under the control of the source code of the algoblock program consisting of the mentioned arrays, created and modified in the visual environment of algoblock programming and is an interpreter, and each block is accessible to the entire volume of the mentioned data sets.EFFECT: technical result is to automate the creation of programs for computing devices.13 cl, 38 dwg, 9 tbl

Description

Technical field

The invention relates to computer systems and, more specifically, to systems and methods for creating programs for computing devices, namely for the visual creation of programs for computing devices.

State of the art

Currently, the vast majority of existing programming methods and systems remain textual (scripted). They require the programmer to know the correct use and location of text characters (letters, numbers, punctuation marks, etc.), not every combination of which is the correct text of the program, that is, excessive freedom of action during programming leads to the possibility of syntax errors, significantly complicating and lengthening the programming process and distracting from its main task - the creation and implementation of the correct algorithm. The programmer is overloaded with unnecessary knowledge on the use of text characters and their combinations and efforts to comply with these rules, distracted from the programming process itself.

To overcome this fundamental drawback of all text (scripting) languages, visual languages and programming systems that provide a symbolic representation of a programming language operation as a single graphic symbol and a visual representation of the relationship between such operations allow. This representation allows the programmer to specify the operation (operator) by choosing from an acceptable set of operations, and the transmission of the operation data by visual indication of the connection with another operation from where this data should come from. This eliminates the need for the programmer to independently select the correct combination of characters that encode both the operation itself and the task of its source data. However, existing systems and methods of visual programming are only pre-translators to script (text) languages and therefore inherit some of their shortcomings.

For example, there is a method for visually programming a set of instructions for a process (see Application: 2006113579/09, Publ. 27.10.2007), comprising receiving a request for a process design; providing an interactive display of the process designer; storing a library containing at least one function, accepting, through the interactive display of the process designer, information related to the function related to the function of the function, which contains at least one of the function input, function output, connection input to function, connection output from functions and function settings; the conclusion, through the interactive display of the process designer, a graphical representation of the information associated with the function and generating a set of instructions for the process based on the function and information associated with the function.

As already noted, the disadvantages of existing technical solutions are the need for the user to know the syntax of programming languages, the large amount of time spent by the user on creating and debugging programs for computing devices, as well as the low speed of interpreting the created programs for computing programs in real time.

The objective of the present invention is to overcome the disadvantages of existing technical solutions.

SUMMARY OF THE INVENTION

The main difference not only from all script (text) programming systems, but also existing visual programming systems, for example, the above-described visual programming method and the like, is the proposed method and the system of the present invention that implements it provides direct visual selection of the desired function from the list of possible with immediate the execution of automatic data type matching and visual presentation of the result immediately at the time of selecting the function, rather than generating a set and text commands (scripts) that perform the desired function (operation, operator) with their subsequent parsing, including analysis of the correctness of data type matching, compilation and only then execution.

The technical result achieved by the present invention is to reduce the time and cost spent by the user on creating programs for computing devices, as well as to increase the speed of interpretation of created programs for computing programs in real time.

Also, the technical result achieved by the present invention is to reduce the time and cost necessary for the user to learn programming tools, and then to create and debug programs using them for computing devices.

Also, the technical result achieved by the present invention is to increase the speed of interpretation of the created programs for computing devices, which allows you to implement programs that run in real time.

Also, the technical result achieved by the present invention is to enable reliable verification of the program being executed due to the unambiguity of restoring the program code of the existing program for its analysis.

A method and system for visually creating programs for computing devices in which a user creates and edits a program (algoblock program) for a computing device by means of a graphical user interface by selecting and adding operators (algoblocks) from the list of available algoblocks is performed, then the user is connected to the inputs and outputs of algoblocks, which ensures the specification of data flows between operators (algoblocks), immediately after their creation algoblocks perform actions specified by a code of their type (or type code and their additional parameters) on the data supplied to the inputs of the algoblocks, in accordance with visual connections with the outputs of other algoblocks (represented by links in the form of rows in the table containing the number of the algoblock and its output, which at the same time specify the visual arrangement of communication lines) - from at least one output of at least one algo block, or by links containing the index of the value in the general data array (data arrays are vectors and or data matrices that are stored in the database), while the results of the above-mentioned actions of the algoblocks remain either at the outputs of the algoblocks (the vector or matrix of which make up the database of outputs), or are written in accordance with the links or links (specifying the number of the element in the data array where the result is stored) into shared data arrays.

Visually algoblocks are graphic elements, which, in turn, are visual images of devices or processing units in the form of rectangles, tables, mnemonic images of blocks or processing units. Visually, communication lines, or link pointers between the inputs and outputs of the algoblocks and / or between sets of data arrays that are stored in the database, are also presented.

Creating an algoblock program can be carried out in the following ways:

- by setting at least one sequence of algoblocks and connections between their inputs and outputs or between their inputs and outputs and data arrays;

- by setting for a predetermined sequence of algoblocks the parameters of the settings of the algoblocks and the connections between their inputs and outputs or between their inputs and outputs and data arrays.

The algoblock program is executed by the runtime environment, which is an immutable program and which sequentially executes the algoblock behind the algoblock, selecting their codes and links from the first list (array) - the data links for this algoblock are in the second list (array), that is, the runtime runs under the control of the source code of the algoblock program, consisting of the mentioned arrays, created and modified in the visual environment of the algoblock programming, it is an interpreter, and each algob oku available the entire volume of said data arrays.

If it is necessary to simultaneously solve problems with a different period of data processing by the visual programming system and the runtime, it is possible to separate algoblocks into different bypass cycles:

- the first cycle has the shortest execution period - in this cycle, tasks that require the most frequent execution are solved;

- the second execution cycle can be divided (divided) into several parts, and after each execution of the first cycle, the algoblocks of the next part of the second cycle from the first to the last are executed sequentially, and the entire second cycle is performed for as many periods of execution of the first cycle as the number of parts of the second cycle ;

- the third cycle corresponds to the second, as the second to the first.

The execution of the algoblock program is performed by the runtime in an infinite loop, with the exception of special modes, when the program is limited to one cycle.

Creating and editing an algoblock program is carried out by editing the user of the arrays that make up the algoblock program by specifying or editing the sequence of algoblocks by selecting them from the list of possible types of algoblocks and specifying input data for the algoblocks or by graphically indicating the connections of the inputs and outputs of the algoblocks, or by choosing the inputs and outputs from a list of possible databases and their item numbers.

Due to the impossibility of entering invalid or incorrect data at any time when creating and / or editing the algoblock program, the algoblock program does not contain syntax errors and looping errors, which allows its execution to continue while the runtime program is being created and edited and, in turn, allows visual control of the result of editing the program directly at the time of editing.

Since the creation and editing by the user of the mentioned arrays constituting the algoblock program is carried out by defining or editing the sequence of algoblocks by selecting them from the list of possible types of algoblocks and specifying the input data for them in the graphical user interface or by graphically indicating the connections of the inputs and outputs of the algoblocks, or by selecting data from their list permissible, thereby guaranteeing the impossibility of entering invalid or incorrect data at any time during the creation or editing of an algoblock program and allows you to continue its implementation when you create and edit it in the absence of syntax errors and loop errors, providing visual control of the result of editing the program immediately at the time of its execution.

When creating and editing an algoblock program, the data types between the inputs and outputs of the algoblocks (operators), as well as between the inputs and outputs of the algoblocks (operators) and between external databases, are automatically coordinated according to predefined rules.

When creating and editing an algoblock program, direct text input of numbers or other symbol sequences is carried out with control directly during input of both the validity of each character input and the validity of the input number or other character sequence in such a way that at the moment of input completion this number or sequence immediately could be used in an algoblock program.

It is possible to create and edit the algoblock program on one computing device, followed by the transfer of the algoblock program to another computing device, from where the current program data is then obtained, and the stored and transmitted algoblock program uniquely and completely corresponds to the originally created algoblock program, and therefore can be extracted from the computing device on which it is executed by extracting the arrays of the above-described arrays , displayed, verified (verified) and edited by the user on another computing device.

Depending on the tasks to be solved, the structure and volumes of information requiring processing, block-based programs are divided into three levels:

- the lower level with a small amount of data and, accordingly, the ability to foresee a set of all the necessary operations for their processing - at this level, the set and sequence of algoblocks are fixed, part or all of the algoblocks are implemented in hardware, programming consists in setting up connectives for the given algoblocks and parameters of the algoblocks is the most simple and affordable;

- an average level with a small amount of data requiring a wide variety of processing functions - for this level, the sequence of algoblocks and their types are specified during programming, the database consists of the outputs of the algoblocks, the connections for the inputs of the algoblocks refer to the outputs in this database, a small part of the algoblocks can be implemented hardware, at this level, the algoblock programming system is a digital model of an analog computer;

- the upper level, characterized by large amounts of information: when programming, the sequence of algoblocks and types are set, the databases are external and links to them are set for inputs and outputs.

Between algoblock programs of different levels, interaction is performed by setting the links between their databases, similar to the bundles (links) inside the algoblock programs.

The interaction between the algoblock programs of various computing devices is performed by setting the connections between their databases, similarly to the bonds within the algoblock programs or the bonds between the algoblock programs of various levels within the same computing device, while the actual data transfer between the devices can be carried out according to any existing or future communication channels between computing devices.

The invention is illustrated by drawings:

In FIG. 1 shows an exemplary embodiment of a mid-level algoblock program according to one implementation of the present invention;

In FIG. 2 shows a menu allowing a user to add a new algoblock, according to one implementation of the present invention;

In FIG. 3 shows an exemplary embodiment of components of an algoblock program, according to one implementation of the present invention;

In FIG. 4 shows a window (menu) for setting parameters of an algoblock, according to one implementation of the present invention;

In FIG. 5 shows an exemplary embodiment of displaying an operation error by an algoblock, according to one implementation of the present invention;

In FIG. 6 shows an exemplary embodiment of an algoblock program with added logical algoblock and task algoblock, according to one implementation of the present invention;

In FIG. 7 shows a submenu of output data for the task unit according to one implementation of the present invention;

In FIG. 8 shows a menu for setting a value for an algoblock input, according to one implementation of the present invention;

In FIG. 9 shows an algoblock parameter setting menu for changing the default value of an algoblock input according to one implementation of the present invention;

In FIG. 10 shows an exemplary embodiment of an algoblock settings interface, according to one implementation of the present invention;

In FIG. 11 is a window of properties of the comparison algoblock, according to one implementation of the present invention;

In FIG. 12 shows one embodiment of a system window of a program according to one implementation of the present invention;

In FIG. 13 is a window of a visual table programming environment used to create an algoblock program at a higher level according to one implementation of the present invention;

In FIG. 14 shows an algoblock editing window in a top-level algoblock program editing mode according to one implementation of the present invention;

In FIG. 15 shows a data source selection menu for an algoblock, according to one implementation of the present invention;

In FIG. 16 shows an algoblock editing window with the selected “Arithmetic” operation as an operation for two operands, according to one implementation of the present invention;

In FIG. 17 shows a menu for selecting the type of arithmetic operation that is performed by the user when selecting the type of arithmetic operation, according to one implementation of the present invention;

In FIG. 18 shows an example of an algoblock editing window with the selected “Arithmetic” operation as the operation for two operands, according to one implementation of the present invention;

In FIG. 19 shows a database window of analog signals, according to one implementation of the present invention;

In FIG. 20 is an example of setting a step by a user for terms and sums, according to one implementation of the present invention;

In FIG. 21 shows a database window of analog signals for an algoblock, according to one implementation of the present invention;

In FIG. 22 depicts an exemplary embodiment of procedures and execution control, according to one implementation of the present invention;

In FIG. 23 shows an exemplary embodiment of an algoblock structure, according to one implementation of the present invention;

In FIG. 24 shows an exemplary embodiment of the structure of the operand of an algoblock, according to one implementation of the present invention;

In FIG. 25 shows an exemplary embodiment of the structure of the operation and the result, according to one implementation of the present invention;

In FIG. 26 shows an example of the structure of these operands and the result determined by the list, according to one implementation of the present invention;

In FIG. 27 shows an exemplary user interface for interacting with databases, according to one implementation of the present invention;

In FIG. 28 shows one embodiment of a user interface for describing a database, according to one implementation of the present invention;

In FIG. 29 shows an exemplary embodiment of an algoblock slot, according to one implementation of the present invention;

In FIG. 30 shows an exemplary embodiment of an algoblock of a Memory slot, according to one implementation of the present invention;

In FIG. 31 shows an exemplary algoblock of a FRAM slot, according to one implementation of the present invention;

In FIG. 32 shows an exemplary algoblock of a CAN slot, according to one implementation of the present invention;

In FIG. 33 shows an exemplary embodiment of an algoblock list window, according to one implementation of the present invention;

In FIG. 34 shows an embodiment of an arithmetic algoblock, according to one implementation of the present invention;

In FIG. 35 shows an exemplary display of two interconnected algoblocks, according to one implementation of the present invention;

In FIG. 36 shows an exemplary appearance of an algoblock parameter setting window according to one implementation of the present invention;

In FIG. 37 shows a window for configuring inputs of an algoblock, according to one implementation of the present invention;

In FIG. 38 shows a window (of an interface, page, etc.) for setting the outputs of an algoblock, according to one implementation of the present invention.

The objects and features of the present invention, methods for achieving these objects and features will become apparent by reference to exemplary embodiments. However, the present invention is not limited to the exemplary embodiments disclosed below, and may be implemented in various forms. The essence described in the description is nothing more than the specific details provided to assist the specialist in the field of technology in a comprehensive understanding of the invention, and the present invention is defined only in the scope of the attached claims.

Used in the present description of the invention, the terms "component", "element", "system", "module", "part", in particular, "component", and the like are intended (used) to refer to computer entities (entities / objects associated with a computer, computing entities), which can be hardware / equipment (for example, a device, instrument, apparatus, equipment, part of a device, in particular, a processor, microprocessor, printed circuit board, etc.), software (on Example, executable program code, compile the application, software module, part of the software and / or code, etc.) or firmware (firmware / firmware). So, for example, a component can be a process running / executing on a processor, a processor, an object, an executable file, a program, a function, a method, a library, a subprogram and / or a computing device (for example, a microcomputer or a computer) or a combination of software or hardware.

The present invention describes a method and system for visually creating programs (software) for computing devices with a runtime system (runtime), in particular, a method and system for creating software using visual elements — graphic elements or tables, including the runtime created software.

The described system of visual programming, including the execution environment, is primarily intended for the creation of self-propelled guns (automatic control systems) and automated process control systems (automated process control systems), primarily real-time components of such systems, industrial facilities from a separate unit (for example, a pump or machine), workshop, pump station, nuclear reactor, etc. to the plant, power station or the entire gas pipeline, vehicles (cars, trains, aircraft ships, etc.), urban infrastructure, including, for example, a "smart home", etc., and is designed to program primarily industrial controllers , tablet, panel, on-board and desktop computers in such systems. However, it is possible to use this system for programming any computer devices, including cell phones, watches, household appliances, communications, information, entertainment, etc.

Visual programming is implemented as an imitation of the assembly, configuration and commissioning of a real device, for example, an analog computer or a control system:

- or by choosing from a fixed set of the necessary blocks or processing units, connecting them together or in the form of, for example, wires or pipes in the desired sequence;

- or laying out the cells, filling in the cells of a fixed structure - the table - elements (blocks, nodes, links) by choosing from a list of possible for each cell;

- subsequent adjustment by changing the parameters of the nodes in the ranges limited by the admissibility limits.

Data between processing nodes, which are language operators, are automatically negotiated according to predefined rules.

In the particular case of the implementation of the present invention, graphic elements are visual images of devices or processing units — algoblocks (which are described in more detail below), for example, in the form of rectangles, tables, mnemonic images of blocks or processing units, as well as communication lines or link pointers between them inputs and outputs and / or between sets of data arrays that can be stored in at least one database, for example, as a single table or several tables.

Visual algoblock programming language allows you to create software (for example, applications):

- by setting at least one sequence of algoblocks and connections between their inputs and outputs or between their inputs and outputs and arrays of processed data:

- by setting for a predetermined sequence of algoblocks the parameters of the settings of the algoblocks and the connections between their inputs and outputs or between their inputs and outputs and arrays of processed data.

Algoblocks are the operators (components) of the described method and system — the visual algoblock programming language. Algoblocks carry out the actions specified by a code of their type or type code and their additional action parameters (for example, addition, maximum search, logical operations, integration over time, etc.) over the data coming into them, algoblocks, inputs, in accordance with the connections, specified links or links (for example, as rows in a table containing the number of the algoblock and its output, where the data are taken from, or containing the index of the value in the array (in the database) of the processed data) from at least one output of at least one algoblock ( for example, the output of the same algoblock or another algoblock, as described in more detail below) or from common arrays of processed data. In the particular case of the implementation of the present invention, the data array is a vector or matrix of data that can be stored in at least one database.

The results of the above-mentioned actions of the algoblocks remain either at the outputs of the algoblocks, the vector or matrix of which constitutes the database of the processed data, or are written in accordance with the links or links (which specify, for example, the number of the element in the array (in the database) of the processed data where the result is placed) in general arrays of processed data (in the database).

Thus, a program of a visual algoblock programming language is a set of arrays (vectors) of data, in particular numbers, and can, in a particular case, have the following structure:

- An array, in particular, a vector containing numbers, each of which determines the type of algoblock, and the sequence of such numbers of the array (vector) defines the sequence of execution of the algoblocks. For example, the number “1” of the mentioned array can specify (define) the addition algo block, the “2” of the mentioned array defines the subtraction algo block (it is also possible to use any arithmetic and logical operations, dynamic operations, such as triggers or integrators, or combinations of different complexity, each type of algoblock is assigned its own code), etc. Then the sequence of numbers in the array 1,2,2,1 defines the sequence of algorithms that perform the operations: Addition, Subtraction, Subtraction, Addition.

An implementation option is also possible, in which the number “1” of the mentioned array can specify (determine) the arithmetic execution unit, for which the type of operation is set by the parameter of the algo unit which, in turn, is set in another array (vector), in which for the arithmetic unit (type 1) addition is specified by number 1, subtraction - by number 2, multiplication - by number 3, etc., number “2” can specify (define) the logic block for performing logical operations for which the type of operation is specified by the parameter of the block, which which, in turn, is also specified in an additional array (vector) of parameters of the algoblocks, in which for the algoblock of logical operations (type 2) the operation "AND" is specified by the number 1, "OR" - by the number 2, etc. In this case, the above example of the sequence of operations - Addition, Subtraction, Subtraction, Addition - is defined by two connected arrays: an array of the sequence of algoblocks 1, 1, 1, 1 and an array of their parameters - 1,2,2,1.

A separate type of algoblock is the subroutine call algoblock, the processing of which is to start the sequence of algoblocks that are a subroutine.

Algoblocks and examples of algoblocks, as well as operations carried out by algoblocks are described in more detail below.

- The second array may contain numbers that specify the element numbers in the databases of the processed data or in the base of the outputs of the algoblocks, from where the values supplied to the input of the algoblock for processing are received, i.e. the establishment (in the particular case, determination) of the above-mentioned ligaments is carried out.

- The third array may contain initial values for the inputs of the algoblocks, which turned out to be unrelated to the output databases or the databases of the processed data.

The algoblock program is executed (executed) by the runtime that sequentially performs the algoblock (operation) behind the algoblock (operation), choosing their codes and links (or links) to the data for this algoblock in the second list (array) from the first list (array).

Parallel computing is allowed only in the following cases:

- within the framework of one algoblock;

- within the framework of a special sequence of algoblocks, in which:

- the sequence algoblocks do not use the results (output data) of each other’s calculations,

- until the completion of all algoblocks of a sequence, the use by other algoblocks of the program of the results (data outputs) of any algoblock of such a sequence is not allowed, that is, the execution of the following algoblock cannot begin;

- within the framework of a set of several sequences of algoblocks executed in parallel, combined, for example, into one subprogram, and having the following properties:

- the algoblocks of each of this set of sequences do not use the results (output data) of the algoblocks of any other of the sequences of this set;

- until the completion of all the algoblocks of all sequences of the set, the use by other algorithms of the program of the results (data outputs) of any algoblock of this set of sequences is not allowed, that is, the execution of the next following this set of sequences of the algoblock cannot begin.

The execution environment, as can be seen from the above, works directly under the control of the source code of the program, consisting of the arrays described above, created and modified in the visual environment of the algoblock programming, that is, it is an interpreter. In this case, due to the guaranteed absence of syntax errors in the source code, the need for resource-consuming parsing is eliminated, which ensures the execution speed of an algoblock program by a runtime environment comparable to the speed of a compiled program.

Due to the strict sequence of execution and the absence of interruption of execution, special synchronization of data between algoblocks is also not required; the entire volume of processed data arrays is available to each algoblock.

In the particular case of the implementation of the present invention, if it is necessary to separate the resources of the system, for example, to simultaneously solve problems with different periods of data processing by the visual programming system and the execution environment, it is possible to separate the algorithms into different bypass cycles:

- the first cycle has the shortest execution period - in this cycle, tasks that require the most frequent execution are solved;

- the second execution cycle can be divided (divided) into several parts, and after each execution of the first cycle, the algoblocks of the next part of the second cycle from the first to the last are executed sequentially, and the entire second cycle is performed for as many periods of execution of the first cycle as the number of parts of the second cycle ;

- the third cycle corresponds to the second, as the second to the first.

An example of such a task from the field of automatic control systems is the case when it is necessary in a short time (for example, 0, 1 sec) to open the relief valve when the permissible pressure value is exceeded and at the same time maintain the temperature, flow and level using PID control (proportionally-integral differentiating regulation). At the same time, regulation can be carried out less frequently than verification, for example, at least once every 0.5 sec. If there are not enough computing resources for performing a pressure check in each cycle with the possible opening of the valve and simultaneously performing the functions of all three regulators (for example, it takes 0.05 sec for each of the regulators and 0.05 sec for processing the pressure signal with a signal to the valve ), but in 0.1 second only one controller manages to check, then performing only a check in the first cycle, and in the second cycle in each part after each execution of the first one controller, the problem is successfully solved.

It is worth noting that the cycles mentioned above (first, second and third) are described in more detail below.

 The above-described algorithm for executing algorithms, including a resource sharing algorithm, guarantees the integrity of the data being cut and processed, the absence of synchronization costs, and the predictable execution time of tasks. This ensures the determinism of the computing process, which allows the application of the present invention to solve real-time problems.

The runtime is an immutable program that can be implemented:

- one or a set of software modules that function:

- Under the control of various operating systems (for example, MS Windows, FreeBSD, Linux, RTOS, iOS, Android, Mac OS, etc.), including a virtual machine;

- without using an external operating system (for example, MS Windows, FreeBSD, Linux, RTOS, iOS, Android, Mac OS, etc.), including being the operating system itself;

- a software module executable from read-only memory;

- hardware module based on strict logic (consisting of logic microcircuits or FPGAs) and others - for example, input and output blocks of analog or discrete parameters, etc.

The execution (work) of the algoblock program is carried out by the runtime in an infinite loop, with the exception of special modes, when the program is limited to one cycle or its part, for example:

- during step-by-step execution of an algoblock program or execution to a stopping point during debugging;

- when synchronizing execution with other programs - for example, when a program stops at a fixed point in the algorithm of one program, after which another or all other programs are executed, after which the first one continues to execute;

- in other special cases of performance.

The described invention allows the creation and editing by the user (program developer, programmer, etc.) of the above-described arrays constituting the algoblock program, in particular, by defining or editing the sequence of algoblocks by selecting them from the list of possible types of algoblocks and setting input data for the algoblocks:

- either by graphically indicating the connections of the inputs and outputs of the algoblocks,

- either by selecting entries and exits from the list of possible databases and their element numbers, while entering numbers can be done either by selecting from the list or by directly entering a number at which directly during the input process both the validity of the input of each character and the validity of the input whole numbers.

Thus, due to the impossibility of entering invalid or incorrect data at any time of creating and / or editing an algoblock program, such an algoblock program does not contain syntax errors and loop errors, which allows its execution to continue when the algo block program is created and edited in the described method and system visual programming. This, in turn, allows you to provide visual control of the result of editing the program directly at the time of editing.

In the particular case of the implementation of the present invention, the visual algoblock programming system provides the loading of the algoblock program (in the form of the arrays described above) into a hardware module remote or without its own visual interface (which can be implemented by a computing device, for example, a personal computer, industrial control controller, smartphone, etc. .d.), and also provides the receipt of the current processed and processed data from such a hardware module and pumping from the mentioned the removed hardware module of the algoblock program (in the form of the arrays described above) with the possibility of its subsequent editing and reverse download. This feature is provided by the fact that the pumped-out algoblock program unambiguously and completely corresponds to the originally created algoblock program and can be displayed and edited in the visual algoblock programming system, since the pumping of the algoblock program is carried out by pumping out the arrays described above that make up the algoblock program.

Depending on the tasks to be solved, the structure and volumes of information requiring processing, block-based programs can be divided into three levels:

- the lower level of algoblock programs - with such a small amount of data that it seems possible to foresee a set of all necessary operations for their processing. At this level, the set and sequence of algoblocks are pre-fixed as part of the runtime environment, part or all of the algoblocks are implemented in hardware, the described programming method (of creating an algoblock program) is to configure bundles (links) for such algoblocks and parameters of the algoblocks (and is the easiest and most implementation by the user);

- An average level of algoblock programs - with a small amount of data, but requiring a wide variety of processing functions. When creating an algoblock program, the user sets the sequence of algoblocks and their types for the given level, the database of processed and processed data consists of the outputs of the algoblocks, the connections for the inputs of the algoblocks refer to the outputs in this database, some of the algoblocks can be implemented in hardware. At this level, as at the bottom, the algoblock programming system is a digital model of an analog computing device;

- the upper level of the algoblock programs is characterized by large arrays of data (information), when creating the algoblock program, the user sets the sequence of algoblocks and their types, the databases of processed and processed data are external to the program, links to the elements of these databases are set for inputs and outputs.

In a system distributed by space or by function, as well as between algoblock programs of various levels, interaction is carried out by setting relationships between the databases of processed and processed data, similar to the connections (bundles) inside algoblock programs, as described above and as will be described in more detail below.

The following are examples of the implementation of this invention.

Algoblock programs of the middle level - for their creation, as for other levels, the visual graphic programming environment is used.

In FIG. 1 shows an exemplary embodiment of a mid-level algoblock program according to one implementation of the present invention.

In FIG. 1, a system algoblock (“SYS”) is shown as an illustration of part of the present invention. In the shown in FIG. In the user interface, the inputs and outputs of the algoblock are represented by the outputs of the algoblock, and the operations by the algoblocks themselves. A user in the graphical interface, for example, by pressing the right button of the Mouse button (or by using combinations of hot keys, buttons of the graphical user interface, or by any other known method), in particular, in the main window of the graphical user interface, can open the menu for adding algoblocks, which is shown in FIG. 2.

In FIG. 2 shows a menu allowing a user to add a new algoblock, according to one embodiment of the present invention.

It is worth noting that the addition of the subsequent algoblock can be carried out both at the end of the list, and before and in the field of the selected algoblock, that is, the algoblock on which the mouse button was pressed.

As one of the exemplary descriptions of the present invention, an example of an arithmetic function, in particular addition, by using a system algoblock and an arithmetic algoblock, as shown in FIG. 3. So, as an example, the addition (by the user) of the arithmetic algoblock to the already added and shown in FIG. 1 system algoblock.

In FIG. 3 shows an exemplary embodiment of components of an algoblock program, according to one embodiment of the present invention. In the given example, the system algoblock (“SYS”) is basic and which allows you to use system parameters in programs.

The outputs of the algoblock can be connected to the inputs of another algoblock or to the inputs of the same algoblock. So, for example, one of the outputs of a system algoblock can be connected by a user to at least one of the inputs of another algoblock, for example, to one of the inputs of an arithmetic algoblock (in particular, input 1 “Bx1”). Those. one output of the algoblock can be connected with one or more inputs of at least one algoblock, and one input of the algoblock can be connected with only one output of the algoblock. It is worth noting that the outputs and inputs of one algoblock can be interconnected.

When the user selects one of the outputs of the algoblock, this output of the algoblock is highlighted, in particular, a colored, for example, red stripe is highlighted. After the user selects the output of the algoblock, the user can select one of the inputs of the other or the same algoblock to associate the said output. After selecting the input when communicating the input and output of the algoblock (algoblocks), the user may be presented with a confirmation menu for establishing a connection between the input and output of the algoblock (algoblocks).

After establishing a connection (binding, linking) between the input and output of the algoblock (algoblocks), such a connection is displayed in the graphical user interface via a line connecting the mentioned input and output of the algoblock (algoblocks). Such at least one line reflecting the implementation of the input and output communication of at least one algo block can have a color reflecting, for example, the data type of such communication (for example, pink - bits, gray - bytes, red - yellow - real number, etc.), in order to provide the user with visual control over the connections between the algoblocks (inputs and outputs of the algoblocks). In order to increase visibility, the lines can visually go from the outputs to the common data bus (a line with a greater thickness of black, for example, color) and exit from it to the inputs. In this case, a color line from the output to the input is shown, including inside the wider bus by choosing the output or input with the mouse, for example.

At the outputs of the arithmetic algoblock, the results of the execution of the type specified by the code of the algoblock and its additional action parameters on the data arriving at the inputs of the arithmetic algoblock, the inputs, in accordance with the connections given by the connectives, are displayed. In the shown in FIG. In the 3rd example, at Input 1 of the arithmetic algoblock, a variable value (in this case, the number of the current cycle of the algoblock program) is supplied from the output of the system algoblock, as described above. The remaining inputs of the arithmetic algoblock are zeros. The result of the indicated arithmetic algoblock (in particular, operations, which will be described in more detail below, of each component of the arithmetic algoblock - “1”, “2”, “3”, “4”, “5”, “6” and “7 ") Are the values at its outputs (in this example, the values at the outputs 1, 2, 3, 4, 5, 6 and 7). According to the values at the arithmetic algoblock inputs and the given algoblock code (including the mentioned operations of the constituent elements of the arithmetic algoblock, which in this case are addition operations), at Output 1, Output 5, and Output 7 of the arithmetic algoblock, in this case, the values correspond (are equal) the input value at Input 1 of the arithmetic algoblock, taking into account the zero value at Input 2. The values of the other outputs of this arithmetic algoblock in this case are equal to zero, according to the aforementioned arithmetic operations algoblock and the values at inputs 3 and 4, 5 and 6, 7 and 8.

Further, as an illustrative option, the aforementioned output of the system algoblock is connected (by the user) with the input of the arithmetic algoblock different from that used above, in particular, with Input 3 (“Bx-3”) of the arithmetic algoblock, another output of the system algoblock is connected, for example, with the Input 4 ("Bx-4") arithmetic algoblock.

The user can select the algoblock (in this case, the arithmetic algoblock) to open the menu of the structure of the algoblock (properties of the algoblock) - the window (menu) for setting the parameters of the algoblock, as shown in FIG. four.

The algoblock settings (parameters) menu contains the “Settings” submenu (in particular, the implemented window that opens by selecting the appropriate “Settings” tab by the user), the “Data Inputs” submenu, the “Control Inputs” submenu, the “Data Outputs” submenu and the “Diagnostic Outputs” submenu ", Which are described in more detail below.

The “Settings” submenu displays the values at the inputs and outputs of the currently selected algo block, as well as the operations for the corresponding inputs and outputs of the algo block (operations carried out by the algo block between the corresponding input and output, for example, Input 3 and Input 4, etc.) . So in the present example, the Operation (“Op1”) for Input 3 (“In 3”) and Input 4 (“In 4”) is the addition operation (“+”). The operation (according to the type of algoblock) can be changed by the user in the (drop-down) menu of operation types. In this case, one of the arithmetic operations, for example, addition, subtraction, division, multiplication, percent, exponentiation, logarithm, etc., can be selected for the arithmetic algoblock. For other types of algoblocks (for example, a logical algoblock), operations corresponding to the type of algoblock can be selected (by the user). It is also worth noting that the type of operation can also be set by using the control inputs (control inputs) of the algoblock, by setting the corresponding number operation (for example, 0 - addition, 1 - subtraction, 3 - multiplication, etc.) as described in the framework of the present invention.

The user can configure any parameters of the algoblock program and individual algoblocks, and the algoblock program changes during operation (execution) during debugging, i.e. display of the result of the work of the algoblock program and its components, algoblocks occur at the time when the user makes the described changes, for example, in the algoblock properties menu (window for setting the parameters of the algoblock).

Fundamental acceleration of development and debugging in this invention is achieved due to the fact that the program can be edited during its operation and immediately see the result due to the fact that the system is graphic (visual), does not require translation, and there is no possibility to make a syntax error: regardless of what parameters in the interface, in particular, in the properties menu of the algoblock, the user selects, the result of his actions is a workable, non-looping program.

To achieve this action, available to the user are selected so that there is no possibility of not only a syntax error, but also a loop of the program. As described in the framework of the present invention, the algoblock program has one common cycle, inside which the user cannot set cycles, the depth of iterative calculations is strictly limited.

It is worth noting that the algoblock has several types of outputs, in particular data and diagnostic outputs (which are described in more detail below). Algoblocks also have several types of inputs, in particular data and control inputs (which are described in more detail below).

If for the first input ("-1") of the arithmetic algoblock on which the variable / value (or constant value / value) is located (set, supplied) and at input 2 ("Вх 2") there is (set, supplied) the value " 0 ", then in the event that Operation 1 is changed from" + "(addition) to" / "(division), Output 1 (" Output 1 ") of the algoblock will display a warning about the incorrect operation (in this case, division by zero - the Input value 1 to the value of Input 2, the last value of which is zero by default), which indicates that the operation performed by the algoblock , Completed with errors, as shown in FIG. 5 (display of “exclamation mark”). At the same time, at the first diagnostic output, corresponding in this case to the first data output, 0 will change to 1, which is also a sign of an incorrect operation that can be processed in the subsequent part of the program.

Those. the result of this operation (division by zero is an invalid operation) is invalid - the operation completed with an error. Such a mention allows the user to take appropriate actions to make changes to the program (in particular, operations, input data, etc.) for processing by the algoblock in an appropriate (correct) way to handle the situation (in particular, to eliminate the potential error). During the execution (execution process) of the algoblock program, no exceptions are implemented and the created (created) program continues to function (work), i.e. the continuation of the execution of the algoblock program is carried out. Thus, the execution of the program is always automatic, which allows the described system (in the particular case used to automatically control various devices, mechanisms, etc.) to carry out the mentioned control and make decisions independently without user intervention, that is, without waiting for user intervention, both after and during the creation of the algoblock program.

The above ensures the execution of the algoblock program (and system) regardless of the data supplied to its input (in particular, to the input (s) of the algoblocks), i.e. the program processes any data submitted to its input, and, for a given clock cycle, for a given time, depending on the specified characteristics.

The described system and method allows for the (automatic) coordination of data types. So, in the above example, the input of the arithmetic algoblock, capable of receiving data types in the form of real numbers, was given integer numbers from the output of the system algoblock. So, as an example, the first lower left output of the system algoblock (which is a bit (logical) output having a bit data type at the output) can be fed to one of the arithmetic algoblock inputs, in particular, to input 5 of the arithmetic algoblock.

Thus, the described system allows the coordination of data types, in particular, bit, integer, real, etc., i.e. coordination of all types of data is carried out by the described system automatically. This allows the user to create a program without knowledge of programming languages, in particular, without knowledge of the user about the need to coordinate data types and / or without knowledge of the syntax of programming languages by the user.

In FIG. 6 shows an exemplary variant of an algoblock program with added logical algoblock (in this case, bitwise) and an algoblock of tasks (in this case, bitwise), according to one embodiment of the present invention. As mentioned above, the user can add the algoblock (in this case, the logical algoblock) to the end of the list of algoblocks, as well as before or after the (pre) user-selected algoblock in the user interface. The selection of the position of the added algoblock is carried out by means of an additional menu for selecting the position of adding the algoblocks.

In this example, the output 1 of the task unit is connected (by the user) to the input 1 of the logical algorithm, and the output 2 of the task unit is connected (by the user) to the input 2 of the logical unit. In this case, the outputs of the logical algo block contain zeros.

In the shown in FIG. In example 6, a special algoblock - tasks - is characterized in that the output values of this algoblock are not changed by the inputs of this algoblock, since this algoblock has no inputs. The output values of this algoblock can be set by the user in the settings window (properties) of the algoblock without the ability to change the values at the output of such an algoblock by outputs from other algoblocks, etc., i.e. This algoblock does not allow the algoblock program (or at least one component element of the algoblock program) to change, in a particular case, overwrite (overwrite) the output values of this special algoblock.

In FIG. 7 shows a submenu of output data for the task unit according to one embodiment of the present invention.

After changing (by the user) the value of output 1 (“Output 1”) of the algoblock, in this case from “0” to “1”, in the output menu, the value at output 1 of the logical algoblock changed to “1”, according to the values at the inputs of the logical the algoblock and the given algoblock code (including the mentioned operations of the constituent elements of the arithmetic algoblock, which in this case are addition operations), in this case, the OR operation for inputs 1 2 of the logical algoblock. When changing the mentioned “OR” operation of the logical algoblock to “AND”, in real mode, as part of the interpretation of the algoblock program, the value at the output 1 of the logical algoblock will be “0” according to the current operation set by the user.

The control inputs mentioned above, which are visually separated from the main inputs of the algoblock, are the same inputs of the algoblock as data inputs, but they allow you to control the algoblock, in particular, change operations by supplying to the control input values that are encoded types of the described operations. So, for example, the “OR” operation of a logical algo block can be encoded with a numerical value, in the particular case, with a value equal to “14”, the “And” operation of an algo block can be encoded with a numerical value equal to “8”, the identity is “9”, etc. d. The type of operation at the input of the algoblock encoded in the manner described above is displayed in the user interface. The control input of the algoblock can be connected with the output of another (or the same algoblock) in order to establish (or change) the type of this operation, which also allows you to dynamically change the type of operation, depending on the value supplied to the control input of the algoblock, in particular, on ( control) input of the operation of the algoblock. The value of the unconnected input (general or control) of the algoblock can be changed by the user in the window of the list of algoblocks of the user interface by selecting the given input by the user and by setting the value for the given input of the algoblock, for example, through the menu for setting the value (in particular, encoded as described above) according to by default for the input of the algoblock, as shown in FIG. 8. As shown in FIG. The 8 submenus of the “Data Inputs” of the algoblock display the values of the inputs of the algoblock, the default values of the inputs, the relationship between the inputs and outputs of the algoblock, etc.

It is worth noting that the values of unconnected (unbound) inputs of the algoblocks, in particular, those not connected with the outputs of the algoblocks (for example, the output of the same algoblock or another algoblock) are set (in particular, stored) in a separate database table (the table of default values for inputs Algoblocks). Such values for the inputs of the algoblocks can be set both for the inputs of the data of the algoblocks and for the control inputs of the algoblocks. Those. in the particular case of the implementation of the present invention, the default values for the inputs of the algoblocks are constants and are stored in the mentioned table of default values for the inputs of the algoblocks. So, for example, when you select the “Data Inputs” submenu for the algoblock (for example, the logical algoblock) in the settings menu of the algoblock (after it is selected by the user), the user can change the default value for at least one of the inputs of the algoblock, for example, Input 3 ("Vh3") from "0" to "1", as shown in FIG. 9, and in the window of the list of algoblocks of the user interface at the corresponding input of the algoblock, the value set by the user in this way will be displayed. And in this case, when the user changes the mentioned default value, the algoblock program itself (but not the data) is changed, since the default values (which are constants) are part of the algoblock program. So, when changing the values of the outputs of the algoblocks (for example, the above-mentioned algoblock of tasks), the data is changed only in the RAM, but the algoblock program does not change, and when the default values are changed, the algoblock program is changed, i.e. when you enter (change) the default values, you change (in particular, enter) the values in the tables describing the algoblock program and which can be stored in permanent or semi-permanent memory.

The algoblock program is described by a table of algoblocks (types of algoblocks), a table of relations between algoblocks, and a table of values of the inputs of algoblocks by default, and these tables compose (form) a database. Thus, an algoblock program is a set of said tables of at least one database that are stored in at least one data store, in particular in read-only memory, for example, read-only memory of a (computing) device, in particular a ROM of a device, or in semi-permanent memory. Moreover, the output values of the algoblocks are stored (stored) in RAM, in particular in the RAM (computing) device.

In the process of creating (developing) the algoblock program, all the data of the algoblock program and the tables that make up the program itself are stored in RAM. In this case, the tables that make up the program, when they are changed, are stored in the semi-permanent memory of the device (including a hard disk drive or flash memory), on which such an algoblock program is created. In the permanent or semi-permanent memory of the execution device, the program (its constituent tables) can be recorded remotely from the device where the program is being developed at the command of the user. Alloblock program can also be fully read out at the command of the user from the device where it is executed, to the device where the user can change it, debug it and download it back to the execution device. Remote debugging mode is also possible, when data from the execution device is constantly supplied to the device where the program is debugging, which allows the user to constantly see the results of all the program blocks.

When (user) changes in the relationships (bundles) between the algoblocks and / or the values of the inputs of the algoblocks, the algoblock program is changed, while when the values of the outputs are changed, the data (for) the created (or created, in particular during the change) algoblock program is changed.

It is worth noting that (by the user), the algoblock can be turned off (suspension of the execution of the algoblock code), in particular, by setting the value corresponding to disabling the algoblock on the corresponding (control) input of the algoblock. So, for example, when setting (feeding) to one of the first two upper left (control) inputs of the algoblock responsible for disabling the algoblock, the value corresponding to disabling the algoblock, for example, in the particular case, is “1” (or a number other than “0” / value, which is the default value and is the value corresponding to the fact that the algoblock is disabled, i.e. the algoblock code is not executed), then in this case the execution of this algoblock will be (if) stopped, i.e. the algoblock will stop executing, in particular, the algoblock code will stop executing. Thus, when changing the default value, for example, at input 1 of the logical algoblock in the input data tab of the window for setting the parameters of the algoblock from “0” to “1”, the outputs of the logical algoblock have zero values, in contrast to the values indicated in FIG. 7.

It is worth noting that the control algoblock input (in this example, the arithmetic algoblock control input) can be connected to any output of another algoblock, for example, the task algoblock, or any other output of the same algoblock (in this arithmetic algoblock example).

As mentioned above, depending on the value at the output of the algoblock, which (output) is connected to the (control) input of the algoblock, when the output value is changed by means of the settings window for the parameters of the algoblock in the submenu of data outputs, it can be stopped or executed (including continued ) execution of the algoblock. Thus, when applying a “disconnecting” value to the input of the algoblock from the output of the algoblock (the same or another), the execution of the algoblock can be stopped, the input of which is supplied with a “disconnecting” value, and the values of the outputs of the algoblock cease to change.

As mentioned above, and within the framework of the considered example, one of the outputs of the algoblock (in the considered example, the logical algoblock) can be connected to the input of another algoblock (in the considered example, the arithmetic algoblock), and with the control input (in this case, the disconnect input of the algoblock). In this example, the output 1 of the logical algoblock is connected to the trip input (control input) of the arithmetic algoblock. Since the value at the output of the logical algo block is “0”, the operation of the arithmetic algo block does not stop (the logical algo block continues to execute the code of the algo block). In this case, “0” at the control input (in particular, the algoblock shutdown input) of the arithmetic algoblock corresponds to the fact that the algoblock continues to execute the algoblock code, as described above.

Further, when setting (by the user) at Output 1 of the task unit the value equal to “1” (unit), which in this case is connected to input 1 of the logical unit, and at Output 1 of the logical unit, now the value is “1” (unit) and this value fed to the trip input of the arithmetic algoblock. Since in this case the value at the trip input of the arithmetic algoblock corresponds to the trip value of the algoblock (in particular, different from "0"), the values at the outputs of the arithmetic algoblock cease to change (they are frozen). The described control inputs (including trip inputs) are used to perform calculations by algo blocks. In this example, through the operations performed above, in particular, the described relationships between the algoblocks and setting values at the outputs (and inputs) of the algoblocks, an analogue of the conditional logical “IF” operator was created. In this example, if the true value (“1”, “True”) is supplied to the (control) input of the arithmetic algoblock, then the operation is blocked.

If necessary, the user can change the logic of the action (algoblock) by selecting (specifying) the necessary algoblock (in this example, the arithmetic algoblock) in the Control Inputs submenu (settings window of the algoblock) by changing the parameters of the Control Inputs. So, for example, in the Control Inputs submenu, the user can change the parameters of the control inputs of the algoblock. In particular, for the aforementioned algoblock logic change, the user can set the inversion flag for at least one control input. As noted above, when at least one of the values (or parameters) of the control inputs of the algoblock is changed, the algoblock program is changed, and any change of the algoblock program completely erases the RAM in which the data of the algoblock program are stored - the output tables Algoblock diagnostic data and outputs, as described above.

Further, when changing (in particular, restoring previously set values) at the outputs of the algoblocks, for example, the algoblock of tasks, the execution (codes) of the algoblocks is performed.

Using no more than one algoblock, a dynamic operation can be created (by the user). To create dynamics (dynamic operation) in the algoblock program, memorization from the previous steps (previous execution steps) is used. So, for example, in the case of a logical algoblock, the outputs of such an algoblock (values of the outputs of the algoblock) are the values from the previous step of this algoblock.

In the above example, a trigger can be assembled (created) based on a logical algo block. In this case, the first two (main) inputs of the logical algoblock are the counting inputs of the trigger. One of the inputs of the logical algoblock can be used as trigger feedback (apply a value to it from the previous step). The third input of the logical algoblock is used as a reset input. Output 5, which is the result of processing all four outputs of the logical algoblock, is connected to Input 4 of the same logical algoblock. Operation 5 (for Output 1 and Output 2) in the settings of the algoblock was changed (by the user) to the operation "OR", and operation 2 (between the third and fourth inputs of the logical algoblock) was changed to operation "2> 1", which reset the output of the algoblock when applying “1” to the reset input - Input 3.

By setting the values of the algoblock (in this case, the algoblock of tasks), the operation of the trigger can be checked, as mentioned above.

Similarly, an integrator can be built on the basis of the argmetic algoblock of the arithmetic algoblock by linking the output of the summation operation with one of its two inputs - the integral will accumulate at the output of the algoblock that corresponds to the summation operation.

In FIG. 10 shows an exemplary embodiment of an algoblock settings interface, in accordance with one embodiment of the present invention. In the particular case of the implementation of the present invention, the interface of the algoblock settings is the interface of the properties of the algoblock.

The user, having selected a graphical interface element, for example, represented by a menu item ("tab") of the output data, bind at least one parameter to the database (DB), in particular, bind at least one of the parameters to the database.

In the particular case of the implementation of the present invention, the user, by connecting Out1 with A1 and / or Out2 with A2, can “minimize” (or close the window) properties of the algoblock, for example, by “left-clicking” on an empty space of the graphical user interface (in particular , under the algoblocks, a chain of algoblocks). The user can also connect other outputs of the algoblocks with the inputs of other algoblocks, for example, Output1 of the analog block of inputs from Вх1 of the comparison block, and Output2 of inputs with У1 (first setting) of the comparison block. Next, the user can open the properties window of the comparison algoblock (which is shown in FIG. 11), as described above.

Further, the user can bind in the Output Data tab, as shown in FIG. eleven.

In the created program, using algoblocks, the value from A1 of the database is compared with the value of A2 from the database, and the result of the comparison is entered in D1, as shown in FIG. 12.

In FIG. 12 shows one embodiment of a system window of a program according to one embodiment of the present invention. As shown in FIG. 12, the variable D1 took a value equal to one, since the value of A1 exceeded the setting, i.e. A2 value.

The name and description of the variable D1 can be set (defined) by the user manually using the tools described in the present invention provided by the described system, for example, in the database interface window.

The mechanism for exchanging data with external devices through ports or memory is for mid-level algoblocks of a special type of algoblocks - slots.

It should be noted that in the framework of the present invention can be used several types of slots (algoblock slots), for example:

- slots (MikKON), an example of one of which is shown in FIG. 29, exchanging data with modules (MikKON), in the particular case slots, using the serial ports of the module;

- Memory slots (an example of one of which is shown in FIG. 30), exchanging data through the module’s memory;

- FRAM slots (an exemplary embodiment of one of which is shown in FIG. 31) that read / write data in FRAM;

- CAN slots (an example of one of which is shown in FIG. 32), exchanging data with the modules via CANBUS.

In the slot settings, the number of slots of this type and the type of outputs (the slot can either read data or write it) and the memory address from which they are read or written to can be set.

It is worth noting that for the mentioned slots, the type of slot (protocol used) can be set, the starting address in the memory of the module (all inputs and outputs of the module are mapped to its memory), type and names of the outputs.

The type of slot used in the future, additional parameters can be set in the slot algoblock settings window. For example, a port number and address can be specified, for some, an extension address (MikKON).

A slot can perform either a read operation from a module or a write operation to a module. Thus, a slot can have either inputs or outputs. The names of the conclusions cannot be repeated, since they are used to identify the conclusions. The offset specifies the offset of the output address relative to the specified address in the module memory. The offset can be specified in the format <byte>: <bit>. For example, to subtract the very first bits from bytes at addresses 5 and 10, the base address in the module's memory can be set to 3, and the offsets:

- for the first conclusion: 2: 0;

- for the second conclusion: 7: 0.

After configuring the slots, the corresponding slot blocks will be available, which can be selected in the window menu of the list of blocks.

In FIG. 29 shows an exemplary embodiment of a slot algoblock (MikKON), according to one embodiment of the present invention.

Depicted in FIG. 29 “Dis1” and “Dis2” are algoblock disable inputs. A nonzero value on any of these inputs disables the algoblock. Depicted in FIG. 29 “T” is the minimum polling cycle (in milliseconds). Depicted in FIG. 29 “Adr” is the address of the module. Depicted in FIG. 29 “SA” is the extension address of the module. Depicted in FIG. 29 "#" is the port number through which the exchange is made with the module. It is worth noting that depicted in FIG. 29, “Dis1”, “Dis2”, “T”, “Adr”, “SA”, “#” are the control inputs.

In addition to the control inputs, the algoblock may have diagnostic outputs (as shown in FIG. 29):

“A” - module activity. “1” means that the exchange with the module is normal. If there is no response from the module for a time equal to the minimum polling cycle, then 0 is set on this pin;

“T” is the actual polling cycle (in milliseconds).

In FIG. 30 shows an exemplary algoblock of a Memory slot (“MEM”), according to one embodiment of the present invention.

In the particular case of the implementation of the present invention, the control inputs "Dis1" and "Dis2" are the disable inputs of the algoblock. A nonzero value on any of them disables the algoblock.

In FIG. 31 shows an exemplary algoblock of a FRAM slot, according to one embodiment of the present invention. A nonzero value on any of them disables the algoblock.

In the particular case of the implementation of the present invention, the control inputs "Dis1" and "Dis2" are the disable inputs of the algoblock.

In FIG. 32 shows an exemplary algoblock of a CAN slot, according to one embodiment of the present invention.

In the particular case of the implementation of the present invention, the control inputs "Dis1" and "Dis2" are the disable inputs of the algoblock. A nonzero value on any of them disables the algoblock.

Depicted in FIG. 32 “T” is the minimum polling cycle (in milliseconds). Depicted in FIG. 32 “Adr” is the address of the module. Depicted in FIG. 32 "#" is the port number through which the exchange is made with the module.

In addition to the control inputs, the algoblock may have diagnostic outputs (as shown in FIG. 32):

"T" - the actual polling cycle (in milliseconds);

“A” - module activity. “1” means that the exchange with the module is normal. If there is no response from the module for a time equal to the minimum polling cycle, then 0 is set on this pin.

In the particular case of the implementation of the present invention, the program to be created may contain several repeating algoblocks and / or chains of algoblocks that can be added (added) by the user to at least one subprogram, which, in the particular case, can reduce the overall size of the program.

It is worth noting that in the particular case, the program is another run cycle that can be called using the subroutine call block. If a subroutine call is found in the chain of the algoblocks of the algoblock, the program execution system stops the execution of the current cycle, executes the subprogram, and then continues execution from the output of the subroutine of the algoblock.

A subprogram always starts with the algoblock for entering the subprogram and ends with the algoblock for exiting the subprogram and can have, in the particular case, 16 inputs and 16 outputs. In addition, the inputs of the algoblocks located in the body of the subprogram can be tied to the outputs of the algoblocks of the main loops for using “global” data.

As described above, the user can add algoblocks to the program.

In FIG. 33 shows an exemplary embodiment of an algoblock list window, in accordance with one embodiment of the present invention.

In this window, the user can add and remove algoblocks in the selected cycle and change the binding of inputs (algoblocks) to outputs (algoblocks), and also algoblocks of the selected cycle are displayed.

In the particular case, the color of the displayed algoblock may depend on whether it is selected by the user, whether the outputs of the algoblock are connected to the inputs of another algoblock, etc. So, for example, the user-selected algoblock is displayed in yellow, the algoblock whose outputs are connected to the inputs of the selected one is turquoise, and the algoblock whose inputs are connected to the outputs of the selected one is crimson.

In the particular case of the implementation of the present invention, the user can add the algoblock to the program he creates using the mouse. So, for example, the user, having pressed (“clicking”) the right button of the mouse manipulator, can select the “insert algo block” tab in the pop-up menu and then select the desired algo block in the submenu.

It is worth noting that the user can add (“insert”) the algoblock to the beginning of the list, before the selected algoblock or to the end of the list (in particular, after all existing algoblocks).

In the particular case of the implementation of the present invention, the user associates ("binds") at least one output of at least one algoblock with at least one input of at least one other algoblock. In the particular case, such a binding ("binding") can be carried out using the mouse. So, for example, the user can select one of the outputs of one of the algoblocks and associate it with the input of another (or the same) algoblock. So, the user can select the output of one algoblock (data output or diagnostic output, etc.), then select the input of another, and then confirm the binding.

In FIG. 34 shows yet another embodiment of an algoblock, in particular an arithmetic algoblock, according to one embodiment of the present invention. In the given example, the data inputs are located at the left of the algoblock. Above are the control inputs. To the right are the data outputs, below are the diagnostic outputs. It is worth noting that the number of inputs and outputs of the algoblocks depends on the type of algoblock. In the particular case of the implementation of the present invention, the inputs of the algoblock have a default value, which is used if the input of such an algoblock is not connected to the output of another algoblock. Inside the body of the algoblock, in the upper left corner, the number of the cycle in which the given algoblock and the number of the algoblock in the cycle are specified (in which it is added) is displayed. Under it can be located the type designation of the algoblock. Also, inside the body of the algoblock, a sign of inversion and sign for the inputs of the algoblock can be displayed. An exemplary embodiment of the algoblock depicted in FIG. 34, at the data input “Вх1” the user specified (defined) the inversion of the value (neg), and for the input “Вх2" - account of the sign (sign). The combination of the inversion of the neg value and the accounting of the sign sign depending on the type of input is shown in the table below:

Type of neg = 0, sign = 0 neg = 0, sign = 1 neg = 1, sign = 0 neg = 1, sign = 1 Bit 1 if greater than 0 1 if not equal to 0 1 if less than or equal to 0 1 if equal to 0 Byte Does not change Does not change Bitwise inversion of input value Opposite sign 2-byte integer Does not change Does not change Bitwise inversion of input value -value 4-byte integer Does not change Does not change Bitwise inversion of input value -value 8-byte integer Does not change Does not change Bitwise inversion of input value -value 4-byte floating point Does not change 1 / value -value -1 / value 8-byte floating point Does not change 1 / value -value -1 / value

It should be noted that the algoblocks can have control inputs “Dis1” and “Dis2”. Mentioned inputs can be used to disable this algoblock from execution. If a nonzero value is supplied to them, then the algoblock does not work.

Algoblock outputs can be linked to a database (MWBridge). In this case, the results of the implementation of the algoblock will be reflected in the corresponding database parameters (MWBridge). To transfer data from the database (MWBridge) to the execution system of the algoblock program, a special type of algoblocks can be used: job algoblocks. This type of algoblocks reserves a data region of the corresponding type and allows you to transfer the value from the database (MWBridge) to the inputs of other algoblocks.

It is worth noting that the user can select the input of one algoblock associated with the output of another algoblock, or the user can be the output of one algoblock associated with the input of another algoblock to cause the described system and method to display two such associated algoblocks shown in FIG. 35.

 In FIG. 35 shows an exemplary display of two interconnected algoblocks, according to one embodiment of the present invention. In FIG. 35 shows the relationship between two algoblocks, in particular, the relationship between the output "No. DB" of the system algoblock ("SYS") and the input ("Bx4") of the arithmetic algoblock ("1: 2"). By the demonstrated and described method, the user can monitor the entire sequence of algoblocks, in particular, the relationships between the algoblocks.

It should be noted that in the particular case of the implementation of the present invention, the user can configure the parameters of the blocks.

In FIG. 36 shows an exemplary appearance of the algoblock parameter setting window. In the above window (in particular, the user interface, the user dialog, page, etc.), the user can configure the parameters of the selected algoblock. It is worth noting that for each type of algoblocks there can be its own dialog (window, interface, page, etc.) settings. In the particular case of the implementation of the present invention, the windows (pages, interface, etc.) of viewing and adjusting the inputs (data) of the algoblock, the inputs of the control of the algoblock, the outputs (data) of the algoblock and the outputs of the control of the algoblock can be the same.

Also, for the algoblock, the user can change the description of the algoblock, for example, in order to give greater readability to the program being created from the algoblocks as a whole.

 As mentioned above, the user can configure the inputs of the algoblocks, in particular through the window (interface, page, etc.) of the settings of the inputs of the algoblock, an example of which is shown in FIG. 37. In the particular case of the implementation of the present invention, as shown in FIG. 37, in the settings window of the inputs of the algoblock, the user can be displayed: the current value of the input, its default value, sign of inversion ("neg") and sign ("sign"). Also, in the last field, the connection with the output, the number of the cycle and the algoblock in the cycle, as well as the name of the output can be displayed. Inversion and sign can be set (defined, set, etc.) by the user (only) for input-output connections. Thus, for an unconnected input (“hanging in the air”), the parameters mentioned cannot be defined (assigned) by the user.

As mentioned above, the user can configure the outputs of the algoblocks, in particular by means of the window (interface, page, etc.) of the settings of the outputs of the algoblocks, an example of which is shown in FIG. 38. In the particular case of the implementation of the present invention, as shown in FIG. 38, in the settings window of the outputs of the algoblock, the user can view or change (edit) the name of the outputs of the algoblock, its current value, type of output and / or its index in the corresponding database, for example, the MWBridge database. In the particular case, a new value, for each of the mentioned parameters, can be entered (set, set, etc.) by the user in the corresponding field. In particular, in the “connect to module” mode, this value will be transferred to the module. In the particular case, the mentioned value can be used in the program until it is overwritten with the new value as a result of the execution of the algoblock (in the particular case, if such an algoblock is not disabled by the control inputs “Dis1” or “Dis2”).

It is worth noting that the program (using the algoblock program) created with the use of algoblocks can consist of at least three cycles in order to ensure the possibility of separating computing resources by time:

- the main cycle;

- slow cycle;

- slow cycle.

Algoblocks in each cycle are executed sequentially. Upon completion of the cycle, a cycle of lower priority begins (after the "main" - "slow", after the "slow" - "slow"). If in the chain of “slow” or “slow” cycle algoblocks there is an algoblock of return to the previous cycle, then the execution of this cycle is paused, and control is transferred to a higher priority cycle (from “slow” to “slow”, from “slow” to “main” "). This makes it possible to efficiently use the computing resources of the system for executing an algoblock program, creating structures of the type “during a single execution of a“ slowed down ”cycle, execute a“ slow ”cycle N times. In addition, in this case, it is possible to precisely determine where and when the interruption of the execution of one cycle and the transition to another cycle will be carried out, and data integrity is ensured during such transitions, without requiring special costs for maintaining the context.

 For the described middle-level algoblock program, databases (output values) of such programs exist only when the algoblock program exists and the algoblocks are created (by the user).

It is also worth noting that the elements of such a database — the outputs of the algoblocks — can be connected to an external database (for example, a database of analog variables or discrete variables, in particular, the MWBridge database) stored in RAM. The image of such a database, at the request of the user and / or by modification, can be copied to read-only memory, in particular, to a data storage, for example, on a hard disk drive with, moreover, the image of the database can be saved in both binary and text format, in particular in files. Moreover, storing the mentioned data in binary format allows you to speed up access to such data, and storing in text format allows you to edit it (for example, by the user) in any other medium (or system), for example, in any text or spreadsheet editor. The image is used for initial initialization of the database located in RAM with the execution program stratum.

In another particular embodiment of the present invention, the algoblock programs are implemented as upper-level algoblock programs also using a visual table programming environment, but optimized for the upper level.

The described system and method are intended to create (user) procedures (as described in more detail below) executed by computing devices or at least one module of said computing devices (hereinafter referred to as executable procedures or procedures). Said executable procedures may be executed by at least one computing device or at least one module (software or hardware) of such a computing device in real time.

The top-level algoblock is a set of data (including binary data) that defines the required operation (addition, trigger, solution of a system of linear equations, etc.) in at least one of the following ways:

- Algoblock inputs - operands (at least one, for example, one or two operands, depending on the type of operation);

- the result of the operation;

- type of transaction;

- conditions for the operation;

- conditions for the use of operands;

- Algoblock output - the result of the operation, including the logical result of the operation.

Each aforementioned algoblock dataset may include (additional) flags specifying the usage modes of such algoblock datasets.

The mentioned procedures (including user procedures) are a set of algorithms executed (by the executing system) sequentially one after another.

For the first four of the above-mentioned procedures of the top-level algoblock program, execution is carried out according to a special cyclic time-sharing algorithm similar to that described above for the three cycles of mid-level algoblocks. That is, the first four procedures mentioned in this implementation are four traversal cycles.

The first procedure, which is the main, most frequently executed procedure, is always present and forms a fast traversal cycle (cycle of the first procedure), executed at each clock cycle of the real-time kernel (of the described system). To organize the computing process (program execution), the user is provided with a special algoblock (which can be selected by the user, in particular, through the menu, as described below) of the “Go” cycle to the previous bypass cycle, which allows you to interrupt the execution of the current bypass cycle (except for the first, which is not interrupted) and proceed to the execution of the previous faster loop (the procedure with the lower number is executed). The mentioned special algoblock may be executed unconditionally or may have a condition of execution, in particular, by the value of a certain variable or time, i.e. the algorithm for organizing the computational process (execution of cycles of the second and higher) can be changed according to the results of the program during its execution.

For example, for the case when the number of bypass cycles is three, and the second and third bypass cycles include an algoblock cycle that divides these procedures into two parts: “2-1”, “2-2” and “3-1”, “3 -2 ”, respectively (in the particular case, the algoblock of the cycle unconditionally transfers control to the previous bypass cycle).

Real-time Kernel Clock Number Executable Procedures one 1 + "2-1" 2 1 + "2-2" 3 1 + "3-1" four 1 + "2-1" 5 1 + "2-2" 6 1 + "3-2"

Next, the sequence (execution of cycles of the second and higher) is repeated.

Thus, in the above example, the first loop (procedure No. 1) is executed 3 times more often than the second and 6 times more often than the third.

The executed number of bypass cycles can be less than specified if, for example, one of the procedures included in the bypass cycles is not defined (for example, the number of algoblocks in it is 0).

For this implementation of the algoblock system, procedures with numbers greater than the number of bypass cycles, that is, starting with the fifth, are not included in the continuous cyclic execution algorithm and can only be started using the special procedure call algorithm.

In this case, the implementation of the present invention, the user can add to the procedure a subroutine from the mid-level algoblock program by using (adding) the corresponding “Subroutine call” algoblock.

In the top-level algoblock program, data validation can be performed. Such data validation may be carried out after data sampling (if the sampling is determined). In the particular case, before using operands in an operation, the operands can be checked for validity. In the particular case, at least one of the types of checks can be carried out:

 - status check;

 - database check.

At least one of the described checks can be carried out both jointly with each other (combined by the combination of “AND” / “OR”), and separately from each other, as described below.

In FIG. 13 shows a window of the visual table programming environment used to create an algoblock program at the top level.

By pressing the "Generation" button, the current system of the algoblock program is transferred to the executing system, that is, the corresponding set of tables. This button can be translated by pressing the right button of the “Mouse” manipulator into a constantly pressed state (“Auto-generation” mode) in the programming interface, then the current version will be transferred to the executing system immediately after any changes to the program are made.

In the table “Calculation procedures”, the user can select one of the rows of the table, for example, using the “Mouse” manipulator.

When the user selects one of the rows of the mentioned table, the algoblock edit window is displayed. So, for example, when the user selects the first row of this table, the editing window of the first algoblock is displayed, which is shown in FIG. fourteen.

In FIG. 14 shows the editing window of the algoblock in the editing mode of the algoblock top-level programs.

In this editing mode of the algoblock, the user can specify the operands and results of operations. So, the user can specify the data source, for example, by choosing database "A" as the data source (analog signal database, an example of which is shown in FIG. 19) or the digital signal database "D", or other databases in that including internal, which are described in the framework of the present invention (as shown in FIG. 15.

In FIG. 15 shows a menu for selecting a data source for an algoblock.

In FIG. 16 shows the editing window of the algoblock with the selected “Arithmetic” operation as the operation for two operands (Operand 1 and Operand 2).

In FIG. 17 shows a menu for selecting the type of arithmetic operation, which is carried out by the user when selecting the type of arithmetic operation.

After the user changes the type of arithmetic operation, in this case to “addition”, the operands of the algoblock (in particular, Operand 1 and Operand 2) automatically changed to terms, as shown in FIG. eighteen.

In FIG. Figure 18 shows an example of an algoblock editing window with the selected "Arithmetic" operation as an operation for two operands, in this case, the terms of the selected type of arithmetic operation in the form of summing these operands. The result of this algoblock is the sum as shown in FIG. 18. The input parameter for the first term is the value of the field "LastValue" (the last value) of table A1 (the database shown in FIG. 19); the input parameter for the second term is the value of the “LastValue” field (last value) of table A2; and the result of the addition operation (Sum) is displayed in the “Last Value” field (last value) of Table A3, as shown in FIG. 19.

In FIG. 19 shows an analog signal database window. In this database, at least the result of the work (execution) of the algoblocks is displayed, and the user can set values for the algoblocks, in particular, by changing the fields of the tables (A0, A1, A2, etc.), for example, the values of the fields "Last Value". The user can change the “Scalar” to “Vector” (or “Matrix”) for the first term, the second term and for Sum, as well as set the size of the vector. In this example, the size of the vector is set by the user to two (2).

The user can also set the step, which in this case is also equal to two, as shown in FIG. 20 for the first and second terms, as well as for the Sum.

In FIG. 21 shows a window of a database of analog signals for an algoblock, an example of which is shown in FIG. twenty.

In the same manner as described above, a logical algoblock or any other algoblock described in the framework of the present invention can be created.

A status check can be performed for data having status bits of signal status, in particular:

- estimated database (Rsprog RR);

- DB (MWBridge / MLB) A and D.

Moreover, for databases (MWBridge / MLB), status checks are turned on bit by bit:

- bit “N” - validation (which is described in more detail below);

- bit “K” - acknowledgment bit;

- 6 bits of the settings (in the case of reliability, the “H” bit is not charged) / types of inaccuracy (in the case of uncertainty, the “H” bit is cocked, that is, equal to one). Checking the database is carried out by analyzing the state of the specified database element (scalar, vector or matrix — if necessary, the data is convolved using the “AND” / “OR” flag) - the element is checked for True / False depending on the specified check flags. The conversion of various data types to a logical type is carried out as follows:

- for numerical data (any real and integer), a value of zero is false, and a value of non-zero is true;

- for character data, the character code is used and further processing is carried out as for integers (in particular, through the use of an ASCII code).

Instead of checking against the database, the databases specified in the processing condition as an extension of the operand / result database should be used, moreover, such a check (according to the “AND” / “OR” statuses of the database) is the reliability check mentioned above.

For each operation, the user can specify the modes of using the results of such verification when performing the operation. For the operation, the check job flag is defined, which has the following values:

- NPR (do not check operands for reliability);

- Lyub (at least one of the operands must be reliable);

- Both (check both operands),

as well as a flag of the feasibility of the operation, depending on the results of the check:

- Yes (the operation is in progress);

- No (the operation is not performed).

If necessary, the operands are convolved according to "AND" or "OR".

Accounting for false data during convolution is performed as follows:

Operand checking "I" convolution Convolution by "OR" Do not check The operand constant is used. Operand is skipped Check The operand itself is used. Operand is skipped

NPR
(do not check) ANY / BOTH Perform an operation Do not perform an operation one
operand 2 operands one
operand 2 operands one
operand 2 operands ANY BOTH ANY BOTH OP
DST-0 Both OP
DST-0 OP
DST-0 Both OP
DST-0 Both OP
DST-0 OP
DST-0 Both OP
DST-0 Both OP
DST-0 OP
NEDST-
one One OP
NEDST-2 OP
NEDST-4 One OP
NEDST-5 One OP
NEDST-7 OP
NEDST-9 One OP
NEDST-10 One OP
NEDST-12 Both OP
NEDST-
3 Both OP
NEDST-
6 Both OP
NEDST-
8 Both OP
NEDST-
eleven Both OP
NEDST-
13

where OP DST - The operand is reliable; OP NEDST - The operand is unreliable.

Happening Act Recorded Status 0 Trivial case: operation is performed on operands 0 one Instead of the NEST operand, the OPERAND CONSTANT is used 0 2 If the operand was minimized by "AND": ORANDAND CONSTANT: ORDER NOT OPERATED 0 3 === one four Used Operand itself 5 5 NEDST operand is not taken into account 0 6 === four 7 === four 8 === four 9 Operation DOES NOT PERFORM: RESULT CONSTANT is used (if enabled); The constant is written with its STATUS, the status record flag is ignored. But, if a status record is specified, then the status of the constant will be erased by the status of the operation 5 10 === 5 eleven === 9 12 === 9 13 === 9

If the operation cannot be performed (division by 0, etc.), then the result constant (if allowed) and status 5 (if the status record is allowed) is written to the result.

The following is an example of analysis of the reliability of operands during convolution:

- Convolution according to the "I" flag: the resulting collapsed operand is declared invalid if at least one of the collapsed data was invalid;

- Convolution by the "OR" flag: the resulting collapsed operand is declared invalid if all collapsed data was invalid.

If, as a result of the convolution by the "OR" flag (with the skipping of invalid faithfuls), there is not a single reliable data, then such an operand is considered absent.

The following is an example of actions in the absence of operands when the absence of at least one operand is detected, then:

- with the values of the flags “Lyub” or “Both” and with the flag of feasibility of the operation “Yes”, the result constant is written to the result;

- for all other flag combinations, the result does not change.

The expansion of the operand / result database due to the database specified in the condition field allows the use of additional databases in operations. The extension is activated by “clicking” the “mouse” manipulator in the Processing condition or Processing result area, and the name changes to Operand expansion or Result extension.

Extension Rules:

- expansion is carried out by (simple) increase in dimensions:

Operand structure Condition structure Resulting structure Note 1. Scalar Scalar Vector (2) Vector (n) Vector (1 + n) Matrix (n, m) Vector (1 + n) 2. Vector (l) Scalar Vector (l + 1) Vector (n) Vector (l + n) Matrix (n, m) Vector (l + n) 3. The matrix (l, k) Scalar Matrix (l, k) No extension Vector (n) Matrix (l, k) No extension Matrix (n, m) Matrix (l + n, k) There is only if m> = k

- when expanding for additional databases, the same type of values is used as for the main operand / result; if this type of value does not exist for the additional database, then the current value is used.

The following describes the recording of data in the algoblocks.

When writing data to the database (MWBridge / MLB) before writing, the previously recorded value is checked. Recording is carried out only if the data is different (an exception may be the “Copy” algoblock). In a particular case, the data are (actually) the value and status (depending on the operating mode, the value and status can be written both together and separately).

Writing data to the database (Rsprog) is always done.

In FIG. 22 depicts an exemplary embodiment of procedures and execution control, in accordance with one embodiment of the present invention.

In FIG. 23 depicts an exemplary embodiment of an algoblock structure, according to one embodiment of the present invention.

In FIG. 24 shows an exemplary embodiment of the structure of an operand of an algoblock, according to one embodiment of the present invention.

In FIG. 25 depicts an exemplary embodiment of an operation structure and result, according to one embodiment of the present invention.

In the particular case of the implementation of the present invention, the structure of these operands and the result can be determined:

- scalar;

- vector:

- matrix;

- a list.

In FIG. 26 shows an example of the structuredness of these operands and the result determined by the list, according to one embodiment of the present invention.

In the particular case of the implementation of the present invention, the structure defined by the list contains:

1 Separation by job mode:

1.1 assignment by constants;

1.2 assignment of links to the database.

2 Separation of the organization of data in lists:

2.1 list of scalars (forms a vector - it is processed as a vector);

2.2 list of vectors (forms a matrix - is processed as a matrix);

2.3 list of lists (forms a matrix - processed as a matrix).

The table below shows an example of the use of elements of the list Sp (1 ... 8) in various modes (according to FIG. 26):

Data organization Job mode 1.1 Constants 1.2 References 2.1 List of scalars (vector) Sp (1..8) - list specified by constants (maximum 8 elements) - vector size Sp (1) - link to the beginning of the list; Sp (2) - the number of list items (vector size) 2.2 List of vectors (matrix) Sp (1..6) - list specified by constants (maximum 6 elements) - vector size; Sp (7) - the number of vectors (matrix size); Sp (8) is the displacement between the vectors of the matrix; 6XSp Matrix (7) Sp (1) -link to the beginning of the list (matrix element (1,1)); Sp (2) - the number of list items (vector size); Sp (3) -number of vectors (matrix size); Sp (4) -shift between the vectors of the matrix; the matrix Sp (2) XSp (3) is formed 2.3 List of lists (matrix) Sp (1..4) - list specified by constants (maximum 4 elements) - vector size; Sp (5..8) - displacements between the vectors of the matrix counted from the 1st vector; 4X5 matrix is formed Sp (1) -link to the beginning of the list (matrix element (1,1)); Sp (2) - the number of list items (vector size); Sp (3) -number of vectors (matrix size); Sp (4) -link to the list of displacements of the matrix vectors counted from the 1st matrix vector (the size of the list is sp (3) -1); the matrix Sp (2) XSp (3) is formed

It is worth noting that

1. Lists defined by constants:

- have individual negation flags;

- list items less than or equal to zero and not falling into the normal number area (there are no normal numbers behind them) are discarded.

2. Lists specified by links:

- if the list item is given a negative number, then it is considered that it has a negation - the absolute value is used to select the item;

- no other checks are performed - zeros are not discarded.

3. The individual negation of the list item and the general negation of the entire operand are combined according to the “Exclusive OR” rule, thus two negations cancel the negation.

Denial of elements is carried out after reading or before writing according to the following rules:

- for numbers multiplied by -1;

- the NOT function is performed for logical elements;

- for characters:

- if the character code is less than 128, then 128 is added to it;

- if the character code is greater than 127, then 128 is subtracted from it.

In FIG. 27 illustrates an exemplary user interface for interacting with databases, according to one embodiment of the present invention. In the particular case of the implementation of the present invention, the described method enables the user to view and edit (settlement) databases, which may include at least two modes of user interaction:

- initialization of databases;

- view and edit current values.

In the particular case of the invention, the user can carry out:

- view databases;

- editing databases:

- editing of individual elements of vectors;

- group assignment of the same values (for a character vector, both an assignment character and its code are entered);

- change the dimensions of vectors (only in initialization mode) (use the "Install" button);

- definition of database elements used to organize remote control of the program execution process ("Debugger"):

- the "Commands" field defines the database elements used to transmit commands to the executing system (the presence of a command is determined by the value of the corresponding variable: = 0 - there is no command, = 1 - there is a command; after executing the command, the executing system resets the control variable to 0);

- the “Parameters” field defines the database elements used both for transmitting parameters in certain commands and for receiving the results of the execution system; the “Start” field defines two consecutive parameters: the number of the procedure and the algoblock; the “Stop” field defines three consecutive parameters: cycle, procedure, and algoblock number; the “Time” field defines three consecutive parameters in milliseconds: system clock, real-time kernel execution time, and algoblock program execution time; the Cycles field defines the vector of cycle counts (the number of cycles is predefined);

- the “Autostart” field determines the program launch mode after loading:

- when the "Autostart" mode is on, the program starts to be executed immediately after loading with a possible delay indicated in seconds;

- if the "Autostart" mode is disabled, the program is not executed after the system starts; launch is possible only:

- or using the control buttons in the database (Rsprog) (only local launch - the program starts to run on this computing device);

- or by setting the value "1" in the corresponding control variable of the database ("Start"), and it is possible to remotely start the program, provided that this control variable is included in the network transmission;

- the “Accounting groups” field allows you to set the processing method for accounting groups:

-before the execution of the program;

-after the execution of the program;

-in the body of the program itself using the “Accounting Groups” algoblock (in this case, it is possible to specify the numbers of the groups to be counted; in other cases, all groups are always calculated)

Additional features of the user viewing and editing (calculated) databases, including, but not limited to, initializing databases, viewing and editing current values, are presented in the table below:

Team Parameters Used Actions Start Start (Pr / Alg) - the program starts with the specified procedure and the algoblock (Pr and Alg are not equal to 0); Stop (Ck / Pr / Alg) - the program stops after reaching the specified procedure and the algoblock on a given cycle (Ck, Pr and Alg are not equal to 0); Running a program for execution Stop ----- Program execution stop; in the Stop parameters (Tsk / Pr / Alg), the cycle, procedure, and algoblock numbers are returned, at which the stop Generation ----- The calculated arrays and the program are rebooted; if the program was previously running, it starts Continue ---- Continued execution after shutdown Reset Counters ---- Zeroing execution counters for all procedures that are included in bypass cycles Algoblock "+" ---- Step-by-step execution; in the Stop parameters (Tsk / Pr / Alg), the cycle, procedure, and algoblock numbers are returned, at which the stop The cycle "+" Bypass cycle (defines the number of the procedure included in the bypass cycle) Execution of the specified procedure for one cycle; in the Stop parameters (Tsk / Pr / Alg), the cycle, procedure, and algoblock numbers are returned, at which the stop System cycle (set in ms.) ---- Change the main cycle of the system

In the particular case, the execution of the command is called by setting "1" in the corresponding database variable, as shown in the table below:

Parameter Value Start (Pr / Alg) The starting procedure and the algoblock are determined Stop (CC / Pr / Alg) At start: define a breakpoint;
On stop: return a breakpoint Bypass cycle For the command "Cycle" + "determines the number of the procedure included in the loop Execution / Error Returns the value “1” when the program is running and “0” when the program is not running. Negative values indicate errors:
-1 - error loading Progres.nsi;
-2 - error connecting to the database (MWBridge);
-3 ..- 8 - error processing database files RS $ RR, RS $ LR, RS $ SR, RS $ IR, RS $ IR2, RS $ IR4, respectively;
-9 - there is not enough RAM to load the calculated databases;
-10 - insufficient RAM to load the procedure;
-11 - Error processing the procedure file;
-12 - Win-program cannot be executed under DOS;
-13 - memory allocation error for the area of previous values;
-14 - missing procedure file;
-15 - the file size of the procedures does not match the required
-16 - the internal structure of the procedure file is destroyed;
-17 - no procedures for calculation;
-18 - error creating the Procedur.prs file;
-19 - error writing to the Procedur.prs file;
-20 - checksum error. Last procedure, last algoblock Returns the procedure and algoblock numbers on which execution on the current clock cycle of the executing system is completed Resident cycle Returns the current value of the cycle: 0 - start, 1 - execution, 2 - completion Cycle (vector) Returns the current values of the cycle counts for the procedures included in the loop (the number of procedures is determined by the dimension of the vector, but not more than the loop) Time (S / R / U) Returns time in ms: S - the main clock of the system; R is the clock cycle of Resident; U is the clock cycle of the runtime processing system of algoblocks

In FIG. 28 shows one embodiment of a user interface for describing a database according to one embodiment of the present invention. In the particular case of the invention, the user can view and edit descriptions of signals, as well as analyze the use of signals.

In the particular case, the user can view and edit the signal name, description of the signal, initialization value, current value (in particular, when the system for executing algorithms is loaded).

So, in a particular case, the user with the mentioned editing can use:

- Add function - one new signal is added to the end of the database (when the executing part is loaded, the database is rebooted);

- Correction function - the transition to the database correction format is performed;

- operations with the clipboard (the clipboard can later be used in the correction format):

- writing to the clipboard (to the beginning, to the end, with zeroing the previous contents, etc.);

- buffer cleaning (full cleaning, block cleaning, etc.);

- assignment of signal numbers for writing to the buffer using the mouse button in the signal number area (using the left button of the mouse button, the user can determine the beginning of the recording area, using the left button of the mouse button the user can determine the end of the recording area for copying to clipboard).

It is also worth noting that the present invention analyzes the use of elements of at least one of the databases. Such an analysis can be carried out automatically. The analysis mode can be set (implemented, defined, set, etc.) by the user, at least by choosing from the following modes:

- only assignment;

- only use;

- appropriation and use.

The Use mode allows you to determine those places in the program (procedure, algoblock number and area in the algoblock) where this element is used, either as a given, or as a flag, or as a reference array.

The Assignment mode allows you to determine those places in the program (procedure number, algoblock and the area in the algoblock) where this element is assigned, i.e. changes the meaning.

In both cases, the use and assignment can be carried out by reference, i.e. depend on the current value of other elements.

In the particular case, the analysis of the reference information is carried out (only) when the executing system is loaded.

In the particular case of the implementation of the present invention, verification of performance under the terms of the result can be carried out.

So, for example, verification of the need for execution of an algoblock can be carried out (directly) at the calculation stage. For this, the conditions of the result can be used.

To enable verification, the user can:

- cock the flags:

- use of the conditions of the result;

- checks on the conditions of the result;

- determine the value for verification (for example, True, False, 0 13, as described in the framework of the present invention);

- set the default scan result (Yes, No) used for invalid data or incorrect addressing of the scan conditions.

In the particular case, a given (specific, established, etc.) check thus allows you to perform operations individually. For example, in the operation of adding vectors with writing to the result vector, you can determine the result condition vector that allows addition to be performed only for selected elements of the vectors (for those elements of the result vectors for which the corresponding elements of the result condition vector have a value equal to the one being checked).

Verification by the conditions of the result may be applicable for at least one of the following operations:

- general operations:

- copying;

- (all) arithmetic operations (except for progression, solving a system of linear equations, as well as determining the coefficients of a polynomial);

- (all) logical operations, except for an aperiodic filter and deviations;

- dynamics operations:

- restriction;

- PWM;

- timers:

- cyclic;

- astronomical.

In a particular embodiment of the present invention, by a user or at least one part of a system implementing the method described in the present invention, an operation of selecting operands can be performed.

The operand selection operation is used to filter operands according to certain criteria. Unsampled operands do not participate in the operation. The mentioned sample can be organized according to the following criteria:

- by dial number;

- by parameter status;

- by parameter value.

Selection by dialing number can be done for the database (MWBridge). A parameter is considered to satisfy this selection criterion if the parameter set number is equal to the specified one.

Status sampling can be performed for the database (MWBridge) and the RR vector. A parameter is considered to satisfy this selection criterion if the current status of the parameter is included in the group of statuses allowed for this selection. The following organization of sampling by status can be carried out:

- Norm (status = 0);

- Reliably (0.3.4);

- Unreliable (1,2,5,6,7);

- For the upper setting (3);

- For the lower setting (4);

- For the upper or lower setting (3.4);

- Not at the upper setting (0.4);

- Not at the lower setting (0.3);

- Direct indication of the status value in the range 0-7.

Also, to organize the sampling, a status byte can be used, in which bitwise (6 bits of settings analysis, a validity bit and an acknowledgment bit) are indicated:

- Use of this bit (setting the bit to "1");

- Use of this bit (reset bit to "0");

- Refusal to analyze this bit.

In the particular case, it is considered that the sample has been passed if all the bits for which the test is defined have the indicated values.

Sampling by value can be performed for all databases. A parameter is considered to satisfy this selection criterion if the current value of the parameter satisfies the specified verification condition. The following value checks are possible:

- equal to a constant;

- unequally constant;

- more constants;

- less constant;

- is in the range <constant1 - constant2>;

- is out of the range <constant1 - constant2>.

The results of the selection according to the above criteria can be combined into a single result by the logical operations "AND" and "OR", which allows you to compose complex logical structures for selecting operands.

Sampling can be carried out for the following operations:

- general:

- copying;

- arithmetic:

- all binary operations;

- all unary operations;

- weighted addition and multiplication, as well as weighted average;

- falling into the range;

- progression;

- brain teaser:

- denial (NOT);

- AND, OR, Exclusive OR, NOT AND, NOT OR, NOT Exclusive OR, Following, NOT Following,

- comparison with settings;

- comparison of values;

- falling into the range;

- dynamics:

- model identification.

The inclusion of sampling is as follows:

- set the general flag to enable the selection;

- include the necessary samples (by set, status and value);

inclusion is made by clicking the "mouse" in the namespace

sampling;

- for each included sample, set the required values for verification;

- determine the logical connective of the samples (if more than one sample is used).

The present invention uses a graphical (visual) interpretative type programming language (GUYAP).

It is worth noting that the NSG is procedural (in terms of sequence of execution).

It is also worth noting that the NSG is a digital analog computer model (in terms of data processing).

Also, in the NSG there is no translation into a text language and further compilation.

The program described in the framework of the present invention consists of visual communication of the algoblocks and is stored (in RAM, on a hard disk drive, etc.):

- in the form of a set of algoblocks;

- links between the algoblocks and the initial data for the algoblocks, which (algoblocks, links, initial data), in turn, are stored in the form of linked tables.

It is also worth noting that the runtime environment, in the particular case of the described system (for various software and hardware platforms), is a real-time environment (which ensures the determinism of the execution time of one program cycle) is an interpreter that executes the created / created program.

Also, a user-created program in the runtime runs continuously in an endless loop, stopping the program is a temporary debugging action.

It should be noted that there is no parsing in the runtime (interpreter), and parsing is performed by the programming interface by presenting only valid elements of the programming language for use, which eliminates user syntax errors and does not allow the possibility of creating other infinite or indefinitely long cycles, except for one general program cycle.

Also, the conversion of data formats (integer-real, real-integer, etc.) occurs automatically according to predefined rules;

The method and system allow both programming controllers and creating general-purpose programs / software (programs for operating systems, operating systems, etc.).

In conclusion, it should be noted that the information provided in the description are examples that do not limit the scope of the present invention defined by the claims. One skilled in the art will recognize that there may be other embodiments of the present invention consistent with the spirit and scope of the present invention.

Claims (27)

1. Implemented by the processor a method of visually creating programs for computing devices, in which: - the creation and editing by the user through the graphical user interface of the program (algoblock program) for the computing device is carried out by selecting and adding operators (algoblocks) from the list of available algoblocks, then the user inputs and outputs the algoblocks, thereby setting data flows between operators (algoblocks) , immediately after their creation, the algoblocks perform the actions specified by their type code (or type code and their additional parameters) I am on the data coming to the inputs of the algoblocks, in accordance with visual connections with the outputs of other algoblocks (represented by links in the form of rows in a table containing the number of the algoblock and its output, which simultaneously set the visual arrangement of communication lines) from at least one output of at least at least one algoblock, or with links containing an index of a value in a common data array (data arrays are vectors or data matrices that are stored in the database), while the results of the above-mentioned algorithms the shackles remain either at the outputs of the algoblocks (the vector or matrix of which make up the database of outputs), or are written in accordance with the links or links (specifying the number of the element in the data array in which the result is stored) to the general data arrays, and the algoblocks are graphic elements that in turn, they are visual images of devices or processing units in the form of rectangles, tables, mnemonic images of blocks or processing units, communication lines, or pointers, are also visually represented links between the inputs and outputs of the algoblocks and / or between the sets of data arrays that are stored in the database, and the creation of the algoblock program is carried out: - by setting at least one sequence of algoblocks and connections between their inputs and outputs or between their inputs and outputs and data arrays: - by setting for a predetermined sequence of algoblocks the parameters of the settings of the algoblocks and the connections between their inputs and outputs or between their inputs and outputs and data arrays; - the algoblock program is executed by the executing hardware-software environment, which sequentially executes the algoblock behind the algoblock, choosing their codes and links from the first list (array) - data links for this algoblock are in the second list (array), and the runtime is managed the source code of the algoblock program, consisting of the arrays mentioned, created and modified in the visual environment of the algoblock programming, is an interpreter, and the whole Volume of the mentioned data arrays. 2. The method according to p. 1, characterized in that if it is necessary to simultaneously solve problems with different periods of data processing by the visual programming system and the runtime, it is possible to separate the algoblocks into different bypass cycles: - the first cycle has the shortest execution period - in this cycle, tasks that require the most frequent execution are solved; - the second execution cycle can be divided (divided) into several parts, and after each execution of the first cycle, the algoblocks of the next part of the second cycle from the first to the last are executed sequentially, and the entire second cycle is performed for as many periods of execution of the first cycle as the number of parts of the second cycle ; - the third cycle corresponds to the second, as the second to the first. 3. The method according to p. 2, characterized in that the execution of the algoblock program is carried out by the runtime in an infinite loop, with the exception of special modes, when the program is limited to one cycle. 4. The method according to claim 1, characterized in that the creation and editing of the algoblock program is performed by the user editing the arrays comprising the algoblock program by defining or editing the sequence of algoblocks by selecting them from the list of possible types of algoblocks and specifying input data for the algoblocks or by means of graphical indication of the connections of inputs and outputs of the algoblocks, or by the selection of inputs and outputs from the list of possible databases and their element numbers. 5. The method according to p. 4, characterized in that due to the impossibility of entering invalid or incorrect data at any time when creating and / or editing the algoblock program, such an algoblock program does not contain syntax and loop errors, which allows its execution to continue while the runtime is created and editing the algoblock program, and in turn, allows you to provide visual control of the result of editing the program directly at the time of editing. 6. The method according to claim 1, characterized in that the data types between the inputs and outputs of the algoblocks (operators), as well as between the inputs and outputs of the algoblocks (operators) and between external databases are automatically coordinated according to predefined rules. 7. The method according to p. 1, characterized in that the direct text input of numbers or other character sequences is carried out with the control directly in the process of entering both the validity of the input of each character and the validity of the input number or other character sequence in such a way that at the time of completion input, this number or sequence could be used immediately in the algoblock program. 8. The method according to PP. 6 and 7, characterized in that the user creates and edits the mentioned arrays that make up the algoblock program by specifying or editing the sequence of algoblocks by selecting them from the list of possible types of algoblocks and specifying the input data in the graphical user interface for them or by graphically setting the connections of inputs and outputs Algoblocks, in which it is possible to connect only the inputs and outputs that are valid for the connection, or by selecting data from the list of valid, due to which syntax is impossible errors and errors of looping and entering invalid or incorrect data, and at any time of creation or editing, and the algoblock program allows you to continue its execution when you create and edit it, that is, the creation of the algoblock program is carried out visually by the user by selecting from the list of valid parameters and graphical assignments and provides visual control of the result of editing the program immediately at the time of its execution. 9. The method according to p. 1, characterized in that the means of the said computing device stores and transfers the algoblock program to another computing device, and also receives current data from the said computing device, and the stored and transmitted algoblock program uniquely and completely corresponds to the original created the block program and is displayed and edited by the user on another computing device, by means of saving I and the transfer of the above arrays that make up the algoblock program. 10. The method according to p. 1, characterized in that depending on the tasks to be solved, the structure and volumes of information requiring processing, the block-based programs are divided into three levels: - the lower level with a small amount of data and, accordingly, the ability to foresee a set of all necessary operations for their processing - at this level, the set and sequence of algoblocks are fixed, part or all of the algoblocks are implemented in hardware, programming consists in setting up connectives for the data of the algoblocks and parameters of the algoblocks and is the most simple and affordable; - an average level with a small amount of data requiring a wide variety of processing functions - for this level, the sequence of algoblocks and their types are specified during programming, the database consists of the outputs of the algoblocks, the connections for the inputs of the algoblocks refer to the outputs in this database, a small part of the algoblocks can be implemented hardware, at this level, the algoblock programming system is a digital model of an analog computer; - the upper level, characterized by large amounts of information: when programming, the sequence of algoblocks and types are set, the databases are external and links to them are set for inputs and outputs. 11. The method according to p. 10, characterized in that between the algoblock programs of different levels, the interaction is performed by setting the links between their databases, similar to the links inside the algoblock programs. 12. The method according to p. 1, characterized in that between the algoblock programs of various computing devices, the interaction is performed by setting the links between their databases, similar to the links inside the algoblock programs or the links between the algoblock programs of different levels within the same computing device, while the actual data transfer between devices can be carried out by any of the existing or future channels of data exchange between computing devices. 13. A system for visually creating programs for computing devices, including: - a graphical user interface through which the user creates a program (algoblock program) for a computing device by selecting and adding operators (algoblocks) from the list of available algoblocks, then the user inputs and outputs the algoblocks, thereby setting data flows between operators (algoblocks) , immediately after their creation, the algoblocks carry out actions given by their type code (or type code and their additional parameters) the inputs arriving at the algoblocks in accordance with visual connections with the outputs of other algoblocks (represented by links in the form of rows in the table containing the number of the algoblock and its output, which simultaneously set the visual arrangement of communication lines) from at least one output of at least one of the algoblock, or with links containing the index of the value in the general data array (the data arrays are vectors or data matrices that are stored in the database), while the results of the above actions either at the outputs of the algoblocks (the vector or matrix of which make up the database of outputs), or are written in accordance with the links or links (specifying the number of the element in the data array in which the result is stored) to the general data arrays, and the algoblocks are graphic elements that are in turn, they are visual images of devices or processing nodes in the form of rectangles, tables, mnemonic images of blocks or processing nodes, communication lines, or link pointers between at the entrances and exits algoblokov and / or between sets of data that are stored in a database, and creating algoblochnoy program is: - by setting at least one sequence of algoblocks and connections between their inputs and outputs or between their inputs and outputs and data arrays: - by setting for a predetermined sequence of algoblocks the parameters of the settings of the algoblocks and the connections between their inputs and outputs or between their inputs and outputs and data arrays; - an executing hardware and software environment that executes the algoblock program, which sequentially executes the algoblock behind the algoblock, choosing their codes and links from the first list (array) - the data links for this algoblock are in the second list (array), and the runtime runs under control of the source code of the algoblock program, consisting of the arrays mentioned, created and modified in the visual environment of the algoblock programming, is an interpreter, and all the algoblocks have access to it said data arrays.

Images