Distributed Path Reconfiguration and Data Forwarding in Industrial IoT Networks

In today's typical industrial environments, the computation of the data distribution schedules is highly centralised. Typically, a central entity configures the data forwarding paths so as to guarantee low delivery delays between data producers and consumers. However, these requirements might become impossible to meet later on, due to link or node failures, or excessive degradation of their performance. In this paper, we focus on maintaining the network functionality required by the applications after such events. We avoid continuously recomputing the configuration centrally, by designing an energy efficient local and distributed path reconfiguration method. Specifically, given the operational parameters required by the applications, we provide several algorithmic functions which locally reconfigure the data distribution paths, when a communication link or a network node fails. We compare our method through simulations to other state of the art methods and we demonstrate performance gains in terms of energy consumption and data delivery success rate as well as some emerging key insights which can lead to further performance gains.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

01/07/2019

D2D Data Offloading in Vehicular Environments with Optimal Delivery Time Selection

Within the framework of a Device-to-Device (D2D) data offloading system ...
10/04/2021

Learning, Computing, and Trustworthiness in Intelligent IoT Environments: Performance-Energy Tradeoffs

An Intelligent IoT Environment (iIoTe) is comprised of heterogeneous dev...
10/01/2018

Exploring the Performance Boundaries of NB-IoT

NB-IoT has just jonied the LPWAN community. Unlike most of its competito...
07/25/2020

EAGP: An Energy-Aware Gossip Protocol for Wireless Sensor Networks

In Wireless Sensor Networks (WSN), typically composed of nodes with reso...
07/01/2018

Joint Failure Recovery, Fault Prevention, and Energy-efficient Resource Management for Real-time SFC in Fog-supported SDN

In this paper, we focus on the problems of traffic engineering, failure ...
05/04/2022

Joint Compute-Caching-Communication Control for Online Data-Intensive Service Delivery

Emerging Metaverse applications, designed to deliver highly interactive ...
05/31/2021

Energy-Efficient and Federated Meta-Learning via Projected Stochastic Gradient Ascent

In this paper, we propose an energy-efficient federated meta-learning fr...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

With the introduction of Internet of Things (IoT) concepts in industrial application scenarios, industrial automation is undergoing a tremendous change. This is made possible in part by recent advances in technology that allow interconnection on a wider and more fine-grained scale [10]. The core of distributed automation systems and networks is essentially the reliable exchange of data. Any attempt to steer processes independently of continuous human interaction requires, in a very wide sense, the flow of data between some kind of sensors, controllers, and actuators [7].

In today’s typical industrial configurations, the computation of the data exchange and distribution schedules is quite primitive and highly centralised. Usually, the generated data are transferred to a central network controller or intermediate network proxy nodes using wireless links. The controller analyses the received information and, if needed, reconfigures the network paths, the data forwarding mechanisms, the caching proxy locations and changes the behaviour of the physical environment through actuator devices. Traditional data distribution schemes can be implemented over relevant industrial protocols and standards, like IEC WirelessHART, IEEE 802.15.4e and IETF 6TiSCH.

Those entirely centralised and offline computations regarding data distribution scheduling, can become inefficient in terms of energy, when applied in industrial IoT networks. In industrial environments, the topology and connectivity of the network may vary due to link and sensor-node failures [8]. Also, very dynamic conditions, which make communication performance much different from when the central schedule was computed, possibly causing sub-optimal performance, may result in not guaranteeing application requirements. These dynamic network topologies may cause a portion of industrial sensor nodes to malfunction. With the increasing number of involved battery-powered devices, industrial IoT networks may consume substantial amounts of energy; more than needed if local, distributed computations were used.

Our contribution. In this paper we consider an industrial IoT network comprised of sensor and actuator nodes. Data consumers (actuators) and producers (sensors) are known. A number of intermediate resource-rich nodes act as proxies. We assume that applications require a certain maximum delivery delay from proxies to consumers, and that, at some point in time, a central controller computes an optimal set of multi-hop paths from producers to proxies, and proxies to consumers, which guarantee a maximum delivery delay, while maximising the energy lifetime of the networks (i.e., the time until the first node in the network exhaust energy resources). We focus on maintaining the network configuration in a way such that application requirements are met after important network operational parameters change due to some unplanned events (e.g., heavy interference, excessive energy consumption), while guaranteeing an appropriate use of nodes energy resources. We provide several efficient algorithmic functions which reconfigure the paths of the data distribution process, when a communication link or a network node fails. The functions regulate how the local path reconfiguration should be implemented and how a node can join a new path or modify an already existing path, ensuring that there will be no loops. The proposed method can be implemented on top of existing data forwarding schemes designed for industrial IoT networks. We demonstrate through simulations the performance gains of our method in terms of energy consumption and data delivery success rate.

2 Related works

The previous works that are the most related to this paper are [2], [4], [9] and [5]. Although those works proxy nodes for the efficient distributed management of network data, they all perform path selection computations centrally. Placement and selection strategies of caching proxies in industrial IoT networks have been investigated in [2]. Efficient proxy-consumer assignments are presented in [4]. Data re-allocation methods among proxies for better traffic balancing are presented in [9]. Scheduling of the data distribution process maximising the time until the first network node dies is suggested in [5], respecting end-to-end data access latency constraints of the order of ms, as imposed by the industrial operators [1]. Different to those works, in this paper, we present a method which exploits the local knowledge of the network nodes so as to perform distributed path reconfiguration computations towards more efficient energy dissipation across the network.

3 The model

We model an industrial IoT network as a graph . Typically, the network features three types of devices [11]: resource constrained sensor and actuator nodes , a central network controller , and a set of proxy nodes in a set , with , . Every node , at time , has an available amount of finite energy . In general, normal nodes have limited amounts of initial energy supplies , and proxy nodes have significantly higher amounts of initial energy supplies, with .

A node can achieve one-hop data propagation using suitable industrial wireless technologies (e.g., IEEE 802.15.4e) to a set of nodes which lie in its neighbourhood . contains the nodes for which it holds that , where is the transmission range of node (defined by the output power of the antenna) and is the Euclidean distance between and . The sets are thus defining the set of edges of the graph . Each one-hop data propagation from to results in a latency . Assuming that all network nodes operate with the same output power, each one-hop data propagation from to requires and amount of of energy dissipated by so as to transmit one data piece to . A node can also transmit control messages to the network controller by consuming amount of energy. For this kind of transmissions, we assume that more expensive wireless technology is needed, and thus we have that (for example, the former can occur over WiFi or LTE links, while the latter over 802.15.4 links).

Occasionally, data generation occurs in the network, relevant to the industrial process. The data are modelled as a set of data pieces . Each data piece is defined as , where is the source of data piece , is the consumer111If the same data of a source, e.g., , is requested by more than one consumers, e.g., and , we have two distinct data pieces, and , where . of data piece , and is the data generation rate of . Each data piece is circulated in the network through a multi-hop path . Each node knows which is the previous node and the next node in the path of data piece . Without loss of generality, we divide time in time cycles and we assume that the data may be generated (according to rate ) at each source at the beginning of each , and circulated during . The data generation and request patterns are not necessarily synchronous, and therefore, the data need to be cached temporarily for future requests by consumers. This asynchronous data distribution is usually implemented through an industrial pub/sub system [4]. A critical aspect in the industrial operation is the timely data access by the consumers upon request, and, typically, the data distribution system must guarantee that a given maximum data access latency constraint (defined by the specific industrial process) is satisfied. We denote this threshold as .

Due to the fact that the set of proxy nodes is strong in terms of computation, storage and energy supplies, nodes can act as proxy in the network and cache data originated from the sources, for access from the consumers when needed. This relieves the IoT devices from the burden of storing data they generate (which might require excessive local storage), and helps meeting the latency constraint. Proxy selection placement strategies have been studied in recent literature [4, 2]. We denote as the latency of the multi-hop data propagation of the path , where . Upon a request from , data piece can be delivered from via a (distinct) multi-hop path. We denote as the data access latency of , with . We assume an existing mechanism of initial centrally computed configuration of the data forwarding paths in the network, e.g., as presented in [5]. In order to meet the industrial requirements the following constraint must be met: .

4 Network epochs and their maximum duration

In order to better formulate the data forwarding process through a lifetime-based metric, we define the network epoch. A network epoch

is characterised by the time ( divides ) elapsed between two consecutive, significant changes in the main network operational parameters. A characteristic example of such change is a sharp increase of between two consecutive time cycles, due to sudden, increased interference on node , which in turn leads to increased retransmissions on edge and thus higher energy consumption. In other words, , where is a predefined threshold. During a network epoch, (all or some of) the nodes initially take part in a configuration phase (central or distributed), during which they acquire the plan for the data distribution process by spending an amount of energy for communication. Then, they run the data distribution process. A network epoch is thus comprised of two phases: Configuration phase. During this initial phase, the nodes acquire the set of neighbours from/to which they must receive/forward data pieces in the next epoch. Data forwarding phase. During this phase the data pieces are circulated in the network according to the underlying network directives.

Network epochs are just an abstraction that is useful for the design and presentation of the algorithmic functions, but does not need global synchronisation. As it will be clear later on, each node locally identifies the condition for which an epoch is finished from its perspective, and acts accordingly. Different nodes “see” in general different epochs. Although some events which affect the epoch duration cannot be predicted and thus controlled, we are interested in the events which could be affected by the data distribution process and which could potentially influence the maximum epoch duration. We observe that an epoch cannot last longer than the time that the next node in the network dies. Consequently, if we manage to maximise the time until a node dies due to energy consumption, we also make a step forward for the maximisation of the epoch duration.

We now define the maximum epoch duration, as it can serve as a useful metric for the decision making process of the distributed path reconfiguration. The maximum epoch duration is the time interval between two consecutive node deaths in the network. Specifically, each epoch’s duration is bounded by the lifetime of the node with the shortest lifetime in the network, given a specific data forwarding configuration. Without loss of generality, we assume that the duration of the configuration phase equals . We define the variables, which hold the necessary information regarding the transmission of the data pieces across the edges of the graph. More specifically, for epoch , when edge is activated for data piece . On the contrary, when edge is inactive for the transmission of data piece . We denote as the aggregate data rate of for epoch . Stacking all together, we get

, the data rate vector of node

for every . Following this formulation (and if we assumed that ) the maximum lifetime of during epoch can be defined as:

(1)

where is the amount of energy that is needed by in order to complete the configuration phase. Consequently, given an epoch , the maximum epoch duration is .

There have already been works in the literature which identify, for each data source , the proxy where its data should be cached, in order to maximise the total lifetime of the network until the first node dies [5] (or, in other words, maximise the duration of the first epoch: ), and configure the data forwarding paths accordingly. Reconfigurations can be triggered also when the conditions under which a configuration has been computed, change. Therefore, (i) epoch duration can be shorter than , and (ii) we do not need any centralised synchronisation in order to define the actual epoch duration. We consider the epoch as only an abstraction (but not a working parameter for the functions), which is defined as the time between two consecutive reconfigurations of the network, following the functions presented in Section 5.

5 Path reconfiguration and data forwarding

The main idea behind our method is the following: the nodes are initially provided with a centralised data forwarding plan. When a significant change in the network occurs, the nodes involved are locally adjusting the paths, using lightweight communication links among them (e.g., 802.15.4) instead of communicating with the central network controller (e.g., LTE, WiFi). The main metric used for the path adjustment is the epoch-related , as defined in Eq. 1. The functions’ pseudocode is presented in the following subsections. Due to lack of space we omit the presentation of some functions’ pseudocodes, but those can be found in the extended version of the paper [6]. The functions are presented in upright typewriter font and the messages which are being sent and received are presented in italics typewriter font. The arguments in the parentheses of the functions are the necessary information that the functions need in order to compute the desired output. The arguments in the brackets of the messages are the destination nodes of the messages and the arguments in the parentheses of the messages are the information carried by the messages. We assume that a node complies with the following rules: knows the positions of every , knows the neighbourhood of every node in its own neighbourhood , and stores only local information or temporarily present data pieces in transit.

1 if  then
2       send status[] receive plan[] repeat
3             run DataForwarding if  with  then
4                   Deactivate, send alert[],
5             if receive alert[] then
6                   Deactivate call LocalPathConfig
7            if receive join[] then
8                   call JoinPath
9            if receive modify_path then
10                   call ModifyPath
11            
12      until  or for of active edges of
send alert[], , Disconnect()
Algorithm 1 DistrDataFwd

Distributed data forwarding. The distributed data forwarding function DistrDataFwd pseudocode is being ran on every node of the network and is provided in the body of Alg. 1. At first, if , the node communicates its status to the central network controller (which uses the method presented in [5] for computing the data distribution parameters (proxy allocation, data forwarding paths) in an initial setup phase of the network), it receives the data forwarding plan and it initiates the first time cycle (lines 1-1). Then, for every time cycle repeats the following process, until either it is almost dead, or more than half of its associated wireless links spend more energy compared to the previous time cycle, according to the system parameter (lines 1-1): starts the data forwarding process according to the data distribution plan received by (line 1). Afterwards, it checks if a set of control messages have been received from any and acts accordingly, by calling the necessary functions (lines 1-1).

If detects that a link is consuming too much energy and has to be deactivated, it deactivates this link (by causing a path disconnection) and notifies the previous node in the path for , , by sending an alert message (lines 1-1). For a given deactivated link for data piece , alert messages contain information on which is the data piece of interest, and which were the two nodes in the path prior to disconnection. Then, checks whether there has been an alert message received (line 1), and calls function LocalPathConfig (displayed in Alg. 2). Through this function the paths can be reconfigured accordingly, for all involved data pieces . Due to the fact that LocalPathConfig sends some additional messages regarding joining a new path and modifying an existing one, then checks for reception of any of those messages (lines 1 and 1) and calls the necessary functions JoinPath and ModifyPath.

Finally, sends an alert message to the previous nodes in the existing paths prior to final disconnection due to energy supplies shortage (line 1).

Local path configuration. A node calls the path configuration function LocalPathConfig when it receives an alert which signifies cease of operation of an edge due to a sudden significant increase of energy consumption due to interference or a cease of operation of a node due to heavy interference in all of ’s edges or due to low energy supplies (Alg. 1, lines 1 and 1).

1 if  with and  then
2       send join[] replace with
3 else
4       run local_aodv+
Algorithm 2 LocalPathConfig

LocalPathConfig is inherently local and distributed. The goal of this function is to restore a functional path between nodes and by replacing the problematic node with a better performing node , or if does not exist, with a new efficient multi-hop path . At first, checks if there are nodes in its neighbourhood which can directly connect to and achieve a similar or better one-hop latency than the old configuration (line 2). If there are, then the selected is the node which given the new data piece, will achieve a maximum lifetime compared to the rest of the possible replacements, i.e., , and an acceptable latency (line 2). then sends to a join message (line 2).

If such a node does not exist, then runs local_aodv+, a modified, local version of AODV protocol for route discovery, between nodes and . local_aodv+ is able to add more than one replacement nodes in the path. The main modification of local_aodv+ with respect to the traditional AODV protocol is that local_aodv+ selects the route which provides the maximum lifetime for the nodes which are included in the route. Specifically, this modification with respect to the classic AODV is implemented as follows: The nodes piggyback in the route request messages the minimum lifetime that has been identified so far on the specific path. Then when the first route request message arrives at , instead of setting this path as the new path, waits for a predefined timeout for more route request messages to arrive. Then, selects the path which provided the . The reader can find more details about the AODV protocol in [3].

Joining new paths, modifying existing paths and avoiding loops. In this subsection, we briefly describe the functions regarding joining a new path and modifying an already existing path for loop elimination. Due to lack of space, we do not include the pseudocode of those functions; however, they can be found at the extended version of this paper [6]. JoinPath is the function which regulates how, for data piece , a node will join an existing path between nodes and and how will trigger a path modification and avoid potential loops which could result in unnecessary traffic in the network. Due to the fact that the reconfigurations do not use global knowledge, we can have three cases of joining a path: (i) is not already included in the path (), (ii) is already included in the path (), and is preceding in the new path () with a new link , and (iii) is already included in the path (), and is preceding in the new path () with a new link . In all three cases, JoinPath sends a modification message to the next node to join the path, with the appropriate arguments concerning the deletion of parts of the paths, and the direction of the deletion, for avoidance of potential loops (see [6]). This messages triggers the function ModifyPath (see [6]). In case (i) it is apparent that there is no danger of loop creation, so there is no argument for deleting parts of the path. In order to better understand cases (ii) and (iii) we provide Figures 1 and 2. In those Figures we can see how the function ModifyPath eliminates newly created loops on from path reconfigurations which follow unplanned network changes.

Following the loop elimination process, loop freedom is guaranteed for the cases where there are available nodes which can directly replace . In the case where this is not true and LocalPathConfig calls local_aodv+ instead (Alg. 2, line 2), then the loop freedom is guaranteed by the AODV path configuration process, which has been proven to be loop free [12].

(a) Unplanned change.
(b) (re-)joining the path.
(c) Loop elimination.
Figure 1: Loop avoidance - forward loop.
(a) Unplanned change.
(b) (re-)joining the path.
(c) Loop elimination.
Figure 2: Loop avoidance - backward loop.

6 Performance evaluation

We implemented DistrDataFwd method and we conducted simulations in order to demonstrate its performance. We configured the simulation environment (Matlab) according to realistic parameters and assumptions. A table presenting the parameter configuration in details can be found in the extended version of the paper [6]. Briefly, we assume an industrial IoT network, comprised of devices equipped with ultra low-power MCUs like MSP430 and IEEE 802.15.4 antennae like CC2420, able to support industrial IoT standards and protocols like WirelessHART and IEEE 802.15.4e. We assume a structured topology (as in usual controlled industrial settings) of 18 nodes with 4 proxies which form a 2D grid with dimensions of m m. We set the transmission power of the nodes for multi-hop communication to dBm (typical low-power) which results in a transmission range of m. For the more expensive communication with the network controller, we set the transmission power to dBm, typical of wireless LAN settings. We set the time cycle second, the percentage of consumers over the population % and we produce per consumer. In order to perform the simulations in the most realistic way, we align the value with the official requirements of future network-based communications for Industry 4.0 [1], and set the latency threshold to ms. We set , the argument of local_aodv+ equal to , we assume a maximum battery capacity of mAh (3.7 V) and equip the nodes with energy supplies of Wh and Wh. Last but not least, in order to have a realistic basis for the one-hop latencies to be used in the simulations, we performed some limited experiments with real devices. Specifically, we repeated one-hop propagation measurements multiple times for 18 WSN430 nodes, for different pairs of transmitting and receiving nodes. We concluded to the measurements that are shown in Fig. 2(a), after measuring the relevant latencies using WSN430 with CC2420 antenna, under the TinyOS operating system. We assigned to the different the corresponding, variable intervals of values.

In order to have a benchmark for our method, we compared its performance to the performance of the PDD data forwarding method which was provided in [5]. Due to the fact that PDD was designed for static environments without significant network parameter changes, we also compare to a modified version of PDD, which incorporates central reconfiguration when needed (we denote this version as PDD-CR). Specifically, PDD-CR runs PDD until time , when a significant change in the network happens, and then, all network nodes communicate their status () to the network controller by spending amount of energy. computes centrally a new (near-optimal as shown in [5]) data forwarding plan and the nodes run the new plan. In our case, we run the PDD-CR reconfigurations for each case where we would do the same if we were running DistrDataFwd. As noted before, the conditions that trigger a change of the forwarding paths are either node related (a node dies) or link related (change of interference which results in )222The qualitative behaviour would not change in case of additional reconfiguration events, which simply increase the number of reconfigurations.. We ran the experiments multiple times and we depict the average values so as to capture stochastic variations (e.g., different latencies on the same node, see Fig. 2(a)).

(a) Device latencies.
(b) Energy consumption.
(c) Var. reconfigurations
(d) Data pieces lost.
(e) Max. access latency.
Figure 3: Performance results.

Energy efficiency. The energy consumption over the entire network during 2000 hours of operation is depicted in Fig. 2(b). The energy consumption values include the energy consumed for both the data distribution process and the reconfiguration. Our method achieves comparable energy consumption as PDD, despite being a local, adaptive method. This is explained by the following facts: PDD-CR requires more energy than DistrDataFwd for the path reconfiguration process, as during each epoch alteration every node has to spend amount of energy for the configuration phase. On the contrary, in the DistrDataFwd case, only some of the nodes have to participate in a new configuration phase (usually the nodes in the neighbourhood of the problematic node), and spend significantly less amounts of energy. In the case of PDD, the nodes do not participate in configuration phases, so they save high amounts of energy. In Fig. 2(c), we can also see the energy consumption of DistrDataFwd and PDD-CR for different percentages of reconfigurations (w.r.t. the number of time cycles ). It is clear that the more the reconfigurations that we have in the network, the more the gap between the performance of DistrDataFwd and PDD-CR increases.

Data delivery rate. The data pieces lost during 2000 hours of operation are depicted in Fig. 2(d). We consider a data piece as lost when the required nodes or path segments are not being available anymore so as to achieve a proper delivery. When a data piece is delivered, but misses the deadline , it is not considered as lost, but we measure the high delivery latency instead. We can see that the low energy consumption of the PDD method comes at a high cost: it achieves a significantly lower data delivery rate than the PDD-CR and the DistrDataFwd methods. This is natural, because as noted before, PDD computes an initial centralised paths configuration and follows it throughout the entire data distribution process. The performance of the DistrDataFwd method stays very close to the performance of the PDD-CR method, which demonstrates the efficiency of DistrDataFwd in terms of successfully delivering the data pieces.

Maximum data access latency. The maximum data access latency during 2000 hours of operation is depicted in Fig. 2(e). The measured value is the maximum value observed among the consumers, after asynchronous data requests to the corresponding proxies. PDD does not perform well, due to the fact that it is prone to early disconnections without reconfiguration functionality. The fluctuation of PDD-CR’s curve is explained by the re-computation from scratch of the data forwarding paths which might result in entirely new data distribution patterns in the network. DistrDataFwd respects the threshold for most of the time, however at around 1700 hours of network operation it slightly exceeds it for a single proxy-consumer pair. On the contrary, PDD-CR does not exceed the threshold. This performance is explained by the fact that DistrDataFwd, although efficient, does not provide any strict guarantee for respecting , for all proxy-consumer pairs, mainly due to the absence of global knowledge on the network parameters during the local computations. PDD-CR, with the expense of additional energy for communication, is able to centrally compute near optimal paths and consequently achieve the desired latency. There are two simple ways of improving DistrDataFwd’s performance in terms of respecting the threshold: (i) insert strict latency checking mechanisms in the local_aodv+ function, with the risk of not finding appropriate (in terms of latency) path replacements, and thus lowering the data delivery ratio due to disconnected paths, and (ii) increase the argument of local_aodv+, with the risk of circulating excessive amounts of route discovery messages, and thus increasing the energy consumption in the network. Including those mechanisms is left for future work.

7 Conclusion

We identified the need for a distributed reconfiguration method for data forwarding paths in industrial IoT networks. Given the operational parameters the network, we provided several efficient algorithmic functions which reconfigure the paths of the data distribution process, when a communication link or a network node fails. The functions regulate how the local path reconfiguration is implemented, ensuring that there will be no loops. We demonstrated the performance gains of our method in terms of energy consumption and data delivery success rate compared to other state of the art solutions.

References

  • [1] Network-based communication for Industrie 4.0. Publications of Plattform Industrie 4.0, www.plattform-i40.de (2016), accessed: 01-01-2018
  • [2] Ha, M., Kim, D.: On-demand cache placement protocol for content delivery sensor networks. In: 2017 International Conference on Computing, Networking and Communications (ICNC). pp. 207–216 (Jan 2017)
  • [3] Perkins, C., Belding-Royer, E., Das, S.: Ad hoc on-demand distance vector (AODV) routing (2003)
  • [4] Raptis, T.P., Passarella, A.: A distributed data management scheme for industrial IoT environments. In: 2017 IEEE 13th International Conference on Wireless and Mobile Computing, Networking and Communications (WiMob). pp. 196–203 (Oct 2017)
  • [5] Raptis, T.P., Passarella, A., Conti, M.: Maximizing industrial IoT network lifetime under latency constraints through edge data distribution. In: 1st IEEE International Conference on Industrial Cyber-Physical Systems, (ICPS) (May 2018), available at http://cnd.iit.cnr.it/traptis/2018-raptis-icps.pdf
  • [6] Raptis, T.P., Passarella, A., Conti, M.: Distributed path reconfiguration and data forwarding in industrial iot networks (extended version). http://cnd.iit.cnr.it/traptis/2018-raptis-wwic-ext.pdf (2018)
  • [7] Sauter, T., Soucek, S., Kastner, W., Dietrich, D.: The evolution of factory and building automation. IEEE Industrial Electronics Magazine 5(3), 35–48 (Sept 2011)
  • [8] Shrouf, F., Ordieres, J., Miragliotta, G.: Smart factories in Industry 4.0: A review of the concept and of energy management approached in production based on the internet of things paradigm. In: 2014 IEEE International Conference on Industrial Engineering and Engineering Management. pp. 697–701 (Dec 2014)
  • [9] Sun, X., Ansari, N.: Traffic load balancing among brokers at the IoT application layer. IEEE Transactions on Network and Service Management 15(1), 489–502 (March 2018)
  • [10] Wollschlaeger, M., Sauter, T., Jasperneite, J.: The future of industrial communication: Automation networks in the era of the internet of things and Industry 4.0. IEEE Industrial Electronics Magazine 11(1), 17–27 (March 2017)
  • [11] Xu, L.D., He, W., Li, S.: Internet of things in industries: A survey. IEEE Transactions on Industrial Informatics 10(4), 2233–2243 (Nov 2014)
  • [12] Zhou, M., Yang, H., Zhang, X., Wang, J.: The proof of AODV loop freedom. In: 2009 International Conference on Wireless Communications Signal Processing. pp. 1–5 (Nov 2009)