23,390 research outputs found
On Abstraction-Based Controller Design With Output Feedback
We consider abstraction-based design of output-feedback controllers for
dynamical systems with a finite set of inputs and outputs against
specifications in linear-time temporal logic. The usual procedure for
abstraction-based controller design (ABCD) first constructs a finite-state
abstraction of the underlying dynamical system, and second, uses reactive
synthesis techniques to compute an abstract state-feedback controller on the
abstraction. In this context, our contribution is two-fold: (I) we define a
suitable relation between the original system and its abstraction which
characterizes the soundness and completeness conditions for an abstract
state-feedback controller to be refined to a concrete output-feedback
controller for the original system, and (II) we provide an algorithm to compute
a sound finite-state abstraction fulfilling this relation.
Our relation generalizes feedback-refinement relations from ABCD with
state-feedback. Our algorithm for constructing sound finite-state abstractions
is inspired by the simultaneous reachability and bisimulation minimization
algorithm of Lee and Yannakakis. We lift their idea to the computation of an
observation-equivalent system and show how sound abstractions can be obtained
by stopping this algorithm at any point. Additionally, our new algorithm
produces a realization of the topological closure of the input/output behavior
of the original system if it is finite-state realizable
On Model Based Synthesis of Embedded Control Software
Many Embedded Systems are indeed Software Based Control Systems (SBCSs), that
is control systems whose controller consists of control software running on a
microcontroller device. This motivates investigation on Formal Model Based
Design approaches for control software. Given the formal model of a plant as a
Discrete Time Linear Hybrid System and the implementation specifications (that
is, number of bits in the Analog-to-Digital (AD) conversion)
correct-by-construction control software can be automatically generated from
System Level Formal Specifications of the closed loop system (that is, safety
and liveness requirements), by computing a suitable finite abstraction of the
plant.
With respect to given implementation specifications, the automatically
generated code implements a time optimal control strategy (in terms of set-up
time), has a Worst Case Execution Time linear in the number of AD bits , but
unfortunately, its size grows exponentially with respect to . In many
embedded systems, there are severe restrictions on the computational resources
(such as memory or computational power) available to microcontroller devices.
This paper addresses model based synthesis of control software by trading
system level non-functional requirements (such us optimal set-up time, ripple)
with software non-functional requirements (its footprint). Our experimental
results show the effectiveness of our approach: for the inverted pendulum
benchmark, by using a quantization schema with 12 bits, the size of the small
controller is less than 6% of the size of the time optimal one.Comment: Accepted for publication by EMSOFT 2012. arXiv admin note:
substantial text overlap with arXiv:1107.5638,arXiv:1207.409
Caring, sharing widgets: a toolkit of sensitive widgets
Although most of us communicate using multiple sensory modalities in our lives, and many of our computers are similarly capable of multi-modal interaction, most human-computer interaction is predominantly in the visual mode. This paper describes a toolkit of widgets that are capable of presenting themselves in multiple modalities, but further are capapble of adapting their presentation to suit the contexts and environments in which they are used. This is of increasing importance as the use of mobile devices becomes ubiquitous
A Map-Reduce Parallel Approach to Automatic Synthesis of Control Software
Many Control Systems are indeed Software Based Control Systems, i.e. control
systems whose controller consists of control software running on a
microcontroller device. This motivates investigation on Formal Model Based
Design approaches for automatic synthesis of control software.
Available algorithms and tools (e.g., QKS) may require weeks or even months
of computation to synthesize control software for large-size systems. This
motivates search for parallel algorithms for control software synthesis.
In this paper, we present a Map-Reduce style parallel algorithm for control
software synthesis when the controlled system (plant) is modeled as discrete
time linear hybrid system. Furthermore we present an MPI-based implementation
PQKS of our algorithm. To the best of our knowledge, this is the first parallel
approach for control software synthesis.
We experimentally show effectiveness of PQKS on two classical control
synthesis problems: the inverted pendulum and the multi-input buck DC/DC
converter. Experiments show that PQKS efficiency is above 65%. As an example,
PQKS requires about 16 hours to complete the synthesis of control software for
the pendulum on a cluster with 60 processors, instead of the 25 days needed by
the sequential algorithm in QKS.Comment: To be submitted to TACAS 2013. arXiv admin note: substantial text
overlap with arXiv:1207.4474, arXiv:1207.409
A New Simulation Metric to Determine Safe Environments and Controllers for Systems with Unknown Dynamics
We consider the problem of extracting safe environments and controllers for
reach-avoid objectives for systems with known state and control spaces, but
unknown dynamics. In a given environment, a common approach is to synthesize a
controller from an abstraction or a model of the system (potentially learned
from data). However, in many situations, the relationship between the dynamics
of the model and the \textit{actual system} is not known; and hence it is
difficult to provide safety guarantees for the system. In such cases, the
Standard Simulation Metric (SSM), defined as the worst-case norm distance
between the model and the system output trajectories, can be used to modify a
reach-avoid specification for the system into a more stringent specification
for the abstraction. Nevertheless, the obtained distance, and hence the
modified specification, can be quite conservative. This limits the set of
environments for which a safe controller can be obtained. We propose SPEC, a
specification-centric simulation metric, which overcomes these limitations by
computing the distance using only the trajectories that violate the
specification for the system. We show that modifying a reach-avoid
specification with SPEC allows us to synthesize a safe controller for a larger
set of environments compared to SSM. We also propose a probabilistic method to
compute SPEC for a general class of systems. Case studies using simulators for
quadrotors and autonomous cars illustrate the advantages of the proposed metric
for determining safe environment sets and controllers.Comment: 22nd ACM International Conference on Hybrid Systems: Computation and
Control (2019
Observer-based correct-by-design controller synthesis
Current state-of-the-art correct-by-design controllers are designed for
full-state measurable systems. This work first extends the applicability of
correct-by-design controllers to partially observable LTI systems. Leveraging
2nd order bounds we give a design method that has a quantifiable robustness to
probabilistic disturbances on state transitions and on output measurements. In
a case study from smart buildings we evaluate the new output-based
correct-by-design controller on a physical system with limited sensor
information
A toolkit of mechanism and context independent widgets
Most human-computer interfaces are designed to run on a static platform (e.g. a workstation with a monitor) in a static environment (e.g. an office). However, with mobile devices becoming ubiquitous and capable of running applications similar to those found on static devices, it is no longer valid to design static interfaces. This paper describes a user-interface architecture which allows interactors to be flexible about the way they are presented. This flexibility is defined by the different input and output mechanisms used. An interactor may use different mechanisms depending upon their suitability in the current context, user preference and the resources available for presentation using that mechanism
- …