Graphical programming cloud platform-based computing power elasticity development system and collaborative development method thereof

Abstract

The application discloses a computing power elasticity development system based on a graphical programming cloud platform and a collaborative development method thereof, and the computing power elasticity development system comprises an editing platform, a user end and a technical background, and is characterized in that the user end is an edge automatic controller, the edge automatic controller comprises a core processor and a subordinate function module, a basic environment library and a user coding environment are arranged in the editing platform, and a function logic workstation is arranged in the user coding environment; the function logic workstation supports system operation and operation development in the form of graphic element logic combination; and the graphic element logic combination and computing power elasticity are distributed to the core processor and the subordinate function module. The application has the beneficial effects that the dependence on a local development environment is eliminated, and the software development environment and the updating problem thereof are solved. Not only can the development environment of a developer and a user be organically coordinated, but also the computing power elasticity distribution can be realized according to the code paragraph structure corresponding to the graphic element, and the working efficiency of a user equipment is improved.

Description

Technical Field

[0001] This invention belongs to the field of industrial internet technology, specifically relating to a computing power elastic development system based on a graphical programming cloud platform and its collaborative development method. Background Technology

[0002] Programmable control technology has been widely applied in various technical fields such as industry, commerce, agriculture, healthcare, and education, with many cases already entering smart homes and smart cities. With the development of internet technology, network-based programming has connected technical development talent with project stakeholders. The network platform provides the basic hardware and software environment, while technical personnel build the technical backend offline to support market demands. However, various hardware and software vendors are constantly releasing newer underlying tools; for example, even the most basic Windows system has several new versions, rendering older systems obsolete. This makes it difficult for technical personnel to keep up with the latest technology and hardware, and the network platform also struggles to quickly update and upgrade the basic hardware and software environment. Constantly downloading and updating new systems has become a pain point for the industry. The diversification and pluralism of programming languages ​​and logical relationships further increase the difficulty of industry development. Even with the emergence of graphical language editing technologies, such as PLC graphical editing technology, the problem of logical languages ​​can only be solved to a certain extent in specific fields.

[0003] Existing graphical language editors offer a more intuitive and user-friendly interface. Graphical programming languages ​​reduce the learning curve, allowing users to get started quickly and easily. If an editor needs updating, developers must release a new version, which users then download or upgrade from.

[0004] However, its main drawback is:

[0005] (1) Depends on the local development environment. Developers need to configure the development environment before using it, which occupies the storage space of the user's computer.

[0006] (2) The pain points of updating work still exist. Updating the editor is very cumbersome. It requires releasing a new version, and users need to download and install the new version. If a serious bug occurs, it may be necessary to roll back the version.

[0007] (3) The designer’s development environment does not match the user’s specific hardware and software environment. The user’s hardware and software environment is diverse. Even if the development environment can be unified, the user’s specific device and its perception execution unit still need to be synchronized with the protocol.

[0008] (4) The algorithm timing of various processors and algorithm processors in user equipment is not coordinated, resulting in low working efficiency. Summary of the Invention

[0009] In view of this, the purpose of this invention is to provide a computing power elastic development system and its collaborative development method based on a graphical programming cloud platform. In a unified graphical software development environment, it not only organically coordinates the development environments of developers and users, but also enables elastic distribution of computing power, improving the working efficiency of equipment.

[0010] The technical solution is as follows:

[0011] A computing power elastic development system (WebReal) based on a graphical programming cloud platform includes an editing platform, and a user terminal and a technical backend connected to the editing platform via a network. The key feature is that the user terminal is an Edge Automatic Controller (EAC), which includes a core processor and at least one lower-level functional module. The core processor is connected to the editing platform and to all lower-level functional modules.

[0012] The lower-level functional modules are either connected to sensing elements or to execution elements;

[0013] The editing platform is equipped with a basic environment library and a user coding environment. The basic environment library obtains the hardware and software environment of the edge automatic controller and converts it into environment primitives and sends it to the user coding environment. The user coding environment is equipped with a function logic workbench (7).

[0014] The function logic workbench (7) is used to: support system operation and computation development in the form of primitive logic combination;

[0015] The function logic workbench (7) is also used to: combine primitive logic and distribute computing power flexibly to the core processor and each lower-level functional module.

[0016] The editing platform serves as a support, allowing users to contribute their own hardware and software environment—namely, the edge autocontroller—and submit project requirements. These requirements are then outsourced to developers through the platform. All developers uniformly use primitives to describe the program structure and translate it into the logic language used by the edge autocontroller. This organically coordinates the development environments of developers and users.

[0017] Furthermore, the edge automatic controller is flexibly distributed across the core processor and lower-level functional modules based on the primitive-based WebReal. The core processor may be a Windows PC, a Linux PC, a microcontroller, an IP core, or a GPU.

[0018] The lower-level functional modules may be MCUs, Linux system PCs, IP cores, GPUs, or FPGAs.

[0019] WebReal, based on primitives, can be deployed on computing units, which have two layers: an operating system layer (Windows, Linux, microcontroller, IP core, GPU) and a runtime engine layer (a virtual environment that runs the primitive source code). Therefore, WebReal is cross-platform. Different computing units have different computing power and timing accuracy, allowing WebReal to achieve accurate and controllable timing and reasonable distribution of computing power. There are six common computing models (WEB, M2M, ECS, FPGA, MCU, GPU), which can be combined arbitrarily. Examples include: EAC's single-machine series: CPU + MCU; EAC's enhanced single-machine series: CPU + FPGA + MCU; NI's: CPU + FPGA; EAC's network version; and PC (WEB) + server M2M + EAC's single-machine series.

[0020] Furthermore, the core processor is connected to lower-level functional modules via USB, Ethernet, serial port, or PCIe data interface;

[0021] The core processor is also connected to a monitor, mouse, buttons, wireless network card, and memory.

[0022] It is evident that EAC integrates the functions of industrial control computers and PLCs.

[0023] Furthermore, the user coding environment is equipped with a Kanban workbench (6), the function logic workbench (7) generates a function logic relationship expressed by a combination of primitive logic, and maps the underlying function logic relationship to the Kanban workbench (6), and the user coding environment directly sends the primitive logic combination and function logic relationship to the core processor, and the core processor realizes human-computer interaction through the display and mouse;

[0024] The core processor is equipped with an edge compiler, which compiles the functional logic into machine language, and coordinates with the communication protocol of each lower-level functional module.

[0025] Furthermore, the user coding environment is equipped with a Kanban workbench. The function logic workbench generates a function logic relationship composed of primitive logic combinations and maps the underlying function logic relationship to the Kanban workbench. The Kanban workbench (6) is connected to a compiler, which compiles the function logic relationship into machine language and cooperates with the communication protocols of the core processor and each lower-level functional module.

[0026] Furthermore, the function logic workbench is equipped with work frames corresponding to the core processor and each lower-level functional module, realizing a one-to-one correspondence between work frames and physical units. The corresponding primitive logic sub-combinations and related operation functions in each work frame are matched with the computing power of the physical unit. Each lower-level functional module stores primitives corresponding to its function.

[0027] Furthermore, the editing platform is equipped with a developer interface and a technical interface. The developer interface is connected to a developer terminal, which is connected to the technical interface via the developer interface. The developer terminal then edits the virtual edge automatic controller in the basic environment library (12) via the technical interface.

[0028] A collaborative development method for a computing power elastic development system based on a graphical programming cloud platform is described below:

[0029] Step 1: Based on user needs or user resources, the developer determines the hardware and software environment of the user edge automatic controller in the basic environment library and builds the user coding environment. The user coding environment is equipped with a user primitive library, a resource work platform, a function logic workbench (7) and a Kanban workbench.

[0030] Step 2: Based on user requirements, match relevant graphic elements in the user coding environment to the user graphic element library and send them to the resource workbench;

[0031] Step 3: In the Kanban workbench, generate input controls, output display controls, and debugging controls using the user element library according to your own functional requirements;

[0032] Step 4: Based on its own functional requirements, extract the existing data resources and their control elements from the user element library (4) to the resource workbench;

[0033] Alternatively, in the resource workbench, the available data resources of the user's graphic element library can be adaptively processed to generate usable data and its control elements;

[0034] Step 5: Submit the basic functions, mature data resources and their icons to the Function Logic Workbench, or use the basic functions to edit the logic function primitives created by the developer in the Function Logic Workbench;

[0035] In accordance with the program logic sequence, drag and drop the primitives representing all logical functions, mature data resource primitives, input resource control primitives, and output result display control primitives into the same running flowchart to generate the logic program;

[0036] Step 6: Edit the function logic of each physical unit in the function logic workbench:

[0037] Within the function logic workbench, work frames corresponding to the core processor and each lower-level functional module are also set up, realizing a one-to-one correspondence between work frames and physical units. The corresponding primitive logic sub-combinations and related operation functions within each work frame are matched with the computing power of that physical unit.

[0038] And map this logic program to the Kanban workbench;

[0039] Step 7: Adjust the input value of the input resource control element. The logic program calculates the output result data based on the input value, and the output result data is mapped to the display control for display.

[0040] Furthermore, in step 1, the developer determines the hardware and software environment of the basic environment library by scanning the edge automatic controller on the user's end.

[0041] Developers can use technical interfaces to virtualize the hardware and software environment required for user coding within the basic environment library, according to user needs.

[0042] Furthermore, the Kanban workbench may send the completed logic program to the compiler, which will compile the corresponding logic program according to the user's requirements and store it in the memory for the user to retrieve.

[0043] Alternatively, the Kanban workbench (6) can directly send the completed logic program to the user edge automatic controller.

[0044] Furthermore, the Kanban workbench may send image data to the core processor and each lower-level functional module for simulated program debugging;

[0045] Alternatively, once the simulation program is successfully debugged, the compiler sends the compiled executable program to the core processor, which then compiles it into machine language adapted to each lower-level functional module in the WebReal environment.

[0046] During system synchronization debugging, and subsequently during system operation:

[0047] Alternatively: The clock cycles of the core processor and all subordinate functional modules are set and calculated independently.

[0048] Alternatively: Select the core processor or any lower-level functional module to uniformly determine the working clock cycle of each unit and synchronize it throughout the process.

[0049] The beneficial effects of this invention are: it eliminates dependence on the local development environment and solves the problems of software development environment and its updates. It not only organically coordinates the development environments of developers and users, but also enables flexible distribution of computing power based on the code segmentation structure corresponding to the primitives, thereby improving the working efficiency of user devices. Attached Figure Description

[0050] Figure 1 This is a structural block diagram of the present invention;

[0051] Figure 2 This is a structural block diagram of EAC. Detailed Implementation

[0052] The present invention will be further described below with reference to the embodiments and accompanying drawings.

[0053] The basic primitive library, basic environment library, and user coding environment within the editing platform are bidirectionally connected:

[0054] The user coding environment is used to build the software development environment required by the user.

[0055] The basic environment library stores various versions of underlying systems, such as Windows, development tools such as mechanical 2D tools, circuit diagram development tools, office tools, and mobile apps.

[0056] User primitive library: Used to store primitives required by users for developing software;

[0057] Graphical primitives are the smallest abstract units in a graphical programming language. They are represented as Kanban controls, functions, resources, lines, and structural diagrams, displayed as physical graphics in the development platform, and consist of a name, ID, icon, code, and help documentation. Examples include switch controls, pressure regulation controls, integral function controls, pi controls, various PID controls, known data controls representing input resources such as text input controls, waveform controls, numerical controls, table controls, instrument and dashboard controls, borders, lines, arrows, structural diagrams, and other result data controls.

[0058] User workbench assembly: Used to call up primitives and generate primitive assemblies according to software development logic. These primitive assemblies are mapped to underlying logic programs.

[0059] The user's coding environment is consistent with the user's software environment;

[0060] The user primitive library is connected to the basic primitive library. The user primitive library includes a control style library, a basic control library, a resource library, a basic function library, and a data dictionary.

[0061] A data dictionary is a collection of information describing data; it's a set of definitions for all data elements used in the system. It provides the basic data needed for operations in the resource workbench, function logic workbench, and Kanban workbench.

[0062] These basic data also exist in the form of graphic elements, such as pi controls, metric unit controls, and various ways of expressing atmospheric pressure.

[0063] The basic function library provides the function relationships required for operations on the function logic workbench, such as summation function primitives and square root function primitives.

[0064] The resource library provides data resources for the resource workbench; data resources can be text files, video files, tables, forms, diagrams, etc.

[0065] like Figure 1 As shown, any program segment has input information and output results. Users use primitives to fill in relevant information, calculate intermediate data, and output primitives according to functional requirements, and store them in the coding environment.

[0066] The basic control library provides control elements with various basic functions for the Kanban workbench;

[0067] The control style library provides styles for control elements that are waiting to be assigned functionality to the Kanban workbench;

[0068] The resource workbench generates basic input resource control elements and output result control elements for the function logic workbench;

[0069] The function logic workbench generates a function logic relationship expressed by a combination of primitives, and maps the underlying function logic relationship to the Kanban workbench;

[0070] The Kanban workbench combines functional logic relationships with control elements to generate a Kanban interface expressed by the combination of control elements, and presents the Kanban interface and the underlying logic program to the user terminal or technical backend.

[0071] The technical backend also connects to the compiler, basic primitive library, and basic environment library. It allows for content editing and functional limitations of the compiler, basic primitive library, and basic environment library.

[0072] The editing platform is equipped with a technical interface, and the technical backend is connected to various units within the editing platform via the technical interface.

[0073] A computing power elastic development system based on a graphical programming cloud platform. Within a unified graphical software development environment, it not only organically coordinates the development environments of developers and users but also enables elastic distribution of computing power, improving equipment efficiency. Its technical solution is as follows:

[0074] It includes an editing platform, and a user terminal 2 and a technical backend 3 connected to the editing platform 1 via a network. The user terminal 2 is an EAC, which includes a core processor and at least one lower-level functional module. The core processor is connected to the editing platform 1 and is connected to all lower-level functional modules.

[0075] The lower-level functional modules are either connected to sensing elements or to execution elements;

[0076] The editing platform 1 is equipped with a basic environment library 12 and a user coding environment. The basic environment library 12 obtains the hardware and software environment of the edge automatic controller and converts it into environment primitives and sends it to the user coding environment. The user coding environment is equipped with a function logic workbench 7.

[0077] The function logic workbench 7 is used to support system operation and computation development in the form of primitive logic combination;

[0078] The function logic workbench 7 is also used to: combine primitive logic and flexibly distribute computing power to the core processor and each lower-level functional module.

[0079] like Figure 2 As shown, the edge automatic controller is based on primitive-based WebReal and is flexibly distributed on the core processor and lower-level functional modules. The core processor may be a Windows PC, a Linux PC, a microcontroller, an IP core, or a GPU.

[0080] The lower-level functional modules may be MCUs, Linux system PCs, IP cores, GPUs, or FPGAs.

[0081] The core processor connects to lower-level functional modules via USB, Ethernet, serial port, or PCIe data interface;

[0082] The core processor is also connected to a monitor, mouse, buttons, wireless network card, and memory.

[0083] There are two compilation methods here:

[0084] Method 1: A Kanban workbench 6 is set up in the user coding environment. The function logic workbench 7 generates a function logic relationship expressed by the combination of primitive logic and maps the underlying function logic relationship to the Kanban workbench 6. The user coding environment directly sends the primitive logic combination and function logic relationship to the core processor. The core processor realizes human-computer interaction through the display and mouse. At this time, the user can see the structure of the primitive madman, which is convenient for debugging and maintenance on the user end.

[0085] The core processor is equipped with an edge compiler, which compiles the functional logic into machine language, and coordinates with the communication protocol of each lower-level functional module.

[0086] Method Two: A Kanban workbench 6 is set up within the user coding environment. The function logic workbench 7 generates functional logic relationships expressed by primitive logic combinations and maps the underlying functional logic relationships to the Kanban workbench 6. The Kanban workbench 6 is connected to a compiler 8, which compiles the functional logic relationships into machine language, cooperating with the communication protocols of the core processor and each lower-level functional module. This eliminates the need for a monitor and mouse, reducing costs.

[0087] The function logic workbench 7 is equipped with work frames corresponding to the core processor and each lower-level functional module, so that each work frame corresponds to a physical unit. The corresponding primitive logic sub-combination and related operation functions in each work frame are matched with the computing power of the physical unit.

[0088] The editing platform 1 is equipped with a developer interface and a technical interface. The developer interface is connected to a developer terminal, which is connected to the technical interface via the developer interface. The developer terminal then edits the virtual edge automatic controller in the basic environment library 12 via the technical interface.

[0089] The collaborative development method of this computing power elastic development system, and its specific steps are as follows:

[0090] Step 1: Based on user needs or user resources, the developer determines the hardware and software environment of the user edge automatic controller in the basic environment library 12 and builds the user coding environment. The user coding environment is equipped with user primitive library 4, resource work platform 5, function logic workbench 7 and Kanban workbench 6.

[0091] Developers log in to the editing platform via the network, set up a user coding environment within the platform, and build a user primitive library on the platform according to their own functional requirements. This includes the content filling and building of the control style library, basic control library, resource library, basic function library, and data dictionary.

[0092] Step 2: Based on user requirements, match relevant graphic elements in the user coding environment to the user graphic element library and send them to the resource workbench 5;

[0093] Developers use the user primitive library to generate input controls, output display controls, and debug controls;

[0094] Extract existing data resources and their control elements from the resource repository to the resource workbench;

[0095] Alternatively, in the resource workbench, the data dictionary can be adapted to the available data resources in the resource library to generate usable data and its control elements;

[0096] Step 3: In the Kanban workbench 6, according to your own functional requirements, use the user element library 4 to generate input controls, output display controls and debugging controls;

[0097] Step 4: Based on your own functional requirements, extract the existing data resources and their control elements from the user element library 4 to the resource workbench 5;

[0098] Alternatively, in the resource workbench 5, the available data resources of the user element library 4 can be adaptively processed to generate usable data and its control elements;

[0099] Step 5: Send the basic functions, mature data resources and their icons into the function logic workbench 7, or use the basic functions to edit the logic function primitives created by the developer in the function logic workbench (7);

[0100] In accordance with the program logic sequence, drag and drop the primitives representing all logical functions, mature data resource primitives, input resource control primitives, and output result display control primitives into the same running flowchart to generate the logic program;

[0101] Alternatively, you can use the basic functions and their icons from the basic function library to submit them to the function logic workbench.

[0102] Alternatively, users can utilize basic functions, mature data resources, and data dictionaries to create their own logic function primitives.

[0103] Step 6: According to the program logic sequence, drag the primitives representing all logical functions, mature data resource primitives, input resource control primitives, and output result display control primitives into the same running flowchart primitive to generate the logical program, and map the logical program to the Kanban workbench.

[0104] According to the program logic, connect the various graphical elements in the function logic workbench, and map the program logic to the Kanban workbench, and:

[0105] Edit the function logic of each physical unit in Function Logic Workbench 7:

[0106] Within the function logic workbench 7, work frames corresponding to the core processor and each lower-level functional module are also set up, realizing a one-to-one correspondence between work frames and physical units. The corresponding primitive logic sub-combinations and related operation functions within each work frame are matched with the computing power of that physical unit.

[0107] And map this logic program to the Kanban workbench 6;

[0108] Step 7: Adjust the input value of the input resource control element. The logic program calculates the output result data based on the input value, and the output result data is mapped to the display control for display.

[0109] Furthermore, in step 1, the developer determines the hardware and software environment of the basic environment library 12 by scanning the edge automatic controller of the user terminal 2.

[0110] Developers can use the technical interface to virtualize the hardware and software environment required for user coding in the basic environment library 12, according to user needs.

[0111] Furthermore, the Kanban workbench 6 may send the completed logic program to the compiler 8, which will compile the corresponding logic program according to the user's requirements and store it in the memory 9 for the user to retrieve.

[0112] Alternatively, the Kanban workbench 6 can directly send the completed logic program to the user edge automatic controller.

[0113] Furthermore, the Kanban workbench 6 may send image data to the core processor and each lower-level functional module for simulated program debugging;

[0114] Alternatively, once the simulation program is successfully debugged, the compiler 8 sends the compiled executable program to the core processor, which then compiles it into machine language adapted to each lower-level functional module in the WebReal environment.

[0115] The components of the user graph library include:

[0116] The control style library is constructed by extracting various icon control style options from the basic graphic element library;

[0117] The basic control library is constructed by extracting various basic controls from the basic primitive library for later use.

[0118] The resource library is populated by users who, based on their own resource needs, fill in the data information of known resources, unknown resources, and intermediate resources into the resource library and assign them independent display icons and known, unknown, and intermediate attributes respectively.

[0119] The basic function library extracts various operational function relationships and their operational primitives from the basic primitive library for later use.

[0120] The data dictionary extracts necessary, frequently used elements from the basic element library for later use. These include numerical values, roles, units, positions, and payment methods.

[0121] It should be noted that the above description is not intended to limit the present invention, and the present invention is not limited to the examples given above. Any changes, modifications, additions or substitutions made by those skilled in the art within the scope of the present invention should also fall within the protection scope of the present invention.

Claims

1. A computational power elastic development system based on a graphical programming cloud platform, comprising an editing platform, and a user terminal (2) and a technical backend (3) connected to the editing platform (1) via a network, characterized in that: The user terminal (2) is an edge automatic controller, which includes a core processor and at least one lower-level functional module. The core processor is connected to the editing platform (1) and is connected to all lower-level functional modules. The lower-level functional modules are either connected to sensing elements or to execution elements; The editing platform (1) is equipped with a basic environment library (12) and a user coding environment. The basic environment library (12) obtains the hardware and software environment of the edge automatic controller and converts it into environment primitives and sends it to the user coding environment. The user coding environment is equipped with a function logic workbench (7). The function logic workbench (7) is used to: support system operation and computation development in the form of primitive logic combination; The function logic workbench (7) is also used to: combine primitive logic and distribute computing power flexibly to the core processor and each lower-level functional module; The edge automatic controller is based on the primitive-based WebReal and is flexibly distributed on the core processor and lower-level functional modules. The core processor may be a Windows PC, a Linux PC, a microcontroller, an IP core, or a GPU. The lower-level functional modules may be MCUs, Linux system PCs, IP cores, GPUs, or FPGAs; The core processor is connected to the lower-level functional modules via USB, Ethernet, serial port or PCIe data interface; The core processor is also connected to a monitor, mouse, buttons, wireless network card, and memory. The user coding environment is equipped with a Kanban workbench (6), the function logic workbench (7) generates a function logic relationship expressed by a combination of primitive logic, and maps the underlying function logic relationship to the Kanban workbench (6). The user coding environment directly sends the primitive logic combination and function logic relationship to the core processor, and the core processor realizes human-computer interaction through the display and mouse. The core processor is equipped with an edge compiler, which compiles the functional logic into machine language, and cooperates with the communication protocol of each lower-level functional module. The user coding environment is equipped with a Kanban workbench (6), and the function logic workbench (7) generates a function logic relationship composed of primitive logic combinations and maps the underlying function logic relationship to the Kanban workbench (6). The Kanban workbench (6) is connected to a compiler (8), which compiles the function logic relationship into machine language and cooperates with the communication protocols of the core processor and each lower-level functional module respectively. The function logic workbench (7) is equipped with work boxes corresponding to the core processor and each lower-level functional module, so that the work boxes correspond one-to-one with the physical units. The corresponding graphic logic sub-combinations and related operation functions in each work box are matched with the computing power of the physical unit. Each lower-level functional module stores graphic elements corresponding to its function.

2. The computing power elastic development system based on a graphical programming cloud platform according to claim 1, characterized in that: The editing platform (1) is equipped with a developer interface and a technical interface. The developer interface is connected to a developer terminal, which is connected to the technical interface via the developer interface. The developer terminal then edits the virtual edge automatic controller in the basic environment library (12) via the technical interface.

3. A collaborative development method for the computing power elastic development system as described in claims 1-2, characterized in that, include: Step 1: Based on user needs or user resources, the developer determines the hardware and software environment of the user edge automatic controller in the basic environment library (12) and builds the user coding environment. The user coding environment is equipped with a user primitive library (4), a resource work platform (5), a function logic workbench (7), and a Kanban workbench (6). Step 2: Based on user needs, match relevant graphic elements in the user coding environment to the user graphic element library and send them to the resource workbench (5). Step 3: In the Kanban workbench (6), according to its own functional requirements, use the user graphic library (4) to generate input controls, output display controls and debugging controls; Step 4: Based on its own functional requirements, extract the existing data resources and their control elements from the user graphic element library (4) to the resource workbench (5); Alternatively, in the resource workbench (5), the available data resources of the user graphic element library (4) can be adaptively processed to generate available data and its control graphic elements; Step 5: Send the basic functions, mature data resources and their icons into the function logic workbench (7), or use the basic functions to edit the logic function primitives created by the developer in the function logic workbench (7); In accordance with the program logic sequence, drag and drop the primitives representing all logical functions, mature data resource primitives, input resource control primitives, and output result display control primitives into the same running flowchart to generate the logic program; Step 6: Edit the function logic of each physical unit in the function logic workbench (7): Within the function logic workbench (7), work boxes corresponding to the core processor and each lower-level functional module are also set up to achieve a one-to-one correspondence between work boxes and physical units. The corresponding primitive logic sub-combinations and related operation functions within each work box are matched with the computing power of the physical unit. And map the logic program to the Kanban workbench (6); Step 7: Adjust the input value of the input resource control element. The logic program calculates the output result data based on the input value, and the output result data is mapped to the display control for display.

4. The collaborative development method of the computing power elastic development system according to claim 3, characterized in that: In step 1, the developer or the edge automatic controller of the user terminal (2) determines the hardware and software environment of the basic environment library (12); Developers can use technical interfaces to virtualize the hardware and software environment required for user coding environment in the basic environment library (12) according to user needs.

5. The collaborative development method of the computing power elastic development system according to claim 3, characterized in that: Alternatively, the Kanban workbench (6) sends the completed logic program to the compiler (8), and the compiler (8) compiles the corresponding logic program according to the user's requirements and stores it in the memory (9) until the user retrieves it; Alternatively, the Kanban workbench (6) can directly send the completed logic program to the user edge automatic controller.

6. The collaborative development method of the computing power elastic development system according to claim 3, characterized in that: Alternatively, the Kanban workbench (6) can send image data to the core processor and each lower-level functional module for simulated program debugging. Alternatively, after the simulation program is successfully debugged, the compiler (8) sends the compiled executable program to the core processor, and the core processor then compiles it into machine language that is compatible with each lower-level functional module in the WebReal environment.

7. The collaborative development method of the computing power elastic development system according to claim 6, characterized in that: During system operation: The clock cycles of the core processor and all subordinate functional modules are set and calculated independently.

8. The collaborative development method of the computing power elastic development system according to claim 6, characterized in that: During system operation: Choose the core processor or any lower-level functional module to uniformly determine the operating clock cycle of each unit.

Images