tuning_profiles.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Jon Evans <[email protected]>
 *
 * 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 KICAD_TUNING_PROFILES_H
#define KICAD_TUNING_PROFILES_H
 
#include <settings/nested_settings.h>
#include <layer_ids.h>

struct DELAY_PROFILE_VIA_OVERRIDE_ENTRY
{
    PCB_LAYER_ID m_SignalLayerFrom;
    PCB_LAYER_ID m_SignalLayerTo;
    PCB_LAYER_ID m_ViaLayerFrom;
    PCB_LAYER_ID m_ViaLayerTo;
    int          m_Delay;
 
    bool operator<( const DELAY_PROFILE_VIA_OVERRIDE_ENTRY& other ) const
    {
        if( m_SignalLayerFrom != other.m_SignalLayerFrom )
            return IsCopperLayerLowerThan( m_SignalLayerFrom, other.m_SignalLayerFrom );
 
        if( m_SignalLayerTo != other.m_SignalLayerTo )
            return IsCopperLayerLowerThan( m_SignalLayerTo, other.m_SignalLayerTo );
 
        if( m_ViaLayerFrom != other.m_ViaLayerFrom )
            return IsCopperLayerLowerThan( m_ViaLayerFrom, other.m_ViaLayerFrom );
 
        if( m_ViaLayerTo != other.m_ViaLayerTo )
            return IsCopperLayerLowerThan( m_ViaLayerTo, other.m_ViaLayerTo );
 
        return m_Delay < other.m_Delay;
    }
 
    bool operator==( const DELAY_PROFILE_VIA_OVERRIDE_ENTRY& other ) const
    {
        if( m_SignalLayerFrom != other.m_SignalLayerFrom )
            return false;
 
        if( m_SignalLayerTo != other.m_SignalLayerTo )
            return false;
 
        if( m_ViaLayerFrom != other.m_ViaLayerFrom )
            return false;
 
        if( m_ViaLayerTo != other.m_ViaLayerTo )
            return false;
 
        if( m_Delay != other.m_Delay )
            return false;
 
        return true;
    }
};
 
class TUNING_PROFILES;

class DELAY_PROFILE_TRACK_PROPAGATION_ENTRY
{
public:
    friend class TUNING_PROFILES;
 
    void SetSignalLayer( const PCB_LAYER_ID aLayer ) { m_signalLayer = aLayer; }
    void SetTopReferenceLayer( const PCB_LAYER_ID aLayer ) { m_topReferenceLayer = aLayer; }
    void SetBottomReferenceLayer( const PCB_LAYER_ID aLayer ) { m_bottomReferenceLayer = aLayer; }
 
    void SetWidth( const int aWidth ) { m_width = aWidth; }
    void SetDiffPairGap( const int aDiffPairGap ) { m_diffPairGap = aDiffPairGap; }
    void SetDelay( const int aDelay ) { m_delay = aDelay; }
    void SetEnableTimeDomainTuning( bool aEnable ) { m_enableTimeDomainTuning = aEnable; }
 
    PCB_LAYER_ID GetSignalLayer() const { return m_signalLayer; }
    PCB_LAYER_ID GetTopReferenceLayer() const { return m_topReferenceLayer; }
    PCB_LAYER_ID GetBottomReferenceLayer() const { return m_bottomReferenceLayer; }
 
    int GetWidth() const { return m_width; }
    int GetDiffPairGap() const { return m_diffPairGap; }
    int GetDelay( const bool aForce = false ) const { return ( m_enableTimeDomainTuning || aForce ) ? m_delay : 0; }
 
    bool operator==( const DELAY_PROFILE_TRACK_PROPAGATION_ENTRY& other ) const
    {
        if( m_signalLayer != other.m_signalLayer )
            return false;
 
        if( m_topReferenceLayer != other.m_topReferenceLayer )
            return false;
 
        if( m_bottomReferenceLayer != other.m_bottomReferenceLayer )
            return false;
 
        if( m_width != other.m_width )
            return false;
 
        if( m_diffPairGap != other.m_diffPairGap )
            return false;
 
        if( m_delay != other.m_delay )
            return false;
 
        if( m_enableTimeDomainTuning != other.m_enableTimeDomainTuning )
            return false;
 
        return true;
    }
 
private:
    PCB_LAYER_ID m_signalLayer{ UNDEFINED_LAYER };
    PCB_LAYER_ID m_topReferenceLayer{ UNDEFINED_LAYER };
    PCB_LAYER_ID m_bottomReferenceLayer{ UNDEFINED_LAYER };
 
    int m_width{ 0 };
    int m_diffPairGap{ 0 };
    int m_delay{ 0 };
 
    bool m_enableTimeDomainTuning{ false };
};
 

struct TUNING_PROFILE
{
    enum class PROFILE_TYPE
    {
        SINGLE,
        DIFFERENTIAL
    };
 
    wxString                                           m_ProfileName;
    PROFILE_TYPE                                       m_Type;
    double                                             m_TargetImpedance;
    bool                                               m_GenerateNetClassDRCRules;
    bool                                               m_EnableTimeDomainTuning;
    std::vector<DELAY_PROFILE_TRACK_PROPAGATION_ENTRY> m_TrackPropagationEntries;
    int                                                m_ViaPropagationDelay;
    std::vector<DELAY_PROFILE_VIA_OVERRIDE_ENTRY>      m_ViaOverrides;
 
    // This is not persisted - but is used for quick lookup for track statistics calculations
    std::map<PCB_LAYER_ID, DELAY_PROFILE_TRACK_PROPAGATION_ENTRY> m_TrackPropagationEntriesMap;
 
    bool operator==( const TUNING_PROFILE& aOther ) const
    {
        if( m_ProfileName != aOther.m_ProfileName )
            return false;
 
        if( m_Type != aOther.m_Type )
            return false;
 
        if( m_TargetImpedance != aOther.m_TargetImpedance )
            return false;
 
        if( m_GenerateNetClassDRCRules != aOther.m_GenerateNetClassDRCRules )
            return false;
 
        if( m_EnableTimeDomainTuning != aOther.m_EnableTimeDomainTuning )
            return false;
 
        if( m_TrackPropagationEntries != aOther.m_TrackPropagationEntries )
            return false;
 
        if( m_ViaPropagationDelay != aOther.m_ViaPropagationDelay )
            return false;
 
        if( m_ViaOverrides != aOther.m_ViaOverrides )
            return false;
 
        return true;
    }
};
 

class KICOMMON_API TUNING_PROFILES final : public NESTED_SETTINGS
{
public:
    TUNING_PROFILES( JSON_SETTINGS* aParent, const std::string& aPath );
 
    virtual ~TUNING_PROFILES();
 
    bool operator==( const TUNING_PROFILES& aOther ) const;
 
    bool operator!=( const TUNING_PROFILES& aOther ) const { return !operator==( aOther ); }
 
    void ClearTuningProfiles() { m_tuningProfiles.clear(); }
 
    void AddTuningProfile( TUNING_PROFILE&& aTraceEntry ) { m_tuningProfiles.emplace_back( std::move( aTraceEntry ) ); }
 
    const std::vector<TUNING_PROFILE>& GetTuningProfiles() const { return m_tuningProfiles; }
 
    TUNING_PROFILE& GetTuningProfile( wxString aProfileName );
 
private:
    std::vector<TUNING_PROFILE> m_tuningProfiles;
 
    TUNING_PROFILE m_nullDelayProfile;
};
 
#endif // KICAD_TUNING_PROFILES_H