KR20060071753A - Interfacing method between application and library of a master on home network - Google Patents

Abstract

The present invention relates to a standard interfacing method that can ensure compatibility of various applications and libraries operated for a home network. The routine is called to the library, and the identification information of the device to be controlled and the command code for control are added as an input variable, and the library calls the command to the device specified by the identification information of the device. Then return the call to the application by generating a result according to the response.

Home network, library, device, call, control, function, command

Description

Interfacing method between application and library of a master on home network}             

1 schematically shows the structure of a server and a home network applied to an interfacing method with a home network library according to the present invention.

FIG. 2 illustrates a procedure of performing an operation between an application and a library when the device of FIG. 1 is initially driven.

FIG. 3A illustrates a process in which the library of FIG. 1 separately classifies and processes an event.

3b illustrates a process in which the library of FIG. 1 integrates and processes all events.

4 illustrates a structure of a command necessary for individually inquiring / modifying / controlling devices of a home network defined between an application and a library,

5a to 5c illustrate a process in which a library sets a home code for each device of a home network,

6 is a flowchart illustrating a process of allocating an address to one device in a home network.

※ Explanation of code for main part of drawing

100: control application 110: library

120: physical interface 200: physical communication network

301, 302: home network device

The present invention relates to a method of interfacing with a library for a program such as a control application in a server for a home network to access a remote device in a network.

Many home appliances are spreading in the house, and it is necessary to concentrate their management. In accordance with this trend, a home network has been introduced, and LAN and power line communication have been proposed as a physical network for constructing a home network. Many electronics are connected to the home network, and these may be of different manufacturers.

Different manufacturers may also have different libraries provided with the product to access their home network, and different libraries also have different interfaces to applications such as control programs.

In this way, if the interface method is different, the application will be operated only on the device in which a specific library operates, so compatibility is not guaranteed. In addition, if the library developers provided for the home network are different, compatibility problems arise, such as the need to purchase application applications accordingly.

Accordingly, an object of the present invention is to provide a standard interfacing method that can ensure compatibility of various applications and libraries operated for a home network.

The present invention for achieving the above object provides a method for querying a list of home network devices.

The present invention also provides a method for inquiring detailed information of a home network device.

The present invention also provides a method of changing a list of home network devices, for example, deleting or adding a device.

The present invention also provides a method for a driving sequence between an application and a library in a master (server) of a home network.

The present invention also provides a method of notifying change of a state of a home network device.

The present invention also provides a method for individually checking the status of a home network device.

The present invention also provides a method for individually controlling a home network device.                     

The present invention also provides a method for command synchronization between an application and a library in a server of a home network.

The present invention also provides a method for setting a home code, which is a unique identifier of a network, which is required for the construction of a home network.

The present invention also provides a method for setting / changing an address of a home network device.

The present invention also provides a method for setting an operation option of a home network device, for example, alive status report period, time, event report activation, and the like.

Hereinafter, a method of interfacing with a home network library according to the present invention will be described in detail.

1 schematically illustrates the structure of a server and a home network applied to an interfacing method with a home network library according to the present invention.

The server to which the interfacing method according to the present invention is applied includes a user application 100 such as an operation program of a home network, a library 110 including all necessary functions and execution routines for accessing a home network (this library is LnCP). (Also referred to as a Living Network Control Protocol) library, a physical interface 120 for connecting to a physical communication network 200, such as a power line or a LAN cable. Also shown in the home network of FIG. 1 are remote devices 301 and 302 controlled by the server. These devices are inquired, changed, and / or controlled by the execution routine of the library 110, and commands for such an operation are performed by the user application (hereinafter referred to as a control application) 100. Called according to the definition of the API of the library 110, which will be described in detail below.

First, a description will be given of how the server queries a live device in a home network.

The control application 100 makes the following function call to the library 110 to know the list of devices connected to the home network.

get_active_device_list (&active_device_list);

Then, the library 110 loads information of devices that are alive (activated) on the network in an input argument (ie, & active_device_list (pointer to active_device_list)). The list of information contains the total number of devices and the device list. The structure of the information for each device is as follows.

typedef struct device {

device_descriptor_t dd;

device_type_t device_type;

device_mode_t device_mode;

} device_t;

Each device information in the list includes a protocol index, device descriptor information, its type, and mode information. The type information specifies the type of device, such as a refrigerator or a washing machine, and the mode information is a value specifying whether the device is a master or a slave.

On the other hand, when the library 110 transmits the information of the living device to the control application 100, the internal memory is allocated for the memory space required for each of the living devices.

Then, when the control application 100 does not need to use (or control) the live devices, the active_list is released by the following command to release the memory allocated to the library 110.

release_active_device_list (&active_device_list);

Next, we'll explain how the server can look up live devices on the home network in more detail.

In this case, the control application 100 may inquire about the requested device in detail by causing the library 110 to load an address, a device type, a model name, and location information in a return value using a following function.

get_device_info_by_dd (device_descriptor_t dd, device_info_t * ret_entry)

Here, dd is information (device descriptor) uniquely identifying a device on a network, and the library 110 carries information having the following structure in a pointer of ret_entry.

typedef struct device_info {

device_descriptor_t dd;                     

unsigned short address;

device_type_t device_type;

char model [MAX_MODEL_NAME_LEN];

unsigned char location;

} device_info_t;

address is a combination of type and serial number of the type, model is the text of the model name, and location is information about where the home is located. For example, a living room, a bedroom, etc.

When the control application 100 obtains information on a specific device by the inquiry command as described above, the control application 100 calls the appropriate control command requested by the user to the library 110, and if it is determined that the information on the corresponding device is not necessary, By calling a command to release the device to the library 110, the memory allocated by the library 110 can be used again for another purpose.

Next, a description will be given of how the control application 100 removes a specific device on a home network.

The control application 100 registers the device deletion event and a function to be called back when the event occurs in the library 110 by calling a next function.

add_sys_event_func_entry (EVT_SYSTEM_PLUG_OUT, plugout_event_handler);

The library 110 calls the registered callback function (plug_out_event_handler) when an event of EVT_STSTEM_PLUG_OUT (value designated as a plug-out event) occurs on the home network. At this time, dd (device descriptor or protocol index) is loaded into the input variable of the called function. That is, the routine in the control application 100 is called from the library 110 as follows.

plugout_event_handler (sys_event_value_t dd);

Then, the plugout_event_handler routine deletes the device from the device list managed by the device.

If, after registering the deletion event in the library 110, the device deletion event is no longer desired, the callback function that has already been registered is released by the following function call. To release, enter the event you want to release in the argument value of the release function and the registration function to receive the callback.

del_sys_event_func_entry (EVT_SYSTEM_PLUG_OUT, plugout_event_handler);

In case of adding device, it is same as the process of device deletion event registration and execution by callback function, but the value of additional event (EVT_SYSTEM_ACTIVE_DEVICE_ADD) to be used when calling is different. Also, callback routine for additional event processing indicates that device is added. Inform the user or handle the addition.

The process for when the device is reconnected to the network is the same as adding the device above (using EVT_SYSTEM_ACTIVE_DEVICE_ADD for event values) and user processing is the same or very similar. That is, the message informing the user may be slightly different.                     

Meanwhile, in order for the operation between the control application and the library in the server of FIG. 1 to be normally performed, the function call or the exchange of information should be performed according to a predetermined procedure so that the subsequent operation can be normally performed.

2 is a flowchart of an embodiment thereof. First, when the control application 100 is driven (S21) to drive the user UI required. The library 110 requests initialization of the library 110 (S22). At this time, basic information (eg, communication port, baudrate, etc.) of each device to be controlled is transmitted to the library 110. As described above, the living devices are inquired and a request for initialization thereof is provided (S23). In addition, each event registers an event handler to be processed, for example, a plug-in or a plug-out and the like, and event handlers for them, that is, callback functions (S24). After this process is performed in order, the LnCP library 110 when the events are generated from each device on the home network, by calling the corresponding callback function registered to the appropriate action for the event is made. (S25).

If necessary, the control application 100 may perform a function call to release an event and a function registered by the control application 100.

Next, a description will be given of a method of causing the device state to be notified of change. In the case of a device that supports the function of the home network, the device itself generates an event when the state of the device (for example, power state, operating state, temperature value, operation mode, selection course, etc.) changes. When an event occurs, the event code indicating the type of event and the event value, which is the value of the event occurrence state, are delivered.                     

To this end, first, the control application 100 registers an event callback function for processing a corresponding event in the library 110. Callback functions that handle events can be divided into two types: one for handling individual events and one for receiving and processing all events.

First, in case of processing each event, a user_event_func_t type function defined as follows is registered in the library 110 with device descriptor 'dd' and event code 'ec'.

typedef void (* user_event_func_t) (event_value1_t event_value);

int add_event_handler (device_descriptor_t dd, event_code_t ec, user_event_func_t uefunc);

Where ec is the type of event to be reported from the library 110, uefunc is a pointer to the callback function.

When an event occurs, the library 110 finds a device descriptor and an event code from a hash table managed by the library 110 and calls back by calling a pointer of a corresponding function, that is, registered uefunc (step 301 of FIG. 3A). At this time, 'event_value' is loaded as an input variable of uefunc. This is a state value in which an event has occurred. According to this value, the control application 110 notifies a user or performs an appropriate action specified for the value.

Second, in order to process all events, the user_all_event_func_t type function defined as follows is registered in the library 110.                     

typedef void (* user_all_event_func_t) (unsigned short device_addr, unsigned char size, unsigned char * event_data);

int add_all_event_handler (user_all_event_func_t func);

When this function is registered in the library 110, no matter what event occurs from any device on the network, the library 110 always calls back the function 'func' defined by user_all_event_func_t (step 302 of FIG. 3B). Instead, device_addr (for type and serial number for specifying one device in the home network) and * event_data are input variables so that the library 110 can identify the device that triggered the event and identify the event. Call back. The pointer of event_data may include the code and value of the event.

The routine in the callback control application 100 performs a process of appropriately processing the event based on the received information of the parameter.

Next, a description will be given of a method in which the control application 100 individually controls devices through routine calls of the library 110.

First, in order to call the device control function in the library 110 from the control application 100, the following information should be determined.

First, the ID (device descriptor) of the device to be controlled and the command code of the command to be executed must be known. The command code may be provided internally in the library. In order to control the power supply of the washing machine, for example, an argument regarding a power input (POWER_ON) or a power off (POWER_OFF) must be input.

Depending on the characteristics of the user program, command options such as whether to receive a response after the execution of the command is completed (Synchronize mode), to return the function immediately when the command is delivered (Asynchronize mode), and to wait for a response in Synchronize mode. This is necessary.

When the necessary device argument is added and the device control function is called, the library 110 calls the internal control_device function by including the command option defined in FIG. 4 in the structure of command_t.

In the structure of command_t of FIG. In addition, an option variable having a structure of command_option_t (described later) is included. Input variables cc, args, and option values are determined based on user input. The fields of var_arg and var_ret in the structure 401 of the command_args_t structure and the command_ret_t structure 402 are pointers to messages added to commands and responses.

The internal control_device function registers a function to process a response using the address of the controlling device and a command code as a key, and then generates a protocol packet for controlling the actual device to generate the protocol packet for the device 301 or 302 through the physical interface 200. To send.

If a response is received after the packet is transmitted, a function that processes the previously registered response is called to process the response. If there is information necessary for the response received from the device, the packet is returned in a structure of command_t. In the device control function transferred to the control right by this return, the structure of command_t is unpacked and stored in the output parameter of the corresponding function, and then the control result and the output parameter are returned to the control application 100 so as to be requested by the user or the control application ( Complete the control operation for the individual device requested by 100).

Next, a description will be given of how the control application 100 inquires the status of individual devices through routine calls of the library 110.

Status inquiry of an individual device is the same as the method of controlling an individual device previously, except for the following points.

Since the device's inquiry (monitoring) function must receive a response after all the commands are executed in the device, it should always be in synchronized mode, and therefore, it is necessary to specify a time to wait for the response. The mode and time of the command is given as a command option with the following structure:

typedef struct command_option {

unsigned char async;

unsigned long wait_time; // sec. unit

} command_option_t;

async has a value (0 or 1) that you specify as SYNC_COMMAND or ASYNC_COMMAND, SYNC_COMMAND means that you (the control application 100) want to send a command and wait for an answer to that command, and ASYNC_COMMAND means that you send the command This means not waiting for an answer to the command.

When setting the value of async to SYNC_COMMAND, it starts from the time when the command is sent and waits for the time set in wait_time, and if there is an answer in it, it terminates normally. Will run. The value of wait_time is ignored by the library 110 when the value of async is ASYNC_COMMAND.

In order to share options for the entire command between the control application 100 and the library 110, a structure by command_option_t may be designated as a global variable as follows.

static command_option_t * func_option

In addition, since there may be a plurality of commands simultaneously requested between the control application 100 and the library 110, the structure of command_option may further include a command code for identifying a command having the option as follows. .

typedef struct command_option {

unsigned char cc; // comment code

unsigned char async;

unsigned long wait_time; // sec. unit

} command_option_t;

When defined and used as described above, even if a command option is used as a global variable, the command can be appropriately operated synchronously or asynchronously between the control application 100 and the library 110 according to the command.

Hereinafter, a method for initializing or changing the home network will be described in detail.

First, a description will be given of how to initially set up a home network.

To form an independent network in a home, you use what is called a home code. The home code is the only independent code in the house, and only home network devices with the same home code can communicate with each other. The home code is set by the control application 100 calling the following function to the library 110 at the request of the user.

int set_home_code ();

In response to the call, the library 110 performs the process of FIG. 5A, and first broadcasts a message with a response from the devices, for example, a message requesting the name of a device, through the physical network 200 (S51). ). In this message, the home code set in the physical interface 120 is used. If there is a response to the broadcast message (S52), when the device is added, a broadcast message for setting the home code is transmitted (S52). Otherwise, otherwise, the physical interface 120, for example, the power line modem to give a command to generate a home code (S53), and broadcasts a message that requires a response, that is, a name request message over the network (S54) . At this time, if there is a response (S55), it means that the just-generated home code is being used somewhere, so the regeneration process is performed (S53, S54). It transmits through a network (S56).

By this process, even if the home network is connected to other home appliances through a power line, a unique and unique home code is set in the home, so that only the devices in the home can communicate.

5B is a detailed flowchart of a process of determining whether a home network is initially set up or addition of a new device in the above process.

As mentioned earlier, the way you set up your home code differs depending on whether you are setting up your network for the first time or setting up your home code with a new device. The determination of whether to install the network for the first time or to add a new device is, for example, if it sends a name request command three times (S502) and responds (S503, S504), it is determined that a new device is added. If there is no response (S506), it is determined that the network is installed for the first time and is operated (S505).

FIG. 5C is a flowchart illustrating the process of S53 to S55 in FIG. 5A in more detail. When installing the network for the first time, the physical interface 120, for example, to generate a new home code to the home network modem (S511) and check that the newly created home code does not overlap with the home code of other networks. And then broadcast the home code so that other home network modems also set the home code. Whether or not the home code is a duplicated home code is determined by sending a name request packet (S513). A handler for a response message of the name request message is registered in a table before sending the message (S512). This handler performs the routine S515 for the response message.

If there is no response by broadcasting the name request message (S514), it is determined that the home code is not duplicated. When no response to the three or more messages is sent, the home code setting message is transmitted as described above (S56). If there is a response, since the home code is a duplicate, a home code clear command is sent to the modem (S515) to clear the home code just before (S515) and generate a home code (S511).

The call of the routine of the library 110 for the home code cree is performed as follows.

int clear_home_code ()

This routine sends the home code clear command packet to the home network modem connected to the master so that the home code set on the modem for the home network connected to the master is removed.

On the other hand, the home code generation / release process is repeated until the home code is not duplicated.

As described above, when a new device is added to an existing network instead of the first network installation, the existing home code is broadcasted on the network to set the home code in the home network modem of the new device ( S56).

When setting a home code, the library 110 may be set to a home code directly set by a user (or a network installer / operator), not a home code randomly generated. In this case, the home code may be manually set by calling the following function to the library 110.

int push_home_code (unsigned long home_code);

When the function is called, the library 110 broadcasts the value of its input variable home_code through a home network to be set in the modems of the devices 301 and 302.

On the other hand, each home network device must have its own address to communicate with each other. The library 110 provides the routine necessary to set this address so that the control application 100 can conveniently assign an address.

The device attempting to join the home network broadcasts a Plug-In Notification message in order to receive an address (S61), and the master's library 110 receiving the Plug-In Notification processes the message and sends it to the requesting device. Assign an address.

To this end, the library 110 first registers the Plug-In Notification Handler in its response function hash table so that the Plug-In Notification packet can be processed.

Therefore, when the Plug-In Notification Packet is received, the Plug-In Notification Handler is executed, and the handler finds the type of the device that sent the packet, and then searches its DB with the type. Search the DB to check the empty address (S62), and then send the address to the Address Change command (S63). This process is accomplished by calling the function

int change_address (old_addr, new_addr);

As an input parameter of the change_address function, an existing address of a home network device and an address to be newly set are input. If it is the first device joining the home network, old_addr will be the default address (for example, 0). The execution of this function sends an address change command over the home network.

When this function routine returns, a value indicating whether the address change operation was successful is included as an input variable.

Meanwhile, the device receiving the address change command sets its own address as the address included in the command and sends a response. When the change_address routine receives the response, the change_address routine is successfully set, and thus stores the allocated address in its DB (S64). In addition, to update another network manager (Manager) that the new device has been registered to send a DB (Update) command (S65).

After doing this, additional information about newly registered device (ie, address assigned) is requested (S66, S67) to find out and recorded in DB. For example, the device search command is sent to find out whether the device is a master or slave (S66), and the model request is sent to find a model name (S67).

Next, the method for setting options of the devices connected to the home network at the time of initial initialization by the device functioning as the master in using the home network will be described in detail.                     

The library 110 in the device functioning as the master in the home network must check whether each home network device exists and whether or not it operates. To this end, each device sends a message to the master device at regular intervals to let it know that it is working. This message is called an Alive message. Therefore, when the master's control application 100 is performed for the first time and initializes the network, the library 110 checks whether each device sends an Alive message at the sent time interval by sending this time interval to the devices. Make sure that each device is working properly.

For this purpose, the control application 100 calls the routine of the library 110 for the time interval input from the user (or operator) as follows.

int set_alive_message_interval (time);

When this function is called, the library 110 receives a time variable as an input argument and transmits the value as a configuration message to each device in the home network, thereby setting the designated interval as the alive message transmission period.

And, the time can be set for devices that can set the current time among the home network devices. To set this, the control application 100 calls the set_clock function routine of the library 110. The set_clock function to be called is defined as follows.

int set_clock (hour, min, sec);

At the time of calling this function, the library 110 transmits the packet of the hour, minute, and second as input variables to the corresponding devices in the home network, and the result of the processing is controlled based on the returned message. Deliver to application 100.

In addition, the home network devices basically notify the other devices and the master devices of the change of their state through an event, and can set whether or not to continue sending these events through the library 110. To set this option, the control application 100 calls the following function routine in the library 110.

int event_enable (enable);

When calling this function, the library 110 receives whether the event transmission is activated as an input variable, makes a command according to this input variable, sends it to the corresponding device, and sets whether or not to activate the event report according to this setting value. Do it. When the response message according to the setting is received, the library 110 transmits a return value according to the response message to the control application 100.

According to the present invention described in detail above, the compatibility between manufacturers is secured by standardizing the interface method between the control application and the library, so that users have a wider choice of devices for the construction of a home network, and manufacturers support the built-in devices. There is an effect of reducing the management cost for repair or after-sales service.

Claims (5)

In a command and / or response method between an application and a library in a device managing a home network, Calling, by the application, a function routine for controlling a device connected to a network to the library, and adding identification information of a device to be controlled and a command code for control as an input variable; And Step 2, wherein the library requests a command by the command code to the device specified by the identification information of the device, generates a result value according to the response, and returns the value for the call of step 1; Including method. The method of claim 1, In the step 1, the application further comprises a command option information to the input variable indicating whether or not to wait for the result according to the command. The method of claim 1, And the library constructs a command structure for storing information according to the input variable and information according to the response to carry out the call and its response. The method of claim 3, wherein And said command structure is assigned identification information of said device, said command code, a string of said input variable, information to return, and a space for storing options of the command. The method of claim 4, wherein The information to return comprises a string and / or a message to return.

Images