KR101399356B1 - Developer terminal and target device, which communicate with each other according to same communication protocol and system and method for emulating the target device - Google Patents

Abstract

An emulation method and system using a developer terminal including a network agent, a target device, and a network agent are disclosed. The emulation system according to the present invention includes a target terminal and a developer terminal for developing a target driver for driving the target terminal. The developer terminal includes an application layer for transferring a control command for controlling a target device to a system layer, a hardware abstraction layer (HAL) for abstracting control commands received from the system layer to correspond to hardware characteristics of the target device, . The target device includes a target control unit that receives the abstracted control command, controls the target device in accordance with the abstracted control command, and transmits the obtained emulation result to the developer terminal. The developer terminal and the target device communicate with each other according to the same communication protocol. According to the present invention, one emulation device or one target device can be shared by a plurality of developer terminals, thereby realizing a 1: D or D: 1 development environment. By using a driver developed without any additional work, The device can be driven.

Description

A developer terminal and a target device that communicate with each other in accordance with the same communication protocol, and a system and method for emulating the target device, and a system and method for emulating the target device }

1 is a diagram conceptually showing an embedded system according to the prior art.

2 is a block diagram conceptually illustrating a developer terminal according to an aspect of the present invention.

3 is a block diagram conceptually illustrating an emulation system according to another aspect of the present invention.

4 is a block diagram conceptually showing a result of porting a target driver to a target device according to another aspect of the present invention.

5 is a flowchart illustrating an emulation method using a network agent according to another aspect of the present invention.

The present invention relates to a method and apparatus for emulating a target device, and more particularly to a method and apparatus for emulating a target device using a network agent, a developer terminal capable of communicating with various target devices using the network agent, a target device including a network agent, An emulation method, and an emulation system.

With advances in technology, a variety of user electronic devices are developed. There are new devices in user electronics that have not existed in the past. For example, new electronic devices such as portable multimedia players (PMPs) and navigation devices have been developed. In addition, existing electronic devices are frequently upgraded to improve or add functionality to meet diverse user needs. For example, conventional portable telephones are upgraded to implement DMB (Digital Multimedia Broadcasting) functions and camera functions.

However, electronic devices operating in a stand-alone manner include a controller therein, and an application for driving such a controller must be modified and supplemented each time a new performance is added. For example, in the case of a personal digital assistant (PDA) implemented in accordance with the ARM (Advanced RISC Machine) architecture, the instructions for controlling the ARM core are updated by porting them to the ROM of the terminal.

In general, in the case of an electronic device operating in a stand-alone mode, it is very troublesome to develop a device driver while controlling a target device to be controlled directly in the development process. The reason for this is that the hardware of the standalone electronic device does not provide a suitable environment for the user to develop the device driver. In addition, the types of hardware cores used in the target device are very diverse, and it is also not easy for the user to know all instruction sets corresponding to all cores. In addition, since general electronic devices have a Reduced Instruction Set Computer (RISC) architecture, the number of instructions that can be implemented is limited, while manipulating these instructions directly using lower level languages is not easy.

Therefore, a method of developing a driver for driving a target device in a developer terminal that provides more system resources is widely used.

1 is a diagram conceptually showing an embedded system according to the prior art.

An embedded system refers to an electronic device that can operate in a stand-alone manner with a built-in device control unit. Referring to FIG. 1, upper layer middleware and application layer directly call a device driver and an operating system mounted on a target device. Referring to FIG. 1, a process of developing an embedded system will be described. A hardware device driver is implemented in the lowest layer. Then, the middleware layer and the application layer are implemented in the upper part of the hardware device driver.

However, in the conventional embedded system, a lower layer must be implemented, and a layer operating on the lower layer can operate. For example, development of a higher-level software is possible only when development of a device driver related to the hardware of the target device is completed. Therefore, not only the development period is longer, but all layers must be changed at the same time even if the hardware of the target device is changed slightly. In addition, if an error occurs during driver development, it is difficult to confirm whether the error occurred in the application or hardware of the target device.

Thus, an emulation technique is used that implements the environment in which the target device is driven even if the target device is not directly driven by emulating the hardware of the target device. Through the emulation technology, the middleware layer and the application layer can be implemented so as not to be dependent on the target device. Accordingly, in the process of developing a device driver, a driver is developed independently from a target device in a middleware layer and an application layer. By developing the device driver in this way, even if the hardware of the target device is changed later, it suffices to accommodate the changes only in the system layer. In addition, emulation can be used to determine errors that occur during application development as software errors and to debug the software.

However, according to the emulation method according to the related art, one target device is connected to one developer terminal. Therefore, since the target device is monopolized by one developer terminal, even if several developers participate in the development of the driver, it is not possible to separate them smoothly. This disadvantage is particularly noticeable when the equipment used for emulation is expensive.

In addition, the emulation environment does not exactly match the actual target device. Therefore, even if a driver is developed by emulating a target device in a developer terminal, it is not necessarily guaranteed that the developed driver will operate correctly when the target device is implanted. However, since the API used in the developer terminal and the API used in the target device are different, the target device can not be directly driven using the device driver for the target device. Therefore, even if the device driver is completed, a process of porting is required to correspond to the API of the target device. If an error occurs as a result of driving the target device using the ported driver, the driver must be modified again using the emulation device. Also, the modified driver must be ported to correspond to the API of the target device again.

Therefore, in addition to sharing one emulation device by a plurality of developer terminals, when the development of the driver is completed, a technique for directly porting the developed driver directly to the target device is required without additional work.

An object of the present invention is to provide an emulation system capable of shortening a driver development period by sharing one emulation device or one target device at a plurality of developer terminals.

It is a further object of the present invention to provide a network system that includes a network agent communicating with the system layer, the emulation section, and the target device of the developer terminal according to the same communication protocol, and after the driver is developed, Thereby providing an emulation method for directly driving a target device using a driver developed without additional work.

According to an aspect of the present invention, there is provided an emulation system including a target device and a developer terminal for developing a target driver for driving the target device, And a hardware abstraction layer (HAL) for abstracting control commands received from the application layer and the system layer to transfer control commands received from the system layer to the target device in accordance with hardware characteristics of the target device, Wherein the developer terminal and the target device communicate with each other in accordance with the same communication protocol, and the developer terminal and the target device communicate with each other in accordance with the same communication protocol, and the target terminal controls the target device in response to the abstracted control command and transmits the obtained emulation result to the developer terminal. . Preferably, the developer terminal and the target device each include a network agent operating according to a communication protocol, and the network agents are preferably interconnected through a predetermined network. In particular, the target device is preferably shared by a plurality of developer terminals via a network. In addition, when a target driver is developed, the developed target driver is preferably ported to the memory of the target device along with the network agent. Further, the developer terminal further includes a middleware layer located between the operating system abstraction layer (OSAL) and operating system abstraction layer (OSAL) and the application layer that abstracts the operating system of the developer terminal.

According to another aspect of the present invention, there is provided an emulation method including a target device and a developer terminal for developing a target driver for driving the target device. The emulation method according to another aspect of the present invention includes the steps of transferring a control command for controlling the target device from the application layer of the developer terminal to the system layer, abstracting the received control command to correspond to the hardware characteristics of the target device, Transmitting the control command to the target device according to a predetermined communication protocol, receiving the abstracted control command, emulating the target device in accordance with the abstracted control command, and emulating the target device to communicate the obtained emulation result To the developer terminal according to the protocol. The developer terminal and the target device communicate with each other using a network agent operating according to a communication protocol, and the target device is preferably shared by a plurality of developer terminals through a predetermined network. Particularly, the communication protocol is an Ethernet protocol or a serial communication protocol. Further, the emulation method according to the present invention further includes the step of, when the target driver is developed, porting the developed target driver to the memory of the target device together with the network agent.

According to another aspect of the present invention, there is provided a developer terminal for developing a target driver for emulating a target device to drive a target device. The developer terminal according to the present invention includes an application layer for transferring a control command for controlling a target device to a system layer, a hardware abstraction layer for abstracting control commands received from the system layer to correspond to hardware characteristics of a target device, (HAL), and an emulation section for receiving the abstracted control command, controlling the target device in accordance with the abstracted control command, and transmitting the obtained emulation result to the developer terminal, wherein the developer terminal and the emulation section And communicate with each other. Further, the developer terminal and the emulation section each include a network agent operating in accordance with a communication protocol, and the network agent is interconnected through a predetermined network. In particular, the developer terminal according to the present invention is characterized in that when a target driver is developed, the developed target driver is ported to the memory of the target device together with the network agent.

According to another aspect of the present invention, there is provided a target device controlled by an abstracted control command received from a developer terminal. A target apparatus according to the present invention includes a network agent for receiving an abstracted control command according to a predetermined communication protocol and a target control unit for controlling the target apparatus by an abstracted control command, And transmits the emulated result to the developer terminal through the network agent. In particular, the network agent is connected to the developer terminal through a predetermined network. Furthermore, the target device is preferably shared by a plurality of developer terminals via a network. In addition, the network agent further includes a memory for receiving the target driver ported from the developer terminal, when the target driver is developed, and the target device storing the received target driver together with the network agent.

According to the present invention, not only one target device can be shared by a plurality of developer terminals using a network, but also a target device can be driven by directly embedding the developed driver on a target device without any additional work.

In order to fully understand the present invention, operational advantages of the present invention, and objects achieved by the practice of the present invention, reference should be made to the accompanying drawings and the accompanying drawings which illustrate preferred embodiments of the present invention.

Hereinafter, the present invention will be described in detail with reference to the preferred embodiments of the present invention with reference to the accompanying drawings. In each drawing, the same reference numerals denote the same members.

2 is a block diagram conceptually illustrating a developer terminal according to an aspect of the present invention.

Referring to FIG. 2, the developer terminal 200 includes an application layer 210, a middleware layer 220, a system layer 230, and an emulation section 290. The system layer 230 includes an operating system abstraction layer (OSAL) 240 and a hardware abstraction layer 250, and the emulation unit 290 includes a target control unit 280.

The application layer 210 corresponds to an application program directly available to the user. For example, when the target device is a television tuner, the application layer 210 controls a menu selection screen such as a facial adjustment, a volume adjustment, and a channel setting, and an OSD (On Screen Display).

The middleware layer 220 is a layer that controls a common part of operations among target apparatuses that are different from each other. For example, when the target device is a television tuner, all the television tuners commonly perform operations such as a channel change engine, a screen adjustment engine, a channel information database management, and a hardware control, even if the application used for the television tuner is different . Accordingly, these common operations are controlled in the middleware layer 220. [

By thus distinguishing the application layer 210 and the middleware layer 220, development time for various target devices can be shortened. That is, even if the applications used for different target devices are different, a common operation between these target devices can be implemented in the middleware layer 220. Then, the developer can use the middleware layer 220 in common and develop only different functions in the application layer 210, thereby shortening the development time.

2, the developer terminal 200 operates on a first operating system OS1. The first operating system (OS1) may be a variety of operating systems such as Windows, Linux, embedded Linux, VxWORKs, WinCE, WinCE.net, and the like. The application layer 210 and the middleware layer 220 of the developer terminal 200 operate on the operating system OS1. Accordingly, when the operating system OS1 is changed, both the application layer 210 and the middleware layer 220 must be changed. Therefore, an operating system abstraction layer (OSAL) 240 is used to ensure the independence of the application layer 210 and the middleware layer 220 for the operating system OS1 operating in the developer terminal 200. [ That is, even if the operating system OS1 used in the developer terminal 200 is changed, since the changed operating system is abstracted by the operating system abstraction layer 240, the application layer 210 and the middleware layer 220 are not changed You do not have to.

The hardware abstractio layer (HAL) 250 will be described below.

In order to effectively emulate various target devices and to implement the application layer 210 and the middleware layer 220 without depending on the target device, a hardware abstraction layer 250 that abstracts the hardware of the target device is needed. Only the lower layers of the defined hardware abstraction layer 250 are adapted to the target device and the application layer 210 and the middleware layer 220 ) Can be implemented independently of the target device. That is, the hardware abstraction layer 250 represents a collection of routines for processing hardware-dependent details necessary for an input / output interface, an interrupt control, an implementation of a multiprocessor communication, and the like. By defining a hardware abstraction layer in the embedded system and implementing this function on the developer terminal, the emulation-based development environment can be provided and the middleware layer 220 or the application layer 210 can be provided Can be developed.

The emulation unit 290 controls the target control unit 280 using a control command abstracted by the hardware abstraction layer 250. By driving the target control unit 280 by the emulation unit 290, the developer can obtain an effect similar to driving the target device directly.

In the developer terminal 200 shown in FIG. 2, the hardware abstraction layer 250 and the emulation unit 290 include first and second network agents 260 and 270, respectively. The control commands generated in the application layer 210 are transferred to the system layer 230 through the middleware layer 220. Then, the hardware abstraction layer 250 transmits the control command abstracted through the first network agent 260 to the emulation unit 290. Then, the second network agent 270 receives the abstracted control command and delivers the received control command to the target control unit 280. [

The emulation result emulating the target device corresponding to the control command received at the emulation unit 290 is transmitted again from the second network agent 270 to the first network agent 260. [ Then, the hardware abstraction layer 250 transfers the received emulation result to the application layer 210 via the middleware layer 220. The application layer 210 may analyze the received emulation result to develop a device driver. The first operating system (OS1) may be a variety of operating systems such as Windows, Linux, embedded Linux, VxWORKs, WinCE, WinCE.net, and the like.

As shown in FIG. 2, data exchange between the system layer 230 and the emulation unit 290 is performed using network agents. The control command is directly transmitted to the emulation unit 290 through the network agent and the emulation result is directly transmitted to the application layer 210. [ Therefore, developers' development time can be shortened. In addition, the emulation result transmitted from the emulation unit 290 may be shared by one or more developer terminals. In this case, since the environment in which the driver is developed in the developer terminal 200 can be connected to the target device, the driver can be verified based on the target device in an improved development environment.

When development of the driver is completed, both the first network agent 260 and the second network agent 270, as well as the developed driver, are ported to the target device. This process will be described later in detail with reference to FIG.

3 is a block diagram conceptually illustrating an emulation system according to another aspect of the present invention.

The emulation system shown in Figure 3 includes a developer terminal 200 and a target device 300.

The developer terminal 200 shown in Fig. 3 is similar in construction and operation to the developer terminal shown in Fig. Thus, a repetitive description of the application layer 210, the middleware layer 220, the system layer 230, the operating system abstraction layer 240, the hardware abstraction layer 250, and the first network agent 260 is omitted do.

The developer terminal 200 shown in FIG. 3 directly controls the target device 300 using the developed driver. The target device 300 includes a system layer 360, a second network agent 370, a target control 380, and an operating system abstraction layer 390. The hardware abstraction layer 250 of the developer terminal 200 abstracts control commands received from the application layer 210 and transmits abstracted control commands using the first network agent 260. Then, the second network agent 370 of the target device 300 receives the abstracted control command via the network. The received control command is transmitted to the target control unit 380, and the target control unit 380 directly controls the target apparatus. The target device 300 shown in Fig. 3 operates on a second operating system OS2. Of course, like the first operating system OS1, the second operating system OS2 can be various operating systems such as Windows, Linux, embedded Linux, VxWORKs, WinCE, WinCE.net, and the like. The operating system abstraction layer 390 included in the target device 300 abstracts the second operating system OS2 so that the first operating system OS1 of the developer terminal 200 can access the second operation of the target device 300 The driver developed in the developer terminal 200 can be directly applied to the target device 300 even if it is different from the OS2.

3, the hardware abstraction layer 250 and the system layer 360 communicate with each other through the network agents. Therefore, the target device 300 can be directly driven using the driver developed in the developer terminal 200 It can be seen that Preferably, the network agents 260 and 360 may communicate with each other through an Ethernet network corresponding to the Ethernet protocol, but the present invention is not limited thereto. Thus, it should be understood that various wired and wireless communication networks may be used to convey the abstracted control commands and emulation results.

4 is a block diagram conceptually showing a result of porting a target driver to a target device according to another aspect of the present invention. The target device 400 shown in FIG. 4 includes an application layer 410, a middleware layer 420, a first system layer 430, and a second system layer 465. The first system layer 430 includes an operating system abstraction layer 440 and a hardware abstraction layer 450. The hardware abstraction layer 450 includes a first network agent 460 and the second system layer 465 includes a second network agent 470. [ The target device 400 operates in accordance with the second operating system OS2.

The application layer 410, the middleware layer 420 and the first system layer 430 included in the target device 400 include those included in the developer terminal 200 shown in FIG. 2 or 3, Is similar. That is, the application layer 410, the middleware layer 420, and the first system layer 430, which are implemented in the developer terminal, are ported to the target device 400 when the development of the driver is completed. In this case, network agents responsible for communication between the hardware abstraction layer 450 and the second system layer 465 are ported together. Accordingly, the driver developed using the developer terminal 200 is directly ported to the target device 400 without any modification. That is, the control commands provided by the application layer 410 are abstracted by the hardware abstraction layer 450 to drive the target controller 480 directly through the network agents.

5 is a flowchart illustrating an emulation method using a network agent according to another aspect of the present invention.

First, the control command generated by the driver implemented in the application layer is transferred to the middleware layer (S510).

Then, the middleware layer transfers the received control command to the system layer including the hardware abstraction layer (HAL) (S520). The hardware abstraction layer (HAL) abstracts the received control command corresponding to the hardware of the target device to generate an abstracted control command (S530). In addition, the abstracted control command is transmitted to the emulation unit or the target apparatus through the network agent (S540). In the case of emulating a target device by software in a developer terminal, the abstracted control command is transferred to the emulation section in the developer terminal. However, if the developer terminal directly controls the target device, the abstracted control command is delivered to the target device.

Then, the target control (see 280 in FIG. 2) in the emulation unit or the target control (see 380 in FIG. 3) in the target device is controlled by the received abstracted control command. The result of driving the target device is transferred to the developer terminal as an emulation result (S550). It is desirable that the network agent responsible for communication between the developer terminal and the target device operates in accordance with the same communication parameters as described above.

If the emulation operation and the driver development operation are repeatedly performed, it is determined whether a driver for the target device has been developed (S560). If it is determined that the driver is completed, the target driver is ported to the target device together with the network agent (S570). The porting operation means, for example, an operation of compiling a driver developed in a window-based environment corresponding to a target device. This operation can be performed through a process of mapping the instruction set of the window-based driver to the instruction set used in the target device. In this case, the main commands are formed in API (Application Program Interface) form and can be communicated through the network.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is evident that many alternatives, modifications and variations will be apparent to those skilled in the art. For example, in the present invention, a television tuner is used as a target device for convenience of explanation, but it is obvious that the present invention is not limited to this. Also, in the embodiment of the present invention, the control command and the emulation result are transmitted and received through the network agent, but the present invention is not limited thereto. Furthermore, it is needless to say that the control command and the emulation result are not necessarily transmitted through the network, but can also be transmitted through the serial communication. Therefore, it should be noted that all communication modules communicating in accordance with the same communication protocol can be used as a network agent.

Accordingly, the true scope of the present invention should be determined by the technical idea of the appended claims.

According to the present invention, one emulation device or one target device can be shared among a plurality of developer terminals, thereby realizing a 1: D or D: 1 development environment and shortening a driver development period.

Further, according to the present invention, a network agent communicating with the system layer, the emulation section, and the target device of the developer terminal according to the same communication protocol is included, and after the driver is developed, the network agent is ported together with the driver into the target device The target device can be directly driven by using the developed driver without any additional work.

Claims (24)

1. An emulation system comprising a target device and a developer terminal for developing a target driver for driving the target device, An application layer for transferring a control command for controlling the target device to a system layer, And a hardware abstraction layer (HAL) that abstracts the control command received from the system layer to correspond to a hardware characteristic of the target device and transmits the abstracted control command to the target device, And a target control unit for receiving the abstracted control command, controlling the target apparatus in response to the abstracted control command, and transmitting the obtained emulation result to the developer terminal, Wherein the developer terminal and the target device communicate with each other according to the same communication protocol. 2. The system of claim 1, wherein the developer terminal and the target device further comprise: Each network agent operating in accordance with the communication protocol, Wherein the network agents are interconnected via a predetermined network. 3. The apparatus of claim 2, And is shared by a plurality of developer terminals via the network. 3. The method of claim 2, Wherein the communication protocol is an Ethernet protocol or a serial communication protocol. 3. The method of claim 2, Wherein when the target driver is developed, the developed target driver is ported to the memory of the target device together with the network agent. The terminal according to claim 1, An operating system abstraction layer (OSAL) that abstracts the operating system of the developer terminal and Further comprising a middleware layer located between the operating system abstraction layer (OSAL) and the application layer. An emulation method comprising a target device and a developer terminal for developing a target driver for driving the target device, Transferring a control command for controlling the target device from an application layer of the developer terminal to a system layer; Abstracting the received control command to correspond to a hardware characteristic of the target device, and transmitting an abstracted control command to the target device according to a predetermined communication protocol; Receiving the abstracted control command and emulating the target device in response to the abstracted control command; And And transmitting emulation results obtained by emulating the target device to the developer terminal according to the communication protocol. 8. The system of claim 7, wherein the developer terminal and the target device And communicate with each other using a network agent operating in accordance with the communication protocol. 9. The apparatus of claim 8, And is shared by a plurality of developer terminals via a predetermined network. 9. The method of claim 8, Wherein the communication protocol is an Ethernet protocol or a serial communication protocol. 9. The method of claim 8, And when the target driver is developed, porting the developed target driver to the memory of the target device with the network agent. 8. The terminal according to claim 7, An operating system abstraction layer (OSAL) that abstracts the operating system of the developer terminal and And a middleware layer located between the operating system abstraction layer (OSAL) and the application layer. A developer terminal device for developing a target driver for emulating a target device to drive the target device, An application layer for delivering control commands to the system layer for controlling the target device; A hardware abstraction layer (HAL) that abstracts the control command received from the system layer to correspond to the hardware characteristics of the target device and transmits the abstracted control command to the target device; And And an emulation unit for receiving the abstracted control command and controlling the target device in response to the abstracted control command to transmit the obtained emulation result to the hardware abstraction layer, Wherein the hardware abstraction layer and the emulation unit communicate with each other according to the same communication protocol. 14. The apparatus of claim 13, wherein the hardware abstraction layer and the emulation unit comprise: Each network agent operating in accordance with the communication protocol, And the network agents are interconnected through a predetermined network. 15. The apparatus of claim 14, And is shared by a plurality of developer terminals through the network. 15. The method of claim 14, Wherein the communication protocol is an Ethernet protocol or a serial communication protocol. 15. The developer terminal apparatus according to claim 14, And when the target driver is developed, port the developed target driver to the memory of the target device together with the network agent. 14. The developer terminal apparatus according to claim 13, An operating system abstraction layer (OSAL) that abstracts the operating system of the developer terminal device and Further comprising a middleware layer located between the operating system abstraction layer (OSAL) and the application layer. A target device controlled by an abstracted control command received from a developer terminal, A network agent for receiving the abstracted control command according to a predetermined communication protocol; and And a target control unit for controlling the target apparatus by the abstracted control command, Wherein the target control unit transmits a result of emulating the target device to the developer terminal via the network agent. 20. The method of claim 19, Wherein the network agent is connected to the developer terminal via a predetermined network. 21. The apparatus of claim 20, And shared by a plurality of developer terminals via the network. 21. The method of claim 20, Wherein the communication protocol is an Ethernet protocol or a serial communication protocol. 21. The method of claim 20, Wherein the network agent receives the target driver ported from the developer terminal when the target driver is developed, Wherein the target device further comprises a memory for storing the received target driver with the network agent. 20. The apparatus of claim 19, And an operating system abstraction layer (OSAL) that abstracts the operating system of the target device.

Images