Philip
Sargent
Cambridge University, Engineering Department,
Trumpington Street, CB2 1PZ
CUED/E-MANUF./TR.2 June 1993
Published as Sargent, P.M., Inherently Flexible Cell Communications: a review, Computer Integrated Manufacturing Systems, 6 (4) 244-259, Nov. 1993
The first generations of flexible manufacturing systems (FMS) are flexible only with respect to implicitly predefined types of parts and assemblies: determined by the machines and software comprising the FMS. A more radical form of flexibility is the ability to be readily adapted to produce unforseen product types. It is this inherent flexibility which is becoming a primary, rather than a secondary, requirement of new manufacturing systems architectures. The burden of this flexibility falls almost entirely on software which is the glue that defines what machines constitute and FMS and how they work together. This paper reviews current computer science research which addresses these issues.
This paper explores the issue of devising programs and architectures that support their own replacement within the real-time, heterogeneous factory environment. Formal computable specifications for reconfiguration have been proposed as a way of producing flexibility but this paper argues that self-referential systems based on independently communicating agents are both more flexible and more acceptable in practice. Requirements for long-term, inherent flexibility are shown to share more features with fault-tolerance and error recovery needs than with short-term flexibility. Five partial, complementary solutions are suggested which together should improve the inherent flexibility of future software systems: (1) global information services, (2) high-level standardization such that only the standards actually needed are generated, (3) distributed agent heterarchical architectures, (4) dynamic updating of configuration-oriented software, and (5) computational reflection.
Inherently flexible software is a major goal for developers of manufacturing automation but current offerings fall far short of what is desired. Flexibility of machining centres and cells has now reached such a level that it is often the inflexibility of the software, not the machines, which inhibits a fast response to market demands [Schofield, 1992]. Here we are referring to long-term reconfigurability, which too often is sacrificed for the sake of short-term product-mix flexibility achieved through the use of hard-to-modify complex scheduling and dispatching software [Upton, 1992].
This paper takes the view that the most significant problem now in cell control is the management of the flow of information and not the scheduling of the flow of work [Ranky, 1990b; Warnecke, 1991]. This is a distinct change from the late 1980s when workflow was seen as the critical factor [Rogers and Williams, 1988], although this is not to say that scheduling is a solved problem [Parunak, 1991]. It has been estimated that seven-eighths of the workforce of general manufacturing companies handle information rather than product [Groover, 1987]. A current European Community initiative (ESPRIT’s "domain 5") identifies four software areas for special attention for manufacturing systems:
but none of these address the problem of software flexibility which has yet to be generally recognized as a modern significant problem.
The large number of fundamentally different approaches to computer integrated manufacturing (CIM) implementation has arisen because vendors have usually taken a working package which manages some part of the problem and then incrementally extended that specific package’s range of services. Major categories of viewpoint are those which have grown "up" from programmable logic controllers (PLC) [McLagan, 1992], "down" from computer aided production management (CAPM) [Sargent, 1992] or CAD/CAPP [Harhalakis, et al., 1990; Kim and Tokawa, 1989], or "sideways" from, for example, accountancy or discrete event simulation [Browne and Timon, 1991]. All these viewpoints eventually have to meet in the issue of manufacturing cell communication.
Manufacturing cells
Automated cell level management in manufacturing covers a multitude of problems and abstractions. What is meant by "cell level" is currently defined by exclusion: everything that is "between shop floor devices and the plant/area control system"[Franks, Loftus and Wood, 1990; Loftus and Robson, 1989] and there is a multiplicity of fundamentally different approaches taken by vendors. This paper surveys some requirements of cell-level management, describes which functions can usefully migrate "up", "down" or "sideways" to non-cell software systems, and takes the approach that the need to integrate alien software systems into existing cells is fundamental.
One conclusion is general: cell management systems contain both a real-time fast-response coordination-control subsystem and a more leisurely high-level management response subsystem: "on the cusp of real-time control and transaction management" [Laduzinsky, 1990]. Therein lies the major complexity: the cheapest hardware to perform these functions nearly invariably consists of two computer subsystems running different operating systems, communicating at quite different levels of abstraction [Bihari and Gopinath, 1992]. Spanning these levels is hard and the software to do this well is expensive, even when the computers share the same backplane (e.g. Allan-Bradley’s VAX-PLC/250 or B&R’s Maestro) or where they are really the same real-time computer (e.g. Fastech’s CELLworks on QNX). This software is not only expensive and slow to produce, the systems produced are also particularly difficult to reconfigure [Williams, Rogers and Upton, 1986]. Consequently, in order to reduce software costs, implementors have to make do with a degree of functionality that is less than ideal.
This paper will show that the real-time versus management split is not, in fact, the most important distinction in cell control. The distinctions between different levels and styles of ontological commitment are instead the major determiners of major, long-term costs [Efstathiou, 1988; Gruber, Tenenbaum and Weber, 1992; Williams, West and Hinde, 1991].
FMS reconfiguration
In FMS software there is a trade-off between cost and generality. Writing highly flexible software – which makes very few implicit assumptions about the systems on which it will run or the parts which it will make – is always possible; but it takes longer and costs more for no immediate benefit. Since some software always needs replacing whenever machines are added or replaced, it makes better commercial sense to purchase somewhat less general programs initially and to buy only the new functionality actually required. This presupposes, however, that reconfiguring the existing software (which is not to be replaced) is possible at all.
The Cell Management Language (CML) system takes replacement and upgrading as fundamental and uses table-based grammars to define new capabilities in the form of new mini-languages [Bourne, 1986], whereas most approaches lean towards standardization of architectures, concepts and messages as the solution. Inevitably, more modern attempts at standardization become more abstract and implementations increasingly resemble CML in practice.
It is impossible to forsee all possible new requirements that an organization might wish to place on an FMS. Thus there will always be a need for software and machine upgrades (sometimes reflecting new versions of standards). The cost of writing new software for obsolete hardware is such that wholesale replacement of the complete software system for an existing FMS is unlikely to be cheaper than buying an entire new system including new machines. Hence the focus on inherently flexible software systems where it is not assumed that all future flexibility needs in product design or operating conditions can be "designed in" from the beginning but that replacement will be an expected and necessary operation.
Commercial simulation systems are always more general than actual implementations of FMS software but once a specific simulation model of an actual FMS has been implemented, there exists the problem of keeping the simulation and the reality in step when upgrades are made to the FMS. In the future it will make less and less sense to use entirely independent software systems for simulation and implementation.
Software development
The returns to scale which apply to packaged software in the spreadsheet and word processor markets do not apply to cell management because (a) there are orders of magnitude fewer cells than typists and managers, because (b) cells are always unique and require regular reconfiguration incorporating alien machine tools, and because (c) cell systems are not properly designed as inherently flexible software systems. Costs are therefore high [Bititci and Large, 1989]. However, as side effects of the packaged software market, there now exist much better methods for:
(a) designing human user interfaces which make complex reconfiguration more manageable,
(b) writing software that is modular, reconfigurable and fast (object oriented techniques among others),
(c) translating high-level specifications directly into executable programs (compiler technology and computer-aided software engineering aided by reflective computation [Kiczales, 1992]).
Business personal computing is now driving development of better techniques for:
(d) self-configuring local-area networks (such as AppleTalk®),
(e) high-level device-driver specifications to ease the addition of new hardware to new micro-kernel operating systems [Udell, 1992]
(f) remote equipment monitoring and reporting standards such as Simple Network Management Protocol (SNMP) and ISO’s Communication Management Information Prototcol (CMIP)
Similarly, computer science research is now devising better methods for:
(f) transferring single-threaded programs to run automatically on multiple, distributed computers
g) devising different types of abstraction and reflection to cope with large-scale software reconfiguration, updating and replacement [Dourish, 1992a; Garlan, Kaiser and Notkin, 1992; Kiczales, 1992; Kiczales, des Rivières and Bobrow, 1991; Segal and Frieder, 1993]
and software engineering technologists have been
h) developing "enterprise integration" information models and methodologies to capture human organizational needs in formal language [Petrie Jnr., 1992a]
All these developments are proceeding independently of effort spent in cell control and manufacturing system networking [Ranky, 1990a] and with orders of magnitude more resources allocated to them. It is important that cell control development should not be too short-sighted by focussing on todays’ problems which may therefore be ephemeral [Carrie, 1989]. It is quite possible that SNMP and the new device driver technology available with Microsoft’s Windows NT operating system may be able to fulfill all the non-time-critical monitoring and configuration functions that a cell control system needs for its attached equipment. This would also operate at a much more understandable high level, e.g. directly in terms of equipment utilisation rather than as a series of timer and counter values [Bititci and Large, 1989], but could still be fast enough if reflective systems were used [Kiczales, 1992]. Commercial software such as PowerFrame (a configuration manager from Digital Corp.) and IBM’s distributed automation edition (DAE) can now provide significant proportions of an entire CIM system [Gay, 1993].
Low level communication can already be achieved in terms of trigger/control/monitor blocks in the cell controller and program/control blocks in all its attached equipment [Bititci and Patel, 1989] but this requires that all software be written from scratch for each cell and for each item of equipment. Such modularization into standard functional blocks makes writing the software easier than it would otherwise be, but the long term future must be for automation of such low level communication and specification of needs at a higher level of abstraction.
The weakest point of all the approaches to providing flexibility in CIM architectures is that of reconfiguration and extension to absorb new equipment necessary to make entirely new products. The proportion of the system that needs to be reconfigured on such changes is a property of the architecture itself.
Control architectures, whether hierachical or heterarchical, have to reconcile a variety of different goals and planning horizons, from months down to minutes, and a variety of response times, from minutes to milliseconds [Jones and Saleh, 1990; Williams, West and Hinde, 1991]. What is not often realized is that there is a similar time horizon in the time between software reconfigurations, though here the times are shortest in the middle levels, not at the more abstract or more detailed extremes. The ISO shop floor production model (SFPM) defines 4 levels: section/area, cell, station and equipment [Messina and Tricomi, 1990] and this is usually extended to six levels by adding two more: facility and enterprise [Graefe and Thomson, 1989; Harhalakis, et al., 1990]. The Purdue University model defines 5 levels: company, plant management, area coordination, cell (DNC) and workstation (CNC) with each task expressable in 11 representation layers [CIM Reference Model Committee, 1989]. Fisher Controls’ PROVOX system also defines 5 levels, but defined differently [Shaw, 1991].
Figure 1 Control sophistication levels, both for a CIM architecture as a whole and potentially for each component level (from [Chacón and Santiago, 1992; Rogers and Williams, 1988])
Information classification
Achitectural classifications are the key to devising flexible software update and replacement policies and to devising flexible communication protocols.
Since there are no standards for the information modelling necessary for cell management, different companies classify the information entities differently. Thus in one company a product recipe might be part of a cell-level system whereas in another it might reside on the MRPII database and be consulted by the cell controller [McLagan, 1992]. This taxonomic uncertainty is the real issue in cell level management. Unless there is agreement on which types of information belong to which classifications (ontologies), it is impossible to actually use any messaging standard or software module replacement policy because other systems may have made different ontological commitments. For example, MRPII and CIM have developed from different starting points, but they form a continuum in reality [Harhalakis, et al., 1990; Ranky, 1990b], so at the area of overlap there are entities which are viewed and classified in two different ways. This communication and module update problem also occurs if two different parts of a plant have had software systems installed where different numbers of system layers have been committed to in the two parts (which is an argument for standardizing layer types and numbers and not permitting the implementor to have a free decision, as suggested by Jones and Saleh [1990]).
Responsive versus reasoning levels
A fundamental semantic divide exists between the purely responsive lower levels and the upper levels – which have to reason explicitly about temporal knowledge, precendence and simultaneity [Bihari and Gopinath, 1992; Parthasarathy and Kim, 1989]. One solution for devising communication protocols is to define them only at the "meta-CIM" level, where a higher level, uniform semantic structure can be shared by sophisticated independent software systems [Glicksman, et al., 1991; Pan, Tenenbaum and Glicksman, 1989]. This works, but it has not found favour with most CIM implementors probably because the principles are harder to comprehend because of the extra abstraction. It also means that software replacement can only occur at the granularity of an entire independent software system spanning both levels. An alternative is to accept the conceptual gulf between responsive and reasoning levels (which do in reality form a natural interface at which it would be sensible to divide software modules [Garlan, Kaiser and Notkin, 1992; Segal and Frieder, 1993]), and to use negotiation methods to resolve conflicting decisions across two levels [Jones and Saleh, 1990; Petrie Jnr., 1992b].
Systems specification and integration
Systems integration on the basis of a formal specification is thus far more than the simple translation service it "should" be . There are two basic approaches to solving this: the formal ("neat") and the informal ("scruffy"): all real approaches are a combination of the two. This type of difference in the style of concept representation has been previously suggested [Chryssolouris and Gruenig, 1988]. but only in the context of managing the distinction between database systems (driven by SQL/fortran) and decision-making functions (written in LISP). Even extensive studies of distributed information handling have used a single data modelling schem with uniform ontological committment from top to bottom of the system [Krishnamurthy, et al., 1987; Libes and Barkmeyer, 1988; Vernadat, 1992].
When discussing systems integration, it is important to realise that there are two types of standard which should not be confused:
An example of the first type is the approved list of geometric entities (points, curves, circles etc.) permitted in IGES CAD files. An example of the second type is the Express language defined as part of the STEP standard (ISO 10303) which can be used to define points, curves, circles etc.
Formal classification
The "neat" method is to decide generic information classifications, embody them in a working code or standard, and set up an institutional mechanism based on hierarchical and/or democractic human organizations for updating the code and for issuing authorative guidelines for its use. This is the general approach used by the world’s telecommunication authorities for telephone signalling, and in the STEP (ISO 10303) product modelling standard. The syntax of such representations is completely sufficient to indicate the meaning because it has been defined in detail in a standard.
Informal classification
The "scruffy" method is to throw all the information into a "bit bucket" and rely on real-time interpretation, by software-aided human beings or entirely automatically, to determine what any message means; or fast, intelligent searching to find any required information irrespective of where it has been stored. This is the approach taken by full-text database retrieval systems and by people when negotiating contracts. The meaning of such representations has to be grasped directly, the syntax gives only partial guidance but this can often be enough to get started [Petrie Jnr., 1992b].
Clearly manufacturing systems lean far more towards the "neat" than the "scruffy" school as regards the actual operation of plant. This is for speed as much as anything else. But when one is considering the design of a cell system, then more freedom is appropriate: standards could artificially define what information is "cell" level and what is "device" level, but this type of classification would be more useful in guidelines than as standards. Also as one progresses up the architectural functions from direct response to learning (Figure 1), it becomes less possible to rely on rigorous classification and more necessary to interpret meanings directly. This fundamental change in style of information management is harder to deal with – often because it is not recognized – than the change between fast, real-time and slower database update functions within cell management.
Self-defining classification
One of the positions on the spectrum between "neat" and "scruffy" is that taken by the ISO standards SGML (Standard Generalized Markup Language), for formatted text-graphic information, and IRDS (Information Resource Dictionary System) for CASE tool definition. In both these cases the philosophical viewpoint is to let the information be expressed, defined or classified completely freely; but then a formal description of how it is formatted and what the classification used actually "means" is attached. The IRDS model would appear to be particularly appropriate for manufacturing system information modelling, and it has already been adapted for engineering materials database specification [Sargent, 1990; Sargent, 1991].
These types of classification "classifications" are one level more abstract than any individual classification but that does not mean that devising them is easier: they have to directly embody certain constraints so that classifications defined using them make sense. These constraints come directly from the fundamental nature of the information being described so deriving them is a task for manufacturing engineers, not computer scientists. Commitments made in deriving self-defining classification systems cannot be overcome later, so ontological over-commitment, leading to inflexible and inexpressive software systems, is the major danger.
In defining behaviour, which is usually the primary aspect of manufacturing systems software, it is not necessary always to use traditional imperative (operational) programming techniques as exemplified by languages such as Basic, Pascal, C++, Lisp etc. Programs written in this style are known to be particularly difficult to reconfigure and reprogram. The more declarative and the less imperative, the easier it is to identify what has to be changed and the less likely it is that side-effects will cause unwanted changes. Functional, synchronous, asynchronous, transformational, form-based, dataflow, logic-based, constraint-based and demonstrational paradigms all have advantages in this respect [Ambler, Burnett and Zimmerman, 1992]. Examples of languages embodying these principles are ML, Actus, Linda, Bertrand, Plane-Lucid, Show-and-Tell, Prolog,ThingLab and MetaMouse respectively. These all have mathematical properties which are better defined than the imperative languages and which (a) facilitate the use of very high levels of abstraction, (b) improve the organization of very large programs, (c) aid the verification of programs from specifications and (d) permits easier use of parallel-processing computers.
Imperative languages produce code which is faster to execute for simple problems on simple computers, but this kind of speed is becoming less relevant as hardware prices drop and as we wish to perform more complex operations with controlled flexibility. In any case, modern compiler technology can now produce optimised executable code from Lisp which is faster than that produced from Fortran [Abelson, et al., 1989] and metalevel interfaces can improve the performance of specific implementations in a clean manner [Kiczales, 1992].
Computational reflection
If stand-alone automated cells are to be integrated they must have increased intelligence about their own state. This again can push the information handling towards the more flexible "scruffy" approach, a tendency which manufacturing engineers unfortunately find hard to deal with since it requires a more abstract computational training. However such systems scale up much more easily when the size of the system as a whole increases, and have much better flexibility with respect to both reconfiguration and error recovery [Upton, 1992].
This intelligence about their own state is not the same as conventional artificial intelligence (AI) technology. Although rule-based manufacturing software systems are well known, they are often used merely as syntactically sweetened state-tables or finite-state machines [Ranky, 1988] and fuzzy control approaches are "really" purely deterministic, complex state-tables in an easy to understand form. Conventional AI is usually used so that software systems are declaratively-based rather than procedurally-based; as an aid to manual upgrading and maintenance. Using knowledge-based systems in a truly flexible, self-referential way is much harder to come to grips with. (Recently, however, some AI systems have been devised for constructing CIM software [Rao and Luxhoj, 1991].)
Recent computer science research in computational reflection tackles head-on the issue of systems representing explicitly their own state and behaviour which also embody a two-way link in that changes to that representation directly change the system behaviour [Kiczales, des Rivières and Bobrow, 1991]. One way of providing such capability is for each program module to provide two interfaces to client programs: a traditional function-call interface and a metalevel interface which is used to customize the underlying implementation; manipulating aspects which traditionally would remain hidden [Kiczales, 1992].
Dourish [1992a] proposes that reflective software design is an organizing principle to understand, and a coherent framework to manage, three different types of flexibility:
Inherently flexible CIM software requires all three type of flexibility especially the third type where the behaviour changes; which is less well understood in the reflective software community [Dourish, 1992b]. If the software, cogniscent of its own condition, sends commands to its own metalevel interface then it will change its own behaviour in a controlled and manageable manner. The types of behaviour changes feasible have to be pre-designed of course (by people).
Dynamic flexibility has a great deal in common with fault tolerance and error recovery which also require behaviour change without stopping a running program. More important, perhaps, is the strong possibility that in the future it would physically not be possible to stop all the hardware running components of a distributed program. This is already the case for some organizations’ "local" area networks which are gatewayed to span continents. Note that dynamic flexibility is more than dynamic linking (as made popular by Microsoft’s Windows operating systems and IBM’s OS/2) since the internal state of a program has to be preserved during updating. Such systems have already been developed for in the laboratories of telecommnications software producers [Segal and Frieder, 1993] and applying them to CIM is merely a matter of time and effort.
Complexity control versus integration ease
More than 23 manufacturing system architectures have been proposed [Bakker, 1988; Bititci and Patel, 1989; Chryssolouris and Gruenig, 1988; CIM Reference Model Committee, 1989; Franks, Loftus and Wood, 1990; Glicksman, et al., 1991; Hinde, West and Williams, 1989; Jones, Barkmeyer and Davis, 1989; Joryz and Vernadat, 1990a; Kehoe and Little, 1991; Krishnamurthy, et al., 1987; Libes and Barkmeyer, 1988; Meyer, Isenberg and Hübner, 1988; Moss, 1989; Nof, 1992; Pan, Tenenbaum and Glicksman, 1989; Weston, et al., 1989]. Most propose a pure hierarchy, modified hierarchy or a network of overlapping hierarchies, of control and data transfer [Dilts, Boyd and Whorms, 1991]. This includes almost all systems currently in use [Patankar, 1991]. At the lower levels of such systems, at the device and equipment level, this is sensible because the cost of any kind of network attachment (a serial line) means that a single connection is all that can be afforded. This directly implies hierarchical control at the lowest levels.
Hierarchies control complexity by partitioning: if any entity becomes too complex, it can itself be split into a hierarchy (in an ideal situation) [Joshi and Smith, 1992]; but there is a limit. At fine enough detail, the interactions between the components within a layer become too intricate to permit further layering [Shaw, 1991]. Unfortunately the complexity is also determined by the specific functionality of a specific plant or cell, so an ideal hierarchy is entirely non-standard compared with any other plant. Conversely, an ideally standardized hierarchy (for example, as is seen in the CIMOSA architecture [Klittich, 1990; Vernadat, 1992]), is nearly always overcomplex everywhere since every entity has have a structure able to cope with the maximum complexity any entity in its level is ever likely to see. Whenever insoluble trade-offs such as this arise in technical systems it is a clear indication that something is wrong with the whole approach.
In this paper five partial, but complementary solutions are suggested which together should improve the inherent flexibility of future CIM software systems and help manage the unavoidable complexity:
Heterarchical architectures
Traditional hierarchical or multi-hierarchical FMS architectures as described above thus have many systemic problems with respect to flexibility, reconfiguration and software production which get worse as the size of the system increases. Upton’s heterarchical architecture [1992] dramatically alleviates the scaling problems and improves both long and short-term flexibility by making a significant fraction of the coordination software entirely unecessary. It does this by increasing the level of intelligence of individual machines and part-carriers such that they can negotiate directly about turnaround times and routing. This means that a great deal of complex software which in a traditional architecture would manage coordination, control and fault recovery [Jones and Saleh, 1990; Joshi and Smith, 1992; Teng and Black, 1990] becomes entirely implicit in the physical movement of large numbers of parts [Hatvany, 1985].
Figure 2 A part transmits processing requests to a number of machines which bid for its servicing (from [Upton, 1992]).
Since the organization of the system is so "loose", every part-carrier and machine could be running a different software version so long as the communication protocols were unchanged or strictly compatible.
Clearly heterarchical architectures have significant advantages in that they are inherently flexible and writing flexible software for them is also easier (though updating new communication protocols needs to be done carefully). However only a proportion of a plant can be constructed in this distributed fashion and the stochastic nature of the response of the system can be a problem with very valuable or dangerous work in progress. Thus even in a largely heterarchical system there will be "islands of hierarchy", the heterarchical shop-floor will be an element of a plant-wide hierarchy (or at least a "static" rather than "dynamic" architecture [Shaw, 1991]), and these will require the other methods described in this paper to improve their long-term flexibility.
In large distributed networks of multiple computers the only knowledge that independent software processes have of each other is that which is transmitted using communications protocols over that network since it is impractical to shut down the entire system simultaneously. Thus the ontological committments built into these protocols are a critical issue because they determine what kinds of messages, and thus what kind of knowledge, can be sent. Flexibility requires that information regarding the type and version of a protocol be encoded directly and explicitly so that new and old versions can coexist over the time that it takes for updates to be performed [Segal and Frieder, 1993].
Current protocol standards
The existing MMS (manufacturing message service) as defined by MAP (manufacturing automation protocol) may be adequate [Laduzinsky, 1992; Messina and Tricomi, 1990], or entirely new OSI message services for low level equipment may be necessary [Chacón and Santiago, 1992] for future cell communication systems. Alternatively Fieldbus (a family of standards under development which includes FIP and Profibus) [Furness, 1992a; Furness, 1992b] or the new miniMAP incorporating the Japanese FAIS (factory automation and interconnection system) may dominate the equipment connection protocols leaving OSI (open systems integration) and full-MAP protocols unused [Anon., 1992a]. The future in this area is not academically determined by technical issues since there is distinct merit in using accepted standards irrespective of their technical capability (within reason) [Weston, et al., 1988].
The communications standards most appropriate for constructing interoperating cell-level systems are particularly problematic precisely because cell systems span the management versus real-time control divide; and protocols based on quite different principles have been devised for these two uses. The manufacturing message service (MMS), although defined by MAP, is not restricted to using MAP’s lower level protocols and it’s logical functions can run just as well over ethernet (or perhaps even a serial line using SLIP: serial line internet protocol). The important abstraction that MMS brings is the Virtual Manufacturing Device (VMD) which can be used to set up a table of variables defining and describing the manufacturing process in a format which can be interrogated and updated by any other MMS-complient system [Ward, 1992]. (This is almost identical to the Management Information Base (MIB) tables of variables maintained by SNMP-compliant devices such as network gateways, bridges and routers [Sidhu, Andrews and Oppenheime, 1991].)
MMS also can be set up so that as well as maintaining a readable information base at any machine which is polled by a higher-level system, that low-level machine can also send unsolicited messages; as might be required for emergency conditions. As well as delivering messages, MMS can also trigger programs to run and thus devices to begin operation.
All these capabilities for MMS can be seen to be appropriate and useful for real-time control of low-level devices, so the fact that MMS is defined at the top of the protocol stack should not mislead one into thinking that MMS is appropriate only for high-level devices in a manufacturing system: quite the reverse.
Capabilities at each layer
One cause of the difficulty of standardizing cell-level operations and information is the constant tension between simplicity and overdesign. The simplest solution would be for every individual sensor and actuator to be fully MAP-complient, incorporating fully-capable intelligent communication and storage functions. Such a system would, of course, be hopelessly expensive because it would be overdesigned.
In the real-time segment alone it would be possible to devise half a dozen layers of increasing hardware and software sophistication so that every piece of equipment had exactly the information processing capability it needed and no more [Rembold and Levi, 1988]. But the complexity cost (as seen in software development and maintenance) and translation overhead (in response time) means that this other "ideal" extreme is also unworkable.
If there were an obvious "happy medium" between these extremes then devising cell architecture and protocol solutions would be easy, but the position of the optimum balance is very sensitive to the details of the process being managed and especially sensitive to previous committments made in factory cabling and automation. The "correct" solution is therefore contingent and not absolute. Two conclusions follow: first, there is a distinct limit in the detail to which it is worth devising master CIM architectures (many would say that academic architectures have already far outstripped any likely industrial implementation in terms of sophistication, e.g. [Joshi and Smith, 1992; Kim, 1989]) and second, real plant will always be using information processing techniques which are to some degree inappropriate to the task in hand. This can be alleviated but not eliminated by whatever degree of flexibility is built in to the protocols used.
The long term trend is towards greater capability being built into the simplest equipment, driven by the decreasing costs of silicon and optical components and the continuous development of more robust, formal protocols which can be compiled into that silicon. Any "generic" factory control architecture will therefore have a limited life during which it is applicable (less than six years probably, given the rate of silicon development), and specific plant will eventually require CIM protocol replacement more frequently than the replacement of actual machines. New protocols will therefore need to be capable of being incrementally upgraded so that the confusion of the type that occurred between MAP 1.0 and 2.1 will not be a constant irritation. Flexibility on upgrading and reconfigurability is a property of both the individual updateable protocols [Segal and Frieder, 1993] and the enclosing architecture. Inherently flexible, "scruffy" architectures will make this easier [Upton, 1992] but so will very capable cell control software based on sound mathematics and able to adapt its behaviour from fundamental principles [Teng and Black, 1992]. Together, Upton-style architectures and dynamically updateable protocols solve the problem which separately they only alleviate.
Figure 3 Generic functions applicable at any level in a hierarchy, or an any entity in a heterarchy (after [Jones and Saleh, 1990; Joshi and Smith, 1992])
The most important determining factor of overall cell protocols is the minimum capability built into the lowest level, the simplest item of equipment, e.g. sensors. These are (a) very numerous, and so are resistant to rapid change in practice, but also (b) currently very simple, so only small absolute increments of capability would have large relative effects. The cell management language (CML) developed by Bourne at Carnegie-Mellon [Bourne, 1986] is an example of a technology which can completely change the basis of cell control but which is sensitive to this minimum level of device capability [Rogers and Williams, 1988].
Cell level systems
Figure 4 shows an architectural design of discrete cell control systems with some novel additions. The cell controller has both low-level (Fieldbus) and high level (MAP) network connections, but these are not intended to connect directly with the real-time subsystem (Fieldbus) and slow-response management subsystem (MAP). Instead there is a configuration utility which is intended to connect any service to any protocol via named "plugs" and "sockets". This configuration information would be stored the cell controller’s database but would also be compiled in to the fast-response software on each reconfiguration to maintain speed. This sockets updating system is required because, as we have seen:
Figure
4 Architecture view, showing functions
(after Franks et al.[Franks, Loftus and Wood,
1990] and
extended)
As well as the sockets interconnection system there is a more general configuration system which works in a similar manner but which defines which lower-level machines are managed by the cell. This system was unnecessary in the past because the cell was implicitly defined as those machines directly connected to the controller by wiring. Now it is more likely that some, at least, of the machines will be connected directly to area-wide cabling systems, i.e. the cabling topology need no longer mirror the command and control topology [Dilts, Boyd and Whorms, 1991] and virtual cells can be formed as and when required [Joshi and Smith, 1992; Seifoddini, 1990]. This has great reconfigurability advantages and some slight cabling damage localization disadvantages.
Definition of "real-time"
In the foregoing it has been assumed that the distinction between a fast subsystem and a slow subsystem remains a sensible one. While this will remain true for a while, in future all systems are likely to operate in real-time, i.e. within defined time limits, but with widely varying response times . The reasons for the current distinctions are simply that relatively cheap and capable database/operating system combinations are available but only for non-real-time use. The future trend for modern kernel-based operating systems (e.g. OS/9, Windows NT, Mach-based Unix, the forthcoming Mach-based OS/2 version 3 etc.) is to be able to support fast context-switching at a very fundamental level so that all software will have the capability of operating with real-time response.
The significant difference between real-time systems and slower, but defined-repsonsivness systems, is whether the duration of the computation/communication is significant with repect to the response time required and whether the computation/communication duration can be bounded if its inputs are bounded. What this means is that even if computation takes a long time (say, 5 seconds), if we always know that there can never be more than a defined number of inputs (say, 10), then we can assure real-time response within 50 seconds or so without any special programming tricks. However, if there are a potentially unbounded number of inputs, or if computation/communication could be lengthy even for a small number of inputs (which is often the case for configuration, planning and scheduling problems [Frederking and Chase, 1990]); then the system software must support interupts and task switching. If the required response time is shorter than the operating system context switch time, then a different hardware/software system must be used for that function. However the new kernel-based systems software can inherently switch contexts much more quickly than current operating systems in wide use (e.g. Solaris, VMS, AIX, MS-DOS, MacOS).
Information mobility
The "client-server" approach to software architecture has broken the identity between supervisory function and software execution control. The flow of control between computers is no longer simple sequencing or polling of subordinates. Thus while in general information "flows up" and control "flows down", the actual details of which programs call other programs has no such simple relationship [Weston, et al., 1989]. The same pair of computers may simultaneously be in a server-client relationship with respect to one pair of programs whilst being in a client-server relationship for another pair of programs. This freedom of control flow also frees information storage and information transfer from artificial restrictions.
Global servers
Hierarchies control complexity very well, but their major disadvantage is that they just distribute the integration task, they do not reduce the "total amount" of integration necessary. Global information servers, however, can reduce the complexity of the system as a whole by completely decoupling some tasks from the control hierarchy (see Figure 5). These can be easily based on local area network technology which also has other reconfiguration and throughput advantages [Ghosh, 1989].
One example of an architecture aided by a global information service would be where an entirely separate part-program repository system exists. A machine tool would be instructed to load a particular program, but the program itself would then be located by name by the tool and loaded over a separate communication channel from a separate program repository. This removes the data transfer task from the control channel . Even where the repository is a program running on the same computer as the control program, and where a single cable is used for both information transfer and control, separating the two channels permits better priority management and real-time response [Jones and Saleh, 1990]. The conceptual simplicity of the global server principle pays off above a certain number of tools and controllers.
A modern analogy is with aircraft landing systems. Currently the position information and the landing sequencing both involve ground-air communication through the microwave landing system and control-tower radio respectively. Boeing have recently made dozens of blind landings without microwave or radar using locally-updated global positioning system (GPS) satellites to give the plane’s position and height with respect to the runway. This single global information service, while originally expensive, has the potential to remove the need for microwave systems at every airport in the world.
Other global (factory-wide) services that might profitably be considered are time/date stamping, authentication service, perhaps current shift and holiday status, and certainly plant-wide emergency conditions. Clearly once a reliable global information system is established and trusted, it would make sense to migrate as much stable and unchanging information as possible to those repositories to take the load off the command and communication channel. This might even include bills of material where plants have low product variety.
Alternatively, heterarchical systems have been suggested as a mechanism for removing many of the problems of hierarchical systems (e.g. [Hatvany, 1985; Upton, 1992]). It has been assumed that heterarchies "require that global information is minimized of eliminated" [Dilts, Boyd and Whorms, 1991], but this only applies to coordination information. Globally-accessible information can enable heterarchical systems by providing a rich "common backdrop" information environment against which active agents can communicate simple coordination messages. The heterachical British Aerospace Control Architecture implements some of these ideas.
Figure 5 Modified hierarchical form [Dilts, Boyd and Whorms, 1991] with additional global information service
However, if the individual heterarchical agents have any kind of adaptive behaviour (the usual case [Kim, 1989]), then they should probably be prevented from either writing to the global store, or from taking actions which result in information being added to the store, since this would provide a route for non-local impliit control communication. If the adaptive behaviour is heavily circumscribed and preprogrammed then this would not be a cause for worry, but if the adaption is general enough to be termed "learning", then there is a real danger that the system will evolve to be highly tuned to the current circumstances through non-local communciation and persistent storage, with an associated bad impact on its reconfigurabilty. Computer-based experiments with evolving independent agents have shown that this is eminently possible [Todd, 1992].
The global server approach is in direct contradiction to the IMDAS (Integrate Manufacturing Data Administration System) approach developed at NIST [Libes and Barkmeyer, 1988] in the 1980s. In IMDAS every database transaction is explicitly managed across a distributed set of databases which may have very different internal structure. This is because IMDAS is designed to be able to incorporate legacy systems. The global server approach is only feasible now because of near universal acceptance of several basic communication hardware and software standards and the availability of cheap TCP/IP protocols running over a great variety of hardware.
Abstract specification
Whenever an information standard becomes over-complex, it is a general rule to look for an alternative viewpoint that enables one to standardize at a simpler, higher level of abstraction. The clearest example is the transition from a standardized set of statements to a standardized grammar which can generate only "appropriate" statements.
The penalty associated with this approach is that receiving systems have to be significantly more complex: instead of merely matching statements against an approved list, they have to be parsed and interpreted. The engineering of grammars is now well-understood so in principle this is no longer a problem, formally-stated grammars can be used to automatically generate parsers and interpreters through tools such as yacc and pocc. Manufacturing grammars must play a central role in defining tasks, controls, part-programs and communications protocols because standardization of these is essential; but standardization of grammars rather than messages is inherently more flexible [Joshi and Smith, 1992; Williams and Upton, 1989]. In practice, the speed of such parsers has prevented their use in the the lower levels of CIM systems where response times are short. This limitation will disappear as the rate of semiconductor development, coupled with the slower rate of communications development, inevitably produces a trend towards short messages with complex meanings.
A more important limitation for more abstract specifications is the difficulty that people have in working with them. When reconfiguring or extending a CIM system, it is no use being able to automatically generate the system software if only very few people can state properly the reconfiguration necessary in the form required. This is a severe problem with parts of the STEP standard (ISO 10303) and also with CIMOSA [Beeckman, 1989].
While cell-level management is already difficult, we must from the start consider multiple interacting cells otherwise the methods we develop will not be useful in practice. Design trends indicate that many plants will install many more than one cell or system and the integration of these facilities will be a key activity in the future [Little, 1989]. It is hoped that this will lead to a synergistic increase in productivity [Laduzinsky, 1990] but clearly centralized software for multiple cell systems is inappropriate [Bakker, 1988; Dilts, Boyd and Whorms, 1991; Upton, 1992].
Software and interfaces are the enduring problem [Warnecke, 1991]. Interfaces can be reduced in number only to a degree, and protocols can only be standardized within a level of generality which is decided upon in advance when the language in which they are expressed is defined. One simplification is found in the NIST control hierarchy used for AMRF whereby each distinct level operates with identical generic control logic [Jones and Saleh, 1990] though clearly care must be taken not to force quite different types of reasoning into the same control and communication moulds.
Types of integration
Although the problem of islands of automation is well known, it is only recently that it has been realized that there are several distinct types of integration problem [JFIT, 1992].
This paper concentrates on the incremental and longitudinal problems.
System design methods
Two approaches
There have been two basic approaches applied to the construction of CIM systems and other, similarly complex, software. The first is to formally define the complete system in terms of the functions it is required to have, and then generate the system itself by elaborating these specifications. The second is to provide support for producing and integrating the system modules directly. The former is typified by the CIMOSA and CIM-BIOSYS architectures [Beeckman, 1989; Joryz and Vernadat, 1990a; Joryz and Vernadat, 1990b; Klittich, 1990; Vernadat, 1992] and the second, evolutionary approach, by reconfiguration programming [Kramer, 1990; Kramer, et al., 1992; Twidle, et al., 1992].
The CIM-BIOSYS architecture is centred on a formal information model (a "conceptual schema") of several independently-written modular software control systems. This schema is edited using graphical reconfiguration tools to produce a new schema which defines the new manufacturing software system. Once an alien software module has been formally defined in the schema and an interface translator ("handler") written, it can be reconfigured declaratively [Hodgson and Weston, 1992].
Formal specification approaches have many advantages (such as being provably consistent in certain respects) but currently require rare experts able to use difficult specification languages somewhat akin to enterprise modelling of MRPII design [Bertrand, Wortmann and Wijngaard, 1990; Kim, 1989; Petrie Jnr., 1992a]. They do not provide direct support for local changes but work top-down, always starting from the top.The problem with the formal approach is that people generally find it hard to think purely in terms of behaviour specifications. The specification language, since it has to be able to define the entire system, is usually highly complex on several levels of abstraction (the STEP standard is another case in point). Thus this approach is expensive in terms of trained manpower and even small incremental changes have to be re-cast in abstract specification terms.
A major difficulty with automatic generation of system software from high-level specifications is that the generator might have to be very application specific, matched directly to the particular manufacturing process (machining, casting, asembly etc.) even if the equipment itself could be described in some parametized or grammatical form [Williams, 1989]. Whatever system is used to adapt or recreate new CIM software, the "delivery vehicle" for the changes are best expressed in terms of grammars for new sub-languages [Williams and Upton, 1989]. This is the CML approach which has proved to have unrivalled capabilities for reconfigurability in the areas where it is appropriate [Bourne, 1986; Wright and Bourne, 1988].
The problem with the reconfiguration approach is that it can lend itself to "hacking" a system until it appears to work, but with no guarantees of correctness. Thus it must always be coupled with extensive validation procedures, both statically in terms of the the structure of the configuration, and dynamically through simulation [Browne and Timon, 1991; Rowen, 1989].
Crudely, these can be thought of approximately top-down and bottom-up methods. In practice, these two approaches are not entirely exclusive since the specification approach can be used on an area by area basis and reconfiguration can be applied to specifications as well as to control software modules [Kramer, 1990]. In the long run, we can expect computer science to develop tools that provide principled support for the design of architectures themselves [Shaw, 1991].
Instinctive programming
One of the most direct attempts to tackle the problem of new system integration software was by Williams et al. [1986], where the reconfigurer is assumed to be mechanically competent but software-system naive. The goal of "instinctive programming" was achieved by a teaching process where error states were detected automatically and corrected by instructing the cell in the correct response. The system relied for its success on (a) an irreducibly simple tabular, state-driven, declarative program representation, which scales very badly and so can only handle (b) a very small number of detectors which must really be only two-state sensors. A more recent conclusion from this type of work is that purposive and error-avoidance behaviours are quite different and perhaps should be generated and programmed using quite different specification and implementation methods [Hinde, West and Williams, 1989].
Software technologies
Computer aided software engineering (CASE) specification tools have a large role in FMS and cell design because they manage consistency while specifying a variety of different viewpoints: data flow, control flow, data structure, system decomposition, interface identification and system dynamics [Dasgupta, 1989; Kehoe and Little, 1991; Petrie Jnr., 1992a; Warfield, 1990]. Perhaps the best-known in the CIM area is the set of IDEF techniques [Banerjee and Al-Maliki, 1988; Ranky, 1990b]. Since CASE software is a large market, some of the commodity software economies of scale referred to at the beginning of this paper have an influence here; thus leveraging manufacturing engineers into higher productivity than would be possible based on investment in purely manufacturing software. More manual methodologies, such as GRAI [Meyer, Isenberg and Hübner, 1988] while pehaps more appropriate for CIM, do not have the advantage of commodity returns to scale for tool development and so may be increasingly less useful in practice in the future.
CASE tools and real-time software design methods followed entirely separate lines of development throughout the 1980s. Only in the past two or three years have the two communities begun to take notice of each others’ achievements [Morin, et al., 1992; Peyton Jones, 1992]. The formal specification community have also been developing techniques independently of the more commercially-led CASE community, producing notations such as Z [Hall, 1990; Potter, Sinclair and Till, 1991; Spivey, 1990] based on discrete mathematics [Mycroft, 1989] . Z in particular would appear to be a much better vehicle for specifying sequencing and precedence specifications than the prolog-based rules (as used by Ranky and others) for which the semantics are not nearly so well defined [Ranky, 1988; West, et al., 1988; Wordsworth, 1992].
Ad hoc software systems which do not attempt achitectural support but instead aim to aid software adaption in general (such as 4th generation languages, icon-driven programming systems etc.) will certainly be necessary but not sufficient. These would include toolkits of generic configuration software which include design aids, static evaluation and dynamic simulation, aids to using simulation data and individual modules for tool, schedule and cluster management [Newman, et al., 1991]. Such systems provide no assurance that the new system is absolutely correct (but then neither do the formal systems [Hall, 1990]). Simulation of the new system is a feasible and prudent approach before any implementation, and vital to optimization.
Limitations of object-oriented approaches
Much improved methods for specifying the required behaviour of CIM systems would therefore appear to be well within our grasp if only manpower can be trained in the techniques we now know are appropriate. However there is still significant research required in developing instrinsically flexible data structures such that the specification techniques can produce real systems. Object-oriented design (OOD) is commonly looked on as the solution here [Hinde, West and Williams, 1989], but this only represents the current conception of the important entities in the system; and while appropriate for concrete actors such as sensors and actuators, for abstract systems such as cell control this can be very limiting. In addition, OOD techniques are still not mature because the early versions tend to concentrate on concrete entities at the expense of abstract concepts although this is not inherent in the approach [Fichman and Kemerer, 1992]. If physics were developed using early OOD techniques then we would have only Galilean entities; using which it would be impossible even to express Newtons’s laws. Deep conceptual design is required before the fundamental entities can be identified. These may be quite abstract.
Surprisingly, most object oriented programming languages and development environments are particularly wanting in their support of scalability, program configuration and structure in a distributed environment [Kramer, et al., 1992], but these deficiences can be alleviated if a separate configuration language is used.
Graphical reconfiguration
User interfaces have to be largely graphical to permit manufacturing engineers to easily reconfigure cells, to interface with other company systems, to disconnect from old software versions and to load upgraded systems. As has been described earlier, this is an important facility for any inherently flexible manufacturing system software. Commercial products already exist: IVI from Hewlett-Packard, PlantWorks from IBM, MainStream from ITP, and CIMPICS from Reflex. Graphical systems are particularly and intrinsically appropriate for manipulating the structural (topological) information which specifies configurations [Kramer, Magee and Ng, 1989] because a "direct manipulation" style of interaction can be used. The graphical "grammar" of this human-computer interaction however must be easy to understand and this depends on the underlying configuration control language. It is perhaps worth remarking that such systems can be configured while they are executing, and while this is not sensible if the software is a live control system, it is useful if the software is running as a simulation.
The power of graphical systems depends crucially on selecting fundamental abstractions which can then be manipulated topologically, i.e. which are context independent and which can be composed into more complex components which are also context independent. This is where deep-level system design can have immense payoffs if abstract concepts can be developed which behave as reconfigurable objects. Programming by configuring independent processes has been shown to lead to clear and flexible designs which are comprehensible, maintainable and amenable to change [Kramer, 1990; Kramer, et al., 1992]. Thus the resulting system would be object-based, but not necessarily designed using current object-oriented design techniques.
There is a well-known limit to the complexity of systems which can be specified graphically in a declarative style, and additional special purpose procedural high-level specification langauges are usually supplied with all commercial configuration systems "for expert use only", i.e. because a purely graphical approach is eventually too limiting. This is a symptom of the failure of the deep-level design to capture all the important concepts as topologically rearrangeable objects [Garlan, Kaiser and Notkin, 1992]. Such failure is inevitable eventually because the real-world can require totally new concepts to be incorporated, this also means that the systems for managing software upgrades must eventually be upgraded themselves.
Demonstational interfaces [Myers, 1992] do permit a graphical system to produce procedural programs but the safety inherent in a declarative system with instrinsic constraints is lost and maintaining such programs is currently a research issue [Ambler, Burnett and Zimmerman, 1992].
System generation
Developing easy methods for specifying cell management requirements is half the problem of providing unplanned-for flexibility, the other half is generating the implementation from those specifications. Ideally this second half would be entirely automated, as it is for some classes of database application program where the CASE tool specifications are sufficiently precise and unambiguous to be compiled into executable code.
An alternative viewpoint is to insist that the generation of code is automatic, and then to explore which type of requirements are feasible to specify. This could be the point of view of a software developer wishing to expand its market of cell controller software into companies without programming capability. The capabilities of the back-end generator and deep-level design concepts then become very important as they directly determine the range of application and the degree of inherent flexibility of the whole system.
Developing inherently flexible manufacturing systems software requires coordinated attention to fundamental architecture, communications protocols, standardization, enterprise modelling, system specification methodologies, programming techniques and user interface design. It is impossible to forsee all future requirements so it must be straightforward to replace, and not merely reconfigure, software components and the protocols by which they communicate. The replacement mechanisms themselves must also be upgradeable. These are the significant practical issues but the aspect which most fundamentally inhibits flexibility is the ontological committment to concepts, classifications of modules and definitions of interfaces.
The author thanks SERC for an advanced fellowship and the NSF-supported Engineering Design Research Center at Carnegie-Mellon University for a visiting professorship during the time that this work was devised. Much of the compiler-centered viewpoint presented here originates with Prof. David Williams of Loughborough University of Technology who first introduced me to this area; to whom, many thanks.
Abelson, Harold, et al. Intelligence in scientific computing. Comm. ACM 32 (5) (1989) 546-562.
Aho, Alfred V., Ravi Sethi, and Jeffrey D. Ullman. Compilers: principles, techniques and tools, Addison-Wesley, Reading, MA, USA, 1986. ISBN 0-201-1-194-7, 796 pages.
Ambler, Allen L., Margaret M. Burnett, and Betsy A. Zimmerman. Operational versus definitional: a perspective on programing paradigms. IEEE Computer 25 (9) (1992) 28-43.
Anon. Fieldbus success, the market decides; It’s hail and farewell to FAIS. Manufacturing Systems (June) (1992a) 4-5.
Anon. Nanobytes. Byte 17 (14) (1992b) 38.
Bakker, Hans. DFMS: a new control structure for FMS. Computers in Industry 10 (1) (1988) 1-9.
Banerjee, S.K., and I. Al-Maliki. A structured approach to FMS modelling. Int. J. Computer Integrated Manufacturing 1 (2) (1988) 77-88.
Beeckman, Dirk. CIM-OSA: computer integrated manufacturing - open system architecture. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 94-105.
Bertrand, J.W.M., J.C. Wortmann, and J. Wijngaard. Production control: a strcutural anddesign oriented approach, "Manufacturing Research and Technology". Elsevier, Amsterdam, 1990. ISBN 0-444-88122-0, 322 pages.
Bihari, Thomas E., and Prabha Gopinath. Object-oriented real-time systems: concepts and examples. IEEE Computer 25 (12) (1992) 25-44.
Bititci, U.S., and M.W. Large. Modular architecture for cell management systems. Advances in Manufacturing Technology 4 (1989) 287-291.
Bititci, U.S., and R.R. Patel. Common architecture for a co-ordination controller in a flexible manufacturing cell. Advances in Manufacturing Technology 4 (1989) 282-286.
Bonney, M.C., R.J. Barson, M.A. Head, and N. Huang. "UNISON - a tool for enterprise integration" Enterprise Integration Modelling: proceedings of the first international conference. Ed. Charles J. Petrie Jnr. MIT Press, Cambridge, Mass. USA, 1992. ISBN 0-262-66080-6, 237-248.
Bourne, David A. CML: a meta-interpreter for manufacturing. AI Magazine 7 (1986) 86-96.
Browne, Jim, and J. Feargal Timon. "Design of flexible assembly systems using simulation modelling" Handbook of Flexible Manufacturing Systems. Ed. Nand K. Jha. Academic Press Inc., San Diego, 1991. ISBN 0-12-385310-9, 217-274.
Carrie, A.S. The changing role of simulation. Advances in Manufacturing Technology 4 (1989) 297-301.
Chacón, Edgar, and Orestes Llanes Santiago. Definition of a control service in the application layer of the ISO/OSI reference model for control stations. Computers in Industry 20 (1992) 187-192.
Chryssolouris, George, and Ingfried Gruenig. On a database design for intelligent manufacturing systems. Int. J. Computer Integrated Manufacturing 1 (3) (1988) 171-184.
CIM Reference Model Committee, Purdue University. A reference model for computer integrated manufacturing from the viewpoint of industrial automation. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 114-127.
Dasgupta, S. The structure of design processes. Advances in Computers 28 (1989) 1-28.
Dilts, D.M., N.P. Boyd, and H.H. Whorms. The evolution of control architectures for automated manufacturing systems. J. Manufacturing Systems 10 (1) (1991) 79-93.
Dourish, Paul. Computational reflection and computer-supported cooperative work (CSCW) design, Technical Report, EPC-92-102 , Rank Xerox Ltd., Cambridge EuroPARC, 1992a.
Dourish, Paul. Groping towards a metaobject protocol for CSCW, or, The inifinite tower meets the wicked problem, Brown bag seminar, Rank Xerox Cambridge EuroPARC, (26 November), 1992b.
Efstathiou, Janet. "Intelligent knowledge-based systems for factory management", Factory 2000: integrating information and materials flow, Churchill College, Cambridge, UK: Institution of Electronic and Radio Engineers, (1988) 271-278.
Eisenberg, Michael. Descriptive simulation: combining symbolic and numerical methods in the analysis of chemical reaction mechanisms, AI Memo, 1171 (September), AI Lab., MIT, 1989.
Fichman, Robert G., and Chris F. Kemerer. Object-oriented and conventional analysis and design methodologies. IEEE Computer 25 (10) (1992) 22-39.
Franks, Ivor T., Martin Loftus, and Neil A. Wood. Discrete cell control. Int. J. Prod. Res. 28 (9) (1990) 1623-1633.
Frederking, Robert E., and Lin Lawrence Chase. "Plannning in a CIM environment: research towards a constraint-directed planner", 4th. Intl. Conf. on Expert Systems in Production and Operations Management, Hilton Head, South Carolina, USA: (1990)
Furness, Harry. Fieldbus benefits and status. Control Eng. (March) (1992a) 43-44.
Furness, Harry. Plugging into SP50’s Fieldbus. Control Eng. (March) (1992b) 39-41.
Garlan, David, Gail E. Kaiser, and David Notkin. Using tool abstraction to compose systems. IEEE Computer 25 (6) (1992) 30-38.
Gay, Robert K.L. "An experimental facility for computerized production planning and control", 2nd. International Conf. on Computer Integrated Manufacturing (ICCIM), Sept. 1993, Singapore: GINTIC, (1993)
Ghosh, Biman K. Optimum design of communication network for computer integrated manufacturing. Int. J. Computer Integrated Manufacturing 2 (1) (1989) 23-35.
Glicksman, Jay, Bruce L. Hitson, Jeff Y-C. Pan, and Jay M. Tenenbaum. MKS: a conceptually centralized knowledge service for distributed CIM environments. J. Intelligent Manufacturing 2 (1) (1991) 27-42.
Graefe, Udo, and Vince Thomson. A reference model for production control. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 86-93.
Groover, Mikell P. Automation, production systems, and computer integrated manufacturing, 2nd. Ed. Prentice-Hall Inc., Englewood Cliffs, New Jersey, 1987. IBSN 0-13-054652-6, pages.
Gruber, T.R., Jay M. Tenenbaum, and J.C. Weber. "Toward a knowledge medium for collaborative product development", AI in Design’92, Ed. J. Gero. Carnegie Mellon University, Pittsburgh, PA: Kluwer Academic Publishers, (1992) ISBN 0-7923-1799-8, 413-432.
Hall, Anthony. Seven myths of formal methods. IEEE Software 7 (5) (1990) 11-20.
Harel, David. On visual formalisms. Communications of the ACM 31 (5) (1988) 514-530.
Harhalakis, G., C.P. Lin, H. Hillion, and K.Y. Moy. Development of a factory level CIM model. J. of Manufacturing Systems 9 (2) (1990) 116-127.
Hatvany, J. Intelligence and cooperation in heterarchical manufacturing systems. Robotics and Computer Integrated Manufacturing 2 (2) (1985) 101-104.
Hinde, Christopher J., Andrew A. West, and David J. Williams. "The use of object orientation for the design and implementation of manufacturing process control systems", Intl. Conf. on Object-oriented manufacturing systems, Calgary, Canada: (1989) 133-138.
Hodgson, A., and R.H. Weston. "Application and information support systems for planning and control in CIM", ACME Research Conf., Brunel University, UK: SERC, (1992) 22-27.
Hutchinson, G.K., and Clementson. Manufacturing control systems: an approach to reducing software costs. Robotics and Computer-Integrated Manufacture 1 (3/4) (1984) 271-281.
Iggulden, David. "The ANSA architecture as a framework for heterogeneous execution environments" Enterprise Integration Modelling: proceedings of the first international conference. Ed. Charles J. Petrie Jnr. MIT Press, Cambridge, Mass. USA, 1992. ISBN 0-262-66080-6, 501-512.
JFIT. Intelligent systems integration program, First call for proposals, (24 August), dti/SERC, 1992.
Jones, Albert, Edward Barkmeyer, and Wayne Davis. Issues in the design and implementation of a system architecture for computer integrated manufacturing. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 65-76.
Jones, Albert, and Abdol Saleh. A multi-level/multi-layer architecture for intelligent shop-floor control. Int. J. Computer Integrated Manufacturing 3 (1) (1990) 60-70.
Joryz, H.R., and F.B. Vernadat. CIM-OSA Part 1: total enterprise modelling and function view. Int. J. Computer Integrated Manufacturing 3 (3) (1990a) 144-156.
Joryz, H.R., and F.B. Vernadat. CIM-OSA Part 2: information view. Int. J. Computer Integrated Manufacturing 3 (3) (1990b) 157-167.
Joshi, Sanjay B., and Jeffrey B. Smith. "Intelligent control of manufacturing systems" Intelligent design and manufacturing. Ed. Andrew Kusiak. John Wiley and SOns, Inc., London, 1992. ISBN 0-471-53473-0, 491-520.
Kehoe, D.F., and D. Little. "Methodology for the design and outline specification for a flexible manufacturing cell system", ACME Research Conference, Leicester University: SERC/ACME, (1991) 30-35.
Kiczales, Gregor. "Towards a new model of abstraction in the engineering of software", IMSA’92 Proceedings (Workshop on Reflection and Meta-level architectures), (1992)
Kiczales, Gregor, Jim des Rivières, and Daniel Bobrow. The art of the meta-object protocol, MIT Press, Cambridge, Mass., USA, 1991. , pages.
Kim, Steven H. A systematic approach to intelligent systems design - 1. Concepts. Robotics and Computer Integrated Manufacturing 6 (2) (1989) 143-155.
Kim, Steven H., and Takahide Tokawa. A systematic approach to intelligent systems design - 2. Multi-level case study. Robotics and Computer Integrated Manufacturing 6 (2) (1989) 157-165.
Klittich, M. CIM-OSA Part 3: CIM-OSA integrating structure - the operatinal basis for integrated manufacturing systems. Int. J. Computer Integrated Manufacturing 3 (3) (1990) 168-180.
Kramer, Jeff. "Configuration programming: a framework for the development of distributable systems", Intl. Conf. on Computer Systems and Software Engineering (COMPEURO’90), May, Israel: IEEE, (1990)
Kramer, Jeff, Jeff Magee, and Keng Ng. Graphical configuration programming: the structural description, construction and evolution of software systems using graphics. IEEE Computer 22 (10) (1989) 53-65.
Kramer, Jeff, Jeff Magee, Morris Sloman, and Narankar Dulay. Configuring object-based distributed programs in REX. IEE Software Engineering J. (Special issue on object-oriented systems) (March) (1992) .
Kramer, Jeff, Jeff Magee, and Andrew Young. "Towards unifying fault and change management", Proc. IEEE Intl. Workshop on Distributed Computing Systems in the ‘90s, Cairo, Egypt: IEEE, (1990) 57-63.
Krishnamurthy, Vishnu, Stanley Y.W. Su, Herbert Lam, Mary Mitchell, and Ed Barkmayer. "A distributed database architecture for an integrated manufacturing facility", Intl. Conf. on Data and Knowledge Systems for Manufacturing and Engineering, Hartford, CT, USA: IEEE, (1987) 4-13.
Laduzinsky, Alan J. Cell controllers proffer new vista for plant operations. Control Eng. (July) (1990) 47-50.
Laduzinsky, Alan J. Networking’s undiscovered country: the factory floor. Control Eng. (February) (1992) 49-51.
Libes, Don, and Ed Barkmeyer. The integrated manufacturing data administration system (IMDAS) - an overview. Int. J. Computer Integrated Manufacturing 1 (1) (1988) 44-49.
Little, D. A structured approach to FMS design. Advances in Manufacturing Technology 4 (1989) 275-281.
Loftus, Martin, and A. Robson. The current status of the cell controller. Advances in Manufacturing Technology 4 (1989) 389-393.
Mansfield, Niall. The X Window System: a user’s guide, Addison-Wesley, 1991. ISBN 0-201-56344-4, pages.
McLagan, Scott. From distributed control to integrated information. Control Eng. (March) (1992) 13-16.
Messina, Gaetano, and Guido Tricomi. Manufacturing communication architectures. Computers in Industry 13 (1990) 285-293.
Meyer, Wolfgang, Randolf Isenberg, and Martin Hübner. Knowledge-based factory supervision: The CIM shell. Int. J. Computer Integrated Manufacturing 1 (1) (1988) 31-41.
Morin, Magnus, Simin Nadjm-Tehrani, Per Österling, and Erik Sandewall. Real-time hierarchical control. IEEE Software 9 (5) (1992) 51-57.
Moss, S.P. A mangaement and control architecture for factory-floor systems: from concept to reality. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 106-113.
Mycroft, Alan. Introduction to discrete mathematics, Teaching report, (4 May), University of Cambridge Computer Laboratory, 1989.
Myers, Brad A. Demonstrational interfaces: a step beyond direct manipulation. IEEE Computer 25 (8) (1992) 61-73.
Newman, S.T., R. Bell, L.B. McQueen, S. Rahimifard, M. Ozbayrak, and R.B.R. de Souza. "The design of flexible machining facilities", ACME Research Conference, Loughborough University, UK: SERC/ACME, (1991) 36-41.
Nof, Shimon. The number of proposed CIM architectures, Personal communication, (September), 1992.
Pan, Jeff Y-C., Jay M. Tenenbaum, and Jay Glicksman. A framework for knowledge-based computer-integrated manufacturing. IEEE Trans. Semiconductor Manufacturing 2 (2) (1989) 33-46.
Parthasarathy, Sanjay, and Steven H. Kim. Temporal reasoning for manufacturing: a hybrid representation and complexity management. Robotics and Computer Integrated Manufacturing 6 (1) (1989) 67-81.
Parunak, H. Van Dyke. Characterizing the manufacturing scheduling problem. J. Manufacturing Systems 10 (3) (1991) 241-259.
Patankar, Ajit K. "Flexible Manufacturing Systems: a survey of U.S. applications" Handbook of Flexible Manufacturing Systems. Ed. Nand K. Jha. Academic Press Inc., San Diego, 1991. ISBN 0-12-385310-9, 275-292.
Petrie Jnr., Charles J., ed. Enterprise Integration Modelling: proceedings of the first international conference, Scientific and engineering computation. MIT Press, Cambridge, Mass. USA, 1992a. ISBN0-262-66080-6, 564 pages.
Petrie Jnr., Charles J. "A minimalist model for coordination" Enterprise Integration Modelling: proceedings of the first international conference. Ed. Charles J. Petrie Jnr. MIT Press, Cambridge, Mass. USA, 1992b. ISBN0-262-66080-6, 409-415.
Peyton Jones, S.L. UK research in functional programming. SERC Bulletin 4 (11) (1992) 24-25.
Potter, Ben, Jane Sinclair, and David Till. An introduction to formal specification in Z, Prentics-Hall Intl., 1991. ISBN 0-13-478702-1, pages.
Ranky, Paul G. A real-time, rule-based FMS operation control strategy in CIM environment - Part 1. Int. J. Computer Integrated Manufacturing 1 (1) (1988) 55-72.
Ranky, Paul G. Computer networks for world class CIM systems, "World class computer integrated manufacturing (CIM) series". CIMware Ltd., Guildford, UK, 1990a. ISBN 1-872631-01-0, 231 pages.
Ranky, Paul G. Flexible manufacturing cells and systems in CIM, "World class computer integrated manufacturing (CIM) series". CIMware Ltd., Guildford, UK, 1990b. ISBN 1-872631-02-9, 263 pages.
Rao, Ming, and James T. Luxhoj. Integration framework for intelligent manufacturing processes. J. Intelligent Manufacturing 2 (1991) 43-52.
Rembold, U., and P. Levi. The factory of the 90s. Computers in Mechanical Engineering (May/June) (1988) 30-37.
Rogers, Paul, and David J. Williams. Knowledge-based control in manufacturing automation. Int. J. Computer Integrated Manufacturing 1 (1) (1988) 21-30.
Rowen, Robert. Nonprose alternatives as sources of manufacturing floor control software requirements. J. of Manufacturing Systems 8 (3) (1989) 235-237.
Sargent, P.M. Materials Data Interchange for Component Manufacture. Engineering with Computers 6 (1990) 237-247.
Sargent, P.M. Inherently self-describing materials information catalogue structure, Unpublished report distributed to a UK Engineering Design Centres’ private workshop on "Materials selection and databases", Cambridge University Engineering Dept., (11 April), 1991.
Sargent, Philip Michael. "Chapter 23: Strategies for computer integrated operations" Handbook of Engineering Management. Ed. Dennis Locke. 2nd. ed. Butterworth Heinemann Publ., Oxford, 1992.
Schofield, Norman. "Computer integrated manufacture", ACME Research Conf., Brunel University, UK: SERC, (1992) 34-35.
Segal, Mark E., and Ophir Frieder. On-the-fly program modification: systems for dynamic updating. IEEE Software 10 (2) (1993) 53-65.
Seifoddini, Hamid. A probabilistic system for machine cell formation. J. Manufacturing Systems 9 (1) (1990) 69-75.
Shaw, Mary. "Heterogeneous design idioms for software architecture", Proc. Sixth Intl. Workshop on Software Specification and Design, Como, Italy (Oct.25-26): IEEE Computer Society, (1991) 158-165.
Sidhu, G.S., R.F. Andrews, and A.B. Oppenheime. Inside AppleTalk®, 2nd. Ed. Addison-Wesley Publ. Co. Inc, New York, 1991. ISBN 0-201-55021-0, pages.
Spivey, J. Michael. Specifying a real-time kernel. IEEE Software 7 (5) (1990) 21-28.
Spoor, Edu. The design of inherently flexible information systems, Seminar, Cambridge University Engineering Dept. (Management Group), (27 October), 1992.
Story, Guy, Lawrnece O’Gorman, David Fox, Louise Levy Schaper, and H.V. Jagadish. The RightPages image-based electronic library for alerting and browsing. IEEE Computer 25 (9) (1992) 17-26.
Teng, Sheng-Hsien (Gary), and J. Temple Black. Cellular manufacturing systems modeling: the Petri net approach. J. Manufacturing Systems 9 (1) (1990) 45-54.
Teng, Sheng-Hsien (Gary), and J. Temple Black. Petri nets for manufacturing cell control operations. Manufacturing Review 5 (2) (1992) 127-137.
Todd, Peter M. The animat path to intelligent adaptive behaviour. IEEE Computer 25 (11) (1992) 78-81.
Twidle, K., M. Sloman, J. Magee, J. Kramer, N. Dulay, S. Crane, and S.C. Cheung. "Configuring heterogeneous open systems" Enterprise Integration Modelling: proceedings of the first international conference. Ed. Charles J. Petrie Jnr. MIT Press, Cambridge, Mass. USA, 1992. ISBN 0-262-66080-6, 513-523.
Udell, Jon. Windows NT up close. Byte 17 (10) (1992) 167-178.
Upton, David M. A flexible structure for computer-controlled manufacturing systems. Manufacturing Review 5 (1) (1992) 58-74.
Vernadat, François B. "CIMOSA - A European development for enterprise integration - Part 2: enterprise modelling" Enterprise Integration Modelling: proceedings of the first international conference. Ed. Charles J. Petrie Jnr. MIT Press, Cambridge, Mass. USA, 1992. ISBN 0-262-66080-6, 189-204.
Ward, Steven. The language of integration. Manufacturing Systems (June) (1992) 24-25.
Warfield, J. The Science of Generic Design: Managing Complexity Through Systems Design, (2 vols.) Intersystems Pulishers, Seaside, CA, 1990. 1 & 2, pages.
Warnecke, H.J. "Factory of the future" Handbook of Flexible Manufacturing Systems. Ed. Nand K. Jha. Academic Press Inc., San Diego, 1991. ISBN 0-12-385310-9, 293-314.
West, Andrew A., R. Chandrakar, David J. Williams, and D.J. Mulvaney. "Hybrid representations of real-time control rules for manufacturing process control in electronics manufacture", IEEE Intelligent Control Conf.,, (1988)
Weston, R.H., J.D. Gascoine, A. Rui, Allan Hodgson, C.M. Sumpter, and I. Coutts. Steps towards information integration in manufacturing. Int. J. Computer Integrated Manufacturing 1 (3) (1988) 140-153.
Weston, R.H., Allan Hodgson, J.D. Gascoine, C.M. Sumpter, A. Rui, and I. Coutts. Configuration methods and tools for manufacturing systems integration. Int. J. Computer Integrated Manufacturing 2 (2) (1989) 77-85.
Williams, David J. "Manufacturing intelligence - from systems to processes", Proc. Conf. AI in Engineering, Cambridge, UK: (1989) 3-15.
Williams, David J., Paul Rogers, and David M. Upton. Programming and recovery in cells for factory automation. Intl. J. of Advanced Manufacturing Technology 1 (2) (1986) 37-47.
Williams, David J., and David M. Upton. Syntactic models of manufacturing processing and control. Int. J. Computer Integrated Manufacturing 2 (4) (1989) 229-237.
Williams, David J., Andrew A. West, and Christopher J. Hinde. "A hierarchical model of intelligent materials processing", Intl. Symp. on Intelligent Control, Arlington, WV, USA: IEEE, (1991) 330-333.
Wordsworth, J.B. Software development with Z, Addison-Wesley Publ. Co., 1992. ISBN 0-201-62757-4, pages.
Wright, Paul Kenneth, and David Alan Bourne. Manufacturing Intelligence, Addison-Wesley, Reading, MA, USA, 1988. ISBN 0-201-13576-0, 352 pages.
Figures
Figure 1 Control sophistication levels, both for a CIM architecture as a whole and potentially for each component level
Figure 2 A part transmits processing requests to a number of machines which bid for its servicing (from [Upton, 1992]).
Figure 3 Generic functions applicable at any level in a hierarchy, or an any entity in a heterarchy
Figure 4 Architecture view, showing functions
Figure 5 Modified hierarchical form with additional global information service
Copyright Notice
Making a single copy of this paper for individual personal use is permitted without payment or royalty.
This paper, or an extract thereof, may be copied and distributed in multiple copies for any non-profit-making purpose provided that reproduction is done without alteration and provided that the title, author's name, report number and name and address of the Cambridge University Engineering Dept. is present on each copy or extract. Any extract distributed in this way must also state plainly that it is incomplete and must also state where and from whom a full copy may be obtained.
The title and summary may be distributed royalty free without further permission by computer-based or other information-service systems.
Permission to republish this paper, or any substantial portion thereof, must be sought from the author. Short extracts, for the purpose of review, may be published without permission on condition that a copy of the article containing the extracts is sent to the author.
Requests for additional copies should, in the first instance, be addressed to The Librarian, Cambridge University Engineering Dept. for which a nominal charge of £10 will be made. The author also keeps some copies for distribution.
©1993 Dr. Philip M.
Sargent
Cambridge University Engineering Department
Trumpington Street, Cambridge CB2 1PZ, England
tel.
(direct line) +44 223 332627
tel. (switchboard) +44 223 337733
fax. +44 223 332662
telex 81239 G
e-mail
info server
Edited to
HTML 26 March, 1999 01:08
http://purl.oclc.org/NET/sargents/Philip/