Development of a control system based on fuzzy logic with code generation in DLL

Introduction

SimInTech is a tool for creating mathematical models of any systems, the description of which can be presented in the form of systems of algebraic and ordinary differential equations.

To simplify the process of modeling complex branched systems, SimInTech allows you to use graphical animation of blocks, which change their graphical display depending on the calculated parameters.

To speed up simulation and check the performance of the developed algorithms as embedded control algorithms, SimInTech allows you to convert computational schematics of control algorithm models into dynamic-link libraries (DLLs) using automatic generation of C code and use these DLL instead of the original schematics of control algorithm models.

At the first stage of this laboratory work a study of the work of animated blocks will be carried out using the example of library blocks Fuzzy logic. At the second stage, a model of a control system based on fuzzy logic will be developed to maintain the specified water level in a leaky tank. At the third stage, the fuzzy controller will be converted to the form of a dynamic-link library (DLL) using automatic code generation.

Purpose of the work

• Explore work of animated blocks using the example of the blocks of the libraryFuzzy logic
• Acquire primary skills to develop a control system model based on fuzzy logic
• Learn how the SimInTech code generator works

Tasks of the work

• Study the principle of constructing the Mamdani fuzzy inference system
• Develop a model for studying the operation of animated blocks based on fuzzy logic
• Study operation of the animated blocks
• Develop a model of the leaky tank control system:
  • develop a model of a leaky tank
  • develop a valve model
  • develop a controller model based on fuzzy logic
• Draw the plots showing the dependence of the target and current water levels in the tank over time, and a plot showing the outlet flow rate dependence over time.
• Compare the plots of the target and current water level in the tank
• Convert a fuzzy controller to a dynamic DLL using a code generator
• Compare the operation of the system model with the converted fuzzy controller with the operation of the initial system model

Basic theoretical information

In the classical theory of automatic control, the control signal on the system is calculated depending on the controlled value expressed in numerical form, and the control system converts the input parameters into control signals by transfer functions.

In these examples, the control signal is determined not in numerical form depending on the numerical value of the water temperature or the value of the water level in the tank, but in the form of a logical analysis of the statements.

To build control algorithms based on fuzzy logic, the data transmitted to the control unit based on fuzzy logic must be converted. To do this, it is necessary to convert the input and output parameters linguistic variables. Each linguistic variable is characterized by a set of terms.

Each term is defined by its membership function μ_i(x), which can take values from 0 to 1. For each value of the input variable x, the values of μ_i(x) for each term are calculated. This procedure of converting an crisp input of input quantities into a fuzzy set, determined using the values of the membership functions μ_i(x), is called fuzzification.

After fuzzification, a set of rules is applied. The result of applying the rule is a quantity called the truth degree, which takes a value from 0 to 1. For example, let's say for the following rule:

IF "level" = "low", THEN "valve control signal" = "open fast",

the input value indicating the level, h, is given in meters. If the value of the level is low (μ_low(h) = 1, where μ_low(h) is the membership function for the term "low"), or the level is not low (μ_low(h) = 0), then the truth degree of the rule takes the value of 1 or 0, similar to classical logic. Fuzzy logic applies if the membership function takes a value from 0 to 1, that is, if 0 < μ_low(h) < 1. So, μ_low(h) = 0.5 means that the level is not low and not high, respectively, the valve opening speed should be between fast and slow. In this rule, the truth degree of the statement "open fast" is 0.5.

Similarly, the truth degree for each rule is calculated. If in the condition rule. This procedure is called aggregation. The calculated truth value for all conditions of each rule is applied to the statements of each rule. This process is called activation. Aggregation and activation form a fuzzy inference.

It follows that the opening speed of the valve must be between fast and slow.

According to the obtained truth degrees, its numerical value is calculated for each term of the output variable. This procedure is called defuzzification.

The described fuzzy inference system is called a Mamdani type system, its structure is shown in Figure (Figure 1).

Task 1. Exploring the operation of animated blocks

For fuzzification and defuzzification, it is necessary to set the membership functions for each term. Let the water level in the tank be defined as the distance from the level sensor located at a level that is defined as normal to the current water level with the corresponding sign: if the value is close to -1, then the level is defined as "low", close to 0 – "normal", close to 1 – "high". The membership functions of these terms will be given as Gaussian membership functions. Let the valve control signal be defined as the valve opening/closing rate with the corresponding sign: if the value is close to -1, then the command is defined as "close fast", 0 – "do not change", 1 – "open fast". The membership functions of these terms will be set as triangular.

To develop a fuzzy inference system, it is necessary to build a fuzzy inference to a given set of rules. Since the rules set simple conditions – there are no complex logical constructions of the form "condition 1" AND/OR "condition 2", such fuzzy rules are represented by an implication operation of the form Y = X * w, where w is a weight factor equal to 1 in this case. Accordingly, Y = X, that is, the implication operation can be omitted and accumulation and defuzzification can be carried out immediately.

Development of a fuzzification model

Place the blocks on the diagram and connect them with signal lines according to the figure (Figure 2).

After that, you need to set the properties of the blocks on the diagram. The value of the input variable must be between -1 and 1. It is necessary to open the window Properties of the block Linear source and set the property values according to figure (Figure 3).

It is necessary to open the window Properties of the block Gaussian fuzzification and set the property values according to figure (Figure 4).

The property "S-function at the boundaries" is necessary to check the output of the input value outside the range, since the Gaussian function decreases outside the range, and therefore the value of the membership function decreases, which is not always permissible. For example, if the water temperature reaches 100°C, this should mean that the water is hot and it is necessary to open the cold water valve, but if the check for out of range is not carried out, then at this point the Gaussian function can have a value equal to 0, which will be interpreted as the water temperature is not hot, and subsequently can lead to incorrect results.

In order to draw three plots of membership functions on the same chart at once, to the inputs of the block Phase portrait three pairs of phase variables shall be transmitted, i.e. two vector values, of dimension "3”. To do this, it is necessary to convert the scalar input signal into a vector consisting of three identical elements equal to the input signal using a block Vector replicator. To do this, open the windowProperties of the block Vector replicator and in the "Formula" field, set the value of the "Multiplication coefficient" property to "3#1".

Starting the simulation and working with plots

After setting up the schematic, in order to plot the results of fuzzification, it is necessary to start the simulation process and wait for the end of the calculation.

Save changes and close the window by clicking the button Ok.

The plots should look similar to the figure (Figure 6).

Plots of Gaussian membership functions are obtained, which show how a linear change in the input variable from -1 to 1 leads to a change in the values of three terms in the range from 0 to 1. At the beginning, when the input value is -1, the term "low" has a membership function equal to 1, the membership functions of the terms "normal" and "high" are zero. As the input value increases, the value of the membership function of the term "low" decreases, and the term "normal" begins to grow: the closer to 0, the closer the value of the function to 1. As the input value approaches 1, the membership function of the term "high" approaches 1, and the terms "low" and "normal" tend to 0. Thus, an increase in the input value from -1 to 1 is presented as a visual process of transition from "low", through "normal", to "high".

In addition to Gaussian fuzzification, it is possible to use blocks of triangular and trapezoidal fuzzification or, if the membership functions cannot be represented using these standard functions, it is possible to specify user-defined functions using a programming language. Example of implementing a two-sided Gaussian membership function using a block Programming language is given in Laboratory Work No.1 of the Moscow Polytechnic University "Study of the membership functions of fuzzy sets" in the section "Task 4. Plotting the two-sided Gaussian membership function. "

Study of the work of the "Gaussian fuzzification” animated block

To observe the block animation Gaussian fuzzificationyou need to perform the real-time synchronization, to do this, open the windowProject parameters and in the tabSimulation control activate the parameterReal-time synchronization. After that, you need to initialize the project by clicking on the buttonInitialization. In this case, a vertical blue line will appear on the left in the field at the top of the block, meaning that the membership function of the first term ("low") is equal to "1" at the initial input signal equal to "0" (Figure 7).

After that, it is possible to take steps to track changes in the image in the coordinate space above the block using the button Take a step, or by starting the simulation process by clicking the button Start, pause simulation using the button Pause at the required point in time, and then resume the simulation by clicking the button Start. With increasing time, the image changes: as the value of the membership function of each of the terms increases or decreases, the height of the blue vertical lines corresponding to the terms increases or decreases accordingly. For example, at a time of 13.8 seconds, the value of the membership function for the second term ("normal") is approximately 0.5, and the term "high" is close to zero, according to Figure (Figure 8).

To view the script responsible for changing the block image: the color of the lines, their position and other characteristics of the graphic primitives involved in the animation, you must right-click on the block Gaussian fuzzification to open the context menu of the block, select the itemBlock display and in the opened window Graphic editor click the button Script (Figure 9).

In the opened window Animation script the text of the script that changes the block image is included. For example, in the block animation script Gaussian fuzzificationcoordinates are calculated and new objects are set for display – grid lines of coordinate space, which are drawn above the block, as well as lines whose height varies depending on the values of the membership functions calculated during the simulation. By changing the animation script, you can change the display of existing image objects, for example, color or position, as well as add new objects.

To change the color of the displayed level lines, it is necessary in the window Animation scriptto change the line in which the color of the level lines is set by setting the green code (Figure 10). Save the changes made to the image animation script for the block and close the window by clicking the button Close and apply.

It is necessary to verify the correctness of the lines display after changing the script. Start simulation by clicking on the button Start. Image above the block Gaussian fuzzification will change, i.e. the displayed level lines will turn green (Figure 11).

Addition to the model and study of the animated block "Triangular membership function block"

The model must be supplemented with a fuzzy inference system by adding a block that performs accumulation and defuzzification. To do this, add a block to the project window workspace. Triangular membership function block from submenu Fuzzy inferenceof the library Fuzzy logic and connect with a signal line according to figure (Figure 12).

When you start the simulation, an animation will be displayed in the block. For a more comfortable viewing of the displayed image, it is recommended to increase the size of the block Triangular membership function block, to do this, select the block with a single click of the left mouse button and move the mouse cursor to the edge of the block. The mouse cursor will change to the "Diagonal resize" cursor as shown in the figure (Figure 12).

Grab the edge of the block with a single left mouse click and drag it to the side to change the size of the block Triangular membership function block according to figure (Figure 13).

It is necessary to set the parameters that define the triangular membership functions of the terms of the output variable "valve control signal". To do this, it is necessary to open the windowProperties of the block Triangular membership function block and set the property values according to figure (Figure 14).

After that, you need to initialize the project by clicking on the button Initialization. In this case block graphic image Triangular membership function block will change and correspond to the first given triangular membership function, and a vertical red line will appear, meaning that the numerical value of the output variable at the initial time is equal to the coordinate of the vertex of the given triangular membership function for the first term ("close fast") (Figure 15).

Next, it is possible to track how the shapes and position of the line change either by setting a real-time synchronization or by performing a step-by-step simulation, as shown above.

For example, at a time of 5.1 seconds (Figure 16), the values resulting from the accumulation are displayed as triangles filled to about a quarter of the height, and the value of the output signal (red line) is between them, which can be interpreted as the position of the valve needs to be changed, and the valve closing speed should not be fast.

To view and edit the block animation script text Triangular membership function blockit is necessary to open the window Animation script in the same way previously described for the block Gaussian fuzzification.

To change the fill color of the displayed triangles, it is necessary in the window Animation script to change the line in which the code of this color is set. Set the code of green color in the corresponding line (Figure 17). Save the changes made to the image animation script for the block and close the window by clicking the button Close and apply.

After that, you need to start simulation and make sure that only the fill color of the triangular membership function blocks has changed to green, and the shape of the figures and the position of the red line correspond to the shape and position of the line before the changes in the script, that is, the operation of the block is not disturbed. Block display Triangular membership function block at a time point of 5.1 seconds (Figure 18) corresponds to the image before changes in the script at the same time point (Figure 16).

In this task, the animation of blocks was considered using the example of library blocks Fuzzy logic. In addition to using standard blocks in SimInTech, it is possible to create your own blocks and it is also possible to make them animated. An example of creating a custom animation block and the procedure for adding it to a new library is described in SimInTech Laboratory work No.3 "Developing an animation block in SimInTech" (section "Developing a block library").

Familiarization with the work of animated blocks is completed. Further, using these blocks, a model of a leaky tank control system based on fuzzy logic will be developed.

Task 2. Development of a leaky tank control system based on fuzzy logic

In this task, a model of a leaky tank control system is considered, which should maintain the water level in the tank at a given level.

Leaky tank model description

A schematic representation of a leaky tank is shown in the figure (Figure 19). Two pipes approach the tank: through one pipe equipped with a valve, water flows into the tank, through the other – it flows out. The intensity of the flow of water entering the tank depends on the position of the regulator-controlled valve. The water flow is uncontrolled and depends on the diameter of the outlet pipe (fixed value) and on the current water level in the tank.

Leaky tank dynamics equations:

where g = 9.81 m/s² is the acceleration of gravity.

Valve model description

Output value – the flow rate of water entering the tank, "rate", is calculated as the product of the nominal flow rate and the valve position value.

Fuzzy controller model description

The valve position is controlled by a fuzzy controller (Figure 20). The control algorithm is the Mamdani fuzzy inference system, which determines the opening/closing rate of the valve based on the signals received at the input of the controller: the difference between the current and target water level of the tank and the rate of change of the level.

The controller is a fuzzy inference system that includes the following components: a fuzzifier, an inference engine, a defuzzifier.

Thus, if the difference between the current and target water level in the tank is negative, that is, the actual level is lower than the target, then it is necessary to increase the flow rate of water entering the tank; if the difference is positive, that is, the actual level exceeds the target, then it is necessary to limit the supply of water to the tank; if the difference is close to zero, that is, the actual level corresponds to the target or differs by a small amount, then it is not necessary to change the position of the valve, but if the water level changes with a certain speed, then to determine the opening/closing rate of the valve, it is necessary to take into account the second variable – "rate of level change".

So, if the level difference is close to zero and the rate of change of the level decreases, then it is necessary to slowly increase the flow of water entering the tank, and if the rate increases, then it is necessary to slowly reduce the flow of water entering the tank.

The membership functions that define fuzzy sets for input variables will be set as Gaussian membership functions, for the output variable – as triangular membership functions.

Task accomplishment

Developing the model of a leaky tank

The development of models of a leaky tank, a valve and a fuzzy controller will be carried out in separate submodels for the convenience of organizing blocks according to models. After all models are developed, they will be combined into a general control system model.

Place the blocks on the diagram, connect them with signal lines, set the names of the input and output ports and set the labels to the blocks according to the figure (Figure 21).

initialization
    {Tank height}
    ht = 2;
    {Tank cross-section}
    area = 1;
    {Outlet pipe cross-section}
    outarea = 0.05;
    {position of the overflow sensor from the upper cut}
    overs = 0;
    {initial fluid level in the tank}
    inith = 0;
end;       

Next, it is necessary to implement a model of filling the tank with water and water leakage from the tank. The filled volume of the tank will be determined by the block Integrator with limitation. It is necessary to open the window Properties of the block Integrator with limitation and set the formulas for the properties according to the figure (Figure 23).

To set the formula for calculating the water level, open the window Properties of the blockGain labeled "Tank level" and set the "Gain factor" property to "1/area" in the "Formula" field.

After that, double-click with the left mouse button on the blockProgramming language to open a text editor and implement the formula for calculating water leakage from the tank in text form according to the presented script. After entering all the text of the script, click on the button Close and apply to accept changes in the block Programming language and closing the editor window.

{Calculation of tank leakage proportional to pressure}
input h;
g = 9.8;
outrate = sqrt(2*g*h)*outarea;
output outrate;        

After closing the text editor window of the block Programming languagethe names of the block ports will change according to the variables specified in the script. Since the port labels overlap, it is necessary to resize the block according to the figure (Figure 25).

The creation of the tank model is completed, then you need to exit the submodel by double-clicking the left mouse button on the free space of the submodel workspace.

Developing the valve model

Connect the blocks with signal lines and set the names of the input and output ports of the submodel according to the figure (Figure 26).

After creating the valve model, it is necessary to exit the submodel and resize the blocksSubmodel labeled "Tank" and "Valve" so that the names of the input and output ports of the blocks do not overlap, according to the figure (Figure 27).

Developing the fuzzy controller model

For blocks Demultiplexer it is necessary to set the value of the property "Array of input dimensions" to "[1, 1, 1]" and for the block Multiplexerto set the value of the property "Number of ports" to "5".

After preparing the blocks, it is necessary to arrange the blocks, connect them with signal lines and set the names of the input and output ports, labels to the blocks in accordance with the specified base of rules according to the figure (Figure 28):

1. IF "level difference" = "negative", THEN "valve control signal" = "open fast"
2. IF "level difference" = "close to zero", THEN "valve control signal" = "do not change"
3. IF "level difference" = "positive", THEN "valve control signal" = "close fast"
4. IF "level difference" = "close to zero" AND "rate of level change" = "decreases", THEN "valve control signal" = "open slowly"
5. IF "level difference" = "close to zero" AND "rate of level change" = "increases", THEN "valve control signal" = "close slowly"

Labels for the blocks Demultiplexer and Multiplexer denote the correspondence between the numbers of output and input ports and linguistic terms. Thus, to the first output port of the upper block Demultiplexer corresponds the linguistic term "low", and to the first input port of the block Multiplexer corresponds the term "close fast".

Next, you need to set the values of the properties that determine the membership functions of fuzzy sets corresponding to the input and output variables, that is, set the properties of the fuzzifiers and the defuzzifier. To do this, open the window Properties of the block Gaussian fuzzification labeled "Level difference" and set the property values according to the figure (Figure 29).

For the block Gaussian fuzzification labeled "Rate of level change" and set the property values according to the figure (Figure 30).

After that, you need to open the window Properties of the block Triangular membership function block and set the property values according to figure (Figure 31).

After completing the configuration of the fuzzy controller model schematic, it is necessary to exit the submodel and resize the block labeled "Fuzzy controller" so that the port labels do not overlap each other.

Merging the models into leaky tank control system based on fuzzy logic

Since it is necessary to plot not only the actual water level, but also the target water level, and compare them, it is necessary that these plots be drawn in one window. This requires for one of the blocks Scope to set the value of the property "Number of input ports" to "2".

Arrange the blocks on the diagram, connect them with signal lines and set labels according to the figure (Figure 32).

To form a target level, you need to open the window Properties of the blockSquare wave and set the property values according to figure (Figure 33). This block generates a periodic rectangular pulse signal with an amplitude of 1 and a half-period of 20 seconds.

Next, you need to set the nominal flow rate of water entering the tank. To do this, open the window Properties of the block Constant and set the value of the "Value" property to "0.5".

Configuring simulation condition

After configuring the schematic, before starting the simulation, it is necessary to configure the Calculation parameters. Since the half-period of the target level change was set to "20", then for simulating and plotting for several periods, it is necessary to change the project Calculation parameters, increasing the duration of the model time interval at which the simulation is performed, and for simulation speedup it is required to increase the maximum integration step. To do this, open the window Project parameters and set the values of the parameters "Maximum step" and "End calculation time" according to the figure (Figure 34).

Close the window Project parameters, in this case the changes made are saved.

Starting the simulation and working with plots

After setting up the project for plotting, you need to start the simulation process and wait for the end of the calculation.

To save changes and close the window, click the button Ok. The plot should look similar to the figure (Figure 36).

The plot of the target water level is pulses with a half-period of 20 seconds, the values of which will change from 1.5 m to 0.5 m and back. The plot of the current water level quite smoothly tends to the graph of the target level. As a result of the analysis of the obtained plots, it was proved that the model works correctly.

Save changes and close the window by clicking the button Ok.

The plot should look similar to the figure (Figure 39).

As a result of the analysis of the obtained plot, it was found that the plot fully corresponds to the expected results: the variable "outrate" at the time of 20 seconds is approximately equal to "0.271", which is consistent with the theoretical value calculated by the formula for the water level value at the same time equal to "1.5 m":

Task 3. Conversion of the control system of an leaky tank into a system with a fuzzy controller in the DLL form

SimInTech allows you to convert simulation diagrams of control algorithm models into dynamic-link libraries (DLL) using automatic generation of C code. The use of dynamic DLL libraries instead of the original schematics of control algorithm models allows you to significantly increase the simulation speed and check the performance of these algorithms as embedded control algorithms. This section is devoted to the conversion of the valve control algorithm – a fuzzy controller – into C program code and its compilation into DLL using a built-in template configured to create DLL libraries for Windows "MinGW".

Conversion of the fuzzy controller into a dynamic-link library (DLL) using a C code generator

Before converting the fuzzy controller into a dynamic-link library (DLL), it is necessary to save the model of the fuzzy controller to a separate file. To do this, double-click with the left mouse button on the block Submodel labeled "Fuzzy controller” to enter the submodel, then in the main window of SimInTech you need to select the item File subitemSave page as. Save the fuzzy controller model to a new project file named "FL_controller.prt".

After that, you need to prepare a fuzzy controller model schematic for code generation. To do this, open the project "FL_controller.prt" and replace the blocks Input port and Output port respectively to the blocks Input contact andOutput contact from tab Signals. In the block properties Input port in the "Value" field, set the value of the "Contact name" property to: "input:0", "input:1" respectively (Figure 40).

In the block properties Output port in the "Value" field, you must select the "Contact type" property according to the figure (Figure 41).

After configuring the diagram, before code generation, it is necessary to configure the Simulation parameters and the parameters of the code generator. To do this, open the window Project parameters and in the "Code generation" group, in the "Algorithm name (s)" parameter, in the "Value" field, enter "fuzzy_control" (Figure 42). Save the project.

After setting up the project parameters, it is necessary to configure the code generator. To do this, select in the main SimInTech window the item Code generator sub itemC Code generator. In the opened window C Code generator in the tabSettings in the "Source directory" line, specify ".\src" to save the source files of the program obtained as a result of the operation of the code generator to the "src" directory, in the "Code template directory" line, specify the path "% codetemplates %MinGW_DLL\". This template allows you to generate C code and a dynamic-link library for simulation using a floating point. At the same time, it is allowed to use other templates built into SimInTech (Figure 43).

In particular, for example, to obtain code that performs calculations with a fixed point, it is necessary in the tab Settings in the "Code template directory" line, select the line in the drop-down menu: "%codetemplates%FixPoint_16_16_MinGW_DLL\".

Study the operation of the control system of the leaky tank with the fuzzy controller in the DLL form

To study the operation of the control system of the leaky tank with the fuzzy controller in the DLL form, it is necessary to save a copy of the project with the original model of the system "General view model schematic.prt" using the name "General view model schematic_1.prt". Open the project "General view model schematic_1.prt".

The remaining block properties are set by default. If necessary, it is possible to change the values of the following properties:

• "Sorting type" – using this property, a checkbox is set that defines the simulation order in the main diagram
• "Equipment names" – with the help of this property, the names of equipment (components) are set, which are substituted into the input/output contacts of the DLL schematic
• "Create non-existing variables by default" – when this property is activated, variables will be created in the database that do not exist for the calculated equipment (components)
• “Issue warnings if the signal is not found" – when this property is activated, warnings will be issued if the signal is not found
• "Number of threads" – this property sets the number of threads in which simulations will be made for this DLL

After preparation of the block DLL it is necessary to replace the block Submodel labeled "Fuzzy controller" with the block DLL according to figure (Figure 46).

After setting up the project for plotting, you need to start the simulation process and wait for the end of the simulation. The plots should look similar to ones on the figures (Figure 47, Figure 48). The results of the model operation correspond to the previously obtained results (Figure 36, Figure 39), which confirms the operability of the DLL library of the fuzzy controller as part of the system.

To monitor the process of simulating the fuzzy controller, it is necessary to set real-time synchronization. After starting the simulation, double-click with the left mouse button on the block DLLto open the project specified in the value of the "Project file names for debugging" property of the block DLLwhich contains the fuzzy controller simulation diagram corresponding to the loaded DLL. In this case, the animation of the blocks is displayed on the recalled schematic, similar to the usual schematic, it is possible to view the values on the signal lines by double-clicking with the left mouse button on the required signal line (Figure 49). If no file names are specified, the schematic cannot be viewed in this way.

To compare the simulation speed with the controller in the form of the schematic in the submodel and in the form of compiled code, it is necessary to disable in the current project the parameterReal-time synchronization. After that start simulation and wait the end of calculation. In the main SimInTech window, select the item Simulation subitemDebug information (Figure 50).

In the opened window SimInTech debug information in the "Performance" tab, the "Maximum possible speedup" line shows how many times faster the simulation was made in real time (Figure 51).

After that, you need to open the project "General view model schematic.prt" created in the previous task and start it for simulation. After the end of the simulation, open the windowSimInTech debug information (Figure 52). The value in the "Maximum possible speedup" line is almost 3.5 times less than the speedup value obtained for a system with a controller in the DLL form, that is, the simulation is slower, which confirms the efficiency of using dynamic-link libraries to speed up the simulation.

Conclusion

In the course of this laboratory work, a model was developed for studying the operation of animated blocks on the example of the blocks of the library Fuzzy logic. A model of the control system for the leaky tank with the controller based on the Mamdani type fuzzy inference system the was also developed. The plot of the dependence of the water level in the tank on time and the outlet flow rate on time were drawn, and the plots of the target and current water level in the tank were compared. As a result of mathematical modeling, the correctness of the operation of the control system model of the leaky tank based on fuzzy logic was tested.

To get acquainted with the methods of C-code generator operation, the conversion of the fuzzy controller into the dynamic-link library (DLL) was carried out. The test simulation showed that the fuzzy controller in the form of a dynamic DLL generated in C language works similarly to the fuzzy controller in the submodel. Comparison of operating speedups showed that a system with a controller in the DLL form works several times faster than a similar system with a controller in the form of a schematic in a submodel.