Patent Publication Number: US-5835781-A

Title: Break-away key for electronic circuitry

Description:
This is a continuation, of application Ser. No. 07/947,323 filed Sep. 18, 1992, now abandoned. 
    
    
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The invention relates generally to electronic circuitry of the type mounted on circuit boards and more particularly to apparatus for selecting one of several available modes of operation for such circuitry. 
     2. Description of the Background Art 
     Circuit boards have been manufactured with break-away portions. Campisi, No. 5,023,726 shows circuit boards being broken apart during the manufacturing of circuitry for a TV set. In a similar vein, UK Patent Application GB 2 160 366A shows a break-out portion which becomes a separate small circuit board connected by a ribbon connector to a main circuit board. 
     Circuit boards have included portions which could be removed to change the connections and certain functions on a circuit board. Harford, U.S. Pat. No. 4,216,523 describes a portion of a circuit that can be removed when circuitry is defective. Zernov, U.S. Pat. No. 4,985,808, shows a break-away tab for selecting a different impedance. Rovin, No. 5,049,728, shows parts which are removed to change the interconnection of circuit paths on a circuit board. 
     Freeman, No. 4,670,749, shows that the state of certain switching elements can be controlled by data in a memory to connect certain conductors in a circuit board. Freeman does not place the memory or the switching elements on a break-away section of the board. 
     In certain instances, it may be desirable to provide a microprocessor-based electronic circuit with one set of functions for one type of end user and another set of functions for another type of end user. The manufacturer may desire to control the function of the circuit board while limiting the end user&#39;s control over changes in the function of the circuit board. In such situations, it also important that the manufacturer&#39;s intent not be defeated or reversed. 
     SUMMARY OF THE INVENTION 
     The invention is incorporated in an electronic circuit board with a break-away portion and a processor which is programmed to recognize whether the break-away portion is present or broken away. The break-away portion has a physical and electrical arrangement which secures the electronic circuit board against tampering to defeat the break-away operation. The break-away portion with its electrical arrangement functions as a tamper-resistant key. 
     More specifically, the invention is embodied in an electronic module including a circuit board with a main portion, including a microelectronic processor on the main portion. A break-away portion carries one or more identification signals in a predetermined logic state and the main portion has a corresponding status register which is addressable by the microelectronic processor. 
     The microelectronic processor executes instructions for carrying out user-programmed functions. The microelectronic processor executes further instructions to address the break-away portion to read the one or more predetermined identification signals. The microelectronic processor executes further instructions that are responsive to the absence of the one or more identification signals in the predetermined logic state for limiting execution of instructions for carrying out user-programmed functions. 
     The circuit is designed to prevent tampering by imbedding the circuit paths which carry the identification signals in a multi-layered circuit board. The signals traverse a boundary of frangible links at a plurality of different levels and may be interconnected between levels or dead-ended on the break-away portion. The break-away portion is covered by foil masks on the top and bottom to prevent observation of the circuit patterns on the break-away portion. The break-away portion forms a key to the operation of the circuit. If it is present, the circuit will operate in one mode; if it is absent, the circuit will operate in another mode. 
     Other objects and advantages, besides those discussed above, will be apparent to those of ordinary skill in the art from the description of the preferred embodiment which follows. In the description, reference is made to the accompanying drawings, which form a part hereof, and which illustrate examples of the invention. Such examples, however, are not exhaustive of the various embodiments of the invention, and, therefore, reference is made to the claims which follow the description for determining the scope of the invention. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIGS. 1 and 1a are plan views of a circuit board and break-away portion of the present invention; 
     FIG. 2 is an exploded view in perspective of the break-away portion of the circuit board of FIG. 1; and 
     FIG. 3a-3g are a series of plan views of the layers of the break-away portion seen in FIG. 2; 
     FIG. 4 is a block diagram of the circuitry on the circuit board of FIG. 1; and 
     FIG. 5 is a flow chart of program instructions executed by the processor on the circuit board of FIG. 1. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     Referring to FIG. 1, the invention is incorporated in an electronic circuit board module 10 having circuit packages 11 mounted on circuit board 12. The packages 11 are interconnected by printed circuit paths known as traces 13 (seen in FIG. 3b). The circuit board 12 has a rectangular break-away section 14 forming a key and bounded by a drill pattern of slots and holes which create a series of frangible links 21 along a boundary 29 between the break-away section 14 and a main portion 15 of the circuit board 12. As seen in FIG. 3a, the drill pattern includes a first, L-shaped slot 16, a first series of holes 17, a second, straight slot 18, a second series of holes 19 and a third, L-shaped slot 20. When it is desired to remove section 14 the remaining thin, frangible portions 21 along the line 29 of the drill pattern are fractured to separate the break-away section 13. 
     As seen in FIGS. 2, 3a-3g, circuit board 10, including the break-away portion 14, is a layered construction with eight surfaces on seven substrate layers 22-28 that carry circuit patterns or traces 13. A number of &#34;through holes&#34; 30 are seen in all layers, and these are used to make connections of circuit paths 13 on different layers 22-28. On the main portion 15 of circuit board 12, the center layer carries power and ground lines on opposite surfaces, but these do not extend to substrate 25 of the break-away section 14, so no circuitry is seen on substrate 25 in FIGS. 2 and 3d. The next two upper substrate layers 23-24 carry circuit paths 13 on their top surfaces. The next two lower substrate layers 26-27 carry circuit paths 13 on their bottom facing surfaces. The uppermost substrate layer 22 has a rectangular patch of metal foil 31 adhered to its top surface and lowermost substrate layer 28 has a rectangular patch of metal foil 32 adhered to its bottom surface. As seen in FIGS. 3a and 3g, the foil masks 31, 32 cover most of the area of the other layers 22-28 and prevent visibility through the circuit board 12 which would disclose the pattern and interconnections of the traces 13 disposed between the top and bottom layers 22-28. In some instances connections are made from one layer to another through the through holes 30. 
     As seen in FIGS. 3a-3g and 4, twelve circuit paths 13 traverse the circuit boundary. Two pairs of these circuit paths 33-34 and 36-37 are illustrated as forming a complete loop or circuit to and from the main portion 15 of the circuit board 12. One pair of circuit paths 33-34 connects to a pull-up resistor circuit 35 on the main portion 15 of circuit board 12 which will transmit a logic &#34;1&#34; or high signal when the break-away section 14 is intact. Another pair of circuit paths 36-37 connects to a pull-down resistor circuit 38 on the main circuit board, which will transmit a logic &#34;0&#34; or low signal when the break-away section 14 is intact. 
     Circuit paths 39-46 are illustrated as dead-ended on break-away section 14, but these circuit paths 39-46 could also be dead-ended or interrupted on the main portion 15 of the circuit board 12. Circuits 84-87 are optional pull-up and pull-down circuits, which if connected through the break-away section 14, will generate four additional logic signals on lines 40, 42, 43 and 45. 
     In addition to pull-up resistor circuit 35 and pull-down resistor circuit 38, lines 34, 40, 42, 43, 45 and 36 are also connected to pull-up resistor circuits 35&#39; and 38&#39; on the main portion 15 of circuit board 12. These pull-up circuits 35&#39; and 38&#39; are pulled up to a voltage V1 which is smaller than voltage V2 of pull-up circuit 35. Thus, the greater magnitude of signal generated by circuit 35 controls the level of the logic signal on line 34. Similarly, circuit 38 controls the level of logic signal on line 34. On the other hand, if circuits 35 and 38 were not connected to lines 34 and 36, the voltage from circuits 35&#39; and 38&#39; would pull these lines to a predetermined logic level. With logic circuits 84-87 not connected, the logic signals on lines 40, 42, 43 and 45 are controlled by pull-up circuits (not shown) on the main portion 15 of the circuit board 12, similar to the operation of circuits 35&#39; and 38&#39;. 
     Circuit paths 34, 40, 42, 43, 45 and 36 connect to inputs on logic gates 47 in programmable logic circuit 48. Logic gates 47 sense the combined logic state of signals on those lines and produce a resulting output signal (LOGIC OUT) representing the state of signals on all lines coming from the break-away section 14 of the electronic circuit board 12. The LOGIC OUT signal is transmitted from the output of logic gates 47 and is stored in a register 49 in a gate array 50. It will be apparent to those skilled in the art that logic gates 47 are not necessary and only one path 34 or 36 need be utilized to signal presence or absence of the break-away section 14. The additional lines and signals are utilized to provide more complex bit patterns and more circuit paths on the break-away section 14. 
     As further seen in FIG. 4, a microelectronic CPU 60 is connected through address bus 51, data bus 52, control bus 53, and appropriate bus buffering and address latching circuits (not shown) to decoding circuitry 54 in the gate array 50. The address and control signals are decoded by circuitry 50 to generate an enable signal to register 49 so that data can be read on data bus 52. The microelectronic CPU 60 is preferably a Motorola 68030 series CPU. The CPU 60 connects through buses 51-53 to a programmable read only memory (PROM) 55 and to a random access memory (RAM). A program of firmware instructions 56 is stored in object code in PROM 55. The RAM 56 stores data generated by program execution and also stores a user control program 58. 
     The source code for certain firmware instructions 56 relevant to the invention, is included in Appendix A and illustrated in the flow chart shown in FIG. 5. As seen there, there is a routine &#34;AXES CHECK&#34; which starts with start block 72. Sometime prior to this routine being called, the microelectronic CPU 60 executes instructions represented by block 70 to address the register 49 and read data representing the LOGIC OUT signal and also the status of a battery. Before the CPU 60 executes a next command or move block in user program 58 in FIG. 4, it executes instructions as represented by decision block 71 to test several bits including a break-away bit which represents the logic state of the LOGIC OUT signal. If this bit is a logically true or &#34;on&#34;, the AXES CHECK routine is executed. This signal indicates that the break-away section 14 has been removed. When this happens, the function of the CPU 60 will be limited in executing other instructions in the user control program 58. 
     If the break-away bit is not &#34;on&#34; as represented by the &#34;NO&#34; result from decision block 71, the processor skips the AXES CHECK routine as represented by process block 73. In the case of a &#34;YES&#34; result from executing decision block 71, the AXES CHECK routine will be executed next, as represented by start block 72. After detecting the break-away condition in decision block 71, a test is made to see if there are any moving axes in the next block of the user program 58, as represented by decision block 74. If motion along an axis has not been commanded or requested by the &#34;NO&#34; result, then the CPU 60 skips the remaining instructions in the routine and proceeds to return block 81 to end the routine. 
     If there are moving axes as represented by the &#34;YES&#34; result from decision block 74, then further instructions are executed, as represented by decision block 75, to see if a pair of axes has been grouped as Axis Group 0. If the result from this test is &#34;YES&#34;, then dual slave axes are present and one of these must be subtracted from the total moving axes count, as represented by process block 76. After executing this procedure, or in the case when there is no Axis Group 0, the routine proceeds to check for Axis Group 1, as represented by decision block 77. If this Axis Group is present as represented by the &#34;YES&#34; result, then the axes count is again reduced by one to account for the dual slave axes as represented by process block 78. After this procedure has been completed, or if no &#34;Axis Group 1&#34; is detected in decision block 77, the CPU 60 executes further instructions, represented by decision block 79, to compare the number of commanded moving axes with an axes limit. If the number of moving axes is greater than the axes limit, as represented by the &#34;YES&#34; result from decision block 79, the CPU 60 will not execute the block of the user program 58 and will display an error message as represented by process block 80. The error message is displayed on a visual display 83 which may be in a piece of equipment connected to the electronic module 10 through a serial port 82 in FIG. 4. 
     Where the number of moving axes in the user program block is less than the limit, as signified by the &#34;NO&#34; result in decision block 79, the AXES CHECK routine is completed and the CPU 60 returns to complete execution of the user program block or proceeds to the next block in the user program 58. 
     It can be seen from this description that where the section 14 is broken away from the circuit board 12, the CPU 60 will be limited in its execution of instructions in the higher-level user program 58. Where the break-away bit is &#34;off&#34; in decision block 71 because the appropriate signals have been received at logic gate 47 to generate the appropriate LOGIC OUT signal, the CPU will continue to execute motion blocks in the user program 58, without an axes limitation. Such a procedure is also applicable to other types of functions besides number of axes which may be controlled by the manufacturer of the module 10 using the apparatus and method of the present invention 
     This description has been by way of example and various details may be modified in arriving at other detailed embodiments of the invention. Therefore, to apprise the public of the scope of the invention and the embodiments covered by the invention, the following claims are made. 
     NOTICE 
     This program listing is an unpublished work in which copyright protection is claimed by Allen-Bradley Company, Inc. If publication of this work should occur, the following notice shall apply: 
     © 1992 Allen-Bradley Company, Inc. 
     
         __________________________________________________________________________
2.0 Approach                                                              
use the following two elements in the setup buffer. For each motion       
block, use these two axes bit patterns to count the total number of       
interpolated Axes during setup stage 2. If the total is greater than      
four (4), cycle stop with a decode error.                                 
struct Setup.sub.-- Buff {                                                
.                                                                         
.                                                                         
short mvng.sub.-- axis.sub.-- btptrn; /* (1) bit pattern of the moving    
axis */                                                                   
master dual axis ALWAYS included                                          
includes a dual slave axis if LINEAR move                                 
does not include PAL axis                                                 
.                                                                         
.                                                                         
.                                                                         
short mvng.sub.-- dual.sub.-- axes(2); /* (0s) bit pattern of moving dual 
axes */                                                                   
includes both master and slave axes                                       
3.0 C Code - one routine called from setup stage 2 if the hardware        
signal                                                                    
indicates the COCOM tab has been broken.                                  
.                                                                         
.                                                                         
.                                                                         
/* If the COCOM bit is true; check for compliance */                      
if (Battery.sub.-- test &amp; 0x08)                                           
{                                                                         
cocom.sub.-- axes.sub.-- check( );                                        
}                                                                         
.                                                                         
.                                                                         
.                                                                         
/*************************************************************************
***/                                                                      
/*                                                                        
  NAME:                                                                   
       cocom.sub.-- axes.sub.-- check( )                                  
                                       */                                 
/*                                     */                                 
/*                                                                        
  DESCRIPTION:                                                            
           This routine checks for COCOM compliance. If the               
                                       */M                                
/*         breakout is true, there can be a maximum of four               
                                       */                                 
/*         concurrent interpolated Axes. Pal Axes are not                 
                                       */uded,                            
/*         and duals (one master with multiple slaves) count as           
                                       */                                 
/*         A Split/Skewed pair also count as one axis.                    
                                       */                                 
/*                                     */                                 
/*                                                                        
  RETURN VALUE:                                                           
           none                        */                                 
/*************************************************************************
***/                                                                      
void cocom.sub.-- axes.sub.-- check( )                                    
{                                                                         
short axis.sub.-- mask;                                                   
              /* axis bit mask         */                                 
short cocom.sub.-- axes;                                                  
              /* count of concurrent cocom moving axes                    
                                       */                                 
short da.sub.-- slaves.sub.-- mvng;                                       
              /* dual slave axes moving                                   
                                       */                                 
short i;      /* loop counter          */                                 
short mvng.sub.-- axis.sub.-- btptrn;                                     
              /* bit pattern of moving axes; includes                     
                                       */                                 
              /* dual slave axes on LINEAR moves . . .                    
                                       */                                 
register struct Setup.sub.-- Buff                                         
              *set.sub.-- ptr;                                            
                   /* use register for speed                              
                                     */                                   
/************************************************************************ 
.                                                                         
 *  copy Stg2.sub.-- intrf.sub.-- ptr to register; get total bit pattern  
    of mvng axes                                                          
 ************************************************************************/
7                                                                         
 set.sub.-- ptr = Stg2.sub.-- intrf.sub.-- ptr;                           
 mvng.sub.-- axis.sub.-- btptrn = ste.sub.-- ptr-&gt;mvng.sub.-- axis.sub.-- 
btptrn;                                                                   
/************************************************************************ 
N                                                                         
 *  only do the COCOM checks if a motion block. Note that mvng.sub.--     
    axis.sub.-- btptrn                                                    
 *  does NOT contain Split/Skewed slave Axes, Pal Axes, or dual           
    non-linear                                                            
 *  slaves.                                                               
 ************************************************************************/
O                                                                         
 if (mvng.sub.-- axis.sub.-- ptptrn)                                      
 {                                                                        
/**********************************************************************   
 *   check for moving dual group one; remove dual slave axes from axis    
     bits                                                                 
 **********************************************************************/  
 if (set.sub.-- ptr-&gt;mvng.sub.-- dual axes 0!)                            
 {                                                                        
da.sub.-- slaves.sub.-- mvng = set.sub.-- ptr-&gt;mvng.sub.-- dual.sub.--    
axes 0! &amp;                                                                 
           ˜FGDATA.sub.-- ptr-&gt;da.sub.-- current1.sub.-- master;    
mvng.sub.-- axis.sub.-- btptrn &amp;= ˜da.sub.-- slaves.sub.-- mvng;    
 }                                                                        
/**********************************************************************   
 *   check for moving dual group two; remove dual slave axes from axis    
     bits                                                                 
 **********************************************************************/  
 if (set.sub.-- ptr-&gt;mvng.sub.-- dual.sub.-- axes 1!)                     
 {                                                                        
da.sub.-- slaves.sub.-- mvng = set.sub.-- ptr-&gt;mvng.sub.-- dual.sub.--    
axes 1!&amp;                                                                  
           ˜FGDATA.sub.-- ptr-&gt;da.sub.-- current2.sub.-- master;    
mvng.sub.-- axis.sub.-- btptrn &amp;= ˜da.sub.-- slaves.sub.-- mvng;    
 }                                                                        
/**********************************************************************   
 *   count the number of moving axes. If more than allowed by COCOM -     
     (4)                                                                  
 *   force a decode error.                                                
 **********************************************************************/  
 cocom.sub.-- axes = 0;                                                   
 for (i = 0, axis.sub.-- mask = 1; i &lt; set.sub.-- ptr-&gt;num.sub.--         
rv.sub.-- axes; i++, axis.sub.-- mask &lt;&lt;=1)                               
 }                                                                        
if (mvng.sub.-- axis.sub.-- btptrn &amp; axis.sub.-- mask)                    
{                                                                         
cocom.sub.-- axes++;                                                      
}                                                                         
 {                                                                        
 if (cocom.sub.-- axes &gt; 4)                                               
 }                                                                        
intrf.sub.-- 2.sub.-- error(DE.sub.-- COCOM.sub.-- AXES.sub.-- EXCEEDED); 
N                                                                         
 }                                                                        
 }                                                                        
}                                                                         
__________________________________________________________________________