statistic-brd.ulp

老外的PCB设计软件,是免费的.可以上网更新.

#usage "<qt><b>Statistic Table of Elements in the Layout</b><p>\n"
       "To change the units in the table, please use the variable uval,\n"
       "which can be found in the ulp file.<p>\n"
       "THIS PROGRAM IS PROVIDED AS IS AND WITHOUT WARRANTY OF ANY KIND, "
       "EXPRESSED OR IMPLIED.<p>\n"
       "<author>Author: [e-mail]</author></qt>"

#require 4.1106

// 12.01.2005 - Check if layer Top or Bottom used as Power-Plane *** [e-mail]
// 05.07.2005 - Calculate used area of packages. Use pads, smds and elements in
//              Layer 21/51 to calculate the used area of package.
//              Rotation of packages are not consider
// 19.07.2005 - Polygon-Rank [e-mail]
// 17.11.2005 - List all defined Layers [e-mail]


string Version = "1.0.2";

int    uval = 1;
string unit[] = { "Micron", "mm", "Mil", "Inch" };
int    unitPrec[] = { 0, 1, 1, 3 }, RoundFactor = pow(10, unitPrec[uval]);

string minvalfile = filesetext(argv[0], "-checkmin.val");
real   checkMinWire = 0.3;
real   checkMinArc = checkMinWire;
real   checkMinCirc = checkMinWire;
real   checkMinPoly = checkMinWire;
real   checkMinRestringP = checkMinWire;
real   checkMinRestringV = checkMinWire;
real   checkMinClearance = 0.3;
real   checkMinIsol = checkMinClearance;
real   checkMinPadDrill = 0.6;
real   checkMinViaDrill = checkMinPadDrill;
real   checkMinHoleDrill = checkMinPadDrill;
string showminValWidth;
string showminValOther;

int    maxX = INT_MIN;
int    minX = INT_MAX;
int    maxY = INT_MIN;
int    minY = INT_MAX;

string wireWidthInternal = " * Wire width are saved in 0.2 micron!\n";

int    WireWidth[];
int    cWireWidth[];
int    cntWire = 0;

int    ArcWidth[];
int    cArcWidth[];
int    cntArc = 0;

// ******************************************************************
// *** WIRE WIDTH wird nur geradzahlig gespeichert, wegen Teilung *** az
// ******************************************************************
string PolygonLayer[] = { "" , ""};
int    cPolygonL = 0;
int    PolygonWidth[];
int    cPolygonWidth[];
int    cntPolyW = 0;

string PolygonSignalName[];
int    PolygonIsolate[];
int    PolygonRank[];
int    cPolygonIsolate[];
int    cntPolyIso = 0;

int    cntLayer = 0;
string usedLayer;
int    cntalllay;
string allLayers[];
string layerError;
string displayLayerError;
real   outlines = 0;
string brdoutline;
string brdmaximum = "max. Board length ?\n(layer 20 empty)";

string NetClassName[];
int    NetClassWidth[];
int    NetClassClear[];
int    NetClassDrill[];
int    NetClassNr[];
int    cNetClass[];

string SignalName[];
int    SignalClass[];
string SignalClassList[];
int    SignalClassSelect = 0;
int    SignalCnt = 0;
int    SignalUnrouted = 0;
string Unrouted = "";

int    cnt_pad_on_signal = 0;

int    SMDx[], SMDy[];
int    cSMD[];
int    cntSMDt = 0;
int    cntSMDb = 0;
int    cntSMD = 0;

int    CirclWidth[];
int    cCirclWidth[];
int    cntCircl = 0;

int    RECTx[];
int    RECTy[];
int    cRECT[];
int    cntRECT = 0;

int    TextWidth[];
int    cTextWidth[];
int    cntTextWidth = 0;

int    TextSize[];
int    cTextSize[];
int    cntTextSize = 0;

int    PadDrill[];
int    cPadDrill[];
int    cntPDril = 0;

int    PadDiameterTOP[];
int    cPadDiameterTOP[];
int    cntPDiamTOP = 0;
int    PadDiameterBOT[];
int    cPadDiameterBOT[];
int    cntPDiamBOT = 0;
int    iPadDiameter[];  // inner Layer
int    ciPadDiameter[];
int    cntiPDiam = 0;

int    PadRestringTOP[];
int    cPadRestringTOP[];
int    cntPringTOP;
int    PadRestringBOT[];
int    cPadRestringBOT[];
int    cntPringBOT;
int    PadRestringI[];
int    cPadRestringI[];
int    cntPringI = 0;

int    ViaDrill[];
int    cViaDrill[];
int    cntVDril = 0;

int    ViaDiameter[];
int    cViaDiameter[];
int    cntVDiam = 0;

int    ViaDiameterI[];
int    cViaDiameterI[];
int    cntVDiamI = 0;

int    ViaRestringO[],  ViaRestringI[];
int    cViaRestringO[], cViaRestringI[];
int    cntVringO = 0,   cntVringI = 0;

int    ViaStackCnt[];
string ViaStack[];
int    cntStack = 0;

int    Hole[];
int    cHole[];
int    cntHole = 0;

// int    cntDrillrack;
string drillRack[];
real   Drilling[];
int    imax = 0;

string Lbr[];
int    cLbr[];
int    cntLbr = 0;

string PacName[];
int    cPacName[];
int    cntPacName = 0;

string EValue[];
int    cEValue[];
int    cntEValue = 0;
int    emptyValue = 0;
string empty = "~/-empty-/~";

int    cntElement = 0;
string Ename[];
real   eUsedArea[];  // calculate over xPlace/xDocu/PAD/SMD  12.05.2005 [e-mail]
int    eUsedLayer[];
real   summary_area = 0;

int    art_selected = 0;
int    LBRselected;
int    PACselected;
int    pac_drill[], cntpac_drill[], cnt_d;
int    pac_hole[], cntpac_hole[], cnt_h;
int    VALselected;
string Element_info = " \n \n \n";
string linfo = "<nobr><font color=darkgreen>&nbsp;Double click in listings<br> for detailed info</font></nobr>";

string sum;
   int sumSignals = 0;
   int sumWires = 0;
   int minWires = INT_MAX;
   int sumARCw = 0;
   int minARCw = INT_MAX;
   int sumCIRCw = 0;
   int minCIRCw = INT_MAX;
   int sumRECT = 0;
   int minRECTx = INT_MAX;
   int minRECTy = INT_MAX;
   int minClearance = INT_MAX;
   int sumPOLYw = 0;
   int minPOLYw = INT_MAX;
   int sumISOL = 0;
   int minISOL = INT_MAX;
   int sumSMD = 0;
   int minSMDx = INT_MAX;
   int minSMDy = INT_MAX;
   int sumPADdril = 0;
   int minPADdril = INT_MAX;
   int sumPADdia = 0;
   int minPADdia = INT_MAX;
   int sumPADdiaI = 0;
   int minPADdiaI = INT_MAX;
   int sumPADrest = 0;
   int minPADrest = INT_MAX;
   int sumPADrestI = 0;
   int minPADrestI = INT_MAX;
   int sumVIAdril = 0;
   int minVIAdril = INT_MAX;
   int sumVIAdiam = 0;
   int minVIAdiam = INT_MAX;
   int sumVIAdiamI = 0;
   int minVIAdiamI = INT_MAX;
   int sumVIArest = 0;
   int minVIArest = INT_MAX;
   int sumVIArestI = 0;
   int minVIArestI = INT_MAX;
   int sumHOLE = 0;
   int minHOLE = INT_MAX;
   int sumTEXTw = 0;
   int minTEXTw = INT_MAX;


int indexWire[],
    indexPolygonWidth[],
    indexPolygonIsolate[],
    indexSMD[],
    indexPadDrill[],
    indexPadDia[],
    indexiPadDia[],
    indexPadRestring[],
    indexPadRestringI[],
    indexViaDrill[],
    indexViaRestringO[],
    indexViaRestringI[],
    indexViaDiameter[],
    indexViaDiameterI[],
    indexHole[],
    indexArcW[],
    indexCirclW[],
    indexTextWidth[];

numeric string statisticWirew[];
numeric string statisticPolyw[];
numeric string statisticPoliso[];
numeric string statisticCLASS[];
numeric string statisticSMD[];
numeric string statisticPADdril[];
numeric string statisticPADdiaTOP[];
numeric string statisticPADdiaBOT[];
numeric string statisticPADdiaI[];
numeric string statisticPADrestTOP[];
numeric string statisticPADrestBOT[];
numeric string statisticPADrestI[];
numeric string statisticVIAdril[];
numeric string statisticVIAdia[];
numeric string statisticVIAdiaI[];
numeric string statisticVIArest[];
numeric string statisticVIArestI[];
numeric string statisticVIAstack[];
numeric string statisticHOLE[];
numeric string statisticARCw[];
numeric string statisticCIRw[];
numeric string statisticRECT[];
numeric string statisticTEXTw[];
numeric string statisticTEXTsize[];
numeric string statisticLBR[];
numeric string statisticPAC[];
numeric string statisticVALUE[];

string Text;

string ulp_path;
char bkslash = '/';
int pos = strrchr(argv[0], bkslash);
if (pos >= 0) ulp_path = strsub(argv[0], 0, pos + 1);

string attention = "<img src=statistic_attention_min_value.bmp>";

string brdfile;


// Functions

real u2u(int v) {
  switch (uval) {
    case GRID_UNIT_MIC  : return u2mic(v);
      break;

    case GRID_UNIT_MM	: return u2mm(v);
      break;

    case GRID_UNIT_MIL  : return u2mil(v);
      break;

    case GRID_UNIT_INCH : return u2inch(v);
      break;
  }
}


string value(int v, string is) {
  if (v == INT_MAX) return "<i>not used</i> " + is;
  string sv;
  switch (uval) {
    case GRID_UNIT_INCH : sprintf(sv, "%.6f %s", u2inch(v), is);
                          break;

    case GRID_UNIT_MIL  : sprintf(sv, "%.3f %s", u2mil(v), is);
                          break;

    case GRID_UNIT_MM   : sprintf(sv, "%.4f %s", u2mm(v), is);
                          break;

    case GRID_UNIT_MIC  : sprintf(sv, "%.1f %s", u2mic(v), is);
                          break;
  }
  return sv;
}


string min_value(int v, real minv) {
  string sv = "<p>";
  switch (uval) {
    case GRID_UNIT_INCH : if(u2inch(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MIL  : if(u2mil(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MM   : if(u2mm(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MIC  : if(u2mic(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;
  }
  return sv;
}


string check_min_ValueWidth(void) {
  string sh;
  sprintf(sh, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
         value(minWires, " - Wire width "),
         min_value(minWires, checkMinWire),
         value(minPOLYw, " - Polygon wire width"),
         min_value(minPOLYw, checkMinPoly),
         value(minARCw, " - Arc width "),
         min_value(minARCw, checkMinArc),
         value(minCIRCw, " - Circle width "),
         min_value(minCIRCw, checkMinCirc),
         value(minPADrest, " - Pad Restring "),
         min_value(minPADrest, checkMinRestringP),
         value(minVIArest, " - Via Restring "),
         min_value(minVIArest, checkMinRestringV),
         value(minClearance, " - Clearance "),
         min_value(minClearance, checkMinClearance),
         value(minISOL, " - Isolate Polygon "),
         min_value(minISOL, checkMinIsol)
         );
  return sh;
}

string check_min_ValueOther(void) {
  string sh;
  sprintf(sh, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
         value(minTEXTw, " - Text width ") + "<p>",
         value(minSMDx, " - SMD X ") + "<p>",
         value(minSMDy, " - SMD Y ") + "<p>",
         value(minPADdril, " - Pad drill "),
         min_value(minPADdril, checkMinPadDrill),
         value(minPADrestI, " - Pad Restring Inner.<p>"),
         value(minVIAdril, " - Via drill "),
         min_value(minVIAdril, checkMinViaDrill),
         value(minVIArestI, " - Via Restring Inner.<p>"),
         value(minHOLE, " - Hole drill "),
         min_value(minHOLE, checkMinHoleDrill),
         value(minRECTx, " - Rectangle X ") + "<p>",
         value(minRECTy, " - Rectangle Y ")
         );
  return sh;
}

void AddDrilling(int Size) {
  real x;
  switch (uval) {
    case GRID_UNIT_MIC  :   x = round(u2mic(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_MM   :   x = round(u2mm(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_MIL  :   x = round(u2mil(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_INCH : x = round(u2inch(Size) * RoundFactor) / RoundFactor;
                         break;
  }

  for (int i = imax; --i >= 0; )
      if (Drilling[i] == x)
         return;
  Drilling[imax++] = x;
  return;
}

void loadminval(void) {
  string line[];
  int lines = fileread(line, minvalfile);
  checkMinWire      = strtod(line[0]);
  checkMinArc       = strtod(line[1]);
  checkMinCirc      = strtod(line[2]);
  checkMinPoly      = strtod(line[3]);
  checkMinRestringP = strtod(line[4]);
  checkMinRestringV = strtod(line[5]);
  checkMinClearance = strtod(line[6]);
  checkMinIsol      = strtod(line[7]);
  checkMinPadDrill  = strtod(line[8]);
  checkMinViaDrill  = strtod(line[9]);
  checkMinHoleDrill = strtod(line[10]);
  return;
}


void saveminval(void) {
  output( minvalfile, "wt") {
    printf("%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f",
         checkMinWire,
         checkMinArc,
         checkMinCirc,
         checkMinPoly,
         checkMinRestringP,
         checkMinRestringV,
         checkMinClearance,
         checkMinIsol,
         checkMinPadDrill,
         checkMinViaDrill,
         checkMinHoleDrill );
  }
  return;
}

void GetCheckValues(void) {
  dlgDialog("Checked min values") {
    dlgGridLayout {
         dlgCell( 0, 0) dlgRealEdit( checkMinWire, 0, 10);
         dlgCell( 0, 1) dlgLabel("Check minimum Wire width");
         dlgCell( 1, 0) dlgRealEdit( checkMinArc, 0, 10);
         dlgCell( 1, 1) dlgLabel("Check minimum ARC width");