Previous chapters have outlined the functional aspects of BCAPP. At this point it is the intention of the author to demonstrate the validity of the Boolean approach to planning, as well as discussing some outstanding problems. A few examples have been chosen to illustrate the method in general. The first examples will be simple machined parts. These are selected as a simple introduction to the results. After these a plan will be presented for a desk toy, in the form of a scaled up ‘clothes pin’. This is customized with an advertisement, and can be used to hold a stack of paper. Finally, a novel application will be displayed by using the planner to select electrical components for a digital circuit.

Machined parts come from a very limited domain. When machining, most parts involve selecting a piece of stock, and then removing metal to get to a finished part shape. Generally there will be two ways a designer would approach this problem. The first would be when he selects a basic piece of stock, then subtracts volumes until the final part shape is reached. At present this approach is easily handled by the system. On the other hand, if the designer decides to build up a part from primitives, then a piece of stock must be identified for machining. Since stock identification requires geometrical reasoning, and this has not been added to the method yet, it is not possible to deal with this case for production. It has been stated in the past [Requicha and Vandenbrande, 1988] that the alternate representations are a problem. However, if we use the knowledge about what the alternate representations are, and what they mean, then it is possible to convert between them. There are two equivalent cases shown below in Figure 12.1 Alternate Representations for the Same Part.

If a designer has chosen one representation or another it would suggest a particular process. In the top representation, the designer would obviously be suggesting machining. In the bottom, the designer would be suggesting some sort of joining process. At present BCAPP can plan for both of these processes, but until geometrical reasoning is added to allow transformation between the two representations, it will be difficult for BCAPP to suggest welding for the top part representations, and likewise machining for the bottom part.

One of the first parts used for development is seen below. It is a block with an angles face cut off and a through hole drilled.

The number of possible machining operations that can be used for this part is limited. In fact the number of reasonable CSG models for such a part are also limited. The design file for this part is given below.

The part file only uses a single design equation to represent the design. As can be seen, I have constructed the basic form of the part with block and wedge primitives. While the basic form can be created a number of ways, the hole through the block can only rationally be made with a ‘( ~ CYLINDER )’ term, any other would be excessive, or redundant. When it comes to the formation of the block/wedge pair they exemplify the non-unique nature of CSG. This could be made by,

cutting a square block, and cutting off the parts where it doesn’t overlap the wedge,

cutting a wedge shape, and removing the sections where it doesn’t overlap the block shape,

cutting a square block, and removing the material on one half of a half-space plane,

As mentioned before, there are two clear manipulations at work here. The first is simple equation manipulation, as in the commutation of the ‘WEDGE’ and ‘BLOCK’ above. In the second case, there is the selection of new equations and primitives, as in replacing the ‘WEDGE’ with the ‘HALFSPACE’. As mentioned before, only equation manipulation is used here. Therefore the discussion will centre about the first two cases listed above.

Both of the cases above can be recognized with rules, and both are quite valid. But, it is not desirable to cut stock with a triangular cross section, as would be required in the first case. Recognizing this there are only a few rules for cutting stock in standard shapes, such as square and round. In addition to rules for recognizing stock, there are also rules for looking for certain shapes to cut externally, such as the wedge. It is known that this shape is external because it is ANDed with the stock. Whereas the cylinder is probably an internal feature because is in the form ‘( AND ..... ( NOT CLYINDER ) .... ‘. In simple terms the basic planning process will follow the steps below.

This plan is quite straight forward, and does get planned without problems. If the wedge and the block were reversed the plan would continue until it was time to get a triangular stock. No rule would be found for getting triangular stock, and the system would have to backtrack until it finds an alternative plan. Also of interest is the naive suggestions of machining volumes. When suggesting milling parts of the block outside the wedge shape, some geometrical calculations are required to determine the volumes to be milled. Geometrical information is not available, but if it was a CSG model of the volume as ‘( & BLOCK ( ~ WEDGE )’ would be the machined volume.

This plan is the direct output from the operation planner, with detailed machining information not given. At the top we see that the Product name is identified. Second we see an operation summary sheet, that identifies the part, the quantity to be manufactured, and a number of operations. The first operation requires that stock be cut. Secondly, a milling operation is called for to eliminate the excess wedge. Finally, the hole is drilled.

To be critical, there are a number of data details that would eventually have to be added to the rules to make them complete, such as a knowledge of available stocks sizes and shapes. Also important is that the call for milling naively calls for milling of a wedge shape. At its worst this would work, but it would be very inefficient. However, computer graphics tools could be used to show a picture of the part before and after for the benefit of human users. The final call for a drilled hole is fairly straight forward, and should work well. Detailed locations, etc. are not given here for most operations. This is for clarity, but the indication of block dimensions shows that the system is indeed capable of reflecting the detailed information. Another detail to point out is that it is possible that the drilling operation would be listed before the milling operation. This is not acceptable because both of the entrance faces for the hole would not be at a normal to the axis of drill insertion (i.e. the drill would slip). This sort of information requires some geometrical interpretation to allow rule conditions to be checked. This does not mean that future work cannot incorporate this feature, but it does mean in the present state some geometrically absurd operations will be suggested.

The previous section showed a very simple machined part that was quite simple to plan. Also, the rules for planning were overlooked. In this section a more complex part will be suggested, and the complete rule set will be presented.

The part shown below is a rod support mount that was randomly selected from a drafting textbook. It contains many similar operations in the previous example, but is more extensive.

The file above is more sophisticated than the previous design file, and should give the reader an appreciation of the power of this representation technique. For example there is a reused feature in the design called the ‘Mount_Feature’. This feature is used twice in the design.

The rule file below will only be shown once because of size, although the same file is used for the first three examples in this chapter (i.e. the angles part, the rod support mount, and in the next section the big clothes pin).

When this rule file is applied to the part we obtain an enlarged design file, as shown below.

The Plan File for the Rod Support Mount (cont’d)

ACTIVE: 0

EXPANDED ( 2 0 0 0 )

}

MILLED_ROUND_19 {

form = CYLINDER

radius = 3.4

height = 12.0

translate_x = 0.2

rotate_y = 90

cost = 0.250000

}

Rod_Support_OP19 {

DESCRIPTION ( cut a block from stock with band saw )

DESCRIPTION ( width = 11.3 )

DESCRIPTION ( depth = 3.2 )

DESCRIPTION ( height = 6.4 )

EQUATION: NULL

}

BLOCK_STOCK_20 {

material = brass

form = BLOCK

width = 11.3

depth = 3.2

height = 6.4

cost = 34714.100000

matl_cost = 150.000000

}

Rod_Support_PART {

form = COMPLEX

description = Rod_Support

equation = ( & Stock ( ~ Rod_Hole ) ( ~ ( + Mount_Hole

Mount_Gouge );Mount_Hole_1 ) ( ~ ( + Mount_Hole Mount_Gouge

);Mount_Hole_2 ) ( ~ Top_Channel ) ( ~ Bottom_Channel )

Top_Round )

}

Figure 12.1 The Plan File for the Rod Support Mount

The file listed above lists not only the design file information, but also the process plan information, as discussed in the previous chapters. One point of interest is that for some of the operations there are multiple choices. Only one of these has been selected, but the system is at least choosing between a number of alternatives. When this file is interpreted through to the final design, the operation plan results are listed below.

-------- Work Order Sheets ------------

Product: Rod_Support

OPERATION SUMMARY_SHEET: Rod_Support_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

0 cut a block from stock with band saw

width = 11.3

depth = 3.2

height = 6.4

10 Mill Off Round Shape

20 Mill Out Block Shape

30 Mill Out Block Shape

40 Mill Out Block Shape

50 drill hole : COMBINED_SET_10

60 Mill Out Block Shape

70 drill hole : COMBINED_SET_5

120 drill hole : Rod_Hole

Figure 12.2 An Operation Plan for the Rod Support Mount

Here again we can see that many of the operations may be alternated in order. For example, BCAPP would be quite likely to schedule the drilling of the ‘Mount_feature’ holes before the ‘Mount_gouges’. This would not make sense, but without the solid modeling capabilities, it is difficult to detect the excess volume that would have to be drilled for the reversed sequence.

12.4 Multi-Domain Planning

In both examples so far the process domain has been limited to machining. It is very unusual to find a part that is manufactured using one type of an industrial process, such as machining only. Therefore another important test of the planner was planning for a product with mixed operation types and parts. The part selected is shown below. The product is a paper clip in the form of a ‘clothes pin’. The clip has two halves and a connecting spring. On one of the sides there is an advertising logo embossed on. The same side also has a hole drilled into it so that the clip may be mounted on a wall. In total there are a number of possible technologies that may be applied to the part. First, the spring is quite straight forward, and only involves the forming of some wire. In the second case, either of the clip halves could be made by injection molding (this was used in the actual production of the sample product used). But, in other cases, it is possible to machine the entire part from a piece of polypropylene. The decision can be based on the quantities of parts to be produced. For example, to machine two halves of a clip for a prototype might only cost a few hundred dollars, as opposed to $50,000 to $100,000 for molds for injection molding (the figure are based on my personal experience). A graphical representation of the clip is shown below.

Figure 12.3 A Test Part: A Large Plastic Clothes Pin

// This file contains a test part for the BCAPP system. The part is a

// large Plastic Clothes peg which is intended for use as an paper

// holder. It is also has an embossed logo on the side.

// -------------------- Main Geometry Definition ---------------------

main Big_Clothes_Pin {

EQUATION: ( : Spring;attach_spring Logo_Side;position_logo_side

Clip_half )

}

// ------------------ Assembly and positioning information ----------

Package {

quantity = 20

}

attach_spring {

translate_y = -0.4

translate_z = -0.275

}

position_logo_side {

translate_z = 0.55

rotate_y = 180

}

// -------------------- Defintion of Logo Side of Clip --------------

Logo_Side {

EQUATION: ( : ( & Clip_half ( ~ Screw_hole );position_screw_hole

);add_logo )

}

Screw_hole {

EQUATION: ( + HOLE CHAMFER )

}

HOLE {

form = CYLINDER

radius = 0.06

height = 0.6

}

CHAMFER {

form = CONE

radius = 0.125

height = 0.25

translate_z = -0.18

}

position_screw_hole {

translate_y = 0.85

}

add_logo {

operation = emboss

// description = ‘ add CBS logo ‘

}

// ---------- This is the box to put the pins into -------------------

Box {

description = #10_standard_box

EQUATION: ( & OUTSIDE ( ~ INSIDE ) )

}

OUTSIDE {

form = BLOCK

width = 15.2

depth = 6.1

height = 1.3

translate_z = -0.1001

}

INSIDE {

form = BLOCK

width = 15

depth = 5.9

height = 1.1

}

// ---------- This is the clip spring (This is a tough definition) ---

Spring {

form = SPRING

ends = L

inside_radius = 0.12

outside_radius = 0.2

length = 1.50

turns = 14.5

rotate_y = 90

}

// ------------ The geometry for one half of the clip is defined here

Clip_half {

EQUATION: ( & ( ~ B ) ( ~ C ) ( & A E ) ( ~ D ) )

material = polypropylene

color = hong_kong_red

}

A {

form = BLOCK

width = 1.4

depth = 5.9

height = 0.55

material = polypropylene

}

B {

form = CYLINDER

radius = 0.28

height = 1.45

translate_x = 0.275

translate_y = 1.95

rotate_y = 90

}

C {

form = CYLINDER

radius = 0.1

height = 1.45

translate_x = -0.275

translate_y = 1.2

rotate_y = 90

}

D {

form = CYLINDER

radius = .2

height = 1.45

translate_x = 0.275

translate_y = -0.4

rotate_y = 90

}

E {

form = BLOCK

height = 10

width = 10

depth = 10

translate_z = 4.68

rotate_x = -9

}

// ------------------------------------------------------------------

Figure 12.4 Big Clothes Peg Product Description File

After the rule file listed previously (in Figure 4) was applied, the following output file was obtained.

-------- Work Order Sheets ------------

Product: Big_Clothes_Pin

OPERATION SUMMARY_SHEET: Clip_half_PART: Quantity 2.000000

OP# Operation Description

------------------------------------------

0 cut a block from stock with hot wire

width = 1.4

depth = 5.9

height = 0.55

10 drill hole : D

20 drill hole : C

30 drill hole : B

40 mill out block shape : E

OPERATION SUMMARY_SHEET: 0:Logo_Side_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

1000 get WIP from inventory

name = Clip_half

1010 drill chamfer

1020 drill hole : COMBINED_SET_10

OPERATION SUMMARY_SHEET: Logo_Side_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

2000 fixture part : LOGO_PART_18

2010 Add Logo to part

OPERATION SUMMARY_SHEET: Spring_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

3000 coil spring from wire

bend coil spring

wire dia. = 0.080000

turns. = 14.500000

3010 bend spring ends

L offset on spring = 0.0

length of free end = 3.400000

OPERATION SUMMARY_SHEET: Big_Clothes_Pin_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

4000 fixture part : Spring_PART;attach_spring

4010 add part to fixtured part

add Clip_half_PART to COMBINED_SET_28

4020 add part to fixtured part

add Logo_Side_PART;position_logo_side to COMBINED_SET_28

Figure 12.5 Operation Plan for the Big Clothes Pin

The plan above exhibits a few very important factors. First, the plan contains a range of operations, from forming to cutting. Thus showing the independence from a single processing domain. Also shown is the ability for the planner to break the product into natural components, one of these being the clip half with the logo added. In this case the planner separated out the addition of the logo, even though the design does not indicate it as an individual assembly. This is in keeping with what would happen in an industrial environment, where a number of clip halves would be made in a large economical batch, then the logos would be added a later time to smaller batches, as requested by a customer.

The reader is also asked to consider the flexible nature of the description within the plan. This indicates that the plan can be easily customized to suit the varying needs and abilities of the manufacturer.

12.5 Selection of Electrical Components

Up to this point the examples have been mainly limited to discrete manufacturing of mechanical parts. In this section a somewhat novel approach of the planner will be suggested. This is given for some illustration of the implications of this planning approach. The example chosen was a digital circuit design for an encoder that would take ten input lines, and derive a four bit binary output number that would indicate which of the input lines is active. The design was done in a format similar to the previous designs, except that obvious features such as geometrical features are no longer needed.

The digital-to-binary encoder is a simple logical circuit using combinatorial logic expressions. The truth table for such a system is shown below.

Figure 12.6 Truth Table for Digital to Binary Encoder

This can be directly converted to as design file, as shown below.

// This is a description of a digital circuit that does 10 bit digital

// input to 4 bit binary output conversion

main decade_to_binary {

EQUATION: ( : A B C D )

}

A {

// The least significant bit

EQUATION: ( + I1 I3 I5 I7 I9 )

}

B {

// The second least significant bit

EQUATION: ( + I2 I3 I6 I7 I10 )

}

C {

// The second most significant bit

EQUATION: ( + I4 I5 I6 I7 )

}

D {

// The most significant bit

EQUATION: ( + I8 I9 I10 )

}

I1 {

// input for 0

form = INPUT

}

I2 {

// input for 1

form = INPUT

}

I3 {

// input for 2

form = INPUT

}

I4 {

// input for 3

form = INPUT

}

I5 {

// input for 4

form = INPUT

}

I6 {

// input for 5

form = INPUT

}

I7 {

// input for 6

form = INPUT

}

I8 {

// input for 7

form = INPUT

}

I9 {

// input for 8

form = INPUT

}

I10 {

// input for 9

form = INPUT

}

Figure 12.7 A Product Description File for a Digital to Binary Encoder

The file above is sufficient to describe the function of the circuit. Interesting is the representation of the parallel Boolean equations using the assembly operator that is not often used in standard switching circuit design theory. This design was then planned with a set of rules shown below.

// Rules for selecting chips for digital circuits

// The equation templates are listed here

equation_form 2_INPUT_OR_GATES {

EQUATION: ( + VAR:V:0 VAR:V:1 ...)

RULE: 2_input_or

}

equation_form 3_INPUT_OR_GATES {

EQUATION: ( + VAR:V:0 VAR:V:1 VAR:V:2 ...)

RULE: 3_input_or

}

equation_form 4_INPUT_OR_GATES {

EQUATION: ( + VAR:V:0 VAR:V:1 VAR:V:2 VAR:V:3 ...)

RULE: 4_input_or

}

equation_form FIND_SINGLE_TERM_OR {

EQUATION: ( + VAR:V:0 )

RULE: Eliminate_single_term

}

equation_form OUTPUT_LIST {

EQUATION: (> : VAR:V:0 ...)

RULE: List_output_connection

}

// The rules are listed here

rule 2_input_or {

EQUATION: ( & ( + 1_INPUT 1_RESULTANT ) ( + 2_INPUT

2_RESULTANT ) )

RESULT: USE_2_INPUT_OR_GATE

}

rule 3_input_or {

EQUATION: ( & ( + 1_INPUT 1_RESULTANT ) ( + 2_INPUT 2_RESULTANT )

( + 3_INPUT 3_RESULTANT ) )

RESULT: USE_3_INPUT_OR_GATE

}

rule 4_input_or {

EQUATION: ( & ( + 1_INPUT 1_RESULTANT ) ( + 2_INPUT 2_RESULTANT )

( + 3_INPUT 3_RESULTANT ) ( + 4_INPUT 4_RESULTANT ) )

RESULT: USE_4_INPUT_OR_GATE

}

rule List_output_connection {

EQUATION: ( & 1_EXISTS )

RESULT: ADD_OUTPUT_TO_LIST

}

rule Eliminate_single_term {

EQUATION: ( & 1_EXISTS )

RESULT: KILL_SINGLE_TERM

}

// The rule conditions are used here

condition 1_EXISTS {

COMPARE ( V0.form $ )

}

condition 1_INPUT {

COMPARE ( V0.form $ )

COMPARE ( V0.form == INPUT )

}

condition 1_RESULTANT {

COMPARE ( V0.form $ )

COMPARE ( V0.form == CALCULATED )

}

condition 2_INPUT {

COMPARE ( V1.form $ )

COMPARE ( V1.form == INPUT )

}

condition 2_RESULTANT {

COMPARE ( V1.form $ )

COMPARE ( V1.form == CALCULATED )

}

condition 3_INPUT {

COMPARE ( V2.form $ )

COMPARE ( V2.form == INPUT )

}

condition 3_RESULTANT {

COMPARE ( V2.form $ )

COMPARE ( V2.form == CALCULATED )

}

condition 4_INPUT {

COMPARE ( V3.form $ )

COMPARE ( V3.form == INPUT )

}

condition 4_RESULTANT {

COMPARE ( V3.form $ )

COMPARE ( V3.form == CALCULATED )

}

// The rule results are defined here

result USE_2_INPUT_OR_GATE {

COPY_SET ( V0 2_INPUT_GATE )

FIND ( 2_INPUT_GATE input_0 SET_NAME V0 )

FIND ( 2_INPUT_GATE input_1 SET_NAME V1 )

EQUATION_INSERT_SYMBOL ( :0 2_INPUT_GATE )

EQUATION_DELETE_SYMBOL ( :1 )

DELETE_PROPERTY ( 2_INPUT_GATE form )

ADD_PROPERTY ( 2_INPUT_GATE form = CALCULATED )

ADD_PROPERTY ( 2_INPUT_GATE cost = 0.50 )

DECLARE_COST ( 2_INPUT_GATE cost )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Use 2 input OR gate for ‘

2_INPUT_GATE.input_0 2_INPUT_GATE.input_1 ‘ ) ‘ )

DELETE_PROPERTY ( 2_INPUT_GATE input_0 )

DELETE_PROPERTY ( 2_INPUT_GATE input_1 )

FIND ( 2_INPUT_GATE output THIS_NAME 2_INPUT_GATE )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Output is ‘

2_INPUT_GATE.output ‘ ) ‘ )

DELETE_PROPERTY ( 2_INPUT_GATE output )

}

result USE_3_INPUT_OR_GATE {

COPY_SET ( V0 3_INPUT_GATE )

FIND ( 3_INPUT_GATE input_0 SET_NAME V0 )

FIND ( 3_INPUT_GATE input_1 SET_NAME V1 )

FIND ( 3_INPUT_GATE input_2 SET_NAME V2 )

EQUATION_INSERT_SYMBOL ( :0 3_INPUT_GATE )

EQUATION_DELETE_SYMBOL ( :1 )

DELETE_PROPERTY ( 3_INPUT_GATE form )

ADD_PROPERTY ( 3_INPUT_GATE form = CALCULATED )

ADD_PROPERTY ( 3_INPUT_GATE cost = 0.65 )

DECLARE_COST ( 3_INPUT_GATE cost )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Use 3 input OR gate for ‘

3_INPUT_GATE.input_0 3_INPUT_GATE.input_1 3_INPUT_GATE.input_2

‘ ) ‘ )

DELETE_PROPERTY ( 3_INPUT_GATE input_0 )

DELETE_PROPERTY ( 3_INPUT_GATE input_1 )

DELETE_PROPERTY ( 3_INPUT_GATE input_2 )

FIND ( 3_INPUT_GATE output THIS_NAME 3_INPUT_GATE )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Output is ‘

3_INPUT_GATE.output ‘ ) ‘ )

DELETE_PROPERTY ( 3_INPUT_GATE output )

}

result USE_4_INPUT_OR_GATE {

COPY_SET ( V0 4_INPUT_GATE )

FIND ( 4_INPUT_GATE input_0 SET_NAME V0 )

FIND ( 4_INPUT_GATE input_1 SET_NAME V1 )

FIND ( 4_INPUT_GATE input_2 SET_NAME V2 )

FIND ( 4_INPUT_GATE input_3 SET_NAME V3 )

EQUATION_INSERT_SYMBOL ( :0 4_INPUT_GATE )

EQUATION_DELETE_SYMBOL ( :1 )

DELETE_PROPERTY ( 4_INPUT_GATE form )

ADD_PROPERTY ( 4_INPUT_GATE form = CALCULATED )

ADD_PROPERTY ( 4_INPUT_GATE cost = 0.75 )

DECLARE_COST ( 4_INPUT_GATE cost )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Use 4 input OR gate for ‘

4_INPUT_GATE.input_0 4_INPUT_GATE.input_1 4_INPUT_GATE.input_2

4_INPUT_GATE.input_3 ‘ ) ‘ )

DELETE_PROPERTY ( 4_INPUT_GATE input_0 )

DELETE_PROPERTY ( 4_INPUT_GATE input_1 )

DELETE_PROPERTY ( 4_INPUT_GATE input_2 )

DELETE_PROPERTY ( 4_INPUT_GATE input_3 )

}

result ADD_OUTPUT_TO_LIST {

COPY_SET ( V0 OUTPUT )

FIND ( OUTPUT output SET_NAME V0 )

EQUATION_DELETE_SYMBOL ( :0 )

ADD_PROPERTY ( OUTPUT form = CALCULATED )

ADD_PROPERTY ( OUTPUT cost = 0.05 )

DECLARE_COST ( OUTPUT cost )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Connect output for ‘

OUTPUT.output ‘ ) ‘ )

}

result KILL_SINGLE_TERM {

COPY_SET ( V0 OUTPUT )

FIND ( OUTPUT output SET_NAME V0 )

FIND ( OUTPUT terminal THIS_PART )

EQUATION_DELETE_SYMBOL ( :0 )

PLAN_PUSH_FORMAT ( ‘ DESCRIPTION ( Connect gate output ‘

OUTPUT.output ‘ to output ‘ OUTPUT.terminal ‘ ) ‘ )

}

Figure 12.8 Rules For Converting a Digital Design to Gate Embodiment

For the sake of brevity, the rules only used OR gates, but these are sufficient to implement the design. These rules were applied to the design to get the following process plan for connecting the circuit.

-------- Work Order Sheets ------------

Product: decade_to_binary

OPERATION SUMMARY_SHEET: D_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

0 Connect gate output 2_INPUT_GATE_5 to output D_OP5

10 Use 2 input OR gate for 2_INPUT_GATE_3 I10

Output is 2_INPUT_GATE_5

20 Use 2 input OR gate for I8 I9

Output is 2_INPUT_GATE_3

OPERATION SUMMARY_SHEET: C_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

1000 Connect gate output 2_INPUT_GATE_12 to output C_OP12

1010 Use 2 input OR gate for 2_INPUT_GATE_10 I7

Output is 2_INPUT_GATE_12

1020 Use 2 input OR gate for 2_INPUT_GATE_8 I6

Output is 2_INPUT_GATE_10

1030 Use 2 input OR gate for I4 I5

Output is 2_INPUT_GATE_8

OPERATION SUMMARY_SHEET: B_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

2000 Connect gate output 2_INPUT_GATE_21 to output B_OP21

2010 Use 2 input OR gate for 2_INPUT_GATE_19 I10

Output is 2_INPUT_GATE_21

2020 Use 2 input OR gate for 2_INPUT_GATE_17 I7

Output is 2_INPUT_GATE_19

2030 Use 2 input OR gate for 2_INPUT_GATE_15 I6

Output is 2_INPUT_GATE_17

2040 Use 2 input OR gate for I2 I3

Output is 2_INPUT_GATE_15

OPERATION SUMMARY_SHEET: A_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

3000 Connect gate output 2_INPUT_GATE_30 to output A_OP30

3010 Use 2 input OR gate for 2_INPUT_GATE_28 I9

Output is 2_INPUT_GATE_30

3020 Use 2 input OR gate for 2_INPUT_GATE_26 I7

Output is 2_INPUT_GATE_28

3030 Use 2 input OR gate for 2_INPUT_GATE_24 I5

Output is 2_INPUT_GATE_26

3040 Use 2 input OR gate for I1 I3

Output is 2_INPUT_GATE_24

OPERATION SUMMARY_SHEET: decade_to_binary_PART: Quantity 1.000000

OP# Operation Description

------------------------------------------

4000 Connect output for D_PART

4010 Connect output for C_PART

4020 Connect output for B_PART

4030 Connect output for A_PART

Figure 12.9 A Process Plan for Circuit Construction

This process plan is a bit naive, but it does allow construction of the part automatically. Some points of interest in this case are,

the operations to produce the part are reversed. This is not a large problem, but indicates that some problems are not necessarily suited to backwards planning,

two input OR gates have been chosen, as opposed to 3 or 4 input gates. This is the result of a search routine that only considers the cheapest operation first. A more extensive search routine would do a more cost based approach to planning,

the system was easily able to track inputs and outputs to gates, and generate unique identifiers to minimize confusion.

This example illustrates that the BCAPP approach is truly multi-domain, and is able to be extended to a number of problems.

12.6 Conclusion

This section outlined a number of successful examples for process planning, including machining, assembly, embossing, forming, and electrical assembly. Some problems were indicated in terms of design representation, sequencing, planning approach, cost optimization, and the need for geometrical modeling.

The various machined parts were planned successfully, and indicated that the planner would work well for a single process domain. The addition of multiple process domains increased the challenge to the planner. This example clearly showed the shortcoming of the method by suggesting that a drilling operation be used for a hole that is only half embedded in the workpart (and would cause drill bit deflection). In addition, this example demonstrated the planners ability to deal with complex shapes (the spring). The planner was also capable of recognizing the symmetry of two parts, and it produced them in batches of two, instead of as two separate parts. Finally the process plan included a printing operation, that would effectively have no geometrical significance, but be of great importance to the value of the final product.

The digital circuit example illustrated that the planner was also capable of doing innovative planning problems. But, the plan for the selection and assembly of the circuit was reversed in order. This in itself is not significant, but it does indicate that the planner requires more study.

12. Test Cases

The Plan File for the Rod Support Mount (cont’d)