Embedded graphical programming development method and device based on Internet of Things and medium

Abstract

The invention discloses an embedded graphical programming development method and device based on the Internet of Things and a medium, and the method comprises the steps: creating a graphical programming system application containing a Blockly framework, adding a dependency library on the graphical programming system application, and carrying out the page layout and initialization configuration; the method comprises the following steps of: constructing graphic block components with different functions on the application of the graphic programming system, and determining required graphic blocks: a Modbus RTU (Remote Terminal Unit) graphic block component, a serial port-Rs485 graphic block component, a NetManage graphic block component, a Home Assistance graphic block component, a ThingsBoard graphic block component and an input / output control graphic block component; freely combining the determined required graphic blocks to build a business scene, and completing program development through graphic programming; and downloading the program subjected to graphical programming to equipment for running. The development efficiency of the system is improved, and the development difficulty is reduced.

Description

Technical Field

[0001] The present invention relates to the field of Internet of Things and embedded system development, and in particular to an Internet of Things-based embedded graphical programming development method, equipment and medium. Background Art

[0002] With the rapid development of microcontroller technology, small and low-power microcontrollers such as ARM Cortex-M / A series, STM32, ESP8266, Raspberry Pi, etc. are becoming more and more popular. These microcontrollers provide powerful computing power and communication interfaces for various devices that require embedded control.

[0003] The rapid development of the Internet of Things has put forward higher requirements for small embedded devices, requiring them to have stronger communication, processing and programming capabilities. Traditional assembly language and C language programming are relatively limited in function and development efficiency, and a more advanced and easier to learn programming language is urgently needed.

[0004] Python has become one of the most popular programming languages ​​due to its easy-to-learn and powerful features. Porting Python to small microcontrollers can provide a new programming method for IoT development.

[0005] The traditional embedded system programming model, based on C language firmware development, has relatively high requirements for developers and requires in-depth hardware knowledge. The existing embedded programming model has the following problems:

[0006] 1. Low development efficiency and high learning difficulty: Embedded system development often requires writing a large amount of underlying code and driver-related peripheral interfaces, with a long development cycle and complex debugging;

[0007] 2. Embedded systems have different hardware interfaces and drivers. Traditional development requires writing specific code for each interface, which makes it difficult to achieve modular design and reuse.

[0008] 3. With the development of embedded technology, new hardware platforms and new technologies continue to emerge. Traditional development tools are independently developed by each chip manufacturer. If multiple chips are used, it is necessary to download the development environment of the supporting manufacturer. There are many tools and it is difficult to quickly support new technologies. Summary of the invention

[0009] In view of this, the purpose of the present invention is to propose an embedded graphical programming development method based on the Internet of Things. Through graphical programming, the entry threshold of programming is lowered, so that students can more easily understand programming logic and concepts, and the Internet of Things projects can be quickly implemented, which significantly improves the development efficiency of embedded systems, reduces the development difficulty, and enhances the maintainability and reliability of the system, providing embedded developers with more powerful and flexible tools.

[0010] In order to achieve the above technical objectives, the technical solution adopted by the present invention is:

[0011] The present invention provides a method for developing embedded graphical programming based on the Internet of Things, comprising the following steps:

[0012] Step 1: Create a graphical programming system application that includes the Blockly framework, add dependent libraries to the graphical programming system application, and perform page layout and initialization configuration;

[0013] Step 2: construct graphic block components with different functions on the graphical programming system application, and determine the required graphic blocks:

[0014] S1. Construct the graphic block component of ModbusRTU function, perform the demand analysis of task-type graphic blocks according to the working business process of ModbusRTU industrial protocol, and determine the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0015] S2, constructing a graphic block component of the serial port-RS485 function, performing a demand analysis of task-type graphic blocks according to the workflow of the serial port-RS485 communication, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0016] S3. Construct the graphic block component of the NetManage function, perform demand analysis of task-type graphic blocks according to the communication mode of the device network port, and determine the required graphic blocks. The required graphic blocks include task-type graphic blocks and statement-type graphic blocks.

[0017] S4, constructing the graphic block component of the Home Assistant function, performing a demand analysis of task-type graphic blocks according to the communication API of the Home Assistant platform, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0018] S5. Build the graphic block component of ThingsBoard functions, analyze the demand for task-type graphic blocks according to the communication API of ThingsBoard platform, and determine the required graphic blocks. The required graphic blocks include task-type graphic blocks and statement-type graphic blocks.

[0019] S6. Constructing a graphic block component of an input / output control function, performing a demand analysis of task-type graphic blocks according to the GPIO input / output control process, and determining required graphic blocks, wherein the required graphic blocks include task-type graphic blocks and statement-type graphic blocks;

[0020] Step 3: Combine specific business needs and freely combine the required graphic blocks determined in S1 to S6 to build business scenarios, and complete program development through graphical programming;

[0021] Step 4: Download the graphically programmed program to the device for running.

[0022] Furthermore, the step 1 specifically includes:

[0023] Step 11: Create a graphical programming system application, add the Blockly framework and related dependent libraries to the graphical programming system application, and use the NPM run command to install the Blockly framework and related dependent libraries;

[0024] Step 12: Configure the Blockly framework:

[0025] Basic configuration of Blockly framework: introduce Blockly framework and import JavaScript file of Blockly framework in HTML file of the project;

[0026] Add a basic workspace: Define a div element in the HTML file to place the Blockly workspace and initialize the configuration, including grid size, scroll bar, and toolbox position;

[0027] Set up the toolbox: Design and add a toolbox, including basic blocks supported by the Blockly framework;

[0028] Add real-time preview: set the preview window to display the real-time effect of generated code;

[0029] Step 13. Compile and build the project through pnpm build. If there is no error, start the front-end web application through the web server. After starting, access the URL through the browser to verify whether the development environment of the Blockly framework is successfully imported locally. After successful verification, proceed to step 14.

[0030] Step 14. Add the core script file blockly_compressed.js of the Blockly framework to the application code for loading;

[0031] Step 15. Inject a resizable workspace: Place the blocklyDiv element over the blocklyArea element and remove any height and width styles from the blocklyDiv element and add absolute positioning;

[0032] Step 16. Replace the injection script with the script that places blocklyDiv on blocklyArea. The code generator generates code and imports the Blockly framework / JavaScript file.

[0033] Step 17: After introducing the Blockly framework, introduce the code generation including the file description of python_compressed.js; this completes the initialization configuration of the graphical programming system application.

[0034] Furthermore, the step S1 specifically includes:

[0035] Step S11, constructing the ModbusRTU_Tools graphic block class;

[0036] Step S12, adding function graphic blocks of the ModbusRTU protocol to the ModbusRTU_Tools graphic block class, including: function code 01 graphic block read_coils, function code 02 graphic block read_discrete_inputs, function code 03 graphic block read_holding_registers, function code 04 graphic block read_input_registers, function code 05 graphic block write_single_coil, function code 06 graphic block write_single_registers and function code 16 graphic block write_multi_registers;

[0037] The function code 01 graphic block read_coils: sends slave_address, start address and data length to the bound serial port, and then reads the output status of one or more switching coils;

[0038] The function code 02 graphic block read_discrete_inputs: sends slave_address, start address and data length to the bound serial port, and then reads the status of one or more switch inputs;

[0039] The function code 03 graphic block read_holding_registers: sends slave_address, start address and data length to the bound serial port, and then reads the data of multiple holding registers;

[0040] The function code 04 graphic block read_input_registers: sends slave_address, start address and data length to the bound serial port, and then reads the data of multiple input registers;

[0041] The function code 05 graphic block write_single_coil: sends slave_address, start address and written data to the bound serial port to turn on or off, and writes the switch output;

[0042] The function code 06 graphic block write_single_registers: sends slave_address, start address and written data to the bound serial port, and writes a single-channel register;

[0043] The function code 16 graphic block write_multi_registers: sends slave_address, start address and write multi-channel data to the bound serial port, and writes multi-channel register operations;

[0044] Step S13, initialize the ModbusRTU_Tools graphic block class, initialize the serial port bound to the ModbusRTU protocol, perform relevant function code operations according to the function codes supported by the nodes of the ModbusRTU protocol, and obtain corresponding protocol data according to whether the CRC check is successful or not;

[0045] Step S14: The programmer configures parameters by dragging a specific small task module and communicates with the node of the ModbusRTU protocol;

[0046] Step S15: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0047] Furthermore, the step S2 specifically includes:

[0048] Step S21, constructing a serial port-RS485 graphic block class to provide a serial port communication function;

[0049] Step S22, adding uartInit graphic block, uart_control_485_pin graphic block, uart_set_callback graphic block, uartWrite graphic block, uartRead graphic block and uart_callback_fun graphic block to the serial port-Rs485 graphic block class;

[0050] The uartInit graphic block is used for serial port initialization, and the serial port baud rate, data bit, parity check and stop bit, and hardware control flow are set through the uartInit graphic block;

[0051] The uart_control_485_pin graphic block is used to set the RS-485 transceiver pin control;

[0052] The uart_set_callback graphic block is used to set the serial port callback function;

[0053] The uartWrite graphics block is used to control serial port data transmission;

[0054] The uartRead graphic block is used to control serial port data reception;

[0055] The uart_callback_fun graphic block is used to execute the serial port receiving callback function;

[0056] Step S23: The programmer configures parameters by dragging a specific small task module to complete serial port data transmission and reception;

[0057] Step S24: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0058] Furthermore, the step S3 specifically includes:

[0059] Step S31, constructing a NetManage_Tools graphic block class for managing different communication methods, including connecting to the network via a wired method and connecting to the network via a wireless SIM card 4G communication method;

[0060] Step S32, adding eth_set_DHCP_mode graphic block, eth_set_Static_mode graphic block, sim_status graphic block, wait_connect graphic block and reconnect graphic block to the NetManage_Tools graphic block class;

[0061] The eth_set_DHCP_mode graphic block is used to set the device to use a dynamic IP, obtain an IP from a router, and access the network through the router;

[0062] The eth_set_Static_mode graphic block is used to set the device to use a static IP and access the network through a router;

[0063] The sim_status graphic block is used to read the SIM card status;

[0064] The wait_connect graphic block is used for 4G dial-up Internet access and waits for the network connection to be completed;

[0065] The reconnect graphic block is used to reconnect to the network when a SIM card is inserted and dialing fails;

[0066] Step S33: The programmer configures parameters by dragging a specific small task module and connects it to the network;

[0067] Step S34: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0068] Further, the step S4:

[0069] Step S41, constructing a Home Assistant graphic block class to support MQTT communication;

[0070] Step S42, adding init graphic block, set_callback graphic block, publish graphic block, subscribe graphic block, wait_msg graphic block, add_actuator_to_HA graphic block, add_sensor_to_HA graphic block and add_binary_to_HA graphic block to the Home Assistant graphic block class;

[0071] The init graphic block is used to initialize and create a connection between the MQTT client and the server;

[0072] The set_callback graphic block is used to set the callback;

[0073] The publish graphic block is used to publish messages to the corresponding topic;

[0074] The subscribe graphic block is used to subscribe to the MQTT topic;

[0075] The wait_msg graphic block is used to block and wait for the server message response to obtain the MQTT connection status;

[0076] The add_actuator_to_HA graphical block is used to add an actuator entity to the Home Assistant platform;

[0077] The add_sensor_to_HA graphic block is used to add a sensor entity to the Home Assistant platform;

[0078] The add_binary_to_HA block is used to add a binary sensor entity to the Home Assistant platform.

[0079] Step S43: The programmer configures parameters by dragging a specific small task module and connects it to the HomeAssistant platform;

[0080] Step S44: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0081] Furthermore, the step S5 specifically includes:

[0082] Step S51, construct ThingsBoard graphic block class to support Mqtt communication for MQ telemetry transmission;

[0083] Step S52: adding the init graphic block, the set_callback graphic block, the shed_telemetry graphic block and the send_rpc_reply graphic block to the ThingsBoard graphic block class;

[0084] The init graphic block is used to initialize and create a connection between the MQTT client and the server;

[0085] The set_callback graphic block is used to set the callback;

[0086] The shed_telemetry block is used to publish telemetry data to ThingsBoard platform;

[0087] The send_rpc_reply graphic block is used to reply to the RPC command request sent by the server;

[0088] Step S53: The programmer configures parameters by dragging a specific small task module and connects it to the ThingsBoard platform;

[0089] Step S54: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0090] Furthermore, the step S6 specifically includes:

[0091] Step S61, constructing a GPIO input and output control graphic block class;

[0092] Step S62, adding a machine.Pin graphic block, a set_dir graphic block and a get_dir graphic block to the GPIO input and output control graphic block class;

[0093] The machine.Pin graphic block is used to initialize the GPIO pins and set whether to pull up or down and the default level;

[0094] The set_dir graphic block is used to set the input and output modes of the pin of the machine.Pin initialization completion pin;

[0095] The get_dir graphic block is used to obtain the current input and output mode of the pin, and then the gpio.read graphic block or the gpio.write graphic block can be called to read or set the gpio output high and low levels;

[0096] Step S63: The programmer configures parameters by dragging a specific small task module and controls GPIO;

[0097] Step S64: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0098] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, an embedded graphical programming development method based on the Internet of Things as described above is implemented.

[0099] The present invention also provides a computer-readable storage medium on which a computer program is stored. When the program is executed by a processor, the above-mentioned method for developing embedded graphical programming based on the Internet of Things is implemented.

[0100] By adopting the above technical solution, the present invention has the following beneficial effects compared with the prior art:

[0101] 1. Improved development efficiency and greatly reduced learning difficulty: A large number of code graphic blocks are encapsulated in the graphical programming system application. Each graphic block encapsulates the relevant functional interface at the bottom, which reduces the need for developers to write low-level code, reduces the learning curve and technical threshold, and helps beginners build programming thinking and confidence; developers do not need to master the syntax of programming languages ​​in depth, and can design logical processes in an intuitive way. Through the graphical programming drag-and-drop method, they can quickly complete the combination of functional modules, which is particularly friendly to beginners or non-technical personnel, and can quickly get started and greatly improve the efficiency of code development cycle and debugging. Enhanced system visualization and reduced code errors can effectively improve the work efficiency of developers, especially for rapid iteration and prototype development of complex systems.

[0102] 2. Bottom-level hardware abstraction and modular design: The graphical programming system application provides an abstract layer for the hardware platform and encapsulates it into different graphical blocks based on the Micropython language, allowing developers to perform modular development under a unified interface. In this way, it is easier to reuse code modules on different platforms and support rapid replacement and expansion of hardware.

[0103] 3. Scalability and future technology support: The graphical programming system application is designed with good scalability and can quickly support new hardware platforms and technologies through plug-ins or custom modules. This provides developers with the ability to cope with future technological changes and extend the service life of the platform. BRIEF DESCRIPTION OF THE DRAWINGS

[0104] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0105] Figure 1 It is an execution flow chart of an Internet of Things embedded graphical programming development method provided by an embodiment of the present invention.

[0106] Figure 2 The present invention provides a process diagram of ModbusRTU graphical programming.

[0107] Figure 3 It is a schematic diagram of an electronic device provided by an embodiment of the present invention.

[0108] Figure 4 It is a schematic diagram of a computer-readable storage medium provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0109] The present invention will be further described in detail below in conjunction with the accompanying drawings and examples. It is particularly noted that the following examples are only used to illustrate the present invention, but are not intended to limit the scope of the present invention. Similarly, the following examples are only partial embodiments of the present invention rather than all embodiments, and all other embodiments obtained by those of ordinary skill in the art without creative work are within the scope of protection of the present invention.

[0110] See also Figure 1 , a method for developing embedded graphical programming based on the Internet of Things of the present invention comprises the following steps:

[0111] Step 1: Create a graphical programming system application that includes the Blockly framework, add dependent libraries to the graphical programming system application, and perform page layout and initialization configuration;

[0112] The graphical programming system application supports graphical and drag-and-drop module programming to implement Modbus_RTU protocol device communication, serial port-RS485 communication, NetManage network management, Home Assiatant smart home platform communication, ThingBoard platform communication and input / output GPIO control; developers can use pre-generated graphical templates, components and other tools to create software applications, significantly reducing the amount of manually written code and the complexity of the code;

[0113] A graphical programming system application using the Blockly framework, which is a visual programming framework developed by Google that allows developers to add a block-based code editor to web and mobile applications. This editor uses puzzle-like graphic blocks to represent programming concepts such as variables, logical expressions, loops, etc., allowing users to program directly according to programming principles without paying attention to syntax details.

[0114] In this embodiment, the step 1 specifically includes:

[0115] Step 11, create a graphical programming system application, add the Blockly framework and related dependent libraries in the graphical programming system application, and use NPM (Node Package Manager, which is the official package management tool of Node.js and is used to install, publish, and manage JavaScript packages and dependencies) to run the command (npminstall--save blockly, which is used to install the Blockly framework in the Node.js project and add it to the project's dependency list) to install the Blockly framework and related dependent libraries;

[0116] Step 12: Configure the Blockly framework:

[0117] Basic configuration of Blockly framework: introduce Blockly framework, import JavaScript file (a file containing JavaScript code) of Blockly framework in the HTML file (HyperTextMarkup Language, a standard markup language for creating web pages, which tells the browser how to display web page content by using a series of tags) of the project;

[0118] Add a basic workspace: Define a div element in the HTML file (a very common block-level element in HTML, which is used as a container to wrap other HTML elements) to place the Blockly workspace and initialize the configuration, including grid size, scroll bar and toolbox position;

[0119] Set up Toolbox: Design and add toolboxes (drag areas), including basic blocks supported by the Blockly framework (such as logic, loops, mathematics, etc.);

[0120] Add real-time preview: set the preview window to display the real-time effect of generated code;

[0121] Step 13. Compile and build the project through pnpm build (pnpm build is a command usually used in Node.js projects to build or compile project code). If there is no error, start the front-end web application through the web server. After starting, visit the URL (http: / / localhost:30080) through the browser to verify whether the development environment of the Blockly framework is successfully imported locally. After successful verification, proceed to step 14.

[0122] Step 14. Add the core script file blockly_compressed.js of the Blockly framework (which is the core compressed file of the Blockly framework, which contains the main functions of the Blockly framework and is compressed to reduce the file size and speed up the loading speed) to the application code for loading;

[0123] Step 15: Inject a resizable workspace: Insert the blocklyDiv element (an HTML element used to host the Blockly workspace in a web page) Element. It is one of the core components of Blockly and is responsible for displaying the visual programming interface) placed in the blocklyArea element (used to represent the HTML containing the Blockly editor area The ID of the element. This element is usually used to define the display area of ​​the Blockly workspace on the page) and remove any height and width styles from the blocklyDiv element and add absolute positioning;

[0124] Step 16. Replace the injection script with the script that places blocklyDiv on blocklyArea. The code generator generates code and imports the Blockly framework / JavaScript file.

[0125] Step 17, after introducing the Blockly framework, introduce the code generation including the file description of python_compressed.js (a compressed file used to generate Python code); this completes the initialization configuration of the graphical programming system application.

[0126] The graphical programming system application uses a unified graphical module to realize the code development generation and deployment platform in the form of graph dragging; adding a visual code editor to the library of the web application. Using the Blockly open source framework, the editor uses interlocking graphical blocks to represent code concepts such as variables, logical expressions, loops, etc.

[0127] Step 2: construct graphic block components with different functions on the graphical programming system application, and determine the required graphic blocks:

[0128] S1. Constructing a graphic block component of ModbusRTU (a serial communication protocol widely used in the field of industrial automation) function, performing a demand analysis of task-type graphic blocks according to the working business process of the ModbusRTU industrial protocol, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0129] ModbusRTU_Tools graphic block class: This graphic block class is an industrial protocol based on serial communication, which is widely used in industrial automation and control systems. It adopts a master-slave architecture, and a master device (such as a PLC or computer) can exchange data with multiple slave devices (such as sensors and actuators). Modbus RTU uses compact and efficient data frames, and data is transmitted over serial lines, supporting up to 247 slave devices. Communication is initiated by the master device, and the slave device identifies the request and responds through a unique address. The communication rate is high, and CRC check is usually used to ensure data integrity. Modbus RTU is particularly suitable for situations where real-time data transmission is required in low-bandwidth and long-distance environments, such as monitoring and controlling the operating status of equipment, sensor data acquisition, and remote operation. It is widely used in industrial automation, building management, energy monitoring and other fields.

[0130] In this embodiment, if Figure 2 As shown, the step S1 specifically includes:

[0131] Step S11, constructing ModbusRTU_Tools (tools) graphic block class;

[0132] Step S12, adding the function function graphic blocks of the ModbusRTU protocol to the ModbusRTU_Tools graphic block class, including: function code 01 graphic block read_coils (reading coils), function code 02 graphic block read_discrete_inputs (reading discrete inputs), function code 03 graphic block read_holding_registers (reading holding registers), function code 04 graphic block read_input_registers (reading input registers), function code 05 graphic block write_single_coil (writing a single coil), function code 06 graphic block write_single_registers (writing a single register) and function code 16 block write_multi_registers (writing multiple registers); these function codes are very important in the Modbus RTU protocol and can realize the status reading and control of the device.

[0133] The function code 01 graphic block read_coils: sends slave_address (slave address, used to identify each slave device on the network), start address and data length to the bound serial port, and then reads the output status of one or more switching coils;

[0134] The function code 02 graphic block read_discrete_inputs: sends slave_address, start address and data length to the bound serial port, and then reads the status of one or more switch inputs;

[0135] The function code 03 graphic block read_holding_registers: sends slave_address, starting address and data length to the bound serial port, and then reads the data of multiple holding registers (registers are readable and writable, and function codes 06 or 10 are used to modify register data);

[0136] The function code 04 graphic block read_input_registers: sends slave_address, start address and data length to the bound serial port, and then reads the data of multiple input registers (registers can only be read but not written);

[0137] The function code 05 graphic block write_single_coil: sends slave_address, start address and written data to the bound serial port to turn on or off, and writes the switch output;

[0138] The function code 06 graphic block write_single_registers: sends slave_address, start address and written data to the bound serial port, and writes a single-channel register;

[0139] The function code 16 graphic block write_multi_registers: sends slave_address, start address and write multi-channel data to the bound serial port, and writes multi-channel register operations;

[0140] Step S13, initialize the ModbusRTU_Tools graphic block class, initialize the serial port bound to the ModbusRTU protocol, perform relevant function code operations according to the function codes supported by the nodes of the ModbusRTU protocol, and obtain corresponding protocol data according to whether the CRC check is successful or not;

[0141] Step S14: The programmer configures parameters by dragging a specific small task module and communicates with the node of the ModbusRTU protocol;

[0142] Step S15: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0143] S2, constructing a graphic block component of the serial port-RS485 function, performing a demand analysis of task-type graphic blocks according to the workflow of the serial port-RS485 communication, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0144] Serial port - Rs485 graphic block class: This graphic block class provides UART serial port data transmission function, including initializing RS485 serial port to set baud rate, data bit [5-8], parity (0-NONE, 1-EVEN, 2-ODD), stop bit [1-2] hardware control flow, setting data sending and receiving control pins, obtaining the size of unread data in the receiving buffer, setting serial port data callback function, and sending serial port data;

[0145] In this embodiment, step S2 specifically includes:

[0146] Step S21, constructing a serial port-RS485 graphic block class to provide a serial port communication function;

[0147] Step S22, adding uartInit (serial port initialization) graphic block, uart_control_485_pin (control serial port-rs485 pin) graphic block, uart_set_callback (set serial port callback) graphic block, uartWrite (serial port data transmission) graphic block, uartRead (serial port data reception) graphic block and uart_callback_fun (serial port reception callback) graphic block to the serial port-rs485 graphic block class;

[0148] The uartInit graphic block is used for serial port initialization, and the serial port baud rate, data bit, parity check and stop bit, and hardware control flow are set through the uartInit graphic block;

[0149] The uart_control_485_pin graphic block is used to set the RS-485 transceiver pin control;

[0150] The uart_set_callback graphic block is used to set the serial port callback function;

[0151] The uartWrite graphics block is used to control serial port data transmission;

[0152] The uartRead graphic block is used to control serial port data reception;

[0153] The uart_callback_fun graphic block is used to execute the serial port receiving callback function;

[0154] Step S23: The programmer configures parameters by dragging a specific small task module to complete serial port data transmission and reception;

[0155] Step S24: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0156] S3. Construct the graphic block component of NetManage (a comprehensive network device management system) function, analyze the demand for task-type graphic blocks according to the communication mode of the device network port, and determine the required graphic blocks. The required graphic blocks include task-type graphic blocks and statement-type graphic blocks.

[0157] NetManage_Tools graphic block class: This graphic block class provides methods for network communication management. It can control the device to access the external network through the wired network port based on dynamic IP or static IP, and can also access the external network using a 4G SIM card.

[0158] In this embodiment, step S3 specifically includes:

[0159] Step S31, constructing a NetManage_Tools graphic block class for managing different communication methods, including connecting to the network via a wired method (including network communication via a network port static IP method and network communication via a network port dynamic IP method) and connecting to the network via a wireless SIM card 4G communication method;

[0160] Step S32, adding eth_set_DHCP_mode (setting Ethernet to DHCP mode) graphic block, eth_set_Static_mode (setting Ethernet to static mode) graphic block, sim_status (SIM card status) graphic block, wait_connect (wait for connection) graphic block and reconnect (reconnect) graphic block to the NetManage_Tools graphic block class;

[0161] The eth_set_DHCP_mode graphic block is used to set the device to use a dynamic IP, obtain an IP from a router, and access the network through the router;

[0162] The eth_set_Static_mode graphic block is used to set the device to use a static IP and access the network through a router;

[0163] The sim_status graphic block is used to read the SIM card status;

[0164] The wait_connect graphic block is used for 4G dial-up Internet access and waits for the network connection to be completed;

[0165] The reconnect graphic block is used to reconnect to the network when a SIM card is inserted and dialing fails;

[0166] Step S33: The programmer configures parameters by dragging a specific small task module and connects it to the network;

[0167] Step S34: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0168] S4. Build a graphic block component for Home Assistant (an open source smart home platform that allows users to connect, automate and control various smart devices) functions, perform a demand analysis of task-type graphic blocks based on the communication API of the Home Assistant platform, and determine the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0169] Connecting HomeAssistant Graphic Block Class: Connecting Home Assistant via MQTT mainly uses the relevant interfaces of the MQTT protocol to realize the communication and control between IoT devices and Home Assistant. The main interfaces called in Home Assistant include: MQTT Subscribe: Home Assistant receives status updates, sensor data and other information from devices by subscribing to specific MQTT topics. MQTT Publish: By publishing specific messages to MQTT topics, Home Assistant can control devices, such as turning devices on and off, adjusting brightness, etc. MQTT Auto Discovery: This interface allows devices to automatically report their functions and status to Home Assistant, simplifying the device configuration process.

[0170] In this embodiment, the step S4:

[0171] Step S41, constructing a Home Assistant graphic block class to support MQTT (also known as MQ telemetry transmission, which is an Internet of Things connection protocol built on TCP / IP to support lightweight publish / subscribe message transmission) communication;

[0172] Step S42, adding init (initialization) graphic block, set_callback (set callback) graphic block, publish (publish) graphic block, subscribe (subscribe) graphic block, wait_msg (wait for message) graphic block, add_actuator_to_HA (add actuator to Home Assistant) graphic block, add_sensor_to_HA (add sensor to Home Assistant) graphic block and add_binary_to_HA (add binary device to Home Assistant) graphic block to the Home Assistant graphic block class;

[0173] The init graphic block is used to initialize and create a connection between the MQTT client and the server;

[0174] The set_callback graphic block is used to set the callback;

[0175] The publish graphic block is used to publish messages to the corresponding topic;

[0176] The subscribe graphic block is used to subscribe to the MQTT topic;

[0177] The wait_msg graphic block is used to block and wait for the server message response to obtain the MQTT connection status;

[0178] The add_actuator_to_HA graphical block is used to add an actuator entity to the Home Assistant platform;

[0179] The add_sensor_to_HA graphic block is used to add a sensor entity to the Home Assistant platform;

[0180] The add_binary_to_HA block is used to add a binary sensor entity to the Home Assistant platform.

[0181] Step S43: The programmer configures parameters by dragging a specific small task module and connects it to the HomeAssistant platform;

[0182] Step S44: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0183] S5. Build the graphic block components of ThingsBoard (an open source Internet of Things (IoT) platform, mainly used for data collection, processing, visualization and device management) functions, perform demand analysis of task-type graphic blocks according to the communication API of the ThingsBoard platform, and determine the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks;

[0184] Connecting ThingsBoard graphic block class: When connecting to ThingBoard via MQTT, the main interface called is used for data transmission and control between the device and the IoT platform. ThingBoard provides the following main MQTT interfaces: Device telemetry: The device sends sensor data or status information to the ThingBoard platform by publishing MQTT messages, and the ThingBoard platform can store and display these data. Device attributes: The device can upload static or dynamic attributes through the MQTT interface, and ThingBoard can also query or set the device's attributes through this interface. RPC (remote procedure call): ThingBoard can call functions or instructions on the device through MQTT, and the device will perform corresponding operations after receiving the message, such as remote switch, mode adjustment, etc. The purpose of these interfaces is to realize real-time data interaction, remote control and status monitoring between the device and ThingBoard.

[0185] In this embodiment, step S5 specifically includes:

[0186] Step S51, construct ThingsBoard graphic block class, support MQTT communication (also known as MQ telemetry transmission, which is an Internet of Things connection protocol built on TCP / IP to support lightweight publish / subscribe message transmission), for MQ telemetry transmission;

[0187] Step S52: adding an init (initialization) graphic block, a set_callback (set callback) graphic block, a shed_telemetry (telemetry data transmission) graphic block, and a send_rpc_reply (send RPC response) graphic block to the ThingsBoard graphic block class;

[0188] The init graphic block is used to initialize and create a connection between the MQTT client and the server;

[0189] The set_callback graphic block is used to set the callback;

[0190] The shed_telemetry block is used to publish telemetry data to ThingsBoard platform;

[0191] The send_rpc_reply graphic block is used to reply to the RPC command request sent by the server;

[0192] Step S53: The programmer configures parameters by dragging a specific small task module and connects it to the ThingsBoard platform;

[0193] Step S54: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0194] S6. Constructing a graphic block component of an input / output control function, performing a demand analysis of task-type graphic blocks according to the GPIO input / output control process, and determining required graphic blocks, wherein the required graphic blocks include task-type graphic blocks and statement-type graphic blocks;

[0195] GPIO input and output control graphic block class: used to initialize GPIO, control the pin direction of PIN, set GPIO input and output mode and set the GPIO pin level;

[0196] In this embodiment, step S6 specifically includes:

[0197] Step S61, constructing a GPIO input and output control graphic block class;

[0198] Step S62, adding a machine.Pin (control pin) graphic block, a set_dir (set pin direction) graphic block and a get_dir (get pin direction) graphic block to the GPIO input and output control graphic block class;

[0199] The machine.Pin graphic block is used to initialize the GPIO pins and set whether to pull up or down and the default level;

[0200] The set_dir graphic block is used to set the input and output modes of the pin of the machine.Pin initialization completion pin;

[0201] The get_dir graphic block is used to obtain the current input and output mode of the pin, and then the gpio.read (read pin level) graphic block or the gpio.write (write pin level) graphic block can be called to read or set the gpio output high and low levels;

[0202] Step S63: The programmer configures parameters by dragging a specific small task module and controls GPIO;

[0203] Step S64: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

[0204] Step 3: Combine specific business needs and freely combine the required graphic blocks determined in S1 to S6 to build business scenarios, complete program development through graphical programming, and significantly reduce the total amount of manually written code and the complexity of the code;

[0205] Take the acquisition of ModbusRTU protocol devices and the use of Modbus Slave software to simulate the devices as an example;

[0206] First, use the Serial Port-Rs485 graphic block component in step S2 to complete the initialization of the serial port, drag in the uartInit graphic block, set the serial port baud rate, data bit, parity, stop bit and hardware control flow through the uartInit graphic block, set the Rs-485 transceiver pin control through the uart_control_485_pin graphic block, set the serial port callback function through the uart_set_callback graphic block, implement serial port data transmission through the uartWrite graphic block, implement serial port data reception through the uartRead graphic block, and execute the serial port reception callback function through the uart_callback_fun graphic block;

[0207] Next, according to the ModbusRTU graphic block component completed in step S1, the development of the modbusRTU protocol is completed by graphical programming, specifically including first using the ModbusRTU_Tools graphic block class, using the function code 01 graphic block read_coils: sending slave_address, starting address and data length to the bound serial port, and then you can read the output status of one or more switch coils; using the function code 02 graphic block read_discrete_inputs: sending slave_address, starting address and data length to the bound serial port, and then you can read one or more switch status inputs; using the function code 03 graphic block read_holding_registers: sending slave_address, starting address and data length to the bound serial port, and then you can read multiple holding registers (registers are readable and writable, and 06 or 10 function codes are used to modify register data).

[0208] Step 4: Download the graphically programmed program to a device (such as a 4G edge terminal) for execution.

[0209] Use the graphical programming combination of step S1 and step S2 to quickly complete the simulation of hardware devices using the serial port-Rs485 acquisition modbusslave software; first use the serial port-Rs485 graphic block class interface to complete the initialization of the serial port parameters, then call the ModbusRTU graphic block class to complete the initialization configuration of the function code and the graphical function code development, then download the developed code to the 4G edge terminal to realize the communication connection with the Modbus slave software, and verify the functions of different function codes realized by graphical programming.

[0210] like Figure 3 As shown, an embodiment of the present invention further provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, the above-mentioned method for developing embedded graphical programming based on the Internet of Things is implemented.

[0211] like Figure 4 As shown, an embodiment of the present invention further provides a computer-readable storage medium on which a computer program is stored. When the program is executed by a processor, the above-mentioned method for developing embedded graphical programming based on the Internet of Things is implemented.

[0212] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0213] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, server, or network device, etc.) or a processor (processor) to perform all or part of the steps of each embodiment of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), disk or optical disk and other media that can store program codes.

[0214] The above descriptions are only some embodiments of the present invention, and are not intended to limit the protection scope of the present invention. Any equivalent device or equivalent process transformation made using the contents of the present invention specification and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent protection scope of the present invention.

Claims

1. A method for developing embedded graphical programming based on the Internet of Things, characterized in that: The steps include: Step 1: Create a graphical programming system application that includes the Blockly framework, add dependent libraries to the graphical programming system application, and perform page layout and initialization configuration; Step 2: construct graphic block components with different functions on the graphical programming system application, and determine the required graphic blocks: S1. Construct the graphic block component of ModbusRTU function, perform the demand analysis of task-type graphic blocks according to the working business process of ModbusRTU industrial protocol, and determine the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks; S2, constructing a graphic block component of the serial port-RS485 function, performing a demand analysis of task-type graphic blocks according to the workflow of the serial port-RS485 communication, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks; S3. Construct the graphic block component of the NetManage function, perform demand analysis of task-type graphic blocks according to the communication mode of the device network port, and determine the required graphic blocks. The required graphic blocks include task-type graphic blocks and statement-type graphic blocks. S4, constructing the graphic block component of the Home Assistant function, performing a demand analysis of task-type graphic blocks according to the communication API of the Home Assistant platform, and determining the required graphic blocks, which include task-type graphic blocks and statement-type graphic blocks; S5. Build the graphic block component of ThingsBoard functions, analyze the demand for task-type graphic blocks according to the communication API of ThingsBoard platform, and determine the required graphic blocks. The required graphic blocks include task-type graphic blocks and statement-type graphic blocks. S6. Constructing a graphic block component of an input / output control function, performing a demand analysis of task-type graphic blocks according to the GPIO input / output control process, and determining required graphic blocks, wherein the required graphic blocks include task-type graphic blocks and statement-type graphic blocks; Step 3: Combine specific business needs and freely combine the required graphic blocks determined in S1 to S6 to build business scenarios, and complete program development through graphical programming; Step 4: Download the graphically programmed program to the device for running.

2. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step 1 specifically includes: Step 11: Create a graphical programming system application, add the Blockly framework and related dependent libraries to the graphical programming system application, and use the NPM run command to install the Blockly framework and related dependent libraries; Step 12: Configure the Blockly framework: Basic configuration of Blockly framework: introduce Blockly framework and import JavaScript file of Blockly framework into HTML file of the project; Add a basic workspace: Define a div element in the HTML file to place the Blockly workspace and initialize the configuration, including grid size, scroll bar, and toolbox position; Set up the toolbox: Design and add a toolbox, including basic blocks supported by the Blockly framework; Add real-time preview: set the preview window to display the real-time effect of generated code; Step 13. Compile and build the project through pnpm build. If there is no error, start the front-end web application through the web server. After starting, access the URL through the browser to verify whether the development environment of the Blockly framework is successfully imported locally. After successful verification, proceed to step 14. Step 14. Add the core script file blockly_compressed.js of the Blockly framework to the application code for loading; Step 15. Inject a resizable workspace: Place the blocklyDiv element over the blocklyArea element and remove any height and width styles from the blocklyDiv element and add absolute positioning; Step 16. Replace the injection script with the script that places blocklyDiv on blocklyArea. The code generator generates code and imports the Blockly framework / JavaScript file. Step 17: After introducing the Blockly framework, introduce the code generation including the file description of python_compressed.js; this completes the initialization configuration of the graphical programming system application.

3. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S1 specifically includes: Step S11, constructing the ModbusRTU_Tools graphic block class; Step S12, adding function graphic blocks of the ModbusRTU protocol to the ModbusRTU_Tools graphic block class, including: function code 01 graphic block read_coils, function code 02 graphic block read_discrete_inputs, function code 03 graphic block read_holding_registers, function code 04 graphic block read_input_registers, function code 05 graphic block write_single_coil, function code 06 graphic block write_single_registers and function code 16 graphic block write_multi_registers; The function code 01 graphic block read_coils: sends slave_address, start address and data length to the bound serial port, and then reads the output status of one or more switching coils; The function code 02 graphic block read_discrete_inputs: sends slave_address, start address and data length to the bound serial port, and then reads the status of one or more switch inputs; The function code 03 graphic block read_holding_registers: sends slave_address, start address and data length to the bound serial port, and then reads the data of multiple holding registers; The function code 04 graphic block read_input_registers: sends slave_address, start address and data length to the bound serial port, and then reads the data of multiple input registers; The function code 05 graphic block write_single_coil: sends slave_address, start address and written data to the bound serial port to turn on or off, and writes the switch output; The function code 06 graphic block write_single_registers: sends slave_address, start address and written data to the bound serial port, and writes a single-channel register; The function code 16 graphic block write_multi_registers: sends slave_address, start address and write multi-channel data to the bound serial port, and writes multi-channel register operations; Step S13, initialize the ModbusRTU_Tools graphic block class, initialize the serial port bound to the ModbusRTU protocol, perform relevant function code operations according to the function codes supported by the nodes of the ModbusRTU protocol, and obtain corresponding protocol data according to whether the CRC check is successful or not; Step S14: The programmer configures parameters by dragging a specific small task module and communicates with the node of the ModbusRTU protocol; Step S15: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

4. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S2 specifically includes: Step S21, constructing a serial port-RS485 graphic block class to provide a serial port communication function; Step S22, adding uartInit graphic block, uart_control_485_pin graphic block, uart_set_callback graphic block, uartWrite graphic block, uartRead graphic block and uart_callback_fun graphic block to the serial port-Rs485 graphic block class; The uartInit graphic block is used for serial port initialization, and the serial port baud rate, data bit, parity check and stop bit, and hardware control flow are set through the uartInit graphic block; The uart_control_485_pin graphic block is used to set the RS-485 transceiver pin control; The uart_set_callback graphic block is used to set the serial port callback function; The uartWrite graphics block is used to control serial port data transmission; The uartRead graphic block is used to control serial port data reception; The uart_callback_fun graphic block is used to execute the serial port receiving callback function; Step S23: The programmer configures parameters by dragging a specific small task module to complete serial port data transmission and reception; Step S24: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

5. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S3 specifically includes: Step S31, constructing a NetManage_Tools graphic block class for managing different communication methods, including connecting to the network via a wired method and connecting to the network via a wireless SIM card 4G communication method; Step S32, adding eth_set_DHCP_mode graphic block, eth_set_Static_mode graphic block, sim_status graphic block, wait_connect graphic block and reconnect graphic block to the NetManage_Tools graphic block class; The eth_set_DHCP_mode graphic block is used to set the device to use a dynamic IP, obtain an IP from a router, and access the network through the router; The eth_set_Static_mode graphic block is used to set the device to use a static IP and access the network through a router; The sim_status graphic block is used to read the SIM card status; The wait_connect graphic block is used for 4G dial-up Internet access and waits for the network connection to be completed; The reconnect graphic block is used to reconnect to the network when a SIM card is inserted and dialing fails; Step S33: The programmer configures parameters by dragging a specific small task module and connects it to the network; Step S34: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

6. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S4: Step S41, constructing a Home Assistant graphic block class to support MQTT communication; Step S42, adding init graphic block, set_callback graphic block, publish graphic block, subscribe graphic block, wait_msg graphic block, add_actuator_to_HA graphic block, add_sensor_to_HA graphic block and add_binary_to_HA graphic block to the Home Assistant graphic block class; The init graphic block is used to initialize and create a connection between the MQTT client and the server; The set_callback graphic block is used to set the callback; The publish graphic block is used to publish messages to the corresponding topic; The subscribe graphic block is used to subscribe to the MQTT topic; The wait_msg graphic block is used to block and wait for the server message response to obtain the MQTT connection status; The add_actuator_to_HA graphical block is used to add an actuator entity to the Home Assistant platform; The add_sensor_to_HA graphic block is used to add a sensor entity to the Home Assistant platform; The add_binary_to_HA block is used to add a binary sensor entity to the Home Assistant platform. Step S43: The programmer configures parameters by dragging a specific small task module and connects it to the HomeAssistant platform; Step S44: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

7. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S5 specifically includes: Step S51, construct ThingsBoard graphic block class to support Mqtt communication for MQ telemetry transmission; Step S52: adding the init graphic block, the set_callback graphic block, the shed_telemetry graphic block and the send_rpc_reply graphic block to the ThingsBoard graphic block class; The init graphic block is used to initialize and create a connection between the MQTT client and the server; The set_callback graphic block is used to set the callback; The shed_telemetry block is used to publish telemetry data to ThingsBoard platform; The send_rpc_reply graphic block is used to reply to the RPC command request sent by the server; Step S53: The programmer configures parameters by dragging a specific small task module and connects it to the ThingsBoard platform; Step S54: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

8. The method for developing embedded graphical programming based on the Internet of Things as claimed in claim 1, characterized in that: The step S6 specifically includes: Step S61, constructing a GPIO input and output control graphic block class; Step S62, adding a machine.Pin graphic block, a set_dir graphic block and a get_dir graphic block to the GPIO input and output control graphic block class; The machine.Pin graphic block is used to initialize the GPIO pins and set whether to pull up or down and the default level; The set_dir graphic block is used to set the input and output modes of the pin of the machine.Pin initialization completion pin; The get_dir graphic block is used to obtain the current input and output mode of the pin, and then the gpio.read graphic block or the gpio.write graphic block can be called to read or set the gpio output high and low levels; Step S63: The programmer configures parameters by dragging a specific small task module and controls GPIO; Step S64: For unpredictable or relatively complex tasks, programmers use statement programming graphic blocks to perform logical combinations to synthesize specific requirements.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the program, an embedded graphical programming development method based on the Internet of Things is implemented as described in any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, an embedded graphical programming development method based on the Internet of Things is implemented as described in any one of claims 1 to 8.

Images