haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/pcbnew/plotgerb.cpp

906 lines
24 KiB
C++
Raw Blame History

/****************************************/
/**** Routine de trace GERBER RS274X ****/
/****************************************/
#include "fctsys.h"
#include "common.h"
#include "plot_common.h"
#include "pcbnew.h"
#include "pcbplot.h"
#include "trigo.h"
#include "plotgerb.h"
#include "protos.h"
/* Variables locales : */
static int s_Last_D_code;
static float Gerb_scale_plot; // Coeff de conversion d'unites des traces
static int scale_spot_mini; // Ouverture mini (pour remplissages)
static D_CODE * s_DCodeList; // Pointeur sur la zone de stockage des D_CODES
wxString GerberFullFileName;
static double scale_x, scale_y; // echelles de convertion en X et Y (compte tenu
// des unites relatives du PCB et des traceurs
static bool ShowDcodeError = TRUE;
/* Routines Locales */
static void Init_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile);
static void Init_ApertureList();
static void Fin_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile);
static void Plot_1_CIRCLE_pad_GERBER(wxPoint pos, int diametre);
static void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient);
static void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient);
static D_CODE * get_D_code(int dx, int dy, int type, int drill);
static void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size, wxSize delta,
int orient, int modetrace);
/********************************************************************************/
void WinEDA_BasePcbFrame::Genere_GERBER(const wxString & FullFileName, int Layer,
bool PlotOriginIsAuxAxis)
/********************************************************************************/
/* Genere les divers fichiers de trace:
* Pour chaque couche 1 fichier xxxc.PHO au format RS274X
*/
{
int tracevia = 1;
EraseMsgBox();
GerberFullFileName = FullFileName;
g_PlotOrient = 0;
if( Plot_Set_MIROIR )
g_PlotOrient |= PLOT_MIROIR;
/* Calcul des echelles de conversion */
Gerb_scale_plot = 1.0; /* pour unites gerber en 0,1 Mils, format 3.4 */
scale_spot_mini = (int)(10 * spot_mini * Gerb_scale_plot);
scale_x = Scale_X * Gerb_scale_plot;
scale_y = Scale_Y * Gerb_scale_plot;
g_PlotOffset.x = 0;
g_PlotOffset.y = 0;
if( PlotOriginIsAuxAxis )
g_PlotOffset = m_Auxiliary_Axis_Position;
dest = wxFopen( FullFileName, wxT("wt") );
if( dest == NULL )
{
wxString msg = _("unable to create file ") + FullFileName;
DisplayError(this, msg);
return;
}
setlocale(LC_NUMERIC, "C");
InitPlotParametresGERBER(g_PlotOffset, scale_x, scale_y);
/* Clear the memory used for handle the D_CODE (aperture) list */
Init_ApertureList();
Affiche_1_Parametre(this, 0, _("File"), FullFileName, CYAN);
Init_Trace_GERBER(this, dest);
nb_plot_erreur = 0;
int layer_mask = g_TabOneLayerMask[Layer];
// Specify that the contents of the "Edges Pcb" layer are also to be
// plotted, unless the option of excluding that layer has been selected.
if( ! Exclude_Edges_Pcb )
layer_mask |= EDGE_LAYER;
switch( Layer )
{
case FIRST_COPPER_LAYER:
case LAYER_N_2:
case LAYER_N_3:
case LAYER_N_4:
case LAYER_N_5:
case LAYER_N_6:
case LAYER_N_7:
case LAYER_N_8:
case LAYER_N_9:
case LAYER_N_10:
case LAYER_N_11:
case LAYER_N_12:
case LAYER_N_13:
case LAYER_N_14:
case LAYER_N_15:
case LAST_COPPER_LAYER:
Plot_Layer_GERBER(dest, layer_mask, 0, 1);
break;
case SOLDERMASK_N_CU:
case SOLDERMASK_N_CMP: /* Trace du vernis epargne */
if( g_DrawViaOnMaskLayer )
tracevia = 1;
else
tracevia = 0;
Plot_Layer_GERBER(dest, layer_mask, g_DesignSettings.m_MaskMargin, tracevia);
break;
case SOLDERPASTE_N_CU:
case SOLDERPASTE_N_CMP: /* Trace du masque de pate de soudure */
Plot_Layer_GERBER(dest, layer_mask, 0, 0);
break;
default:
Plot_Serigraphie(PLOT_FORMAT_GERBER, dest, layer_mask);
break;
}
Fin_Trace_GERBER( this, dest );
setlocale( LC_NUMERIC, "" );
}
/***********************************************************************/
void WinEDA_BasePcbFrame::Plot_Layer_GERBER(FILE * File,int masque_layer,
int garde, int tracevia)
/***********************************************************************/
/* Trace en format GERBER. d'une couche cuivre ou masque
*/
{
wxPoint pos;
wxSize size;
MODULE * Module;
D_PAD * PtPad;
TRACK * track ;
EDA_BaseStruct * PtStruct;
wxString msg;
// (Following command has been superceded by new command on lines 93 and 94.)
// masque_layer |= EDGE_LAYER; /* Les elements de la couche EDGE sont tj traces */
/* trace des elements type Drawings Pcb : */
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
switch( PtStruct->Type() )
{
case TYPEDRAWSEGMENT:
PlotDrawSegment( (DRAWSEGMENT*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer );
break;
case TYPETEXTE:
PlotTextePcb( (TEXTE_PCB*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer );
break;
case TYPECOTATION:
PlotCotation( (COTATION*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer );
break;
case TYPEMIRE:
PlotMirePcb( (MIREPCB*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer );
break;
case TYPEMARKER:
break;
default:
DisplayError( this, wxT("Type Draw non gere") );
break;
}
}
/* Trace des Elements des modules autres que pads */
nb_items = 0;
Affiche_1_Parametre(this, 38, wxT("DrawMod"), wxEmptyString, GREEN);
Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE *)Module->Pnext )
{
PtStruct = Module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
switch( PtStruct->Type() )
{
case TYPEEDGEMODULE:
if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->GetLayer()] )
Plot_1_EdgeModule(PLOT_FORMAT_GERBER, (EDGE_MODULE*) PtStruct);
break;
default:
break;
}
}
}
/* Trace des Elements des modules : Pastilles */
nb_items = 0;
Affiche_1_Parametre(this, 48, wxT("Pads"), wxEmptyString, GREEN);
Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE *)Module->Pnext )
{
PtPad = (D_PAD*) Module->m_Pads;
for( ; PtPad != NULL; PtPad = (D_PAD*)PtPad->Pnext )
{
wxPoint shape_pos;
if( (PtPad->m_Masque_Layer & masque_layer) == 0 )
continue;
shape_pos = PtPad->ReturnShapePos();
pos = shape_pos;
size.x = PtPad->m_Size.x + 2 * garde;
size.y = PtPad->m_Size.y + 2 * garde;
/* Don't draw a null size item : */
if( size.x <= 0 || size.y <= 0 )
continue;
nb_items++;
switch( PtPad->m_PadShape )
{
case PAD_CIRCLE:
Plot_1_CIRCLE_pad_GERBER(pos, size.x);
break;
case PAD_OVAL:
// Check whether the pad really has a circular shape instead
if( size.x == size.y )
Plot_1_CIRCLE_pad_GERBER(pos, size.x);
else
trace_1_pastille_OVALE_GERBER(pos, size, PtPad->m_Orient);
break;
case PAD_TRAPEZOID:
{
wxSize delta = PtPad->m_DeltaSize;
trace_1_pad_TRAPEZE_GERBER(pos, size,
delta, PtPad->m_Orient, FILLED);
}
break;
case PAD_RECT:
default:
PlotRectangularPad_GERBER(pos, size, PtPad->m_Orient);
break;
}
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 48, wxEmptyString, msg, GREEN);
}
}
/* trace des VIAS : */
if( tracevia )
{
nb_items = 0;
Affiche_1_Parametre(this, 56, wxT("Vias"), wxEmptyString, RED);
for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{
if( track->Type() != TYPEVIA )
continue;
SEGVIA * Via = (SEGVIA *) track;
// vias not plotted if not on selected layer, but if layer
// == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn,
// if they are on a external copper layer
int via_mask_layer = Via->ReturnMaskLayer();
if( via_mask_layer & CUIVRE_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CU;
if( via_mask_layer & CMP_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CMP;
if( ( via_mask_layer & masque_layer) == 0 )
continue;
pos = Via->m_Start;
size.x = size.y = Via->m_Width + 2 * garde;
/* Don't draw a null size item : */
if( size.x <= 0 )
continue;
Plot_1_CIRCLE_pad_GERBER(pos, size.x);
nb_items++;
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 56, wxEmptyString, msg, RED);
}
}
/* trace des pistes : */
nb_items = 0;
Affiche_1_Parametre(this, 64, wxT("Tracks"), wxEmptyString, YELLOW);
for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{
wxPoint end;
if( track->Type() == TYPEVIA )
continue;
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 )
continue;
size.x = size.y = track->m_Width;
pos = track->m_Start;
end = track->m_End;
PlotGERBERLine(pos, end, size.x);
nb_items++;
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 64, wxEmptyString, msg, YELLOW);
}
/* trace des zones: */
nb_items = 0;
if( m_Pcb->m_Zone )
Affiche_1_Parametre(this, 72, wxT("Zones "), wxEmptyString, YELLOW);
for( track = m_Pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext )
{
wxPoint end;
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 )
continue;
size.x = size.y = track->m_Width;
pos = track->m_Start;
end = track->m_End;
PlotGERBERLine(pos, end, size.x);
nb_items++;
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 72, wxEmptyString, msg, YELLOW);
}
}
/**********************************************************************/
void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient)
/**********************************************************************/
/* Trace 1 pastille PAD_OVAL en position pos_X,Y:
* dimensions dx, dy,
* orientation orient
* Pour une orientation verticale ou horizontale, la forme est flashee
* Pour une orientation quelconque la forme est tracee comme un segment
*/
{
D_CODE * dcode_ptr;
int x0, y0, x1, y1, delta;
if( orient == 900 || orient == 2700 ) /* orient tournee de 90 deg */
EXCHG(size.x, size.y);
/* Trace de la forme flashee */
if( orient == 0 || orient == 900 || orient == 1800 || orient == 2700 )
{
UserToDeviceCoordinate(pos);
UserToDeviceSize(size);
dcode_ptr = get_D_code(size.x, size.y, GERB_OVALE, 0);
if( dcode_ptr->m_NumDcode != s_Last_D_code )
{
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode);
fputs(cbuf, dest);
s_Last_D_code = dcode_ptr->m_NumDcode;
}
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y);
fputs(cbuf, dest);
}
else /* Forme tracee comme un segment */
{
if( size.x > size.y )
{
EXCHG(size.x, size.y);
if( orient < 2700 )
orient += 900;
else
orient -= 2700;
}
/* la pastille est ramenee a une pastille ovale avec dy > dx */
delta = size.y - size.x;
x0 = 0;
y0 = -delta / 2;
x1 = 0;
y1 = delta / 2;
RotatePoint(&x0, &y0, orient);
RotatePoint(&x1, &y1, orient);
PlotGERBERLine( wxPoint(pos.x + x0, pos.y + y0),
wxPoint(pos.x + x1, pos.y + y1), size.x );
}
}
/******************************************************************/
void Plot_1_CIRCLE_pad_GERBER(wxPoint pos,int diametre)
/******************************************************************/
/* Plot a circular pad or via at the user position pos
*/
{
D_CODE * dcode_ptr;
wxSize size(diametre, diametre);
UserToDeviceCoordinate(pos);
UserToDeviceSize(size);
dcode_ptr = get_D_code(size.x, size.x, GERB_CIRCLE, 0);
if( dcode_ptr->m_NumDcode != s_Last_D_code )
{
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode);
fputs(cbuf, dest);
s_Last_D_code = dcode_ptr->m_NumDcode;
}
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y);
fputs(cbuf, dest);
}
/**************************************************************************/
void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient)
/**************************************************************************/
/* Trace 1 pad rectangulaire d'orientation quelconque
* donne par son centre, ses dimensions, et son orientation
* Pour une orientation verticale ou horizontale, la forme est flashee
* Pour une orientation quelconque la forme est tracee par 4 segments
* de largeur 1/2 largeur pad
*/
{
D_CODE * dcode_ptr;
/* Trace de la forme flashee */
switch( orient )
{
case 900:
case 2700: /* la rotation de 90 ou 270 degres revient a permutter des dimensions */
EXCHG(size.x, size.y);
// Pass through
case 0:
case 1800:
UserToDeviceCoordinate(pos);
UserToDeviceSize(size);
dcode_ptr = get_D_code(size.x, size.y, GERB_RECT, 0);
if( dcode_ptr->m_NumDcode != s_Last_D_code )
{
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode);
fputs(cbuf, dest);
s_Last_D_code = dcode_ptr->m_NumDcode;
}
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y);
fputs(cbuf, dest);
break;
default: /* Forme tracee par remplissage */
trace_1_pad_TRAPEZE_GERBER(pos, size, wxSize(0, 0), orient, FILLED);
break;
}
}
/*****************************************************************/
void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta,
int penwidth, int orient)
/*****************************************************************/
/* Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque
* donne par son centre,
* ses dimensions ,
* ses variations ,
* l'epaisseur du trait,
* et son orientation orient
*/
{
int ii;
wxPoint coord[4];
size.x /= 2;
size.y /= 2;
delta.x /= 2;
delta.y /= 2; /* demi dim dx et dy */
coord[0].x = pos.x - size.x - delta.y;
coord[0].y = pos.y + size.y + delta.x;
coord[1].x = pos.x - size.x + delta.y;
coord[1].y = pos.y - size.y - delta.x;
coord[2].x = pos.x + size.x - delta.y;
coord[2].y = pos.y - size.y + delta.x;
coord[3].x = pos.x + size.x + delta.y;
coord[3].y = pos.y + size.y - delta.x;
for( ii = 0; ii < 4; ii++ )
{
RotatePoint(&coord[ii].x, &coord[ii].y, pos.x, pos.y, orient);
}
PlotGERBERLine( coord[0], coord[1], penwidth );
PlotGERBERLine( coord[1], coord[2], penwidth );
PlotGERBERLine( coord[2], coord[3], penwidth );
PlotGERBERLine( coord[3], coord[0], penwidth );
}
/*******************************************************************/
void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size,wxSize delta,
int orient,int modetrace)
/*******************************************************************/
/* Trace 1 pad trapezoidal donne par :
* son centre pos.x,pos.y
* ses dimensions size.x et size.y
* les variations delta.x et delta.y ( 1 des deux au moins doit etre nulle)
* son orientation orient en 0.1 degres
* le mode de trace (FILLED, SKETCH, FILAIRE)
*
* Le trace n'est fait que pour un trapeze, c.a.d que delta.x ou delta.y
* = 0.
*
* les notation des sommets sont ( vis a vis de la table tracante )
*
* " 0 ------------- 3 "
* " . . "
* " . O . "
* " . . "
* " 1 ---- 2 "
*
*
* exemple de Disposition pour delta.y > 0, delta.x = 0
* " 1 ---- 2 "
* " . . "
* " . O . "
* " . . "
* " 0 ------------- 3 "
*
*
* exemple de Disposition pour delta.y = 0, delta.x > 0
* " 0 "
* " . . "
* " . . "
* " . 3 "
* " . . "
* " . O . "
* " . . "
* " . 2 "
* " . . "
* " . . "
* " 1 "
*/
{
int ii, jj;
int dx, dy;
wxPoint polygone[4]; /* coord sommets */
int coord[8];
int ddx, ddy;
/* calcul des dimensions optimales du spot choisi = 1/4 plus petite dim */
dx = size.x - abs(delta.y);
dy = size.y - abs(delta.x);
dx = size.x / 2;
dy = size.y / 2;
ddx = delta.x / 2;
ddy = delta.y / 2;
polygone[0].x = - dx - ddy;
polygone[0].y = + dy + ddx;
polygone[1].x = - dx + ddy;
polygone[1].y = - dy - ddx;
polygone[2].x = + dx - ddy;
polygone[2].y = - dy + ddx;
polygone[3].x = + dx + ddy;
polygone[3].y = + dy - ddx;
/* Dessin du polygone et Remplissage eventuel de l'interieur */
for( ii = 0, jj = 0; ii < 4; ii++ )
{
RotatePoint(&polygone[ii].x, &polygone[ii].y, orient);
coord[jj] = polygone[ii].x += pos.x;
jj++;
coord[jj] = polygone[ii].y += pos.y;
jj++;
}
if( modetrace != FILLED )
{
PlotGERBERLine( polygone[0], polygone[1], scale_spot_mini );
PlotGERBERLine( polygone[1], polygone[2], scale_spot_mini );
PlotGERBERLine( polygone[2], polygone[3], scale_spot_mini );
PlotGERBERLine( polygone[3], polygone[0], scale_spot_mini );
}
else
PlotPolygon_GERBER(4, coord, TRUE);
}
/**********************************************************/
void PlotGERBERLine(wxPoint start, wxPoint end, int large)
/**********************************************************/
/* Trace 1 segment de piste :
*/
{
D_CODE * dcode_ptr;
UserToDeviceCoordinate(start);
UserToDeviceCoordinate(end);
dcode_ptr = get_D_code(large, large, GERB_LINE, 0);
if(dcode_ptr->m_NumDcode != s_Last_D_code )
{
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode);
fputs(cbuf, dest);
s_Last_D_code = dcode_ptr->m_NumDcode;
}
sprintf(cbuf, "X%5.5dY%5.5dD02*\n", start.x, start.y);
fputs(cbuf, dest);
sprintf(cbuf, "X%5.5dY%5.5dD01*\n", end.x, end.y);
fputs(cbuf, dest);
}
/********************************************************************/
void PlotCircle_GERBER( wxPoint centre, int rayon, int epaisseur )
/********************************************************************/
/* routine de trace de 1 cercle de centre centre par approximation de segments
*/
{
int ii;
int ox, oy, fx, fy;
int delta; /* increment (en 0.1 degres) angulaire pour trace de cercles */
delta = 120; /* un cercle sera trace en 3600/delta segments */
/* Correction pour petits cercles par rapport a l'epaisseur du trait */
if( rayon < (epaisseur * 10) )
delta = 225; /* 16 segm pour 360 deg */
if( rayon < (epaisseur * 5) )
delta = 300; /* 12 segm pour 360 deg */
if( rayon < (epaisseur * 2) )
delta = 600; /* 6 segm pour 360 deg */
ox = centre.x + rayon;
oy = centre.y;
for( ii = delta; ii < 3600; ii += delta )
{
fx = centre.x + (int)(rayon * fcosinus[ii]);
fy = centre.y + (int)(rayon * fsinus[ii]);
PlotGERBERLine(wxPoint(ox, oy), wxPoint(fx, fy), epaisseur);
ox = fx;
oy = fy;
}
fx = centre.x + rayon;
fy = centre.y;
PlotGERBERLine(wxPoint(ox ,oy), wxPoint(fx, fy), epaisseur);
}
/***************************************************************/
void PlotPolygon_GERBER(int nb_segm, int * coord, bool fill)
/***************************************************************/
{
int ii;
wxPoint pos;
fputs("G36*\n", dest);
pos.x = *coord;
coord++;
pos.y = *coord;
coord++;
UserToDeviceCoordinate(pos);
fprintf( dest, "X%5.5dY%5.5dD02*\n", pos.x, pos.y );
for( ii = 1; ii < nb_segm; ii++ )
{
pos.x = *coord;
coord++;
pos.y = *coord;
coord++;
UserToDeviceCoordinate(pos);
fprintf( dest, "X%5.5dY%5.5dD01*\n", pos.x, pos.y );
}
fputs("G37*\n", dest);
}
/*******************************************************/
D_CODE * get_D_code( int dx, int dy, int type, int drill )
/*******************************************************/
/* Fonction Recherchant et Creant eventuellement la description
* du D_CODE du type et dimensions demandees
*/
{
D_CODE * ptr_tool, * last_dcode_ptr;
int num_new_D_code = FIRST_DCODE_VALUE;
ptr_tool = last_dcode_ptr = s_DCodeList;
while( ptr_tool && ptr_tool->m_Type >= 0 )
{
if( ( ptr_tool->m_Size.x == dx ) &&
( ptr_tool->m_Size.y == dy ) &&
( ptr_tool->m_Type == type ) )
return(ptr_tool); /* D_code deja existant */
last_dcode_ptr = ptr_tool;
ptr_tool = ptr_tool->m_Pnext;
num_new_D_code++;
}
/* At this point, the requested D_CODE does not exist: It will be created */
if( ptr_tool == NULL ) /* We must create a new data */
{
ptr_tool = new D_CODE();
ptr_tool->m_NumDcode = num_new_D_code;
if( last_dcode_ptr )
{
ptr_tool->m_Pback = last_dcode_ptr;
last_dcode_ptr->m_Pnext = ptr_tool;
}
else
s_DCodeList = ptr_tool;
}
ptr_tool->m_Size.x = dx;
ptr_tool->m_Size.y = dy;
ptr_tool->m_Type = type;
return(ptr_tool);
}
/******************************************************************/
void Init_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile)
/******************************************************************/
{
char Line[1024];
s_Last_D_code = 0;
DateAndTime(Line);
wxString Title = g_Main_Title + wxT(" ") + GetBuildVersion();
fprintf(gerbfile, "G04 (Genere par %s) le %s*\n", CONV_TO_UTF8(Title), Line);
// Specify linear interpol (G01), unit = INCH (G70), abs format (G90):
fputs("G01*\nG70*\nG90*\n", gerbfile);
fputs("%MOIN*%\n", gerbfile); // set unites = INCHES
/* Set gerber format to 3.4 */
strcpy(Line, "G04 Gerber Fmt 3.4, Leading zero omitted, Abs format*\n%FSLAX34Y34*%\n");
fputs(Line, gerbfile);
fputs("G04 APERTURE LIST*\n", gerbfile);
}
/***********************************/
static void Init_ApertureList()
/***********************************/
/* Init the memory to handle the aperture list:
* the member .m_Type is used by get_D_code() to handle the end of list:
* .m_Type < 0 is the first free aperture descr
*/
{
D_CODE * ptr_tool;
ptr_tool = s_DCodeList;
while( ptr_tool )
{
s_DCodeList->m_Type = -1;
ptr_tool = ptr_tool->m_Pnext;
}
ShowDcodeError = TRUE;
}
/*****************************************************************/
void Fin_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile)
/*****************************************************************/
{
char line[1024];
wxString TmpFileName, msg;
FILE * outfile;
fputs("M02*\n", gerbfile);
fclose(gerbfile);
// Reouverture gerbfile pour ajout des Apertures
gerbfile = wxFopen( GerberFullFileName, wxT("rt") );
if( gerbfile == NULL )
{
msg.Printf( _("unable to reopen file <%s>"), GerberFullFileName.GetData() );
DisplayError(frame, msg);
return;
}
// Ouverture tmpfile
TmpFileName = GerberFullFileName + wxT(".$$$");
outfile = wxFopen( TmpFileName, wxT("wt") );
if( outfile == NULL )
{
fclose(gerbfile);
DisplayError(frame, wxT("Fin_Trace_GERBER(): Can't Open tmp file"));
return;
}
// Placement des Apertures en RS274X
rewind(gerbfile);
while( fgets(line, 1024, gerbfile) )
{
fputs(line, outfile);
if( strcmp(strtok(line, "\n\r"), "G04 APERTURE LIST*") == 0 )
{
frame->Gen_D_CODE_File(outfile);
fputs("G04 APERTURE END LIST*\n", outfile);
}
}
fclose(outfile);
fclose(gerbfile);
wxRemoveFile(GerberFullFileName);
wxRenameFile(TmpFileName, GerberFullFileName);
}
/******************************************************/
int WinEDA_BasePcbFrame::Gen_D_CODE_File(FILE * penfile)
/******************************************************/
/* Genere la liste courante des D_CODES
* Retourne le nombre de D_Codes utilises
* Genere une sequence RS274X
*/
{
D_CODE * ptr_tool;
int nb_dcodes = 0 ;
/* Init : */
ptr_tool = s_DCodeList;
while( ptr_tool && ( ptr_tool->m_Type >= 0 ) )
{
float fscale = 0.0001; // For 3.4 format
char * text;
sprintf(cbuf, "%%ADD%d", ptr_tool->m_NumDcode);
text = cbuf + strlen(cbuf);
switch( ptr_tool->m_Type )
{
case 1: // Circle (flash )
sprintf(text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale);
break;
case 2: // PAD_RECT
sprintf(text, "R,%fX%f*%%\n", ptr_tool->m_Size.x * fscale,
ptr_tool->m_Size.y * fscale);
break;
case 3: // Circle ( lines )
sprintf(text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale);
break;
case 4: // PAD_OVAL
sprintf(text, "O,%fX%f*%%\n", ptr_tool->m_Size.x * fscale,
ptr_tool->m_Size.y * fscale);
break;
default:
DisplayError( this, wxT("Gen_D_CODE_File(): Dcode Type err") );
break;
}
// compensation localisation printf (float x.y g<>n<EFBFBD>r<EFBFBD> x,y)
to_point( text + 2 );
fputs(cbuf, penfile);
ptr_tool = ptr_tool->m_Pnext;
nb_dcodes++;
}
return( nb_dcodes );
}
Reference in New Issue View Git Blame Copy Permalink