KR102120231B1 - Automatic generation method of sensor node program using state transition diagram - Google Patents

Abstract

The present invention relates to a method for automatically generating a sensor node program through a state transition diagram capable of automatically generating a sensor node program or a program skeleton through a state transition diagram for a sensor node, and more specifically, the state of the sensor node. A state value generation step in which the indicated state value is constructed; An event value generation step in which an event value representing an event of the sensor node generated from the state value is configured; A condition value generating step in which a condition value indicating the type (condition) of the event value is constructed; An event value coding step in which source codes (programs) of a programming language corresponding to the generated event values and condition values are generated and stored; A diagram generation step in which a state transition diagram is generated using the state value, the event value, and the condition value; And a program output step in which a program for a sensor node is output in a predetermined code form based on the state values, event values and condition values of the generated state transition diagram and stored source code. It relates to a method for automatically generating a sensor node program.

Description

Automatic generation of sensor node program through state transition diagram {AUTOMATIC GENERATION METHOD OF SENSOR NODE PROGRAM USING STATE TRANSITION DIAGRAM}

The present invention relates to a method for automatically generating a sensor node program through a state transition diagram, and in particular, a sensor node program through a state transition diagram capable of automatically generating a sensor node program or a program skeleton through a state transition diagram for a sensor node. It is about the automatic generation method.

The sensor network is useful in collecting and applying sensor data in various fields such as marine, defense, smart home, and smart factory. In particular, as the 4th Industrial Revolution recently emerged as an issue, cloud computing, big data computing, and the Internet of Things (IoT) have become issues together, and the sensor network can be said to be a representative technology that is the basis of the IoT. The sensor network is largely composed of sensors, sensor nodes, and gateways. The sensor node, which is directly involved in collecting sensor data, which is one of the roles of the sensor network, is a sensor node.

The main role of the sensor node is to collect the data of the surrounding environment and process it and deliver it to the upper node. Due to the frequent communication for the collection of sensor data and delivery to the upper node, the sensor node's energy efficiency, communication overhead, etc. It has a huge effect. In particular, energy efficiency is important for a sensor network with limited resources, so it is necessary to increase the energy efficiency by configuring the sensor node that has a great influence on the performance of the sensor network to suit the usage environment.

Writing sensor node code (program) for acquiring sensor data and sending/receiving data or messages on sensor network is a task that requires expertise and skills in hardware, especially microcontroller devices, embedded programming languages, and embedded programming. It takes a lot of time, effort, and trial and error to master the skills and techniques. Therefore, to reduce the time, effort and trial and error, and to increase productivity and maintainability, identify the elements that cover the general functions that the sensor node can perform, and design and automate the embedded software of the sensor node based on these elements. We propose a method using a state transition model to generate codes.

The reason for designing the sensor node embedded software and generating the code automatically using the state transition model is because it has the following advantages.

1. It can facilitate modeling of sensor node software.

2. The program is designed with the state transition model itself, so it can be easily converted into event-oriented code.

3. It is easy to compare the processing method and difference for each model.

4. Productivity of sensor node program can be increased and maintenance is easy.

(Quote 1) DongHyun Shin, Changhwa Kim, "Sensor Node Design based on State Transition Model" Journal of Korea Multimedia Society Vol. 20, No. 8, August 2017 (pp. 1357-1368)

The technical problem to be solved by the present invention is to generate a state transition diagram based on the configured state, event and condition values, and through this, a sensor node program through a state transition diagram that can automatically generate a sensor node program of a predetermined type. It is to provide an automatic generation method.

Another technical problem to be solved by the present invention is to generate a state transition diagram as described above, and through this, a state transition diagram capable of providing a program skeleton by outputting it in a form of pseudo code according to a grammar for each programming language. It is to provide a method for automatically generating a sensor node program through the.

According to a feature of the present invention for achieving the above technical problem, the present invention relates to a method for automatically generating a sensor node program through a state transition diagram that generates a program for a sensor node using a state transition diagram. A state value generation step in which a state value representing a state is configured; An event value generation step in which an event value representing an event of the sensor node generated from the state value is configured; A condition value generating step in which a condition value representing the type (condition) of the event value is constructed; An event value coding step in which source codes (programs) of a programming language corresponding to the generated event values and condition values are generated and stored; A diagram generation step in which a state transition diagram is generated using the state value, event value, and condition value; And a program output step in which a program for a sensor node is output in a predetermined code form based on the generated state value, event value, and condition value of the state transition diagram and the stored source code. do.

In addition, the step of generating a status value includes: a status value input step in which a status value representing the state of the sensor node is input; And a status value deleting step in which the input status value is deleted.

In addition, the status value is composed of at least a plurality of status values selected from one group including Start, PortCheck, Sleep, InterruptCheck, MessageProcessing, Data/MessageReception, DataTransmission, Data/MessageOptionJudgement, Data/MessageSourceJudgement, DataSave and Stop It is characterized by.

In addition, the event value generating step includes: an event value input step in which an event value generated from the status value is input; And an event value deletion step in which the input event value is deleted.

In addition, the event value includes the event function name and parameters, and the function code is selectively included and displayed.

In addition, the event value, MessageExistance(), MessageReceptionCompletion(), DataTransmissionCompletion(), MessageSourceCheck(), MessageOptionCheck(), FinalData(), InterruptCheck(), WFU, ProcessingCompletion, Interrupt at least a plurality of selected from the group It is characterized by consisting of event values.

In addition, the condition value generation step, characterized in that it comprises; a return value assignment step to which the type or type of the return value for the event value is assigned.

In addition, the step of generating the diagram is characterized in that a user interface (UI) that is schematized through the status value, event value, and condition value is used.

In addition, in the generated state transition diagram, one of the state value and the event value and condition value connected thereto are displayed to be distinguished from the other of the state value and the event value and condition value connected thereto.

In addition, the preset code type is characterized in that it is a pseudo code (Pseudo Code).

In addition, the programming language is characterized in that any one of the embedded programming language.

The method for automatically generating a sensor node program through the state transition diagram according to the present invention described above has the following effects.

First, it is possible to facilitate the modeling of the sensor node software by using the state transition model.

In addition, since the program can be designed with the state transition model itself, it can be easily converted into an event-oriented code (program).

In addition, it is easy to design a state transition diagram based on state values, event values, and condition values, and can be easily converted into a program because it is output as a predetermined source code through the designed state transition diagram.

In addition, it is easy to maintain the sensor node program through maintenance of the state transition diagram, and even if the complete source code is not output, the program skeleton is provided for each embedded programming language, so even beginner programmers can easily perform the program work. (Program) The design and production time can be reduced to improve work efficiency.

1 is a configuration diagram according to an embodiment of a method for automatically generating a sensor node program through a state transition diagram according to the present inventors;
2 to 12 are views showing a process of generating a state transition diagram according to an embodiment of the present invention,
13 is a view showing a state transition arrangement state in the state transition diagram generation in FIGS. 2 to 12,
14 is a diagram illustrating a state transition diagram based on polling according to an embodiment;
15 is a diagram illustrating an interrupt-based state transition diagram according to an embodiment;
16 is a diagram illustrating a state transition diagram based on polling and interruption according to an embodiment.

Hereinafter, some embodiments of the present invention will be described in detail through exemplary drawings. It should be noted that in adding reference numerals to the components of each drawing, the same components have the same reference numerals as possible even though they are displayed on different drawings. In addition, in describing the embodiments of the present invention, when it is determined that detailed descriptions of related well-known structures or functions interfere with the understanding of the embodiments of the present invention, detailed descriptions thereof will be omitted.

In addition, in describing the components of the embodiments of the present invention, terms such as first, second, A, B, (a), (b), and the like can be used. These terms are only for distinguishing the component from other components, and the nature, order, or order of the component is not limited by the term. When a component is described as being "connected", "coupled" or "connected" to another component, that component may be directly connected to or connected to the other component, but another component between each component It should be understood that may be "connected", "coupled" or "connected".

First, to identify the components of the state transition model for constructing the sensor node so that the actual sensor node can be easily modeled based on factors to be considered for designing the sensor node applied to the present invention.

The components of the state transition model for sensor node design can be broadly classified into states (values) and events (values) and conditions (values) dependent on events (values).

The representative types of states that make up the state transition model are Start, PortCheck, Sleep, InterruptCheck, MessageProcessing, Data/MessageReception, DataTransmission, Data/MessageOptionJudgement, Data/MessageSourceJudgement, DataSave, and Stop, which are a total of 11 types. It is as shown in [Table 1].

Of course, depending on the design of the sensor node, states may be added and deleted in addition to the 11 types listed above.

No. States Explanation One Start Program start state 2 PortCheck Port Check state for polling 3 Sleep Sleep state of MCU 4 InterruptCheck State for interrupt check 5 MessageProcessing State for other message processing 6 Data/MessageReception State for data or message reception 7 DataTransmission State for data transmission to upper node 8 Data/MessageOption
Judgement State for immediate or delayed delivery selection 9 Data/MessageSource
Judgement State for data/message source identification 10 DataSave State for data-saving 11 Stop Program stop state

In addition, an event (event) is required for each state to move to the next state. The typical events required for this are MessageExistence(), MessageReceptionCompletion(), DataTransmissionCompletion(), MessageSourceCheck(), MessageOptionCheck(), FinalData(), InterruptCheck(), WFI, Processing Completion, Interrupt, and a total of 10. See Table 2 below for a description.

According to the sensor node design and each state, events may be added and deleted in addition to the above 10 types of states.

No. Events Explanation
One
MessageExistence() This event checks whether any message exists in port check state. If true it moves data/message reception state, otherwise, it remains still in port check state
2
MessageReception
Completion() This event checks whether the message reception is finished completely in data/message reception state. If true the current state moves to data/message source judgement state, otherwise, the state remains still in data/message reception state
3
DataTransmission
Completion() This event checks whether the message transmission is finished completely in data transmission state. If true the current state moves to port check state, otherwise, the state remains still in data transmission state

4
MessageSource
Check() This event checks what the type of the received message source is. If message source is the sensor type in data/message source judgment, the current state moves to data/message option judgment state, but if the source type is ETC, it moves to message processing state

5
MessageOption
Check() If the returned option value as the result of this event is IM in data/message option judgement state, the current state moves to data transmission state, but if it is SV, the current state moves to data save state
IM means immediate transmission, SV means save and transmission
6
FinalData() If the saved data is final in data save state, the current state moves to data transmission state, otherwise, it moves to port check or sleep state
7
InterruptCheck() If the return value of interrupt check() is reception, the current state moves to data/message receipt state, but if ETC, it moves to message processing state 8 WFI If data transmission is completed in data transmission state, the current state moves to WFI (Wait for Interrupt) state 9 Processing
Completion If data transmission is completed in message processing state, the current state moves to sleep state 10 Interrupt If interrupt occurs in sleep state, the current state moves to interrupt state

In addition, the condition indicates the directionality of the event, and the transition occurs according to the event value, and in which direction (to which state) the transition occurs is determined according to the condition value.

The condition value may be expressed as a return value of a function including'True' or'False' or whether it is a value transmitted from a sensor ('Sensor' or'ETC').

The present invention relates to a method for automatically generating a sensor node program through a state transition diagram that generates a program for a sensor node using a state transition diagram.

Referring to FIG. 1, the present invention includes a state value generation step, an event value generation step, a condition value generation step, an event value coding step, a diagram generation step, and a program output step.

In the state value generation step, a state value representing the state of the sensor node is configured. The status values may include Start, PortCheck, Sleep, InterruptCheck, MessageProcessing, Data/MessageReception, DataTransmission, Data/MessageOptionJudgement, Data/MessageSourceJudgement, DataSave and Stop, and at least a plurality of status values selected from the listed status values. Can be configured.

The above-described status values can be added or deleted through the status value input step and the status value deletion step.

In the event value generation step, an event value representing an event of the sensor node generated from the state value is configured. The event value may include MessageExistance(), MessageReceptionCompletion(), DataTransmissionCompletion(), MessageSourceCheck(), MessageOptionCheck(), FinalData(), InterruptCheck(), WFU, ProcessingCompletion, Interrupt, among the event values listed above. It may be composed of at least a plurality of selected event values.

The above-described event values may also be added or deleted through the event value input step and the event value deletion step.

The event value can be expressed in the form of an event function name (processed as a function to check the occurrence of an event). For example, in the event value "MessageExistance()", the event function name is "MessageExistance", and the function is indicated by parameters in parentheses as the "()" part. If the parameter cannot be defined reliably, it is composed of blanks as indicated above, and if the parameter can be reliably defined, it is defined according to the grammar of the programming language to be converted. Following the function parameter definition, if the code for the function cannot be clearly defined, it is composed of blanks. If the function code can be clearly defined, insert the complete actual code according to the syntax of the programming language to be converted. Can be. Here, code refers to a program.

In the condition value generation step, the above-described condition value indicating the type (condition) of the event value is configured. In addition, a type, type, or variable of a return value for the event value may be assigned through a return value assignment step. That is, each return item of the event function should consider the part giving the type and the part giving the variable, and the type and the variable should consider the embedded programming language to be used and the grammar accordingly.

In the event value coding step, source codes (programs) of a programming language corresponding to the generated event values and condition values are generated and stored. Since the status value is displayed as it is in the program, only codes corresponding to the event value and the condition value are generated and stored. At this time, the appropriate source code is selected according to the embedded programming language to be applied and generated and stored. The programming language may be one of embedded programming languages such as embedded C and embedded Java.

In the diagram generation step, a state transition diagram is generated using the state value, the event value, and the condition value, and the process of generating the state transition diagram will be described in more detail with reference to FIGS. 2 to 12.

In the diagram generating step, a user interface (UI) capable of being plotted through the state value, event value, and condition value may be used, and the user interface may be configured with computer software.

When configured with computer software, the user interface can use a monitor, mouse, and keyboard. A main menu in which a plurality of function icons are arranged is configured at an upper portion of the monitor, a status menu is configured at the bottom left of the main menu, and an event (transition) menu is configured at the right. Between the status menu and the event (transition) menu, a screen for generating a status transition is configured. As described above, states and events can be added and deleted as needed.

In the case of embedded C code, the sensor node program needs to initialize the header file to be included (include), and also the initialization such as pin setting, timer selection and clock application to be used for input/output from the MCU in the initialization part. Can be set.

First, as shown in FIG. 2, initially, the state transition diagram starts with a'Start' state of the state value on the generation screen, and an arrow associated with the'Start' state is displayed. The'Start' state means the start and starts from the state connected to the arrow when the program starts.

As shown in FIG. 3, when a desired state is selected from the states of the state menu with a mouse and dragged onto the state transition generation screen, a state figure having a state name is automatically generated at that location. Dotted lines indicate the act of dragging after selecting with the mouse, and numbers indicate the order in which the states were created.

Referring to FIG. 4, when an event that causes a state transition (movement) is selected from the event (transition) menu, condition values corresponding to the transition condition appear on the menu, and a desired state transition condition can be selected from the displayed menu. 'MessageExistance()' in ① indicates an event value, and'TRUE, FALSE' in ② indicates a condition value. At this time, when each of the state values is selected, a transition value that can be generated for each selected state value is activated, and when each of the transition values is selected, a condition value that can be generated for each selected transition value can be configured to be activated.

In FIG. 5, numbers ① and ② indicate the order in which state transition is to be performed, and ③ indicates two nodes where a transition occurs by a selected event or one node (after selecting a state, dragging the mouse to the next state node. When is executed, an arrow is created between two nodes, showing that the selected'event name = condition value' is displayed above the arrow.

In FIG. 6, ④ and ⑤ numbers also indicate an order in which state transition is to be performed, and ⑥ is a'MessageExistence()=False' event in the same way as the previous method, from the'PortCheck' state to the state going to itself. Indicates the transition.

Referring to FIG. 7, the numbers ⑦ and ⑧ also indicate the order in which state transitions should be performed, in order of connection between state transition states (⑨) after event value selection (⑦) and condition value selection (⑧). A state transition diagram is generated.

The numbers shown in FIGS. 8 to 11 indicate the order in which the events are generated, and after all the states are generated, all state transitions (events, conditions) may be generated, but the states and state transitions may be generated in any order. .

In addition, as shown in FIG. 12, in the generated state transition diagram, any one of the state values and the event values and condition values connected thereto are separated from the other one and the event values and condition values connected thereto. It can be marked as possible. As an example, different colors were identified on the drawing. As described above, it is easy to correct errors when classifying, and has an advantage of easily and quickly grasping the progress.

13 shows a state transition arrangement state when a state transition diagram (state transition diagram) is generated by the above procedure.

The state transition array consists of a state transition array element, which is a previous state corresponding to the state transition, a subsequent state, an event that causes the transition, and a condition value of the event.

In addition, as shown in the above state transition generation method, the element generation method selects an event → a condition value selection → when two state selections for a state transition are made, records the previous state, subsequent state, event, and condition values with these values. It can be configured and inserted into the state transition array.

In the program output step, a program for the sensor node is output in the form of a predetermined code based on the state value, the event value, and the condition value of the state transition diagram generated as described above and the stored source code.

If the function value can be reliably defined as described above, the completed program can be output by inserting the complete actual code.

On the other hand, as described above, the state output to the program based on the state transition diagram (state transition diagram) includes the following polling-based state transition diagram, interrupt-based status transition diagram, and polling and interrupt-based status transition diagram. Listen and explain.

14 shows a polling-based state transition diagram generated by the above-described procedure, and the data (Data or Message) described below may be sensor data received from a sensor or higher node data received from a higher node.

Referring to FIG. 14, in the port check step (S100), it is confirmed whether there is data to be received in the reception port with start. If there is no data to be received in the receiving port, check the receiving port again to check whether there is data, and if there is, move to the data receiving step (S110) to receive the existing data (① → ①'→ ②) .

Data source determination step of receiving data in the data receiving step (S110) and confirming whether the received data is data received from the sensor (sensor data) or data received from the upper node (higher node data) when data reception is completed. Go to (S120) (②' → ③).

In the data source determination step S120, it is determined whether the received data is sensor data or upper node data. At this time, in the case of sensor data, it moves to the data option determination step (S130) to determine whether to immediately transmit the received sensor data to the upper node or to integrate it (④).

When it is determined in the data option determination step (S130) that the sensor data is immediately transmitted to the upper node, although not shown in detail, in the data transmission step (S140), the sensor data is transmitted to the upper node, and the sensor data is transmitted. When it is completed, it moves back to the port check step (S100). (⑤ → ⑥) Also, if the transmission of the sensor data is not completed, the process returns to the data transfer step (S140). (⑥')

In addition, when it is determined that the sensor data is integrated and transmitted in the data option determination step (S130), the sensor data received in the data storage step (S150) is stored, and then the port check step (S100) is performed. If the sensor data is the last data, go to the data transfer step (S140) (④ → ⑦ → (⑧ → ① → ①'→ ② → ②'→ ③ → ④ → ⑦) and repeat → ⑨). Specifically, when sensor data is integrated and transmitted, the sensor data is continuously stored each time it is received. This continues to store until the last sensor data is received, and when the last sensor data is received and stored, the previously stored sensor data is integrated and transmitted to the upper node. In addition, if the received sensor data is not the last data, it returns to the data storage step (S150). (⑨')

Here, the data option determination step (S130) is determined whenever sensor data is received, and if it is determined to be transmitted immediately while sensor data is being stored, the corresponding data is immediately transmitted to the upper node.

On the other hand, when the data received in the data source determination step S120 is upper node data received from the upper node, the received upper node data is processed and then the port check step S100 is performed (⑩ → ⑪).

That is, when a signal is detected in the PortCheck state, data is received and it is determined whether to immediately transmit to the upper node or store and transmit according to the message option state. When it starts for the first time, the port is checked (PortCheck), and when a message is received, it is moved to the receiving state. At this time, when the message reception is completed, the message is moved to the status of checking whether it is a sensor message from the sensor or a message from the upper node. In the case of a message from the sensor, it is determined whether the sensor data is immediately transmitted to the upper node or integrated. When the option value is immediately transmitted, it moves to the status of transmitting data and returns to the initial status when data transfer is completed. If the option value is later transmitted, it moves to the status of saving data and moves to the initial status. Is done. At this time, in the case of the last data, it moves to the state of transmitting data, and then, when the data transmission is completed, it moves to the first state. If the message arrives from the parent node, it returns to the initial state after processing the message in the state of processing the message.

When the above-described polling-based state transition diagram is generated, a program is output in a predetermined code form (here, a pseudo code form) in the program output step, and the output codes are as shown in [Table 3].

15 shows an interrupt-based state transition diagram generated by the above-described procedure, which will be described below.

Move to the power saving mode step (S200) to maintain the power saving state with the start (①).

When an interrupt corresponding to reception of data occurs in the power saving mode step S200, it is checked whether an interrupt has occurred in the interrupt checking step S210 (②).

In the interrupt confirmation step (S210 ), when an interrupt for data reception occurs, the process moves to a data reception step (S220) for receiving the corresponding data. When the data reception is completed in the data reception step (S220), the process moves to the data option determination step (S230), which determines whether the received sensor data is to be transmitted to the upper node immediately or integratedly (③ → ③'→ ④).

If it is determined in the data option determination step (S230) that the sensor data is immediately transmitted to the upper node, although not shown in detail, in the data transmission step (S240), the sensor data is transmitted to the upper node, and the sensor data is transmitted. When completed, go back to the power saving mode step (⑤ → ⑥).

In addition, when it is determined that the sensor data is integrated and transmitted in the data option determination step (S230), the sensor data received in the data storage step (S250) is stored, and then the power saving mode step (S200) is performed. If the sensor data is the last data, go to the data transmission step (S240) (④ → ⑦ → (⑧ → ① → ② → ③ → ③'→ ④ → ⑦) and repeat → ⑨). Even in this case, when sensor data is integrated and transmitted, it is continuously stored whenever sensor data is received. This continues to store until the last sensor data is received, and when the last sensor data is received and stored, the previously stored sensor data is integrated and transmitted to the upper node.

Here, the data option determination step (S230) is judged whenever the sensor data is received, and if it is determined as an immediate transmission while the sensor data is being stored, the corresponding data is immediately transmitted to the upper node.

On the other hand, in the interrupt confirmation step (S210), when an interrupt occurs for receiving data (higher node data) from the upper node, the received upper node data is processed and then moved to the power saving mode step (S200) (⑩ → ⑪).

That is, in an interrupt-based state transition diagram, an interrupt method is used while waiting for data or a message. This method is in the Sleep state as soon as it is first started, and the following procedure can be performed only when an interrupt occurs. The second embodiment is similar to the first embodiment, but immediately enters a power saving mode (Sleep state) without first checking the port. At this time, if an interrupt occurs, if the interrupt is an interrupt for data reception, the data is moved to a receiving state, and if it is an interrupt, the interrupt is moved to a processing state. Except for this, the contents of the polling-based state transition diagram are the same.

When the above-described interrupt-based state transition diagram is generated, a program is output in a predetermined code form (here, a pseudo code form) in the program output step, and the output codes are as shown in [Table 4].

16 shows a state transition diagram based on polling and interrupt, and this will be described as follows.

The polling and interrupt base is the same as the interrupt base described above, and it will be different in that it further includes a port check step like the polling base described above.

In the port check step 270, it is checked whether the data exists after the interrupt check step (S210), and if data is present, the data is transferred to the data receiving step (S220) (⑫ → ⑫'→ ⑬).

Other operations may refer to the above-described interrupt-based operation state.

In other words, polling and interrupt-based are techniques that use both polling and interrupting. A power saving mode is performed at the start, and data is received by the polling method at regular intervals, and data is received by the interrupt method otherwise. In this case, data can be received by a polling method between the sensor and the sensor node, and an interrupt method between the sensor module and the sensor node. This method is a mixture of polling-based state transition and interrupt-based state transition, and when the above-described polling and interrupt-based state transition is generated, a predetermined code form in the program output step (here, a pseudo code (Pseudo Program) is output in the form of Code), and the output codes are as shown in [Table 5].

Meanwhile, the preset code type may be output in the form of a pseudo code.

That is, although it can be generated as a complete program (code), if the function is not known exactly, it can be provided in the form of a program skeleton (code skeleton) so that the user can easily complete the program according to each programming language.

An example of the procedure for generating a code frame of an event function is as follows.

First, non-overlapping events corresponding to the value of the'event (transition event)' field for all records in the event transition array are obtained.

Next, for all elements (events) of the set Event (the value of this element is called Event), if the code is already a defined function, the function code is output. If not defined, the pseudo code is as follows. ) Outputs the code frame in the form, but outputs the actual code implementation according to the grammar of the corresponding programming language (where'ReturnValueType' is the type of the value returned by the event function Event).

'ReturnValueType Event() {

}'

Also, an example of the code frame generation procedure of the main program will be described as follows.

Step 1: The predefined initialization code portion is output through the initial screen.

Step 2: Read the first element (state)'Start' from the state array, find the record with the previous state'Start' in the state transition array, and then record the next state of the record (the value of this field is called PostState). Pseudo code is output, but the actual code output follows the syntax of the programming language.

'STATE = PostState;

CONTINUE=TRUE;'

Step 3: Output the following pseudo code, but the actual code output follows the grammar of the corresponding programming language.

'WHILE(CONTINUE) {

SWITCH(STATE) {'

Step 4: Each state (the value of this state is called StateValue) is processed as follows from the second state (element) to the last state (element) of the state array.

Case 1: When'StateValue' is not'Stop' (case 2 will be described later)

Step 4-1: Output the following pseudo code, but the actual code output follows the syntax of the corresponding programming language.

'CASE StateValue:'

Step 4-2: In the state transition array, find all records with this event as the previous state, but if there is only one record, output the following pseudo code, but the actual code output follows the syntax of the programming language (here,'PostState ','TransitionEvent', and'ConditionValue' indicate the values of the fields after the record, event, and condition values).

'IF(TransitionEvent == ConditionValue) THEN STATE = PostState;

BREAK;'

Step 4-3: If there are two or more records in step 4-2, the following cases are processed.

Case 1-1: Output the following pseudo code for the first record, but the actual code output follows the syntax of the corresponding programming language.

'IF(TransitionEvent == ConditionValue) THEN STATE = PostState;'

Case 1-2: The following Pseudo code is output for each record that is not the first record but the last one, but the actual code output follows the syntax of the corresponding programming language.

'ELSE IF(TransitionEvent == ConditionValue) THEN STATE = PostState'

Case 1-3: Output the following pseudo code for the last record, but the actual code output follows the syntax of the corresponding programming language.

'ELSE IF(TransitionEvent == ConditionValue) THEN STATE = PostState;

BREAK;'

Case 2: If'StateValue' is'Stop', the following Pseudo code is output, but the actual code output follows the syntax of the corresponding programming language.

'CASE StateValue:

CONTINUE=FALSE;

BREAK;'

Step 5: Output the following pseudo code, but the actual code output follows the grammar of the corresponding programming language.

'}

}'

In the above, even if all the components constituting the embodiments of the present invention are described as being combined or operated as one, the present invention is not necessarily limited to these embodiments. That is, if it is within the scope of the present invention, all of the components may be selectively combined and operated. In addition, the terms "include", "consist" or "have" as described above mean that the corresponding component can be intrinsic, unless specifically stated otherwise, to exclude other components. It should not be interpreted as being able to further include other components. All terms, including technical or scientific terms, have the same meaning as generally understood by a person skilled in the art to which the present invention belongs, unless otherwise defined. Commonly used terms, such as predefined terms, should be interpreted as being consistent with the contextual meaning of the related art, and are not to be interpreted as ideal or excessively formal meanings unless explicitly defined in the present invention.

The above description is merely illustrative of the technical idea of the present invention, and those of ordinary skill in the art to which the present invention pertains will be capable of various modifications and variations without departing from the essential characteristics of the present invention. Therefore, the embodiments disclosed in the present invention are not intended to limit the technical spirit of the present invention, but to explain, and the scope of the technical spirit of the present invention is not limited by these embodiments. The scope of protection of the present invention should be interpreted by the following claims, and all technical spirits within the equivalent range should be interpreted as being included in the scope of the present invention.

Claims (11)

A method for automatically generating a sensor node program through a state transition diagram that generates a program for a sensor node using a state transition diagram,
A state value generation step in which a state value representing the state of the sensor node is configured;
An event value generation step in which an event value representing an event of the sensor node generated from the state value is configured;
A condition value generating step in which a condition value representing the type (condition) of the event value is constructed;
An event value coding step in which source codes (programs) of a programming language corresponding to the generated event values and condition values are generated and stored;
A diagram generation step in which a state transition diagram is generated using the state value, event value, and condition value; And
And a program output step in which a program for a sensor node is output in a predetermined code form based on the generated state value, event value and condition value of the state transition diagram and the stored source code.
The condition value generating step includes a method for automatically generating a sensor node program through a state transition diagram including a step of assigning a return value to which the type or type of the return value is assigned to the event value.
The method of claim 1, wherein the generating of the status value comprises:
A state value input step in which a state value representing the state of the sensor node is input; And
A method for automatically generating a sensor node program through a state transition diagram, including; a state value deletion step in which the input state value is deleted.
The method of claim 1, wherein the state value,
Sensor node program through a state transition diagram consisting of at least a plurality of status values selected from one group including Start, PortCheck, Sleep, InterruptCheck, MessageProcessing, Data/MessageReception, DataTransmission, Data/MessageOptionJudgement, Data/MessageSourceJudgement, DataSave and Stop Automatic generation method.
The method of claim 1, wherein the generating the event value,
An event value input step in which an event value generated from the status value is input; And
Method for automatically generating a sensor node program through a state transition diagram comprising; an event value deletion step in which the input event value is deleted.
According to claim 1, The event value,
A method for automatically generating a sensor node program through a state transition diagram that includes an event function name and parameters, and optionally includes a function code.
The method of claim 1, wherein the event value,
State transition consisting of at least a plurality of event values selected from the group including MessageExistance(), MessageReceptionCompletion(), DataTransmissionCompletion(), MessageSourceCheck(), MessageOptionCheck(), FinalData(), InterruptCheck(), WFU, ProcessingCompletion, Interrupt How to automatically generate a sensor node program through a diagram.
delete According to claim 1, The diagram generating step,
A method for automatically generating a sensor node program through a state transition diagram in which a user interface (UI), which is schematically illustrated through the state value, event value, and condition value, is used.
According to claim 1,
In the generated state transition diagram, a sensor node program through a state transition diagram is displayed so that any one of the state values and the event values and condition values connected thereto are distinguished from the other state values and the event values and condition values connected thereto. Automatic generation method.
According to claim 1,
The preset code type is a method for automatically generating a sensor node program through a state transition diagram that is a pseudo code.
The method according to any one of claims 1 to 6,
The programming language is a method for automatically generating a sensor node program, which is one of embedded programming languages.

Images