Automatic Program Generation Research Articles

Distributed measurement and control system based on microcontrollers with automatic program generation

The paper describes an open architecture microcontroller based distributed measurement and control system with automatic generation of application program. Interpretation of functions and generation of program for control of the newly added distributed unit or distributed unit of a new type connected to the system performs automatically, without user assistance. The elements of the system are interconnected by means of a serial common bus according to the reduced OSI protocol. The proposed concept was tested in a system developed by using 8-bit Atmel microcontrollers of 89S and 89C series. Apart from the central unit, intelligent distributed units were developed for the control of a stepper motor, programmable linear movement, control of halogen lamps, acquisition and generation of analogue, digital and timing pulses and a real time clock (RTC).

Towards Domain-Specific Formal Specification Languages for Railway Control Systems

Abstract The authors motivate and illustrate an approach for domain-specific specification languages in the field of small local railway or tramway control systems. Adopting terms and concepts from the application domain, such languages are the ideal means of communication between users, system engineers and control computer specialists. Semantic rigour is provided by a transformation of the domain-specific representation into wide-spectrum formal specification languages. These transformations offer the possibilities of formal verification and testing against formal specifications, as well as automatic generation of executable programs from specifications. The construction of the transformation can be substantially simplified if the class of control systems is formalised in a generic way using design patterns and frameworks.

Automatic PLC software generator with a natural interface

This paper presents an object-oriented textual language designed to specify programmable logic controller software. This methodology, called OOST, allows users to specify the control logic in a natural manner, using a collection of objects that represent machines and other devices within a manufacturing system. The object-oriented specification technique may be used during the whole control software life cycle, and could be considered as a requirement definition language or an implementation one. An automatic PLC program generation system that uses descriptions written in OOST is also presented. A brief literature review is presented and the implementation details are discussed. The final part presents some future improvements and a few remarks.

Borg: a knowledge-based system for automatic generation of image processing programs

This article deals with the design of a system that automates the generation of image processing applications. Users describe tasks to perform on images and the system constructs a specific plan, which, after being executed, should yield the desired results. Our approach to this problem belongs to a more general category of systems for the supervision of a library of operators. The generation of an application is considered as the dynamic building of chains of image processing through the selection, parameter tuning and scheduling of existing operators. To develop such a system, we suggest to use a knowledge-rich resolution model and to integrate seven design rules. The Borg system has been developed following these prescriptions. It hinges on hierarchical, opportunistic and incremental planning by means of knowledge sources of the blackboard model, which enable to take into account the planning, evaluation and knowledge acquisition issues.

ATPRG: an automatic test program generator using HDL-A for fault diagnosis of analog/mixed-signal integrated circuits

HDL-A is an analog version of the Hardware Description Language which is suitable for structural and behavioral descriptions and simulations of digital, analog, and mixed-signal circuits and systems. This paper presents an automatic test program generator (ATPRG) for fault diagnosis of analog/mixed-signal integrated circuits. The ATPRG is developed under the Mentor Graphics Design system environment, where the units under test (UUT's) are modeled in HDL-A and simulated by Accusim, and AMPLE (Advanced Multi-Purpose Language) in Mentor Graphics Design system environment is used to define and execute the generation process automatically. To increase the reliability and quality, the generated test programs will be verified and validated. A verification process checks if the test programs are generated correctly and if the generated test programs can effectively locate fault(s). The test programs are validated by emulating the UUT's. The actual test can be run in a fully automatic mode, or interactively.

ATESAT: A symbolic processor for artificial satellite theory

Analytical theories for the artificial satellite motion involve operations with the so called Poisson series. Even if only a second order theory is required, the amount of terms involved is so huge, that it is almost an impossible task to carry out by hand the theory. Thus, algebraic manipulators are essential in this field, and even more, since general purpose manipulators are not completely satisfactory, specific manipulators are necessary. Aware of this fact, we build ATESAT (Automatization of Theories and Ephemeris in the artificial Satellite problem), that provides the automatic generation of programs for computing the ephemeris of the satellite from the analytical theory chosen. ATESAT is built with PSPC, an algebraic manipulator from our own, especially designed for manipulating Poisson series.

An intelligent software system for the automatic generation of NC programs from wireframe models of 2-1/2D mechanical parts

The aim of this work is to generate automatically NC part programs for machined components of 2-1/2 dimensions starting from a wireframe CAD model. An IGES post-processor was developed to interface the system to any CAD system, then a conversion program sought to obtain solid modelling geometry from the wireframe model. Subsequently, drawing annotation information was allocated to solid model entities through pattern matching techniques in Prolog. The product model was completed by deriving feature instances according to pre-defined feature templates constructed in Prolog according to a simple model. Operation selection uses the feature model as well as process planning knowledge structured into a hierarchy of Prolog rules processed by a context sensitive inference engine. The resulting operation sequence is communicated to a module that calculates cutting conditions and produces NC code. The system was proved to work satisfactorily with components of an industrial standard.

Design Verification of Complex Microprocessors

As the complexity of microprocessors increases, functional verification becomes more difficult and emerges as the bottleneck of the design cycle. In this paper, we suggest a functional verification methodology, especially for compatible microprocessor designs. To guarantee perfect compatibility with previous microprocessors, we developed three C models in different abstraction levels, i.e. Polaris, MCV and StreC. An instruction behavioral level C model (Polaris) is verified using the slowed-down PC. In the implemetation of micro-architecture, a micro-operational level model (MCV) and RTL model (StreC) are co-simulated with consistency checking between these two models. The simulation speed of C models makes it possible to test the "real-world" application programs on the RTL design with a software board model (VPC). To increase the confidence level of verifications, Profiler reports the verification coverage of the test program, which is fed-back to the automatic test program generator (Pandora). The Restartability feature also helps to significantly reduce the total simulation time. Using the proposed verification methodology, we designed and verified the HK486, an Intel 80486 pin-compatible microprocessor successfully.

Model-based automatic generation of sequence-control programs from design information

Sequence control is an important part of the control software in mechatronics machines. A new model-based technique automatically generates sequence-control programs by integrating various kinds of design information.

Automatic Program Generator for Customized Fuzzy Logic Controllers

The generator includes several tools that allows to translate the initial problem specification to a specific circuit implementation. From the rule based specification the generator produces a first computing scheme. By applying various transformations (lattice and arithmetic operation minimization, optimal register assignation, ...) the system produces the microprogram that drives the controller. For this purpose, the VHDL language is used to simulate the hardware controller, and the ES2 design kit is used to design the circuits to be integrated.

Automatic generation of intelligent agent programs

One cause for excitement about agent oriented AI is the belief that it is easier to write programs for many narrow, autonomous systems than for fewer, broader, user-driven systems. A related cause for excitement is the primary message of these comments: it is also easier to automatically generate agent programs. The artificial life, machine learning, and automatic programming literature already describes many experiments in which systems with agent-like properties have been automatically generated. Although most of the previously generated systems have been too simple to perform helpful tasks for actual users, recent advances suggest that useful intelligent agents will soon be within reach of these techniques. The paper focuses on one particular technology, genetic programming, but related points should apply to other automatic programming technologies.

An introduction to partial evaluation

Partial evaluation provides a unifying paradigm for a broad spectrum of work in program optimization compiling interpretation and the generation of automatic program generators [Bjørner et al. 1987; Ershov 1992; and Jones et al. 1993]. It is a program optimization technique, perhaps better called program specialization , closely related to but different from Jørring and Scherlis' staging transformations [1986]. It emphasizes, in comparison with Burstall and Darlington [1977] and Jørring and Scherlis [1986] and other program transformation work, full automation and the generation of program generators as well as transforming single programs. Much partial evaluation work to date has concerned automatic compiler generation from an interpretive definition of programming language, but it also has important applications to scientific computing, logic programming, metaprogramming, and expert systems; some pointers are given later.

Automatic generation of prime length FFT programs

Describes a set of programs for circular convolution and prime length fast Fourier transforms (FFTs) that are relatively short, possess great structure, share many computational procedures, and cover a large variety of lengths. The programs make clear the structure of the algorithms and clearly enumerate independent computational branches that can be performed in parallel. Moreover, each of these independent operations is made up of a sequence of suboperations that can be implemented as vector/parallel operations. This is in contrast with previously existing programs for prime length FFTs: They consist of straight line code, no code is shared between them, and they cannot be easily adapted for vector/parallel implementations. The authors have also developed a program that automatically generates these programs for prime length FTTs. This code-generating program requires information only about a set of modules for computing cyclotomic convolutions.

SPROUT—A Modeling Language for SEED

An important capability of the SEED system is rapid generation of internal design representations, including design alternatives, that can be evaluated in terms of a broad range of criteria. It consists of modules that must communicate with each other and remain extensible. From a software engineering perspective, there exists no single programming language or database management system, commercial or research-based, that provides all the needed support. In this paper, we describe the SPROUT modeling language, the cornerstone of efforts to bridge this gap. It supports the specification of a system information model, which contains a building product model as a subset. Developments are discussed that lead to the current language design as well as the support for case-based design, persistent storage of objects, management of versions and alternatives, and communication between different SEED modules (i.e., agents). Emphasis is placed on the automatic generation of computer programs and database schemas from a SPROUT specification. Lastly, this effort is compared to other comparable efforts including PDES/STEP.

Automatic generation of parallel programs for mimd computer systems

The use of linear-time automatic algorithms for sequential program parallelization substantially expands the scope of MCS. Parallel implementation is justified from time considerations even when the application program is executed only a few times without modification (only once when the macrooperation system is introduced), i.e., for frequently reprogrammed jobs.

Planning multiple observations for object recognition

Most computer vision systems perform object recognition on the basis of the features extracted from a single image of the object. The problem with this approach is that it implicitly assumes that the available features are sufficient to determine the identity and pose of the object uniquely. If this assumption is not met, then the feature set is insufficient, and ambiguity results. Consequently, much research in computer vision has gone toward finding sets of features that are sufficient for specific tasks, with the result that each system has its own associated set of features. A single, general feature set would be desirable. However, research in automatic generation of object recognition programs has demonstrated that predetermined, fixed feature sets are often incapable of providing enough information to unambiguously determine either object identity or pose. One approach to overcoming the inadequacy of any feature set is to utilize multiple sensor observations obtained from different viewpoints, and combine them with knowledge of the 3-D structure of the object to perform unambiguous object recognition. This article presents initial results toward performing object recognition by using multiple observations to resolve ambiguities. Starting from the premise that sensor motions should be planned in advance, the difficulties involved in planning with ambiguous information are discussed. A representation for planning that combines geometric information with viewpoint uncertainty is presented. A sensor planner utilizing the representation was implemented, and the results of pose-determination experiments performed with the planner are discussed.

Integrated Test Solutions for a System Design Environment

While the performance, density, and complexity of application-specific systems increase at a rapid pace, equivalent advances are not being made in making them more easily testable, diagnosable, and maintainable. Even though testability bus standards, like JTAG Boundary Scan, have been developed to help eliminate these costs, there exists a need for efficient hardware and software tools to support them. Hence, a testability design and hardware support environment for application-specific systems is described which provides a designer with a set of hardware modules and circuitry, that support these standards and software tools for automatic incorporation of testability hardware, as well as automatic test vector and test program generation.

Techniques for automatic part program generation

This paper describes an automatic part program generator which is a part of a feature-based process planning system. The goal of the described system is to generate automatically reliable NC code from sequenced process plans. Process plans are generated and sequenced by the feature-based process planning system. The part program generator can be tailored by associating parametric part program definitions to the primitive processes of the system, work-elements, which are related to classes of features. These parametric part program definitions are filtered through a code generation algorithm, which produces segments of part program code with relevant coordinate and nominal values. Work-elements are organized as an inheritance hierarchy to enable sharing of common instructions such as tool changes and pallet rotations, and to enable the description of different cutting parameters for tools with different cutting edge materials for which the tool path to be generated remains the same. Generated code segments are glued together to form a complete part or pallet program for part family members. The part program can be interpreted and the tool path visualized either as a whole, work-element by work-element, or instruction by instruction. Visualization provides a fast and relatively reliable test of the correctness of the generated code.

An integrated simulation model development environment for SLAM II using object-oriented paradigm

An integrated simulation model development environment was implemented to assist the modeler by automating certain activities of simulation modeling. The system included interactive model definition, experimental design, automatic simulation program generation in SLAM II. Object-oriented paradigm at software development stage was extensively used to conceptualize the structure, and rules of the SLAM II language in order to generate efficient, and modular program code. The present system targeted modeling of various probabilistic inventory control system problems. The remarkable advantages of the system were rapid model development time, and achieving reliable program code without requiring any knowledge in SLAM II. Object-oriented programming was very promising, and effective programming paradigm in system development cycle. At the final stage, response surface methodlogy (RSM) in conjunction with the steepest-ascent method was used to find the optimum inventory policy minimizing the average cost per unit of time based on simulation output. Comparing RSM results to those of the deterministic relaxation of the probabilistic inventory model demonstrated that RSM could be an efficient tool for optimization in simulation.

Automatic generation of 2-axis laser-cutter NC machine program and path planning from CAD

A cutter path planning algorithm is developed as part of a procedure for the automatic generation of NC machine programs beginning with a part description within a CAD system. This procedure is implemented in the form of a simple and functional CAD to 2-axis numerical control programming interface. The method begins by extracting entity information from a machine-independent geometry data file and creates a tool path with the proper sequence and directions of cut for internal and external part contours. A generic NC program is created which acts as an input file to a postprocessor creating G-Code output for specific machine controls. In this paper, a laser-cutting machine is used as a test bed for the programs generated by this procedure.