CN109542464B - Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program - Google Patents

Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program Download PDF

Info

Publication number
CN109542464B
CN109542464B CN201811261820.0A CN201811261820A CN109542464B CN 109542464 B CN109542464 B CN 109542464B CN 201811261820 A CN201811261820 A CN 201811261820A CN 109542464 B CN109542464 B CN 109542464B
Authority
CN
China
Prior art keywords
engine
script
server
script program
development
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
CN201811261820.0A
Other languages
Chinese (zh)
Other versions
CN109542464A (en
Inventor
王永斌
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Eastone Century Technology Co ltd
Original Assignee
Eastone Century Technology Co ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Eastone Century Technology Co ltd filed Critical Eastone Century Technology Co ltd
Priority to CN201811261820.0A priority Critical patent/CN109542464B/en
Publication of CN109542464A publication Critical patent/CN109542464A/en
Application granted granted Critical
Publication of CN109542464B publication Critical patent/CN109542464B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/60—Software deployment
    • G06F8/61—Installation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/70—Software maintenance or management
    • G06F8/71—Version control; Configuration management

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Security & Cryptography (AREA)
  • Debugging And Monitoring (AREA)
  • Stored Programmes (AREA)

Abstract

The invention discloses a development and deployment system, a development and deployment method and a storage medium of an IoT device script program, wherein the system comprises a server and a client, and the server comprises: the Web server is used for providing an access interface of external equipment and providing RESTful service; the core constitutes a dump component for storing the crash information of the script program; the debugger server is used for receiving debugging instructions sent by users and collecting system operation information; the mixed operation engine is used for executing the script program and optimizing the development operation environment of the script program; the client comprises: a compiler for compiling a native high-level language into machine code; and the debugger client is used for transmitting a debugging instruction sent by a user. The invention reduces the occupied space of the memory, improves the computing capacity of the system, reduces the delay of data transmission between the server and the client, and can be widely applied to the technical field of the Internet of things.

Description

Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program
Technical Field
The invention relates to the technical field of Internet of things, in particular to a development and deployment system, a development and deployment method and a storage medium of an IoT equipment script program.
Background
In recent years, with the rapid development of economy and the rapid development of the internet of things industry, the internet of things brings many benefits to the work and life of people, and by 2025, the total amount of global data reaches 160ZB, wherein 50% of data comes from user equipment and 25% of data comes from internet of things equipment. The increase of data volume brings a series of problems to the development of the internet of things, such as network congestion, high delay, privacy problems and the like. In order to solve these problems, the concept of edge computing is proposed, in which a server originally located in a cloud is moved from the cloud to a location closer to a client.
However, at the same time, the edge calculation also brings the following two problems: (1) how to debug a distributed dynamic system? (2) How is the program most efficiently dynamically deployed?
Therefore, how to develop a lightweight distributed development system for the internet of things becomes an urgent problem to be solved.
Disclosure of Invention
To solve the above technical problems, the present invention aims to: provided are a system, a method, and a storage medium for developing and deploying an IoT device script program with low delay and high computing power.
On one hand, the technical scheme adopted by the invention is as follows:
the development and deployment system of the IoT device script program comprises a server and a client, wherein:
the server includes:
the Web server is used for providing an access interface of external equipment and providing RESTful service;
the core constitutes a dump component for storing the crash information of the script program;
the debugger server is used for receiving debugging instructions sent by users and collecting system operation information;
the mixed operation engine is used for executing the script program and optimizing the development operation environment of the script program;
the client comprises:
a compiler for compiling a native high-level language into machine code;
and the debugger client is used for transmitting a debugging instruction sent by a user.
Further, the server and the client realize data communication through RESTful API.
Further, the hybrid operation engine comprises a local engine and a script engine, wherein the script engine is established on the virtual machine, and the local engine is established on the operating system;
the local engine is used for executing a local script application program;
the script engine is used for providing the running environment of the script program and managing the life cycle of the script program.
Further, the local engine is further configured to:
calling CPU and RAM storage resources of the Internet of things equipment;
providing access to Internet of things equipment resources, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
providing timing, system time access, and network access functions;
and providing functions of dynamically registering RESTful resources and canceling RESTful resources.
Further, the server further comprises a REST engine;
the REST engine is used for providing loosely coupled RESTful service based on CoAP or HTTP protocol.
The technical scheme adopted by the other aspect of the invention is as follows:
the development and deployment method of the IoT device script program comprises the following steps:
compiling the native high-level language into machine codes through a compiler of the client;
sending a debugging instruction to a server through a debugger client of the client;
receiving a debugging instruction and collecting system operation information through a debugger server of a server;
executing the script program and optimizing the development running environment of the script program through a hybrid running engine of the server;
storing crash information of the script program through a core composition dump component of the server;
and providing an access interface of the external equipment and providing RESTful service through a Web server of the server.
Further, the step of executing the script program and optimizing the development and execution environment of the script program by the hybrid execution engine of the server includes the following steps:
providing a running environment of the script program and managing a life cycle of the script program through a script engine;
calling a CPU (Central processing Unit) and RAM (random Access memory) storage resource of the Internet of things equipment through a local engine;
providing access to Internet of things equipment resources through a local engine, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
providing timing, system time access and network access functions through a local engine;
the functions of dynamically registering RESTful resources and canceling RESTful resources are provided by the local engine.
Further, the step of executing the script program and optimizing the development and execution environment of the script program by the hybrid execution engine of the server further includes the following steps:
providing a loosely coupled RESTful service based on a CoAP or HTTP protocol through a REST engine;
the step of providing a loosely coupled RESTful service based on a CoAP or HTTP protocol by a REST engine specifically includes:
macro definition is carried out through an REST engine, and REST resources are created;
adding a cache time variable to the REST resource;
a cache time is specified for the HTTP request for the REST resource.
Further, the server and the client realize data communication through RESTful API.
The technical scheme adopted by the other aspect of the invention is as follows:
a storage medium having stored therein processor-executable instructions that when executed by a processor are for performing the development deployment method of the IoT device script.
The invention has the beneficial effects that: the distributed dynamic debugging, the distributed dynamic program development and the distributed dynamic program deployment are realized through the server and the client; moreover, the invention also provides a hybrid operation environment through a hybrid operation engine, reduces the occupied space of the memory and improves the computing capacity of the system; in addition, the invention is respectively provided with the debugger server and the debugger client on the server and the client, thereby reducing the delay of data transmission between the server and the client.
Drawings
Fig. 1 is a schematic structural diagram of a system according to an embodiment of the present invention.
Detailed Description
The invention will be further explained and explained with reference to the drawings and the embodiments in the description.
As shown in fig. 1, an embodiment of the present invention provides a development and deployment system of an IoT device script program, including a server and a client, where:
the server includes:
the Web server is used for providing an access interface of external equipment and providing RESTful service;
the core constitutes a dump component for storing the crash information of the script program;
the debugger server is used for receiving debugging instructions sent by users and collecting system operation information;
the mixed operation engine is used for executing the script program and optimizing the development operation environment of the script program;
the client comprises:
a compiler for compiling a native high-level language into machine code;
and the debugger client is used for transmitting a debugging instruction sent by a user.
The developer can create a native development system on the client according to the system of the invention, then deploy the development system on the server, the developer can create a native application program and a script application program in the client, upload and deploy the native application program and the script application program on equipment using RESTful API on the server, and then control and debug the core composition dump component through the RESTful API.
In this embodiment, the compiler compiles the native C language into machine code, and in some embodiments, the high-level language further includes Fortran, Pascal, Cobol, C + +, Basic, Ada, Java, C #, and the like, which are not described herein again.
In this embodiment, the role of the debugger server includes: (1) an acquisition function: acquiring the current operating environment of the system, including statement variables, currently executed codes and function information; (2) single step debugging function: operating programs line by line and operating programs in program blocks; (3) breakpoint debugging function: operations on the breakpoints are added, deleted, enabled and disabled; (4) the backtracking function is as follows: the stack information that calls the current function is listed.
The core composition dump component of the present embodiment implements the mechanism of STM32L152 core dump. When the program crashes, the core constitutes a dump component, so that the crash information stored at the moment can be quickly found. The core dump refers to when a program crashes or otherwise causes system interruption, records and other states in the memory during the program running process, such as register values, stack pointers, memory management information and the like, are stored in the file system for future access. The core dump library is located at the bottom of the operating system kernel, and can communicate with the hardware of the device and be associated with firmware. The results of the core dump process can be sent directly to the developer through the client or stored in ROM of the east and west device. In the program execution process, the core dump mechanism does not affect the normal execution process of the program, does not need additional storage space, and only needs some additional storage space to store exception information and an execution state when a crash occurs.
The embodiment realizes a core dump mechanism of a development board based on STM32L 152. The STM32L152 board is equipped with an ARMCortex-M3CPU, and its critical runtime failures can be divided into four types: HardFault, BusFault, UsageFault, MemoryManagementFault. When one of the faults occurs when the program crashes, the present embodiment finds the cause based on the flag state in the context register. When a fault occurs, the core dump module records the function stack pointer of each layer at the specified address of the ROM with the help of the SP and LR registers, and then reads the error record on the ROM by means of the addr2line tool, so that the complete function callback stack information can be recovered. In addition, due to the strict limitations of device storage, the present embodiment only saves the functional stack pointer when a critical failure occurs.
The Web server of the present embodiment runs in the operating system as a general interface for interaction with the outside. The cloud-based cloud service system provides a uniform access interface for the business equipment so as to display data and functions of the business equipment to the cloud. In addition, online debugging and script loading can also be performed through RESTful services provided by the mini Web server. Compared with the traditional embedded system, the method greatly simplifies the application program development, and developers must construct a complex and fragile cross-compiling environment to edit, compile, load and debug the application program.
Further as a preferred embodiment, the server and the client realize data communication through RESTful API. In the embodiment, RESTful API is used as an adhesive between the server and the front end, so that the traditional one-way development environment is separated, and the two-way interactive communication between the client and the server is realized.
Further as a preferred embodiment, the hybrid operation engine includes a local engine and a script engine, the script engine is built on the virtual machine, and the local engine is built on the operating system;
the local engine is used for executing a local script application program;
the script engine is used for providing the running environment of the script program and managing the life cycle of the script program.
Specifically, the hybrid-type operation engine of the present embodiment includes: (1) the script engine is built on the virtual machine and used for providing a runtime environment and managing a script life cycle; (2) and the local engine is established on the operating system and provides a uniform entrance and control management for the MCU.
The script engine of the embodiment adopts a Lua script engine, and the script engine is established on a script virtual machine. It provides a runtime environment and manages the lifecycle of the script application. The present embodiment uses a virtual machine to dynamically interpret scripts, wherein the scripting language not only can implement functions such as selection, branching, and looping, but also provides operations and functions that can only be implemented by a portion of the local engine. Thus, the user can implement the same functionality as native C code through the scripting language. The script virtual machine of the present embodiment interprets the bytecode compiled by the script.
The embodiment builds a system based on the Lua kernel, develops a script application program and optimizes a runtime environment. The Lua is a lightweight scripting language and can be embedded into an application program written in other languages to run. The occupied space of the Lua is smaller than that of most scripting languages, the Lua strictly follows ANSIC standards, the transportability is good, only a small amount of changes are needed, and the program written by the Lua can run on the equipment with limited resources. In addition, Lua is one of the fastest interpreted scripting languages.
In addition, since Lua has multiple versions, the functions of the Lua of the various versions are different, wherein the characteristics of coroutines and closures are important concepts in the functional programming provided by the Lua of the high version. However, applications on the device do not need to use the properties of coroutines and closures. In the Lua 2.5.1 version, the virtual machine may be implemented using stacks or registers. Because the occupied space of the stack-based virtual machine is smaller, the embodiment selects Lua 2.5.1 as the basis of Lua-lite, and realizes that the stack-based virtual machine explains the Lua-lite script on the business equipment.
In general, the execution style typically includes interpreted execution using a command line or using a virtual machine. The script is first compiled into bytecode and then uploaded to the device and interpreted as program instructions in Lua. Since Lua has a lexical analyzer generated by Lex and its own parser, the virtual machine of the present embodiment does not need to perform lexical analysis, parsing, or generating execution instructions when executing bytecodes. In addition, user interaction is not required when the script program is executed on the user equipment.
In the embodiment, the Lua operation process is divided into two parts, and then the two parts are respectively distributed on a desktop PC (server) and a device (client) so as to reduce the memory occupation of the device. When a developer performs online debugging for a script, the debugger client interacts with the debugger server through the RESTful API. The compiler compiles the Lua-lite source code into bytecode and saves it as a binary file. In addition, the script engine of the present embodiment also provides functions of syntax checking and file size checking.
The Lua linehook adds a hook to the object line of the script source code. Before executing the target row, the embodiment of the present invention may execute the function defined by the developer. The Lua callhook is a hook function that is performed each time the function is entered and exited. In Lua-lite, the present embodiment implements five different hook functions based on the Lua line hook function provided by the original Lua.
Specifically, the five hook functions include:
(1) NONE HOOK: initializing a debugger, which sets an initial value of a function stack depth to-1; (2) CONTINUEHOOK: moving to the next executable line of code; (3) STEP HOOK: step-by-step debugging, wherein when a subfunction is encountered, the subfunction is entered and the step-by-step debugging is continuously executed, otherwise, the step-by-step debugging is moved to the next executable code line; (4) NEXT HOOK: performing a STEP, different from STEP HOOK, if a sub-function is encountered, NEXT HOOK stops after completion of the sub-function execution, rather than entering the sub-function; in NEXT HOOK, the stack depth of the current function needs to be checked; before NEXTHOOK is called, it should not exceed the stack depth of the current function; assuming that the code of function A is executing and then NEXTHOOK is called and the MCU's pointer count goes into sub-function B, the stack depth of function B should not be deeper than A's stack; (5) RUN HOOK: execution of the program continues from the current line of code until the program ends or a breakpoint is encountered.
Further as a preferred embodiment, the local engine is further configured to:
calling CPU and RAM storage resources of the Internet of things equipment;
providing access to Internet of things equipment resources, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
providing timing, system time access, and network access functions;
providing functions of dynamically registering RESTful resources and canceling RESTful resources;
for the local engine, which is used to execute the local part of the Lua-lite script application, the local engine of this embodiment discards the components of lexical analysis, parsing and instruction generation. The virtual machine running on the device only accepts compiled byte code files, which can reduce the occupied space by about 30%. This mechanism greatly increases the efficiency of script programming. Lua-lite will delete the IO operation library and Lua's math library since it only needs to simply compute some devices. With these modifications, the size of the binary file compiled by the virtual machine on Lualite is reduced from 103KB to 61 KB.
The local engine of the present embodiment is located on top of the operating system and provides a unified access and control interface for the scripting application to connect to peripheral devices such as an MCU. Sensors (e.g., temperature, humidity, acceleration) and other peripherals (e.g., GPIO, UART, SPI, FLASH) may be registered as REST resources. In the conventional method, it is very difficult to write peripheral resources using a scripting language due to the diversity of MCU-based device peripherals, a developer must write application drivers for each peripheral in the conventional embedded system, and other programmers may need to read SDK documents or source codes to create applications based on these drivers, which requires professional skills and experience, greatly increasing labor and time costs. The invention abstracts the meta-method for resource access according to the REST unified interface principle, wherein the meta-method comprises creation, reading, writing and deletion.
The caching mechanism can significantly reduce the latency of HTTP requests. It can reduce the uncertainty of the edge calculation system. However, since HTTP does not support caching initially, this embodiment adds HTTP caching support in the local engine to improve the quality of experience (i.e., QoE) of the script application. The main functions of the local engine of the present embodiment are as follows: (1) the CPU and RAM storage resources of the Internet of things equipment can be called to realize basic programming language functions such as selection, branching, circulation and the like; (2) the access to the resources of the Internet of things equipment such as GPIO, FLASH, UART and the like is provided; (3) the method realizes a plurality of operations of the Internet of things equipment, such as opening, reading, writing, closing and the like; (4) providing part of support functions, such as timing, system time access, network access and the like; (5) it provides network access to obtain REST network resources of themselves or other devices, and at the same time, it can also realize data exchange and access between different devices; (6) it provides dynamic registration and cancellation functionality for RESTful resources.
Further as a preferred embodiment, the server further comprises a REST engine;
the REST engine is used for providing loosely coupled RESTful service based on CoAP or HTTP protocol.
In particular, in order to facilitate the developer to implement the RESTful access interface of the IoT resource, the Contiki OS of the present invention is also equipped with a REST engine. The REST engine provides loosely coupled RESTful services based on the CoAP or HTTP protocols. The official REST engine of Contiki enables the creation of REST resources through macro definitions, but it does not support caching HTTP requests. In this regard, the present invention adds a cache time variable to the definition of the resource structure. In defining macros, a user may specify a cache time for an HTTP request specifying a resource. The invention utilizes a cache mechanism, can greatly shorten the response time and improve the performance of the edge computing system and the reliability of script application.
The embodiment of the invention also provides a development and deployment method of the IoT equipment script program, which comprises the following steps:
compiling the native high-level language into machine codes through a compiler of the client;
sending a debugging instruction to a server through a debugger client of the client;
receiving a debugging instruction and collecting system operation information through a debugger server of the server;
executing the script program and optimizing the development running environment of the script program through a hybrid running engine of the server;
storing crash information of the script program through a core composition dump component of the server;
and providing an access interface of the external equipment and providing RESTful service through a Web server of the server.
Further, as a preferred embodiment, the step of executing the script program and optimizing the development operation environment of the script program by the hybrid operation engine of the server includes the following steps:
providing a running environment of the script program and managing a life cycle of the script program through a script engine;
calling a CPU (Central processing Unit) and RAM (random Access memory) storage resource of the Internet of things equipment through a local engine;
providing access to Internet of things equipment resources through a local engine, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
providing timing, system time access and network access functions through a local engine;
the functions of dynamically registering RESTful resources and canceling RESTful resources are provided by the local engine.
Further, as a preferred embodiment, the step of executing the script program and optimizing the development operation environment of the script program by the hybrid operation engine of the server further includes the following steps:
providing a loosely coupled RESTful service based on a CoAP or HTTP protocol through a REST engine;
the step of providing a loosely coupled RESTful service based on a CoAP or HTTP protocol by a REST engine specifically includes:
macro definition is carried out through an REST engine, and REST resources are created;
adding a cache time variable to the REST resource;
a cache time is specified for the HTTP request for the REST resource.
Further as a preferred embodiment, the server and the client realize data communication through RESTful API.
In addition, the embodiment of the present invention also provides a storage medium, in which processor-executable instructions are stored, and when the processor-executable instructions are executed by a processor, the storage medium is used for executing the development and deployment method of the IoT device script program.
In summary, the present invention is based on internet of things devices and a standardized RESTful API system, wherein the RESTful API simplifies data processing and device management operations. The key technical points are two aspects: (1) an IoT device development debugging environment based on Lua Script; (2) and a RESTful distributed development environment converts a traditional compiler and a debugger into a standard RESTful development mode and can provide a hybrid running environment, so that a distributed dynamic system is debugged and a program is dynamically deployed. The interface of the invention is uniform, and developers can develop and debug the script program at any place.
While the preferred embodiments of the present invention have been illustrated and described, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims.

Claims (9)

  1. An IoT device script development deployment system, characterized by: the system comprises a server and a client, wherein:
    the server includes:
    the Web server is used for providing an access interface of external equipment and RESTful service;
    the core constitutes a dump component for storing the crash information of the script program;
    the debugger server is used for receiving debugging instructions sent by users and collecting system operation information;
    the mixed operation engine is used for executing the script program and optimizing the development operation environment of the script program;
    the client comprises:
    a compiler for compiling a native high-level language into machine code;
    the debugger client is used for transmitting a debugging instruction sent by a user;
    the hybrid operation engine comprises a local engine and a script engine, wherein the script engine is established on a virtual machine, and the local engine is established on an operating system;
    the local engine is used for executing a local script application program;
    the script engine is used for providing the running environment of the script program and managing the life cycle of the script program.
  2. 2. The development deployment system of an IoT device script according to claim 1, wherein: and the server and the client realize data communication through RESTful API.
  3. 3. The development deployment system of an IoT device script according to claim 1, wherein: the local engine is further to:
    calling CPU and RAM storage resources of the Internet of things equipment;
    providing access to Internet of things equipment resources, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
    providing timing, system time access, and network access functions;
    and providing functions of dynamically registering RESTful resources and canceling RESTful resources.
  4. 4. The development deployment system of an IoT device script according to claim 1, wherein: the server further comprises a REST engine;
    the REST engine is used for providing loosely coupled RESTful service based on CoAP or HTTP protocol.
  5. The development and deployment method of the IoT device script program is characterized by comprising the following steps: the method comprises the following steps:
    compiling the native high-level language into machine codes through a compiler of the client;
    sending a debugging instruction to a server through a debugger client of the client;
    receiving a debugging instruction and collecting system operation information through a debugger server of the server;
    executing the script program and optimizing the development running environment of the script program through a hybrid running engine of the server;
    storing crash information of the script program through a core composition dump component of the server;
    providing an access interface of external equipment and RESTful service through a Web server of the server;
    the hybrid operation engine comprises a local engine and a script engine, wherein the script engine is established on a virtual machine, and the local engine is established on an operating system;
    the local engine is used for executing a local script application program;
    the script engine is used for providing the running environment of the script program and managing the life cycle of the script program.
  6. 6. The development deployment method of the IoT device script program in claim 5, wherein: the step of executing the script program and optimizing the development operation environment of the script program by the hybrid operation engine of the server comprises the following steps:
    providing a running environment of the script program and managing a life cycle of the script program through a script engine;
    calling a CPU (Central processing Unit) and RAM (random Access memory) storage resource of the Internet of things equipment through a local engine;
    providing access to Internet of things equipment resources through a local engine, wherein the Internet of things equipment comprises a GPIO (general purpose input/output), a FLASH and a UART (universal asynchronous receiver/transmitter);
    providing timing, system time access and network access functions through a local engine;
    the functions of dynamically registering RESTful resources and canceling RESTful resources are provided by the local engine.
  7. 7. The development deployment method of the IoT device script program in claim 6, wherein: the step of executing the script program and optimizing the development and operation environment of the script program by the hybrid operation engine of the server further comprises the following steps:
    providing a loosely coupled RESTful service based on a CoAP or HTTP protocol through a REST engine;
    the step of providing a loosely coupled RESTful service based on a CoAP or HTTP protocol by a REST engine specifically includes:
    macro definition is carried out through an REST engine, and REST resources are created;
    adding a cache time variable to the REST resource;
    a cache time is specified for the HTTP request for the REST resource.
  8. 8. The development deployment method of the IoT device script program in claim 5, wherein: and the server and the client realize data communication through RESTful API.
  9. 9. A storage medium having stored therein instructions executable by a processor, characterized in that: the processor-executable instructions, when executed by a processor, are for performing the development deployment method of the IoT device script program recited in any of claims 5-8.
CN201811261820.0A 2018-10-26 2018-10-26 Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program Active CN109542464B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN201811261820.0A CN109542464B (en) 2018-10-26 2018-10-26 Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN201811261820.0A CN109542464B (en) 2018-10-26 2018-10-26 Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program

Publications (2)

Publication Number Publication Date
CN109542464A CN109542464A (en) 2019-03-29
CN109542464B true CN109542464B (en) 2022-05-10

Family

ID=65845366

Family Applications (1)

Application Number Title Priority Date Filing Date
CN201811261820.0A Active CN109542464B (en) 2018-10-26 2018-10-26 Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program

Country Status (1)

Country Link
CN (1) CN109542464B (en)

Families Citing this family (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN111158940B (en) * 2019-12-31 2022-01-28 因特睿科技有限公司 Method and device for docking and dynamically loading different devices in field of Internet of things
CN111857675B (en) * 2020-08-03 2023-07-11 北京思特奇信息技术股份有限公司 Method and system for realizing RESTFUL service based on C++
CN113238794A (en) * 2021-04-07 2021-08-10 工业互联网创新中心（上海）有限公司 Method and system for preprocessing data at edge side

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101727316A (en) * 2008-10-22 2010-06-09 上海超级计算中心 Parallel program integrated development system suitable for clustering system as well as application implementation method thereof
CN106648717A (en) * 2015-11-03 2017-05-10 陈智玲 Network real-time programming development method for microcontroller
US20180262388A1 (en) * 2006-09-25 2018-09-13 Weaved, Inc. Remote device deployment

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20180262388A1 (en) * 2006-09-25 2018-09-13 Weaved, Inc. Remote device deployment
CN101727316A (en) * 2008-10-22 2010-06-09 上海超级计算中心 Parallel program integrated development system suitable for clustering system as well as application implementation method thereof
CN106648717A (en) * 2015-11-03 2017-05-10 陈智玲 Network real-time programming development method for microcontroller

Also Published As

Publication number Publication date
CN109542464A (en) 2019-03-29

Similar Documents

Publication Publication Date Title
KR20210002701A (en) Execution control through cross-level trace mapping
US5732210A (en) Use of dynamic translation to provide fast debug event checks
JP5415557B2 (en) User script code conversion for debugging
US8458681B1 (en) Method and system for optimizing the object code of a program
US10445216B2 (en) Debugging program code at instruction level through emulation
CN109542464B (en) Development and deployment system, method and storage medium of IoT (Internet of things) equipment script program
US8261243B2 (en) Selective execution of trace mechanisms for applications having different bit structures
US8429632B1 (en) Method and system for debugging merged functions within a program
US8776024B2 (en) Software application fine-tuning method, system, and corresponding computer program product
US8893100B2 (en) Return address optimisation for a dynamic code translator
US9134973B2 (en) Dynamic compiling and loading at runtime
CN113196243A (en) Improving simulation and tracking performance using compiler-generated simulation-optimized metadata
CN113312046A (en) Sub-application page processing method and device and computer equipment
US8904346B1 (en) Method and system for automated load testing of web applications
US11113182B2 (en) Reversible debugging in a runtime environment
CN111258802A (en) Method for capturing application program crash information and related equipment
US11379195B2 (en) Memory ordering annotations for binary emulation
CN116627850B (en) Function debugging method and device, storage medium and electronic equipment
CN109947407B (en) Data acquisition method and device
US11074153B2 (en) Collecting application state in a runtime environment for reversible debugging
US20130132930A1 (en) Capturing telemetry data by dynamic language engine
US11573787B1 (en) Hot reloading a running application with an unsaved source code change
CN114816672A (en) Virtual machine creation method and device, electronic equipment and storage medium
CN113467861A (en) File calling method and device, storage medium and electronic equipment
Pimás et al. Metaphysics: Towards a Robust Framework for Remotely Working with Potentially Broken Objects and Runtimes

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
CB02 Change of applicant information

Address after: 510630 East Floor 3, No. 14 and No. 16 Jianzhong Road, Tianhe District, Guangzhou City, Guangdong Province

Applicant after: Yitong Century Science and Technology Co., Ltd.

Address before: 510630 East Floor 3, No. 14 and No. 16 Jianzhong Road, Tianhe District, Guangzhou City, Guangdong Province

Applicant before: Guangdong Eastone Technology Co., Ltd.

CB02 Change of applicant information
GR01 Patent grant
GR01 Patent grant