KiCad PCB EDA Suite
Loading...
Searching...
No Matches
export_d356.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2011-2013 Lorenzo Marcantonio <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
25#include "export_d356.h"
27
28#include <algorithm>
29#include <cctype>
30#include <map>
31#include <set>
32#include <vector>
33
34#include <wx/checkbox.h>
35#include <wx/filedlg.h>
36#include <wx/filedlgcustomize.h>
37#include <wx/msgdlg.h>
38#include <kiplatform/ui.h>
39
40#include <confirm.h>
41#include <gestfich.h>
42#include <kiface_base.h>
43#include <pcb_edit_frame.h>
44#include <trigo.h>
45#include <build_version.h>
46#include <macros.h>
48#include <locale_io.h>
49#include <board.h>
51#include <footprint.h>
52#include <layer_range.h>
53#include <pad.h>
54#include <pcb_track.h>
55#include <string_utils.h>
56
57#include <math/util.h> // for KiROUND
59
60
61// D-356 numbers copper layers physically from 1 (front) to the copper layer count (back)
62static int physical_layer( BOARD* aPcb, PCB_LAYER_ID aLayer )
63{
64 if( aLayer == B_Cu )
65 return aPcb->GetCopperLayerCount();
66
67 return static_cast<int>( CopperLayerToOrdinal( aLayer ) ) + 1;
68}
69
70
71// Compute the access code for a pad. Returns -1 if there is no copper
72static int compute_pad_access_code( BOARD *aPcb, LSET aLayerMask )
73{
74 // Non-copper is not interesting here
75 aLayerMask &= LSET::AllCuMask();
76
77 if( !aLayerMask.any() )
78 return -1;
79
80 // Traditional TH pad
81 if( aLayerMask[F_Cu] && aLayerMask[B_Cu] )
82 return 0;
83
84 // Front SMD pad
85 if( aLayerMask[F_Cu] )
86 return 1;
87
88 // Back SMD pad
89 if( aLayerMask[B_Cu] )
90 return aPcb->GetCopperLayerCount();
91
92 // OK, we have an inner-layer only pad (and I have no idea about
93 // what could be used for); anyway, find the first copper layer
94 // it's on
95 for( PCB_LAYER_ID layer : LAYER_RANGE( In1_Cu, B_Cu, aPcb->GetCopperLayerCount() ) )
96 {
97 if( aLayerMask[layer] )
98 return physical_layer( aPcb, layer );
99 }
100
101 // This shouldn't happen
102 return -1;
103}
104
105/* Convert and clamp a size from IU to decimils */
106static int iu_to_d356(int iu, int clamp)
107{
108 int val = KiROUND( static_cast<double>( iu ) / ( pcbIUScale.IU_PER_MILS / 10.0 ) );
109 if( val > clamp ) return clamp;
110 if( val < -clamp ) return -clamp;
111 return val;
112}
113
114/* Extract the D356 record from the footprints (pads) */
115void IPC356D_WRITER::appendPadRecords( BOARD* aPcb, const std::vector<FAB_TEST_POINT>& aPoints,
116 std::vector<D356_RECORD>& aRecords )
117{
118 VECTOR2I origin = aPcb->GetDesignSettings().GetAuxOrigin();
119
120 for( const FAB_TEST_POINT& point : aPoints )
121 {
122 if( !point.m_pad )
123 continue;
124
125 const PAD* pad = point.m_pad;
126 const FOOTPRINT* footprint = pad->GetParentFootprint();
127 D356_RECORD rk;
128 rk.access = compute_pad_access_code( aPcb, pad->GetLayerSet() );
129
130 // It could be a mask only pad, we only handle pads with copper here
131 if( rk.access == -1 )
132 continue;
133
135 continue;
136
137 rk.netname = pad->GetNetname();
138 rk.pin = pad->GetNumber();
139 rk.refdes = footprint->GetReference();
140 // A named pad is a component terminal (end-net point); an unnamed copper
141 // feature is only reachable mid-net, so it is a midpoint per IPC-D-356A
142 rk.midpoint = rk.pin.IsEmpty();
143 rk.drill = point.m_drill;
144 rk.hole = ( rk.drill != 0 );
145 rk.smd = pad->GetAttribute() == PAD_ATTRIB::SMD
146 || pad->GetAttribute() == PAD_ATTRIB::CONN
147 || pad->GetAttribute() == PAD_ATTRIB::NON_COMPONENT;
148 rk.mechanical = ( pad->GetAttribute() == PAD_ATTRIB::NPTH );
149 rk.x_location = point.m_position.x - origin.x;
150 rk.y_location = origin.y - point.m_position.y;
151
152 PCB_LAYER_ID accessLayer = footprint->IsFlipped() ? B_Cu : F_Cu;
153 rk.x_size = pad->GetSize( accessLayer ).x;
154
155 // Rule: round pads have y = 0
156 if( pad->GetShape( accessLayer ) == PAD_SHAPE::CIRCLE )
157 rk.y_size = 0;
158 else
159 rk.y_size = pad->GetSize( accessLayer ).y;
160
161 rk.rotation = -pad->GetOrientation().AsDegrees();
162
163 if( rk.rotation < 0 )
164 rk.rotation += 360;
165
166 // the value indicates which sides are *not* accessible
167 rk.soldermask = 3;
168
169 if( point.m_frontMask )
170 rk.soldermask &= ~1;
171
172 if( point.m_backMask )
173 rk.soldermask &= ~2;
174
175 aRecords.push_back( std::move( rk ) );
176 }
177}
178
179/* Compute the access code for a via. In D-356 layers are numbered from 1 up,
180 where '1' is the 'primary side' (usually the component side);
181 '0' means 'both sides', and other layers follows in an unspecified order */
182static int via_access_code( BOARD *aPcb, int top_layer, int bottom_layer )
183{
184 // Easy case for through vias: top_layer is component, bottom_layer is
185 // solder, access code is 0
186 if( (top_layer == F_Cu) && (bottom_layer == B_Cu) )
187 return 0;
188
189 // Blind via, reachable from front
190 if( top_layer == F_Cu )
191 return 1;
192
193 // Blind via, reachable from bottom
194 if( bottom_layer == B_Cu )
195 return aPcb->GetCopperLayerCount();
196
197 // It's a buried via, accessible from some inner layer
198 // (maybe could be used for testing before laminating? no idea)
199 return physical_layer( aPcb, static_cast<PCB_LAYER_ID>( top_layer ) );
200}
201
202/* Extract the D356 record from the vias */
203static void appendViaRecords( BOARD* aPcb, const std::vector<FAB_TEST_POINT>& aPoints,
204 std::vector<D356_RECORD>& aRecords )
205{
206 VECTOR2I origin = aPcb->GetDesignSettings().GetAuxOrigin();
207
208 for( const FAB_TEST_POINT& point : aPoints )
209 {
210 if( !point.m_via )
211 continue;
212
213 const PCB_VIA* via = point.m_via;
214 const NETINFO_ITEM* net = via->GetNet();
215
216 D356_RECORD rk;
217 rk.smd = false;
218 rk.hole = true;
219
220 if( net )
221 rk.netname = net->GetNetname();
222 else
223 rk.netname = wxEmptyString;
224
225 rk.refdes = wxT( "VIA" );
226 rk.pin = wxT( "" );
227 rk.midpoint = true; // Vias are always midpoints
228 rk.drill = point.m_drill;
229 rk.mechanical = false;
230
231 PCB_LAYER_ID top_layer, bottom_layer;
232
233 via->LayerPair( &top_layer, &bottom_layer );
234
235 rk.access = via_access_code( aPcb, top_layer, bottom_layer );
236
237 if( rk.access != 0 )
238 {
239 rk.start_layer = physical_layer( aPcb, top_layer );
240 rk.end_layer = physical_layer( aPcb, bottom_layer );
241 }
242
243 rk.x_location = point.m_position.x - origin.x;
244 rk.y_location = origin.y - point.m_position.y;
245
246 // The record has a single size for vias. A blind via's 027 record describes its one
247 // surface pad; otherwise take the smaller of the front and back
248 if( rk.access == 1 )
249 rk.x_size = via->GetWidth( F_Cu );
250 else if( rk.access == aPcb->GetCopperLayerCount() )
251 rk.x_size = via->GetWidth( B_Cu );
252 else if( via->Padstack().Mode() != PADSTACK::MODE::NORMAL )
253 rk.x_size = std::min( via->GetWidth( F_Cu ), via->GetWidth( B_Cu ) );
254 else
255 rk.x_size = via->GetWidth( F_Cu );
256
257 rk.y_size = 0; // Round so height = 0
258 rk.rotation = 0;
259
260 // the value indicates which sides are *not* accessible
261 rk.soldermask = 0;
262
263 if( via->IsTented( F_Mask ) )
264 rk.soldermask |= 1;
265
266 if( via->IsTented( B_Mask ) )
267 rk.soldermask |= 2;
268
269 aRecords.push_back( rk );
270 }
271}
272
273// Rule: we can only use the standard ASCII, control excluded
274// Case folding is ASCII only since wxString::Upper() follows the locale (Turkish i)
275static wxString sanitize_d356_name( const wxString& aNetname, bool aUpper )
276{
277 wxString out;
278
279 for( wxUniChar ch : aNetname )
280 {
281 if( ch > 126 || !std::isgraph( static_cast<unsigned char>( ch ) ) )
282 ch = '?';
283 else if( aUpper && ch >= 'a' && ch <= 'z' )
284 ch = static_cast<char>( ch.GetValue() - 'a' + 'A' );
285
286 out += ch;
287 }
288
289 return out;
290}
291
292
293// NNAME aliases fill columns 9-13, so base 36 keeps them to five characters
294static wxString d356_alias( int aIndex )
295{
296 static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
297 wxString alias( wxT( "M" ) );
298
299 for( int div = 36 * 36 * 36; div > 0; div /= 36 )
300 alias += digits[( aIndex / div ) % 36];
301
302 return alias;
303}
304
305
306/* Write all the accumuled data to the file in D356 format */
307void IPC356D_WRITER::write_D356_records( std::vector <D356_RECORD> &aRecords, FILE* aFile )
308{
309 const wxString nc( wxT( "N/C" ) );
310
311 // Source net name to the signal name written in columns 4-17
312 std::map<wxString, wxString> d356_net_map;
313 std::set<wxString> d356_net_set = { nc };
314 std::map<wxString, int> canonCount;
315
316 // Rule: only uppercase (unofficial, but known to give problems otherwise)
317 for( const D356_RECORD& rk : aRecords )
318 {
319 if( !rk.netname.empty() && d356_net_map.emplace( rk.netname, wxEmptyString ).second )
320 canonCount[sanitize_d356_name( rk.netname, true )]++;
321 }
322
323 // Every candidate is reserved so no alias can shadow a real net
324 for( const auto& [candidate, count] : canonCount )
325 d356_net_set.insert( candidate );
326
327 // Every member of a collision is aliased, otherwise its NNAME would name the net that kept it
328 for( auto& [netname, canon] : d356_net_map )
329 {
330 wxString candidate = sanitize_d356_name( netname, true );
331
332 if( candidate.size() <= 14 && candidate != nc && canonCount[candidate] == 1 )
333 canon = candidate;
334 }
335
336 int aliasIndex = 0;
337
338 for( auto& [netname, canon] : d356_net_map )
339 {
340 if( !canon.empty() )
341 continue;
342
343 do
344 {
345 canon = d356_alias( aliasIndex++ );
346 } while( !d356_net_set.insert( canon ).second );
347
348 // Columns 15-72 hold the source name, keeping the tail since hierarchical prefixes repeat
349 fprintf( aFile, "P NNAME%-5.5s %-66.66s\n", TO_UTF8( canon ),
350 TO_UTF8( sanitize_d356_name( netname, false ).Right( 58 ) ) );
351 }
352
353 auto signalName =
354 [&]( const D356_RECORD& aRecord ) -> const wxString&
355 {
356 return aRecord.netname.empty() ? nc : d356_net_map.at( aRecord.netname );
357 };
358
359 // 356A wants the netlist sorted by net; stable keeps each net's vias ahead of its pads
360 std::stable_sort( aRecords.begin(), aRecords.end(),
361 [&]( const D356_RECORD& aLhs, const D356_RECORD& aRhs )
362 {
363 return signalName( aLhs ) < signalName( aRhs );
364 } );
365
366 for( D356_RECORD& rk : aRecords )
367 {
368 const wxString& d356_net = signalName( rk );
369 const bool blindOrBuried = rk.start_layer != 0;
370
371 // Choose the best record type
372 int rktype;
373
374 if( rk.smd )
375 rktype = 327;
376 else if( rk.mechanical )
377 rktype = 367;
378 else if( blindOrBuried )
379 rktype = 307;
380 else
381 rktype = 317;
382
383 auto writeComponent =
384 [&]( int aOpCode, bool aMidpoint )
385 {
386 fprintf( aFile, "%03d%-14.14s %-6.6s%c%-4.4s%c", aOpCode, TO_UTF8( d356_net ),
387 TO_UTF8( rk.refdes ), rk.pin.empty() ? ' ' : '-', TO_UTF8( rk.pin ),
388 aMidpoint ? 'M' : ' ' );
389 };
390
391 auto writeAccessAndSize =
392 [&]()
393 {
394 fprintf( aFile, "A%02dX%+07dY%+07dX%04dY%04dR%03d", rk.access,
395 iu_to_d356( rk.x_location, 999999 ), iu_to_d356( rk.y_location, 999999 ),
396 iu_to_d356( rk.x_size, 9999 ), iu_to_d356( rk.y_size, 9999 ), rk.rotation );
397 };
398
399 writeComponent( rktype, rk.midpoint );
400
401 // Hole definition
402 if( rk.hole )
403 {
404 fprintf( aFile, "D%04d%c",
405 iu_to_d356( rk.drill, 9999 ),
406 rk.mechanical ? 'U':'P' );
407 }
408 else
409 {
410 fprintf( aFile, " " );
411 }
412
413 // A 307 record omits the surface pad size, which goes in its 027 continuation instead
414 if( blindOrBuried )
415 {
416 fprintf( aFile, "A%02dX%+07dY%+07d%14s", rk.access, iu_to_d356( rk.x_location, 999999 ),
417 iu_to_d356( rk.y_location, 999999 ), "" );
418 }
419 else
420 {
421 writeAccessAndSize();
422 }
423
424 // Soldermask lives in columns 73-74 with column 72 left blank
425 fprintf( aFile, " S%d", rk.soldermask );
426
427 // Every test record is a full 80 columns
428 if( blindOrBuried )
429 fprintf( aFile, "L%02dL%02d\n", rk.start_layer, rk.end_layer );
430 else
431 fprintf( aFile, "%6s\n", "" );
432
433 // Blind vias reach a surface, so the 027 continuation describes that pad
434 if( blindOrBuried
435 && ( rk.start_layer == 1 || rk.end_layer == m_pcb->GetCopperLayerCount() ) )
436 {
437 // The midpoint flag belongs to the parent record only
438 writeComponent( 27, false );
439 fprintf( aFile, " " );
440 writeAccessAndSize();
441 fprintf( aFile, " S%d%6s\n", rk.soldermask, "" );
442 }
443 }
444}
445
446
447bool IPC356D_WRITER::Write( const wxString& aFilename )
448{
449 FILE* file = nullptr;
450 LOCALE_IO toggle; // Switch the locale to standard C
451
452 if( ( file = wxFopen( aFilename, wxT( "wt" ) ) ) == nullptr )
453 {
454 return false;
455 }
456
457 // This will contain everything needed for the 356 file
458 std::vector<D356_RECORD> d356_records;
459
460 std::vector<FAB_TEST_POINT> points = FabTestPoints( *m_pcb );
461 appendViaRecords( m_pcb, points, d356_records );
462 appendPadRecords( m_pcb, points, d356_records );
463
464 // Code 00 AFAIK is ASCII, CUST 0 is decimils/degrees
465 // CUST 1 would be metric but gerbtool simply ignores it!
466 // Every record is 80 columns and parameter values must end by column 72
467 auto writeRecord =
468 [&]( const std::string& aRecord )
469 {
470 fprintf( file, "%-80.80s\n", aRecord.substr( 0, 72 ).c_str() );
471 };
472
473 // Parameter values start in column 10 and JOB must lead the header
474 writeRecord( "P JOB " + std::string( TO_UTF8( wxFileName( m_pcb->GetFileName() ).GetName() ) ) );
475 writeRecord( "P CODE 00" );
476 writeRecord( "P UNITS CUST 0" );
477 writeRecord( "P arrayDim N" );
478 writeRecord( "P VER IPC-D-356A" );
479 writeRecord( "P IMAGE PRIMARY" );
480 write_D356_records( d356_records, file );
481 writeRecord( "999" );
482
483 fclose( file );
484
485 return true;
486}
487
488
489
490
491// Subclass for wxFileDialogCustomizeHook to add the checkbox
492class D365_CUSTOMIZE_HOOK : public wxFileDialogCustomizeHook
493{
494public:
495
496public:
497 D365_CUSTOMIZE_HOOK( bool aDoNotExportUnconnectedPads = false ) :
498 m_doNotExportUnconnectedPads( aDoNotExportUnconnectedPads ),
499 m_cb(nullptr)
500 {};
501
502 virtual void AddCustomControls( wxFileDialogCustomize& customizer ) override
503 {
504#ifdef __WXMAC__
505 customizer.AddStaticText( wxT( "\n\n" ) ); // Increase height of static box
506#endif
507
508 m_cb = customizer.AddCheckBox( _( "Do not export unconnected pads" ) );
510 }
511
512 virtual void TransferDataFromCustomControls() override
513 {
515 }
516
518private:
519
521 wxFileDialogCheckBox* m_cb;
522
524};
525
526
528{
529 wxFileName fn = m_frame->GetBoard()->GetFileName();
530 wxString ext, wildcard;
531
533 wildcard = FILEEXT::IpcD356FileWildcard();
534 fn.SetExt( ext );
535
536 wxString pro_dir = wxPathOnly( m_frame->Prj().GetProjectFullName() );
537
538 wxFileDialog dlg( m_frame, _( "Generate IPC-D-356 netlist file" ), pro_dir, fn.GetFullName(),
539 wildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
540 D365_CUSTOMIZE_HOOK customizeHook( m_frame->GetPcbNewSettings()->m_ExportD356.doNotExportUnconnectedPads );
541 dlg.SetCustomizeHook( customizeHook );
542
544
545 if( dlg.ShowModal() == wxID_CANCEL )
546 return 0;
547
548 IPC356D_WRITER writer( m_frame->GetBoard() );
549 bool doNotExportUnconnectedPads = customizeHook.GetDoNotExportUnconnectedPads();
550 writer.SetDoNotExportUnconnectedPads( doNotExportUnconnectedPads );
551 m_frame->GetPcbNewSettings()->m_ExportD356.doNotExportUnconnectedPads = doNotExportUnconnectedPads;
552
553 if( writer.Write( dlg.GetPath() ) )
554 {
555 DisplayInfoMessage( m_frame, wxString::Format( _( "IPC-D-356 netlist file created:\n'%s'." ),
556 dlg.GetPath() ) );
557 }
558 else
559 {
560 DisplayError( m_frame, wxString::Format( _( "Failed to create file '%s'." ),
561 dlg.GetPath() ) );
562 }
563
564 return 0;
565}
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:128
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:985
const VECTOR2I & GetAuxOrigin() const
int GenD356File(const TOOL_EVENT &aEvent)
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
int GetCopperLayerCount() const
Definition board.cpp:1155
BOARD_DESIGN_SETTINGS & GetDesignSettings()
Definition board.cpp:1318
virtual void TransferDataFromCustomControls() override
D365_CUSTOMIZE_HOOK(bool aDoNotExportUnconnectedPads=false)
wxDECLARE_NO_COPY_CLASS(D365_CUSTOMIZE_HOOK)
wxFileDialogCheckBox * m_cb
bool GetDoNotExportUnconnectedPads() const
virtual void AddCustomControls(wxFileDialogCustomize &customizer) override
bool IsFlipped() const
Definition footprint.h:620
const wxString & GetReference() const
Definition footprint.h:793
Wrapper to expose an API for writing IPC-D356 files.
Definition export_d356.h:60
bool m_doNotExportUnconnectedPads
Definition export_d356.h:98
void write_D356_records(std::vector< D356_RECORD > &aRecords, FILE *aFile)
Writes a list of records to the given output stream.
void SetDoNotExportUnconnectedPads(bool aDoNotExportUnconnectedPads)
Sets whether unconnected pads should be exported.
Definition export_d356.h:84
void appendPadRecords(BOARD *aPcb, const std::vector< FAB_TEST_POINT > &aPoints, std::vector< D356_RECORD > &aRecords)
bool Write(const wxString &aFilename)
Generates and writes the netlist to a given path.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition locale_io.h:37
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
static const LSET & AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition lset.cpp:604
Handle the data for a net.
Definition netinfo.h:50
const wxString & GetNetname() const
Definition netinfo.h:110
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition netinfo.h:281
@ NORMAL
Shape is the same on all layers.
Definition padstack.h:175
Definition pad.h:61
Generic, UI-independent tool event.
Definition tool_event.h:167
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition confirm.cpp:245
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition confirm.cpp:192
This file is part of the common library.
#define _(s)
static int physical_layer(BOARD *aPcb, PCB_LAYER_ID aLayer)
static void appendViaRecords(BOARD *aPcb, const std::vector< FAB_TEST_POINT > &aPoints, std::vector< D356_RECORD > &aRecords)
static wxString sanitize_d356_name(const wxString &aNetname, bool aUpper)
static wxString d356_alias(int aIndex)
static int iu_to_d356(int iu, int clamp)
static int via_access_code(BOARD *aPcb, int top_layer, int bottom_layer)
static int compute_pad_access_code(BOARD *aPcb, LSET aLayerMask)
std::vector< FAB_TEST_POINT > FabTestPoints(const BOARD &aBoard)
The caller must build board connectivity before enumerating net endpoints.
static const std::string IpcD356FileExtension
static wxString IpcD356FileWildcard()
size_t CopperLayerToOrdinal(PCB_LAYER_ID aLayer)
Converts KiCad copper layer enum to an ordinal between the front and back layers.
Definition layer_ids.h:986
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ B_Mask
Definition layer_ids.h:94
@ B_Cu
Definition layer_ids.h:61
@ F_Mask
Definition layer_ids.h:93
@ In1_Cu
Definition layer_ids.h:62
@ F_Cu
Definition layer_ids.h:60
This file contains miscellaneous commonly used macros and functions.
void AllowNetworkFileSystems(wxDialog *aDialog)
Configure a file dialog to show network and virtual file systems.
Definition wxgtk/ui.cpp:741
@ NPTH
like PAD_PTH, but not plated mechanical use only, no connection allowed
Definition padstack.h:104
@ NON_COMPONENT
Pad with no hole that does not connect to a physical component, but rather provides a connection poin...
Definition padstack.h:106
@ SMD
Smd pad, appears on the solder paste layer (default)
Definition padstack.h:100
@ CONN
Like smd, does not appear on the solder paste layer (default) Note: also has a special attribute in G...
Definition padstack.h:101
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
wxString refdes
Definition export_d356.h:37
bool mechanical
Definition export_d356.h:41
wxString pin
Definition export_d356.h:38
wxString netname
Definition export_d356.h:36
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708
Definition of file extensions used in Kicad.