KR20190060561A - THE INTERGRATED IoT PROGRAMMING METHOD AND SYSTEM WITH SELECTIVE ABSTRACTION OF THIRD-PARTY DEVICES - Google Patents

Abstract

The present invention relates to a method for integrating development environments of an Internet of Things (IoT) application via selective abstraction of heterogeneous devices and a system thereof. According to an embodiment of the present invention, the method for integrating development environments of an IoT application comprises the steps of: generating source codes via a code generation unit for implementing each of sub programs of a device to be operated through IoT with objects of one object oriented program using a predetermined programming language; analyzing and compiling the generated source codes via a compile unit to generate a program for the device to be operated through IoT; and controlling the device to be operated through IoT based on the generated program. The present invention can reduce the amount of program codes and reduce execution costs.

Description

TECHNICAL FIELD [0001] The present invention relates to a method and system for integrating a development environment of an object Internet application through selective abstraction of heterogeneous devices.

The present invention relates to a method and system for integrating a development environment of object Internet applications through selective abstraction of heterogeneous devices, and more particularly, to a method and system for integrating a development environment of object Internet applications by using abstraction of Object Oriented Programming (OOP) And a method and system for selectively abstracting various heterogeneous devices in an object internet environment and integrating various development environments for each device into one.

Since the object Internet application provides a service by a plurality of heterogeneous devices in cooperation, a developer generally has to implement each sub-program for various object Internet devices. Since each subprogram sends and receives signals and data from heterogeneous devices that are physically distributed, the developer can write code according to the characteristics of heterogeneous devices, data synchronization in a distributed environment, and communication code Additional consideration should be given to writing.

To reduce the burden on developers, IT companies and developers have proposed several integrated Internet application development environments. The Integrated Object Internet Application Development Model integrates the development environment of various devices, communication and synchronization between devices into one programming environment, so that developers can develop Internet applications of things as if they are developing programs that operate in a single computing environment. do. Through the integrated object Internet application development environment, the developer can view the program flow, data communication and synchronization model for the whole Internet service of objects, and some development environment also provides a visual programming development environment through GUI. However, the existing integrated development environment has a disadvantage that it does not support selective abstraction of object Internet devices or simplification of communication techniques through function calls.

In order to efficiently integrate heterogeneous devices in the Internet environment, the integrated development environment requires a selective abstraction of the Internet devices. Since the functions of the same product group differ depending on the manufacturer or model, and the interface is different, the developer has a burden to write the corresponding program in various versions in order to support various devices. To reduce this burden, the integrated Internet application development environment should be abstracted with common functions for each product group, and the various interfaces for each device should be unified into one. However, when all devices are abstracted, the abstraction is performed with standardized interfaces even for devices that do not require abstraction, thereby increasing the burden on the developer. Therefore, there is a need for an optional abstraction technique that abstracts only the product families with multiple products.

In addition, the integrated Internet application development environment requires a technique to simplify communication and synchronization between devices. Since the object Internet service sends and receives data between several devices and cooperatively provides one service, the developer must write the communication and synchronization code between devices in a distributed environment. Such inter-device communication and synchronization make programming difficult and error prone to deadlocks. Therefore, the integrated Internet application development environment should support the function of automatically inserting or simplifying communication and synchronization between devices.

Korean Patent Registration No. 10-0280827 (November 13, 2000)

The object of the present invention is to solve the above-mentioned problems and to provide a method and apparatus for object-oriented programming (OOP) The goal of this paper is to propose an integrated Internet development environment based on object - oriented programming.

Especially, it is an object of the present invention to provide an optional abstraction technique in which a developer efficiently manages heterogeneous devices in an integrated development environment, and a distributed device integration method that can easily program communication and synchronization in a distributed device.

In order to integrate the development environment of the object Internet application through the selective abstraction of the heterogeneous device according to the embodiment of the present invention, A step of generating source code for implementation as objects of one object-oriented program through a code generation unit, a step of analyzing and compiling the generated source code through a compiler, And controlling the device to be operated via the object Internet based on the generated program.

The syntax of a given programming language according to an embodiment of the present invention includes a first pragma for declaring a class to be compiled into a program and a mapping between a class and a device operated through the object Internet And a third indicator for enabling selective abstraction of heterogeneous devices using a hierarchy between classes.

The class according to an embodiment of the present invention includes an ancestor class for defining a common interface of a device operated through the object Internet and a subclass for implementing a detailed function of each device operated through the object Internet descendant class) may be included.

The generated source code according to an embodiment of the present invention is analyzed and compiled through a compiler to generate a program for a device operated through the object Internet. The source code is analyzed through a marker of the compiling unit The source code is converted into a code that can be executed regardless of devices operated on the object Internet, the code converted by the partitioner of the compiling unit is divided into codes for devices operated through the object Internet, Further comprising the step of inserting and translating the communication instruction into the code and the step of compiling the code segmented by the customizer of the compiler based on the architecture information for the device operated through the object internet .

The step of controlling devices operated through the object Internet based on the generated program according to an embodiment of the present invention includes a step of registering a device operated through the object Internet in a program generated through the device management unit, May be further included.

The step of controlling the devices operated through the object Internet based on the generated program according to an embodiment of the present invention includes a step of mapping an object of the program generated through the communication management unit to a device operated through the object Internet, This managed step may be further included.

The step of controlling the devices operated through the object Internet based on the generated program according to the embodiment of the present invention further includes a step of supporting and managing the shared memory of the heterogeneous device through the memory management unit, The shared memory may be a virtual memory space using IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM).

In the development environment integration system of the object Internet application through the selective abstraction of the heterogeneous device according to the embodiment of the present invention, the subprograms of the device operated through the object Internet are classified into one object A compiling unit for generating a program for a device operated through the object Internet by analyzing and compiling the generated source code to generate source code to be implemented by the objects of the oriented program, A device management unit for registering a device operated through the object Internet on the program and selectively abstracting the heterogeneous devices, a communication management unit for mapping the generated program object to a device operated on the object Internet, and managing communication between the objects, Shared memory And a memory management unit for supporting and managing the memory.

The syntax of a given programming language according to an embodiment of the present invention includes a first pragma for declaring a class to be compiled into a program and a mapping between a class and a device operated through the object Internet And a third indicator for enabling selective abstraction of heterogeneous devices using a hierarchy between classes.

The class according to an embodiment of the present invention includes an ancestor class for defining a common interface of a device operated through the object Internet and a subclass for implementing a detailed function of each device operated through the object Internet descendant class) may be included.

The compiling unit according to an embodiment of the present invention includes a marker for analyzing the source code and converting the source code into a code that can be executed regardless of devices operated on the object Internet, A partitioner for dividing each of the code into a code for a device operated through the Internet and inserting and converting a communication command into the divided code, and a partitioner for dividing the divided code into architecture information for a device operated over the Internet And may further include a customizer for compiling.

The shared memory of the heterogeneous device according to an exemplary embodiment of the present invention may be a virtual memory space using IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM).

According to another aspect of the present invention, there is provided a computer-readable recording medium storing a program for causing a computer to execute the above-described method.

According to the user-poisoning diagnosis method and system provided as one embodiment of the present invention, it is possible to selectively apply an abstraction characteristic of object-oriented programming (OOP) according to the kind of a device and a need of a programmer, thereby reducing unnecessary abstraction Various devices can be appropriately abstracted and managed. This reduces the amount of program code and reduces runtime costs over the use of fixed-standard abstractions.

In addition, according to the method and system for diagnosing user's poisoning provided as an embodiment of the present invention, a programmer can easily program communication and synchronization between heterogeneous devices in an integrated Internet application development environment to improve user convenience .

FIG. 1A is a flowchart illustrating a method for integrating a development environment of an object Internet application according to an embodiment of the present invention.
FIG. 1B is a flowchart illustrating a method of analyzing source code and generating a program by compiling source code among methods of integrating a development environment of a thing Internet application according to an embodiment of the present invention.
FIG. 1C is a flowchart illustrating a method for controlling an object Internet device in a method for integrating a development environment of an object Internet application according to an exemplary embodiment of the present invention. Referring to FIG.
FIG. 2 shows an example of a code of a thing Internet application created according to an embodiment of the present invention.
FIG. 3 is a block diagram illustrating a compiling process of a development environment integration system for an object Internet application according to an exemplary embodiment of the present invention. Referring to FIG.
FIG. 4 shows an example of a code for an object Internet device operating in accordance with an embodiment of the present invention.
FIG. 5 is a block diagram illustrating a development environment integration system of a () object Internet application according to an embodiment of the present invention, and (b) a compiling unit of a development environment integration system of the object Internet application.
FIG. 6 is a block diagram illustrating an overall operation of an application development environment integration system for the Internet of Things according to an embodiment of the present invention. Referring to FIG.
FIG. 7 is a block diagram of a conventional object Internet application development system and another example of a block diagram of a development environment integration system for an object Internet application according to an embodiment of the present invention.

The terms used in this specification will be briefly described and the present invention will be described in detail.

While the present invention has been described in connection with what is presently considered to be the most practical and preferred embodiment, it is to be understood that the invention is not limited to the disclosed embodiments. Also, in certain cases, there may be a term selected arbitrarily by the applicant, in which case the meaning thereof will be described in detail in the description of the corresponding invention. Therefore, the term used in the present invention should be defined based on the meaning of the term, not on the name of a simple term, but on the entire contents of the present invention.

When an element is referred to as " including " an element throughout the specification, it is to be understood that the element may include other elements as well, without departing from the spirit or scope of the present invention. Also, the terms " part, " " module, " and the like described in the specification mean units for processing at least one function or operation, which may be implemented in hardware or software or a combination of hardware and software .

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings, which will be readily apparent to those skilled in the art. The present invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. In order to clearly illustrate the present invention, parts not related to the description are omitted, and similar parts are denoted by like reference characters throughout the specification.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

FIG. 1A is a flowchart illustrating a method of integrating a development environment of a thing Internet application according to an embodiment of the present invention. FIG. 1B is a flowchart illustrating a method of integrating a development environment of a thing Internet application according to an embodiment of the present invention. FIG. 1C is a flow chart illustrating a method for controlling an object Internet device in a method of integrating a development environment of an object Internet application according to an exemplary embodiment of the present invention. Referring to FIG.

Referring to FIG. 1, a method for integrating a development environment of an object Internet application through selective abstraction of a heterogeneous device according to an embodiment of the present invention includes integrating a development environment The source code for implementing each of the subprograms of one object-oriented program is generated through the code generator 110 (S110), and the generated source code is analyzed through the compiler 120 Compiling the program to create a program for a device to be operated through the object Internet (S120), and controlling a device to be operated over the object Internet based on the generated program (S130).

Abstraction refers to the trimming of core concepts or functions from complex data, modules, systems, etc. in the art to which the present invention pertains. In other words, abstraction means combining necessary parts and important parts into one, and has the direction to integrate various elements into one. If you use abstraction to express key things in a short time, you can recognize complex contents at a glance, and it is easy to understand.

In other words, according to the embodiment of the present invention, it is possible to integrate common functions for the product groups of each object Internet device through such an abstracting operation to unify various interfaces for each device, and to perform abstraction on devices that do not need abstraction It is possible to proceed with the selective abstraction of the abstraction only for the product group having many devices, thereby reducing the burden on the user and improving the convenience.

In addition, according to an embodiment of the present invention, not only can each of the subprograms driven in the object Internet device be implemented as objects of one object oriented program through a predetermined programming language (Esperanto language) Communication between objects Internet devices can be implemented as function calls between classes, and it is possible to support object Internet device abstraction using the inheritance relationship of object-oriented programs.

In addition, certain programming languages (Esperanto, Esperanto) extend the C ++ language, but the meaning is not limited by the C ++ language, as it does not require the specific functions of the C ++ language.

FIG. 2 is a diagram illustrating (a) an example of a code for an object Internet application including a syntax of a predetermined programming language (Esperanto language) created according to an embodiment of the present invention, (b) an object according to an embodiment of the present invention An example of declaration of a class to which an optional abstraction of an Internet device is applied is shown.

Referring to FIG. 2, a syntax of a predetermined programming language (Esperanto) according to an exemplary embodiment of the present invention includes a first indicator p1 for declaring a class to be compiled into a program, A second indicator c2 for mapping classes and devices operating over the Internet and a third indicator c3 for enabling selective abstraction of heterogeneous devices using a hierarchy between classes .

The class according to an embodiment of the present invention includes an ancestor class for defining a common interface of a device operated through the object Internet and a subclass for implementing a detailed function of each device operated through the object Internet descendant class) may be included. Each class can be implemented using the inheritance relation of object-oriented programming. The object Internet device can be controlled by using the abstracted interface through the superclass, and a device in the user environment can be controlled through the system 100, So that the user can control various devices by connecting the binaries of the subclass in which the detailed function is specified.

Referring to Fig. 2, the first indicator c1 may be called EspDevDecl, and the first indicator EspDevDecl c1 may declare a device capable of being programmed with a name (devlD), a constructor and a destructor. Constructors and destructors can be called sequentially at the beginning and end of a device's subprograms. For example, a programmable device such as a CAM (IP camera) and a Phone with a constructor and a destructor can be declared as in FIG. 2 (a). At this time, the first indicator (EspDevDecl) (c1) can be allowed only to the programmable device since the compiler generates the sub-program binary for the annotated first indicator (EspDevDecl) (c1) device.

Referring to FIG. 2, the second indicator c2 may be referred to as EspDevice, and the second indicator EspDevice c2 may be mapped to the device on which the annotated class is declared. The second directive (EspDevice) (c2) is always located above the class declaration and can be concatenated with the name of the device contained in the statement directly below it and can be associated with the name contained in the first directive (EspDevDecl) (c1) have. For example, the user can install the IPCamera class in the Cam device using the second indicator (EspDevice) (c2) annotation as shown in line 10 of FIG. 2 (a). At this time, the user must insert comments only for the code that should be executed on the device, and when given a comment, the compiler can automatically map the non-annotation command to the appropriate object Internet device according to the performance evaluation result.

In addition, the second indicator EspDevice c2 may optionally include a conditional statement, which may express the value of the hardware variable. That is, the second indicator c2 can additionally specify the corresponding physical device by transferring the condition of the device as an argument. Things To build an Internet development environment requires a description of each device's hardware, such as device type, vendor, model, architecture, and operating system, so use the second directive (EspDevice) (c2) You can map to the appropriate device. For example, referring to FIG. 2 (b), a user of a Bulb device annotates the class with the vendor and model runtime variables (2 lines in Hue.h and lines 2 and 9 in LIFX.h) And the Hue, LIFX, and LIFXZ classes can be mapped to corresponding physical devices such as Hue, LIFX, and LIFXZ smartbulbs through the object Internet development environment system 100 described below according to annotated conditions.

Referring to FIG. 2, the third indicator c3 may be called EspImport, the third indicator EspImport c3 may be used to connect classes declared by the second indicator EspDevice c2 from the outside , A class name, and a function name. For example, using the third indicator (EspImport) (c3) and the import function via the system 100 described below, the object Internet application can use a disparate device that can not be programmed, such as Hue and LIFX bulbs.

Referring to FIG. 2 (a), a third indicator (EspImport) (c3) can generate an import function (line 7) for binding all className devices. The import function acquires the className object Can return. Thus, a user can specify a specific type of device by passing the class type as an argument of className. For example, if a user uses LIFX as the first argument instead of SmartBulb, the imported function returns the associated LIFX and LIFXZ objects, but not the Hue object.

2 (a) through FIG. 2 (a), the object Internet application shown in FIG. 2 (a) is an application that IPCamera detects when the baby is crying and informs the mobile device via SmartBulb. An object-oriented program (OOP) composed of IPCamera and Mobile classes is shown along with a predetermined programming language (hereinafter Esperanto language). The IPCamera and Mobile classes are connected to Cam and Phone devices, respectively, via a second indicator (EspDevivce) (c2), and the cam_ctor and m_ctor constructors included in the first indicator (EspDevDecl) (c1) Omitted) to implement the main function.

Also, the SmartBulb class is connected via the getBulbs function through the third indicator (EspImport) (c3). The cam of the IPCamera pointer type declared as a global variable, the variable m_list of the list of the mobile pointer, the bulbs of the SmartBulb double pointer type, and the integer variable num_bulbs are shared by both Cam and Phone devices. can see. If you look at the cam_ctor function, which is the creator of the device Cam, you initialize the IPCamera pointer variable cam to the IPCamera object created with the new keyword and initialize the bulbs variable with the getBulbs function. The getBulbs function is a function declared through EspImport that finds a device that runs an executable created from a SmartBulb class or a subclass and returns it in SmartBulb double pointer format. IPCamera's onBabyCry function works when the Cam device determines that the baby is crying, calls the alarm function of the currently connected Phone device, and calls the blink function of the currently connected SmarBulb device. The m_ctor function, which acts as the creator of the device phone, initializes the m pointer type variable m to the Mobile object created with the new keyword, and adds the value to the m_list.

2B shows an example of declaration of SmartBulb and its subclasses connected through a third indicator EspImport (c3) of FIG. 2 (a) . In FIG. 2 (b), SmartBulb class, Hue, LIFX class inheriting it, and LIFXZ class inheriting LIFX are declared. Each class is expressed using a second indicator (EspDevice) (c2) The hierarchy and conditional statements are known on the system 100 to be described later and can be used when searching for devices.

FIG. 3 is a block diagram illustrating a compiling process of the development environment integration system 100 of the object Internet application according to an embodiment of the present invention.

Referring to FIG. 3, in step S120, the generated source code according to an embodiment of the present invention is analyzed and compiled through the compiling unit 120 to generate a program for a device operated on the object Internet, A step S121 in which the source code is analyzed through a marker 121 of the compiling unit 120 so that the source code is converted into a code that can be executed regardless of the device operated on the object Internet, A step S122 in which the converted code is divided into a code for a device operated through the object Internet and a communication command is inserted and converted into the divided code through the partitioner 122 of the compiler 120, (S123) in which the divided code is compiled through a customizer 123 of the Internet based on architecture information for a device operated over the Internet.

In the step S121 of analyzing and converting the source code through the marker 121 of the compiling unit 120, the front-end and IR code conversion that can be performed irrespective of the object Internet device on which the final executable file is run can be performed have. In this case, the first thing to do is to extract the information and convert it into IR code by interpreting the Esperanto language in an object-oriented program (OOP) written using the Esperanto language. Then, static analysis is performed on the created IR code to indicate the device on which the IR code that will not be displayed on the second indicator (EspDevice) (c2) is to be driven. In this process, the functions of the constructor, the destructor, and the marked class for each device are the criteria, and the IR code can be distinguished by minimizing the remote function call indicated by the function call of the class. In addition, an IR code may be inserted to register the result of a new keyword in the framework so that the heap memory address of the object can be used as an identifier of each device.

In the step S122 in which the converted code is divided through the partitioner 122 of the compiling unit 120 and the communication command is inserted and converted, the IR code is allowed to operate on each of the object Internet devices through the partitioner 122 Can be converted. Each class, that is, a network communication that enables function call codes between devices to be converted into network communication codes to enable real remote function calls, and which is driven by a third indicator (EspImport) (c3) You can insert code. In order to support IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM) described later, a network communication code is inserted into the global and heap memories so that all the devices can see a consistent memory. Finally, IR Optimized code can be generated by deleting unnecessary parts of each device in the code.

In step S123, in which the divided code is compiled through the customizer 123 of the compiling unit 120 based on the architecture information of the device operated on the object Internet, the customizer 123 123 may compile the compiled code for each object Internet device based on the architectural information of the devices.

FIG. 4 (a) shows the final result of compiling the code for Cam and Phone through the compiler 120 in the example of FIG. Specifically, the main function is automatically generated through the constructor and the destructor, and the mapObjDev function calling code for registering the result on the new keyword on the system 100 to be described later can be inserted. In addition, a function call from IPCamera to Mobile can be replaced with a network communication function, send, to implement a remote function call from Cam to Phone. In the code for the Phone, the communicationHandler function is automatically implemented so that the Phone can be configured to respond to remote function calls from Cam. Finally, the definition of the getBulbs function, which returns the SmartBulb double pointer type, can be created automatically, and the newly declared __getSmartBulb function can be called to retrieve and return the devices connected to the actual runtime.

FIG. 4B shows a result of automatic implementation of the __getSmartBulb function, and the function __getSmartBulb is a function that retrieves and returns a device corresponding to the SmartBulb and the subclasses shown in FIG. 2B at runtime. SmartBulb has a condition of TYPE == BULB according to FIG. 2 (b). Therefore, SmartBulb subclasses can satisfy the condition TYPE == BULB by hierarchy. __getSmartBulb can store the number of SmartBulbs and subclasses of devices connected to it at runtime in the size variable by using getNumDev function. You can also find the most subclass type of the found devices and create an object and return the pointer as an array type.

Referring to FIG. 1 (c), in operation S 130, devices operated through the object Internet on the basis of the generated program according to an embodiment of the present invention, (S131) in which a device operated through the object Internet is registered and a heterogeneous device is selectively abstracted.

In a step S131 in which a device operated through the object Internet is registered in the program generated through the device management unit 130 and the heterogeneous device is selectively abstracted, when the new object internet device is connected to the user environment, the device management unit 130 The collection of hardware descriptions for devices such as IP address, device type, vendor, architecture, and operating system can be made. In addition, a software description including all superclasses of devices connected through the device management unit 130 to support abstraction of the device can be maintained. In addition, when one of the super classes is imported using the third indicator EspImport (c3), the software description is confirmed through the device management unit 130, the connected device is returned, and an object suitable for the device having the hardware description is created Can be.

For example, referring to FIG. 4 (b), the getSmartBulb function may request that the SmartBulb search for a disparate device that is a superclass. The device management unit 130 can find a sub class of SmartBulb from the software description and return a connected device list from a hardware description such as Hue, LIFX and LIFXZ. As shown in FIG. 4 (b), the getSmartBulb function can create and return a corresponding subobject for a device in the list.

Referring to FIG. 1C, in step S130 of controlling devices operated through the object Internet based on the generated program according to an embodiment of the present invention, a program generated through the communication management unit 140 (S132) in which an object of the object is mapped to a device operated through the object's internet and communication between the objects is managed (S132).

In step S132, the object of the program generated through the communication management unit 140 is mapped to a device operated through the object's internet and the communication between the objects is managed (S132), a second indicator EspDevice c2 is transmitted through the above- When the object-to-device mapping call function (mapObjDev) for the allocated object is inserted and called, a new element can be inserted on the object-device map via the communication management unit 140. Also,

Referring to FIG. 1 (c), in operation S 130 of controlling devices operated through the object Internet based on a generated program according to an embodiment of the present invention, a memory management unit 150 manages The shared memory of the heterogeneous device may be a virtual memory space using IoT-heterogeneous distributed shared memory (IoT-HDSM).

 IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM) can provide an integrated virtual memory space for heterogeneous distributed devices and can support the synchronization and consistency of variables. Because heterogeneous distributed shared memory allows virtual memory space to be shared across devices, all objects can have unique memory addresses. Therefore, the memory address of the object is used as the identifier of the object Internet device, so that the device of the same kind can be found by the memory address. Also, the registration of the object Internet device on the system 100 may be made by allocating memory, and the withdrawal may be by memory deletion.

FIG. 5 is a block diagram illustrating (a) a development environment integration system 100 of a thing Internet application according to an embodiment of the present invention, (b) a compiling unit 120 among the development environment integration system 100 of a thing Internet application, Fig.

Referring to FIG. 5A, the development environment integration system 100 of the object Internet application through the selective abstraction of the heterogeneous device according to an embodiment of the present invention includes an object Internet A source code generation unit 110 for generating source code for implementing sub-programs of a device operated through an object-oriented program as objects of one object-oriented program, and a source code generation unit 110 for analyzing and compiling the generated source code, A device management unit 130 for registering a device operated through the object Internet in the generated program and selectively abstracting the heterogeneous devices, Objects Communication with devices that operate over the Internet and to manage communication between objects Rib may include a memory management unit (150) for supporting and managing unit 140 and the shared memory of heterogeneous devices.

The syntax of a given programming language according to an embodiment of the present invention includes a first indicator p1 for declaring a class to be compiled into a program, a mapping between a class and a device operated through the object Internet a second indicator c2 for the mapping between the classes, and a third indicator c3 for enabling the selective abstraction of the heterogeneous devices using the hierarchical structure between the classes.

The class according to an embodiment of the present invention includes an ancestor class for defining a common interface of a device operated through the object Internet and a subclass for implementing a detailed function of each device operated through the object Internet descendant class) may be included.

Referring to FIG. 3, a compiler 120 according to an embodiment of the present invention includes a marker for analyzing a source code and converting the source code into a code that can be executed regardless of a device operated on the object Internet A partitioner 122 for dividing the converted code into codes for devices operated through the object Internet, inserting and converting communication commands into the divided codes, and a partitioner 122 for dividing the divided codes into object objects A customizer 123 for compiling on the basis of architecture information for a device operated via a network interface (not shown).

A marker 121 according to an embodiment of the present invention may analyze a predetermined programming language and map all instructions of a program to a target device. 3, the marker 121 may include a parser, a mark inferrer, and an object mapper.

A parser according to an embodiment of the present invention recognizes the Esperanto syntax and can display all commands of the annotated class of the device as the target device. For example, the parser can mark the IPCamera class and its member functions as cam devices.

A mark inferrer according to an embodiment of the present invention may display all unannotated commands. Since the user does not mark the command as a comment on the specific device, the command can be placed on all the devices. That is, the mark evictor can evaluate the performance of the target device as possible and annotate the command with the optimal device.

The object mapper according to the embodiment of the present invention can insert a call instruction of mapObjDev in a place where a first indicator (EspDevDecl) (c1) annotated object is allocated. The mapObjDev function may register a pointer to the newly allocated memory object and the current network IP address to the object-device map on the system 100. Using the object-device map, the system 100 can find the correct target device from the memory object pointer. If the object does not have a device annotation, the object mapper does not insert the call instruction of mapObjDev.

A partitioner 122 according to one embodiment of the present invention may automatically partition the program into various sub-programs for each object Internet device and insert communication commands. For example, FIG. 4 (a) shows how the partitioner 122 divides the Esperanto program into several sub-programs. First, the partitioner 122 replaces all remote function call sites with network communication function calls (line 23). The partitioner 122 passes the memory address of the callee object as the first argument of the send function. Since the mapObjDev registers the object address with the IP address, the communication management unit 140 can find the destination IP address from the object address. Then, the partitioner 122 creates various sub-programs and deletes the unmarked commands in each sub-program. Finally, the partitioner 122 incorporates disparate memory layouts such as structure alignment, pointer size, and endianness at other object Internet devices.

A customizer 123 according to one embodiment of the present invention can maintain a set of backend compilers and customize each sub-program for each object Internet device. Describing the target device as a compilation input, the corresponding back-end compiler is selected through the compiling unit 120 and the sub-program can be compiled together with the corresponding back-end compiler. If you have code that works only on certain hardware, the customizer (123) can optimize the code with the backend compiler.

That is, the compiling unit 120 according to an embodiment of the present invention may insert a translation code for integrating different memory structures, memory address sizes, and endianness among the object Internet devices, Can minimize the cost of managing shared memory. Also, the compiling unit 120 may insert an object-to-device mapping calling function mapObjDev for the object to which the second directive EspDevice c2 is allocated, and store the instruction of the remote calling function of the object in the object memory pointer To a communication call function (send) that passes the argument as an argument.

FIG. 6 is a block diagram illustrating an overall operation of an application development environment integration system 100 according to an embodiment of the present invention.

Referring to FIG. 6, a device management unit 130 according to an embodiment of the present invention includes a device management unit 130 for managing a device description such as an IP address, a device type, a supplier, an architecture, and an operating system Can be collected. Also, if a generated program searches for a device through a runtime condition such as TYPE == BULB, the device manager can retrieve the device from the hardware description and maintain a software description containing all the superclasses of the connected device. have. In addition, when the device manager 130 obtains one of the superclasses using the third indicator EspImport c3, it can check the software description, return the connected device, and create an object suitable for the device having the hardware description have.

Referring to FIG. 6, when a communication call function (send) is called according to an embodiment of the present invention, the device management unit 130 finds the corresponding IP address having the memory address of the transferred object in the object-device map, Address to an IP address, and then the communication management unit 140 can send the message to the target IP address.

The shared memory of the heterogeneous device according to an exemplary embodiment of the present invention may be a virtual memory space using IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM).

FIG. 7 is a block diagram of a conventional object Internet application development system 100 and another example of a block diagram of a development environment integration system 100 according to an embodiment of the present invention. The gray portions in FIG. 7 represent programs that the user has to create. 7 (c) is a block diagram of an object Internet application development environment integration system 100 according to an embodiment of the present invention, and is a block diagram of a conventional object Internet application development system 100, ) And (b), it can be confirmed that the number of programs to be created by the user is small, and the connection between the object and the device is simplified, and the convenience of the user is improved.

The contents of the above-described method can be applied in connection with the system 100 according to an embodiment of the present invention. Accordingly, the description of the same contents as those of the above-described method with respect to the system 100 is omitted.

According to another aspect of the present invention, there is provided a computer-readable recording medium storing a program for causing a computer to execute the above-described method. In other words, the above-described method can be implemented in a general-purpose digital computer that can be created as a program that can be executed in a computer and operates the program using a computer-readable medium. Further, the structure of the data used in the above-described method can be recorded on a computer-readable medium through various means. Recording media that record executable computer programs or code for carrying out the various methods of the present invention should not be understood to include transient objects such as carrier waves or signals. The computer-readable medium may comprise a storage medium such as a magnetic storage medium (e.g., ROM, floppy disk, hard disk, etc.), optical readable medium (e.g., CD ROM, DVD, etc.).

It will be understood by those skilled in the art that the foregoing description of the present invention is for illustrative purposes only and that those of ordinary skill in the art can readily understand that various changes and modifications may be made without departing from the spirit or essential characteristics of the present invention. will be. It is therefore to be understood that the above-described embodiments are illustrative in all aspects and not restrictive. For example, each component described as a single entity may be distributed and implemented, and components described as being distributed may also be implemented in a combined form.

It is intended that the present invention covers the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents. .

100: User application development environment integration system
110: code generation unit 120:
121: Marker 122: Partitioner
123: CUSTOMER 130: DEVICE MANAGER
140: communication management unit 150: memory management unit

Claims (13)

1. A method for integrating a development environment of an object Internet application through selective abstraction of heterogeneous devices,
Generating source codes for implementing each of the subprograms of the device to be operated through the object Internet as objects of one object-oriented program through a code generator using a predetermined programming language;
Analyzing and compiling the generated source code through a compiler to generate a program for a device to be operated over the Internet; And
And controlling a device to be operated on the object Internet based on the generated program.
The method according to claim 1,
In the syntax of the predetermined programming language,
A first indicator (pragma) for declaring a class to be compiled with the program;
A second indicator for mapping between the class and a device operated over the Internet; And
And a third indicator for enabling selective abstraction of the heterogeneous devices using the hierarchical structure between the classes.
3. The method of claim 2,
The class includes: an ancestor class for defining a common interface of devices operated through the Internet; And a descendant class for implementing a detailed function of each device operated through the object Internet. ≪ Desc / Clms Page number 19 >
The method according to claim 1,
Analyzing and compiling the generated source code through the compiling unit to generate a program for a device operated through the Internet,
Analyzing the source code through a marker of the compiling unit and converting the source code into a code that can be executed regardless of a device operated on the object Internet;
Wherein the converted code is divided into a code for a device operated through the Internet and a communication command is inserted and converted into the divided code through a partitioner of the compiling unit; And
And a step of compiling the divided code on the basis of architecture information for a device operated through the Internet through a customizer of the compiling unit. How to.
The method according to claim 1,
Controlling devices operated through the Internet based on the generated program includes the steps of:
Further comprising the step of registering a device operated on the object Internet through the device management unit and selectively abstracting the heterogeneous device to the generated program.
The method according to claim 1,
Controlling devices operated through the Internet based on the generated program includes the steps of:
Further comprising the step of managing an object of the generated program by a communication management unit with a device operated through the Internet, and managing communication between the objects.
The method according to claim 1,
Controlling devices operated through the Internet based on the generated program includes the steps of:
The shared memory of the heterogeneous device is supported and managed through the memory management unit,
Wherein the shared memory of the heterogeneous device is a virtual memory space using IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM).
In a development environment integration system for object Internet applications through selective abstraction of heterogeneous devices,
A code generation unit for generating source code for implementing sub-programs of devices operated through the object Internet using objects of a single object-oriented program using a predetermined programming language;
A compiling unit for analyzing and compiling the generated source code to generate a program for a device operated over the Internet;
A device management unit for registering a device operated through the Internet on the generated program and selectively abstracting the heterogeneous devices;
A communication manager for mapping an object of the generated program to a device operated through the Internet, and managing communication between the objects; And
And a memory management unit for supporting and managing the shared memory of the heterogeneous device.
9. The method of claim 8,
In the syntax of the predetermined programming language,
A first indicator (pragma) for declaring a class to be compiled with the program;
A second indicator for mapping between the class and a device operated over the Internet; And
And a third indicator for enabling selective abstraction of the heterogeneous device using the hierarchical structure between the classes.
10. The method of claim 9,
The class includes: an ancestor class for defining a common interface of devices operated through the Internet; And a descendant class for implementing a detailed function of each device operated through the object Internet.
9. The method of claim 8,
Wherein the compiling unit includes: a marker for analyzing the source code and converting the source code into a code that can be executed regardless of a device operated through the Internet;
A partitioner for dividing the converted code into a code for a device operated through the Internet and inserting and converting a communication command into the divided code; And
Further comprising a customizer for compiling the divided code on the basis of architecture information for a device operated through the Internet.
9. The method of claim 8,
Wherein the shared memory of the heterogeneous device is a virtual memory space using IoT-Heterogeneous Distributed Shared Memory (IoT-HDSM).
8. A computer-readable recording medium on which a program for implementing the method of any one of claims 1 to 7 is recorded.

Images