**1. Introduction**

In the Internet of Things (IoT), a wireless sensor network node (WSN) is a system that recognizes physical changes or signals targeting various users or environments. It is widely used in various forms for a range of purposes across home and industrial use. In general, a sensor network requires a single smart sensor node capable of detecting numerous signals such as pressure, temperature, humidity, gas flow, infrared, chemical reactions, surface, sound, steam, and others. Handling huge datasets using multiple sensory modalities is within the domain of machine learning, and interpreting the information from numerous signals is becoming increasingly important in an IoT-driven world. The common communication protocols used in WSN have been a combination of cellular and short-range wireless network technology such as Bluetooth, ZigBee, etc. [1,2]. WSN requires a long battery life, so a low-power circuit is essential with substantial resource constraints. To achieve energy efficiency, MIMO is used in the 5G environment [3]. A WSN typically has one or more connected sensors on each node and is monitoring a given physical environment with distributed multiple hops. Baniata et al. [3] used a probability sub-optimal multi-hop routing mechanism among cluster heads to increase the lifespan of the sensor network. The sensor node operates according to an event or application command, and each node communicates wirelessly. Each node has one or more sensors, a microprocessor unit, and a radio unit that receives wake-up signals. Piyare et al. [4] introduced an extension of the TSCH (Time Slotted Channel Hopping) protocol to low data rate applications using the sub-GHz frequency bands operating on TI's System-on-Chip. They employed a special schedule for the network's root nodes and their direct neighbors, as well as the option to have multiple root nodes in a single network. Most WSNs rely

**Citation:** You, S.; Eshraghian, J.K.; Iu,H.C.; Cho, K. Low-Power Wireless Sensor Network Using Fine-Grain Control of Sensor Module Power Mode. *Sensors* **2021**, *21*, 3198. https://doi.org/10.3390/s21093198

Academic Editor: Geoff Merrett

Received: 24 March 2021 Accepted: 28 April 2021 Published: 4 May 2021

**Publisher's Note:** MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

**Copyright:** © 2021 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https:// creativecommons.org/licenses/by/ 4.0/).

on small batteries, which is a serious bottleneck in the system [5,6]. Battery capacity is developing at a very slow rate compared to other technologies, such as integrated circuits or software design. Therefore, energy efficiency has been the prime goal when designing and deploying WSNs [7,8]. Bachir et al. address the challenges related to the reliability of communication and the efficient use of the node's battery in WSN [9]. The performance is improved by doubling the network packet delivery ratio. Please note that the sensor node is in an idle state most of the time. David et al. [10] provided a platform wake-up receiver (WuR) with high integrability and a low cost per node to facilitate the implementation of low-cost sensor nodes. They demonstrate the feasibility of implementing a WuR with commercially available off-chip components by demonstrating a radio frequency envelope detection (RFED) WuR on a PCB mount. The most significant power consumption savings are observed when WuRs are used in low-traffic and low-density WSNs, mainly because the main transceiver is in the sleep mode for most of the time [11]. However, this type of customized platform is not cost-effective. Therefore, low-power design of circuits, architectures, algorithms, protocols, and other elements that affect power managemen<sup>t</sup> must be carefully considered [12–14]. The conventional radio interface or transceiver is frequently the most power-consuming element in a WSN node, dominating both the static and dynamic power consumption of the sensor [15]. The duty cycle controlling a radio receiver and transceiver is a common and well-known solution for reducing the power consumption of WSNs. It reduces the active operation time of the sensor node but increases the wake-up time when the sensor node is in a power saving state for a long time. Therefore, in real-time communication, a wireless method with a very low duty cycle may be inadequate. Similarly, Bdiri et al. [8] introduced the wake-up receiver (WuRx), which handles idle listening while keeping the main radio completely off. The main function of WuRx is to send an interrupt signal to the processing unit when receiving a radio frequency (RF) or wake-up packet (WuPt). However, the drawback is that the WuRx must always be turned on for communication with a very short waiting time. In terms of IoT MCU, ESP32 MCU [16] is conceptually similar to the FGPM proposed in this paper, but the difference is the lack of a distinction between Idle and Active modes. Our proposed FGPM distinguishes the transmit and receive stages in specific modes, which allows for fine-grain control of the duty cycle, which has been shown to be more advantageous for power consumption control. In this paper, we propose a power managemen<sup>t</sup> method for WSNs with five states of fine-grained power modes. We evaluate the proposed method on a test bench Mica2 [17]. As a result, of increased granularity, power consumption is reduced by 74.2% when compared to conventional methods [12]. This paper is structured as follows: Section 2 will present the communication protocol in WSNs, Section 3 will propose the fine-grained power state approach, Section 4 will present simulation results and energy consumption data of our approach, with a comparison against comparable methods, before concluding the work.

#### **2. Communication in Wireless Sensor Node**

#### *2.1. Wireless Sensor Node Architecture*

Each wireless sensor node has a sensing unit which detects events in the allocated area. In a given physical environment, the WSN monitors the events distributed via multi-hops routing. It communicates with the neighboring nodes to deliver the event to the user upon detection. Each inter-node communication uses a wireless transceiver in accordance with the given network protocol [18]. Figure 1 shows a basic WSN and a block diagram of a sensor module. Each node nearby events and broadcasts a signal to the users once the event is confirmed. The node module Mica2 consists of sensing units, a processor Atemga128L with memory, and an RF (CC1000) subsystem with low supply voltage, 1.6–3.6 V [17]. The Mica2's CC1000 is a wireless data transmitter and receiver suitable for short-range communications such as gas sensors and has the advantage of easy low-power managemen<sup>t</sup> with a simple circuit. The firmware on the microprocessor controls all sub-modules with a power managemen<sup>t</sup> strategy.

**Figure 1.** WSN Network connected multiple sensors and hardware block diagram of the sensor node module with a similar architecture to Mica2.

#### *2.2. Wireless Sensore Node Communication*

Figure 2 shows that sensor node communication is based on a handshake protocol. The first node that detects an event becomes a transmitting node (Node 1). It broadcasts a wake-up message to neighboring nodes in a fixed time slot. The node then transfers data packets to a downstream node. After packet transmission, the communication between nodes is completed by the Ack signal. When the possible communication nodes are from Node 2 to Node 4, communication is completed from the node with the highest priority (e.g., based on distance). Then, the successor node becomes a transmitting node which sends the wake-up signal to another neighboring node repeating the above procedure. When a time-out occurs due to packet loss, the scenario is restarted from the wake-up message transmission. Finally, the data on the first wake-up node is transmitted to a sink node as an alarm signal to alert the user. Additional functionalities can be integrated into the WSN as determined by the application and specifications [13]. The communication scheduling between nodes is an important issue to be considered for node power management.

**Figure 2.** Simplified sensor node communication with a handshake protocol.

Figure 3 shows the node communication schedule based on the WiseMAC protocol that determines switching from sleep mode to wake-up mode. All nodes stay in the medium idle state to receive periodically wireless wake-up signals to preserve battery life. The WiseMAC (Wireless Sensor MAC) protocol is a low-power media access control protocol designed for wireless sensor networks developed based on CSMA and preamble sampling [19]. The advantage of WiseMAC is that it dynamically reduces the size of the wake-up preamble. The wake-up signal does not require high traffic and shows that it can

have low-power consumption in the wake-up state. The disadvantage is that it has a slow response performance at wake-up time from sleep. However, this trade-off is tolerable under the given circumstances, where the primary aim is to have a long battery lifetime. Table 1 shows the time parameters that are defined in Figure 3 [20]. We set the medium idle checking pulse Tp such that the WSN receives a wake-up message at this time. The medium idle term T W is the time interval of the idle time Tp. Therefore, a node broadcasts a wake-up message during T W and the neighbor node detects an event at TP. The receiver node (Node 2) returns an Ack signal during Tc when it receives the lossless data packet. Please note that Ack includes the wake-up schedule of the receiver node as piggyback data. When the Ack is completed without any irregularities, the Node 1 transmits a wake-up message (wRx, wake-up Rx) during TP+Tidle according to the received wake-up schedule of the Node 2. This can be applied to the WiseMAC protocol. A time-out occurs since the Ack does not normally arrive during inter-node communication. Node 1 regards it as a packet loss or wake-up failure and transmits the wake-up message and packet again in the next schedule [13,21].

**Figure 3.** Node communication considering wake-up schedule.



#### **3. Proposed Fine Grain Five States Power Mode**

#### *3.1. Power Management*

The sensor node has three operating modes: sleep, idle, and run, as shown in Figure 4. Sleep mode waits for a wake-up event, idle mode is for receiving data or standby state to receive a specific command, and run mode is for executing a specific command. In this paper, we divide the sleep mode into three modes: a deep-sleep mode (state 0), a semi-idle sensor (state 1), and a semi-idle wRx (state 2, using wake-up Rx channel). These correspond to a sleep mode which uses minimum power, a sleep mode using only the sensing unit, and a sleep mode using the wake-up Rx channel. The sleep mode transits to idle mode (s3) when a wake-up event is detected or transits to run mode (s4) according to the node schedule.

**Figure 4.** Tri-state power mode control is modified to five states power mode to reduce power consumption on WSN.

Table 2 shows modules and power consumption for each state [22,23]. As the state increases, the power consumption, as well as the time (TTR) and energy (ETR) for changing between modes also increases. Each state is classified based on the processing state of the sensor node. This power mode distinction is similar to Advanced Configuration and Power Interface (ACPI) [5,13,24]. The paper [9] also lists power consumption parameters for the preselected microcontrollers stated in the datasheet. However, it is estimated at the MCU level.


**Table 2.** Power consumption of the function blocks of the sensor module.

#### *3.2. FGPM Operation*

Figure 5 shows the transition between power modes using the proposed FGPM managemen<sup>t</sup> technique, which controls the five states of various power modes [25]. It is represented as a finite state machine initializing at state 0. The communication schedule in Figure 3 shows how to switch between states. The sensors of the sensor module periodically switch between ON/OFF to check for events, which is the same as a state transition between State 0 and State 1. State 2 uses the wRx channel, and also periodically switches ON/OFF. This is identical to the medium idle state described above [12,20]. A node detects an event by periodically transitioning between State 0 → State 1, and State 2 → State 0 within a short period of time. When an event is detected in State 1 or State 2, it moves to State 4 through State 3. If an event is detected in State 1, then State 4 broadcasts a wake-up message and transmits the data packet. Finally, it switches to State 3 using only a packet Rx (pRx) at the receiving Ack. When an event is detected in State 2, the system switches to State 4 and returns the Ack signal. The sensor module goes back to State 0 when the scheduling of each node is completed. The inter-node communication performs the same procedure in a subsequent cycle.

**Figure 5.** Power mode state transition for fine-grain (with five states) power control on WSN. State 0 is the initial state which is sleep state.

#### *3.3. Power Mode Control on the Sensor Node Platform*

Figure 6 shows the power control of functional blocks for states of a node by using the power managemen<sup>t</sup> procedure of the microprocessor on the module. The sensing unit and wRx communicate their signals to the MCU through the wake-up controller. By using a separate wake-up controller, the MCU can sleep while receiving those signals thus preserving the battery life for longer than using an extended standby state. The MCU controls the power managemen<sup>t</sup> mode that it supplies, or blocks the power of each function block. Table 2 shows power consumption of each functional block for each state [26,27].

**Figure 6.** Self-waking paths on the sensor node module.

Figure 7 shows the wake-up signal process. When the sensor node switches from State 0 to State 1 and State 2 and detects an event, it transmits a wake-up message to the MCU. This enables the sensing unit and wRx channel. After the sensor node processes the signal from the sensor and antenna, they are transmitted to the wake-up controller which is the intermediate manager [28]. A controller that uses a separated power supply sends an interrupt signal to the MCU. Having completed its task, the activated MCU resets the blocks.

**Figure 7.** Modeling of node wake-up signal processing.

#### **4. Energy Analysis of FGPM**

#### *Five-State Energy Consumption*

The power consumption at each state of FGPM is shown in Figure 8. When the state increases, it is transmitted through the intermediate state. As described in Section 2, node communication is processed according to a defined protocol. Even if there is a time delay, it does not affect communication when adhering to a dedicated schedule [29]. FGPM can be applied with significant savings for WSNs that have long latency and short-length data communications, such as gas sensors [13,27].

**Figure 8.** Modeling of node wake-up signal processing.

The energy consumed at a state *k* is shown in Equation (1). It is the sum of the energy consumed by the transition from State 0 to State *k*, *ETR*, and the energy at State *k*, *EAct*,*k*. The energy consumption, *ETR*, while activating State *k* is equal to the product of the power consumption, *Pk*, and the duration of State *k*, *Tk*.

$$E\_k = P\_k \times T\_k = E\_{TR} + E\_{Act,k} \tag{1}$$

*ETR* is an important factor in the calculation of energy consumption. By increasing power mode states, the energy consumption due to state transitions also contributes to a greater power consumption. Thus, too many power modes will result in diminishing returns. The equation for *ETR* is given in Equations (2) to (7).

$$E\_{TR,k} = P\_{TR,k} \times T\_{TR,k} \tag{2}$$

$$T\_{TR,k} = \left( \ T\_{s0 \gets k} + T\_{k \gets s0} \right) = \frac{\left( \tau\_{\mu,k} + \tau\_{d,k} \right)}{2} \tag{3}$$

where *<sup>τ</sup>u*,*<sup>k</sup>* and *<sup>τ</sup>d*,*<sup>k</sup>* are the time taken to activate the node in the previous State *k* − 1 and to return to the previous power reduction mode, are given as follows:

$$\tau\_{d,k} = \left(\tau\_{d,k-1} + \tau\_{d,(k-1)\leftarrow k}\right), \qquad k \ge 2 \tag{4}$$

$$
\pi\_{\mathfrak{u},k} = \left(\pi\_{\mathfrak{u},k-1} + \pi\_{\text{delay},k} + \pi\_{\mathfrak{u},k \leftarrow (k-1)}\right), \ k \ge 2 \tag{5}
$$

Table 3 shows the time taken for WiseMAC protocol communication and the time required for state transitions when the node's power consumption state is changing.

**Table 3.** Power states and Time used in the sleep state.


For an example, we calculate *<sup>τ</sup>u*,*s*<sup>2</sup> using Equation (4), *<sup>τ</sup>u*,*s*<sup>2</sup> = *<sup>τ</sup>u*,*s*<sup>1</sup> + *<sup>τ</sup>delay* + *<sup>τ</sup>u*,*s*2←*s*1. The parameters are summarized in Table 3 as *<sup>τ</sup>u*,*s*<sup>1</sup> = 90 us, *<sup>τ</sup>u*,*s*2←*s*<sup>1</sup> = 2.8 ms, where *<sup>τ</sup>delay*,*<sup>k</sup>* is the time for the state k to stabilize (set to 0 in this experiment). Therefore, *<sup>τ</sup>u*,*s*<sup>2</sup> = 2.89 ms. The power *PTR*,*<sup>k</sup>* required to change State 0 to State k can be obtained using *TTR*,*k*. We can derive *PTR*,*<sup>k</sup>* as shown in Equation (6) by substituting Equation (3) into Equation (2). This is used to obtain *Eth*,*<sup>k</sup>* in Equation (7).

$$P\_{TR,k} = \frac{T\_{s0 \gets k} P\_{s0 \gets k} + T\_{k \gets s0} P\_{k \gets s0}}{T\_{TR}} = \frac{\frac{\tau\_{u,k}}{2} |P\_k - P\_{s0}| + \frac{\tau\_{d,k}}{2} |P\_k - P\_{s0}|}{T\_{TR}} = \frac{P\_k - P\_{s0}}{\tau\_{d,k}} + \frac{P\_k - P\_{s0}}{\tau\_{u,k}} \tag{6}$$

$$E\_{TR,k} = \frac{P\_{\rm k} - P\_{\rm s0}}{2} \tau\_{\rm u,k} + \frac{P\_{\rm k} - P\_{\rm s0}}{2} \tau\_{d,k} \tag{7}$$

*TAct*,*<sup>k</sup>* contains the time parameters *TW*, *Tp* and *TD* shown in Table 1, which depend on the node state. The consumed energy *EAct*,*<sup>k</sup>* is given in Equation (8).

$$E\_{Act,k} = T\_{Act,k} \left( P\_k - P\_{\text{s0}} \right) \tag{8}$$

Thus, energy consumption *Ek* of State *k* during *Tk* is given by Equation (9).

$$E\_k(T\_k) = P\_k T\_{Act,k} + (P\_k - P\_{d0}) T\_{TR} = P\_k T\_{Act,k} + \frac{(P\_k - P\_{s0})}{2} (\tau\_{d,k} + \tau\_{u,k}) = P\_k T\_{Act,k} + \frac{(P\_k - P\_{s0})}{2} \tau\_{u,k} + \frac{(P\_k - P\_{s0})}{2} \tau\_{d,k} \tag{9}$$

Since State 4 and State 0 use the maximum and minimum power, respectively, it is clear that a lower number state will use less power. Equation (10) shows the energy saving for the case where *Pk*(*Tk*) = *Ps*4 − *Pk* in Equation (9) and subtracting the additional power consumption *ETR*. Equation (11) shows the amount of power saving.

$$E\_{\text{saved},k}(T\_k) = (P\_{s4} - P\_k)T\_{\text{Act},k} - E\_{TR} \tag{10}$$

$$E\_{saved,k} = \frac{(P\_{s4} - P\_k)T\_{Act,k} - E\_{TR}}{T\_k} \tag{11}$$

Please note that State (*k* − *n*) (where *n* ≤ *k* − 1) uses less energy than State *k*, but absolute energy reduction is not guaranteed. To save energy at State (*k* − *n*), the energy ETR,n used in the transition from the existing State (*k* − *n*) to State *k* must be greater than the energy *Eth*,*<sup>k</sup>* given in Equation (12).

$$E\_{th, \rm u} = P\_{\rm u} \times T\_{th, \rm u} \tag{12}$$

We can find the minimum time *Tth*,*<sup>k</sup>* at State k keeping *Esave*,*<sup>k</sup>* > 0 using *PTR*,*<sup>k</sup>* described above is given as:

$$T\_{th,k-n} = \frac{1}{2} \left[ \pi\_{d,n} + \frac{(P\_k + P\_{k-n})}{(P\_k - P\_{k-n})} \right] \pi\_{u,n} \tag{13}$$

#### **5. Energy Consumption in Wireless Sensor Node**

*5.1. Node Energy Consumption in Sleep Mode*

The proposed FGPM has three highly granular power modes in sleep mode. In the standby state, wRadio and sensor modules consume power to detect input signals. The proposed structure repeats the use of State 0 and State 1 in order to switch the sensing unit ON/OFF. In the medium idle state, the FGPM makes a state transition from State 3 to State 2 to reduce energy consumption. This section describes the total energy consumption considering all scenarios for the state of dormancy. Table 4 shows power consumption and timing parameters for the sleep mode shown in Figure 9. *Pk* is power consumption in the FGPM complying with a communication protocol. The duration *Tk* for State *k* has many variables as shown in Figure 9.


**Table 4.** Power states and Time used in the sleep states.

Each sensor node is in a sleep state before detecting an event which is as long as i × *TW*. During this time, there is one *wRx* term for sensing a wake-up *Rx* signal and the sensing time is *n* = (*Tw* − *TwRx*)/*Tst*. Equations (14) to (16) show energy consumption while the node awaits the onset of an event.

$$E\_{\text{sleeps}} = \sum\_{T\_{\text{W}=1}}^{j} (E\_{\text{wakeRx}}(T\_P) + n \cdot E\_{\text{sensor}})\_{T\_{\text{W}}} + E\_{\text{senscal}} \tag{14}$$

where *j* represents the total sleep time of a node. It is equivalent to the sum of the energy consumed from sensing, *j* × *TW*, and *j* times of energy of the medium idle state. *EwakeRx* is the energy consumption of the medium idle state of a node while receiving a wake-up signal with wireless communication. It is the largest cause for energy consumption for a node in the sleep state is given as Equation (15).

$$E\_{\text{wakeRx},\text{savt}}\left(T\_p\right) = P\_{s0}T\_{s1p} + \left(P\_{s3} - P\_{s2}\right)T\_P + \left(E\_{TR,3\leftarrow s1} - E\_{TR,\mathcal{Q}}\right) \tag{15}$$

*Esensor* has two types of energy consumption. Based on the proposed method, *Esensor <sup>e</sup>τd*,*s*<sup>1</sup> = (*Ps*1 − *Ps*0)*<sup>τ</sup>d*,*s*<sup>1</sup> because the node sleeps again if it fails to detect an event. If it detects an event, it sends an event signal to the MCU through the wake-up controller, so the energy is the same as *Esensor <sup>e</sup>τu*,*s*4←*s*<sup>1</sup> = (*Ps*4 − *Ps*1)*<sup>τ</sup>u*,*s*4←*s*1. Please note that *TAck*,*s*<sup>1</sup> ≥ *Tth*,*s*<sup>1</sup> can be obtained from Equation (13). Thus, the sensor energy saving is given in Equation (16).

$$E\_{sensor,saved} = (P\_{s1} - P\_{s0})T\_{slp} - \left(E\_{TR,s1} + \left(P\_{s1} - P\_{s0}\right)\tau\_{u,s1}\right) \tag{16}$$

Thus, the saved energy *Esleeps*,*saved* by the proposed method can be written as

$$E\_{\text{skrps,sured}} = \sum\_{i=1}^{\frac{T\_{\text{pull}}}{T\_{\text{N}}}} \left( T\_{\text{slp}}(n+1)(P\_{\text{s1}} - P\_{\text{s0}}) + T\_P(P\_{\text{s3}} - P\_{\text{s2}}) + E\_{TR,\text{s3}\gets\text{s1}} - (E\_{TR,\text{s2}} + n \cdot E\_{TR,\text{s1}}) \right)\_i \tag{17}$$

**Figure 9.** Transforming of energy states in sleep mode of a node.

#### *5.2. Energy Consumption in Sleep Mode*

Figure 10 shows energy consumption in sleep mode for both the conventional and proposed method. Based on the Mica2 node, the energy consumption when using the conventional continuous sensing unit and when the ON/OFF is repeatedly used is 178.64 uJ and 95. 96 uJ [27]. The energy saving is approximately 46.3%. Employing State 2 reduces energy consumption from 11.38 mJ to 3.5 mJ when the node is in the medium idle state, which is a 69.2% energy reduction. By adding these two factors, the Mica2 node consumes 7.96 mJ for 1 s, which results in a total energy saving of 74.2% [20,26,27].

Figure 11 shows energy consumption in sleep states for 4 s to compare the existing and proposed methods. The sensing interval shows a very slow rise of energy, and the medium idle interval shows a faster rate of energy consumption increase. This is because the energy consumed by the node's radio subsystem is large. Therefore, it can be seen that energy reduction in the radio system is emphasized. Compared with the proposed method, energy consumption varies greatly over time. Figure 11 presents a staircase energy consumption difference, but it increases linearly with respect to time.

**Figure 10.** Comparison of energy consumption in the sleep mode.

#### *5.3. Sensor Node Energy Consumption in Communication*

In most cases, the sensor node is in the sleep state for event sensing. When a node senses an event at the sensing unit, it becomes a sender node as the first wake up node. Then, it transmits a wake-up message and data packet to the neighboring nodes and receives an acknowledge signal. In these scenarios, power consumption in a node varies with each time schedule. The WiseMAC protocol has several power consumption levels in the node's communication scenario; however, the state of power consumption was defined only into three types: sleep, doze (idle), and communication state (RUN). The proposed approach introduces FPGM with five states, where partitioning the states enables fine-grained power managemen<sup>t</sup> and reduced energy consumption. Figure 12 shows the change of energy consumption in communication between nodes for WiseMAC in each communication scenario. Node 1 wakes up from the sleep state by sensing an event of the sensing units and starts to communicate with Node 2. As illustrated in Figure 2, a node can have feedback after communicating at least twice for a single event. We show the advantages of the proposed fine-gained partitioned power mode that are analyzed using energy consumption benchmarks in conventional communication.

**Figure 12.** Energy state transition in WiseMAC protocol-based node communications.

Each node sends a wake-up message and data packet to neighboring nodes. The node that first wakes up through a sensor event from the sleep mode receives an Ack.This is phase 1 communication. A time delay of *<sup>τ</sup>sendelay* may occur due to repeated use of the sensor switching ON/OFF that uses energy, though power consumption can be reduced by using State 3 in the Rx state receiving Ack. Energy consumption is calculated in Equations (18) and (19).

$$E\_{conv,node1, pli1} = P\_{s4}T\_W + P\_{s4}T\_D + P\_{s4}T\_T + P\_{s4}T\_c + E\_{TR, \varphi4} \tag{18}$$

$$E\_{prop,node1, ph1} = \tau\_{sendday} P\_{s1} + P\_{s4} T\_W + P\_{s4} T\_D + P\_{s3} T\_T + P\_{s3} T\_c + E\_{TR, \text{s4}} \tag{19}$$

Nodes can communicate repeatedly even after one data packet transmission. For example, in the case of a gas sensor node, the sensor detects events periodically for a given duration, and the number of times is set by the user for checking the current physical environment and the state of the node. It is periodically fed back to the upper node, which is phase 2 communication. In phase 2, the parameter value *TW* of Node 1 is changed to *TP*. Additionally, *<sup>τ</sup>sendelay* is deleted because the medium idle state does not use the sensor. The energy consumption is given in Equations (20) and (21).

$$E\_{conv,node1, pli2} = P\_{s4}T\_P + P\_{s4}T\_D + P\_{s4}T\_T + P\_{\mathfrak{F}3}T\_{\mathfrak{C}} + E\_{TR, \mathfrak{s}4} \tag{20}$$

$$E\_{prop,node1, pli2} = P\_{\mathfrak{s}4} T\_P + P\_{\mathfrak{s}4} T\_D + P\_{\mathfrak{s}3} T\_T + P\_{\mathfrak{s}3} T\_{\mathfrak{c}} + E\_{TR, \mathfrak{s}4} \tag{21}$$

Node 2 wakes up from a long sleep state upon an incident wRx event. It therefore only plays the receiver role until communication with the wRx sender is completed. Node 2 becomes a receiver node that wakes up through a wireless signal without detecting an event from the sensor. In the initial communication, Node 2 can send a piggy-back Ack to inform the sending node that it is in a medium idle mode. Therefore, the energy used for the first communication of the transmitting node and the energy used in the next communication are different for *m* ≥ 2 in *Tidle*,*m*, where *m* represents the number of communication events for a range of 0 ≤ Tidle,m ≤ *TW* − *TP* [8,10,13]. Equations (18) and (19) are modified to (22) and (23).

$$E\_{\rm conv,node2,ph1} = P\_{\rm s3}T\_P + P\_{\rm s3}T\_{\rm idle,1} + P\_{\rm s4} \left(T\_D - \tau\_{\rm u,s4 \gets s3} \right) + P\_{\rm s4}T\_T + P\_{\rm s3}T\_c + E\_{TR,\rm p4} \tag{22}$$

$$E\_{prop,nad2,pl1} = P\_{s2}T\_P + P\_{s3}T\_{idle,1} + P\_{s4}(T\_D - \pi\_{u,s4 \gets s2}) + P\_{s4}T\_T + P\_{s3}T\_4 + E\_{TR,p4} \tag{23}$$

From Phase 2, Node 1 can check the detailed medium idle schedule of Node 2. Thus, the time error *Tidle* of *TP* approaches zero. The energy is modified to Equations (24) and (25).

$$E\_{conv, nodal2, pld2} = P\_{\\$3}T\_P + P\_{\\$3}T\_{\text{idle,2}} + P\_{\\$4}(T\_D - \pi\_{\text{u,s4} \leftarrow \text{s3}}) + P\_{\\$4}T\_T + P\_{\\$3}T\_{\text{c}} + E\_{TR, \text{s4}} \tag{24}$$

$$E\_{prop,node2,pl2} = P\_{s2}T\_P + P\_{s3}T\_{\text{iille},2} + P\_{s4}(T\_D - \pi\_{\text{u,s4}\leftarrow s2}) + P\_{s4}T\_T + P\_{s3}T\_c + E\_{TR, \text{s4}} \tag{25}$$

#### **6. Experimental Results**

Based on the Mica2, we compared the energy consumption of the conventional and proposed approach using the Equations (18) to (25). The ad hoc network is shown in Figure 1, which accounts for inter-node communication from Node 1 to Node 6 in the network. The dotted circles are communication pairs. Node 1 wakes up Node 2 and transmits its signal. Subsequently, Node 2 wakes-up Node 3 by broadcasting a wake-up signal for other nodes. Node 2 wakes up Node 4 separately from communication between Node 1 and Node 3. In the same order, Node 4 communicates with Node 5 and Node 6. There is no communication between Nodes 3 and 4, because Node 2 has a direct line of communication with Node 4. Figure 13 shows the amount of power consumption for the single communication of a dotted circle. The time required at the send Node is *TW* + *TD* + *TT* + *Tc* + *<sup>τ</sup>u*,*s*4←*s*<sup>1</sup> + *<sup>τ</sup>d*,*s*4←*s*<sup>1</sup> , and at the receive node is *TW* + *TD* + *TT* + *Tc* + *<sup>τ</sup>u*,*s*4←*s*<sup>2</sup> + *<sup>τ</sup>d*,*s*4←*s*1. However, the power consumption according to the time period is taken from Table 2. Phase 1 is for sleep mode and phase 2 is for run mode. The proposed method is not significantly different from the previous method in the sender node, but a relatively large difference can be seen in the receiver node.

**Figure 13.** Comparison of node energy consumption for each communication scenario.

Figure 14 shows the energy saving as a function of the parameters time and the number of events in the node. The energy consumption of the waiting time in the proposed method is about 74.2% lower than that of conventional methods. However, the energy reduction effect caused by wake-up is less than 2%, so as the number of events increases, the energy reduction of the proposed method does not necessarily scale. We assumed that the number of events occurred from a minimum 0 to a maximum 16 in a space of two minutes. There is an energy saving of about 57 J for 0 events, but about 9.7 J of energy saving is less than 15% of that for 16 events.

**Figure 14.** Reduced energy consumption with the parameters time and number of events.

Figure 15 shows the reduced energy consumption parameter space over one minute for the number of nodes and event probability in the WSN. This shows the energy saving effect when it is assumed that each node wakes up once due to a single event. The energy saving rises as a 2nd order function for the event probability, but it is linearly increasing for the number of nodes. Based on 100 nodes, the sensor node consumes significantly less energy at 20 mJ for a 0% event probability, but energy consumption exceeds 1100 mJ at the 100% event probability. As in Figure 14, this shows that our approach can save more energy for systems of low event probability [27].

**Figure 15.** Comparison of node energy consumption for each communication scenario.
