board_stackup.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2009-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef BOARD_STACKUP_H
#define BOARD_STACKUP_H
 
 
#include <vector>
#include <wx/string.h>
#include <layer_ids.h>
#include <api/serializable.h>
 
class BOARD;
class BOARD_DESIGN_SETTINGS;
class OUTPUTFORMATTER;
 
// A enum to manage the different layers inside the stackup layers.
// Note the stackup layers include both dielectric and some layers handled by the board editor
// Therefore a stackup layer item is not exactly like a board layer
enum BOARD_STACKUP_ITEM_TYPE
{
 BS_ITEM_TYPE_UNDEFINED, // For not yet initialized BOARD_STACKUP_ITEM item
 BS_ITEM_TYPE_COPPER, // A initialized BOARD_STACKUP_ITEM item for copper layers
 BS_ITEM_TYPE_DIELECTRIC, // A initialized BOARD_STACKUP_ITEM item for the
 // dielectric between copper layers
 BS_ITEM_TYPE_SOLDERPASTE, // A initialized BOARD_STACKUP_ITEM item for solder paste layers
 BS_ITEM_TYPE_SOLDERMASK, // A initialized BOARD_STACKUP_ITEM item for solder mask layers
 // note: this is a specialized dielectric material
 BS_ITEM_TYPE_SILKSCREEN, // A initialized BOARD_STACKUP_ITEM item for silkscreen layers
};
 
// A enum to manage edge connector fab info
enum BS_EDGE_CONNECTOR_CONSTRAINTS
{
 BS_EDGE_CONNECTOR_NONE, // No edge connector in board
 BS_EDGE_CONNECTOR_IN_USE, // some edge connector in board
 BS_EDGE_CONNECTOR_BEVELLED // Some connector in board, and the connector must be beveled
};
 
 
class DIELECTRIC_PRMS
{
public:
 DIELECTRIC_PRMS() :
 m_Thickness(0), m_ThicknessLocked( false ),
 m_EpsilonR( 1.0 ), m_LossTangent( 0.0 )
 {}
 
 bool operator==( const DIELECTRIC_PRMS& aOther ) const;
 bool operator!=( const DIELECTRIC_PRMS& aOther ) const { return !operator==( aOther ); }
 
private:
 friend class BOARD_STACKUP_ITEM;
 
 wxString m_Material; 
 int m_Thickness; 
 bool m_ThicknessLocked; 
 double m_EpsilonR; 
 double m_LossTangent; 
 wxString m_Color; 
};
 
 
class BOARD_STACKUP_ITEM
{
public:
 BOARD_STACKUP_ITEM( BOARD_STACKUP_ITEM_TYPE aType );
 BOARD_STACKUP_ITEM( const BOARD_STACKUP_ITEM& aOther );
 
 bool operator==( const BOARD_STACKUP_ITEM& aOther ) const;
 bool operator!=( const BOARD_STACKUP_ITEM& aOther ) const { return !operator==( aOther ); }
 
 void AddDielectricPrms( int aDielectricPrmsIdx );
 
 void RemoveDielectricPrms( int aDielectricPrmsIdx );
 
 bool HasEpsilonRValue() const;
 
 bool HasLossTangentValue() const;
 
 bool HasMaterialValue( int aDielectricSubLayer = 0 ) const;
 
 bool IsMaterialEditable() const;
 
 bool IsColorEditable() const;
 
 bool IsThicknessEditable() const;
 
 static int GetCopperDefaultThickness();
 
 static int GetMaskDefaultThickness();
 
 int GetSublayersCount() const { return m_DielectricPrmsList.size(); }
 
 wxString FormatEpsilonR( int aDielectricSubLayer = 0 ) const;
 
 wxString FormatLossTangent( int aDielectricSubLayer = 0 ) const;
 
 wxString FormatDielectricLayerName() const;
 
 // Getters:
 bool IsEnabled() const { return m_enabled; }
 
 BOARD_STACKUP_ITEM_TYPE GetType() const { return m_Type; }
 PCB_LAYER_ID GetBrdLayerId() const { return m_LayerId; }
 wxString GetLayerName() const { return m_LayerName; }
 wxString GetTypeName() const { return m_TypeName; }
 int GetDielectricLayerId() const { return m_DielectricLayerId; }
 
 wxString GetColor( int aDielectricSubLayer = 0 ) const;
 int GetThickness( int aDielectricSubLayer = 0 ) const;
 bool IsThicknessLocked( int aDielectricSubLayer = 0 ) const;
 double GetEpsilonR( int aDielectricSubLayer = 0 ) const;
 double GetLossTangent( int aDielectricSubLayer = 0 ) const;
 wxString GetMaterial( int aDielectricSubLayer = 0 ) const;
 
 // Setters:
 void SetEnabled( bool aEnable) { m_enabled = aEnable; }
 void SetBrdLayerId( PCB_LAYER_ID aBrdLayerId ) { m_LayerId = aBrdLayerId; }
 void SetLayerName( const wxString& aName ) { m_LayerName = aName; }
 void SetTypeName( const wxString& aName ) { m_TypeName = aName; }
 void SetDielectricLayerId( int aLayerId ) { m_DielectricLayerId = aLayerId; }
 
 void SetColor( const wxString& aColorName, int aDielectricSubLayer = 0 );
 void SetThickness( int aThickness, int aDielectricSubLayer = 0 );
 void SetThicknessLocked( bool aLocked, int aDielectricSubLayer = 0 );
 void SetEpsilonR( double aEpsilon, int aDielectricSubLayer = 0 );
 void SetLossTangent( double aTg, int aDielectricSubLayer = 0 );
 void SetMaterial( const wxString& aName, int aDielectricSubLayer = 0 );
 
private:
 BOARD_STACKUP_ITEM_TYPE m_Type;
 wxString m_LayerName; 
 wxString m_TypeName; 
 PCB_LAYER_ID m_LayerId; 
 int m_DielectricLayerId;
 std::vector<DIELECTRIC_PRMS> m_DielectricPrmsList;
 
 bool m_enabled; 
};
 
 
class BOARD_STACKUP : public SERIALIZABLE
{
public:
 BOARD_STACKUP();
 BOARD_STACKUP( const BOARD_STACKUP& aOther );
 BOARD_STACKUP& operator=( const BOARD_STACKUP& aOther );
 
 bool operator==( const BOARD_STACKUP& aOther ) const;
 bool operator!=( const BOARD_STACKUP& aOther ) const { return !operator==( aOther ); }
 
 ~BOARD_STACKUP() { RemoveAll(); }
 
 void Serialize( google::protobuf::Any &aContainer ) const override;
 
 bool Deserialize( const google::protobuf::Any &aContainer ) override;
 
 const std::vector<BOARD_STACKUP_ITEM*>& GetList() const { return m_list; }
 
 BOARD_STACKUP_ITEM* GetStackupLayer( int aIndex );
 
 static LSET StackupAllowedBrdLayers()
 {
 return LSET( 6, F_SilkS, F_Mask, F_Paste, B_SilkS, B_Mask, B_Paste )
 | LSET::ExternalCuMask() | LSET::InternalCuMask();
 }
 
 
 void RemoveAll();
 
 int GetCount() const { return (int) m_list.size(); }
 
 int BuildBoardThicknessFromStackup() const;
 
 void Add( BOARD_STACKUP_ITEM* aItem ) { m_list.push_back( aItem ); }
 
 bool SynchronizeWithBoard( BOARD_DESIGN_SETTINGS* aSettings );
 
 void BuildDefaultStackupList( const BOARD_DESIGN_SETTINGS* aSettings,
 int aActiveCopperLayersCount = 0 );
 
 void FormatBoardStackup( OUTPUTFORMATTER* aFormatter,
 const BOARD* aBoard, int aNestLevel ) const;
 
 int GetLayerDistance( PCB_LAYER_ID aFirstLayer, PCB_LAYER_ID aSecondLayer ) const;
 
 wxString m_FinishType;
 
 bool m_HasDielectricConstrains;
 
 bool m_HasThicknessConstrains;
 
 BS_EDGE_CONNECTOR_CONSTRAINTS m_EdgeConnectorConstraints;
 
 bool m_CastellatedPads; 
 bool m_EdgePlating; 
 
private:
 // The list of items describing the stackup for fabrication.
 // this is not just copper layers, but also mask dielectric layers
 std::vector<BOARD_STACKUP_ITEM*> m_list;
};
 
 
#endif // BOARD_STACKUP_H