home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 September / pcwk_09_96.iso / demo / elmark / cupl / manual / ug3.txt < prev    next >
Text File  |  1992-01-17  |  17KB  |  402 lines
  1. .C1.GETTING STARTED               U3
  2.  
  3.     This chapter assumes that the user has had some experience with 
  4.     programming devices.  A basic understanding of logic and logic 
  5.     gates, and how they relate to the design of programmed devices, is 
  6.     required.
  7.  
  8. o.c2.   FIRST STEPS
  9.         Examine the Design Task
  10.            Take a close look at the design that is needed. Remember that 
  11.            state-machine, Boolean equations, or truth tables are 
  12.            available for the design. Try to determine which type of 
  13.            syntax best suits the design task that is being worked on.
  14.  
  15.         Create the CUPL Source File
  16.            Use the template file provided and remove the sections that 
  17.            do not apply.  Remember to edit the header to reflect the new 
  18.            file that is being created.
  19.  
  20.         Formulate the Equations
  21.            Equations must be written in CUPL syntax to specify the logic 
  22.            desired.  This can be in Boolean, state-machine, or truth 
  23.            table format.
  24.  
  25.         Choosing a Target Device
  26.            Make sure that there is a sufficient number of input 
  27.            pins.
  28.  
  29.            Check that the number of registered and non-registered output 
  30.            pins is sufficient for the design.
  31.  
  32.            Ensure that the device has three-state output control, if you 
  33.            need it.
  34.  
  35.            Check that the device can adequately handle the number of 
  36.            product terms required.
  37.  
  38.         Making Pin Assignments
  39.            Assign the inputs and outputs of the design to the pins of 
  40.            the device. Make sure that the device is being used properly 
  41.            by consulting the reference material available from the 
  42.            manufacturer.
  43.  
  44.         Running CUPL
  45.            Decide which file formats will be needed for downloading and 
  46.            simulation.  A choice of four minimizers is available 
  47.            (M1-M4). CUPL will use M1 minimization if none is specified. 
  48.            See Chapter 1 "CUPL Language" for details.
  49.  
  50.            The device library which CUPL will use may be specified when 
  51.            the compiler is invoked. CUPL will use the library defined in 
  52.            the environment variable 'LIBCUPL' if none is specified. See 
  53.            Chapter U2 "Installation" for more information on LIBCUPL.
  54.  
  55. o   .c2.SIMPLE LOGIC DESIGN
  56.     The Subway Turnstile controller is the simplest state machine 
  57.     design. This controller waits for a signal that a coin has been 
  58.     deposited.  It then changes its state from locked to open. In the 
  59.     open phase, it waits for someone to walk through the turnstile, then 
  60.     it changes from open to locked. This two-state design cycles between 
  61.     open and locked using a coin detector and a walk-through detector as 
  62.     inputs.  The following diagram shows the states and the pulses that 
  63.     change the device from one state to the next.
  64.  
  65.     [Picture]
  66.      Figure U3-1. Subway Turnstile Example
  67.  
  68.     The corresponding CUPL state machine code is displayed on the right, 
  69.     so that the relationship between the code and the design concept is 
  70.     easily understood.
  71.  
  72.     ------------------------------------------------------------
  73.                    TURNSTIL.PLD
  74.        Name            Turnstil;
  75.        Partno          FL00001;
  76.        Date            03/06/89;
  77.        Designer        R. Teixeira;
  78.        Company         LDI;
  79.        Location        D21;
  80.        Assembly        Example
  81.  
  82.        /******************************************************/
  83.        /*                                                    */
  84.        /* This is an example to demonstrate how  CUPL        */
  85.        /* compiles a subway turnstile controller             */
  86.        /*                                                    */
  87.        /******************************************************/
  88.        /*  Target Devices: P16R4                             */
  89.        /******************************************************/
  90.  
  91.        /* Inputs:  define inputs to Turnstile controller   */
  92.        Pin 1 = CLK;
  93.        Pin 2 = WALK_THRU;
  94.        Pin 3 = COIN;
  95.  
  96.        /* Outputs:  define outputs as active HI levels 
  97.         ............................... */ 
  98.         Pin 14 = CNT_PULSE; 
  99.         Pin 15 = LOCK;
  100.  
  101.        /* Logic: Subway Turnstile example expressed in CUPL */
  102.         $DEFINE LOCKED  'b'0
  103.         $DEFINE OPEN    'b'1
  104.  
  105.         Sequence LOCK{
  106.         Present LOCKED
  107.            if COIN    Next OPEN;
  108.            if !COIN   Next LOCKED;
  109.         Present OPEN
  110.            if WALK_THRU Next LOCKED;
  111.            Default     Next OPEN;
  112.            Out CNT_PULSE;
  113.        }
  114.     ------------------------------------------------------------
  115.      Figure U3-2.  TURNSTIL.PLD
  116.  
  117. o   .c2.SIMPLE GATES EXAMPLE
  118.     This section will explain in detail the creation of a simple gates 
  119.     program for a PLD.  The following diagram shows what design will be 
  120.     implemented. This design is taken from the Chapter U5 "Design 
  121.     Examples".
  122.  
  123.           [Picture]
  124.      Figure U3-3. Simple Gates
  125.  
  126.     This design gives a simple set of inputs and generates output 
  127.     simulating some simple gates. The outputs are labeled to reflect the 
  128.     function of their gate; for example, the AND gate has an output 
  129.     labeled AND.
  130.  
  131.     Figure U3-4 shows the CUPL source file (GATES.PLD provided in the 
  132.     CUPL package) that describes the design.
  133.  
  134.     ------------------------------------------------------------
  135.                                GATES.PLD
  136.        Name            Gates;
  137.        Partno          CA0001;
  138.        Date            07/16/87;
  139.        Designer        G Woolheiser;
  140.        Company         ATI;
  141.        Location        San Jose, CA.;
  142.        Assembly        Example
  143.  
  144.        /******************************************************/
  145.        /*                                                    */
  146.        /* This is an example to demonstrate how  CUPL        */
  147.        /* compiles simple gates      .                       */
  148.        /*                                                    */
  149.        /******************************************************/
  150.        /*  Target Devices: P16L8, P16P8, EP300,   and 82S153 */
  151.        /******************************************************/
  152.  
  153.        /* Inputs:  define inputs to build simple   gates     */
  154.        Pin 1 = a;
  155.        Pin 2 = b;
  156.  
  157.        /* Outputs:  define outputs as active HI levels
  158.  
  159.          For PAL16L8 and PAL16LD8, De Morgan's  Theorem is
  160.          applied to invert all outputs due to fixed inverting buffer in 
  161.          the device.  */
  162.  
  163.        Pin 12 = inva;
  164.        Pin 13 = invb;
  165.        Pin 14 = and;
  166.        Pin 15 = nand;
  167.        Pin 16 = or;
  168.        Pin 17 = nor;
  169.        Pin 18 = xor;
  170.        Pin 19 = xnor;
  171.  
  172.        /* Logic:  examples of simple gates
  173.        expressed in CUPL */
  174.  
  175.        inva = !a;             /* inverters      */
  176.        invb = !b;
  177.        and = a & b;           /* and gate       */
  178.        nand = !(a & b);       /* nand gate       */
  179.        or  = a # b;           /* or gate       */
  180.        nor = !(a # b);        /*nor gate       */
  181.        xor = a $ b;           /*exclusive or gate       */
  182.        xnor = !(a $ b);       /*exclusive nor gate       */
  183.     ------------------------------------------------------------
  184.     Figure U3-4.  Simple Gates Source File (GATES.PLD)
  185.  
  186.     The first part of the file provides archival information and a 
  187.     description of the intended function of the design, including 
  188.     compatible PLDs.  First, there is the 'Name' line, which CUPL uses 
  189.     to name the output files by adding extensions.
  190.  
  191.     'Partno' specifies the Company's proprietary part number, issued by 
  192.     manufacturing, for a particular PLD design.  The part number is not 
  193.     the type of the target PLD.
  194.  
  195.     'Date' is used to specify the date of compilation. The date should 
  196.     be changed to the current date as a good documentation practice.
  197.  
  198.     'Designer' should be the designer's name or the name of the design 
  199.     team.
  200.  
  201.     'Assembly' is used to specify the assembly name or number of the PC 
  202.     board on which the PLD will be used.  Use the abbreviation ASSY if 
  203.     desired.
  204.  
  205.     'Location' is supposed to be used to indicate the PC board reference 
  206.     or coordinate where the PLD is located.  The abbreviation LOC may 
  207.     also be used. This may be used for other purposes.
  208.  
  209.     Pin declarations are made corresponding to the inputs and outputs in 
  210.     the design diagram.  The gates in this example require two inputs, 
  211.     which are passed through the gates as necessary.  'a' and 'b' are 
  212.     names for the input pins. Next, names are assigned to the output 
  213.     pins.  The names chosen are descriptive of the function being 
  214.     performed.  The use of descriptive names is encouraged, as it makes 
  215.     files easier to debug and update at a later time.
  216.  
  217.     In the "Logic" section of the file, equations describe each of the 
  218.     gates in the design.  Boolean syntax is used to specify each output 
  219.     pin as a function of the input pins 'a' and 'b'.  For the PAL16L8 
  220.     and PAL16LD8 devices, which contain fixed inverting buffers, CUPL 
  221.     applies
  222.  
  223.     DeMorgan's Theorem to invert all outputs because they were all 
  224.     declared active-HI in the pin list.  For example, during 
  225.     compilation, CUPL converts the following equation for an OR gate, on 
  226.     an output pin that has been declared as active-HI:
  227.  
  228.         or = a # b ;
  229.  
  230.     to the following single expanded product term (as shown in the 
  231.     documentation file):
  232.  
  233.         or => !a & !b
  234.  
  235.     The devices chosen for this design were selected because they fit 
  236.     the criteria, as specified earlier, for choosing a device.  They 
  237.     have an adequate number of pins, both input and output.  They have 
  238.     .i.tri-state control;tri-state control. The number of registered and 
  239.     non-registered pins fits our design, and the device can handle the 
  240.     number of product terms.
  241.  
  242. o   .c2.COMPILING THE SOURCE FILE
  243.     At the system prompt, type:
  244.  
  245.         cupl -x P16L8 gates
  246.  
  247.     This will execute CUPL.  The '-x' means to generate a documentation 
  248.     file (GATES.DOC) so that the expanded listing generated by CUPL may 
  249.     be viewed. The target device is a PAL16L8 and the source file is 
  250.     GATES.PLD.  After running CUPL, open the file GATES.DOC, which has 
  251.     the expanded listing generated by CUPL.  This shows how CUPL expands 
  252.     the logic equations when it compiles the design for the device 
  253.     chosen.
  254.  
  255.     In order to see how CUPL reports errors, edit the source file 
  256.     GATES.PLD and remove the semicolon at the end of one of the 
  257.     assignment statements.  Now run CUPL as follows:
  258.  
  259.         cupl -l P16L8 gates
  260.  
  261.     After it has finished, take a look at the file GATES.LST to see how 
  262.     CUPL reports errors.  Notice that an error line appears next to the 
  263.     error, and there are line numbers at the beginning of each line.
  264.  
  265. o     .c2.SIMULATING A   DESIGN
  266.     Now the design will be simulated  using CSIM. Test vectors must be 
  267.     created for the simulator to function. Test vectors specify the 
  268.     expected functional operation of a PLD by defining the outputs as a 
  269.     function of the inputs. Test vectors are also used to do functional 
  270.     testing of a device once it has been programmed, to see if the 
  271.     device functions as expected.
  272.  
  273.     CSIM needs a test specification source file. For this example, it 
  274.     will be called GATES.SI. This file has a description of the function 
  275.     of the device in the circuit.
  276.  
  277.     CSIM compares the input pin and output pin test values in the 
  278.     GATES.SI file, as shown in figure U3-5, with the actual values that 
  279.     are calculated from the logic equations in the absolute file 
  280.     GATES.ABS created by CUPL when the '-a' option is used.  CSIM will 
  281.     not work unless the GATES.ABS file is created.  To create the file 
  282.     GATES.ABS, type:
  283.  
  284.     CUPL -a p16l8 gates    [Enter]
  285.  
  286.     If the results are to be used for simulation, add the J option so 
  287.     that the test vectors will be added to the JEDEC file.
  288.  
  289.     CUPL -aj p16l8 gates[Enter]
  290.  
  291.      ------------------------------------------------------------
  292.         Name           Gates;
  293.         Partno       000000;
  294.         Revision       03;
  295.         Date       9/12/83;
  296.         Designer       CUPL       Engineering;
  297.         Company        Logical       Devices, Inc.;
  298.         Location       None;
  299.         Assembly       None;
  300.         /****************************************************************/
  301.         /*       */
  302.         /*     This is a example to demonstrate how CUPL              */
  303.         /*     compiles       simple gates.       */
  304.         /*       */
  305.         /****************************************************************/
  306.         /*     Target Devices: P16L8, P16LD8, P16P8, EP300, and   82S153*/
  307.         /****************************************************************/
  308.         /* Order:  define order, polarity, and output    */
  309.         /* spacing of stimulus and response     values   */
  310.  
  311.         Order: a, %2, b, %4, inva, %3, invb, %5, and, %8, nand, %7, or, 
  312.               %8, nor, %7, xor, %8, xnor; 
  313.  
  314.         /* Vectors: define stimulus and response values, with header */
  315.         /*   and intermediate messages for the simulator listing     */
  316.         /* Note:  Don't Care state (X) on inputs is reflected in */
  317.         /* outputs where appropriate.   */
  318.         Vectors:$msg "";
  319.         $msg "       Simple Gates Simulation";
  320.         $msg "";
  321.         $msg "inverters and     nand    or     nor       xor     xnor 
  322.         $msg "a b  !a !b  a & b !(a & b) a # b !(a # b) a $ b !(a$b)";
  323.         $msg "- -  -- --  ----- --------  ----- ------- ----- ------";
  324.         00 HHLHLHLH
  325.         01 HLLHHLHL
  326.         10 LHLHHLHL
  327.         11 LLHLHLLH
  328.         1X LXXXHLXX
  329.         X1 XLXXHLXX
  330.         0X HXLHXXXX
  331.         X0 XHLHXXXX
  332.         XX XXXXXXXX
  333.      ------------------------------------------------------------
  334.      Figure U3-5. Gates Simulator Input File (GATES.SI) 
  335.  
  336.      To run the simulator for the simple gates example, type the 
  337.      following:
  338.  
  339.     CSIM -w P16L8 gates [Enter]
  340.  
  341.     The waveform output is available for the DOS version of CUPL only. 
  342.     For UNIX, VMS and all other versions, the only output available is
  343.     the simulator output file. Figure U3-6 shows the simulator output 
  344.     file.  The inputs are listed with the corresponding outputs.
  345.  
  346.      ------------------------------------------------------------
  347.        1:Name           Gates; 
  348.        2:Partno 000000; 
  349.        3:Revision       03; 
  350.        4:Date 9/12/83; 
  351.        5:Designer       CUPL Engineering; 
  352.        6:Company        Logical Devices, Inc.; 
  353.        7:Location       None; 8:Assembly       None;
  354.        9:
  355.        10:/****************************************************************/
  356.        11:/*       */
  357.        12:/*     This is a example to  demonstrate how CUPL              */
  358.        13:/*     compiles simple gates.      */
  359.        14:/*       */
  360.        15:/****************************************************************/
  361.        16:/*       Target Devices: P16L8, P16LD8, P16P8,EP300, and 82S153 */
  362.        17:/****************************************************************/
  363.        18:
  364.        19:
  365.        20:/*
  366.        21: * Order: define order, polarity, and output
  367.        22: * spacing of stimulus and response values
  368.        23: */
  369.         24:
  370.         25:Order: a, %2, b, %4, inva, %3, invb, %5, and, %8,
  371.         26:       nand, %7, or, %8, nor, %7, xor, %8, xnor;
  372.         27:
  373.         28:/*
  374.         29: * Vectors: define stimulus and response values, with header
  375.         30: *          and intermediate messages for the simulator listing.
  376.         31: *
  377.         32: * Note: Don't Care state (X) on inputs is reflected in outputs
  378.         33: *       where appropriate.
  379.         34: */
  380.         35:
  381.         =======================================================================
  382.                                     Simulation Results
  383.         =======================================================================
  384.        Simple Gates Simple Simulation
  385.        inverters and     nand    or     nor
  386.        xor     xnor     
  387.         a a  !a !b  a & b !(a & b) a # b !(a # b) a $ b !(a $ b)
  388.         - -  -- --  ----- -------- ----- -------- ----- --------
  389.   0001: 0 0   H  H    L       H      L       H      L       H
  390.   0002: 0 1   H  L    L       H      H       L      H       L
  391.   0003: 1 0   L  H    L       H      H       L      H       L
  392.   0004: 1 1   L  L    H       L      H       L      L       H
  393.   0005: 1 X   L  X    X       X      H       L      X       X
  394.   0006: X 1   X  L    X       X      H       L      X       X
  395.   0007: 0 X   H  X    L       H      X       X      X       X
  396.   0008: X 0   X  H    L       H      X       X      X       X
  397.   0009: X X   X  X    X       X      X       X      X       X
  398.  
  399.      ------------------------------------------------------------
  400.     Figure U3-6. Gates Simulator Output File (GATES.SO)
  401.  
  402.