Device control system based on execution of block-based source code and execution method thereof

Abstract

This device control system based on execution of a block-based source code according to the present invention comprises: a source code execution module for generating a source code composed of a plurality of blocks, transmitting a command of each block to a corresponding device to execute the command, and receiving the execution result; a device for collecting data in order to perform the command executed by the source code execution module; a communication module for transmitting the commands of the source code execution module to the device and providing, to the source code execution module, the data received from the device; and one or more devices for receiving a command via the communication module and performing an operation in accordance with the received command.

Description

Device control system through block-based source code execution and method for executing the same

[0001] The present invention relates to a device control system through block-based source code execution and a method for executing the same. More specifically, it relates to a device control system through block-based source code execution and a method for executing the same, which enables easy control of a complex system by systematically organizing commands through block-unit source code and having each block issue commands to a device in real time.

[0002] Existing block coding systems have limitations in that they suffer from reduced efficiency when controlling various devices. In general systems, a method is used where all code is compiled at once and the entire code is transmitted to the device for execution. This approach makes it difficult to identify problems occurring during code execution in real time, and synchronization and control may not be smooth, particularly in situations where multiple devices operate in combination.

[0003] In particular, real-time feedback and immediate control reflecting the status of individual devices are crucial in multi-device environments. However, existing methods have limited capabilities for this, resulting in the cumbersome process of correcting errors and re-transmitting based on the overall code execution results. This issue causes inconvenience in diverse device control environments that require rapid corrections and real-time responses.

[0004] For example, in an IoT (Internet of Things) environment, each device performs different functions and must process and transmit various data in real time. In the case of existing block coding methods, there are limitations in simultaneously grasping the connectivity and continuity of operations between individual devices when controlling them in a complex environment, which may result in situations where devices cannot be operated efficiently as desired by the user.

[0005] Furthermore, existing coding platforms support the generation of code capable of controlling a specific single device during coding, but they do not support the generation of code capable of controlling multiple types of devices using a single code. This is because device control is achieved by compiling the entire code and then transmitting it. However, as connectivity between objects strengthens, the variety of devices that can be controlled through coding is increasing. Although controlling these devices in conjunction enables more complex and sophisticated tasks, current coding platforms impose a limitation where control code must be generated and executed separately for each device.

[0006] The present invention aims to provide a device control system through block-based source code execution and a method for executing the same, which enables easy control of a complex system by systematically organizing commands through block-unit source code and having each block issue commands to a device in real time.

[0007] In addition, the present invention aims to provide a device control system through block-based source code execution and a method for executing the same, which makes maintenance and operation very easy by ensuring that the entire system does not stop even if an error occurs in a specific block because commands are executed in block units, and allowing only the relevant block to be modified and re-executed.

[0008] In addition, the present invention aims to enable the control of multiple devices of various types with a single code, and to enable complex operation control, such as controlling other devices of different types based on the results of data analysis collected from one device.

[0009] In addition, the present invention aims to provide a device control system through block-based source code execution and a method for executing the same, which analyzes data collected from a device through an AI model and provides immediate feedback based on the results to enable the device to maintain optimal performance.

[0010] Furthermore, the present invention aims to provide a device control system and a method for executing the same through block-based source code execution, which can be applied in various fields such as robot control, autonomous driving, and industrial automation, and particularly contribute to increasing system reliability through real-time feedback and command reconfiguration in complex control systems.

[0011] The objects of the present invention are not limited to those mentioned above, and other unmentioned objects and advantages of the present invention may be understood from the following description and will be more clearly understood by the embodiments of the present invention. Furthermore, it will be readily apparent that the objects and advantages of the present invention can be realized by the means and combinations thereof set forth in the claims.

[0012] A device control system through block-based source code execution for achieving such an objective comprises a source code execution module that generates source code composed of multiple blocks, transmits commands of each block to at least one of a corresponding device or AI module to execute the commands, and receives the execution results; and one or more communication modules that transmit commands to a pre-matched device or provide data received from a pre-matched device to the source code execution module according to the commands. The device receives commands through the matched communication module and performs an operation according to the received commands, or transmits data collected or generated by the device to the matched communication module at a pre-set interval regardless of the commands.

[0013] In one embodiment, the source code execution module is configured so that a plurality of blocks are executed sequentially, and if an error occurs in a specific block, only that block can be modified and re-executed.

[0014] In one embodiment, the source code execution module can assign a command to a specific device through the communication module according to parameters set in each block, and control the device to execute the command.

[0015] In one embodiment, the communication module receives and stores a sensing value from the device, and can generate a device operation command using the sensing value according to the type of the parameter and provide it to the device.

[0016] In one embodiment, a device control system through block-based source code execution may further include an AI model that analyzes data collected from a device or source code execution module and provides the analysis results to the source code execution module.

[0017] In addition, a method for controlling a device through block-based source code execution to achieve this purpose includes the steps of generating source code composed of a plurality of blocks and executing each block; executing a first block or transmitting a command of each block to at least one of a corresponding device or AI module according to the parameter value of a function corresponding to each block when executing each block; receiving an execution result through a communication module matched to the device; and outputting a result value when the execution of all blocks is completed.

[0018] In one embodiment, the step of the source code execution module generating source code composed of a plurality of blocks and executing each block includes the step of the source code execution module executing the plurality of blocks sequentially and, if an error occurs in a specific block, modifying only that block and re-executing it.

[0019] In one embodiment, the source code execution module may further include the step of assigning a command to a specific device through a communication module according to parameters set in each block, and controlling the device to execute the command.

[0020] In one embodiment, the step of controlling a device to perform a command may include the step of a communication module receiving and storing a sensing value from the device, and providing the device to the device that generates and provides a device operation command using the sensing value for the type of parameter.

[0021] In one embodiment, the source code execution module executes a function corresponding to a block, and if the function is a function that executes another block and the parameter value includes identification information of the other block, it can execute the other block. If the function is a function that transmits commands and the parameter value of the function includes device identification information, the source code execution module can transmit the command to the device through a communication module matched to the device. If the function corresponding to the block is a function that executes an AI model, the source code execution module can transmit an execution command to the AI ​​model to execute the AI ​​model and receive a result value.

[0022] According to the present invention as described above, there is an advantage in that commands are systematically organized through block-unit source code, and each block issues commands to a device in real time, thereby enabling easy control of a complex system.

[0023] In addition, according to the present invention, multiple devices of various types can be controlled with a single code, and complex operation control is possible, such as controlling other devices of different types based on the results of data analysis collected from one device.

[0024] In addition, according to the present invention, since commands are executed in block units, the entire system does not stop even if an error occurs in a specific block, and only the relevant block can be modified and re-executed, which has the advantage of making maintenance and operation very easy.

[0025] Furthermore, according to the present invention, there is an advantage in that data collected from a device is analyzed through an AI model, and immediate feedback is provided based on the results, enabling the system to maintain optimal performance. Specifically, according to the present invention, more efficient and intuitive control can be achieved through a process in which an AI model transmits computation results, a device collects this data, and a control module immediately modifies the device's operation based on it. This offers significant advantages, particularly in fields such as smart home systems, automated processes, and autonomous vehicles.

[0026] This invention can be applied to various fields such as robot control, autonomous driving, and industrial automation, and has the advantage of contributing to increasing system reliability, particularly in complex control systems, through real-time feedback and command reconfiguration.

[0027] FIG. 1 is a network configuration diagram for explaining a device control system through block-based source code execution according to one embodiment of the present invention.

[0028] FIG. 2 is a flowchart illustrating an embodiment of a device control method through block-based source code execution according to the present invention.

[0029] FIGS. 3 to 6 are exemplary diagrams for explaining a device control process through block-based source code execution according to the present invention.

[0030] The aforementioned objectives, signatures, and advantages are described in detail below with reference to the attached drawings, thereby enabling those skilled in the art to easily implement the technical concept of the present invention. In describing the present invention, detailed descriptions of known technologies related to the present invention are omitted if it is determined that such descriptions would unnecessarily obscure the essence of the invention. Hereinafter, preferred embodiments according to the present invention will be described in detail with reference to the attached drawings. In the drawings, the same reference numerals are used to indicate the same or similar components.

[0031]

[0032] FIG. 1 is a network configuration diagram for explaining a device control system through block-based source code execution according to one embodiment of the present invention.

[0033] Referring to FIG. 1, a device control system through block-based source code execution includes a source code execution module (110), an AI model (120_1 to 120_N), and a communication module (140_1 to 140_N), which can control one or more devices (200_1 to 200_N) of various types.

[0034] The source code execution module (110) handles source code formed of multiple blocks that perform specific commands or operations defined by the user. At this time, the source code (block code) generated by the source code execution module (110) is formed of multiple blocks, and each time a block is executed line by line, it provides a command to one or more of the pre-set devices (200_1 to 200_N) and receives the result of executing the command from the devices (200_1 to 200_N). A function is assigned to each individual block. That is, when generating source code with multiple blocks, the user will generate source code by combining the characteristics of the function (specific command or operation) corresponding to each block. When the user selects and inputs one of the multiple parameter setting values ​​of the function corresponding to each block provided by the device control system (100), the source code execution module (110) uses this to convert and execute the code.

[0035] The source code execution module (110) converts and executes the code using specific commands or operation parameters set in each block by the user. The parameter values ​​are determined through user selection input, and the commands of the blocks are assigned to specific devices. For example, in a source code formed by a plurality of blocks as shown in (A) of FIG. 3, device identification information (10), identification information of a motor to be turned on (20), and identification information of a force sensor to be set for pressure conditions (30) may be parameter values, and these may be set by the user during the process of generating the block code. The source code execution module (110) can convert the source code using the commands and parameter setting values ​​of each block to generate code data such as (B) of FIG. 3.

[0036] For example, if the command in block 1 includes a command to call a device (200_1 to 200_N) for determining the position of the robot arm, this block 1 is configured to collect real-time data from the position device (200_1 to 200_N) mounted on the robot arm, and when the command is executed, the device (200_1 to 200_N) transmits the position data to the system.

[0037] As another example, Block 2 can execute the task of analyzing data collected from devices (200_1 to 200_N) using an AI model. Block 2 receives arm position data from Block 1 and analyzes whether the current position is within a reference range, and the AI ​​model determines whether movement is necessary based on the arm position.

[0038] As another example, Block 3 is a command that controls the devices (200_1 to 200_N) and can perform the task of moving the robot arm to a specific position based on the result of the AI ​​model. For example, if the robot arm deviates from the reference position, Block 3 issues a command to the devices (200_1 to 200_N) to move the arm to a specified coordinate. This command is immediately transmitted to and executed by the controller connected to the robot arm.

[0039] As another example, block 4 is a feedback block that checks whether the movement of the robot arm is completed. After the device (200_1 to 200_N) operates and the arm moves, block 4 calls the device (200_1 to 200_N) again to check if the target position has been reached, and if the target position has not been reached, it returns an error or returns to block 3 to make adjustments.

[0040] As described above, when the source code is configured as blocks 1 through 4, blocks 1 through 4 issue commands to corresponding devices (input devices, AI models, output modules) in real time to operate them. At this time, since all commands are processed in block units, immediate feedback and re-execution are possible by modifying only one line of block in the event of an error, and the entire system operates in real time.

[0041] Additionally, the source code execution module (110) can execute the block set as a parameter when another block is set as a parameter of a function (command or operation) corresponding to the block. If the function corresponding to the block is a command, the source code execution module (110) can provide the command to a device (200_1~200_N) corresponding to the parameter or to an AI model corresponding to the parameter through the communication module (140_1~140_N) according to the parameter constituting the command.

[0042] The source code execution module (110) checks the type of input parameter. The parameter can be of various types, and there are various data formats such as numbers, strings, arrays, and objects.

[0043] The source code execution module (110) can execute each block independently when a different block is set in the parameter, that is, when the parameter value contains identification information of another block. To this end, the source code execution module (110) checks the dependencies of the block and prepares for execution in the required order. At this time, commands or operations within the block may be executed sequentially or in parallel. In this step, it is checked whether the resources and input values ​​required by the block are properly prepared.

[0044] The source code execution module (110) determines how to process the command based on the type of parameter when the function corresponding to the block is a command. The command parameter may be interpreted differently depending on the format, such as a number, string, or object.

[0045] When data collected from a device or source code execution module (110) is input to the AI ​​model (120_1~120_N), the AI ​​model performs an analysis based on the input data and provides the analysis results to the source code execution module (110). Accordingly, the source code execution module (110) can transmit commands to the corresponding device based on the results of the AI ​​model (120_1~120_N).

[0046] For example, when an AI model (120_1 to 120_N) receives data such as surrounding vehicles, pedestrians, and road signals from a device (e.g., camera, lidar) mounted on a vehicle, it analyzes the data to recognize obstacles, pedestrians, and traffic conditions, makes decisions such as speed control and direction change, and then provides the analysis results to a source code execution module (110). Accordingly, the source code execution module (110) operates the vehicle's control system (brake, steering, etc.) based on the AI ​​model's decision to reduce speed or stop the vehicle.

[0047] The communication module (140_1 to 140_N) transmits commands generated by the source code execution module (110) to external devices (200_1 to 200_N) (e.g., input devices, output modules, etc.) to communicate with the connected devices, and provides responses or data from the external devices (200_1 to 200_N) to the source code execution module (110). Accordingly, the source code execution module (110) provides the data received from the communication module (140_1 to 140_N) to the next block for use in executing the next command.

[0048] When block code is executed in the source code execution module (110), the communication module (140_1~140_N) generates a command for a specific device (200_1~200_N), and this command is provided to the device (200_1~200_N) through the communication module (140_1~140_N).

[0049] To this end, the communication modules (140_1 to 140_N) receive real-time data from various devices connected to the device (200_1 to 200_N). For example, the communication modules (140_1 to 140_N) receive and store sensing values ​​generated from various types of devices, such as temperature sensors, position sensors, and pressure sensors.

[0050] The above-mentioned stored sensing values ​​are used as reference values ​​required when performing specific tasks in the system. For example, the current position data of the robot arm can be received and stored to be used as a reference for controlling the movement of the robot arm thereafter.

[0051] The source code execution module (110) processes the data received from the device (200_1 to 200_N) differently according to the function and / or parameter corresponding to the block. The type of parameter varies depending on the task or state that a specific device must perform, and a command is generated based on the device data corresponding to the parameter setting.

[0052] For example, if the value set as a parameter is 'temperature', the source code execution module (110) can generate an operation command corresponding to the temperature data received from the device (200_1) equipped with a temperature sensor. If the temperature rises above a certain range, it can generate a command to operate the cooling device (200_2).

[0053] As another example, if 'position' is set as a parameter, the source code execution module (110) can check the position of the robot arm (200_3) and then generate a command to readjust the arm if it deviates from the reference position.

[0054] As another example, if a communication module in a vehicle control system (100) transmits a command to control the speed of the vehicle, this command is transmitted to a brake system or an acceleration system to control the speed of the vehicle.

[0055] As described above, commands generated by the source code execution module (110) are transmitted to one or more devices (200_1 to 200_N) corresponding to each command through the communication modules (140_1 to 140_N). For example, when a command to control a robot arm is generated by the source code execution module (110), this command is transmitted to the robot arm device (200_3) through the communication modules (140_1 to 140_N), and the device operates according to the command.

[0056] The communication module (140_1~140_N) transmits a command to the device (200_1~200_N) and receives feedback from the device (200_1~200_N) regarding whether the device (200_1~200_N) has properly executed the command. This feedback plays an important role in the system and is used to verify whether the command has been successfully executed. The feedback received by the communication module (140_1~140_N) is transmitted to the source code execution module (110). If, as a result of checking the feedback, the device (200_1~200_N) fails to properly execute the command or returns a result different from the expected result, the source code execution module (110) can proceed with the process of generating additional commands or correcting errors.

[0057] This integrated feedback system supports the continuous and stable operation of the system and monitors the operational status of the entire system to enable immediate response when necessary.

[0058] The communication module (140_1 to 140_N) provides compatibility with various types of devices. It communicates with various external devices, such as output devices, input devices, physical sensors, chemical sensors, optical and image sensors, environmental sensors, biometric sensors, magnetic and electromagnetic sensors, and composite sensors, and performs functions by receiving and processing data generated from each device. This is because when the communication module (140_1 to 140_N) transmits a command corresponding to each block code to the device (200_1 to 200_N), it converts the code data (command) to match the communication method (protocol) of the device corresponding to each command. The communication module (140_1 to 140_N) in the present invention can be viewed as a software-implemented module that matches the device (200_1 to 200_N) on a 1:1 basis. For example, the communication module (140_1) may be a communication module corresponding to the device (200_1), which converts commands generated by the source code execution module (110) according to the protocol of the device (200_1) and is a module dedicated to transmitting and receiving data with the matched device (200_1). Accordingly, if the device control system (100) according to the present invention is compatible with N devices, the number of communication modules (140) included in the system (100) may be N or fewer. The number of communication modules (140) may be determined by the number of devices or by the number of device types.

[0059] The communication module (140_1~140_N) waits for data transmission depending on the state of the matched device, and transmits data when the device (200_1~200_N) is in a state where it can receive data. Additionally, it performs the role of temporarily storing data received periodically or non-periodically from the matched device (200_1~200_N) and delivering the stored data when requested by the code execution module (110). As a result, the system can be flexibly used in various industrial and application environments.

[0060] When controlling a device (200_1 to 200_N) that includes a sensor, the communication module (140_1 to 140_N) receives and stores sensing values ​​generated by the device (200_1 to 200_N) and performs an important role of transmitting commands to the device (200_1 to 200_N) based on data generated according to parameters. Through this, a complex system operates accurately in real time, and stable control is possible that minimizes errors through feedback.

[0061] When source code generated by the source code execution module (110) is executed in blocks, if a device call is included in the parameters of the block, the state data of the called device (200_1~200_N) or the data collected by the device (200_1~200_N) can be transmitted to the source code execution module (110) and utilized for block-unit code execution.

[0062] For example, if block 1 is a code block containing a command to request temperature data from one or more devices (200), the devices (200_1 to 200_N) can immediately collect the current temperature value and transmit it to the communication modules (140_1 to 140_N), and the communication modules (140_1 to 140_N) can transmit it to the source code execution module (110). To do this, block 1 can execute a command such as temperature_sensor.read(). The above function is a function that collects real-time temperature data from the devices (200_1 to 200_N). When a command requiring data from a specific device is executed, the communication module (140) may request and transmit data to the device (200) in real time as in the example above, but to increase the speed of the system, the communication module (140_1~140_N) may periodically receive and store data that the device (200_1~200_N) can provide from the dedicated device (200_1~200_N) matched to each communication module, and then transmit only the data required by the command of the source code execution module (110).

[0063] The dynamic block execution unit (160) monitors the current system status or environment variables in real time before executing the block. The dynamic block execution unit (160) can determine whether the block can be executed appropriately by checking the temperature, load status, sensing values, etc. of the output module (not shown).

[0064] After that, the dynamic block execution unit (160) selects a block that meets the conditions based on the monitoring results, or reconfigures the operation of a previously defined block. In this process, unnecessary blocks may be skipped. For example, if the load of the device (200_1~200_N) is excessively high, the dynamic block execution unit (160) may first execute a block that controls the operation of the device (200_1~200_N), or additionally execute a block that controls the cooling device when the temperature of the device (200_1~200_N) is high.

[0065] The dynamic block execution unit (160) optimizes the execution order of the system when multiple blocks need to be executed sequentially to minimize unnecessary delays and selects only the necessary blocks. Through this, it selects an efficient path to complete the task. For example, in general situations, Block 1 and Block 2 are executed sequentially, but in specific situations, performance can be optimized by executing only Block 2 and skipping Block 1.

[0066] The dynamic block execution unit (160) reconfigures and executes existing defined blocks as needed. For example, if a specific block is not executed normally or if there is insufficient data, the system can select another alternative block to continue execution.

[0067] For example, if Block2, which collects data from the force sensor, fails, a backup block or a replacement block can be executed to obtain the same result or maintain minimal system operation.

[0068] Additionally, the dynamic block execution unit (160) can dynamically change the block being executed based on real-time feedback (e.g., changes in sensor values, changes in the external environment) that occurs during the execution of the block. For example, if a new input or an unexpected situation occurs during execution, the block can be dynamically readjusted to match the situation.

[0069]

[0070] FIG. 2 is a flowchart illustrating an embodiment of a device control method through block-based source code execution according to the present invention.

[0071] Referring to FIG. 2, the source code execution module (110) converts code composed of multiple blocks to generate source code and executes each block of the source code independently (step S210). The step of executing each block of the source code can be understood as executing code data corresponding to each block of the source code.

[0072] In one embodiment of step S210, the source code execution module (110) is configured so that a plurality of blocks are executed sequentially, and if an error occurs in a specific block, only that block can be modified and re-executed.

[0073]

[0074] In another embodiment of step S210, the source code execution module (110) can assign a command to a specific device through a communication module according to a parameter value set by the user in each block, and control the device to execute the command.

[0075] For this step, the communication modules (140_1 to 140_N) can periodically receive and store sensing values ​​from the device, and can return the sensing values ​​corresponding to the parameter values ​​set by the user to the source code execution module (110).

[0076] For example, if Block 1 includes a position sensor call command to determine the position of a robot arm device, the command included in Block 1—a command to collect real-time data from the position sensor—can be executed in a source code execution module and transmitted to the robot arm device through a communication module dedicated to the robot arm device. The robot arm device transmits position data collected from the position sensor (assuming the position sensor is included in the robot arm device) to a device control system, and the communication module can transmit this to the source code execution module. The communication module dedicated to the robot arm device may receive position data from the robot arm device and transmit it in real time when a command is received, but it may also periodically collect and store various types of sensor data from the robot arm device, and may operate by returning the corresponding sensor value when a request for a specific sensor value is received from the source code execution module. This is to prevent delays in execution speed due to the characteristic of the present invention—the characteristic that the source code execution module can control multiple multi-type devices by sequentially executing blocks matched to different devices. For each of the multiple types of devices, a communication module operating exclusively for a specific device can significantly reduce the overall code execution speed by periodically collecting sensor data, environmental data, etc. that can be collected from the dedicated device, and then delivering the data required by the source code execution module to the source code execution module during the execution of the entire block code.

[0077] After Block 1 is executed, Block 2 can perform the task of analyzing data collected from the sensor using an AI model. Block 2 receives position data of the robot arm from Block 1 and analyzes whether the current position of the robot arm is within a reference range, and the AI ​​model can determine whether movement is necessary based on the position of the arm.

[0078] The source code execution module checks the parameters of the function corresponding to each block during the execution of the above blocks (step S220).

[0079] A source code execution module may execute a first block according to a parameter value, or transmit the command of each block to at least one of the corresponding device or AI module. Here, the first block may be the block currently being executed itself or another block.

[0080] A source code execution module can execute another block if the parameter value contains identification information of another block. If the function corresponding to the block is an operation function that uses the parameter value, the source code execution module can perform the operation corresponding to its own block using the parameter value.

[0081] The source code execution module has parameter values ​​set to data collectible from the device or to an AI model, and can transmit the block's command to at least one of the device or the AI ​​model (step S230).

[0082] The execution results of other blocks, the execution results of device commands, and the execution results of AI model commands are provided to the source code execution module. In particular, the execution results of the device may be provided to the source code execution module through a communication module matched to the device (step S240). The source code execution module proceeds with the execution of each block sequentially using the execution results, and when the execution of all blocks is completed, it outputs a result value as the output of the entire block code.

[0083]

[0084] FIGS. 3 to 6 are exemplary diagrams for explaining a device control process through block-based source code execution according to the present invention.

[0085] FIG. 3 illustrates a block structure source code (A) and an example of when this source code is converted into code data (B).

[0086] If a user writes source code of a block structure as in (A) using the device control system (100), the block code can be converted into code data as in (B).

[0087] When the block code of FIG. 3 is executed, the data processing process in each module of the device control system (100) and the device (200) is specifically illustrated in FIG. 4 to 6.

[0088] When the first block code of FIG. 3 is executed, the source code execution module executes the source code of two block structures, Block 1 and Block 2, as shown in FIG. 4, but executes Block 1 and Block 2 independently depending on the parameters. Block 1 has two parameters. That is, the two parameters are the first parameter parameter[0] = E for specifying the motor of the device (prime_0) and the second parameter parameter[1] = block2 (referring to the other block Block 2) for specifying the force sensor of the device (prime_0).

[0089] Among the parameters of Block 1, the parameter specifying the force sensor points to Block 2. This can be verified in parameter[1]. When Block 1 is executed, Block 2 is also executed sequentially. At this time, Block 1 is executed independently and then calls another block based on the result.

[0090] Block2 commands the task of reading data from the force sensor. This command is executed by the source code execution module and transmitted to the communication module, which then sends a command to Device_0 to return the sensing value of the force sensor being pressed.

[0091] When Block 2 is executed, the value specifying the force sensor corresponds to the first parameter in Block 2; therefore, the first parameter of Block 2, parameter[0] = A, and next, a command is executed requesting the force intensity (sensor value) of force sensor A from the device named 'Prime_0'. Here, the execution of the command means that the code data corresponding to the block code is converted into a format readable by the device and transmitted to the communication module (Prime_0) corresponding to the 'Prime_0' device. The communication module (Prime_0) stores the sensing values ​​periodically collected from the force sensor of the device (Prime_0), and upon receiving a command from the source code execution module following the execution of Block 2, provides the stored sensing values ​​of force sensor A to the source code execution module.

[0092] Figure 5 illustrates the data flow when the source code execution module executes Block 3. Block 3 has no parameters and calls an AI module as the target, rather than a device. The AI ​​module targeted in this block code is an AI module capable of classifying hand shapes, and the source code execution module sends an AI prediction execution request command to the AI ​​module. Upon receiving the AI ​​prediction execution request command, the AI ​​model performs hand shape classification and stores the result of predicting the hand shape of the image.

[0093] Figure 6 illustrates the data flow when a source code execution module executes Block 4, Block 5, and Block 6. In Figure 6, one of the parameters of Block 4 points to Block 5, and one of the parameters of Block 5 points to Block 6. After Block 4 is executed, the value of the first parameter parameter[0] is Block 5, so the source code execution module executes Block 5, and after Block 5 is executed, the value of the first parameter is 0 and the value of the second parameter parameter[1] is Block 6, so Block 6 is executed.

[0094] The first parameter of Block 6, parameter[0], is intended to specify the direction tilt value; since parameter[0] = heart, a tilt value in the heart direction is requested. Block 6 is a block code that requests the tilt sensor value of the device (G1_0). It receives the tilt sensor value from the communication module (G1_0) that receives data from the device (G1_0) and returns the sensor value. The returned sensing value is provided to Block 5 as the result of Block 6's execution. Block 5 executes an internal function according to the function characteristics of the block code to return a random value between 0 (the first parameter value) and the sensing value. The returned random value is provided to Block 4 as the result of Block 5's execution, and according to the function characteristics of Block 4's block code, an action to wait for a time (unit: seconds) equal to the returned random value is executed.

[0095]

[0096] Although the present invention has been described by the embodiments and drawings described above, the present invention is not limited to the above embodiments, and various modifications and variations are possible from this description by those skilled in the art to which the present invention pertains. Accordingly, the concept of the present invention should be understood only by the claims set forth below, and all equivalent or analogous variations thereof shall be considered to fall within the scope of the concept of the present invention.

Claims

1. A device control system through block-based source code execution that transmits commands of multiple blocks to corresponding devices, A source code execution module comprising a plurality of blocks, which transmits a command of each block to at least one of a corresponding device or AI module to execute the command and receives the execution result; One or more communication modules that transmit the above command to a pre-matched device or provide data received from the pre-matched device to the source code execution module according to the above command; The above device receives commands through the previously matched communication module, performs operations according to the received commands, or transmits data collected or generated by the device to the matched communication module regardless of the commands. The above communication module is, Receives and stores a sensing value from the above device, Transmitting the stored data when the previously matched device is in a state where it can receive data, or storing data received periodically or non-periodically from the previously matched device, and then delivering the stored data when the code execution module requests it. When the above communication module transmits a command corresponding to each block code to a device, it converts the command to match the communication method (protocol) of the device corresponding to each command, and The number of the above communication modules is determined by at least one of the number of devices or the number of device types. Device control system through block-based source code execution.

2. In Paragraph 1, The above source code execution module is It is configured to execute multiple blocks sequentially, and is characterized by the ability to re-execute by modifying only the block in the event that an error occurs in a specific block. Device control system through block-based source code execution.

3. In Paragraph 1, The above source code execution module is Characterized by assigning a command to a specific device through the communication module according to parameters set in each block, and controlling the device to execute the command. Device control system through block-based source code execution.

4. In Paragraph 3, The above source code execution module is Generating a device operation command using the sensing value according to the type of the above parameter and providing it to the device Device control system through block-based source code execution.

5. In Paragraph 1, The above AI module is Characterized by analyzing data collected from a device or source code execution module and providing the analysis results to the source code execution module. Device control system through block-based source code execution.

6. A method for controlling a device through block-based source code execution that transmits commands of multiple blocks to corresponding devices The source code execution module controls the device through block-based source code execution, and A step of generating source code composed of multiple blocks and executing each block; In executing each block, a step of executing a first block according to the parameter value of a function corresponding to each block, or transmitting the command of each block to at least one of the corresponding device or AI module; The method includes the step of receiving an execution result through a communication module matched to the device and outputting a result value when the execution of all blocks is completed. The above communication module is, Receives and stores a sensing value from the above device, Transmitting the stored data when the previously matched device is in a state where it can receive data, or storing data received periodically or non-periodically from the previously matched device, and then delivering the stored data when the code execution module requests it. When the above communication module transmits a command corresponding to each block code to a device, it converts the command to match the communication method (protocol) of the device corresponding to each command, and The number of the above communication modules is determined by at least one of the number of devices or the number of device types. Device control method through block-based source code execution.

7. In Paragraph 6, The step in which the above source code execution module generates source code composed of multiple blocks and executes each block The above source code execution module is characterized by including a step of sequentially executing a plurality of blocks and, if an error occurs in a specific block, modifying only that block and re-executing it. Device control method through block-based source code execution.

8. In Paragraph 6, The above source code execution module further includes the step of assigning a command to a specific device through the communication module according to parameters set in each block, and controlling the device to execute the command. Device control method through block-based source code execution.

9. In Paragraph 8, The step of controlling the said device to perform a command When the communication module receives and stores a sensing value from the corresponding device, a step of generating a device operation command by applying the sensing value to the parameter value; Characterized by including the step of providing the above device operation command to the corresponding device. Device control method through block-based source code execution.

10. In Paragraph 6, The step of executing a first block according to the parameter value or transmitting the command of each block to at least one of the corresponding device or AI module if a parameter exists during the process in which the source code execution module executes each block is A step of executing another block if the above parameter value includes identification information of another block; If the function corresponding to the above block is a function that transmits a command to a device, the step of transmitting a command to a device or AI module corresponding to the parameter value of the function is included. Device control method through block-based source code execution.

Images