KR20200006368A - Method and apparatus for transmitting accumulated notification message in m2m system - Google Patents

Abstract

The present invention may provide a method for transmitting a notification message in a machine-to-machine (M2M) system. According to the present invention, the method for transmitting a notification message may comprise the steps of: generating a plurality of notification messages in a disconnected state; and transmitting at least one of the plurality of notification messages when the disconnected state is switched to a connected state. A notification message to be transmitted among the plurality of notification messages may be determined based on notification attribute information.

Description

METHOD AND APPARATUS FOR TRANSMITTING ACCUMULATED NOTIFICATION MESSAGE IN M2M SYSTEM}

The present invention relates to a method and apparatus for transmitting a accumulated notification message in a machine-to-machine (M2M) system. More specifically, the present invention relates to a method and apparatus for transmitting a accumulated notification message based on a connection failure in an M2M system.

Recently, M2M (Machine-to-Machine) system has been actively introduced. M2M communication may mean communication performed between a machine and a machine without human intervention. M2M may refer to Machine Type Communication (MTC), Internet of Things (IoT), or Device-to-Device (D2D). However, hereinafter, for the convenience of description, the term is referred to as M2M uniformly, but is not limited thereto. The terminal used for M2M communication may be an M2M device. The M2M terminal may generally be a device having low mobility while transmitting less data. In this case, the M2M terminal may be used in connection with an M2M server that centrally stores and manages communication information between machines.

In addition, the M2M terminal may be applied in various systems such as object tracking, vehicle linkage, and power metering.

On the other hand, with respect to the M2M terminal, the oneM2M standardization organization provides the technology for requirements, architecture, API specifications, security solutions, interoperability for M2M communication, IoT, IoT technology. The specifications of the oneM2M standardization organization provide a framework to support a variety of applications and services such as smart cities, smart grids, connected cars, home automation, security and health.

An object of the present invention is to provide a method for transmitting a accumulated notification message.

An object of the present invention is to provide a method for processing a notification message generated when a connection fails.

An object of the present invention is to provide a method for avoiding duplicate subscriptions.

According to an embodiment of the present invention, a method for transmitting a notification message in an M2M system may be provided. In this case, the method for transmitting a notification message may include generating a plurality of notification messages in a connectionless state and transmitting at least one or more of the plurality of notification messages when the connectionless state is changed to a connection state. It may include. In this case, the notification message transmitted among the plurality of notification messages may be determined based on the notification attribute information.

In addition, according to an embodiment of the present invention, an apparatus for transmitting a notification message in an M2M system may be provided. In this case, the apparatus for transmitting the notification message may include a transceiver for transmitting and receiving a signal and a processor for controlling the transceiver. In this case, the processor may detect that a plurality of notification messages are generated in the disconnectable state, and may transmit at least one or more of the plurality of notification messages when the disconnectable state is switched to the connected state. In this case, the notification message transmitted among the plurality of notification messages may be determined based on the notification attribute information.

In addition, the following may be commonly applied to a method and an apparatus for transmitting a notification message.

According to an embodiment of the present invention, when the notification attribute information is "SendAllpending", all of the plurality of notification messages generated in the connection unavailable state may be transmitted.

In this case, according to an embodiment of the present invention, when the first notification message and the second notification message are sequentially generated among the plurality of notification messages, only the changed information may be included in the second notification message in comparison with the first notification message. have.

In this case, according to an embodiment of the present invention, when there is no changed information in the second notification message, the transmission for the second notification message may be omitted.

In addition, according to an embodiment of the present invention, when the data included in the plurality of notification messages is the same information, after switching the connection state of the one notification message including the average value information for the data included in each of the plurality of notification messages Can transmit

In addition, according to an embodiment of the present invention, when the data included in the plurality of notification messages is the same information, only the notification message generated at the first time point among the plurality of notification messages may be transmitted after the connection state transition.

In addition, according to an embodiment of the present invention, the plurality of notification messages may be transmitted based on any one of a batch transmission or a sequential transmission after being switched to the connected state.

In this case, according to an embodiment of the present invention, after switching to a connected state, an indicator indicating whether to send a bundle or sequentially send a plurality of notification messages may be transmitted.

Further, according to an embodiment of the present invention, when a plurality of notification messages are transmitted based on sequential transmission, notification messages having a first priority are first transmitted, and then notification messages having the first priority are transmitted. Notification messages with a second priority may be sent. In this case, the first priority may have a higher priority than the second priority.

In this case, according to an embodiment of the present invention, when the first time elapses after the notification messages having the first priority are transmitted, the notification messages having the second priority may be transmitted.

In addition, when a plurality of notification messages are transmitted based on a batch transmission, notification messages having a first priority may be transmitted first in one bundle, and notification messages having a second priority may be transmitted in one bundle. . In this case, the first priority may have a higher priority than the second priority.

In addition, according to one embodiment of the present invention, when the notification attribute information is set to "sendFirst", only the first notification message occurring in the unconnected state may be transmitted after switching the connection state.

According to the present disclosure, a method of transmitting a accumulated notification message may be provided.

According to the present disclosure, a method of processing a notification message generated when a connection fails can be provided.

According to the present disclosure, a method for avoiding duplicate subscriptions can be provided.

Effects obtained in the present disclosure are not limited to the above-mentioned effects, and other effects not mentioned above may be clearly understood by those skilled in the art from the following description. will be.

1 is a diagram illustrating a hierarchical structure of an M2M system according to the present disclosure.
2 is a diagram illustrating a reference point according to the present disclosure.
3 is a diagram illustrating each node according to the present disclosure.
4 illustrates a common service function according to the present disclosure.
5 is a diagram illustrating a method in which a sender and a receiver exchange messages according to the present disclosure.
6 is a diagram illustrating a subscription attribute according to the present disclosure.
7 is a diagram illustrating a method of transmitting a accumulated notification message according to the present disclosure.
8 is a diagram illustrating a method of transmitting all accumulated notification messages according to the present disclosure.
9 is a diagram illustrating a method for transmitting a notification message through a repeater according to the present disclosure.
10 illustrates a method of transmitting a notification message when a subscription requester and a notification target are different according to the present disclosure.
11 is a diagram illustrating a notification message transmission method when a subscription requester and a notification target are different according to the present disclosure.
12 illustrates a method of transmitting a notification message according to the present disclosure.
13 is a diagram illustrating a device configuration of an M2M terminal according to the present disclosure.

Hereinafter, exemplary embodiments of the present disclosure will be described in detail with reference to the accompanying drawings so that those skilled in the art may easily implement the present disclosure. However, the present disclosure may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein.

In the present disclosure, the terms "first" and "second" are used only for the purpose of distinguishing one component from other components, and do not limit the order or importance between the components unless specifically mentioned. Thus, within the scope of the present disclosure, a first component in one embodiment may be referred to as a second component in another embodiment, and likewise, a second component in one embodiment may be referred to as a first component in another embodiment. It may also be called.

In the present disclosure, when a component is "connected", "coupled" or "connected" with another component, it is not only a direct connection, but also an indirect connection in which another component exists in the middle of the connection. It may also include. In addition, when a component "includes" or "having" another component, it means that it may further include another component, without excluding the other component unless otherwise stated. .

In the present disclosure, the components distinguished from each other are for clearly describing each feature, and do not necessarily mean that the components are separated. That is, a plurality of components may be integrated into one hardware or software unit, or one component may be distributed into a plurality of hardware or software units. Therefore, even if not mentioned otherwise, such integrated or distributed embodiments are included in the scope of the present disclosure.

In the present disclosure, components described in various embodiments are not necessarily required components, and some may be optional components. Accordingly, embodiments that consist of a subset of the components described in one embodiment are also included in the scope of the present disclosure. In addition, embodiments including other components in addition to the components described in the various embodiments are included in the scope of the present disclosure.

In describing the embodiments of the present disclosure, when it is determined that a detailed description of a known structure or function may obscure the gist of the present disclosure, a detailed description thereof will be omitted. In the drawings, parts irrelevant to the description of the present disclosure are omitted, and like reference numerals designate like parts.

In addition, the present specification describes a network based on M2M communication, and the work performed in the M2M communication network may be performed in the process of controlling the network and transmitting data in a system that manages the corresponding communication network.

In addition, in the present specification, the M2M terminal may be a terminal performing M2M communication, but may be a terminal operating in a wireless communication system in consideration of compatibility. That is, the M2M terminal may mean a terminal that can be operated based on the M2M communication network, but is not limited to the M2M communication network. The M2M terminal may also operate based on another wireless communication network, and is not limited to the above-described embodiment.

In addition, the M2M terminal may be fixed or have mobility. In addition, the M2M server refers to a server for M2M communication and may be a fixed station or a mobile station.

In addition, in this specification, an entity may refer to hardware such as an M2M device, an M2M gateway, or an M2M server. Also, as an example, an entity may be used to refer to a software configuration in a hierarchical structure of an M2M system, and is not limited to the above-described embodiment.

In addition, as an example, the present invention will be described based on the M2M system, but the present invention is not limited to the M2M system.

Also, the M2M server may be a server that communicates with an M2M terminal or another M2M server. In addition, the M2M gateway may serve as a connection point connecting the M2M terminal and the M2M server. For example, when the networks of the M2M terminal and the M2M server are different, they may be connected to each other through the M2M gateway. In this case, as an example, both the M2M gateway and the M2M server may be M2M terminals, and are not limited to the above-described embodiment.

1 is a diagram illustrating a hierarchical structure of an M2M system.

Referring to FIG. 1, the layered structure of the M2M system may include an application layer 110, a common service layer 120, and a network service layer 130. In this case, the application layer 110 may be a layer that operates based on a specific application. For example, the application may be a vehicle tracking application, a remote blood sugar monitoring application, a power metering application, a controlling application, or the like. That is, the application layer may be a layer for a specific application. In this case, the entity operating based on the application layer may be an application entity (AE).

The common service layer 120 may be a layer for a common service function. For example, the common service layer 120 may be a layer for providing common services such as data management, device management, M2M service subscription management, location services, and the like. Can be. For example, an entity operating based on the common service layer 120 may be a common service entity (CSE).

The network service layer 130 may provide services such as device management, location service, and device triggering to the common service layer 120. In this case, the entity operating based on the network layer 130 may be a network service entity (NSE).

2 is a diagram illustrating an M2M system structure.

Referring to FIG. 2, an M2M system structure may be classified into a field domain and an infrastructure domain. In this case, each entity in each domain may perform communication through a reference point. As an example, a reference point may represent a communication flow between each entity. In this case, referring to FIG. 2, an Mca reference point, which is a reference point between AE and CSE, an Mcc reference point, which is a reference point between different CSEs, and a Mcn reference point, which is a reference point between CSEs and NSEs, may be set.

3 is a diagram illustrating setting of an M2M system structure.

Referring to FIG. 3, an infrastructure domain of a specific M2M service provider may provide a specific infrastructure node 310 (Infrastructure Node, IN). At this time, the CSE of the IN may perform communication based on the AE and Mca reference points of other infrastructure nodes. In this case, one IN may be set for one M2M service provider. That is, the IN may be a node that communicates with an M2M terminal of another infrastructure based on the infrastructure structure. Also, as an example, the concept of a node may be a logical entity or may be a software configuration.

Next, the application designated node 320 may be a node including at least one AE and not including a CSE. In this case, the ADN may be set in the field domain. That is, ADN may be a dedicated node for AE. For example, the ADN may be a node configured in the M2M terminal in hardware. In addition, the application service node 330 may be a node including one CSE and at least one AE. ASN may be set in the field domain. That is, it may be a node including AE and CSE. In this case, the ASN may be a node connected to the IN. For example, the ASN may be a node configured in the M2M terminal in hardware.

The middle node 340 may also be a node including a CSE and including zero or more AEs. At this time, the MN may be set in the field domain. The MN may be connected based on a reference point with another MN or IN. Also, as an example, the MN may be configured in the M2M gateway in hardware.

In addition, as an example, the non-M2M terminal node 350 (Non-M2M device node, NoDN) is a node that does not include M2M entities may be a node that performs management or collaboration with the M2M system.

4 is a diagram illustrating a common service function.

Referring to FIG. 4, common service functions may be provided. For example, common service functions include application and service layer management, communication management and delivery handling, data management and storage, and device management. , Discovery, Group Management, Location, Network Service Exposure / Service Execution and Triggering, Registration, Security, Service Billing, and It may provide at least one or more functions of calculation (Service Charging and Accounting), Service Session Management (Service Session Management), and Subscription / Notification (Notification). At this time, M2M terminals may operate based on a common service function. In addition, the common service function may be possible in other embodiments, and is not limited to the above-described embodiment.

5 is a diagram illustrating a method in which a sender and a receiver exchange messages.

Referring to FIG. 5, an originator 510 may transmit a request message to a receiver 520. In this case, the transmitter 510 and the receiver 520 may be the M2M terminal described above. However, the present invention is not limited to the M2M terminal, and other terminals may be possible, and are not limited to the above-described embodiment. Also, as an example, the sender 510 and the receiver 520 may be the above-described node, entity, server, or gateway. That is, the sender 510 and the receiver 520 may be a hardware configuration or a software configuration, and are not limited to the above-described embodiment.

In this case, as an example, the request message transmitted by the sender 510 may include at least one parameter. In this case, as an example, the parameter may be an essential parameter or a selection parameter. For example, parameters related to a transmitter, parameters related to a receiver, an identification parameter, an operation parameter, and the like may be essential parameters. In addition, other information may be a selection parameter. In this case, the transmitter-related parameter may be a parameter for the sender 510. Also, the receiver related parameter may be a parameter for the receiver 520. In addition, the identification parameters may be parameters required for mutual identification.

In addition, the operation parameter may be a parameter for distinguishing an operation. As an example, the operation parameter may be set to at least one of Create, Retrieve, Update, Delete, and Notify. That is, it may be a parameter for distinguishing an operation.

In this case, when the receiver 520 receives the request message from the sender 510, the receiver 520 may process the request message. As an example, the receiver 520 may perform an operation included in the request message. For this, the receiver 520 may determine whether a parameter is valid and whether there is an authority. In this case, if the parameter is valid and the authority is authorized, the receiver 520 may check whether the resource to be requested exists and perform processing based on this.

For example, when an event occurs, the sender 510 may transmit a request message including a parameter for notification to the receiver 520. The receiver 520 may check the parameter for the notification included in the request message, perform an operation based on the request message, and send the response message back to the sender 510.

6 is a diagram illustrating attributes for a subscription resource.

Referring to FIG. 6, a subscription resource may include attributes. For example, although the attributes of the subscription resource are described in FIG. 6, this is only one example and may be added, deleted, or changed. At this time, information necessary for subscription-notification may be shared through an attribute of a subscription resource. In addition, as an example, information necessary for performing an operation required for subscription notification may be defined as attribute information, and is not limited to the above-described embodiment. For example, the subscription resource may include “notificationFailcounter”. In this case, “notificationFailcounter” may indicate the maximum number of notification messages that can transmit a notification. Also, as an example, “notificationURI” may indicate address information about a target system to receive notification. In addition, information necessary for subscription-notification may be defined as attribute information as shown in FIG. 6 and is not limited to the above-described embodiment.

7 is a diagram illustrating a method of transmitting a accumulated notification message.

In an M2M system, M2M terminals may operate based on subscription-notification. In more detail, the M2M platform may register an event through a subscription resource and transmit a notification message when the event occurs.

For example, a target system may allocate a subscription resource to a hosting system, and the hosting system may transmit a notification message to the target system when an event occurs. In this case, the hosting system and the target system may be a system that operates based on the above-described M2M terminal. That is, each M2M terminal may be a terminal including a hosting system and a target system.

For example, when a car parked is a hosting system, an event such as an impact may occur. At this time, the event notification for the shock may transmit a notification message to the terminal registered as the vehicle owner, a target system such as a police system, insurance company system. That is, the hosting system may monitor the event based on the subscription and transmit a notification message when an event occurrence is detected.

In this case, as an example, in connection with a subscription notification, a situation in which a notification message may not be delivered due to a network problem may occur. That is, a connectionless state may be set.

Referring to FIG. 7, after the primary notification message is generated, the secondary notification message is generated, and the notification message may not be transmitted due to the unreachable state while the Nth notification message is generated. Then, when the connection is re-established because the problem of the network or the like is solved, the hosting system may transmit a notification message that has not been transmitted in the meantime to the target system. In other words, the hosting system temporarily stores the accumulated notification message and transmits it when the connection is reestablished. However, the accumulated notification message may include a notification message necessary only at a specific time. Also, for example, some of the accumulated notification messages may be notification messages that are not currently needed. Therefore, there may be a need for a method of processing a notification message that occurs during a connection failure in view of system overhead.

In this case, for example, referring to FIG. 7, after notifications 1 to n are generated in a state where the connection state is not guaranteed, the connection state may be changed again. In this case, the hosting system may need a method for efficiently processing the above-described information about notifications 1 to n.

In this case, for example, the priority may be set differently for each notification message in relation to the above-described notifications 1 to n. For example, after returning to the connected state, the hosting system may first send a notification message of high importance. In addition, as an example, the hosting system may transmit only a high priority notification message, which will be described later.

As another example, an attribute for processing notifications 1 to n may be set. That is, attribute information for the notification operation may be set.

In this case, as an example, the attribute for the notification operation may be “pendingNotification” and as an example of “pendingNotification”, it may be as Table 1 below.

More specifically, “pendingNotification” of Table 1 may be attribute information indicating how to handle a notification message generated based on a connection failure. As an example, when “pendingNotification” is set to “sendLatest”, the hosting system may transmit only the last notification message generated after switching to the connected state. That is, only the above-described notification message n can be transmitted. As another example, in the case of “sendAllpending”, the hosting system may transmit all notification messages generated during the connection failure after being switched to the connection state. At this time, for example, in the case of “sendAllpending,” all notification messages may be sequentially transmitted or all notification messages may be transmitted in a bundle, which will be described later.

TABLE 1

As another example, Table 2 may be attribute information indicating the importance of the notification message. For example, “notificationEventCat” of Table 2 may be attribute information indicating an event category for a notification message generated by a subscription, and a notification message may be transmitted after resetting a connection based on this. For example, the event category may be set to “immediate” which needs to be transmitted immediately. In addition, at any point in time, "bestEffort" may be set. In addition, "latest" may be set to transmit only the latest notification message. For example, in the case where "sendLatest" of Table 1 described above is set, the Event Category may be "latest". At this time, as an example, when comparing event categories, “immdidate” may have the highest importance. Therefore, after the hosting system is switched to the connected state, only the highest priority notification message can be transmitted based on the event category, and is not limited to the above-described embodiment.

TABLE 2

The following describes the possible attributes in "pendingNotification" as attributes for the notification operation based on the above.

Example 1

In the first embodiment, the attribute information of "pendingNotification" is proposed as described above. More specifically, when "pendingNotification" is set to "SendAllpending", all notification messages generated during the connection failure may be transmitted. However, if the connection failure period is long, the information size may be large in the generated notification message. For example, when the notification message generated for a long time while the vehicle is turned off is switched to the connected state and then transmitted, the data size of the notification message may be significantly increased. Therefore, if the bundled transmission for the notification message is performed after switching to the connected state, the overhead may be large because large data should be transmitted. Also, for example, in the case of sequential transmission, it may take a long time because the notification message is many.

In order to solve the above, an attribute of “SendAllpendingchanged” may be set. For example, the “SendAllpendingchanged” attribute may be set independently of “SendAllpending” as attribute information of “pendingNotification”. As another example, “SendAllpendingchanged” is attribute information related to “SendAllpending,” and may be set as additional attribute information of “SendAllpending.” It is not limited to the above-described embodiment. In this case, when the notification message is transmitted based on the above description, only a portion changed from the previous transmission data may be transmitted. In this case, in the case of performing the batch transmission, only the information indicating the previous transmission data and the changed part may be included and transmitted, thereby reducing the data size. In addition, for example, even in the case of sequential transmission, the first transmission data may be transmitted, and only the changed portion may be transmitted thereafter. For example, if there is no changed part, the transmission can be omitted, thereby reducing the time that occurs in the sequential transmission. As a specific example, when there are a plurality of identical or similar notifications generated after the vehicle is turned off, it is not necessary to transmit all the notification messages, and thus only the changed parts can be compared and transmitted, thereby enabling efficient transmission. .

As another example, “SendAllpending_same_average” or “SendAllpending_same_specifictime” may be set as attribute information. At this time, SendAllpending_same_average ”or“ SendAllpending_same_specifictime ”attribute may be set independently of“ SendAllpending ”as attribute information of“ pendingNotification ”. As another example, SendAllpending_same_average ”or“ SendAllpending_same_specifictime ”is attribute information related to“ SendAllpending, ”and may be set as additional attribute information of“ SendAllpending. ”It is not limited to the above-described embodiment.

More specifically, “SendAllpending_same_average” can reduce the data capacity by calculating and transmitting an average value without transmitting all data for the same information or the same data. For example, when an engine abnormality occurs in a connection failure state and the engine detects an event that reaches a predetermined temperature or more, a notification message including a temperature value of the engine may be transmitted. In this case, the temperature information may be the same information as the same data. In addition, the specific temperature value may be transmitted by calculating an average value thereof as another numerical value for the same data. For example, the notification message may include temperature value information when a notification message occurs based on an event. However, the important level in the notification message is that the temperature of the engine is high, so all the temperature values may not be necessary. That is, a plurality of notification messages may not be needed. Accordingly, the data size can be reduced by deriving an average value for the temperature values included in the plurality of notification messages and transmitting one notification message based on the average value. That is, for the same information or the same data, an average value of numerical values occurring at a plurality of time points may be calculated and transmitted.

As another example, “SendAllpending_same_specifictime” may selectively transmit only information on a specific time point for the same value. For example, “SendAllpending_same_specifictime” may be “SendAllpending_same_latest” or “SendAllpending_same_old”. More specifically, data may not be needed at a time when a plurality of notification messages occur for the same value. For example, since the data generated at the last time may be important for the same value, only a notification message generated at the last time may be transmitted. As another example, since the data generated at the first time may be important for the same value, only a notification message generated at the first time may be transmitted.

For example, a notification message may be generated and transmitted when a boot failure is not performed due to a vehicle system error in a connection failure state, and boot failure information may be included in the notification message. In this case, if the booting problem is solved when the vehicle system error is solved, the notification message may include booting success information. For example, when booting is successful when the vehicle system problem is solved at a specific time and is switched to the connected state, previous boot failure information may not be needed. Therefore, a notification message including information on whether the booting is successful at the last time as a specific time point may be received based on the above-mentioned "SendAllpending_same_specifictime", and the present invention is not limited to the above-described embodiment.

In addition, as an example, a definition of the same value may be necessary as “same”. In this case, as described above, the same value may mean having different numerical values based on the same kind of data or the same kind of information. That is, as described above, the temperature may be the same information, and the specific temperature value may be an individual numerical value, as described above. Also, for example, the same value may be regarded as a value within a preset error range. In this case, the preset error may be changed and set by the user or the system.

As another example, “sendFirst” may be set independently of “SendAllpending”. In this case, as an example, “sendFirst” may transmit the first data occurring in the unconnectable state after the connection recovery. For example, the unconnectable state may be caused by the user's intention, but may occur regardless of the user's intention. That is, the user may be switched to the unreachable state when the user does not want to. At this time, the user needs to check the information on the notification message that occurs first when the switch to the disconnected state after the connection state recovery. For example, the subscription / notification may be a message based on a connection state based on a network or the like. For example, when detecting whether the network is abnormal, a notification message may be transmitted. In this case, the notification message may include parameters related to network configuration. However, when a network error occurs, the connection may be often caused. Information on the first notification message may be needed after the connection failure. The target system can then receive the first notification message once the problem of network anomalies is resolved and transitioned to the connected state. In this case, the target system may check whether the abnormality occurred in the network based on the parameter information included in the first notification message.

That is, "sendFirst" may be set for information on which the cause analysis of the unconnectable state is important as a notification message related to the connected state, and is not limited to the above-described embodiment.

Example 2

8 is a diagram illustrating a method of transmitting a notification message based on “SendAllpending”.

Referring to FIG. 8, in case of “SendAllpending,” a notification message may be bundled and transmitted or sequentially transmitted. In this case, for example, in the case of a batch transmission, the data size may be increased, but may be transmitted at a time, so that a collision problem with other messages may not occur. On the other hand, in the case of sequential transmission, a notification message accumulated for a certain period may be transmitted. Thus, if a new notification message occurs, a collision with the notification message may occur. In addition, as an example, the receiving terminal (e.g. target system) needs to check the transmission type of the notification message in order to adjust the network load or determine whether to receive another message. To this end, when switched to the connected state, an indicator indicating a batch transmission or a sequential transmission may be transmitted to the receiving terminal.

In more detail, the transmitting terminal (e.g. hosting system) may transmit a notification message as described above when the connection terminal transitions from the failed connection to the connected state. In this case, as an example, the transmitting terminal may recognize that the terminal is switched to the connected state. For example, the transmitting terminal may recognize that the ACK message is received from the receiving terminal or switched to the connected state through another method. In this case, the transmitting terminal may transmit the information on the indicator to the receiving terminal before transmitting the accumulated notification message. In this case, the indicator may indicate bundled transmission or sequential transmission as 1 bit information. As another example, after being switched to the connected state, the transmitting terminal may include the aforementioned indicator in the first message and transmit the same. For example, in the case of the packed transmission, the above-described indicator information may be included in the packed transmission message. In this case, the indicator information may be control information, and the receiving terminal may first check (or decode) the indicator information in the bundled transmission message. Through this, the receiving terminal may receive a bundle transmission message. Meanwhile, in the case of sequential transmission, indicator information may be included in the first notification message transmitted sequentially and transmitted. The receiving terminal may know that the packet is not bundled transmission through the indicator included in the first notification message, and may confirm that the notification messages are sequentially transmitted later.

As another example, in case of “SendAllpending,” there may be a case where there are a plurality of notification messages having different notification importance levels. For example, the notification importance may be “immediate”, “besteffort” or “latest” described above, as described above. In this case, as an example, when sequential transmission is performed as “SendAllpending,” notification messages (e.g. “immediate”) having high notification importance may be sequentially transmitted first. Thereafter, after all of the high priority notification messages are transmitted, a subordinate notification message (e.g. “besteffort”) may be sent. Also, as an example, a notification in which processing is important among data with high notification importance may be included. More specifically, there is a need for the terminal to preferentially perform an operation based on safety or other issues based on the information included in the notification message. Meanwhile, the notification message may be continuously transmitted as described above. In this case, the terminal should simultaneously perform the data receiving process in processing the above operation, there is a possibility that a problem occurs. Therefore, in the case of “SendAllpending,” only a high priority notification message may be transmitted, and a low priority message may be transmitted after a predetermined time elapses. As another example, in case of “SendAllpending”, only a high priority notification message may be transmitted, and a low priority message may be omitted.

As another example, only a high priority notification message may be transmitted and received at a time, and a low priority notification message may not be transmitted. As another example, a low priority notification message may be transmitted in a separate bundle. As another example, when a notification message of low importance is transmitted in a separate bundle, the notification message may be transmitted after a predetermined time, and the present invention is not limited to the above-described embodiment.

That is, in the case of “SendAllpending”, a message of high importance may be set to be processed first.

Example 3

9 is a diagram illustrating a case where a notification message is transmitted by a repeater.

Referring to FIG. 9, entity 2 920 may transmit a notification message received from entity 1 910 to entity 3 930. That is, entity 2 920 may be a repeater. In this case, a connection may exist between entity 1 910 and entity 2 920, and a connection may exist between entity 2 920 and entity 3 930. That is, entity 1 910 may transmit a notification message to entity 2 920 through connection with entity 2 920. In addition, entity 2 920 may relay a notification message received from entity 1 910 through connection with entity 3 930.

In this case, as an example, in the above-described case, connectionlessness may occur. That is, it may be in a disconnected state. In this case, similar to the above-described embodiments 1 to 2 when the notification state is switched from the non-connection state to the connection state may be transmitted. In this case, as an example, as a case of “SendAllpending”, a case where the bundled transmission is performed may be considered.

Referring to FIG. 9, when the connection between entity 1 910 and entity 2 920 is changed from a disabled state to a connected state, entity 1 910 may transmit its notification message in a bundle. That is, notification message 1 to notification message n may be transmitted in a bundle. Meanwhile, entity 2 920 may also transmit its notification message to entity 3 930. In this case, when the connection between the entity 2 920 and the entity 3 930 is changed from the disabled state to the connected state, the entity 2 920 may also transmit its notification message to the entity 3 930 in a bundle. That is, entity 2 920 may transmit notification message 1 ′ to notification message n ′ in bundle 3 to entity 3 930.

At this time, as an example, if the data size of the notification message is not large, it is a bundled transmission, and the entity 2 920 may bundle both the notification message and the notification message of the entity 1 910 and transmit it to the entity 3 930. . That is, the bundled transmission message transmitted by entity 2 920 may include both notification message 1 to notification message n of entity 1 910 and notification message 1 ′ to notification message n ′ of entity 2 920. Through this, entity 3 930 may receive all notification messages at one time, and may reduce a transmission time. In this case, as an example, the bundled transmission message transmitted by the entity 2 920 may include an indicator for distinguishing the notification message of the entity 1 910 from the notification message of the entity 2 920. As another example, each notification message may include identification information for each entity. That is, entity 3 930 may distinguish the subject that transmitted the notification message through the respective identification information in the received batch transmission message, which is not limited to the above-described embodiment.

Example 4

10 and 11 illustrate a method of preventing duplicate subscriptions when a subscription requester and a notification target are different.

Referring to FIG. 10, a subscription request or originator 1010 and a notification target or target system 1030 may be different. That is, there may be a subscription for the third notification, in which case it may be necessary to check for redundancy.

For example, referring to FIG. 10, a subscription host (Hosting CSE or Hosting System) 1020 and the notification target 1030 may generate a subscription 1. In this case, the subscription host 1020 may transmit a notification for subscription 1 to the notification target 1030. That is, when an event corresponding to the subscription 1 resource occurs, the subscription host 1020 may transmit a notification 1 corresponding to the subscription 1 to the notification target 1030. Additionally, the subscription requester 1010 may create a subscription 2 with the subscription host 1020. However, when an event corresponding to the subscription 2 resource occurs, the subscription host 1020 may transmit notification 2 to the notification target 1030 instead of the subscription requester 1010. That is, the case where the subscription requester 1010 and the target for transmitting the notification message are different may be considered.

In this case, for example, the notification 2 may include information about the subscription host 1020. That is, notification 2 may include information about who the subscription requester 1010 is. Thus, even if notification 1 and notification 2 notify the same data, notification 1 and notification 2 can be distinguished from each other. That is, the notification target 1030 may receive each notification separately. However, when notification 1 and notification 2 are notifications based on the same data, the notification target 1030 may receive them in duplicate, which may be inefficient.

As an example, a subscriber may consider a case where an ITS center, a subscription host is a vehicle, and a notification target is an insurance center. In this case, as an example, a case in which a fire occurs due to vehicle damage may be considered. In this case, when an event for a fire occurs in response to subscription 2, the ITS center may transmit a notification message for dispatch service to the insurance center that is a notification target as notification 2. In addition, as an example, the vehicle may transmit notification 1 for dispatch service to the insurance center, which is a notification target when a fire event occurs in advance through subscription 1 as the subscriber requester. That is, based on the same event of a vehicle accident, the insurance center that is the notification target may receive the same notification in duplicate.

In the above situation, the notification 2 may be redundant as the notification 1, and may be unnecessary. Therefore, when setting a subscription to prevent the above-mentioned situation, it is necessary to determine in advance whether or not it is a duplicate subscription.

More specifically, referring to FIG. 11, the subscription hosts Entity 2 and 1120 may generate the notification targets Entity 3 and 1130 and the subscription 1. Thereafter, a case in which the subscription requester Entity 1, 1110 generates a subscription 2 with the subscription host Entity 2, 1120 may be considered. At this time, as described above, since the subscription host has already created the notification targets (Entity 3, 1130) and subscription 1, it is necessary to confirm whether the subscription is a duplicate subscription. In this case, the subscription host 1120 may first determine whether the subscription requester 1110 may subscribe to the subscription host 1120. In this case, if the subscription is not available, the generation for the subscription 2 may be rejected. On the other hand, if subscription is possible, subscription 2 may be generated. Thereafter, the subscription host 1120 may send a Notify / Verify Request to the notification target 1130. In this case, the notification target 1130 may determine whether the subscription host 1120 may perform notification based on the subscription 2 to the notification target 1130 based on the notification and verification request of the subscription host 1120. .

Thereafter, the notification target may include information on whether the notification can be performed in the notification and verify response (Notify / Verify Response) to send to the subscription host 1120. In this case, the subscription host 1120 may check whether the verification is successful based on the information included in the notification and verification response message. That is, when the notification target 1130 transmits information indicating that the subscription host 1120 may perform notification 2 in the notification and verification response, the subscription host 1120 may generate subscription 2. On the other hand, when the notification target 1130 transmits information indicating that the subscription host 1120 cannot perform notification 2 in the notification and verification response, the subscription host 1120 cannot generate subscription 2 and cancel the subscription. Information about may be transmitted to the subscription requester 1110.

Meanwhile, the notification target 1130 transmits the information indicating that the subscription host 1120 may perform notification 2 in the notification and verification response, so that the subscription is duplicated even though the subscription host 1120 may generate subscription 2. There is a need to determine whether or not. That is, whether subscription 2 is included in subscription 1 can be checked. In this case, if the subscription 2 is not included in the subscription 1, the approval message for the subscription 2 may be transmitted to the subscription requester 1110 and the subscription 2 may be generated. On the other hand, when subscription 2 is included in subscription 1, the subscription host 1120 may not generate subscription 2 and may transmit information indicating that subscription 2 cannot be generated to subscription requester 1110 and notification target 1130.

Meanwhile, as an example, whether subscription 2 is included in subscription 1 may be determined based on information included in an event and a notification message. More specifically, when the information included in the event and notification message of the subscription 2 is the same, it can be seen that the subscription 2 is included in the subscription 1.

For example, even if the event conditions of Subscription 1 and Subscription 2 are the same, if the information included in the notification message is different, it may be considered that Subscription 2 is not included in Subscription 1. However, the sameness of the information included in the notification message may mean not the control information such as the identification information but the sameness of the data information actually reported. That is, even if identification information of notification 2 and identification information of notification 1 differ, it can be said that subscription 2 is included in subscription 1, even if it contains the same data.

Also, as an example, even if the data included in the notification 1 and the notification 2 are the same, if the event conditions are different, the subscription 2 may not be included in the subscription 1. For example, when a vehicle damage event and a fire event occur, a notification message for requesting emergency dispatch may be transmitted to a notification target, which is an insurance center, but in both cases, the event may be different, and thus may be different subscriptions. That is, it can be seen that subscription 2 is included in subscription 1 only when the event and notification messages are the same.

As another example, subscription 2 may be considered to be included in subscription 1 in the case of an event of the same type even though specific values of the event are different. For example, a notification generated based on an event having a temperature of 80 degrees or more and a notification generated based on an event having a temperature of 100 degrees or more may be regarded as being caused by the same event and are not limited to the above-described embodiment. .

That is, it is determined whether the subscription is duplicated, and in the case of duplication, unnecessary subscription may not be granted, and the present invention is not limited to the above-described embodiment.

12 is a diagram illustrating a method of transmitting a accumulated notification message.

Referring to FIG. 12, in the M2M system, the M2M terminal may detect that a plurality of notification messages are generated in the unconnectable state. (S1210) In this case, as described above with reference to FIGS. 1 to 11, the M2M terminal is an M2M system. It may be a terminal operating based on. For example, the M2M terminal may be a concept corresponding to the above-described hosting system and target system. Also, as an example, the M2M terminal may be a concept corresponding to the aforementioned entity. Also, as an example, the M2M terminal may be a concept corresponding to a subscription requester, a subscription host, and a notification target. That is, the device operating based on the above description may be an M2M terminal and is not limited to the above-described embodiment. Next, when the non-connection state is switched to the connection state (S1220), the M2M terminal may transmit at least one or more of the plurality of notification messages. (S1230) In this case, as described above with reference to FIGS. The plurality of notification messages may be transmitted based on the notification attribute information. In this case, the notification attribute information may correspond to “pendingNotification” based on Table 4 described above, as described above. In this case, as an example, when “pendingNotification” is set to “sendAllpending”, the M2M terminal may transmit all the notification messages accumulated in the connection unavailable state after switching to the connection state. In this case, as an example, the accumulated notification message may be transmitted only with a changed portion compared to the previous notification message. For example, the first notification message and the second notification message among the accumulated plurality of notification messages may be sequentially transmitted. That is, the first notification message may be a notification message that occurred earlier than the second notification message. In this case, the second notification message may include only information on the changed part of the first notification message. For example, if there is no changed portion of the second notification message compared to the first notification message, the transmission may be omitted. In addition, as an example, the notification message including only the information on the changed part may be transmitted even in the batch transmission and the sequential transmission, but is not limited to the above-described embodiment.

In addition, when the data included in the plurality of notification messages are the same, one notification message including average value information about data included in each of the plurality of notification messages may be transmitted after being switched to the connected state. That is, when data is the same information and each notification message includes a numerical value for the same information, only one notification message including average value information can be transmitted. For example, when data is temperature information as the same information and each notification message includes a numerical value for a specific temperature, only one notification message including average value information for the numerical value may be transmitted.

In addition, as an example, when the data is the same information, a notification message including only a numerical value for the data generated at a particular time point may be transmitted. That is, when the data included in the plurality of notification messages are the same information, only the notification messages generated at the first time point among the plurality of notification messages may be transmitted after the connection state transition.

As another example, after the plurality of notification messages are switched to the connected state, the plurality of notification messages may be based on either a batch transmission or a sequential transmission, as described above. In this case, after switching to the connected state, an indicator indicating whether to transmit a bundle or sequential transmission may be transmitted, and through this, the receiving terminal may check the transmission method. This is as described above.

Also, for example, higher priority notification messages of a plurality of notification messages may be transmitted first, and a lower priority notification message may be transmitted later. In this case, for example, a low priority notification message may be transmitted after a predetermined time for processing a high priority notification message, as described above. In addition, for example, after a high priority notification message is transmitted in one bundle, a low priority notification message may be transmitted in one bundle, as described above.

As another example, it may be set as “sendFirst” as notification attribute information. In this case, as described above, only the first notification message generated in the unconnected state may be transmitted after the connection state change to confirm cause information of the unconnectable state, as described above.

13 is a diagram illustrating a configuration of an M2M terminal device according to the present disclosure.

The M2M terminal device 1300 may include a processor 1310 for controlling the device and a transceiver 1320 for transmitting and receiving a wireless signal. In this case, the processor 1310 may control the transceiver 1320. Also, the M2M terminal device 1300 may communicate with another M2M terminal device 1400. As an example, the above-described sender and receiver may be M2M terminals of FIG. 13. The other M2M terminal device 1400 may also include a processor 1410 and a transceiver 1420, and may perform the same role. In addition, the device of FIG. 13 may be another device. For example, the device may be a device for performing communication, a vehicle, a base station, or the like. That is, the present invention refers to an apparatus capable of performing communication, and is not limited to the above-described embodiment.

Embodiments of the present invention described above may be implemented through various means. For example, embodiments of the present invention may be implemented by hardware, firmware, software, or a combination thereof.

The detailed description of the preferred embodiments of the invention disclosed as described above has been provided to enable any person skilled in the art to make and practice the invention. Although the above has been described with reference to the preferred embodiments of the present invention, those skilled in the art will variously modify and change the present invention without departing from the spirit and scope of the invention as set forth in the claims below. I can understand that you can. Thus, the present invention is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein. In addition, while the preferred embodiments of the present specification have been shown and described, the present specification is not limited to the specific embodiments described above, and the technical field to which the present invention pertains without departing from the gist of the present specification claimed in the claims. Of course, various modifications can be made by those skilled in the art, and these modifications should not be individually understood from the technical spirit or prospect of the present specification.

In the present specification, both the object invention and the method invention are described, and the description of both inventions can be supplementarily applied as necessary.

In addition, the present invention has been described with reference to the preferred embodiments. Those skilled in the art will appreciate that the present invention can be implemented in a modified form without departing from the essential features of the present invention. Therefore, the disclosed embodiments should be considered in descriptive sense only and not for purposes of limitation. The scope of the present invention is shown in the claims rather than the foregoing description, and all differences within the scope will be construed as being included in the present invention.

M2M terminal: 1300 Processor: 1310
Transceiver: 1320 M2M Terminal: 1400
Processor: 1410 Transceiver: 1420

Claims (20)

In the method for transmitting a notification message in the M2M system,
Generating a plurality of notification messages in a connectionless state;
And transmitting at least one or more of the plurality of notification messages when the unconnected state is switched to a connection state.
The notification message transmitted from the plurality of notification messages is determined based on notification attribute information.
The method of claim 1,
And when the notification attribute information is “SendAllpending”, transmitting all of a plurality of notification messages generated in the unconnectable state.
The method of claim 2,
And when a first notification message and a second notification message of the plurality of notification messages are sequentially generated, the second notification message includes only changed information compared to the first notification message.
The method of claim 3, wherein
If the changed information is not present in the second notification message, transmission to the second notification message is omitted.
The method of claim 2,
And when the data included in the plurality of notification messages is the same information, transmitting one notification message including average value information for data included in each of the plurality of notification messages after the connection state change.
The method of claim 2,
And transmitting data after switching of the connection state, only a notification message generated at a first time point among the plurality of notification messages when the data included in the plurality of notification messages are the same information.
The method of claim 2,
And the plurality of notification messages are transmitted based on one of a batch transmission or a sequential transmission after being switched to the connected state.
The method of claim 7, wherein
And an indicator indicating whether to transmit the bundle or the sequential transmission before the plurality of notification messages are transmitted after the transition to the connected state.
The method of claim 7, wherein
When the plurality of notification messages are transmitted based on the sequential transmission, notification messages having a first priority are transmitted first, and notification messages having a second priority after the notification messages having the first priority are transmitted. Are sent,
And the first priority has a higher priority than the second priority.
The method of claim 9,
And when the first time elapses after the notification messages with the first priority have been transmitted, the notification messages with the second priority are sent.
The method of claim 7, wherein
When the plurality of notification messages are transmitted based on the bundle transmission, notification messages having a first priority are first transmitted in one bundle, and notification messages having the second priority are transmitted in one bundle,
And the first priority has a higher priority than the second priority.
The method of claim 1,
And when the notification attribute information is set to "sendFirst", transmit only the first notification message occurring in the disconnection state after the connection state transition.
An apparatus for transmitting a notification message in an M2M system,
Transmitting and receiving unit for transmitting and receiving a signal;
And a processor for controlling the transceiver.
The processor,
Detect that a plurality of notification messages occur in a connectionless state,
When the non-connection state is converted to a connection state, at least one of the plurality of notification messages is transmitted,
And a notification message transmitted among the plurality of notification messages is determined based on notification attribute information.
The method of claim 13,
And when the notification attribute information is "SendAllpending", transmitting all of a plurality of notification messages generated in the unconnectable state.
The method of claim 14,
And when a first notification message and a second notification message of the plurality of notification messages are sequentially generated, the second notification message includes only changed information compared to the first notification message.
The method of claim 15,
And when the changed information is not present in the second notification message, transmission to the second notification message is omitted.
The method of claim 14,
When the data included in the plurality of notification messages is the same information, transmitting a notification message, one notification message including the average value information for the data contained in each of the plurality of notification messages after the connection state switching Device.
The method of claim 14,
And transmitting only a notification message generated at a first time point of the plurality of notification messages after the connection state switching, when the data included in the plurality of notification messages is the same information.
The method of claim 14,
And the plurality of notification messages are transmitted based on one of a batch transmission or a sequential transmission after being switched to the connected state.
The method of claim 19,
And an indicator indicating whether the bundled transmission or the sequential transmission is transmitted after the transition to the connected state and before the plurality of notification messages are transmitted.

Images