Skip to content

K
kicad-source-mirror
Commit 26736baa authored by dickelbeck's avatar dickelbeck
Browse files
Options

gerbview cleanup, and working towards aperture macro support

parent eac91489
Hide whitespace changes
Inline Side-by-side
Showing with 392 additions and 295 deletions
change_log.txt
View file @ 26736baa
......@@ -5,6 +5,17 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with
email address.
2008-Nov-8 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+gerview
Added support for reading in aperture macros embedded in a RS274X compatible file.
Cannot display them yet.
General cleanup of gerbview. GERBER_Descr replaced with class GERBER.
ReturnToolDescr() replaced with GERBER::GetDCODE().
D_CODEs are created lazily now. pcbnew's gerber plotting needs testing, might
have broke something there, accidentally.
2008-nov-5 UPDATE Andrey Fedorushkov <andrf@mail.ru>
================================================================================
+all:
......
gerbview/affiche.cpp
View file @ 26736baa
......@@ -31,14 +31,14 @@ void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
else
Affiche_1_Parametre( frame, 1, _( "PCB Text" ), pt_texte->m_Text, DARKGREEN );
Line = _( "Layer " );
Line = _( "Layer " );
Line << pt_texte->GetLayer() + 1;
Affiche_1_Parametre( frame, 28, _( "Layer:" ), Line,
g_DesignSettings.m_LayerColor[pt_texte->GetLayer()] );
Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );
if( (pt_texte->m_Miroir & 1) )
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
else
......@@ -58,58 +58,3 @@ void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
Affiche_1_Parametre( frame, 70, _( "V Size" ), Line, RED );
}
/*********************************************************************/
void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste )
/*********************************************************************/
/* Affiche les caract principales d'un segment de piste en bas d'ecran */
{
int d_index, ii = -1;
D_CODE* pt_D_code;
int layer = ((PCB_SCREEN*)(frame->GetScreen()))->m_Active_Layer;
wxString msg;
frame->MsgPanel->EraseMsgBox();
d_index = pt_piste->GetNet();
pt_D_code = ReturnToolDescr( layer, d_index, &ii );
switch( pt_piste->Type() )
{
case TYPETRACK:
if( pt_piste->m_Shape < S_SPOT_CIRCLE )
msg = wxT( "LINE" );
else
msg = wxT( "FLASH" );
break;
case TYPEZONE:
msg = wxT( "ZONE" ); break;
default:
msg = wxT( "????" ); break;
}
Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
msg.Printf( wxT( "%d" ), ii + 1 );
Affiche_1_Parametre( frame, 10, _( "Tool" ), msg, RED );
if( pt_D_code )
{
msg.Printf( wxT( "D%d" ), d_index );
Affiche_1_Parametre( frame, 20, _( "D-code" ), msg, BLUE );
Affiche_1_Parametre( frame, 30, _( "D-type" ),
pt_D_code ? g_GERBER_Tool_Type[pt_D_code->m_Shape] : _( "????" ),
BLUE );
}
msg.Printf( wxT( "%d" ), pt_piste->GetLayer() + 1 );
Affiche_1_Parametre( frame, 40, _( "Layer" ), msg, BROWN );
/* Affiche Epaisseur */
valeur_param( (unsigned) (pt_piste->m_Width), msg );
Affiche_1_Parametre( frame, 50, _( "Width" ), msg, DARKCYAN );
}
gerbview/dcode.cpp
View file @ 26736baa
......@@ -63,34 +63,64 @@
D10 ... = Indentification d'outils ( d'ouvertures )
*/
/*********************************/
/* class GERBER : Methodes */
/*********************************/
GERBER::GERBER( int layer )
GERBER::GERBER( int aLayer )
{
int ii;
m_Layer = aLayer; // Layer Number
m_Layer = layer; // Layer Number
m_Selected_Tool = FIRST_DCODE;
ResetDefaultValues();
for( ii = 0; ii <= MAX_TOOLS; ii++ )
m_Aperture_List[ii] = new D_CODE( ii + FIRST_DCODE );
for( unsigned ii = 0; ii < DIM( m_Aperture_List ); ii++ )
m_Aperture_List[ii] = 0;
}
GERBER::~GERBER()
{
int ii;
for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
{
delete m_Aperture_List[ii];
// m_Aperture_List[ii] = NULL;
}
}
if( m_Aperture_List )
D_CODE* GERBER::GetDCODE( int aDCODE, bool create )
{
unsigned ndx = aDCODE - FIRST_DCODE;
if( ndx < (unsigned) DIM(m_Aperture_List) )
{
for( ii = 0; ii < MAX_TOOLS; ii++ )
// lazily create the D_CODE if it does not exist.
if( create )
{
delete m_Aperture_List[ii];
m_Aperture_List[ii] = NULL;
if( m_Aperture_List[ndx] == NULL )
m_Aperture_List[ndx] = new D_CODE( ndx + FIRST_DCODE );
}
return m_Aperture_List[ndx];
}
return NULL;
}
APERTURE_MACRO* GERBER::FindApertureMacro( const APERTURE_MACRO& aLookup )
{
APERTURE_MACRO_SET::iterator iter = m_aperture_macros.find( aLookup );
if( iter != m_aperture_macros.end() )
{
APERTURE_MACRO* pam = (APERTURE_MACRO*) &(*iter);
return pam;
}
return NULL; // not found
}
......@@ -107,8 +137,9 @@ void GERBER::ResetDefaultValues()
m_NoTrailingZeros = FALSE; // True: zeros a droite supprim�s
m_MirorA = FALSE; // True: miror / axe A (X)
m_MirorB = FALSE; // True: miror / axe B (Y)
m_As_DCode = FALSE; // TRUE = DCodes in file (FALSE = no DCode->
// separate DCode file
m_Has_DCode = FALSE; // TRUE = DCodes in file (FALSE = no DCode->
// separate DCode file
m_Offset.x = m_Offset.y = 0; // Coord Offset
m_FmtScale.x = m_FmtScale.y = g_Default_GERBER_Format % 10;
......@@ -136,36 +167,27 @@ void GERBER::ResetDefaultValues()
int GERBER::ReturnUsedDcodeNumber()
/********************************************/
{
int ii, jj;
int count = 0;
jj = 0;
if( m_Aperture_List )
for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
{
for( ii = 0; ii < MAX_TOOLS; ii++ )
{
if( m_Aperture_List[ii] )
if( m_Aperture_List[ii]->m_InUse || m_Aperture_List[ii]->m_Defined )
jj++;
}
++count;
}
return jj;
return count;
}
/******************************/
void GERBER::InitToolTable()
/******************************/
/* Creation du tableau des MAX_TOOLS DCodes utilisables, si il n'existe pas,
* et Init des DCodes � une valeur raisonnable
*/
{
int count;
/* Init du buffer des D_CODES a des valeurs raisonnables */
for( count = 0; count < MAX_TOOLS; count++ )
for( int count = 0; count < MAX_TOOLS; count++ )
{
if( m_Aperture_List[count] == NULL )
continue;
m_Aperture_List[count]->m_Num_Dcode = count + FIRST_DCODE;
m_Aperture_List[count]->Clear_D_CODE_Data();
}
......@@ -184,7 +206,6 @@ void GERBER::InitToolTable()
D_CODE::D_CODE( int num_dcode )
{
m_Num_Dcode = num_dcode;
m_Macro = 0;
Clear_D_CODE_Data();
}
......@@ -203,6 +224,25 @@ void D_CODE::Clear_D_CODE_Data()
m_DrillShape = 0;
m_InUse = FALSE;
m_Defined = FALSE;
m_Macro = 0;
}
const wxChar* D_CODE::ShowApertureType( APERTURE_T aType )
{
const wxChar* ret;
switch( aType )
{
case APT_CIRCLE: ret = wxT( "Round" ); break;
case APT_LINE: ret = wxT( "Line" ); break;
case APT_RECT: ret = wxT( "Rect" ); break;
case APT_OVAL: ret = wxT( "Oval" ); break;
case APT_POLYGON: ret = wxT( "Poly" ); break;
case APT_MACRO: ret = wxT( "Macro" ); break;
default: ret = wxT( "???" ); break;
}
return ret;
}
......@@ -217,7 +257,7 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
char c_type_outil[256];
char line[GERBER_BUFZ];
wxString msg;
D_CODE* pt_Dcode;
D_CODE* dcode;
FILE* dest;
int layer = GetScreen()->m_Active_Layer;
int type_outil;
......@@ -227,6 +267,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
g_GERBER_List[layer] = new GERBER( layer );
}
GERBER* gerber = g_GERBER_List[layer];
/* Mise a jour de l'echelle gerber : */
dcode_scale = 10; /* ici unit dcode = mil, unit interne = 0.1 mil
* -> 1 unite dcode = 10 unit PCB */
......@@ -243,16 +286,18 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
return -1;
}
g_GERBER_List[layer]->InitToolTable();
gerber->InitToolTable();
while( fgets( line, sizeof(line) - 1, dest ) != NULL )
{
if( *line == ';' )
continue; /* Commentaire */
if( strlen( line ) < 10 )
continue; /* Probablemant ligne vide */
pt_Dcode = NULL; current_Dcode = 0;
dcode = NULL;
current_Dcode = 0;
/* Determination du type de fichier D_Code */
ptcar = line;
......@@ -277,7 +322,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
}
else /* valeurs en inches a convertir en mils */
{
fdrill = 0; current_Dcode = 0; fdrill = 0;
fdrill = 0;
current_Dcode = 0;
sscanf( line, "%f,%f,%1s", &fdimV, &fdimH, c_type_outil );
ptcar = line;
while( *ptcar )
......@@ -311,12 +358,12 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
if( current_Dcode >= MAX_TOOLS )
continue;
pt_Dcode = ReturnToolDescr( layer, current_Dcode );
pt_Dcode->m_Size.x = dimH;
pt_Dcode->m_Size.y = dimV;
pt_Dcode->m_Shape = (APERTURE_T) type_outil;
pt_Dcode->m_Drill.x = pt_Dcode->m_Drill.y = drill;
pt_Dcode->m_Defined = TRUE;
dcode = gerber->GetDCODE( current_Dcode );
dcode->m_Size.x = dimH;
dcode->m_Size.y = dimV;
dcode->m_Shape = (APERTURE_T) type_outil;
dcode->m_Drill.x = dcode->m_Drill.y = drill;
dcode->m_Defined = TRUE;
}
fclose( dest );
......@@ -332,14 +379,15 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
/* Set Size Items (Lines, Flashes) from DCodes List
*/
{
TRACK* track;
D_CODE* pt_Dcode; /* Pointeur sur le D code*/
track = m_Pcb->m_Track;
for( ; track != NULL; track = (TRACK*) track->Pnext )
for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
{
pt_Dcode = ReturnToolDescr( track->GetLayer(), track->GetNet() );
pt_Dcode->m_InUse = TRUE;
GERBER* gerber = g_GERBER_List[track->GetLayer()];
wxASSERT( gerber );
D_CODE* dcode = gerber->GetDCODE( track->GetNet(), false );
wxASSERT( dcode );
dcode->m_InUse = TRUE;
if( // Line Item
(track->m_Shape == S_SEGMENT ) /* segment rectiligne */
......@@ -349,12 +397,12 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
|| (track->m_Shape == S_ARC_RECT ) /* segment en arc de cercle (bouts droits) (GERBER)*/
)
{
track->m_Width = pt_Dcode->m_Size.x;
track->m_Width = dcode->m_Size.x;
}
else // Spots ( Flashed Items )
{
int width, len;
wxSize size = pt_Dcode->m_Size;
wxSize size = dcode->m_Size;
width = MIN( size.x, size.y );
len = MAX( size.x, size.y ) - width;
......@@ -365,7 +413,7 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
track->m_Start.y = (track->m_Start.y + track->m_End.y) / 2;
track->m_End = track->m_Start; // m_Start = m_End = Spot center
switch( pt_Dcode->m_Shape )
switch( dcode->m_Shape )
{
case APT_LINE: // ne devrait pas etre utilis� ici
case APT_CIRCLE: /* spot round (for GERBER)*/
......@@ -397,26 +445,6 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
}
/*********************************************************/
D_CODE* ReturnToolDescr( int layer, int Dcode, int* index )
/*********************************************************/
{
GERBER* gerber = g_GERBER_List[layer];
D_CODE* pt_dcode = NULL;
if( index )
*index = 0;
if( gerber && Dcode >= FIRST_DCODE && Dcode < MAX_TOOLS )
{
pt_dcode = gerber->m_Aperture_List[Dcode - FIRST_DCODE];
if( index )
*index = Dcode - FIRST_DCODE + 1;
}
return pt_dcode;
}
/************************************************/
void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
/************************************************/
......@@ -427,15 +455,13 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
WinEDA_TextFrame* List;
int scale = 10000;
int curr_layer = GetScreen()->m_Active_Layer;
int layer;
GERBER* gerber;
/* Construction de la liste des messages */
List = new WinEDA_TextFrame( this, _( "List D codes" ) );
for( layer = 0; layer < 32; layer++ )
for( int layer = 0; layer < 32; layer++ )
{
gerber = g_GERBER_List[layer];
GERBER* gerber = g_GERBER_List[layer];
if( gerber == NULL )
continue;
......@@ -450,7 +476,7 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
for( ii = 0, jj = 1; ii < MAX_TOOLS; ii++ )
{
pt_D_code = gerber->m_Aperture_List[ii];
pt_D_code = gerber->GetDCODE( ii + FIRST_DCODE, false );
if( pt_D_code == NULL )
continue;
......@@ -463,7 +489,8 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
pt_D_code->m_Num_Dcode,
(float) pt_D_code->m_Size.y / scale,
(float) pt_D_code->m_Size.x / scale,
g_GERBER_Tool_Type[pt_D_code->m_Shape] );
D_CODE::ShowApertureType( pt_D_code->m_Shape )
);
if( !pt_D_code->m_Defined )
Line += wxT( " ?" );
......
gerbview/gerbview.h
View file @ 26736baa
......@@ -58,16 +58,6 @@ enum APERTURE_T
APT_MACRO = 'M'
};
/* replaced by APERTURE_T
enum Gerb_StandardShape {
GERB_CIRCLE = 1,
GERB_RECT,
GERB_LINE,
GERB_OVALE,
GERB_SPECIAL_SHAPE
};
*/
// Interpolation type
enum Gerb_Interpolation {
......@@ -111,22 +101,50 @@ enum Gerb_Analyse_Cmd {
ENTER_RS274X_CMD
};
class D_CODE;
/**
* Struct DCODE_PARAM
* Class DCODE_PARAM
* holds a parameter for a DCODE or an "aperture macro" as defined within standard RS274X.
* The \a value field can be either a constant or a place holder for a DCODE
* parameter.
*/
struct DCODE_PARAM
class DCODE_PARAM
{
public:
DCODE_PARAM() :
isImmediate(true),
index(-1),
value(0.0)
{}
bool isImmediate; ///< the \a value field is an actual value, not a parameter place holder.
double value; ///< if immediate then the value, else an integer index into D_CODE.m_am_params.
double GetValue( const D_CODE* aDcode );
void SetValue( double aValue )
{
value = aValue;
index = -1;
}
/**
* Function IsImmediate
* tests if this DCODE_PARAM holds an immediate parameter or is a pointer into
* a parameter held by an owning D_CODE.
*/
bool IsImmediate() { return index == -1; }
int GetIndex()
{
return index;
}
void SetIndex( int aIndex )
{
index = aIndex;
}
private:
int index; ///< if -1, then \a value field is an immediate value, else this is an index into a D_CODE parameter.
double value; ///< if immediate then the value, else an integer index into D_CODE.m_am_params.
};
......@@ -183,7 +201,7 @@ struct APERTURE_MACRO
*/
struct APERTURE_MACRO_less_than
{
// a "less than" test on two wxStrings
// a "less than" test on two APERTURE_MACROs (.name wxStrings)
bool operator()( const APERTURE_MACRO& am1, const APERTURE_MACRO& am2) const
{
return am1.name.Cmp( am2.name ) < 0; // case specific wxString compare
......@@ -206,6 +224,14 @@ typedef std::pair<APERTURE_MACRO_SET::iterator, bool> APERTURE_MACRO_SET_PAIR;
*/
class D_CODE
{
APERTURE_MACRO* m_Macro; ///< no ownership, points to GERBER.m_aperture_macros element
/**
* parameters used only when this D_CODE holds a reference to an aperture
* macro, and these parameters would customize the macro.
*/
DCODE_PARAMS m_am_params;
public:
wxSize m_Size; /* Dimensions horiz et Vert */
APERTURE_T m_Shape; /* shape ( Line, rect , circulaire , ovale .. ) */
......@@ -216,27 +242,55 @@ public:
bool m_Defined; /* FALSE si non defini */
wxString m_SpecialDescr;
APERTURE_MACRO* m_Macro; ///< no ownership, points to GERBER.m_aperture_macros element
/**
* parameters used only when this D_CODE holds a reference to an aperture
* macro, and these parameters would customize the macro.
*/
DCODE_PARAMS m_am_params;
public:
D_CODE( int num_dcode );
~D_CODE();
void Clear_D_CODE_Data();
void AppendParam( double aValue )
{
DCODE_PARAM param;
param.SetValue( aValue );
m_am_params.push_back( param );
}
void SetMacro( APERTURE_MACRO* aMacro )
{
m_Macro = aMacro;
}
/**
* Function ShowApertureType
* returns a character string telling what type of aperture type \a aType is.
* @param aType The aperture type to show.
*/
static const wxChar* ShowApertureType( APERTURE_T aType );
};
inline double DCODE_PARAM::GetValue( const D_CODE* aDcode )
{
if( IsImmediate() )
return value;
else
{
// get the parameter from aDcode
return 0.0;
}
}
/**
* Class GERBER
* holds the data for one gerber file or layer
*/
class GERBER
{
D_CODE* m_Aperture_List[MAX_TOOLS]; ///< Dcode (Aperture) List for this layer
public:
wxString m_FileName; // Full File Name for this layer
wxString m_Name; // Layer name
......@@ -247,7 +301,7 @@ public:
bool m_NoTrailingZeros; // True: zeros a droite supprims
bool m_MirorA; // True: miror / axe A (X)
bool m_MirorB; // True: miror / axe B (Y)
bool m_As_DCode; // TRUE = DCodes in file (FALSE = no DCode->
bool m_Has_DCode; // TRUE = DCodes in file (FALSE = no DCode->
// separate DCode file
wxPoint m_Offset; // Coord Offset
wxSize m_FmtScale; // Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4
......@@ -262,7 +316,6 @@ public:
wxPoint m_CurrentPos; // current specified coord for plot
wxPoint m_PreviousPos; // old current specified coord for plot
wxPoint m_IJPos; // IJ coord (for arcs & circles )
D_CODE* m_Aperture_List[MAX_TOOLS + FIRST_DCODE + 1]; // Dcode (Aperture) List for this layer
FILE* m_Current_File; // Current file to read
FILE* m_FilesList[12]; // Files list
......@@ -283,6 +336,11 @@ public:
void Clear_GERBER();
int ReturnUsedDcodeNumber();
void ResetDefaultValues();
/**
* Function InitToolTable
*/
void InitToolTable();
// Routines utilises en lecture de ficher gerber
......@@ -324,6 +382,26 @@ public:
* @return bool - true if a macro was read in successfully, else false.
*/
bool ReadApertureMacro( char aBuff[GERBER_BUFZ], char*& text, FILE* gerber_file );
/**
* Function GetDCODE
* returns a pointer to the D_CODE within this GERBER for the given
* \a aDCODE.
* @param aDCODE The numeric value of the D_CODE to look up.
* @param createIfNoExist If true, then create the D_CODE if it does not exist.
* @return D_CODE* - the one implied by the given \a aDCODE, or NULL
* if the requested \a aDCODE is out of range.
*/
D_CODE* GetDCODE( int aDCODE, bool createIfNoExist=true );
/**
* Function FindApertureMacro
* looks up a previously read in aperture macro.
* @param aLookup A dummy APERTURE_MACRO with [only] the name field set.
* @return APERTURE_MACRO* - the one with a matching name, or NULL if not found.
*/
APERTURE_MACRO* FindApertureMacro( const APERTURE_MACRO& aLookup );
};
......@@ -334,27 +412,6 @@ public:
bool GetEndOfBlock( char buff[GERBER_BUFZ], char*& text, FILE* gerber_file );
/**
* Function ReturnToolDescr
* returns a D_CODE given a global layer index and Dcode value.
* @param aLayer The index into the global array of GERBER called g_GERBER_List[].
* @param aDcode The dcode value to look up.
* @param aIndex If not null, where to put a one basedindex into the GERBER's m_Aperture_List[] array.
* @return D_CODE* - the looked up D_CODE or NULL if none was encountered in the gerber file for given \a aDcode.
*/
D_CODE * ReturnToolDescr( int layer, int Dcode, int * index = NULL );
eda_global const wxChar* g_GERBER_Tool_Type[6]
#ifdef MAIN
= {
wxT( "????" ), wxT( "Round" ), wxT( "Rect" ), wxT( "Line" ), wxT( "Oval" ), wxT( "Macro" )
}
#endif
;
eda_global GERBER* g_GERBER_List[32];
......
gerbview/readgerb.cpp
View file @ 26736baa
......@@ -261,7 +261,7 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
/* Init DCodes list and perhaps read a DCODES file,
* if the gerber file is only a RS274D file (without any aperture information)
*/
if( !gerber->m_As_DCode )
if( !gerber->m_Has_DCode )
{
wxString DCodeFileName;
if( D_Code_FullFileName.IsEmpty() )
......
gerbview/rs274x.cpp
View file @ 26736baa
......@@ -92,7 +92,7 @@ static int ReadInt( char*& text )
/**
* Function ReadDouble
* reads a double in from a character buffer. If there is a comma after the double,
* reads a double from an ASCII character buffer. If there is a comma after the double,
* then skip over that.
* @param text A reference to a character pointer from which the ASCII double
* is read from and the pointer advanced for each character read.
......@@ -171,9 +171,7 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
{
int code;
int xy_seq_len, xy_seq_char;
char ctmp;
bool ok = TRUE;
D_CODE* dcode;
char line[GERBER_BUFZ];
wxString msg;
double fcoord;
......@@ -221,19 +219,21 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
case 'X':
case 'Y': // Valeurs transmises :2 (really xy_seq_len : FIX ME) digits
code = *(text++);
ctmp = *(text++) - '0';
if( code == 'X' )
{
m_FmtScale.x = *text - '0'; // = nb chiffres apres la virgule
m_FmtLen.x = ctmp + m_FmtScale.x; // = nb total de chiffres
}
else
{
m_FmtScale.y = *text - '0';
m_FmtLen.y = ctmp + m_FmtScale.y;
code = *(text++);
char ctmp = *(text++) - '0';
if( code == 'X' )
{
m_FmtScale.x = *text - '0'; // = nb chiffres apres la virgule
m_FmtLen.x = ctmp + m_FmtScale.x; // = nb total de chiffres
}
else
{
m_FmtScale.y = *text - '0';
m_FmtLen.y = ctmp + m_FmtScale.y;
}
text++;
}
text++;
break;
case '*':
......@@ -321,10 +321,6 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
m_LayerNegative = FALSE;
break;
case AP_MACRO:
ReadApertureMacro( buff, text, m_Current_File );
break;
case INCLUDE_FILE:
if( m_FilesPtr >= 10 )
{
......@@ -349,29 +345,45 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
m_FilesPtr++;
break;
case AP_MACRO:
ok = ReadApertureMacro( buff, text, m_Current_File );
if( !ok )
break;
break;
case AP_DEFINITION:
if( *text != 'D' )
// input example: %ADD30R,0.081800X0.101500*%
// at this point, text points to 2nd 'D'
if( *text++ != 'D' )
{
ok = FALSE;
break;
}
m_As_DCode = TRUE;
text++;
m_Has_DCode = TRUE;
code = ReadInt( text );
ctmp = *text;
dcode = ReturnToolDescr( m_Layer, code );
D_CODE* dcode;
dcode = GetDCODE( code );
if( dcode == NULL )
break;
if( text[1] == ',' ) // Tool usuel (C,R,O,P)
// at this point, text points to character after the ADD<num>, i.e. R in example above
// if text[0] is one of the usual apertures: (C,R,O,P), there is a comma after it.
if( text[1] == ',' )
{
text += 2; // text pointe size ( 1er modifier)
char stdAperture = *text;
text += 2; // skip "C," for example
dcode->m_Size.x = dcode->m_Size.y =
(int) round( ReadDouble( text ) * conv_scale );
switch( ctmp )
switch( stdAperture )
{
case 'C': // Circle
dcode->m_Shape = APT_CIRCLE;
......@@ -402,7 +414,7 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
case 'O': // oval
case 'R': // rect
dcode->m_Shape = (ctmp == 'O') ? APT_OVAL : APT_RECT;
dcode->m_Shape = (stdAperture == 'O') ? APT_OVAL : APT_RECT;
while( *text == ' ' )
text++;
......@@ -444,6 +456,40 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
break;
}
}
else // text[0] starts an aperture macro name
{
APERTURE_MACRO am_lookup;
while( *text && *text!='*' && *text!=',' )
am_lookup.name.Append( *text++ );
if( *text && *text==',' )
{
while( *text && *text!='*' )
{
double param = ReadDouble( text );
if( *text == 'X' )
++text;
dcode->AppendParam( param );
}
}
// lookup the aperture macro here.
APERTURE_MACRO* pam = FindApertureMacro( am_lookup );
if( !pam )
{
// @todo not found, don't know how to report an error
D( printf("aperture macro %s not found\n", CONV_TO_UTF8(am_lookup.name) );)
ok = false;
break;
}
D(printf("pam has %d parameters\n", pam->primitives.size() );)
dcode->SetMacro( (APERTURE_MACRO*) pam );
}
break;
default:
......@@ -531,7 +577,6 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ], char*& text, FILE* gerbe
switch( prim.primitive_id )
{
default:
case AMP_CIRCLE:
paramCount = 4;
break;
......@@ -558,43 +603,48 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ], char*& text, FILE* gerbe
case AMP_THERMAL:
paramCount = 6;
break;
default:
// @todo, there needs to be a way of reporting the line number and character offset.
D(printf("Invalid primitive id code %d\n", prim.primitive_id );)
return false;
}
DCODE_PARAM param;
for( int i=0; i<paramCount && *text && *text!='*'; ++i )
{
DCODE_PARAM param; // construct it on each loop iteration
if( *text == '$' )
{
++text;
param.isImmediate = false;
param.SetIndex( ReadInt( text ) );
}
else
{
param.isImmediate = true;
}
param.SetValue( ReadDouble( text ) );
param.value = ReadDouble( text );
prim.params.push_back( param );
}
// there are more parameters to read if this is an AMP_OUTLINE
if( prim.primitive_id == AMP_OUTLINE )
{
paramCount = (int) prim.params[1].value * 2 + 1;
// params[1] is a count of polygon points, so it must be given
// in advance, i.e. be immediate.
wxASSERT( prim.params[1].IsImmediate() );
paramCount = (int) prim.params[1].GetValue(0) * 2 + 1;
for( int i=0; i<paramCount && *text && *text!='*'; ++i )
{
DCODE_PARAM param; // construct it on each loop
if( *text == '$' )
{
++text;
param.isImmediate = false;
param.SetIndex( ReadInt( text ) );
}
else
{
param.isImmediate = true;
}
param.SetValue( ReadDouble( text ) );
param.value = ReadDouble( text );
prim.params.push_back( param );
}
}
......
include/macros.h
View file @ 26736baa
......@@ -25,6 +25,10 @@
#define ABS( y ) ( (y) >= 0 ? (y) : ( -(y) ) )
#endif
/// # of elements in an arrray
#define DIM(x) (sizeof(x)/sizeof((x)[0]))
#define DEG2RAD( Deg ) ( (Deg) * M_PI / 180.0 )
#define RAD2DEG( Rad ) ( (Rad) * 180.0 / M_PI )
......
pcbnew/plotgerb.h
View file @ 26736baa
/************/
/* pcbplot.h*/
/************/
/************/
/* pcbplot.h*/
/************/
#ifndef PLOTGERB_H
#define PLOTGERB_H
......@@ -8,81 +8,84 @@
/* Format Gerber : NOTES :
Fonctions preparatoires:
Gn =
G01 interpolation lineaire ( trace de droites )
G02,G20,G21 Interpolation circulaire , sens trigo < 0
G03,G30,G31 Interpolation circulaire , sens trigo > 0
G04 commentaire
G06 Interpolation parabolique
G07 Interpolation cubique
G10 interpolation lineaire ( echelle 10x )
G11 interpolation lineaire ( echelle 0.1x )
G12 interpolation lineaire ( echelle 0.01x )
G36 Start polygon description
G37 End polygon description
G52 plot symbole reference par Dnn code
G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
G54 Selection d'outil
G55 Mode exposition photo
G56 plot symbole reference par Dnn A code
G57 affiche le symbole reference sur la console
G58 plot et affiche le symbole reference sur la console
G60 interpolation lineaire ( echelle 100x )
G70 Unites = Inches
G71 Unites = Millimetres
G74 supprime interpolation circulaire sur 360 degre, revient a G01
G75 Active interpolation circulaire sur 360 degre
G90 Mode Coordonnees absolues
G91 Mode Coordonnees Relatives
Gn =
G01 interpolation lineaire ( trace de droites )
G02,G20,G21 Interpolation circulaire , sens trigo < 0
G03,G30,G31 Interpolation circulaire , sens trigo > 0
G04 commentaire
G06 Interpolation parabolique
G07 Interpolation cubique
G10 interpolation lineaire ( echelle 10x )
G11 interpolation lineaire ( echelle 0.1x )
G12 interpolation lineaire ( echelle 0.01x )
G36 Start polygon description
G37 End polygon description
G52 plot symbole reference par Dnn code
G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
G54 Selection d'outil
G55 Mode exposition photo
G56 plot symbole reference par Dnn A code
G57 affiche le symbole reference sur la console
G58 plot et affiche le symbole reference sur la console
G60 interpolation lineaire ( echelle 100x )
G70 Unites = Inches
G71 Unites = Millimetres
G74 supprime interpolation circulaire sur 360 degre, revient a G01
G75 Active interpolation circulaire sur 360 degre
G90 Mode Coordonnees absolues
G91 Mode Coordonnees Relatives
Coordonnees X,Y
X,Y sont suivies de + ou - et de m+n chiffres (non separes)
m = partie entiere
n = partie apres la virgule
formats classiques : m = 2, n = 3 (format 2.3)
m = 3, n = 4 (format 3.4)
ex:
G__ X00345Y-06123 D__*
X,Y sont suivies de + ou - et de m+n chiffres (non separes)
m = partie entiere
n = partie apres la virgule
formats classiques : m = 2, n = 3 (format 2.3)
m = 3, n = 4 (format 3.4)
ex:
G__ X00345Y-06123 D__*
Outils et D_CODES
numero d'outil ( identification des formes )
1 a 99 (classique)
1 a 999
D_CODES:
D01 ... D9 = codes d'action:
D01 = activation de lumiere ( baisser de plume)
D02 = extinction de lumiere ( lever de plume)
D03 = Flash
D09 = VAPE Flash
D51 = precede par G54 -> Select VAPE
D10 ... D255 = Indentification d'outils ( d'ouvertures )
Ne sont pas tj dans l'ordre ( voir tableau ci dessous)
numero d'outil ( identification des formes )
1 a 99 (classique)
1 a 999
D_CODES:
D01 ... D9 = codes d'action:
D01 = activation de lumiere ( baisser de plume)
D02 = extinction de lumiere ( lever de plume)
D03 = Flash
D09 = VAPE Flash
D51 = precede par G54 -> Select VAPE
D10 ... D255 = Indentification d'outils ( d'ouvertures )
Ne sont pas tj dans l'ordre ( voir tableau ci dessous)
*/
/*************************************/
/* Constantes utiles en trace GERBER */
/*************************************/
/*************************************/
/* Constantes utiles en trace GERBER */
/*************************************/
/* codes de type de forme d'outils */
/*
#define GERB_CIRCLE 1
#define GERB_RECT 2
#define GERB_LINE 3
#define GERB_OVALE 4
#define GERB_DONUT 5
*/
/* liste des D_CODES en fonction de leur numero d'ordre (numero d'outil)
(l'ordre 0 n'est pas utilise) ;
Tools have D_CODES >= 10
D_CODES <= 9 are used for commands only:
D01 ... D9 = command codes for photo plotting:
D01 = Light on
D02 = Light off
D03 = Flash
D04 .. D08 = ?
D09 = VAPE Flash
(l'ordre 0 n'est pas utilise) ;
Tools have D_CODES >= 10
D_CODES <= 9 are used for commands only:
D01 ... D9 = command codes for photo plotting:
D01 = Light on
D02 = Light off
D03 = Flash
D04 .. D08 = ?
D09 = VAPE Flash
*/
#define FIRST_DCODE_VALUE 10
......@@ -91,17 +94,17 @@ Outils et D_CODES
class D_CODE
{
public:
D_CODE * m_Pnext, * m_Pback; /* for a linked list */
wxSize m_Size; /* horiz and Vert size*/
int m_Type; /* Type ( Line, rect , circulaire , ovale .. ); -1 = not used (free) descr */
int m_NumDcode; /* code number ( >= 10 ); 0 = not in use */
D_CODE()
{
m_Pnext = m_Pback = NULL;
m_Type = -1;
m_NumDcode = 0;
}
D_CODE * m_Pnext, * m_Pback; /* for a linked list */
wxSize m_Size; /* horiz and Vert size*/
int m_Type; /* Type ( Line, rect , circulaire , ovale .. ); -1 = not used (free) descr */
int m_NumDcode; /* code number ( >= 10 ); 0 = not in use */
D_CODE()
{
m_Pnext = m_Pback = NULL;
m_Type = -1;
m_NumDcode = 0;
}
} ;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment