erc_settings.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018-2020 CERN
 * 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 2
 * 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/>.
 */
 
#pragma once
 
#include <erc/erc_item.h>
#include <pin_type.h>
#include <settings/nested_settings.h>
#include <widgets/ui_common.h>
 
 
class SCH_MARKER;
class SCHEMATIC;
 

enum ERCE_T
{
    ERCE_UNSPECIFIED = 0,
    ERCE_FIRST,
    ERCE_DUPLICATE_SHEET_NAME = ERCE_FIRST,  
    ERCE_ENDPOINT_OFF_GRID,       
    ERCE_PIN_NOT_CONNECTED,       
    ERCE_PIN_NOT_DRIVEN,          
                                  ///<   pins to drive it can be output, passive, 3sttae, I/O
    ERCE_POWERPIN_NOT_DRIVEN,     
    ERCE_HIERACHICAL_LABEL,       
    ERCE_NOCONNECT_CONNECTED,     
    ERCE_NOCONNECT_NOT_CONNECTED, 
    ERCE_LABEL_NOT_CONNECTED,     
    ERCE_SIMILAR_LABELS,          
    ERCE_SIMILAR_POWER,           
    ERCE_SIMILAR_LABEL_AND_POWER, 
    ERCE_SINGLE_GLOBAL_LABEL,            
    ERCE_SAME_LOCAL_GLOBAL_LABEL, 
    ERCE_DIFFERENT_UNIT_FP,       
    ERCE_MISSING_POWER_INPUT_PIN, 
    ERCE_MISSING_INPUT_PIN,       
    ERCE_MISSING_BIDI_PIN,        
    ERCE_MISSING_UNIT,            
    ERCE_DIFFERENT_UNIT_NET,      
    ERCE_BUS_ALIAS_CONFLICT,      
    ERCE_DRIVER_CONFLICT,         
    ERCE_BUS_ENTRY_CONFLICT,      
    ERCE_BUS_TO_BUS_CONFLICT,     
    ERCE_BUS_TO_NET_CONFLICT,     
    ERCE_GROUND_PIN_NOT_GROUND,   
    ERCE_LABEL_SINGLE_PIN,        
    ERCE_UNRESOLVED_VARIABLE,     
    ERCE_UNDEFINED_NETCLASS,      
    ERCE_SIMULATION_MODEL,        
    ERCE_WIRE_DANGLING,           
    ERCE_LIB_SYMBOL_ISSUES,       
    ERCE_LIB_SYMBOL_MISMATCH,     
    ERCE_FOOTPRINT_LINK_ISSUES,   
    ERCE_FOOTPRINT_FILTERS,       
    ERCE_UNANNOTATED,             
    ERCE_EXTRA_UNITS,             
    ERCE_DIFFERENT_UNIT_VALUE,    
    ERCE_DUPLICATE_REFERENCE,     
    ERCE_BUS_ENTRY_NEEDED,        
    ERCE_FOUR_WAY_JUNCTION,       
    ERCE_LABEL_MULTIPLE_WIRES,    
    ERCE_UNCONNECTED_WIRE_ENDPOINT, 
    ERCE_STACKED_PIN_SYNTAX,      
 
    ERCE_LAST = ERCE_STACKED_PIN_SYNTAX,
 
    ERCE_DUPLICATE_PIN_ERROR,
    ERCE_PIN_TO_PIN_WARNING,    // pin connected to an other pin: warning level
    ERCE_PIN_TO_PIN_ERROR,      // pin connected to an other pin: error level
    ERCE_ANNOTATION_ACTION,     // Not actually an error; just an action performed during
                                // annotation which is passed back through the error handler.
    ERCE_GENERIC_WARNING,
    ERCE_GENERIC_ERROR
};

enum class PIN_ERROR
{
    OK,
    WARNING,
    PP_ERROR,
    UNCONNECTED
};

enum class ERC_PIN_SORTING_METRIC
{
    SM_HEURISTICS,
    SM_VIOLATION_COUNT
};

#define NPI    4  // Net with Pin isolated, this pin has type Not Connected and must be left N.C.
#define DRV    3  // Net driven by a signal (a pin output for instance)
#define NET_NC 2  // Net "connected" to a "NoConnect symbol"
#define NOD    1  // Net not driven ( Such as 2 or more connected inputs )
#define NOC    0  // initial state of a net: no connection

class ERC_SETTINGS : public NESTED_SETTINGS
{
public:
    ERC_SETTINGS( JSON_SETTINGS* aParent, const std::string& aPath );
 
    virtual ~ERC_SETTINGS();
 
    bool operator==( const ERC_SETTINGS& other ) const
    {
        return ( other.m_ERCSeverities == m_ERCSeverities );
    }
 
    bool operator!=( const ERC_SETTINGS& other ) const
    {
        return !( other == *this );
    }
 
    bool IsTestEnabled( int aErrorCode ) const
    {
        return GetSeverity( aErrorCode ) != RPT_SEVERITY_IGNORE;
    }
 
    SEVERITY GetSeverity( int aErrorCode ) const;
 
    void SetSeverity( int aErrorCode, SEVERITY aSeverity );
 
    void ResetPinMap();

    int GetPinTypeWeight( ELECTRICAL_PINTYPE aPinType ) const
    {
        wxASSERT( static_cast<int>( aPinType ) < ELECTRICAL_PINTYPES_TOTAL );
        return m_PinTypeWeights.at( aPinType );
    }

    ERC_PIN_SORTING_METRIC GetERCSortingMetric() const { return m_ERCSortingMetric; }
 
    PIN_ERROR GetPinMapValue( int aFirstType, int aSecondType ) const
    {
        wxASSERT( aFirstType < ELECTRICAL_PINTYPES_TOTAL
                  && aSecondType < ELECTRICAL_PINTYPES_TOTAL );
        return m_PinMap[aFirstType][aSecondType];
    }
 
    PIN_ERROR GetPinMapValue( ELECTRICAL_PINTYPE aFirstType, ELECTRICAL_PINTYPE aSecondType ) const
    {
        return m_PinMap[static_cast<int>( aFirstType )][static_cast<int>( aSecondType )];
    }
 
    void SetPinMapValue( int aFirstType, int aSecondType, PIN_ERROR aValue )
    {
        wxASSERT( aFirstType < ELECTRICAL_PINTYPES_TOTAL
                  && aSecondType < ELECTRICAL_PINTYPES_TOTAL );
        m_PinMap[aFirstType][aSecondType] = aValue;
    }
 
    void SetPinMapValue( ELECTRICAL_PINTYPE aFirstType, ELECTRICAL_PINTYPE aSecondType,
                         PIN_ERROR aValue )
    {
        m_PinMap[static_cast<int>( aFirstType )][static_cast<int>( aSecondType )] = aValue;
    }
 
    int GetPinMinDrive( ELECTRICAL_PINTYPE aFirstType, ELECTRICAL_PINTYPE aSecondType ) const
    {
        return m_PinMinDrive[static_cast<int>( aFirstType )][static_cast<int>( aSecondType )];
    }
 
public:
 
    std::map<int, SEVERITY>      m_ERCSeverities;
    std::set<wxString>           m_ErcExclusions;           // Serialized excluded ERC markers
    std::map<wxString, wxString> m_ErcExclusionComments;    // Map from serialization to comment
 
    PIN_ERROR m_PinMap[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL];
 
    static int m_PinMinDrive[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL];
 
private:
 
    static PIN_ERROR m_defaultPinMap[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL];

    std::map<ELECTRICAL_PINTYPE, int> m_PinTypeWeights;

    ERC_PIN_SORTING_METRIC m_ERCSortingMetric;
};
 

class SHEETLIST_ERC_ITEMS_PROVIDER : public RC_ITEMS_PROVIDER
{
private:
    SCHEMATIC*               m_schematic;
    int                      m_severities;
    std::vector<SCH_MARKER*> m_filteredMarkers;
 
public:
    SHEETLIST_ERC_ITEMS_PROVIDER( SCHEMATIC* aSchematic ) :
            m_schematic( aSchematic ),
            m_severities( 0 )
    { }
 
    // We own at least one list of raw pointers.  Don't let the compiler fill in copy c'tors that
    // will only land us in trouble.
    SHEETLIST_ERC_ITEMS_PROVIDER( const SHEETLIST_ERC_ITEMS_PROVIDER& ) = delete;
    SHEETLIST_ERC_ITEMS_PROVIDER& operator=( const SHEETLIST_ERC_ITEMS_PROVIDER& ) = delete;
 
    void SetSeverities( int aSeverities ) override;
 
    int GetCount( int aSeverity = -1 ) const override;
 
    std::shared_ptr<RC_ITEM> GetItem( int aIndex ) const override;
 
    std::shared_ptr<ERC_ITEM> GetERCItem( int aIndex ) const;
 
    void DeleteItem( int aIndex, bool aDeep ) override;
 
private:
 
    void visitMarkers( std::function<void( SCH_MARKER* )> aVisitor ) const;
};