KiCad PCB EDA Suite
board_stackup.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) 2019 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2009-2021 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 3
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 along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21
22#include "board_stackup.h"
23#include <base_units.h>
24#include <string_utils.h>
25#include <layer_ids.h>
27#include <board.h>
28#include <i18n_utility.h> // For _HKI definition
30
31
33{
34 DIELECTRIC_PRMS item_prms;
35 m_DielectricPrmsList.emplace_back( item_prms );
37 m_Type = aType;
39 SetEnabled( true );
40
41 // Initialize parameters to a usual value for allowed types:
42 switch( m_Type )
43 {
47 break;
48
50 m_TypeName = KEY_CORE; // or prepreg
51 SetMaterial( wxT( "FR4" ) ); // or other dielectric name
52 SetLossTangent( 0.02 ); // for FR4
53 SetEpsilonR( 4.5 ); // for FR4
54 break;
55
57 m_TypeName = wxT( "solderpaste" );
58 break;
59
61 m_TypeName = wxT( "soldermask" );
63 SetMaterial( NotSpecifiedPrm() ); // or other solder mask material name
66 break;
67
69 m_TypeName = wxT( "silkscreen" );
71 SetMaterial( NotSpecifiedPrm() ); // or other silkscreen material name
73 break;
74
76 break;
77 }
78}
79
80
82{
83 m_LayerId = aOther.m_LayerId;
85 m_Type = aOther.m_Type;
86 m_enabled = aOther.m_enabled;
88 m_TypeName = aOther.m_TypeName;
89 m_LayerName = aOther.m_LayerName;
90 m_Color = aOther.GetColor();
91}
92
93
94void BOARD_STACKUP_ITEM::AddDielectricPrms( int aDielectricPrmsIdx )
95{
96 // add a DIELECTRIC_PRMS item to m_DielectricPrmsList
97 DIELECTRIC_PRMS new_prms;
98
99 m_DielectricPrmsList.emplace( m_DielectricPrmsList.begin() + aDielectricPrmsIdx, new_prms );
100}
101
102
103void BOARD_STACKUP_ITEM::RemoveDielectricPrms( int aDielectricPrmsIdx )
104{
105 // Remove a DIELECTRIC_PRMS item from m_DielectricPrmsList if possible
106
107 if( GetSublayersCount() < 2
108 || aDielectricPrmsIdx < 0
109 || aDielectricPrmsIdx >= GetSublayersCount() )
110 {
111 return;
112 }
113
114 m_DielectricPrmsList.erase( m_DielectricPrmsList.begin() + aDielectricPrmsIdx );
115}
116
117
118
120{
121 // A reasonable thickness for copper layers:
122 return pcbIUScale.mmToIU( 0.035 );
123}
124
125
127{
128 // A reasonable thickness for solder mask:
129 return pcbIUScale.mmToIU( 0.01 );
130}
131
132
133// Getters:
134int BOARD_STACKUP_ITEM::GetThickness( int aDielectricSubLayer ) const
135{
136 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
137
138 return m_DielectricPrmsList[aDielectricSubLayer].m_Thickness;
139}
140
141
142double BOARD_STACKUP_ITEM::GetLossTangent( int aDielectricSubLayer ) const
143{
144 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
145
146 return m_DielectricPrmsList[aDielectricSubLayer].m_LossTangent;
147}
148
149
150double BOARD_STACKUP_ITEM::GetEpsilonR( int aDielectricSubLayer ) const
151{
152 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
153
154 return m_DielectricPrmsList[aDielectricSubLayer].m_EpsilonR;
155}
156
157
158bool BOARD_STACKUP_ITEM::IsThicknessLocked( int aDielectricSubLayer ) const
159{
160 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
161
162 return m_DielectricPrmsList[aDielectricSubLayer].m_ThicknessLocked;
163}
164
165
166wxString BOARD_STACKUP_ITEM::GetMaterial( int aDielectricSubLayer ) const
167{
168 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
169
170 return m_DielectricPrmsList[aDielectricSubLayer].m_Material;
171}
172
173
174// Setters:
175void BOARD_STACKUP_ITEM::SetThickness( int aThickness, int aDielectricSubLayer )
176{
177 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
178
179 if( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() )
180 m_DielectricPrmsList[aDielectricSubLayer].m_Thickness = aThickness;
181}
182
183
184void BOARD_STACKUP_ITEM::SetLossTangent( double aTg, int aDielectricSubLayer )
185{
186 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
187
188 if( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() )
189 m_DielectricPrmsList[aDielectricSubLayer].m_LossTangent = aTg;
190}
191
192
193void BOARD_STACKUP_ITEM::SetEpsilonR( double aEpsilon, int aDielectricSubLayer )
194{
195 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
196
197 if( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() )
198 m_DielectricPrmsList[aDielectricSubLayer].m_EpsilonR = aEpsilon;
199}
200
201
202void BOARD_STACKUP_ITEM::SetThicknessLocked( bool aLocked, int aDielectricSubLayer )
203{
204 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
205
206 if( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() )
207 m_DielectricPrmsList[aDielectricSubLayer].m_ThicknessLocked = aLocked;
208}
209
210
211void BOARD_STACKUP_ITEM::SetMaterial( const wxString& aName, int aDielectricSubLayer )
212{
213 wxASSERT( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() );
214
215 if( aDielectricSubLayer >= 0 && aDielectricSubLayer < GetSublayersCount() )
216 m_DielectricPrmsList[aDielectricSubLayer].m_Material = aName;
217}
218
219
221{
224};
225
226
228{
231};
232
233
234bool BOARD_STACKUP_ITEM::HasMaterialValue( int aDielectricSubLayer ) const
235{
236 // return true if the material is specified
237 return IsMaterialEditable() && IsPrmSpecified( GetMaterial( aDielectricSubLayer ) );
238}
239
240
242{
246}
247
248
250{
254}
255
256
258{
262}
263
264
265wxString BOARD_STACKUP_ITEM::FormatEpsilonR( int aDielectricSubLayer ) const
266{
267 // return a wxString to print/display Epsilon R
268 // note: we do not want scientific notation
269 wxString txt = UIDouble2Str( GetEpsilonR( aDielectricSubLayer ) );
270 return txt;
271}
272
273
274wxString BOARD_STACKUP_ITEM::FormatLossTangent( int aDielectricSubLayer ) const
275{
276 // return a wxString to print/display Loss Tangent
277 // note: we do not want scientific notation
278 wxString txt = UIDouble2Str( GetLossTangent( aDielectricSubLayer ) );
279 return txt;
280}
281
282
284{
285 // return a wxString to print/display a dielectric name
286 wxString lname;
287 lname.Printf( _( "Dielectric %d" ), GetDielectricLayerId() );
288
289 return lname;
290}
291
292
294{
295 m_HasDielectricConstrains = false; // True if some dielectric layers have constrains
296 // (Loss tg and Epison R)
297 m_HasThicknessConstrains = false; // True if some dielectric or copper layers have constrains
299 m_CastellatedPads = false; // True if some castellated pads exist
300 m_EdgePlating = false; // True if edge board is plated
301 m_FinishType = wxT( "None" ); // undefined finish type
302}
303
304
306{
312 m_FinishType = aOther.m_FinishType;
313
314 // All items in aOther.m_list have to be duplicated, because aOther.m_list
315 // manage pointers to these items
316 for( BOARD_STACKUP_ITEM* item : aOther.m_list )
317 {
318 BOARD_STACKUP_ITEM* dup_item = new BOARD_STACKUP_ITEM( *item );
319 Add( dup_item );
320 }
321}
322
323
325{
331 m_FinishType = aOther.m_FinishType;
332
333 RemoveAll();
334
335 // All items in aOther.m_list have to be duplicated, because aOther.m_list
336 // manage pointers to these items
337 for( BOARD_STACKUP_ITEM* item : aOther.m_list )
338 {
339 BOARD_STACKUP_ITEM* dup_item = new BOARD_STACKUP_ITEM( *item );
340 Add( dup_item );
341 }
342
343 return *this;
344}
345
346
348{
349 for( BOARD_STACKUP_ITEM* item : m_list )
350 delete item;
351
352 m_list.clear();
353}
354
355
357{
358 if( aIndex < 0 || aIndex >= GetCount() )
359 return nullptr;
360
361 return GetList()[aIndex];
362}
363
364
366{
367 // return the board thickness from the thickness of BOARD_STACKUP_ITEM list
368 int thickness = 0;
369
370 for( BOARD_STACKUP_ITEM* item : m_list )
371 {
372 if( item->IsThicknessEditable() && item->IsEnabled() )
373 {
374 thickness += item->GetThickness();
375
376 // dielectric layers can have more than one main layer
377 // add thickness of all sublayers
378 for( int idx = 1; idx < item->GetSublayersCount(); idx++ )
379 {
380 thickness += item->GetThickness( idx );
381 }
382 }
383 }
384
385 return thickness;
386}
387
388
390{
391 bool change = false;
392 // Build the suitable stackup:
393 BOARD_STACKUP stackup;
394 stackup.BuildDefaultStackupList( aSettings );
395
396 // First, find removed layers:
397 for( BOARD_STACKUP_ITEM* curr_item: m_list )
398 {
399 bool found = false;
400
401 for( BOARD_STACKUP_ITEM* item: stackup.GetList() )
402 {
403 if( curr_item->GetBrdLayerId() != UNDEFINED_LAYER )
404 {
405 if( item->GetBrdLayerId() == curr_item->GetBrdLayerId() )
406 {
407 found = true;
408 break;
409 }
410 }
411 else // curr_item = dielectric layer
412 {
413 if( item->GetBrdLayerId() != UNDEFINED_LAYER )
414 continue;
415
416 if( item->GetDielectricLayerId() == curr_item->GetDielectricLayerId() )
417 {
418 found = true;
419 break;
420 }
421 }
422 }
423
424 if( !found ) // a layer was removed: a change is found
425 {
426 change = true;
427 break;
428 }
429 }
430
431 // Now initialize all stackup items to the initial values, when exist
432 for( BOARD_STACKUP_ITEM* item : stackup.GetList() )
433 {
434 bool found = false;
435 // Search for initial settings:
436 for( const BOARD_STACKUP_ITEM* initial_item : m_list )
437 {
438 if( item->GetBrdLayerId() != UNDEFINED_LAYER )
439 {
440 if( item->GetBrdLayerId() == initial_item->GetBrdLayerId() )
441 {
442 *item = *initial_item;
443 found = true;
444 break;
445 }
446 }
447 else // dielectric layer: see m_DielectricLayerId for identification
448 {
449 // Compare dielectric layer with dielectric layer
450 if( initial_item->GetBrdLayerId() != UNDEFINED_LAYER )
451 continue;
452
453 if( item->GetDielectricLayerId() == initial_item->GetDielectricLayerId() )
454 {
455 *item = *initial_item;
456 found = true;
457 break;
458 }
459 }
460 }
461
462 if( !found )
463 {
464 change = true;
465 }
466 }
467
468 // Transfer layer settings:
469 *this = stackup;
470
471 // Transfer other stackup settings from aSettings
472 const BOARD_STACKUP& source_stackup = aSettings->GetStackupDescriptor();
475 m_CastellatedPads = source_stackup.m_CastellatedPads;
476 m_EdgePlating = source_stackup.m_EdgePlating;
477 m_FinishType = source_stackup.m_FinishType;
478
479 return change;
480}
481
482
484 int aActiveCopperLayersCount )
485{
486 // Creates a default stackup, according to the current BOARD_DESIGN_SETTINGS settings.
487 // Note: the m_TypeName string is made translatable using _HKI marker, but is not
488 // translated when building the stackup.
489 // It will be used as this in files, and can be translated only in dialog
490 // if aSettings == NULL, build a full stackup (with 32 copper layers)
491 LSET enabledLayer = aSettings ? aSettings->GetEnabledLayers() : StackupAllowedBrdLayers();
492 int copperLayerCount = aSettings ? aSettings->GetCopperLayerCount() : B_Cu+1;
493
494 // We need to calculate a suitable dielectric layer thickness.
495 // If no settings, and if aActiveCopperLayersCount is given, use it
496 // (If no settings, and no aActiveCopperLayersCount, the full 32 layers are used)
497 int activeCuLayerCount = copperLayerCount;
498
499 if( aSettings == nullptr && aActiveCopperLayersCount > 0 )
500 activeCuLayerCount = aActiveCopperLayersCount;
501
502 int brd__thickness = aSettings ? aSettings->GetBoardThickness() : pcbIUScale.mmToIU( 1.6 );
503 int diel_thickness = brd__thickness -
504 ( BOARD_STACKUP_ITEM::GetCopperDefaultThickness() * activeCuLayerCount );
505
506 // Take in account the solder mask thickness:
507 int sm_count = ( enabledLayer & LSET( 2, F_Mask, B_Mask) ).count();
508 diel_thickness -= BOARD_STACKUP_ITEM::GetMaskDefaultThickness() * sm_count;
509 diel_thickness /= std::max( 1, activeCuLayerCount - 1 );
510
511 int dielectric_idx = 0;
512
513 // Add silk screen, solder mask and solder paste layers on top
514 if( enabledLayer[F_SilkS] )
515 {
517 item->SetBrdLayerId( F_SilkS );
518 item->SetTypeName( _HKI( "Top Silk Screen" ) );
519 Add( item );
520 }
521
522 if( enabledLayer[F_Paste] )
523 {
525 item->SetBrdLayerId( F_Paste );
526 item->SetTypeName( _HKI( "Top Solder Paste" ) );
527 Add( item );
528 }
529
530 if( enabledLayer[F_Mask] )
531 {
533 item->SetBrdLayerId( F_Mask );
534 item->SetTypeName( _HKI( "Top Solder Mask" ) );
535 Add( item );
536 }
537
538 // Add copper and dielectric layers
539 for( int ii = 0; ii < copperLayerCount; ii++ )
540 {
542 item->SetBrdLayerId( ( PCB_LAYER_ID )ii );
543 item->SetTypeName( KEY_COPPER );
544 Add( item );
545
546 if( ii == copperLayerCount-1 )
547 {
548 item->SetBrdLayerId( B_Cu );
549 break;
550 }
551
552 // Add the dielectric layer:
554 item->SetThickness( diel_thickness );
555 item->SetDielectricLayerId( dielectric_idx + 1 );
556
557 // Display a dielectric default layer name:
558 if( (dielectric_idx & 1) == 0 )
559 {
560 item->SetTypeName( KEY_CORE );
561 item->SetMaterial( wxT( "FR4" ) );
562 }
563 else
564 {
565 item->SetTypeName( KEY_PREPREG );
566 item->SetMaterial( wxT( "FR4" ) );
567 }
568
569 Add( item );
570 dielectric_idx++;
571 }
572
573 // Add silk screen, solder mask and solder paste layers on bottom
574 if( enabledLayer[B_Mask] )
575 {
577 item->SetBrdLayerId( B_Mask );
578 item->SetTypeName( _HKI( "Bottom Solder Mask" ) );
579 Add( item );
580 }
581
582 if( enabledLayer[B_Paste] )
583 {
585 item->SetBrdLayerId( B_Paste );
586 item->SetTypeName( _HKI( "Bottom Solder Paste" ) );
587 Add( item );
588 }
589
590 if( enabledLayer[B_SilkS] )
591 {
593 item->SetBrdLayerId( B_SilkS );
594 item->SetTypeName( _HKI( "Bottom Silk Screen" ) );
595 Add( item );
596 }
597
598 // Transfer other stackup settings from aSettings
599 if( aSettings )
600 {
601 const BOARD_STACKUP& source_stackup = aSettings->GetStackupDescriptor();
603 m_CastellatedPads = source_stackup.m_CastellatedPads;
604 m_EdgePlating = source_stackup.m_EdgePlating;
605 m_FinishType = source_stackup.m_FinishType;
606 }
607}
608
609
611 const BOARD* aBoard, int aNestLevel ) const
612{
613 // Board stackup is the ordered list from top to bottom of
614 // physical layers and substrate used to build the board.
615 if( m_list.empty() )
616 return;
617
618 aFormatter->Print( aNestLevel, "(stackup\n" );
619 int nest_level = aNestLevel+1;
620
621 // Note:
622 // Unspecified parameters are not stored in file.
623 for( BOARD_STACKUP_ITEM* item: m_list )
624 {
625 wxString layer_name;
626
627 if( item->GetBrdLayerId() == UNDEFINED_LAYER )
628 layer_name.Printf( wxT( "dielectric %d" ), item->GetDielectricLayerId() );
629 else
630 layer_name = LSET::Name( item->GetBrdLayerId() );
631
632 aFormatter->Print( nest_level, "(layer %s (type %s)",
633 aFormatter->Quotew( layer_name ).c_str(),
634 aFormatter->Quotew( item->GetTypeName() ).c_str() );
635
636 if( item->IsColorEditable() && IsPrmSpecified( item->GetColor() ) )
637 {
638 aFormatter->Print( 0, " (color %s)",
639 aFormatter->Quotew( item->GetColor() ).c_str() );
640 }
641
642 for( int idx = 0; idx < item->GetSublayersCount(); idx++ )
643 {
644 if( idx ) // not for the main (first) layer.
645 {
646 aFormatter->Print( 0, "\n" );
647 aFormatter->Print( nest_level+1, "addsublayer" );
648 }
649
650 if( item->IsThicknessEditable() )
651 {
652 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC && item->IsThicknessLocked( idx ) )
653 aFormatter->Print( 0, " (thickness %s locked)",
654 EDA_UNIT_UTILS::FormatInternalUnits( pcbIUScale, item->GetThickness( idx ) ).c_str() );
655 else
656 aFormatter->Print( 0, " (thickness %s)",
657 EDA_UNIT_UTILS::FormatInternalUnits( pcbIUScale, item->GetThickness( idx ) ).c_str() );
658 }
659
660 if( item->HasMaterialValue( idx ) )
661 aFormatter->Print( 0, " (material %s)",
662 aFormatter->Quotew( item->GetMaterial( idx ) ).c_str() );
663
664 if( item->HasEpsilonRValue() && item->HasMaterialValue( idx ) )
665 aFormatter->Print( 0, " (epsilon_r %g)", item->GetEpsilonR( idx ) );
666
667 if( item->HasLossTangentValue() && item->HasMaterialValue( idx ) )
668 aFormatter->Print( 0, " (loss_tangent %s)",
669 FormatDouble2Str( item->GetLossTangent( idx ) ).c_str() );
670 }
671
672 aFormatter->Print( 0, ")\n" );
673 }
674
675 // Other infos about board, related to layers and other fabrication specifications
677 {
678 aFormatter->Print( nest_level, "(copper_finish %s)\n",
679 aFormatter->Quotew( m_FinishType ).c_str() );
680 }
681
682 aFormatter->Print( nest_level, "(dielectric_constraints %s)\n",
683 m_HasDielectricConstrains ? "yes" : "no" );
684
686 {
687 aFormatter->Print( nest_level, "(edge_connector %s)\n",
688 m_EdgeConnectorConstraints > 1 ? "bevelled": "yes" );
689 }
690
692 aFormatter->Print( nest_level, "(castellated_pads yes)\n" );
693
694 if( m_EdgePlating )
695 aFormatter->Print( nest_level, "(edge_plating yes)\n" );
696
697 aFormatter->Print( aNestLevel, ")\n" );
698}
699
700
701int BOARD_STACKUP::GetLayerDistance( PCB_LAYER_ID aFirstLayer, PCB_LAYER_ID aSecondLayer ) const
702{
703 wxASSERT( IsCopperLayer( aFirstLayer ) && IsCopperLayer( aSecondLayer ) );
704
705 if( aFirstLayer == aSecondLayer )
706 return 0;
707
708 if( aSecondLayer < aFirstLayer )
709 std::swap( aFirstLayer, aSecondLayer );
710
711 int total = 0;
712 bool start = false;
713 bool half = false;
714
715 for( BOARD_STACKUP_ITEM* item : m_list )
716 {
717 // Will be UNDEFINED_LAYER for dielectrics
718 PCB_LAYER_ID layer = item->GetBrdLayerId();
719
720 if( layer != UNDEFINED_LAYER && !IsCopperLayer( layer ) )
721 continue; // Silk/mask layer
722
723 // Reached the start copper layer? Start counting the next dielectric after it
724 if( !start && ( layer != UNDEFINED_LAYER && layer >= aFirstLayer ) )
725 {
726 start = true;
727 half = true;
728 }
729 else if( !start )
730 continue;
731
732 // Reached the stop copper layer? we're done
733 if( start && ( layer != UNDEFINED_LAYER && layer >= aSecondLayer ) )
734 half = true;
735
736 for( int sublayer = 0; sublayer < item->GetSublayersCount(); sublayer++ )
737 {
738 int subThickness = item->GetThickness( sublayer );
739 total += half ? ( subThickness / 2 ) : subThickness;
740 }
741
742 half = false;
743
744 if( layer != UNDEFINED_LAYER && layer >= aSecondLayer )
745 break;
746 }
747
748 return total;
749}
750
751
752bool IsPrmSpecified( const wxString& aPrmValue )
753{
754 // return true if the param value is specified:
755
756 if( !aPrmValue.IsEmpty()
757 && ( aPrmValue.CmpNoCase( NotSpecifiedPrm() ) != 0 )
758 && aPrmValue != wxGetTranslation( NotSpecifiedPrm() ) )
759 return true;
760
761 return false;
762}
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
bool IsPrmSpecified(const wxString &aPrmValue)
@ BS_EDGE_CONNECTOR_NONE
Definition: board_stackup.h:55
BOARD_STACKUP_ITEM_TYPE
Definition: board_stackup.h:41
@ BS_ITEM_TYPE_UNDEFINED
Definition: board_stackup.h:42
@ BS_ITEM_TYPE_COPPER
Definition: board_stackup.h:43
@ BS_ITEM_TYPE_SILKSCREEN
Definition: board_stackup.h:49
@ BS_ITEM_TYPE_DIELECTRIC
Definition: board_stackup.h:44
@ BS_ITEM_TYPE_SOLDERPASTE
Definition: board_stackup.h:46
@ BS_ITEM_TYPE_SOLDERMASK
Definition: board_stackup.h:47
Container for design settings for a BOARD object.
LSET GetEnabledLayers() const
Return a bit-mask of all the layers that are enabled.
int GetBoardThickness() const
The full thickness of the board including copper and masks.
BOARD_STACKUP & GetStackupDescriptor()
Manage one layer needed to make a physical board.
Definition: board_stackup.h:90
void AddDielectricPrms(int aDielectricPrmsIdx)
Add (insert) a DIELECTRIC_PRMS item to m_DielectricPrmsList all values are set to default.
wxString m_Color
type name of layer (copper, silk screen, core, prepreg ...)
PCB_LAYER_ID m_LayerId
mainly for silkscreen and solder mask
int GetSublayersCount() const
void SetDielectricLayerId(int aLayerId)
double GetEpsilonR(int aDielectricSubLayer=0) const
bool HasEpsilonRValue() const
void SetThickness(int aThickness, int aDielectricSubLayer=0)
bool IsMaterialEditable() const
BOARD_STACKUP_ITEM_TYPE m_Type
bool HasMaterialValue(int aDielectricSubLayer=0) const
void SetThicknessLocked(bool aLocked, int aDielectricSubLayer=0)
wxString FormatDielectricLayerName() const
void SetMaterial(const wxString &aName, int aDielectricSubLayer=0)
BOARD_STACKUP_ITEM(BOARD_STACKUP_ITEM_TYPE aType)
bool HasLossTangentValue() const
bool IsThicknessEditable() const
wxString GetColor() const
void SetLossTangent(double aTg, int aDielectricSubLayer=0)
int GetThickness(int aDielectricSubLayer=0) const
void SetEnabled(bool aEnable)
std::vector< DIELECTRIC_PRMS > m_DielectricPrmsList
the "layer" id for dielectric layers, from 1 (top) to 31 (bottom) (only 31 dielectric layers for 32 c...
static int GetMaskDefaultThickness()
wxString GetMaterial(int aDielectricSubLayer=0) const
wxString m_TypeName
name of layer as shown in layer manager. Useful to create reports
void SetBrdLayerId(PCB_LAYER_ID aBrdLayerId)
void SetTypeName(const wxString &aName)
bool IsThicknessLocked(int aDielectricSubLayer=0) const
wxString FormatEpsilonR(int aDielectricSubLayer=0) const
int m_DielectricLayerId
the layer id (F.Cu to B.Cu, F.Silk, B.silk, F.Mask, B.Mask) and UNDEFINED_LAYER (-1) for dielectric l...
void SetEpsilonR(double aEpsilon, int aDielectricSubLayer=0)
void RemoveDielectricPrms(int aDielectricPrmsIdx)
Remove a DIELECTRIC_PRMS item from m_DielectricPrmsList.
int GetDielectricLayerId() const
bool IsColorEditable() const
wxString FormatLossTangent(int aDielectricSubLayer=0) const
double GetLossTangent(int aDielectricSubLayer=0) const
static int GetCopperDefaultThickness()
Manage layers needed to make a physical board.
void RemoveAll()
Delete all items in list and clear the list.
void FormatBoardStackup(OUTPUTFORMATTER *aFormatter, const BOARD *aBoard, int aNestLevel) const
Write the stackup info on board file.
bool m_CastellatedPads
True if castellated pads exist.
const std::vector< BOARD_STACKUP_ITEM * > & GetList() const
static LSET StackupAllowedBrdLayers()
int GetCount() const
bool SynchronizeWithBoard(BOARD_DESIGN_SETTINGS *aSettings)
Synchronize the BOARD_STACKUP_ITEM* list with the board.
int BuildBoardThicknessFromStackup() const
bool m_HasDielectricConstrains
True if some layers have impedance controlled tracks or have specific constrains for micro-wave appli...
void Add(BOARD_STACKUP_ITEM *aItem)
Add a new item in stackup layer.
void BuildDefaultStackupList(const BOARD_DESIGN_SETTINGS *aSettings, int aActiveCopperLayersCount=0)
Create a default stackup, according to the current BOARD_DESIGN_SETTINGS settings.
BOARD_STACKUP & operator=(const BOARD_STACKUP &aOther)
BOARD_STACKUP_ITEM * GetStackupLayer(int aIndex)
int GetLayerDistance(PCB_LAYER_ID aFirstLayer, PCB_LAYER_ID aSecondLayer) const
Calculate the distance (height) between the two given copper layers.
std::vector< BOARD_STACKUP_ITEM * > m_list
bool m_EdgePlating
True if the edge board is plated.
BS_EDGE_CONNECTOR_CONSTRAINTS m_EdgeConnectorConstraints
If the board has edge connector cards, some constrains can be specified in job file: BS_EDGE_CONNECTO...
bool m_HasThicknessConstrains
True if some layers (copper and/or dielectric) have specific thickness.
wxString m_FinishType
The name of external copper finish.
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:265
A helper class to manage a dielectric layer set of parameters.
Definition: board_stackup.h:65
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:530
static const wxChar * Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition: lset.cpp:82
An interface used to output 8 bit text in a convenient way.
Definition: richio.h:310
std::string Quotew(const wxString &aWrapee) const
Definition: richio.cpp:499
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:431
#define _HKI(x)
#define _(s)
Some functions to handle hotkeys in KiCad.
bool IsCopperLayer(int aLayerId)
Tests whether a layer is a copper layer.
Definition: layer_ids.h:823
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:59
@ F_Paste
Definition: layer_ids.h:101
@ B_Mask
Definition: layer_ids.h:106
@ B_Cu
Definition: layer_ids.h:95
@ F_Mask
Definition: layer_ids.h:107
@ B_Paste
Definition: layer_ids.h:100
@ F_SilkS
Definition: layer_ids.h:104
@ UNDEFINED_LAYER
Definition: layer_ids.h:60
@ B_SilkS
Definition: layer_ids.h:103
std::string FormatInternalUnits(const EDA_IU_SCALE &aIuScale, int aValue)
Converts aValue from internal units to a string appropriate for writing to file.
Definition: eda_units.cpp:143
wxString NotSpecifiedPrm()
#define KEY_PREPREG
#define KEY_COPPER
#define KEY_CORE
#define DEFAULT_EPSILON_R_SILKSCREEN
#define DEFAULT_EPSILON_R_SOLDERMASK
std::string UIDouble2Str(double aValue)
Print a float number without using scientific notation and no trailing 0 We want to avoid scientific ...
std::string FormatDouble2Str(double aValue)
Print a float number without using scientific notation and no trailing 0 This function is intended in...
constexpr int mmToIU(double mm) const
Definition: base_units.h:89