topicchi/SyncHome
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2fd78d11a7ad5771cd303e3824bdcec09ec3fb70
SyncHome/trunk/ulp/generate-3d-idf-data.ulp

1018 lines
43 KiB
Plaintext
Raw Normal View History

2023-03-09 10:24:21 +00:00
#usage "en:<b>export 3d-data from board to IDF-FileFormat</b><p>"
"More info can be found here: .../eagle.../doc/generate_3d_data_eng.pdf<br>"
"<author>Original author: Uploaded by Neubacher Andreas from Commend International GmbHh<br>"
"co-Author: alf@cadsoft.de</author><p>"
,
"de:<b>export 3d-data from board to IDF-FileFormat</b><p>"
"Im Layer 50 mu&szlig; eine Kopie der Boardkontour des Layer 20 angelegt werden. Die Wirebreite in Micron "
"ergibt die Boarddicke in mm.<br>"
"Die Bordkontour kann entweder im Board lebst oder in einem Package angelegt werden, es muß nur die "
"obenstehende Bedingung eingehalten werden.<br>"
"Um in einem Board einen Durchbruch zu erzeugen, kann man entweder im Board selbst oder in einem Package "
"eine Kontur mit der Wirebreite von 0 im Layer 50 anlegen.<br>"
"<author>Original author: Uploaded by Neubacher Andreas from Commend International GmbHh<br>"
"co-Author: alf@cadsoft.de</author><p>"
#require 6.0600
string UlpVersion = "1.9";
string Docuemantpath = "Weiter Infos finden sie im Dokumentenordner unter " + path_doc[0] + "/generate_3d_data_eng.pdf<br>";
//############################################################################
// Author: Andy Neubacher
// Version | Date | log
//---------+------------+-----------------------------------------------------
// v1.9 | 2014-04-08 | - Now can change the filedirectory an filename
// select Top and or Bottom side of parts to export
// v1.8 | 2014-04-01 | - Cutout und Koordinaten berichtigt (nur beim ersten Wire, Anfang und Endkoordinate ausgeben)
// dann immer nur die 2. Koordinate bis die erste Koordinate wieder erreicht ist.
// - LoopCounter für geschlossene Konturen (Durchbruch/Cutout) wieder berichtigt.
//
// v1.7 | 2014-01-20 | - draw also pad-holes
// v1.6 | 2013-12-19 | - LoopCounter für geschlossene Konturen (Durchbruch/Cutout).
// Die Bedingung für die Erkennung der einzelnen Konturen ist:
// 1. Die allererste Kontour im Layer 50 ist die Boardkontur,
// was bedeutet, diese Kontour muss als allererste Kontur gezeichnet werden.
// 2. Jede weitere Kontur wird als Cutout betrachtet, und es wird keine Überprüfung
// vorgenommen, ob diese Kontur innerhalb oder ausserhalb der Board-Dimension ist.
// 3. Jede Kontur muss durchgehend gezeichnet und geschlossen sein.
// Das bedeutet, man darf innerhalb einer Kontur nicht an beliebigen Punkten
// das (WIRE) zeichnen unterbrechen, und an einer anderen Stelle wieder beginnen,
// also dem vorher unterbrochenen *Ende* entgegen zeichnen.
//
// v1.5 | 2013-12-18 | - file renamed and now without version, for use in Text-Menu
// | | - draw board cutout
// | | - ++CutoutNumSegments change to CutoutNumSegments++
// alf@cadsoft.de
// v1.4 | 2013-12-11 | - correct Board outline Curve
// | | - correct Pre- to Post-Increment in all Functions
// | | - fixed by Angelo.Cuccato@bogen-electronic.com
// v1.3 | 2013-03-14 | - correct using ARC coorinates
// v1.2 | 2013-01-14 | - Link in description to download page - fixes by alf@cadsoft.de
// v1.1 | 2012-12-04 | - korrect Loop Label for contours in layer Dimension - fixes by alf@cadsoft.de
// v1.0 | 2012-08-20 | - more resolution %.6f of coordinates - fixes by alf@cadsoft.de
// v0.9 | 2012-02-08 | - used function u2mm() for Z-axis value - fixes by alf@cadsoft.de
// | |
// v0.8 | 2011-05-31 | - changed characters that caused import problems
// | | - changed output file extension to .emn and .emp
// | | - fixes by morten@riftlabs.com
// | |
// v0.7 | 2006-10-24 | - outline of board can also be drawn direct in brd-file
// | | - any hole is taken from devices and board direct
// | | - close open polygons on request
// | | - drill vias on request
// | | - bugfix : error if device contains more than one poly on top and bottom
// | | - bugfix : sorting of points possible failed if polygon was open
// | | - bugfix : partheights on bottomlayer were ignored
// v0.6 | 2006-08-31 | now multiple partheights are possible
// v0.5 | 2006-08-25 | modification to 'RIR-standard'
// v0.4 | 2005-11-09 | 1st export of a real board+parts successfull
// v0.3 | 2005-11-03 | correct mirrors at top and bottom side
// v0.2 | 2005-10-21 | 1st working IDF-data
// v0.1 | 2005-09-30 | start of project
//---------+------------+-----------------------------------------------------
//
// HOWTO:
// Create your board outline on layer 50.
// In your library, draw the component outlines on layer 57 (tCad) and use the line thickness to set component height.
// 1000 mic = 1 mm (e.g. if your grid is in mm, then a line thickness of 0.001 equals a component height of 1 mm).
// More info can be found here: ftp://ftp.cadsoft.de/eagle/userfiles/ulp/generate_3d_data_eng.pdf
//
//############################################################################
int Layer3dBoardDimension = 50;
int tLayer3Ddata = 57;
int bLayer3Ddata = 58;
int SelectSide[] = { 1, 1 }; // select Part output on side Top / Bottom
int maxCutoutLineWidth = 0; // -->> is linewidth 0.0 -> line is a cutout ??
string UlpName = filename(argv[0]); // gets ulp name
// partoptions
int NumParts; // number of parts
string PartName[]; // name of part
// vars for polygon calculation
int NumSegments = 0; // number of points
int PointX1[]; // start x
int PointY1[]; // start y
int PointX2[]; // end x
int PointY2[]; // end y
int SegmentType[]; // LINE, ARC, CIRCLE
real SegmentCurve[]; // used by ARCs : - if drawn CCW, + if drawn CW
int SegmentWidth[]; // linewitdh = partheight
int CutoutNumSegments = 0;
int CutoutPointX1[]; // start x
int CutoutPointY1[]; // start y
int CutoutPointX2[]; // end x
int CutoutPointY2[]; // end y
int CutoutSegmentType[]; // LINE, ARC, CIRCLE
int CutoutSegmentCurve[]; // used by ARCs : -180 if drawn CCW, +180 if drawn CW
int CutoutSegmentWidth[]; // linewitdh = partheight
int LoopCounter = 0; // 2015-04-02 für Boardoutline und Cutoutline
enum { LINE = 1, ARC = 2, CIRCLE = 3 };
enum { CUTOUT = 0, OUTLINE = -1 };
enum { false = 0, true = 1};
string Type[];
Type[0] = "0";
Type[LINE] = "LINE";
Type[ARC] = "ARC";
Type[CIRCLE] = "CIRCLE";
// vars for library
int NumPacInLib = 0; // number of pacs in library
int PacIn_LIB_heights[]; // if 0 = only one partheight, if != 0 more than one height
real PacIn_LIB_angle[]; // rotation of part in board
string PacIn_LIB_name[]; // names of pack's in library
int PacIn_LIB_Device_mountside[]; // TOP, BOTTOM
string PacIn_LIB_SubPart_mountside[]; // mountside of subparts
int NumCutouts = 0; // number of holes in the pcb (drills, millings)
int OutlineInDeviceFound = false; // is outline drawn in device symbol
int CloseOpenPoly = false; // close polygon if gap is smaller than ...mm
real MaxGapWidth = 0.1; // value of maximum gap to close
int DrillViaHoles = true; // drill via-holes in pcb
real MinViaHoleDia = 0.254; // diameter of drill
////////////////////////////////////////////////////
void CollectPartData(UL_BOARD brd) { // read out all parts
NumParts = 0;
brd.elements(E) {
PartName[NumParts] = E.name;
PacIn_LIB_angle[NumParts] = -1; // fill with invalid rotation and ...
PacIn_LIB_Device_mountside[NumParts] = -1; // fill with invalid mountside (mirror) for "void IDF_LibaryElectrical(UL_BOARD BRD)" function
PacIn_LIB_heights[NumParts] = 0; // part is only one package
NumParts++;
}
}
////////////////////////////////////////////////////
void IDF_Circle(int x1, int y1, int x2, int y2, int type) { // output circle to file in IDF format
int loopcount = 0;
if(type == CUTOUT) loopcount = NumCutouts; // 2013-12-19
printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
printf("%d %.6f %.6f 360\n", loopcount, u2mm(x2), u2mm(y2));
return;
}
////////////////////////////////////////////////////
void IDF_Arc(int x1, int y1, int x2, int y2, real angle, int type, int first) { // output arc to file in IDF format
int loopcount = 0;
if(type == CUTOUT) loopcount = NumCutouts; // 2013-12-19
if (first) printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
printf("%d %.6f %.6f %.1f\n", loopcount, u2mm(x2), u2mm(y2), angle);
return;
}
////////////////////////////////////////////////////
void IDF_Line(int x1, int y1, int x2, int y2, int type, int first) { // output line to file in IDF format
int loopcount = 0;
if(type == CUTOUT) loopcount = NumCutouts; // 2013-12-19
if (first) printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
printf("%d %.6f %.6f 0\n", loopcount, u2mm(x2), u2mm(y2));
return;
}
////////////////////////////////////////////////////
void OutputLines(int originx, int originy, int type) { // write to file
int first = 1;
int i = 0;
int startx = PointX1[i];
int starty = PointY1[i];
for(i = 0; i < NumSegments; i++) {
NumCutouts = LoopCounter;
switch(SegmentType[i]) {
case LINE : IDF_Line(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, type, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case ARC : IDF_Arc(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, SegmentCurve[i], type, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case CIRCLE : IDF_Circle(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, type);
LoopCounter++;
NumCutouts = LoopCounter;
startx = PointX1[i+1];
starty = PointY1[i+1];
first = 1;
break;
default : string s;
sprintf(s, "Unknown type in Segment %d", i);
if (dlgMessageBox(s, "OK", "esc") != 0) exit(-182);
}
if (startx == PointX2[i] && starty == PointY2[i]) {
first = 1; // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
startx = PointX1[i+1];
starty = PointY1[i+1];
LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
}
}
return;
}
////////////////////////////////////////////////////
void OutputBoardOutLines(int originx, int originy, int type) { // write to file :: type ist hier irrelevant
int first = 1;
int i = 0;
int startx = PointX1[i];
int starty = PointY1[i];
for(i = 0; i < NumSegments; i++) {
NumCutouts = LoopCounter;
switch(SegmentType[i]) { // 2013-12-18
case LINE : IDF_Line(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, CUTOUT, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case ARC : IDF_Arc(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, SegmentCurve[i], CUTOUT, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case CIRCLE : IDF_Circle(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, CUTOUT);
LoopCounter++;
NumCutouts = LoopCounter;
startx = PointX1[i+1];
starty = PointY1[i+1];
first = 1;
break;
default : string s;
sprintf(s, "Unknown type in Segment %d", i);
}
if (startx == PointX2[i] && starty == PointY2[i]) {
first = 1; // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
startx = PointX1[i+1];
starty = PointY1[i+1];
LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
}
}
return;
}
void OutputBoardCutOutLines(int originx, int originy, int type) { // write to file :: type ist hier irrelevant
int first = 1;
int i = 0;
int startx = CutoutPointX1[i];
int starty = CutoutPointY1[i];
for(i = 0; i < CutoutNumSegments; i++) {
NumCutouts = LoopCounter;
switch(CutoutSegmentType[i]) { // 2013-12-18
case LINE : IDF_Line(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CUTOUT, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case ARC : IDF_Arc(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CutoutSegmentCurve[i], CUTOUT, first);
first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
// bis zum Ende sprich schliessen der Schleife
break;
case CIRCLE : IDF_Circle(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CUTOUT);
LoopCounter++;
NumCutouts = LoopCounter;
startx = CutoutPointX1[i+1];
starty = CutoutPointY1[i+1];
first = 1;
break;
default : string s;
sprintf(s, "Unknown type in Segment %d", i);
}
if (startx == CutoutPointX2[i] && starty == CutoutPointY2[i]) {
first = 1; // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
startx = CutoutPointX1[i+1];
starty = CutoutPointY1[i+1];
LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
}
}
return;
}
////////////////////////////////////////////////////
int IsPointEqual (int x1, int y1, int x2, int y2) { // really need a func-description ??
if(x1 == x2 && y1 == y2) return true;
return false;
}
////////////////////////////////////////////////////
real getPartHeight() { // returns maximum partlevel
real ret = u2mm(SegmentWidth[0])*1000.0; // 2012-02-08
return ret;
}
////////////////////////////////////////////////////
int IsPointInCircle(int target_x, int target_y, int circle_x, int circle_y, real radius) {
real dist,a,b;
a = abs(target_y-circle_y);
b = abs(target_x-circle_x);
// calculate distance
dist = sqrt(a*a + b*b);
if(dist <= radius) return true;
return false;
}
////////////////////////////////////////////////////
//int GetArcOptions(UL_WIRE w) { // is arc drawn CW or CCW
// if(IsPointEqual(w.x1, w.y1, w.x2, w.y2)) return (w.arc.angle1 - w.arc.angle2);
// else return (w.arc.angle2 - w.arc.angle1);
//}
////////////////////////////////////////////////////
int DataOnLayerPresent(UL_ELEMENT E, int layer) {
E.package.circles(CIR) { // circle found
if(CIR.layer == layer && CIR.width > maxCutoutLineWidth) return true;
}
E.package.wires(W) {
if(W.arc) { // arc found
if(W.layer == layer && W.width > maxCutoutLineWidth) return true;
}
else { // straight line found
if(W.layer == layer && W.width > maxCutoutLineWidth) return true;
}
}
return false; // no 3d-data on given layer found
}
////////////////////////////////////////////////////
void CollectRemainingPoints(int start, int nr) {
int i;
for(i = 0; i < nr; i++) {
PointX1[i] = PointX1[i+start];
PointY1[i] = PointY1[i+start];
PointX2[i] = PointX2[i+start];
PointY2[i] = PointY2[i+start];
SegmentType[i] = SegmentType[i+start];
SegmentCurve[i] = SegmentCurve[i+start];
SegmentWidth[i] = SegmentWidth[i+start];
}
NumSegments = nr;
return;
}
////////////////////////////////////////////////////
int SortPointsEx (void) { // sort all points to a continous polygon
int i;
int ptfound;
int ResultPointX1[]; // start x
int ResultPointY1[]; // start y
int ResultPointX2[]; // end x
int ResultPointY2[]; // end y
int ResultSegmentType[]; // SegmentType
int ResultSegmentCurve[]; // options of segment (only used for ARCs)
int ResultSegmentWidth[]; // width of line
int PointUsed[];
enum { NOT_FOUND = 0, FOUND = 1, ERROR = 2 };
enum { NOT_USED = 0, USED = 1 };
for(i = 0; i < NumSegments; i++) PointUsed[i] = NOT_USED;
ResultPointX1[0] = PointX1[0]; // startpoint
ResultPointY1[0] = PointY1[0];
ResultPointX2[0] = PointX2[0];
ResultPointY2[0] = PointY2[0];
ResultSegmentType[0] = SegmentType[0];
ResultSegmentWidth[0] = SegmentWidth[0];
ResultSegmentCurve[0] = SegmentCurve[0];
PointUsed[0] = USED;
for(int x=1; x<NumSegments; x++) {
i = 1;
ptfound = NOT_FOUND;
do {
if(!PointUsed[i]) {
// search left point of segment in list
if( IsPointEqual(PointX1[i], PointY1[i], ResultPointX2[x-1], ResultPointY2[x-1]) ) { // x1,y1 = startpoint | x2,y2 = endpoint
ptfound = FOUND;
PointUsed[i] = USED;
ResultPointX1[x] = PointX1[i];
ResultPointY1[x] = PointY1[i];
ResultPointX2[x] = PointX2[i];
ResultPointY2[x] = PointY2[i];
ResultSegmentType[x] = SegmentType[i];
ResultSegmentWidth[x] = SegmentWidth[i];
ResultSegmentCurve[x] = SegmentCurve[i];
}
// search right point of segment in list
if( IsPointEqual(PointX2[i], PointY2[i], ResultPointX2[x-1], ResultPointY2[x-1]) ) { // x2,y2 = startpoint | x1,y1 = endpoint
ptfound = FOUND;
PointUsed[i] = USED;
ResultPointX1[x] = PointX2[i];
ResultPointY1[x] = PointY2[i];
ResultPointX2[x] = PointX1[i];
ResultPointY2[x] = PointY1[i];
ResultSegmentType[x] = SegmentType[i];
ResultSegmentWidth[x] = SegmentWidth[i];
ResultSegmentCurve[x] = SegmentCurve[i] * (-1); // swap also drawing direction of ARC (clockwise, counter-clockwise)
}
} // point used
// checked full array ?
if(i++ >= (NumSegments-1)) {
if(ptfound != FOUND) ptfound = ERROR;
}
} while(ptfound == NOT_FOUND);
// if point was not found -> end sorting of points
if (ptfound == ERROR) break;
} // for NumSegments
// count how many points are not used
int n;
int NumPointsUsed = 0;
for(i=0; i < NumSegments; i++) {
if(PointUsed[i] == USED) NumPointsUsed++;
}
// copy not used points to end of ResultPoint[]
for(i = NumSegments-1; i >= NumPointsUsed; i--) {
for(n = 0; n < NumSegments; n++) {
if(PointUsed[n] == NOT_USED) { // copy if point is not used
PointUsed[n] = USED;
ResultPointX1[i] = PointX1[n];
ResultPointY1[i] = PointY1[n];
ResultPointX2[i] = PointX2[n];
ResultPointY2[i] = PointY2[n];
ResultSegmentCurve[i] = SegmentCurve[n];
ResultSegmentType[i] = SegmentType[n];
ResultSegmentWidth[i] = SegmentWidth[n];
break;
}
}
}
// copy back sorted list
for(i=0; i<NumSegments; i++) {
PointX1[i] = ResultPointX1[i];
PointY1[i] = ResultPointY1[i];
PointX2[i] = ResultPointX2[i];
PointY2[i] = ResultPointY2[i];
SegmentType[i] = ResultSegmentType[i];
SegmentCurve[i] = ResultSegmentCurve[i];
SegmentWidth[i] = ResultSegmentWidth[i];
}
return NumSegments-NumPointsUsed; // return number of pending points
} // SortPointsEx
////////////////////////////////////////////////////
void CloseOpenPolygon (void) {
int i, LineAdded;
int RemainingPoints, LastPoint;
do {
LineAdded = false;
RemainingPoints = SortPointsEx();
LastPoint = NumSegments - RemainingPoints - 1;
if(RemainingPoints) { // only search for gaps if remainingpoints != 0
for(i=LastPoint+1; i<NumSegments; i++) { // start from last+1 poly-segment -> search for points within circle
if(IsPointInCircle(PointX1[i], PointY1[i], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
PointX1[NumSegments] = PointX2[LastPoint]; // add new line with start at last-point
PointY1[NumSegments] = PointY2[LastPoint];
PointX2[NumSegments] = PointX1[i];
PointY2[NumSegments] = PointY1[i];
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
SegmentCurve[NumSegments++] = 0; // 2013-12-11
LineAdded = true;
break; // point within circle found and added -> escape from "for"-loop
}
if(IsPointInCircle(PointX2[i], PointY2[i], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
PointX1[NumSegments] = PointX2[LastPoint]; // add new line with start at last-point
PointY1[NumSegments] = PointY2[LastPoint];
PointX2[NumSegments] = PointX2[i];
PointY2[NumSegments] = PointY2[i];
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
SegmentCurve[NumSegments++] = 0; // 2013-12-11
LineAdded = true;
break; // point within circle found and added -> escape from "for"-loop
}
}
}
} while(LineAdded); // resort points and close gaps if new line added
// finished correct -> but is polygon closed ?!? (firstpoint and lastpoint may no be the same coordinate !)
if(IsPointEqual(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint]) == false) { // poly closed ?
if(IsPointInCircle(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
PointX1[NumSegments] = PointX2[LastPoint]; // add new line with start at last-point
PointY1[NumSegments] = PointY2[LastPoint];
PointX2[NumSegments] = PointX1[0];
PointY2[NumSegments] = PointY1[0];
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
SegmentCurve[NumSegments++] = 0; // 2013-12-11
}
}
return;
}
////////////////////////////////////////////////////
int SortPoints(string ElementName) { // sort all points to a continous polygon
int LastPoint, RemainingPoints;
// close open polygon
if (CloseOpenPoly) CloseOpenPolygon();
// do final sorting
RemainingPoints = SortPointsEx();
// check if polygon is closed
LastPoint = NumSegments - RemainingPoints - 1;
if (LastPoint < 0) {
dlgMessageBox("!Negativ Index in function SortPoints().", "OK");
exit(-472);
}
if(IsPointEqual(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint]) == false) {
if(SegmentType[0] != CIRCLE) {
string x;
int pt_x, pt_y;
pt_x = PointX2[LastPoint];
pt_y = PointY2[LastPoint];
sprintf(x,"!%s contains an open polygon !\n\ncoordinate : X= %.6f[mm], Y= %.6f[mm]", ElementName, u2mm(pt_x), u2mm(pt_y));
if (dlgMessageBox(x, "OK", "Show") != 0) {
sprintf(x, "WIN (%.6fmm %.6fmm);\n", u2mm(pt_x), u2mm(pt_y));
exit(x);
}
}
}
return RemainingPoints;
}
////////////////////////////////////////////////////
void IDF_LibaryHeader(UL_BOARD BRD) { //-> create header of libary
int t = time();
string date;
string sourceID;
sprintf(date, "%d/%02d/%02d.%02d:%02d:%02d", t2year(t), t2month(t), t2day(t), t2hour(t), t2minute(t), t2second(t));
sprintf(sourceID, "Commend International >%s %s %s<", UlpName, UlpVersion, EAGLE_SIGNATURE); // 2013-01-14
printf(".HEADER\n");
printf("LIBRARY_FILE 3.0 \"%s\" %s 1\n", sourceID, date);
printf(".END_HEADER\n");
return;
}
////////////////////////////////////////////////////
int CollectLibOutlineSegments(UL_ELEMENT E, int layer) { // get all segments of elements on 3D-layer
NumSegments=0;
E.package.circles(CIR) { // create circles
if(CIR.layer == layer && CIR.width > maxCutoutLineWidth) {
PointX1[NumSegments] = CIR.x;
PointY1[NumSegments] = CIR.y;
PointX2[NumSegments] = CIR.x + CIR.radius;
PointY2[NumSegments] = CIR.y;
SegmentType[NumSegments] = CIRCLE;
SegmentWidth[NumSegments] = CIR.width;
SegmentCurve[NumSegments++] = 0; // 2013-12-11
}
}
E.package.wires(W) {
if(W.curve) { // create arcs
if(W.layer == layer && W.width > maxCutoutLineWidth) {
PointX1[NumSegments] = W.x1; // 2013-03-14 use wire coordinate, not arc!
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = ARC;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments++] = W.curve; //GetArcOptions(W);
}
}
else { // create straight lines
if(W.layer == layer && W.width > maxCutoutLineWidth) {
PointX1[NumSegments] = W.x1;
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments++] = 0; // 2013-12-11
}
}
}
if(NumSegments != 0) { // show warningbox if element contains no 3d-data
if(layer == bLayer3Ddata) { // is given layer the bottom layer -> mirror
for(int i=0; i<NumSegments; i++) { // swap x-coordinate for bottom parts
PointX1[i] = E.x - ((E.x - PointX1[i])*(-1));
PointX2[i] = E.x - ((E.x - PointX2[i])*(-1));
}
}
}
return NumSegments;
}
////////////////////////////////////////////////////
void IDF_LibaryElectrical(UL_BOARD BRD) { //-> create electrical parts (R, C, IC, ...)
int i,x,inlib,NrOfPolygon;
int RemainingPoints;
string MountSide[] = {"TOP", "BOTTOM"};
int layer[] = { tLayer3Ddata, bLayer3Ddata };
for(i=0;i<NumParts;i++) {
BRD.elements(E) {
inlib = 0;
for(x=0; x<NumPacInLib; x++) { // check if new package
if(PacIn_LIB_name[x] == E.package.name &&
PacIn_LIB_angle[x] == E.angle &&
PacIn_LIB_Device_mountside[x] == E.mirror
) inlib = 1;
}
if(E.name == PartName[i] && inlib == 0) { // is package still in LIB-file
NrOfPolygon = 0;
if(DataOnLayerPresent(E, bLayer3Ddata)) NrOfPolygon=1; // if poly on bot-side found start from "1"
for(int tb=0;tb<2;tb++){
if(CollectLibOutlineSegments(E, layer[tb]) && SelectSide[tb]) { // only add package to lib if line-segments in layer found
do {
RemainingPoints = SortPoints(E.name); // returns number of open/not_used points
NumSegments -= RemainingPoints; // calculate nr of correct/used points in poly
// more than one outline in device present ?
if((NrOfPolygon == 0) && (RemainingPoints != 0)) NrOfPolygon=1;
printf(".ELECTRICAL\n");
printf("%s_ANGLE%.1f_%s.%d CI_LIB MM %.6f\n", E.package.name, E.angle, MountSide[tb], NrOfPolygon, getPartHeight());
OutputLines(E.x, E.y, OUTLINE); // add package to libfile -> subract given offsets -> E.x, E.y
printf(".END_ELECTRICAL\n");
CollectRemainingPoints(NumSegments, RemainingPoints);
PacIn_LIB_heights[NumPacInLib] = NrOfPolygon; // 0=package has only 1 poly; >0 package has more than one poly-outline
PacIn_LIB_name[NumPacInLib] = E.package.name; // mark that package is now in LIB-file
PacIn_LIB_Device_mountside[NumPacInLib] = E.mirror; // safe top- or bottom-side
PacIn_LIB_SubPart_mountside[NumPacInLib] = MountSide[tb]; // safe mountside of subparts
PacIn_LIB_angle[NumPacInLib++] = E.angle; // safe angle of partplacement
if(RemainingPoints != 0 || NrOfPolygon != 0) NrOfPolygon++;
} while(RemainingPoints != 0); // get multiple outline with multiple partheights
}
}
}
}
}
return;
}
////////////////////////////////////////////////////
void IDF_LibaryMechanical(UL_BOARD BRD) { //-> create mechanical parts (drills, holes, ...)
// not implemented yet
return;
}
////////////////////////////////////////////////////
int CollectBoardOutlineSegments(UL_BOARD BRD) { //++ get all segments of boardoutline
NumSegments = 0;
// first search board outline in board direct
BRD.circles(CIR) {
if(CIR.layer == Layer3dBoardDimension) {
if (CIR.width > maxCutoutLineWidth) {
PointX1[NumSegments] = CIR.x;
PointY1[NumSegments] = CIR.y;
PointX2[NumSegments] = CIR.x + CIR.radius;
PointY2[NumSegments] = CIR.y;
SegmentType[NumSegments] = CIRCLE;
SegmentWidth[NumSegments] = CIR.width;
SegmentCurve[NumSegments++] = 0;
}
else {
CutoutPointX1[CutoutNumSegments] = CIR.x;
CutoutPointY1[CutoutNumSegments] = CIR.y;
CutoutPointX2[CutoutNumSegments] = CIR.x + CIR.radius;
CutoutPointY2[CutoutNumSegments] = CIR.y;
CutoutSegmentType[CutoutNumSegments] = CIRCLE;
CutoutSegmentWidth[CutoutNumSegments] = CIR.width;
CutoutSegmentCurve[CutoutNumSegments++] = 0;
}
}
}
BRD.wires(W) {
if(W.layer == Layer3dBoardDimension) {
if (W.width > maxCutoutLineWidth) {
if(W.curve) { // create arcs board-outline board
PointX1[NumSegments] = W.x1; // 2013-03-14 use direct wire coordinate, not arc-coordinate
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = ARC;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments] = W.curve; // GetArcOptions(W);
}
else { // create straight lines board-outline board
PointX1[NumSegments] = W.x1;
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments] = 0;
}
NumSegments++;
}
else {
if(W.curve) { // create arcs board-outline board
CutoutPointX1[CutoutNumSegments] = W.x1;
CutoutPointY1[CutoutNumSegments] = W.y1;
CutoutPointX2[CutoutNumSegments] = W.x2;
CutoutPointY2[CutoutNumSegments] = W.y2;
CutoutSegmentType[CutoutNumSegments] = ARC;
CutoutSegmentWidth[CutoutNumSegments] = W.width;
CutoutSegmentCurve[CutoutNumSegments] = W.curve; //GetArcOptions(W);
}
else {
CutoutPointX1[CutoutNumSegments] = W.x1;
CutoutPointY1[CutoutNumSegments] = W.y1;
CutoutPointX2[CutoutNumSegments] = W.x2;
CutoutPointY2[CutoutNumSegments] = W.y2;
CutoutSegmentType[CutoutNumSegments] = LINE;
CutoutSegmentWidth[CutoutNumSegments] = W.width;
CutoutSegmentCurve[CutoutNumSegments] = 0;
}
CutoutNumSegments++;
}
}
}
// second search board outline in packages
BRD.elements(E) {
E.package.circles(CIR) { // create board-outline of package-libary
if(CIR.layer == Layer3dBoardDimension) {
PointX1[NumSegments] = CIR.x;
PointY1[NumSegments] = CIR.y;
PointX2[NumSegments] = CIR.x + CIR.radius;
PointY2[NumSegments] = CIR.y;
SegmentType[NumSegments] = CIRCLE;
SegmentWidth[NumSegments] = CIR.width;
SegmentCurve[NumSegments++] = 0;
}
}
}
BRD.elements(E) {
E.package.wires(W) {
if(W.layer == Layer3dBoardDimension) {
if (W.width > maxCutoutLineWidth) {
if(W.curve) { // create arcs board-outline of package-libary
PointX1[NumSegments] = W.x1;
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = ARC;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments] = W.curve; // GetArcOptions(W);
}
else { // create straight lines board-outline of package-libary
PointX1[NumSegments] = W.x1;
PointY1[NumSegments] = W.y1;
PointX2[NumSegments] = W.x2;
PointY2[NumSegments] = W.y2;
SegmentType[NumSegments] = LINE;
SegmentWidth[NumSegments] = W.width;
SegmentCurve[NumSegments] = 0;
}
NumSegments++;
}
else {
if(W.curve) { // create arcs board-cutout of package-libary
CutoutPointX1[CutoutNumSegments] = W.x1;
CutoutPointY1[CutoutNumSegments] = W.y1;
CutoutPointX2[CutoutNumSegments] = W.x2;
CutoutPointY2[CutoutNumSegments] = W.y2;
CutoutSegmentType[CutoutNumSegments] = ARC;
CutoutSegmentWidth[CutoutNumSegments] = W.width;
CutoutSegmentCurve[CutoutNumSegments] = W.curve; //GetArcOptions(W);
}
else { // create line board-cutout of package-libary
CutoutPointX1[CutoutNumSegments] = W.x1;
CutoutPointY1[CutoutNumSegments] = W.y1;
CutoutPointX2[CutoutNumSegments] = W.x2;
CutoutPointY2[CutoutNumSegments] = W.y2;
CutoutSegmentType[CutoutNumSegments] = LINE;
CutoutSegmentWidth[CutoutNumSegments] = W.width;
CutoutSegmentCurve[CutoutNumSegments] = 0;
}
CutoutNumSegments++;
}
}
}
}
if(NumSegments == 0) {
string error;
sprintf(error,"!No board-outline on layer %d found !", Layer3dBoardDimension);
dlgMessageBox(error);
exit(-771);
}
return NumSegments;
}
////////////////////////////////////////////////////
void IDF_BoardHeader(UL_BOARD BRD) { //-## create header of boardfile
int t = time();
string date;
string sourceID;
sprintf(date, "%d/%02d/%02d.%02d:%02d:%02d", t2year(t), t2month(t), t2day(t), t2hour(t), t2minute(t), t2second(t));
sprintf(sourceID, "Commend International >%s %s %s<", UlpName, UlpVersion, EAGLE_SIGNATURE);
printf(".HEADER\n");
printf("BOARD_FILE 3.0 \"%s\" %s 1\n", sourceID, date);
printf("\"%s\" MM\n", filename(BRD.name));
printf(".END_HEADER\n");
return;
}
////////////////////////////////////////////////////
void IDF_BoardOutline(UL_BOARD BRD) { //-## create outline of board
// get outline
CollectBoardOutlineSegments(BRD);
SortPoints("Board-Outline"); // boardname
// draw outline
printf(".BOARD_OUTLINE UNOWNED\n");
printf("%.6f\n", getPartHeight());
OutputBoardOutLines(0, 0, OUTLINE); // subract given offsets -> E.x, E.y
OutputBoardCutOutLines(0, 0, OUTLINE);
printf(".END_BOARD_OUTLINE\n");
LoopCounter = 0;
return;
}
////////////////////////////////////////////////////
void IDF_BoardPlaceParts(UL_BOARD BRD) { //-## mount parts on board
int i, inlib;
string MountSide[] = {"TOP","BOTTOM"};
printf(".PLACEMENT\n");
BRD.elements(E) {
inlib = 0;
for(i=0; i<NumPacInLib; i++) { // check if elements was found in libary
if(PacIn_LIB_name[i] == E.package.name && PacIn_LIB_Device_mountside[i] == E.mirror && PacIn_LIB_angle[i] == E.angle) {
inlib = 1;
break;
}
}
if(inlib) { // only add part if part is in lib-file
if(PacIn_LIB_heights[i] == 0) { // part has only one height
printf("%s_ANGLE%.1f_%s.0 CI_LIB %s.0\n", E.package.name, E.angle, PacIn_LIB_SubPart_mountside[i], E.name);
printf("%.6f %.6f 0 0 %s PLACED\n", u2mm(E.x), u2mm(E.y), MountSide[E.mirror]);
}
else { // part has multiple heights -> more than one part on same x/y position
int lib_start = i;
do {
printf("%s_ANGLE%.1f_%s.%d CI_LIB %s.%d\n", E.package.name, E.angle, PacIn_LIB_SubPart_mountside[lib_start], PacIn_LIB_heights[lib_start], E.name, PacIn_LIB_heights[lib_start]);
printf("%.6f %.6f 0 0 %s PLACED\n", u2mm(E.x), u2mm(E.y), PacIn_LIB_SubPart_mountside[lib_start]);
lib_start++;
}while(PacIn_LIB_heights[lib_start] > 1);
}
}
}
printf(".END_PLACEMENT\n");
return;
}
////////////////////////////////////////////////////
void IDF_BoardHoles(UL_BOARD BRD) { //-## create holes in board (cutout, partholes, ...)
printf(".DRILLED_HOLES\n");
// drill holes from board direct
BRD.holes(H)
printf("%.6f %.6f %.6f NPTH BOARD Other UNOWNED\n", u2mm(H.drill), u2mm(H.x), u2mm(H.y));
// drill holes from elements
BRD.elements(E) {
E.package.holes(H)
printf("%.6f %.6f %.6f NPTH BOARD Other UNOWNED\n", u2mm(H.drill), u2mm(H.x), u2mm(H.y));
}
// drill pad(holes) from elements 2014-01-20
BRD.elements(E) {
E.package.contacts(C)
if (C.pad)
if (u2mm(C.pad.drill) > MinViaHoleDia)
printf("%.6f %.6f %.2f PTH BOARD Other UNOWNED\n", u2mm(C.pad.drill), u2mm(C.pad.x), u2mm(C.pad.y));
}
// drill big via's
BRD.signals(S) {
S.vias(V) {
if((DrillViaHoles == true) && (u2mm(V.drill) > MinViaHoleDia)) // drill via-hole
printf("%.6f %.6f %.6f PTH BOARD VIA UNOWNED\n", u2mm(V.drill), u2mm(V.x), u2mm(V.y));
}
}
printf(".END_DRILLED_HOLES\n");
return;
}
////////////////////////////////////////////////////
void IDF_CreateLibaryFile(UL_BOARD BRD, string fname) { // create libary for the IDF-board
output(fname, "wt") {
IDF_LibaryHeader(BRD);
IDF_LibaryElectrical(BRD);
IDF_LibaryMechanical(BRD);
}
return;
}
////////////////////////////////////////////////////
void IDF_CreateBoardFile(UL_BOARD BRD, string fname) { // create boardfile with parts of libary
output(fname, "wt") {
IDF_BoardHeader(BRD);
IDF_BoardOutline(BRD);
IDF_BoardHoles(BRD);
IDF_BoardPlaceParts(BRD);
}
return;
}
////////////////////////////////////////////////////
void DisplayHelp(void) { // show helptext
dlgDialog("Generate 3D IDF data") {
dlgLabel("Version " + UlpVersion);
dlgHBoxLayout dlgSpacing(500);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(200);
dlgTextView(usage);
}
dlgLabel(Docuemantpath);
dlgHBoxLayout {
dlgStretch(1);
dlgPushButton("-Back") dlgReject();
}
};
return;
}
////////////////////////////////////////////////////
// S T A R T of U L P
//
if (board) {
int proceed = 0;
string FileDirectoryName;
string FilenamePanel;
string FileNameIDB; // Board
string FileNameIDL; // Library
board(BRD) {
FileDirectoryName = filedir(BRD.name);
FileNameIDB = filesetext(filename(BRD.name), ".IDB");
FileNameIDL = filesetext(filename(BRD.name), ".IDL");
}
dlgDialog("Generate 3D data format (IDF-file)") {
dlgHBoxLayout {
dlgGroup(" settings ") {
dlgGridLayout {
dlgCell(0,0) dlgCheckBox("close polygon if gap is smaller than : ", CloseOpenPoly);
dlgCell(0,1) dlgRealEdit(MaxGapWidth);
dlgCell(0,2) dlgLabel(" mm");
dlgCell(1,0) dlgCheckBox("drill via-holes if via is bigger than : ", DrillViaHoles);
dlgCell(1,1) dlgRealEdit(MinViaHoleDia);
dlgCell(1,2) dlgLabel(" mm");
dlgCell(2,0) dlgCheckBox("Export top parts", SelectSide[0]);
dlgCell(3,0) dlgCheckBox("Export bottom parts", SelectSide[1]);
}
}
}
dlgGridLayout {
dlgCell(1,0) dlgLabel("Output Directory:");
dlgCell(1,1) dlgLabel(FileDirectoryName, 1);
dlgCell(1,2) {
dlgPushButton("Browse") {
string fdn = dlgDirectory("Save IDF file", FileDirectoryName);
if (fdn) {
int len = strlen(fdn);
if (fdn[len] != '/') fdn+="/"; // dlgDirectory gibt den Pfad ohne abschliessenden Slash zurück!
FileDirectoryName = fdn;
}
}
}
dlgCell(2,0) dlgLabel("Filename IDB (Board)");
dlgCell(2,1) dlgStringEdit(FileNameIDB);
dlgCell(2,2) {
dlgPushButton("Browse") {
string fdb = dlgFileSave("Save IDF file", FileDirectoryName, "IDF files (*.IDB)");
if (fdb) {
FileNameIDB = filename(fdb);
if(strchr(FileNameIDB, '.') < 0) // add fileextension if missing
FileNameIDB += ".IDB";
FileNameIDL = filesetext(FileNameIDB, ".IDL");
}
}
}
dlgCell(3,0) dlgLabel("Filename IDL (Library)");
dlgCell(3,1) dlgStringEdit(FileNameIDL);
dlgCell(3,2) {
dlgPushButton("Browse") {
string fdl = dlgFileSave("Save IDF file", FileDirectoryName, "IDF files (*.IDL)");
if (fdl) {
FileNameIDL = filename(fdl);
if(strchr(FileNameIDL, '.') < 0) // add fileextension if missing
FileNameIDL += ".IDL";
FileNameIDB = filesetext(FileNameIDL, ".IDB");
}
}
}
}
dlgHBoxLayout {
dlgPushButton("OK") { proceed = 1; dlgAccept(); }
dlgPushButton("Cancel") dlgReject();
dlgStretch(1);
dlgLabel("Version: " + UlpVersion);
dlgPushButton("Help") DisplayHelp();
}
};
if(proceed) {
project.board(BRD) {
CollectPartData(BRD); // read out data from BRD
IDF_CreateLibaryFile(BRD, FileNameIDL);
IDF_CreateBoardFile(BRD, FileNameIDB);
}
}
}
else {
dlgMessageBox(usage + "<hr><b>ERROR: No board!</b><p>\nThis program can only work in the layout editor.");
exit(0);
}
Reference in New Issue Copy Permalink