Simple STIL.4 Syntax Example (First Draft)

  TestProgram SimpleTestProgram {
    Device "1mh1";
    OnLoad LoadFlowGroup;
    OnInstall InstallFlowGroup;
    OnInitFlow InitFlowGroup;
    OnStart BeginFlowGroup;
    OnPowerDown PowerDownFlowGroup;
    OnAlarm AlarmFlowGroup;
  }

// Define FailBinMap

// bin_map ctg_map {
//   <04:16:1993 10:24:26>,
//   CLEAR_CONSEC = WAFER_LOT,
//   VIRTUAL_MAP = {
//     { MAP = 1 > 1, COUNTER = "p_good_part" },
//     { MAP = 10 > 10, COUNTER = "fo_signal_opens" },
//     { MAP = 11 > 11, COUNTER = "fs_power_shorts" },
//     { MAP = 12 > 12, COUNTER = "fs_signal_shorts" },
//     { MAP = 20 > 13, COUNTER = "fn_scan_func" },
//     { MAP = 21 > 14, COUNTER = "fn_dc_func" },
//     { MAP = 22 > 14, COUNTER = "fn_ac_func" },
//   },
//   HARDWARE = {
//     { BINS = 1, RETEST = 0, COUNTER = "AA", BIN_TYPE = PASS },
//     { BINS = 10, RETEST = 0, COUNTER = "ZC", BIN_TYPE = FAIL },
//     { BINS = 11, RETEST = 0, COUNTER = "ZP", BIN_TYPE = FAIL },
//     { BINS = 12, RETEST = 0, COUNTER = "ZS", BIN_TYPE = FAIL },
//     { BINS = 13, RETEST = 0, COUNTER = "YZ", BIN_TYPE = FAIL },
//     { BINS = 14, RETEST = 0, COUNTER = "YB", BIN_TYPE = FAIL }
//  }
// }; /* end of BIN_MAP ctg_map */

// NEED RETEST FLAGS SOMEWHERE 
FailBinMap {
   Axis failbins {
      Bin bfo_signal_opens {
         Descriptor = "fo_signal_opens";
         PerRunCounter = 10;
      }
      Bin bfp_power_shorts {
         Descriptor = "fp_power_shorts";
         PerRunCounter = 11;
      }
      Bin bfs_signal_shorts {
         Descriptor = "fs_signal_shorts";
         PerRunCounter = 12;
      }
      Bin bfn_nom_func {
         Descriptor = "fn_nom_func";
         PerRunCounter = 20;
      }
      Bin bfn_scan_func {
         Descriptor = "fn_scan_func";
         PerRunCounter = 21;
      }
      Bin bfn_dc_func {
         Descriptor = "fn_dc_func";
         PerRunCounter = 22;
      }
      Bin bfn_ac_func {
         Descriptor = "fn_ac_func";
         PerRunCounter = 23;
      }
      Bin bfn_highz_func {
         Descriptor = "fn_highz_func";
         PerRunCounter = 24;
      }
      Bin bfp_stress {
         Descriptor = "fp_stress";
         PerRunCounter = 30;
      }
      Bin bfp_nom_func {
         Descriptor = "fp_nom_func";
         PerRunCounter = 31;
      }
      Bin bfp_scan_func {
         Descriptor = "fp_scan_func";
         PerRunCounter = 32;
      }
      Bin bfp_dc_func {
         Descriptor = "fp_dc_func";
         PerRunCounter = 33;
      }
      Bin bfp_ac_func {
         Descriptor = "fp_ac_func";
         PerRunCounter = 34;
      }
      Bin bfp_highz_func {
         Descriptor = "fp_highz_func";
         PerRunCounter = 35;
      }
      Bin bfh_dci_func {
         Descriptor = "fh_dci_func";
         PerRunCounter = 40;
      }
      Bin bfh_dco_func {
         Descriptor = "fh_dco_func";
         PerRunCounter = 41;
      }
      Bin bfh_ac_func {
         Descriptor = "fh_ac_func";
         PerRunCounter = 42;
      }
      Bin bfh_highz_func {
         Descriptor = "fh_highz_func";
         PerRunCounter = 43;
      }
      Bin bfl_dci_func {
         Descriptor = "fl_dci_func";
         PerRunCounter = 50;
      }
      Bin bfl_dco_func {
         Descriptor = "fl_dco_func";
         PerRunCounter = 51;
      }
      Bin bfl_ac_func {
         Descriptor = "fl_ac_func";
         PerRunCounter = 52;
      }
      Bin bfl_highz_func {
         Descriptor = "fl_highz_func";
         PerRunCounter = 53;
      }
      Bin bfd_idd_dynamic {
         Descriptor = "fd_idd_dynamic";
         PerRunCounter = 60;
      }
      Bin bfk_input_leak {
         Descriptor = "fk_input_leak";
         PerRunCounter = 70;
      }
      Bin bfk_output_leak {
         Descriptor = "fk_output_leak";
         PerRunCounter = 71;
      }
      Bin bfk_io_leak {
         Descriptor = "fk_io_leak";
         PerRunCounter = 73;
      }
      Bin bfx_current_or_voltage_meas {
         Descriptor = "fx_current_or_voltage_meas";
         PerRunCounter = 80;
      }
      Bin bfx_time_meas {
         Descriptor = "fx_time_meas";
         PerRunCounter = 81;
      }
      Bin bfi_iddq {
         Descriptor = "fi_iddq";
         PerRunCounter = 90;
      }
      Bin bfi_idd_static {
         Descriptor = "fi_idd_static";
         PerRunCounter = 91;
      }

      Handler Synax {
         [bfo_signal_opens] 10;  // ZC
         [bfp_power_shorts] 11;  // ZP
         [bfs_signal_shorts] 12; // ZS
         [bfn_nom_func] 13;      // YZ
         [bfn_scan_func] 14;     // YB
         [bfn_dc_func] 15;       // YA
         [bfn_ac_func] 15;       // YA
         [bfn_highz_func] 15;    // YA
         [bfp_stress] 15;        // YA
         [bfp_nom_func] 15;      // YA
         [bfp_scan_func] 15;     // YA
         [bfp_dc_func] 15;       // YA
         [bfp_ac_func] 15;       // YA
         [bfp_highz_func] 15;    // YA
         [bfh_dci_func] 16;      // DH
         [bfh_dco_func] 17;      // DG
         [bfh_ac_func] 18;       // DF
         [bfh_highz_func] 19;    // DE
         [bfl_dci_func] 20;      // DD
         [bfl_dco_func] 21;      // DC
         [bfl_ac_func] 22;       // DB
         [bfl_highz_func] 23;    // DA
         [bfd_idd_dynamic] 24;   // BZ
         [bfk_input_leak] 25;    // BE
         [bfk_output_leak] 25;   // BE
         [bfk_io_leak] 25;       // BE
         [bfx_current_or_voltage_meas] 26;      // BD
         [bfx_time_meas] 27;     // BC
         [bfi_iddq] 28;          // BB
         [bfi_idd_static] 29;    // BA
      }
   }
}

PassBinMap {
   Axis passbins {
      Bin bp_best_part {
         Descriptor = "p_best_part";
         PerRunCounter = 1;
      }
      Bin bp_better_part {
         Descriptor = "p_better_part";
         PerRunCounter = 2;
      }
      Bin bp_good_part {
         Descriptor = "p_good_part";
         PerRunCounter = 3;
      }
      Bin bp_fair_part {
         Descriptor = "p_fair_part";
         PerRunCounter = 4;
      }
      Bin bp_passing_part {
         Descriptor = "p_passing_part";
         PerRunCounter = 5;
      }
      Handler Synax {
         [bp_best_part] 1;    // AA
         [bp_better_part] 2;  // AB
         [bp_good_part] 3;    // AC
         [bp_fair_part] 4;    // AD
         [bp_passing_part] 5; // AE
      }
   }
}

FlowGroup LoadFlowGroup {
}

FlowGroup InstallFlowGroup {
  FlowNode INSTALL {
     Execute { _INSTALL; }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_INIT;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = Function_8;
        }
     }
  }
  FlowNode Function_8 {
     Execute { ask_package; }  // User code segment
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_INIT;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = USER_INSTALL;
        }
     }
  }
  FlowNode USER_INSTALL {
     Execute { _USER_INSTALL; }
     Ports {
        Exit single_exit {
           Condition OTHERWISE;
           NextNode = LB_CAL;
        }
     }
  }
  FlowNode LB_CAL {
     Execute { _LB_CAL; }
     Ports {
        Exit single_exit {
           Condition OTHERWISE;
           NextNode = LOAD_PATTERNS;
        }
     }
  }
  FlowNode LOAD_PATTERNS {
     Execute { _LOAD_PATTERNS; }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_INIT;
        }
        Exit fail_exit {
           Condition Pass;
           NextNode = END_INIT;
        }
     }
  }
  FlowNode END_INIT {
     Execute { _END_OF_TEST; }  // Apply levels block powerdown levels
     Ports {
        ExitFlowGroup;
     }
  }
}

FlowGroup InitFlowGroup {
  FlowNode INIT {
     Execute { _INIT; }
     Ports {
        Exit single_exit {
           Condition Otherwise;
           NextNode = Function_9;
        }
     }
  }
  FlowNode Function_8 {
     Execute { menu_operat; }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_INIT;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = Function_11;
        }
     }
  }
  FlowNode Function_11 {
     Execute { compute_tst_cond; }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_INIT;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = END_INIT; // END_INIT is part of InstallFlowGroup above
        }
     }
  }
}

FlowGroup BeginFlowGroup {
  FlowNode BEGIN {
     Ports {
        Exit single_exit {
           Condition Otherwise;
           NextNode = Function_4;
        }
     }
  }
  FlowNode Function_4 {
     Execute {
        initialize {  // User code test object
           In shl_tst_condition=x;
        }
     }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = DC_1;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = DC_1;
        }
     }
  }
  FlowNode DC_1 {
     Execute {
        vdd_opens_cont {
           In Pin_table = mh1ps;
           In Levels_block = cont_levels;
           In Meas_device = PMU_PER_PIN;
           In Meas_method = STATIC;
           In I_V_Mode = V_MEASURE;
           In Force_val = 100uA;
           In Clamp_lo = -120mV;
           In Clamp_hi = 1.5V;
           In Min_limit = NO_LIMIT;
           In Max_limit = 1V;
           In Timeout = 100.000ms;
           In pins=ALL_SIGS[,other_sigs[,some_other_sigs]];
           Out pmu_per_pin_result;
           Out meas_values;  // An array or list of values (?)
        }
     }
     Ports {
        Exit fail_exit {
           // Condition Fail;
           Condition vdd_opens_cont.pmu_per_pin_result;
           NextNode = END_FAIL;
           Bin = bfo_signal_opens;
        }
        Exit pass_exit {
           // Condition Pass;
           Condition vdd_opens_cont.pmu_per_pin_result;
           NextNode = DC_18;
        }
     }
  }
  FlowNode DC_18 {
     Execute {
        gnd_opens_cont;
     }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_FAIL;
           Bin = bfo_signal_opens;
        }
        Exit pass_exit {
           Condition Pass;
           NextNode = DC_2;
        }
     }
  }
  FlowNode DC_2 {
     Execute {
        power_shorts;
     }
     Ports {
        Exit fail_exit {
           Condition Fail;
           NextNode = END_FAIL;
           Bin = bfs_power_shorts;
        }
        { FAIL, END_FAIL, bin = bfs_power_shorts }
        { PASS, DC_7 }
     }
  }
  FlowNode DC_7 {
     Execute {
        sig_shorts_cont;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfs_signal_shorts }
        { PASS, Test_2 }
     }
  }
  FlowNode Test_2 {
     Execute {
        nom_functional_test;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfn_nom_func }
        { PASS, Function_5 }
     }
  }
  FlowNode Function_5 {
     Execute {
        shl_hv_ac_cond {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, Test_1 }
        { PASS, Test_1 }
     }
  }
  FlowNode Test_1 {
     Execute {
        hv_ac_1;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfh_ac_func }
        { PASS, Test_3 }
     }
  }
  FlowNode Test_3 {
     Execute {
        hv_ac_2;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfh_ac_func }
        { PASS, Mpclk_srch }
     }
  }
  FlowNode Mpclk_srch {
     Execute {
        mpclk_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfh_ac_func }
        { PASS, Test_4 }
     }
  }
  FlowNode Test_4 {
     Execute {
        hv_ac_3;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfh_ac_func }
        { PASS, Test_5 }
     }
  }
  FlowNode Test_5 {
     Execute {
        hv_ac_4;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfh_ac_func }
        { PASS, Mpcnrasd_srch }
     }
  }
  FlowNode Mpcnrasd_srch {
     Execute {
        mpcnrasd_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfh_ac_func }
        { PASS, Test_6 }
     }
  }
  FlowNode Test_6 {
     Execute {
        hv_ac_5;
     }
     Ports {
        { FAIL, END_FAIL, bin = bfh_ac_func }
        { PASS, Mpcncasd_srch }
     }
  }
  FlowNode Mpcncasd_srch {
     Execute {
        mpcncasd_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfh_ac_func }
        { PASS, Test_7 }
     }
  }
  FlowNode Test_7 {
     Execute {
        high_voltage_dc
     }
     Ports {
        { FAIL, END_FAIL, bins = bfh_dco_func }
        { PASS, Function_6 }
     }
  }
  FlowNode Function_6 {
     Execute {
        shl_lv_ac_cond {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, Test_9 }
        { PASS, Test_9 }
     }
  }
  FlowNode Test_9 {
     Execute {
        lv_ac_1
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Test_8 }
     }
  }
  FlowNode Test_8 {
     Execute {
        lv_ac_2
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Function_1 }
     }
  }
  FlowNode Function_1 {
     Execute {
        mpclk_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Test_10 }
     }
  }
  FlowNode Test_10 {
     Execute {
        lv_ac_3
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Test_11 }
     }
  }
  FlowNode Test_11 {
     Execute {
        lv_ac_4
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Function_2 }
     }
  }
  FlowNode Function_2 {
     Execute {
        mpcnrasd_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Test_12 }
     }
  }
  FlowNode Test_12 {
     Execute {
        lv_ac_5
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, Function_3 }
     }
  }
  FlowNode Function_3 {
     Execute {
        mpcnrasd_srch {
           In shl_test_cond = x;
        }
     }
     Ports {
        { FAIL, END_FAIL, bins = bfh_ac_func }
        { PASS, Test_13 }
     }
  }
  FlowNode Test_13 {
     Execute {
        low_voltage_dc
     }
     Ports {
        { FAIL, END_FAIL, bins = bfl_ac_func }
        { PASS, DC_5 }
     }
  }
  FlowNode DC_5 {
     Execute {
        idd_dynamic_test
     }
     Ports {
        { FAIL, END_FAIL, bins = bfd_idd_dynamic }
        { PASS, DC_10 }
     }
  }
  FlowNode DC_10 {
     Execute {
        io_hlk123
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_6 }
     }
  }
  FlowNode DC_6 {
     Execute {
        io_llk_4
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_11 }
     }
  }
  FlowNode DC_11 {
     Execute {
        io_hlk_4
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_13 }
     }
  }
  FlowNode DC_12 {
     Execute {
        io_llk5
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_13 }
     }
  }
  FlowNode DC_13 {
     Execute {
        io_hlk5
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_4 }
     }
  }
  FlowNode DC_4 {
     Execute {
        io_llk123
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_io_leak }
        { PASS, DC_14 }
     }
  }
  FlowNode DC_14 {
     Execute {
        in_llk
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_input_leak }
        { PASS, DC_8 }
     }
  }
  FlowNode DC_8 {
     Execute {
        in_hlk
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_input_leak }
        { PASS, DC_15 }
     }
  }
  FlowNode DC_15 {
     Execute {
        in_llk_reset
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_input_leak }
        { PASS, DC_16 }
     }
  }
  FlowNode DC_16 {
     Execute {
        in_hlk_reset
     }
     Ports {
        { FAIL, END_FAIL, bins = bfk_input_leak }
        { PASS, Function_10, bins = bp_good_part }
     }
  }
  FlowNode Function_10 {
     Execute {
        pass_fail
     }
     Ports {
        { FAIL, END_FAIL }
        { PASS, END_PASS }
     }
  }
  FlowNode END_FAIL {
     Execute { _END_OF_TEST; }  // Apply levels block powerdown levels
     Ports {
        ExitFlowGroup;
     }
  }
  FlowNode END_PASS {
     Execute { _END_OF_TEST; }  // Apply levels block powerdown levels
     Ports {
        ExitFlowGroup;
     }
  }
}