Finite State Machine

Centralized communication-based control is one of the main methods that can be implemented to achieve autonomous advanced energy management capabilities in DC microgrids. However, its major limitation is the fact that communication bandwidth and computation resources are limited in practical applications. This can be often improved by avoiding redundant communications and complex computations. In this paper, an autonomous communication-based hybrid state/event driven control scheme is proposed. This control scheme is hierarchical and heuristic, such that on the primary control level, it encompasses state-driven local controllers, and on the secondary control level, an event-driven MG centralized controller (MGCC) is used. This heuristic hybrid control system aims at reducing the communication load and complexity, processor computations, and consequently system cost while maintaining reliable autonomous operation during all possible scenarios. A mathematical model for the proposed control scheme using Finite State Machines (FSM) has been developed and used to cover all the possible modes/sub-modes of operation, and assure seamless transitions among them during various events. Results of some case studies involving severe operational scenarios were presented and discussed. Results verify the validity and effectiveness of the proposed communication-based control scheme. Index Terms—Communication-based control, DC microgrids, finite state machine, hybrid state/event driven control.

The mission of tracking a pedestrian is valuable for many applications including walking distance estimation for the purpose of pervasive healthcare, museum and shopping mall guides, and locating emergency responders. In this paper, we show how accurate and ubiquitous tracking of a pedestrian can be performed using only the inertial sensors embedded in his/her mobile phone. Our work depends on performing dead reckoning to track the user's movement. The main challenge that needs to be addressed is handling the noise of the low cost low quality inertial sensors in cell phones. Our proposed system combines two novel contributions: a novel step count estimation technique and a gait-based accurate variable step size detection algorithm.

— The first part of paper discusses a variety of issues regarding finite state machine design using the hardware description language. VHDL coding styles and different methodologies are presented. Our study of FSM focuses on the modeling issues such as VHDL coding style, state encoding schemes and Mealy or Moore machines. Our discussion is limited to the synchronous FSM, in which the transition is controlled by a clock signal and can occur only at the triggering edge of the clock. The second part contains a worked example of a model that detects a unique pattern from a serial input data stream and generates a '1' value to output whenever the sequence '10' occurs. The string detector is modeled at the RTL level in VHDL and Verilog, for comparison purposes. The last part of this paper presents a view on VHDL and Verilog languages by comparing their similarities and contrasting their difference.

At the beginning of taking a shower, the user needs to manually adjust a rotational handle or the ratio of cold and hot water to get the desired water temperature and the flow rate. In this paper, a temperature and flow rate sensor feedback smart shower is proposed which takes the target water temperature and flow rate from the user as input, and then automatically adjusts the ratio of the cold and the hot water during the shower to keep the temperature and flow rate fixed-even though there is fluctuation of supply water temperature and pressure. The proposed system contains distance sensor and automatically turns off the shower when the user is away for soaping or shampooing. The system generates a report on water usage and shower time – to promote awareness on saving water. An embedded system based prototype of the proposed shower has been developed and tested.

This paper presents a rigorous method for reconstructing events in digital systems. It is based on the idea, that once the system is described as a finite state machine, its state space can be explored to determine all possible scenarios of the incident. To formalize evidence, the evidential statement notation is introduced. It represents the facts conveyed by the evidence as a series of witness stories that restrict possible computations of the finite state machine. To automate event reconstruction, a generic event reconstruction algorithm is proposed. It computes the set of all possible explanations for the given evidential statement with respect to the given finite state machine.

This paper surveys the design of embedded computer systems, which use software running on programmable computers to implement system functions. Creating an embedded computer system which meets its performance, cost, and design time goals is a hardware-software co-design p r o b l e w h e design of the hardware and software components influence each other. This paper emphasizes a historical approach to show the relationships between well-understood design problems and the as-yet unsolved problems in co-design. We describe the relationship between hardware and sofhvare architecture in the early stages of embedded system design. We describe analysis techniques for hardware and software relevant to the architectural choices required for hardware-software co-design. We also describe design and synthesis techniques for co-design and related problems.

— In this paper, an autonomous communication-based centralized control for DC microgrids (MG) has been developed and implemented. The proposed controller enables smooth transition between various operating modes. Finite state machine (FSM) has been used to mathematically describe the various operating modes (states), and the events that may lead to mode changes (transitions). Therefore, the developed centralized controller aims at optimizing the performance of MG during all possible operational scenarios, while maintaining its reliability and stability. Results of selected drastic cases have been presented. These results show stable transition between modes, verifying the validity and applicability of the proposed controller.

Abstract. This paper presents the methodology used to design a Domain Specific Visual Language (DSVL), named HALL (Human Assisted Logic Language), for the purpose of deriving automatically or semiautomatically user interfaces for critical control systems. We will describe our approach to design this language's abstract syntax and the process to describe its semantics by using formal framework based on an algebraic Petri-nets formalism: Concurrent Object-Oriented Petri Nets (CO-OPN). Keywords: Coordination- ...

Gesture recognition pertains to recognizing meaningful expressions of motion by a human, involving the hands, arms, face, head, and/or body. It is of utmost importance in designing an intelligent and efficient human-computer interface. The applications of gesture recognition are manifold, ranging from sign language through medical rehabilitation to virtual reality. In this paper, we provide a survey on gesture recognition with particular emphasis on hand gestures and facial expressions. Applications involving hidden Markov models, particle filtering and condensation, finite-state machines, optical flow, skin color, and connectionist models are discussed in detail. Existing challenges and future research possibilities are also highlighted.

Researchers and practitioners are still trying to find effective ways to model and test Web applications. This paper proposes a system-level testing technique that combines test generation based on finite state machines with constraints. We use a hierarchical approach to model potentially large Web applications. The approach builds hierarchies of Finite State Machines (FSMs) that model subsystems of the Web applications, and then generates test requirements as subsequences of states in the FSMs. These subsequences are then combined and refined to form complete executable tests. The constraints are used to select a reduced set of inputs with the goal of reducing the state space explosion otherwise inherent in using FSMs. The paper illustrates the technique with a running example of a Web-based course student information system and introduces a prototype implementation to support the technique.

A promising approach to managing business operations is based on business entities with lifecycles (BEL's) (a.k.a. business artifacts), i.e., key conceptual entities that are central to guiding the operations of a business, and whose content changes as they move through those operations. A BEL type includes both an information model that captures, in either materialized or virtual form, all of the business-relevant data about entities of that type, and a lifecycle model, that specifies the possible ways an entity of that type might progress through the business by responding to events and invoking services, including human activities. Most previous work on BEL's has focused on the use of lifecycle models based on variants of finite state machines. This paper introduces the Guard-Stage-Milestone (GSM) meta-model for lifecycles, which is an evolution of the previous work on BEL's. GSM lifecycles are substantially more declarative than the finite state machine variants, and support hierarchy and parallelism within a single entity instance. The GSM operational semantics are based on a form of Event-Condition-Action (ECA) rules, and provide a basis for formal verification and reasoning. This paper provides an informal, preliminary introduction to the GSM approach, and briefly overviews selected research directions.

Active libraries are code parts playing an active role during compilation. In C++ active libraries are implemented with the help of template metaprogramming (TMP) techniques. In this paper we present an active library designed as an implementation tool for Finite state machines. With the help of various TMP constructs, our active library carries out compile-time actions like optimizations via state-minimalization, and more sophisticated error-detection steps. Our library provides extended functionality to the Boost::Statechart library, the popular FSM implementation of the Boost library. We describe the implementation and analyze the efficiency.

Hand gestures recognition is the natural way of Human Machine interaction and today many researchers in the academia and industry are interested in this direction. It enables human being to interact with machine very easily and conveniently without wearing any extra device. It can be applied form sign language recognition to robot control and from virtual reality to intelligent home systems. In this paper we are discussing work done in the area of hand gesture recognition where focus is on the soft computing based methods like artificial neural network, fuzzy logic, genetic algorithms, etc. We also described hand detection methods in the preprocessed image for detecting the hand image. Most researchers used fingertips for hand detection in appearance based modeling. Finally we are comparing results given by different researchers after their implementation.

Finite-state machines (FSMs) are among the oldest models employed in the formalization and analysis of both software and hardware. Owing to their simplicity, there exist various implementations to support their practical application in mainstream programming languages. Through such software libraries, programmers can explicitly define states, events and transitions in order to delegate the machine's execution to an underlying engine. However, as far as we know, no such library provides formal verification capabilities alongside its execution engine. That is to say, once an FSM is defined, the resulting program cannot be used as a formal specification to be subject to formal verification , thereby not making the analytical tractability of FSMs available. Formal verification, if any, is conducted in an independent model separate from the program, thus duplicating the information and creating the possibility of discrepancies between both. In this paper we show how to overcome this limitation. To this end, we present the Verum library, which allows the specification, execution and verification of FSMs in the Ruby language, largely bypassing the need to explicitly employ an additional modeling language. Formal verification is achieved by automatically translating the source program of the FSM into a Timed Automaton (TA) specification for the UPPAAL model checker. To illustrate the value of the approach, we present the industrial problem which inspired the creation of this tool and is currently using it, namely, a payment system. Besides the technical aspects of the tool, a number of practical lessons learned with this application are explored. Although we describe very concrete artifacts and applications, the overall approach is quite general.

The high way of presentation of entities or activities and relations which enterprises needed for their higher success and the powerful descriptive and representation method because of their complexity needed more and more in our days. In this paper, an approach for Business Process Modelling (BPM) using Hypergraphs representation based on Finite State Machines (FSM) will be presented. The main goal motives this work is the using of hypergraphs as a flexible mathematical structure describing Information System (IS) from various viewpoints to express the best graphical way for Business Process (BP) The model proposed use FSM as an automated formal model by defining concepts and components of the hypergraph elements based on different FSM patterns (simple, complex) to get representations can be analyzed by either using more traditional tools as logic and inference rules or by a set of tools belonging to data science later.

Logic controller is a digital device used for automation of electromechanical processes, such as control of machinery on factory assembly line or lighting fixtures. This paper presents the method for designing a logic controller. We implement it using reprogrammable structure equipped with Embedded Memory Blocks, e.g. CPLD or FPGA. We find that specification of the controller with appropriate statechart diagram and further synthesis as equivalent Finite State Machine yields encouraging results: the number of programmable resources has been reduced approximately by 85%. Result of the research is illustrated with synthesis of practical controllers, where hardware resource consumption is presented. It shows the usefulness of the approach. 1

Dijkstra defined a distributed system to be self-stabilizing if, regardless of the initial state, the system is guaranteed to reach a legitimate (correct) state in a finite time. Even though the concept of selfstabilization received little attention when it was introduced, it has become one of the most popular fault tolerance approaches. On the other hand, graph algorithms form the basis of many network protocols. They are used in routing, clustering, multicasting and many other tasks. The objective of this paper is to survey the self-stabilizing algorithms for dominating and independent set problems, colorings, and matchings. These graph theoretic problems are well studied in the context of self-stabilization and a large number of algorithms have been proposed for them.

This paper studies the semantics of hierarchical finite state machines (FMS's) that are composed using various concurrency models, particularly dataflow, discrete-events, and synchronous/reactive modeling. It is argued that all three combinations are useful, and that the concurrency model can be selected independently of the decision to use hierarchical FSM's. In contrast, most formalisms that combine FSM's with concurrency models, such as Statecharts (and its variants) and hybrid systems, tightly integrate the FSM semantics with the concurrency semantics. An implementation that supports three combinations is described.

In this study we present a supervisory control system and implement it on a pneumatic system controlled by a PLC. We introduce a step-by-step implementation procedure including a realization methodology of finite state machines by PLCs. A hierarchical control structure is proposed and implemented. The pneumatic system control problem presented in this study is a typical logical Discrete Event System (DES) control problem, therefore it is easy to generalise the methodology for most of the DES control problems.

This paper shows how the behavior of a model described in the specification language proposed by the IEC 60848 standard can be represented, without semantics loss, in a formal manner, by a finite state machine (FSM) with logic inputs and outputs. This contribution is illustrated on a nontrivial example; this case study points out that the duration of the construction of the equivalent FSM complies with the requirements of designers of automation systems.

In this paper, we present a method for describing the syntax and semantics of viewcharts. Viewcharts is a visual formalism for describing the dynamic behavior of system components. We define the syntax of viewcharts as attributed graphs and, based on this graph, describe dynamic semantics of viewcharts by object mapping automata. This approach covers many important constructs of viewcharts, including hierarchy of views, ownership of elements, scope, and composition of views in SEPARATE, OR and AND ways. It also covers completion and interlevel transitions as well as history transitions without violating the independence of views. Viewcharts was originally based on statecharts; in this paper we also change the basis of viewcharts to an extended version of Finite State Machine (EFSM).

This paper discusses our approach and experiences on structuring and maintaining requirements for an evoting system we have built and deployed for elections. Issues related to integrating laws and recommendation for e-voting systems, managing different elections and configurations, supporting a spiral development, yielded problems and approaches to help maintain integrity of requirements and a coherent view of the system. Moreover, the relationship between requirements and system architecture is based on finite state machines, that bridge the gap between the laws and the actual behavior of the machine.

Although a lot of research has been done in the field of state-based testing, the automatic generation of test cases from a functional specification in the form of a state machine is not straightforward. This paper investigates the use of genetic algorithms in test data generation for the chosen paths in the state machine, so that the input parameters provided to the methods trigger the specified transitions.

This paper presents an automated method for the synthesis of multiple-input-change (MIC) asynchronous state machines. Asynchronous state machine design is subtle since, unlike synchronous synthesis, logic must be implemented without hazards, and state codes must be chosen carefully to avoid critical races. We formulate and solve an optimal hazard-free and critical race-free encoding problem for a class of MIC asynchronous state machines called burst-mode. Analogous to a paradigm successfully used for the optimal encoding of synchronous machines, the problem is formulated as an input encoding problem. Implementations are targeted to sum-of-product realizations. We believe this is the first general method for the optimal encoding of hazard-free MIC asynchronous state machines under a generalized fundamental mode of operation. Results indicate that improved solutions are produced, ranging up to 17% improvement.

SystemC is a system level language proposed to raise the abstraction level for embedded systems design and verification. In this paper, we propose to generate Finite State Machines (FSM) from SystemC designs using two algorithms originally proposed for the generation of FSM from Abstract State Machines (ASM). This proposal enables the integration of SystemC with existing tools for test case generation from FSM. Hence, enabling two important applications: (1) using the FSM graph structure to produce test suites allowing functional testing of SystemC designs; and (2) performing conformance testing, where the FSM serves as a precise model of the observable behavior of the system used to validate lower abstraction levels of the design (e.g., Register Transfer Level (RTL)).

This paper presents an abstract view of mutation analysis. Mutation was originally thought of as making changes to program source, but similar kinds of changes have been applied to other artifacts, including program specifications, XML, and input languages. This paper argues that mutation analysis is actually a way to modify any software artifact based on its syntactic description, and is in the same family of test generation methods that create inputs from syntactic descriptions. The essential characteristic of mutation is that a syntactic description such as a grammar is used to create tests. We call this abstract view grammar-based testing, and view it as an interface, which mutation analysis implements. This shift in view allows mutation to be defined in a general way, yielding three benefits. First, it provides a simpler way to understand mutation. Second, it makes it easier to develop future applications of mutation analysis, such as finite state machines and use case collaboration diagrams. The third benefit, which due to space limitations is not explored in this paper, is ensuring that existing techniques are complete according to the criteria defined here.

This paper proposes a general and systematic way to efficiently combine constrained codes with parity-check (PC) codes for optical recording. The proposed constrained PC code includes two component codes: the normal constrained (NC) code and the parity-related constrained (PRC) code. They are designed based on the same finite state machine (FSM). The code rates are only a few tenths below the theoretical maximum. The parity-check constraint is defined by the generator matrix (or generator polynomial) of a linear binary PC code, which can detect any type of dominant error events as well as error event combinations of the system. Two approaches are proposed to design the code in the non-return-to-zero-inverse (NRZI) format and the non-return-to-zero (NRZ) format, respectively. Designing the codes in NRZ format may reduce the number of parity bits required for error detection and simplify post-processing for error correction. Finally, examples of several newly designed codes and their performances are illustrated.

The development of test cases is an important issue for testing software, communication protocols and other reactive systems. A number of methods are known for the development of a test suite based on a formal specification given in the form of a finite state machine. Well-known methods are called the W, Wp, UIO, UIOv, DS, H and HIS test derivation methods. These methods have been extensively used by research community in the last years; however no proper comparison has been made between them. In this paper, we experiment with these methods to assess their complexity, applicability, completeness, fault detection capability, length and derivation time of their test suites. The experiments are conducted on randomly generated specifications and on a realistic protocol called the Simple Connection Protocol.

In the model-based development context, metamodel-based languages are increasingly being defined and adopted either for general purposes or for specific domains of interest. However, meta-languages such as the MOF (Meta Object Facility)—combined with the OCL (Object Constraint Language) for expressing constraints—used to specify metamodels focus on structural and static semantics but have no built-in support for specifying behavioral semantics. This paper introduces a formal semantic framework for the definition of the semantics of metamodel-based languages. Using metamodelling principles, we propose several techniques, some based on the translational approach while others based on the weaving approach, all showing how the Abstract State Machine formal method can be integrated with current metamodel engineering environments to endow language metamodels with precise and executable semantics. We exemplify the use of our semantic framework by applying the proposed techniques to the OMG metamodelling framework for the behaviour specification of the Finite State Machines provided in terms of a metamodel.