High-level Control Structure Research Articles

Trajectory Tracking Control of Autonomous Underwater Vehicle Called PAST

The increasing development of Autonomous Underwater Vehicles (AUVs) with varying levels of autonomy can be seen globally. The paper is devoted to the new AUV called PAST being developed and built within the Polish development project entitled „Development of the underwater autonomous transport system” (no. POIR.01.01.01-00-0893/20). Mainly, the paper focuses on high-level control of PAST AUV devoted to controlling along the desired trajectory. It demands a set of tuned controllers of advanced velocity, course, depth, and trim. The trajectory tracking algorithm should be implemented and verified for different trajectories set in practice. At the beginning of the article, an introduction to the research is inserted. Then, the following scientific issues are presented: the mathematical model of AUV motion, high-level control structure, and the trajectory tracking algorithm. Next, the results of numerical research in the MATLAB environment are presented. In the end, the conclusions for future research are formulated.

Integrated Hardware Garbage Collection

Garbage collected programming languages, such as Python and C#, have accelerated software development. These modern languages increase productivity and software reliability as they provide high-level data representation and control structures. Modern languages are widely used in software development for mobile, desktop, and server devices, but their adoption is limited in real-time embedded systems. There is clear interest in supporting modern languages in embedded devices as emerging markets, like the Internet of Things, demand ever smarter and more reliable products. Multiple commercial and open-source projects, such as Zerynth and MicroPython, are attempting to provide support. But these projects rely on software garbage collectors that impose high overheads and introduce unpredictable pauses, preventing their use in many embedded applications. These limitations arise from the unsuitability of conventional processors for performing efficient, predictable garbage collection. We propose the Integrated Hardware Garbage Collector (IHGC); a garbage collector tightly coupled with the processor that runs continuously in the background. Further, we introduce a static analysis technique to guarantee that real-time programs are never paused by the collector. Our design allocates a memory cycle to the collector when the processor is not using the memory. The IHGC achieves this by careful division of collection work into single-memory-access steps that are interleaved with the processor’s memory accesses. As a result, our collector eliminates run-time overheads and enables real-time program analysis. The principles behind the IHGC can be used in conjunction with existing architectures. For example, we simulated the IHGC alongside the ARMv6-M architecture. Compared to a conventional processor, our experiments indicate that the IHGC offers 1.5–7 times better performance for programs that rely on garbage collection. The IHGC delivers the benefits of garbage-collected languages with real-time performance but without the complexity and overheads inherent in software collectors.

Компилятор с языка программирования EL: усовершенствование и развитие

The implementation of the new multi-paradigm (functionally- imperative) programming language El, developed at the Department of Computer Science of the Novosibirsk State Technical University, in the form of a compiler is associated with the need to find ways to solve a number of complex problems. The current version of the compiler does implement only partially functionality of the language and generates far from optimal executable codes. In this paper, we consider the problem of an efficient compilation of an El-program, taking into account the need to implement new high-level data structures (two-sided lists, vectors with special forms of access, and a number of others) and control structures of the language, which make it possible to uniformly define cyclic and branching computational processes, as well as those laid down in the language a mechanism for explicitly controlling the mutability of variables. The tasks of improving and developing a compiler organized according to the classical multi-platform scheme are briefly considered, in which the front-end (lexical, syntactic, and semantic analyzers) converts the program to be translated into pseudocode of a single format, and used efficient infrastructure for building LLVM compilers as a back-end that turns pseudocode into executable code for different platforms. Execution of all possible operations on elements of high-level data structures (lists, tuples, vectors), as well as on arbitrary-precision numbers, has been moved to the runtime support library and, accordingly, can be deeply optimized. For this structure, the outlined ways of solving the problem of developing and improving the compiler by deep reforming and optimization of the chain of transformations of the translated program implemented by the front-end are formulated. At the initial stage, it is planned to implement a new compiler for two platforms: Linux and Windows.

Development of Visual Servoing-Based Autonomous Docking Capabilities in a Heterogeneous Swarm of Marine Robots

This paper describes the design, development, and testing of both hardware and software for a visual servoing-based system that enables agents within a heterogeneous marine robotic swarm to share energy. The goal of this system is prolonging the active operational time of the swarm as a whole, allowing it to perform long-term environmental monitoring and data collection missions. The implementation presented in the paper features an over-actuated autonomous surface platform docking up to four floating sensor nodes at a time and replenishing their batteries using wireless inductive charging. Mechanical solutions for each robot segment related to the docking procedure are presented, along with pertinent high-level and low-level control structures. A node featuring an extended Kalman filter and additional heuristics is used to fuse measurements from a neural network trained for object detection and a hue thresholding image processing algorithm, in order to track the docking target and achieve visual servoing. Finally, experimental results in both a controlled environment and challenging conditions on-site are presented. Once deployed, the developed system successfully enables the approach and docking of the designated target, showing its feasibility in different real-life conditions.

Multi-Layer Event-Based Vehicle-to-Grid (V2G) Scheduling With Short Term Predictive Capability Within a Modular Aggregator Control Structure

In this work, a novel method of event-based V2G scheduling is devised that is suitable for dynamic real time aggregator control in large scale V2G applications within centrally controlled EV car parks. The method is applicable in deterministic systems where a V2G network provides or receives electricity in reoccurring and predictable patterns (events). The scheduling strategy shown is based on a robust modular high-level aggregator control structure and a proposed communications and data management system. The scheduling consists of three algorithm layers, differentiating between predictive scheduling for in-event periods, smart charging for out-of-event periods and reactive scheduling for ongoing adjustments in real-time to account for uncertainty. The scheduling process is described in terms of its underlying rules for prioritising EVs to be either charged or discharged. It's behaviour is then analysed using a simulated car park of up to one thousand connected EVs for an example application in which a V2G network is used to support nearby electrified rail infrastructure, providing power for train acceleration and accepting power from regenerative braking. The departure or arrival of a train of known type and speed pattern can be regarded as a reoccurring event and its effect on the V2G network is therefore predictable due to train schedules and tracking.

Ethereum smart contracts: Analysis and statistics of their source code and opcodes

Smart contracts are programs that are used for verifying and enforcing the terms of an agreement. Ethereum is an extensively used platform that can be used to execute smart contracts. These can be defined by using high-level languages such as Solidity, Vyper and Bamboo that are compiled into low-level machine instructions, i.e., bytecode. These instructions define a Turing complete language and are often represented by using a readable format that is referred to as opcodes. Here, we present a novel, more comprehensive, study that aims at gaining a precise understanding on how programmers use the linguistic instructions supported by Ethereum. More precisely, the contracts’ source code has been also analysed, in order to understand the high-level control structures and core instructions that are used for smart contract definitions, and how they are reflected on the opcode level. We have gathered ten of thousands of verified Ethereum smart contracts that have been written by using the Solidity language. This study can lay the groundwork for defining new formalisms and new domain specific languages (DSL). These can support the users in the development of decentralised applications (DAPPs).

Modelling distributed crewing in commercial aircraft with STAMP for a rapid decompression hazard

Changes to crewing configurations in commercial airlines are likely as a means of reducing operating costs. To consider the safety implications for a distributed crewing configuration, system theoretic accident model and processes (STAMP) was applied to a rapid decompression hazard. High level control structures for current operations and distributed crewing are presented. The CONOPS generated by STAMP-STPA for distributed crewing, and design constraints associated with unsafe control actions (UCAs) are offered to progress in the route to certification for distributed crewing, and improve safety in current operations. Control loops between stakeholders were created using system-theoretic process analysis (STPA). The factors leading to the Helios 255 incident demonstrated the redundancy that a ground station could offer without the risk of hypoxia, during a decompression incident. STPA analysis also highlighted initial UCAs that could occur within the hypothetical distributed crewing configuration, prompting consideration of design constraints and new CONOPS for ground station design.Practitioner Summary: SPO in commercial aircraft is likely as a means to reduce costs. This paper makes a case for distributed crewing using STAMP-STPA. Comparing current operations with a distributed crewing configuration, the redundancy offered by a ground station is demonstrated. Design constraints and new CONOPs for distributed crewing, and current operations are proposed.

Recovery method for high-level language control structures based on structural analysis

To correctly obtain the high-level language control structures of embedded executables and assembly code,and resolve the problem that the existing recovery methods for high-level language control structures cannot handle the unstructured region,the classical control analysis method,structural analysis algorithm,was introduced to study the recovery method for high-level control structures of embedded assembly code. The structural analysis algorithm was improved according to the characteristics of embedded executables,and the high-level language code was generated by using the program control tree,which can be obtained from the results of structural analysis algorithm. Compared with the open source decompiler named DCC,the results show that the improved algorithm is feasible and efficient.

SYNTHESIS OF CONTROL STRUCTURES FOR HIERARCHICAL CONTROL WITH FLEXIBLE MARKING

The Hierarchical Control with Flexible Marking (HCFM) for Discrete Event Systems (DESs) is an approach that brings important gains when compared to other similar hierarchical control approaches for DES, since it leads to less restrictive models in the high-level in a systematic and direct way. One critical point of the approach is the computation of the high-level DES control structure, exponentially dependent on the number of high-level events. This paper addresses two strategies to alleviate the computational effort to synthesize such control structures, exploiting the fact that they present the upper semilattice property. The economy in the synthesis of the high-level control structures is illustrated by an application example.

Creol: A type-safe object-oriented model for distributed concurrent systems

Object-oriented distributed computing is becoming increasingly important for critical infrastructure in society. In standard object-oriented models, objects synchronize on method calls. These models may be criticized in the distributed setting for their tight coupling of communication and synchronization; network delays and instabilities may locally result in much waiting and even deadlock. The Creol model targets distributed objects by a looser coupling of method calls and synchronization. Asynchronous method calls and high-level local control structures allow local computation to adapt to network instability. Object variables are typed by interfaces, so communication with remote objects is independent from their implementation. The inheritance and subtyping relations are distinct in Creol. Interfaces form a subtype hierarchy, whereas multiple inheritance is used for code reuse at the class level. This paper presents the Creol syntax, operational semantics, and type system. It is shown that runtime type errors do not occur for well-typed programs.

Operation management in reconfigurable manufacturing systems: Reconfiguration for error handling

Reconfigurable manufacturing systems offer quick adjustment of production capacity and functionality in response to unpredictable market changes as being systems designed at the outset for rapid change in system configuration, its machines and controls. During the production process, out-of-ordinary events occur dynamically and unpredictably both at the system (machine breakdowns, change in job's priorities, etc.) and at the cell level (tool failures, robot collisions, etc.). Such exceptions interrupt the production process by causing errors in the schedule plan (system level) or in the task plan (cell level). Error handling is the policy meant for reacting to errors caused by the occurrence of out-of-ordinary events. The reconfiguration ability turns out to be the new technological factor enabling new strategies to handle out-of-ordinary events of the production process. Both economic and performance aspects need to be considered in order to make a decision in support of particular error handling policies such as using reconfiguration. This paper, starting from a simulation case study, highlights advantage of using reconfiguration for error handling. Authors propose an object-oriented high-level control structure for real-time error handling, which integrates the new reconfiguration for error handling technology with the existing reactive scheduling system.

DISIPLE: digital signal processor programming language and environment

A compiler for signal processing applications with high-level language control structures and the ability to express computational parallelism is described. There are two expert system back-ends that generate code using advice about the architecture of the target machine(s). The first back-end generates code for control flow, and the second generates code for computation. Both expert systems use a rule base that describes the number, type, and architecture of the target processors. If an instruction cannot be directly implemented functionally equivalent intermediate language statements are automatically generated. Currently, the prototype compiler generates TMS320 family assembly code and code for distributed memory parallel computers.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Language features that aid the development of reliable, maintainable control system software

Today there exist several high-level languages with features that make them convenient and effective in control systems. These features include high-level control structures, user-defined data types, and machine-level programming. We discuss several of these features, focusing attention on our experience with the language C, developed by Bell Laboratories.

CHAMIL

The design of a Pascal based microprogramming language is described. It is a Pascal dialect adapted to the task of microprogramming a highly pipelined, horizontal micro-architecture. The nature of high level microprogramming languages, data and control structures, and the effect of a microprogramming environment on language and translator development are discussed. Certain complexities of horizontal micro-architectures are outlined.

The design of a global optimizer

We are constructing a compiler for a high level systems and applications programming language. Because the compiler is required to generate efficient object code, a global optimization phase and register allocation phase are an integral part of the design. It was determined that the familiar optimizations of code motion, redundant expression elimination, and dead code removal would be sufficient. The optimizer design was to be based on the most recent applicable theoretical results, yet simple and straightforward to implement. Traditional approaches were considered inadequate because they assume a primitive intermediate code representation (quadruples), elaborate flow graph constructions, and numerous special cases. High level data flow analysis as proposed by Rosen [1,2] provided the framework we sought. Using his approach, the parse tree of the program, with its high level control structures intact, becomes a suitable intermediate representation. Complex statement structures are analyzed quickly in two tree traversals to determine the solutions to data flow problems.

Interpretation control using a linear tree representation

AbstractA linear tree structure is considered for the internal representation of programs executed by interpreters. This representation is appropriate when one wishes to have an internal representation preserving the high level structures of the source language. The linear tree structure facilitates a simple mechanism for interpretation control in the context of high level control structures.