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 <lset.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( { 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