statistic-brd.ulp

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

      else  checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
    }
  }
  E.package.contacts(CON) {
    if (CON.pad) checkpad(CON.pad.x, CON.pad.y, CON.pad.diameter[1], CON.pad.diameter[16], CON.pad.shape[1], CON.pad.shape[16], CON.pad.elongation);
    else         checksmd(CON.smd.x, CON.smd.y, CON.smd.dx[CON.smd.layer], CON.smd.dy[CON.smd.layer], CON.smd.layer);
  }
  E.package.holes(H)  checkHole( H.x, H.y, H.drill );
  E.package.rectangles(R) {
    if (R.layer == 1 || R.layer == 16 || R.layer == 21 ||  R.layer == 22 ||  R.layer == 51 ||  R.layer == 52 )
        checkmaxmin( R.x1, R.x2, R.y1, R.y2, 0 );
  }
  E.package.texts(T) {
    T.wires(W) {
      if (W.layer == 1 || W.layer == 16 || W.layer == 21 ||  W.layer == 22 ||  W.layer == 51 ||  W.layer == 52 ) {
        if (W.arc) {
          checkarc(W.arc.x1, W.arc.x2, W.arc.y1, W.arc.y2, W.arc.xc, W.arc.yc, W.arc.angle1, W.arc.angle2, W.arc.radius, W.width);
        }
        else  checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
      }
    }
  }
  int mx = maxX -  minX;
  int my = maxY -  minY;
  return u2u(mx) * u2u(my);
}


// main
if (board) {
  board(B) {
    brdfile = B.name;
    int n;
    string usedLayers;
    string displayUnrouted;
    B.layers(L) {
      string sl;
      sprintf(sl, "%3d\t%s\t%d", L.number, L.name, L.used);
      allLayers[cntalllay] = sl;
      cntalllay++;
      if (L.used && L.number >=1 && L.number <= 16) {
        cntLayer++;
        sprintf(sl, "%2d %s\n", L.number, L.name);
        usedLayers += sl;
        if (L.number == 1 || L.number == 16) {
          sl = L.name;
          if (sl[0] == '$') {
            sprintf( sl, "Do not use Layer %.d %s for Powerplane!", L.number, L.name);
            layerError += "\n" + sl;
            sprintf( sl, "<br>Do not use Layer <font color=red>%.d %s</font> for Powerplane!", L.number, L.name);
            displayLayerError += sl;
          }
        }
      }
    }
    if (layerError) {
      layerError += "\n\nUse only inner layer (2 to 15) for Powerplane!\n";
      displayLayerError = "<nobr>" + displayLayerError + "</font><br>" +
                          "<br>Only use layer <font color=blue>2 - 15</font> for power planes.</nobr>";
      dlgMessageBox(displayLayerError, "Ok");
    }
    sprintf(usedLayer, "used layers %d\n\n%s", cntLayer, usedLayers);

    B.elements(E) {
      // calculate over xPlace/xDocu/PAD/SMD  12.05.2005 [e-mail]
      cntElement++;
      Ename[cntElement] = E.name;
      eUsedLayer[cntElement] = E.mirror;
      eUsedArea[cntElement] = used_area(E); // berechne f黵 jedes Element(Package) den ben鰐igten Platz
      summary_area += eUsedArea[cntElement];
    }

    resetMaxMin();
    B.wires(W) {
      if (W.layer == 20) {
        if (W.arc) {
          outlines += ArcLength(W.arc.angle1, W.arc.angle2, u2u(W.arc.radius));
          checkarc(W.arc.x1, W.arc.x2, W.arc.y1, W.arc.y2, W.arc.xc, W.arc.yc, W.arc.angle1, W.arc.angle2, W.arc.radius, W.width);
        }
        else {
          outlines += WireLength(W.x1, W.x2, W.y1, W.y2);
          checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
        }
      }
    }
    B.circles(C) {
      if (C.layer == 20) {
        outlines += WireLengthCircle(C.radius);
        checkmaxmin( C.x - C.radius, C.x + C.radius, C.y - C.radius, C.y + C.radius, C.width );
      }
    }
    B.elements(E) {

/* zombie
      if (E.name == "U$1") {
        string hh;
        sprintf(hh, "%s = %s : %.4f %.4f", E.name, E.value, u2u(E.x), u2u(E.y) );
        if (dlgMessageBox(hh, "OK", "Cancel") != 0) exit(-999);
      }
zombie */
      E.package.wires(W) {
        if (W.layer == 20) {
          // *** Dimension in Packages ***
          outlines += WireLength(W.x1, W.x2, W.y1, W.y2);
          checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
        }
      }
      E.package.circles(C) {
        if (C.layer == 20) {
          outlines += WireLengthCircle(C.radius);
          checkmaxmin( C.x - C.radius, C.x + C.radius, C.y - C.radius, C.y + C.radius, C.width );
        }
      }
      E.package.polygons(P) {
        P.wires(W) {
          if (W.width < 10) {
            sprintf(PolygonLayer[cPolygonL], "%s.PAC Layer:%d", E.package.name, W.layer);
            cPolygonL++;
          }
          break;
        }
      }
    }

    if (outlines) {
       sprintf(brdoutline, "Outline contour = %.2f", outlines);
       sprintf(brdmaximum, "max. Board length (Layer 20)\nX = %.2f\nY = %.2f",  WireLength(minX, maxX, 0,0), WireLength(minY, maxY, 0, 0) );
    }

    B.classes(CL) {
      // Net classes ********************
      NetClassNr[CL.number] = CL.number;
      NetClassName[CL.number] = CL.name;
      NetClassWidth[CL.number] = CL.width;
      NetClassClear[CL.number] = CL.clearance;
      NetClassDrill[CL.number] = CL.drill;
      cNetClass[CL.number] = 0;
    }
    B.signals(S) {
      cNetClass[S.class.number]++;
      sumSignals++;
      SignalName[SignalCnt]  = S.name;
      SignalClass[SignalCnt] = S.class.number;
      SignalCnt++;
      SignalClassList[S.class.number] += S.name + "\n";

      // Wires ********************
      S.wires(W) {
        if (W.layer < 19) {
          if (W.arc) {
            for (int n = 0; n <= cntArc; n++) {
              if (ArcWidth[n] == W.arc.width) {
                cArcWidth[n]++;
                break;
              }
            }
            if (n > cntArc) {
              cntArc++;
              ArcWidth[cntArc] = W.arc.width;
              cArcWidth[cntArc]++;
            }
          }
          else {
            for (n = 0; n <= cntWire; n++) {
              if (WireWidth[n] == W.width) {
                cWireWidth[n]++;
                break;
              }
            }
            if (n > cntWire) {
              cntWire++;
              WireWidth[cntWire] = W.width;
              cWireWidth[cntWire]++;
            }
          }
        }
        else {
          SignalUnrouted++;
        }
      }

      // Polygone *********************
      S.polygons(P) {
        // Polygon Wire width *********
        P.wires(W) {
          sprintf(PolygonLayer[cPolygonL], "%s\t%d\t%d\t%.3f", S.name, P.layer, P.rank, u2mm(W.width) );
                                           // Polygon Rank 19.07.2005 alf
          cPolygonL++;
          break;
        }
        for (n = 0; n <= cntPolyW; n++) {
          if (PolygonWidth[n] == P.width) {
            cPolygonWidth[n]++;
            break;
          }
        }
        if (n > cntPolyW) {
          cntPolyW++;
          PolygonWidth[cntPolyW] = P.width;
          cPolygonWidth[cntPolyW]++;
        }
        // Polygon isolate *********
        for (n = 0; n <= cntPolyIso; n++) {
          if (PolygonIsolate[n] == P.isolate) {
            cPolygonIsolate[n]++;
            break;
          }
        }
        if (n > cntPolyIso) {
          cntPolyIso++;
          PolygonIsolate[cntPolyIso] = P.isolate;
          cPolygonIsolate[cntPolyIso]++;
        }
      }

      // Vias *********************
      S.vias(V) {
        // Vias Drill *********************
        for (int n = 0; n <= cntVDril; n++) {
          if (ViaDrill[n] == V.drill) {
          cViaDrill[n]++;
          break;
        }
      }
      if (n > cntVDril) {
        cntVDril++;
        ViaDrill[cntVDril] = V.drill;
        cViaDrill[cntVDril]++;
      }

      // Vias Diameter TOP *********************
      for (n = 0; n <= cntVDiam; n++) {
        if (ViaDiameter[n] == V.diameter[LAYER_BOTTOM]) {
          cViaDiameter[n]++;
          break;
        }
      }
      if (n > cntVDiam) {
        cntVDiam++;
        ViaDiameter[cntVDiam] = V.diameter[LAYER_BOTTOM];
        cViaDiameter[cntVDiam]++;
      }

      // Vias Diameter Inner Layer *********************
      for (n = 0; n <= cntVDiamI; n++) {
        if (ViaDiameterI[n] == V.diameter[2]) {
          cViaDiameterI[n]++;
          break;
        }
      }
      if (n > cntVDiamI) {
        cntVDiamI++;
        ViaDiameterI[cntVDiamI] = V.diameter[2];
        cViaDiameterI[cntVDiamI]++;
      }

      // Vias Restring Top Bottom *********************
      int VRestringO = (V.diameter[LAYER_BOTTOM] - V.drill ) / 2;
      for (n = 0; n <= cntVringO; n++) {
        if (ViaRestringO[n] == VRestringO) {
          cViaRestringO[n]++;
          break;
        }
      }
      if (n > cntVringO) {
        cntVringO++;
        ViaRestringO[cntVringO] = VRestringO;
        cViaRestringO[cntVringO]++;
      }
      // Vias Restring Inner Layer *********************
      int VRestringI = (V.diameter[2] - V.drill ) / 2;
      for (n = 0; n <= cntVringI; n++) {
        if (ViaRestringI[n] == VRestringI) {
          cViaRestringI[n]++;
          break;
        }
      }
      if (n > cntVringI) {
        cntVringI++;
        ViaRestringI[cntVringI] = VRestringI;
        cViaRestringI[cntVringI]++;
      }
      viaStack(V.start, V.end);
    }
    S.contactrefs(C) {
      cnt_pad_on_signal++;
    }
  }

  B.holes(H) {
    // Holes Board *********************
    for (int n = 0; n <= cntHole; n++) {
      if (Hole[n] == H.drill) {
        cHole[n]++;
        break;
      }
    }
    if (n > cntHole) {
      cntHole++;
      Hole[cntHole] = H.drill;
      cHole[cntHole]++;
    }
  }
  B.circles(C) {
    if (C.layer < 19) {
      for (int n = 0; n <= cntCircl; n++) {
        if (CirclWidth[n] == C.width) {
          cCirclWidth[n]++;
          break;
        }
      }
      if (n > cntCircl ) {
        cntCircl++;
        CirclWidth[cntCircl] = C.width;
        cCirclWidth[cntCircl]++;
      }
    }
  }

  B.rectangles(R) {
    if (R.layer < 19) {
      int r_x = R.x2 - R.x1;
      int r_y = R.y2 - R.y1;
      for (int n = 0; n <= cntRECT; n++) {
        if ( RECTx[n] == r_x && RECTy[n] == r_y ) {
          cRECT[n]++;
          break;
        }
      }
      if (n > cntRECT ) {
        cntRECT++;
        RECTx[cntRECT] = r_x;
        RECTy[cntRECT] = r_y;
        cRECT[cntRECT]++;
      }
    }
  }

  B.texts(T) {
    if (T.layer < 19) {
      for (int n = 0; n <= cntTextSize; n++) {
        if (TextSize[n] == T.size) {
          cTextSize[n]++;
          break;
        }
      }
      if (n > cntTextSize) {
        cntTextSize++;
        TextSize[cntTextSize] = T.size;
        cTextSize[cntTextSize]++;
      }
      T.wires(W) {
        for (int n = 0; n <= cntTextWidth; n++) {
          if (TextWidth[n] == W.width) {
            cTextWidth[n]++;
            break;
          }
        }
        if (n > cntTextWidth) {
          cntTextWidth++;
          TextWidth[cntTextWidth] = W.width;
          cTextWidth[cntTextWidth]++;
        }
        break;
      }
    }
  }

  B.elements(E) {
    E.package.holes(H) {
      // Holes Board *********************
      for (int n = 0; n <= cntHole; n++) {
        if (Hole[n] == H.drill) {
          cHole[n]++;
          break;
        }
      }
      if (n > cntHole) {
        cntHole++;
        Hole[cntHole] = H.drill;
        cHole[cntHole]++;
      }
    }

    E.package.contacts(C) {
      if (C.smd) {
        if (C.smd.layer == LAYER_TOP) cntSMDt++;
        else cntSMDb++;
        for (int n = 0; n <= cntSMD; n++) {
          if ( (SMDx[n] == C.smd.dx && SMDy[n] == C.smd.dy) ) {
            cSMD[n]++;
            break;
          }
        }
        if (n > cntSMD) {
          cntSMD++;
          SMDx[cntSMD] = C.smd.dx;
          SMDy[cntSMD] = C.smd.dy;
          cSMD[cntSMD]++;
        }
      }

      if (C.pad) {
        // Drills
        for ( n = 0; n <= cntPDril; n++) {
          if (PadDrill[n] == C.pad.drill) {
            cPadDrill[n]++;
            break;
          }
        }
        if (n > cntPDril) {           // a new drill
          cntPDril++;
          PadDrill[cntPDril] = C.pad.drill;
          cPadDrill[cntPDril]++;
        }
        // Bottom layer
        for ( n = 0; n <= cntPDiamBOT; n++) {
          if (PadDiameterBOT[n] == C.pad.diameter[LAYER_BOTTOM]) {
            cPadDiameterBOT[n]++;
            break;
          }
        }
        if (n > cntPDiamBOT) {
          cntPDiamBOT++;
          PadDiameterBOT[cntPDiamBOT] = C.pad.diameter[LAYER_BOTTOM];
          cPadDiameterBOT[cntPDiamBOT]++;
        }
        // Top layer
        for (n = 0; n <= cntPDiamTOP; n++) {
          if (PadDiameterTOP[n] == C.pad.diameter[LAYER_TOP]) {
            cPadDiameterTOP[n]++;
            break;
          }
        }
        if (n > cntPDiamTOP) {
          cntPDiamTOP++;
          PadDiameterTOP[cntPDiamTOP] = C.pad.diameter[LAYER_TOP];
          cPadDiameterTOP[cntPDiamTOP]++;
        }
        // Inner layer
        for ( n = 0; n <= cntiPDiam; n++) {
          if (iPadDiameter[n] == C.pad.diameter[2]) {
            ciPadDiameter[n]++;
            break;
          }
        }
        if (n > cntiPDiam) {
          cntiPDiam++;
          iPadDiameter[cntiPDiam] = C.pad.diameter[2];
          ciPadDiameter[cntiPDiam]++;
        }
        // Top-Restring *************************
        int Trestring = (C.pad.diameter[LAYER_TOP] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringTOP; n++) {
          if (PadRestringTOP[n] == Trestring) {
            cPadRestringTOP[n]++;
            break;
          }
        }
        if (n > cntPringTOP) {
          cntPringTOP++;
          PadRestringTOP[cntPringTOP] = Trestring;
         cPadRestringTOP[cntPringTOP]++;
        }

        // Bottom-Restring *************************
        int Brestring = (C.pad.diameter[LAYER_BOTTOM] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringBOT; n++) {
          if (PadRestringBOT[n] == Brestring) {
            cPadRestringBOT[n]++;
            break;
          }
        }
        if (n > cntPringBOT) {
          cntPringBOT++;
          PadRestringBOT[cntPringBOT] = Brestring;