Figure 2 - uploaded by Hassan El Alami
Content may be subject to copyright.
Source publication
The communication protocols are an essential part for the data communication of Internet of Things (IoT) applications. However, the selection of a communication protocol is challenging because it depends on the nature of the IoT system and its data transmission system. Copious communications protocols have been developed and employed by researchers...
Similar publications
Citations
... They specify what is to be delivered and reception, as well as the appropriate responses. The most prevalent data transmission and reception protocols are HTTP, MQTT, and CoAP [20]. HTTP was applied in proposed work; HTTP is an application layer protocol for scattered, cooperative hypermedia networks. ...
... Client sends ACK packet in response to server's SYN-ACK packet. After this packet, the client and server will have a trustworthy session [20]. ...
An integration between the Internet of Things (IoT) and cloud computing can potentially leverage the utilization of both sides. As the IoT-based system is mostly composed of the interconnection of pervasive and constrained devices, it can take advantage of the virtually unlimited resources of cloud entities, i.e., storage and computation services, to store and process its sensed data. In this study, we examine the design and implementation of IoT and cloud computing platforms. The proposed system consists of two main components: hardware and software. Many experiments are used to gather data and upload it to the framework. The software is an IoT2ALK platform that is designed and implementation using front- and back-end techniques that can connect any IoT applications to it. Several experiments are implemented to ensure the effectiveness of the platform. The platform depends on connecting the IoT devices to it and using communication protocols like HTTP to transfer the data from the IoT devices to the platform. Another way to gather data is by uploading a CSV file to the platform after filling it with the required data. The system can collect, store, analyze, and process the data in an efficient manner
... Since the 802.11ah standard was published in early 2017, enhancing the association process of the standard has been an active research area [33][34][35][36][37][38]. In this section, we will describe a few studies with published performance results [39][40][41][42]. ...
The 802.11ah standard is a new energy-efficient, wireless networking protocol which allows thousands of indoor and outdoor devices to be connected to the same access point. The Centralized Authentication Control (CAC) method, described in the standard, enables up to 8000 stations to be authenticated and associated with the same access point. A baseline implementation of the CAC method has been reported; however, it suffers from a few limitations. In this paper, an efficient methodology is proposed to minimize the CAC method’s association time. The proposed methodology allows the association of a large number of stations by predicting the size of the network followed by selecting the best step size that will enable fast association between the access point and the stations of the network. The methodology consists of three stages. The first stage provides a baseline implementation of the 802.11ah standard, while the second stage eliminates the effect of too large or too small step sizes. The third stage finds the optimal step size and step repeat for each network size and predicts network size based on queue size. The performance of the proposed methodology is evaluated and compared in terms of total association time, number of total trials and percentage of ineffective trials. The methodology outperforms the baseline implementation by achieving a 30% reduction in the total association time, 30% reduction in the total number of trials and 45% reduction in the total number of ineffective trials.
... By using a publish-subscribe paradigm, MQTT reduces the number of messages a microcontroller needs to send. The publishsubscribe paradigm is commonly used in IoT contexts because its simplicity and effectiveness at reducing network traffic [57,128]. The main idea of this paradigm is to disconnect communication in time and space. ...
Computer programs need to deal with nondeterministic environments. This nondeterminism may arise from many sources, like user input and concurrency for example. If program input were to be deterministic, there would be no need for complex programs. A word processor with deterministic input can simply present the user with their envisioned written document without them having to type it. Nondeterminism caused by concurrency stems from the unknown speed of each thread, the possibility of lost messages and so on. Although it leads to nondeterministic execution, we sometimes need it to fulfill real-world demands such as execution performance and high availability. If a program is nondeterministic, the next state may be one of multiple possibilities. When writing the program, the developer must imagine all possible executions to prevent bugs. Even if there are only two possibilities per program step, there are 2^n possible executions of n steps. This exponential state explosion is what makes working with nondeterminism so difficult. If a failure occurs in one of the myriad of execution traces, it is difficult to find its root cause. Typical debuggers only allow users the debug just one of the possible traces, while the failure may only manifest in very rare execution traces. Both humans and computers cannot deal with state explosion well. Programming languages have nondeterminism introducing constructs to facilitate working in nondeterministic environments. There are constructs for acquiring input, starting concurrent threads and so on. The chosen constructs greatly impact the nondeterminism the programmer has to deal with. In this dissertation we investigate the tree main ways programming systems can work with nondeterminism: embrace it, capture it, and avoid it. First, to embrace nondeterminism we must have the tools to deal with the state explosion it generates. In this dissertation, we present a tool called GraphRedex, which allows exploring the state space graph of nondeterministic programs. Our tool contributes a novel exploration technique for dealing with state explosion: interactive exploration. We allow developers to choose what path in the state space graph they want to follow. This helps developers see the wood for the trees when visualizing all possible execution paths of a program. We conducted a user study to confirm GraphRedex is user friendly and helps uncover bugs. Additionally, we used it to find errors in published research. A second option is to capture the nondeterminism. When something goes wrong in a program’s execution, it is often difficult to determine the exact conditions that triggered a bug. By keeping track of the nondeterministic choices the program makes during its execution, we can replay them, even backwards. If the program failed, stepping backwards can help find the bug that caused the failure. We have implemented such a backwards stepping functionality for a platform that is notoriously difficult to debug or even write programs for: microcontrollers. To do this, we created a WebAssembly virtual machine (VM) for these devices. Our VM, WARDuino allows programmers to use higher level languages to program microcontrollers. A language interoperability layer ensures that device peripherals are safely accessible. While higher level languages alone already prevent bugs, WARDuino additionally allows debugging applications remotely via a VSCode plugin. We show that our novel event-based out-of-place debugging technique reduces debugging latency and permits backwards stepping. Additionally, we determine that WARDuino is fast enough to implement IoT applications by carrying out micro benchmarks. Third, nondeterminism can be avoided by carefully selecting the provided language constructs. As an example of this approach, this dissertation presents Gaiwan. This is a general-purpose GPU (GPGPU) programming language intended for processing time series data. The language is based on a novel size-polymorphic type system we designed and implemented Additionally, Gaiwan only features race condition free constructs. By using our language, non-expert GPGPU users avoid two sources of nondeterminism: the nondeterministic size of the input, and the nondeterminism arising from data races on these extremely parallel devices. Gaiwan’s type system allows developers to use affine functions in one variable to declare the effect parts of their program have on data buffers. From this, our type system derives a set of constraints to which the input should adhere for the program to work. Inputs that do not satisfy these constraints will be rejected. Gaiwan prevents data races by only providing deterministic data race free language constructs. We provide the standard correctness proofs for our type system. Although our proof-of-concept evaluator is not yet fully optimized, we also implement a bitonic sorting algorithm in it and demonstrate that it only has a 25% overhead compared to a handwritten OpenCL implementation from Intel.
Creating IoT programs for resource-constrained microcontrollers differs significantly from conventional computer programming. Microcontrollers are traditionally programmed using low-level programming languages with poor debugging facilities. By contrast, general-purpose systems can be programmed with high-level languages, which make programming easier by providing many useful tools such as advanced debuggers, strong type systems, and/or automatic memory management. Most existing solutions for programming microcontrollers with high-level languages are strongly tied to a specific microcontroller architecture, which makes porting code difficult or impossible. In addition, compiling and flashing software onto a microcontroller is time-consuming, slowing down development.
To solve these problems we present WARDuino, a WebAssembly virtual machine that runs on microcontrollers and provides WebAssembly primitives to control embedded hardware and IoT functionality. WARDuino runs programs written in a plethora of high-level languages that compile to WebAssembly. We give a general approach for language integration libraries to expose the peripherals and networking capabilities of the device following the idioms of the host language.
To ease development, we extend WebAssembly with support for remote debugging and over-the-air reprogramming. WARDuino can remotely instruct a microcontroller to pause, to step, or to dump its state, and to replace local variables, functions or even the entire running program. We use the remote debugger of the virtual machine to create a visual debugging environment in VS Code for WARDuino, that can debug WebAssembly and AssemblyScript. Aside from these important tools, we provide a novel mechanism to handle asynchronous interrupts in WebAssembly, a fundamental building block for responsive embedded applications. Our extensions are implemented in the WARDuino virtual machine and presented as formal extensions to the WebAssembly operational semantics. We use the formalization to proof observational equivalence for the core debugger semantics.
The Internet of Things (IoT) based smart strategies are often resource constrained with respect to energy, computation and memory. Outdated communication protocols are inappropriate for IoT ecosystem because of large overhead, lack of Quality of Service (QoS) and increased complexity. As billions of devices are required to be deployed over diverse applications, the IoT communication system acts as a prominent aspect and so the selection of suitable IoT communication protocol is highly essential. Also, there is a greater need of analysing the protocol behaviour under diverse network conditions. Hence to select a suitable protocol by addressing the limitations, this research paper mainly focuses on comparing lightweight application layer protocols, including Message Queuing Telemetry Transport (MQTT), Constrained Application Protocol (CoAP) and MQTT for sensor Network (MQTTSN). Evaluating the performance of protocol libraries in real environment is highly significant because it helps to discover potential interoperability and compatibility challenges. Also, it can reveal the protocol’s ability in handling scalability and its support in dealing a number of devices efficiently. A testbed named “ProtoLab” has been created for evaluating the performances of CoAP, MQTT and MQTTSN protocols under variable network condition. Using the testbed, the client and server can exchange the data packets under the variable network condition created with the help of network emulator. The data packets can be received and exported using the wireshark application to create a dataset for analysis. Different parameters like round trip time, duplication, round trip reliability, server response time, reliability towards the client to server and client overhead are analysed by configuring loss, corruption, reordering and network delay in the network emulator using wide area network emulator (WANEM) to evaluate the performance of IoT communication protocols. Variable network conditions are considered and analysed using real-time ProtoLab testbed by varying the parameters. The results and observations analyzed through this research can support IoT application developers in making informed decisions while selecting communication protocols for different applications. On analysing the parameters under diverse network conditions, the MQTTSN protocol performs comparatively better in terms of resource efficient delivery in constrained environment. Meanwhile, the MQTT protocol is analysed to be better when concerned with reliability.
