This paper proposes as an element of novelty the Unified Form (UF) clustering algorithm, which treats Fuzzy C-Means (FCM) and K-Means (KM) algorithms as a single configurable algorithm. UF algorithm was designed to facilitate the FCM and KM algorithms software implementation by offering a solution to implement a single algorithm, which can be configured to work as FCM or KM. The second element of novelty of this paper is the Partitional Implementation of Unified Form (PIUF) algorithm, which is built upon the UF algorithm and designed to solve in an elegant manner the challenges of processing large datasets in a sequential manner and the scalability of the UF algorithm for processing datasets of any size. PIUF algorithm has the advantage of overcoming any possible hardware limitations that can occur if large volumes of data are processed (required to be stored, loaded in memory and processed by a certain specified computational system). PIUF algorithm is designed and formulated to be used on a single machine if the processed dataset is very big and it cannot be entirely loaded in the memory; at the same time it can be scaled to multiple processing nodes for reducing the processing time required to find the optimal solution. UF and PIUF algorithms are implemented and validated in BigTim platform, which is a distributed platform developed by the authors, and offers support for processing various datasets in a parallel manner but they can be implemented in any other data processing platforms. The Iris dataset is considered and next modified to obtain different datasets of different sizes in order to test the algorithms implementations in BigTim platform in different configurations. The analysis of PIUF algorithm and the comparison with FCM, KM and DBSCAN clustering algorithms are carried out using two performance indices; three performance indices are employed to evaluate the quality of the obtained clusters.

The majority of present clustering algorithms are designed to work in a sequential manner processing offline data on a single machine. Different approaches were considered for parallelizing the existing clustering algorithms to run in a parallel manner for increasing the size of the dataset that can be processed by a computational system. This paper suggests an extended architecture of the BigTim platform such that to be capable of running clustering algorithms in a distributed manner on mobile devices. The paper presents an enhanced version of the BigTim platform, which will run clustering algorithms on a cluster of devices composed by mobile devices (mobile phones and tablets) and computers connected through a network and working together in a MapReduce manner.

As car sharing becomes an increasingly common task, mediating user access rights from external servers comes with threats regarding user’s privacy. Clearly, users can be tracked by service mediators, e.g., cloud providers, that manage vehicle fleets, etc. In this work we design and test a simple solution based on oblivious transfer, a well-known and secure cryptographic block, that allows to preserve user’s privacy when gaining access to the vehicle. We test the feasibility of deploying such a solution on Android capable smartphones but also account for potential in-vehicle components, e.g., car head units, that may be soon put to such tasks. We use Microsoft Azure as cloud service provider and deploy a Java implementation, based on the Bouncy Castle cryptographic library, on the server side. Our experimental results show that Android based units are capable of handling the required cryptographic operations and the implementation of the employed protocol can be done by existing open-source support.

Most of the clustering algorithms are designed to work as a sequential algorithm that requires all data to be present, which limits the actual implementation to run on a single machine and does not support horizontal scalability. This is problematic in today’s context when volume of data gets larger each day and the need to process data quickly is essential. Hence, in this paper we propose a platform that allows running clustering algorithms in a distributed manner. This is achieved through splitting the data into smaller and equal partitions, and through redesigning the original clustering algorithms to allow working on a sub-set of the input data without having to interact with the processing of the rest of the input data. At the end the so-called reduce phase aggregates the partial results obtained from processing each partition and it produces the global result.

Sensor networks technologies had proved their great practicability in the real world, being just a matter of time until this kind of networks will be standardized and used in the field. This paper presents a new approach to secure the transmission of information in sensor networks and is based on a combined hardware-software architecture using three components: a) a mechanism to provide sensor authentication and secret key distribution; b) AES symmetrical encryption algorithm with predistributed keys; and c) an attack detection stratagem using an expert system based on the prediction of the values provided by the sensors, followed by reducing the sensor trust coefficient.

This paper discusses new optimal path planning algorithms based on a Gravitational Search Algorithm (GSA) and on a Particle Swarm Optimization (PSO) algorithm applied to multiple mobile robots on holonomic wheeled platforms. Four path planning objectives are aggregated in the definition of a set of separate optimization problems for each robot. Each optimization problem involves a single scalar objective function (o.f.) expressed as the weighted sum of four o.f.s. The GSA and the PSO algorithm solve the optimization problems aiming the minimization of the o.f.s, and the path planning algorithms transform the solutions to the optimization problems into optimal solutions as optimal paths. The GSA-and PSO-based path planning algorithms are validated by several experiments with multiple robots that participate in missions.

This paper proposes an optimal path planning algorithm for mobile robots based on a hybridization between a Gravitational Search Algorithm (GSA) and a Particle Swarm Optimization (PSO) algorithm and referred to as hybrid PSO-GSA. The multi-objective optimization is considered as the PSO-GSA uses two objective functions to generate optimal trajectories for mobile robots in static environments while avoiding collisions with the obstacles and danger zones that might exist in the environment. The hybrid PSO-GSA solves the optimization problems by minimizing the objective functions, producing optimal collision-free trajectories in terms of minimizing the length of the path that needs to be followed by the robot and also assuring that the generated trajectories are at a safe distance from the danger zones. The proposed hybrid PSO-GSA path planning algorithm is validated by running several experiments with robots in different environments in the presence of multiple obstacles and multiple danger zones.

This paper proposes a new Gravitational Search Algorithm (GSA)-based approach for generating an optimal path for a robot travelling in partially unknown environments in the presence of multiple (static or dynamic) obstacles. The GSA-based approach is expressed as an algorithm which computes an optimal path for a robot that travels from an initial point to a target point while avoiding all the known obstacles in the environment but also any other static or dynamic object that could appear in the path of the robot to the target point. To validate the new approach for the path planning, the new algorithm is employed in the generation of obstacle-free paths for different robots that are participating in different missions in the framework of the nRobotic platform developed at the “Politehnica” University of Timisoara, Romania. A comparison focused on the resulted path length and performance with another well-known evolutionary algorithm represented by the Particle Swarm Optimization used for path planning is performed.

This paper proposes a navigation algorithm that allows mobile robots that participate in different missions to move in unknown environment. The algorithm uses data from the sonar or from the infrared sensors mounted on the robots and data from the video camera with which the robots are equipped. Using the video camera the robots will be able to detect and classify different traffic signs that can help the robots to arrive the target points safely and in a short time. The algorithm includes a convolutional neural network with six layers to classify the traffic signs. Several simulations were run on the nRobotic platform developed at the “Politehnica” University of Timisoara, Romania, to validate the new algorithm. The simulation scenarios illustrate attractive mechatronics applications concerning the behaviors of robots in unknown environments in the presence of multiple traffic signs.

Hierarchical Timing Language (HTL) is a coordination language for distributed, hard real-time applications. HTL is a hierarchical extension of Giotto and, like its predecessor, based on the logical execution time (LET) paradigm of real-time programming. Giotto is compiled into code for a virtual machine, called the Embedded Machine (or E machine). If HTL is targeted to the E machine, then the hierarchical program structure needs to be flattened; the flattening makes separate compilation difficult, and may result in E machine code of exponential size. In this paper, we propose a generalization of the E machine, which supports a hierarchical program structure at runtime through real-time trigger mechanisms that are arranged in a tree. We present the generalized E machine, and a modular compiler for HTL that generates code of linear size. The compiler may generate code for any part of a given HTL program separately in any order.

This paper offers applications of the nRobotic platform in the framework of path planning and collision avoidance for mobile robots in missions. The nRobotic platform has been proposed three years ago and developed at the “Politehnica” University of Timisoara, Romania, aiming communication with several types of robots. The concept of robot operation is introduced to represent common actions that can be performed by a robot and shared across various missions requiring more than a single capability. A new path planning algorithm is suggested in this paper as an extension of the vector field histogram algorithm with an additional input represented by the positions of other robots. Aspects concerning the implementation of the new path planning algorithm and experimental results are included.

Optical character recognition (OCR) technologies have known an effervescent development in last decade. Development was strongly influenced by the development of hardware, advance in image processing, and classification algorithms. There are multiple OCR technologies available, each of them based on different approaches, e.g., geometric processing or cognitive learning based on neural networks. One critical parameter for each of those approaches is execution time. In our opinion a very important percent of text used to be “OCRed” is coming from preprinted documents and forms, which are bounded by various regulations in layout and/or contained information. Based on this observation we argue that most of the characters that must be recognized have a similar layout, thus improvement of the processing performance can be obtained by creating classes of similar characters (blobs) based on geometric similarities, and performing OCR only on the representative blob from each class. In this paper we will present the architecture of an OCR technology based on a multilayer neural network. Performance improvement has been obtained using a blob classifier that groups characters in classes, and then perform OCR only on the representative blob from each class.

In the last two decades there has been a lot of interest in developing new techniques and new technologies for programming real-time control applications. One of the most recent innovations in the field of real-time programming is represented by the introduction of Hierarchical Timing Language (HTL). Although HTL has many advantages, e.g., timing portability, refinement, etc., one of its major drawbacks is considered to be the overhead introduced at runtime. Nevertheless, in this paper we show that it is possible to develop real-time control applications using HTL for hardware platforms with limited resources, e.g., a microcontroller. Thus in this paper we present an implementation of HTL that targets a microcontroller and we use a quad rotor helicopter to evaluate the performance of the implementation. We also extend the concept of Worst Case Execution Time (WCET) of a task so that it considers the overhead introduces by the runtime system.

In this paper we propose a platform for interconnecting robots that are different in terms of capabilities, hardware, and software. We define a software representation for a robot and for a mission and we discuss possible implementations for three types of robots. The platform exposes a service through which other applications can control different types of robots through a unified interface.

Exotasks are a novel Java programming construct that achieve three important goals. They achieve low latency while allowing the fullest use of Java language features, compared to previous attempts to restrict the Java language for use in the submillisecond domain. They support pluggable schedulers, allowing easy implementation of new scheduling paradigms in a real-time Java system. They can achieve deterministic timing, even in the presence of other Java threads, and across changes of hardware and software platform. To achieve these goals, the program is divided into tasks with private heaps. Tasks may be strongly isolated, communicating only with each other and guaranteeing determinism, or weakly isolated, allowing some communication with the rest of the Java application. Scheduling of the tasks' execution, garbage collection, and value passing is accomplished by the pluggable scheduler. Schedulers that we have written employ logical execution time (LET) in association with strong isolation to achieve time portability. We have also built a quad-rotor model helicopter, the JAviator, which we use to evaluate our implementation of Exotasks in an experimental embedded version of IBM's J9 real-time virtual machine. Our experiments show that we are able to maintain very low scheduling jitter and deterministic behavior in the face of variations in both software load and hardware platform. We also show that Exotasks perform nearly as well as Eventrons on a benchmark audio application.

We propose the notion of logical reliability for real-time program tasks that interact through periodically updated program variables. We describe a reliability analysis that checks if the given short-term (e.g., single-period) reliability of a program variable update in an implementation is sufficient to meet the logical reliability requirement (of the program variable) in the long run. We then present a notion of design by refinement where a task can be refined by another task that writes to program variables with less logical reliability. The resulting analysis can be combined with an incremental schedulability analysis for interacting real-time tasks proposed earlier for the Hierarchical Timing Language (HTL), a coordination language for distributed real-time systems. We implemented a logical-reliability-enhanced prototype of the compiler and runtime infrastructure for HTL.

Chaos-based cryptography emerged in the early 1990s as an innovative application of nonlinear dynamics in the chaotic regime. Even if in theory chaotic dynamics was thought to evolve into a new revolution in cryptography, in real-life an efficient and reliable chaos-based cryptosystem didn't emerge. The main but not the only reason is the dynamic degradation of digital chaotic systems, a subject that became very popular in the last few years. This paper presents a new theoretical background related to this issue that proves the inefficiency of chaos-based encryption algorithms. Even more, in one of the two relevant case studies presented, another myth is demolished: the analog encryption base on synchronized chaos.

Existing programming methodologies for real-time systems suffer from a low level of abstraction and non-determinism in both the timing and the functional domains. As a result, real-time systems are difficult to test and must be re-certified every time changes are made to either the software or hardware environment. Exotasks are a novel Java programming construct that achieve deterministic timing, even in the presence of other Java threads, and across changes of hardware and software platform. They are deterministic functional data-flow tasks written in Java, combined with an orthogonal scheduling policy based on the logical execution time ( LET) model. We have built a quad-rotor model helicopter, the JAviator, which we use as a testbed for this work. We evaluate our implementation of exotasks in IBM's J9 real-time virtual machine using actual flights of the helicopter. Our experiments show that we are able to maintain deterministic behavior in the face of variations in both software load and hardware platform.