KR100882877B1 - Computer-readable medium having interface definition language between embedded device and host server and generating method of source code - Google Patents

Abstract

The present invention provides a computer-readable recording medium storing an interface definition language structure for defining an interface protocol between an interoperable host server and an embedded device and generating basic program source code for each device. A source code generator setting unit including a definition of a data type exchanged between a server and an embedded device, a service mapping setting unit including mapping information for calling a service providing function of the host server and the embedded device, the host server and Interface definition between heterogeneous digital devices including a service definition unit for defining individual services to be provided by the embedded device A computer readable recording medium storing a language structure and a source for extracting information from the language structure to generate basic source code. Provide code generation methods.

According to the present invention, it is very easy to create a program for interworking in heterogeneous digital devices such as a host server and an embedded device.

XML, interface, function, source code

Description

Computer-readable medium having interface definition language between embedded device and host server and generating method of source code}

1 is a conceptual diagram illustrating a program code generation process according to the present invention.

2 is a structural diagram illustrating an interface definition language structure using XML according to the present invention;

Figure 3 is a block diagram showing the configuration and results of the protocol source code generator according to the present invention.

4 is a schematic diagram showing a mapping relationship between an XML interface definition document and a service handler header file according to the present invention.

5 is a schematic diagram showing a mapping relationship between an XML interface definition document and a service handler implementation file according to the present invention.

6 is a schematic diagram illustrating a mapping relationship between an XML interface definition document and a message handler implementation file.

The present invention relates to a computer-readable recording medium and a method for generating a source code, in which a language definition interface between an XML-based host server and an embedded device is stored, and in particular, an XML-based standard interface requiring a communication protocol between the host server and an embedded device. A computer-readable recording medium having a definition language stored therein and a method for generating basic source code for implementing a protocol using the same.

Recently, the information appliance industry is rapidly developing due to the increase of interest in ubiquitous society and the activation of home-network, and the demand for embedded devices for the intelligentization of home appliances and industrial devices is increasing. In addition, these intelligent embedded devices often provide additional services through interaction with other peripheral devices or the host server rather than operating individually.

As a result, the development of various communication protocols for the interaction between embedded devices or between the embedded devices and the host server frequently occurs. However, due to the lack of a standardized development methodology or a standard development environment, a large amount of time and money are consumed for simple repetitive tasks. It is becoming.

Implementing Communication Protocols between Embedded Devices and Host Servers The process of a project may differ, depending on the methodology applied, but is typically a process of requirements analysis, design, implementation, and testing. In other words, it gathers the requirements for protocol definition and defines detailed protocol for the protocol, implements the protocol according to the detailed protocol, and then verifies the protocol implementation through interworking tests.

Embedded systems are dependent on the hardware platform to which they are applied, and require specialized functions and operating environments specific to the platform and system purpose. Therefore, standardized communication methods are difficult to exist when interaction with the host server is required. As a result, when testing and operating existing embedded systems, communication with the host server is required. In this case, the communication protocol development between the host server and the embedded platform is generally separated by the developer who is familiar with each system due to the difference in development environment between the two systems. Developers participating in the protocol development define the message format for the development of the communication protocol, define the procedures for the message exchange, and implement the protocols that operate in the system according to the defined contents.

In this process, an error may occur due to an incorrect understanding of the protocol definition or a wrong implementation of the protocol. In the case of an embedded system, which is relatively weak in debugging, the troubleshooting may take a long time.

It is an object of the present invention to provide a standard interface definition language based on XML that can define a communication protocol between a host server and heterogeneous devices such as embedded devices, and an interface message type for service and service invocation.

Another object of the present invention is to provide an automated protocol source code generator for generating basic source codes for heterogeneous devices based on the interface definition language described above.

In order to achieve the above object, the present invention provides a computer-readable recording medium storing an interface definition language structure for defining an interface protocol between an interoperable host server and an embedded device and generating basic program source code for each device. The definition language includes a source code generator setting unit including a comment, a definition of a data type exchanged between the host server and the embedded device, and a service mapping setting including mapping information for calling a service providing function of the host server and the embedded device. A computer readable recording medium storing an interface definition language structure between heterogeneous digital devices including a unit and a service definition unit defining individual services to be provided by the host server and the embedded device.

The source code generator setting unit may include a general setting element including copyright and source code creator information to be included in a file comment, and a protocol setting related to generating and receiving a message including a CRC usage, a message maximum size, a message frame start and end identifier, and the like. It is preferable to include an element and a data type definition element including mapping information about device-independent data types and device-specific data types.

The service mapping setting unit may include an inbound service mapping element for the host server to call a service of the embedded device, and an outbound service mapping element for the embedded device to call a service of the host server. The service defining unit includes an inbound service element including a detailed definition of a service provided by the embedded device and called by the host server, and a service provided by the host server and provided by the embedded device. It may include an OutboundService element including a detailed definition of the.

The interface definition language structure is preferably described on an XML basis.

According to another aspect of the present invention, in the method for generating the basic program source code for each device between the host server and the embedded device interoperating, receiving the interface definition language written in XML, and analyzing the input interface definition language Classifying the source code generator setting part, the service mapping setting part, and the service definition part, from the information of the source code generator setting part, copyright, source code author related annotations, message frame format between the host server and the embedded device, Creating a header file including a type, creating a header file including a name and a parameter of a processing function from the information of the service mapping setting portion, and operation of the processing function from the information of the service definition portion; Create the described executable source code file A source code generation method is provided.

The header files and the execution source code file may be written in CPP or C language form.

Hereinafter, the configuration of the present invention will be described in detail with reference to the accompanying drawings and preferred embodiments.

1 is a conceptual diagram illustrating a process of generating program code for a host server and an embedded device according to the present invention.

As shown, the definition of the basic matters of the program such as copyright, developer, message to be communicated between devices and execution services using the XML-based interface definition language, and the code according to the present invention based on the created interface definition language When the generator generates the basic code for the host server and the embedded device, respectively, additional program coding can be performed to minimize errors and time wasted in designing and coding the program.

2 is a schematic diagram illustrating an interface definition language structure using XML according to the present invention.

As illustrated, the interface definition language using XML is composed of a source code generator setting unit, a service mapping unit, and a service definition unit including information for defining an interface protocol between systems and generating program source code.

Referring to FIG. 2, the interface definition language using XML has a Xiles element as a top node, and the Xiles element has a structure including one SourceGenerator, ServiceMapping, and ServiceList elements, respectively.

Table 1 is a table showing the detailed structure of the Xiles element according to the present invention.

The SourceGenerator setting part defines the settings used when generating program source code from the XML interface definition document.The general settings (GeneralOptions), the protocol-related message generation (MessageOptions), and the data type definitions (DataTypes). ).

(A) Source code generator setting part

Table 2 is a table showing the detailed structure of the SourceGenerator element according to the present invention.

The GeneralOptions element included in the SourceGenerator element contains information about copyright, source code author, etc., to be included in the comments of the generated source code file. Definition of individual items is defined using Option element, and GeneralOptions element can have several Option elements.

Table 3 is a table showing how to create a GeneralOptions element according to the present invention.

Table 4 is a table showing a method of creating an Option element according to the present invention.

Settings for creating message frames exchanged through the interface protocol are defined using the MessageOptions element.

Definition of individual items is defined using Option element like GeneralOptions element, and GeneralOptions element can have several Option elements. The definition of the Option element included in the MessageOptions element is shown in Table 4.

Table 5 shows a detailed structure of the MessageOptions element according to the present invention.

The SourceGenerator element contains DataTypes elements for generating source code that is neutral to the development environment, such as whether the compiler or O / S is used, and for defining clear data types between systems that exchange messages according to the interface protocol. In the XML interface definition document, data types can be matched between two platforms participating in the interface by defining and using data types that are independent of the platform of the host server and the embedded device. . The DataTypes element does not contain any attributes and contains multiple DataType elements as child nodes.

Table 6 shows a method of defining a DataType element according to the present invention.

The data type specified in the hostType attribute of the mapping information defined in the DataType element and the data type specified in the embeddedType attribute must be compatible.

(B) Service Mapping Configuration

The service mapping setting unit defines mapping information for calling a service providing function by interpreting an interface protocol message. The service mapping setting unit includes an InboundServiceMapping element for the host server to call a service of an embedded device and an OutboundServiceMapping element for the embedded device to call a service of a host server.

Table 7 is a table showing a method of defining a ServiceMapping element according to the present invention.

Both the InboundServiceMapping element and the OutboundSrviceMapping element include a plurality of mapping elements that define mapping information for individual services. When the source code generator receives a message corresponding to the serviceId attribute value, it generates the source code to call a function corresponding to the functionName attribute.

Table 8 is a table showing a method of defining a mapping element according to the present invention.

(C) service definition

The service definition unit defines the detailed information about individual services provided by the embedded device and the host server to the protocol counterpart using the ServiceList element.

The ServiceList element includes the InboundService element and the OutboundService element according to the direction of providing the service, and defines service definitions provided from the embedded device to the host server and services provided by the host server to the embedded device, respectively.

The ServiceList element may include a plurality of InboundService elements and a plurality of OutboundService elements.

Table 9 shows a method of defining a ServiceList element according to the present invention.

Table 10 is a table showing a method of defining an InboundService element according to the present invention.

The ParameterList element for defining information about the parameters for the service invocation contains a number of Parameter elements that define information such as the name of each parameter, its data type, array size, and whether it is a pointer.

Table 11 is a table showing a method of defining a Parameter element according to the present invention.

The host server can call the inbound service and specify that the embedded device should call the host server's service either during or after the execution of the service. This service call is called a callback service. The callback service can be defined using the CallbackService and CallbackRef elements. The CallbackService element is used to define a new complete service for the callback service. The CallbackRef element defines a callback service by referencing an existing defined CallbackService or OutboundService element.

Table 12 shows a detailed structure of the CallbackService element according to the present invention.

Table 13 is a table showing the detailed structure of the CallbackRef element according to the present invention.

Table 14 is a table showing detailed information of the OutboundService element according to the present invention.

OutboundService element defines detailed information about outbound service in the same way as Table 14.

The ParameterList element for defining information about the parameters for the service invocation contains a number of Parameter elements that define information such as the name, data type, array size, and whether the pointer is an individual parameter. Is the same as the definition method.

The protocol specification protocol definition using the interface definition document using XML provides a standard definition method for protocols and is also used as information for protocol source code generators. The protocol source code generator interprets the interface definition document defined in XML and automatically generates the source code for embedded devices and source server for host server. The generated code generates and transmits messages, receives and interprets messages, and services. It includes the same functionality as the call.

3 is a structural diagram showing a system of a protocol source code generator according to the present invention. .

The source code for a host server according to the present invention generates source code suitable for a development environment using MFC in Microsoft Visual C ++, and the source code for embedded devices generates source code suitable for a development environment using C language.

The source code generator for the host server generates the protocol source code for the host server from the interface definition document.

Table 15 is a table showing the source code list for the host server according to the present invention.

The source code files generated by the source code generator are shown in Table 15.

Hereinafter, a process of generating basic source code from an XML interface definition document according to the present invention will be described with reference to FIGS. 4 to 6.

4 is a schematic diagram showing a mapping relationship between an XML interface definition document and a service handler header file according to the present invention, and FIG. 5 is a schematic diagram showing a mapping relationship between an XML interface definition document and a service handler implementation file according to the present invention.

Referring to FIG. 4, a mapping relationship between a part of XilesService.h file created through a source code generator and an interface definition document can be viewed, and the automatic source code generator interprets the interface definition document to generate a service handler header file as shown in FIG. 4. Create The GeneralOptions element is used to create comments in the file, and the MessageOptions element is converted to a #define statement (Figure 5- (b)) with the constant values needed to create a protocol message.

Among the information of the ServiceMapping element, the serviceId attribute of every Mapping element is converted into an identifier declaration (Fig. 5- (c)) to identify the service, and the InboundServiceMapping element creates a protocol message frame to call a service provided by the embedded device. It is converted to a service call function (Caller function) to transmit (Fig. 5 (d)).

The OutboundServiceMapping element is converted into a service function for processing notification or callback invocation from the embedded device (Fig. 5- (ㅁ)).

As shown in FIG. 4, service call functions include call_setChannel (), call_startNetwork (), and call_transmitData () functions, and service functions include onDataReceived () and callbackStatus () functions.

The InboundService and OutboundService elements included in the ServiceList element are converted into parameters of the service call function (Fig. 5- (d)) and information of the service function's parameters (Fig. 5- (ㅁ)), respectively.

6 is a schematic diagram showing a mapping relationship between an XML interface definition document and a message handler implementation file.

Referring to FIG. 6, the XML interface definition document generates C ++ implementation code for a service handler class. In particular, in the service handler implementation file, the service invocation function includes code for generating and sending a protocol message according to the parameter definition (Fig. 6- (b)), and the service function includes a function parameter and a function frame (Fig. 6- ( Only c)) is generated, and additional service processing is written by the developer.

The message handler interprets the received interface protocol message and invokes the corresponding service. Message handlers are also code generated automatically by the source code generator using XML interface definition documents. Message handlers are written in the XilesHandler.h file that declares the member variables and functions of the message handler class and the XilesHandler.cpp file for the actual behavior implementation. The CXilesHandler class, which implements the message handler, includes the registerXilesService () and processXilesService () functions, as shown in the following figure.

The registerXilesService () function registers a pointer to a CXilesService object to call the appropriate service function according to the incoming message. The processXilesService () function interprets the interface protocol message according to the XML interface definition document and passes it to the service function. Extracts the parameter and uses it to call the service function.

Although the configuration of the present invention has been described in detail with reference to the accompanying drawings and preferred embodiments of the present invention, those skilled in the art will appreciate that various changes and modifications can be made within the scope of the technical idea of the present invention. Will be able to. Therefore, the scope of the present invention will be defined by the claims below.

When using the XML-based standard interface definition language that can define the service and the interface message form for the service call derived from the communication protocol design step between the host server and the embedded device according to the present invention, the basic source code for the protocol implementation You can run an automated protocol source code generator to generate it. In addition, when applied to embedded systems where the debugging method is weak, the problem solving ability is improved and the time is shortened.

Claims (7)

A computer-readable recording medium storing an interface definition language structure for defining an interface protocol between an interworking host server and an embedded device and generating basic program source code for each device. The interface definition language structure is A source code generator setting unit including a comment and defining a data type exchanged between the host server and an embedded device; A service mapping setting unit including mapping information for calling a service providing function of the host server and an embedded device; Service definition unit for defining individual services to be provided by the host server and the embedded device A computer-readable recording medium having stored therein an interface definition language structure between heterogeneous digital devices. The method of claim 1, wherein the source code generator setting unit, General configuration elements, including copyright and source code author information to be included in the file comments, Setting elements related to the creation and reception of a protocol including a CRC usage, a message maximum size, a message frame start and end identifier, Data type definition element containing mapping information about device-independent data type and device-specific data type And a interface definition language structure stored therein. The method of claim 1, wherein the service mapping setting unit, An inbound service mapping element for the host server to call a service of the embedded device; An outbound service mapping element for the embedded device to call a service of the host server And a interface definition language structure stored therein. The method of claim 1, wherein the service defining unit, An InboundService element including a detailed definition of a service provided by the embedded device and called by the host server; OutboundService element including detailed definitions of services provided by the host server and provided by the embedded device And a interface definition language structure stored therein. The computer-readable recording medium of claim 1, wherein the interface definition language structure is described on an XML basis. In the method for generating the basic program source code for each device between the host server and the embedded device that interoperate, Receiving an interface definition language written in XML; Analyzing the input interface definition language and classifying a source code generator setting part, a service mapping setting part, and a service definition part; Creating a header file including copyright, source code creator related annotations, and message frame format and type between the host server and the embedded device from the information of the source code generator setting portion; Creating a header file including a name and a parameter of a processing function from the information of the service mapping setting part; Creating an execution source code file describing the operation of the processing function from the information of the service definition portion Source code generation method comprising a. 7. The method of claim 6, wherein the header files and the executable source code file are written in CPP or C language form.

Images