/* * 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 * * 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 . */ #pragma once #include #include #include #include class SCH_MARKER; class SCHEMATIC; /// ERC error codes enum ERCE_T { ERCE_UNSPECIFIED = 0, ERCE_FIRST, ERCE_DUPLICATE_SHEET_NAME = ERCE_FIRST, ///< Duplicate sheet names within a given sheet. ERCE_ENDPOINT_OFF_GRID, ///< Pin or wire-end off grid. ERCE_PIN_NOT_CONNECTED, ///< Pin not connected and not no connect symbol. ERCE_PIN_NOT_DRIVEN, ///< Pin connected to some others pins but no pin to drive it. ///< pins to drive it can be output, passive, 3sttae, I/O ERCE_POWERPIN_NOT_DRIVEN, ///< Power input pin connected to some others pins but no ///< power out pin to drive it. ERCE_HIERACHICAL_LABEL, ///< Mismatch between hierarchical labels and pins sheets. ERCE_NOCONNECT_CONNECTED, ///< A no connect symbol is connected to more than 1 pin. ERCE_NOCONNECT_NOT_CONNECTED, ///< A no connect symbol is not connected to anything. ERCE_LABEL_NOT_CONNECTED, ///< Label not connected to any pins. ERCE_SIMILAR_LABELS, ///< 2 labels are equal for case insensitive comparisons. ERCE_SIMILAR_POWER, ///< 2 power pins are equal for case insensitive comparisons. ERCE_SIMILAR_LABEL_AND_POWER, ///< label and pin are equal for case insensitive comparisons. ERCE_SINGLE_GLOBAL_LABEL, ///< A label only exists once in the schematic. ERCE_SAME_LOCAL_GLOBAL_LABEL, ///< 2 labels are equal for case insensitive comparisons. ERCE_DIFFERENT_UNIT_FP, ///< Different units of the same symbol have different ///< footprints assigned. ERCE_MISSING_POWER_INPUT_PIN, ///< Symbol has power input pins that are not placed on the ///< schematic ERCE_MISSING_INPUT_PIN, ///< Symbol has input pins that are not placed ERCE_MISSING_BIDI_PIN, ///< Symbol has bi-directional pins that are not placed ERCE_MISSING_UNIT, ///< Symbol has units that are not placed on the schematic ERCE_DIFFERENT_UNIT_NET, ///< Shared pin in a multi-unit symbol is connected to ///< more than one net. ERCE_BUS_ALIAS_CONFLICT, ///< Conflicting bus alias definitions across sheets. ERCE_DRIVER_CONFLICT, ///< Conflicting drivers (labels, etc) on a subgraph. ERCE_BUS_ENTRY_CONFLICT, ///< A wire connected to a bus doesn't match the bus. ERCE_BUS_TO_BUS_CONFLICT, ///< A connection between bus objects doesn't share at least ///< one net. ERCE_BUS_TO_NET_CONFLICT, ///< A bus wire is graphically connected to a net port/pin ///< (or vice versa). ERCE_GROUND_PIN_NOT_GROUND, ///< A ground-labeled pin is not on a ground net while another pin is. ERCE_LABEL_SINGLE_PIN, ///< A label is connected only to a single pin ERCE_UNRESOLVED_VARIABLE, ///< A text variable could not be resolved. ERCE_UNDEFINED_NETCLASS, ///< A netclass was referenced but not defined. ERCE_SIMULATION_MODEL, ///< An error was found in the simulation model. ERCE_WIRE_DANGLING, ///< Some wires are not connected to anything else. ERCE_LIB_SYMBOL_ISSUES, ///< Symbol not found in active libraries. ERCE_LIB_SYMBOL_MISMATCH, ///< Symbol doesn't match copy in library. ERCE_FOOTPRINT_LINK_ISSUES, ///< The footprint link is invalid, or points to a missing ///< (or inactive) footprint or library. ERCE_FOOTPRINT_FILTERS, ///< The assigned footprint doesn't match the footprint filters ERCE_UNANNOTATED, ///< Symbol has not been annotated. ERCE_EXTRA_UNITS, ///< Symbol has more units than are defined. ERCE_DIFFERENT_UNIT_VALUE, ///< Units of same symbol have different values. ERCE_DUPLICATE_REFERENCE, ///< More than one symbol with the same reference. ERCE_BUS_ENTRY_NEEDED, ///< Importer failed to auto-place a bus entry. ERCE_FOUR_WAY_JUNCTION, ///< A four-way junction was found. ERCE_LABEL_MULTIPLE_WIRES, ///< A label is connected to more than one wire. ERCE_UNCONNECTED_WIRE_ENDPOINT, ///< A label is connected to more than one wire. ERCE_STACKED_PIN_SYNTAX, ///< Pin name resembles stacked pin notation. 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 }; /// The values a pin-to-pin entry in the pin matrix can take on enum class PIN_ERROR { OK, WARNING, PP_ERROR, UNCONNECTED }; /// The sorting metric used for erc resolution of multi-pin errors. enum class ERC_PIN_SORTING_METRIC { SM_HEURISTICS, SM_VIOLATION_COUNT }; /// Types of drive on a net (used for legacy ERC) #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 /** * Container for ERC settings * * Currently only stores flags about checks to run, but could later be expanded * to contain the matrix of electrical pin types. */ 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(); /** * Get the weight for an electrical pin type. * Used for sorting of pins in pin-to-pin erc resolution. * @param aPinType the pin type to check * @returns the weight for sorting */ int GetPinTypeWeight( ELECTRICAL_PINTYPE aPinType ) const { wxASSERT( static_cast( aPinType ) < ELECTRICAL_PINTYPES_TOTAL ); return m_PinTypeWeights.at( aPinType ); } /** * Get the type of sorting metric the ERC checker should * use to resolve multi-pin errors. */ 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( aFirstType )][static_cast( 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( aFirstType )][static_cast( aSecondType )] = aValue; } int GetPinMinDrive( ELECTRICAL_PINTYPE aFirstType, ELECTRICAL_PINTYPE aSecondType ) const { return m_PinMinDrive[static_cast( aFirstType )][static_cast( aSecondType )]; } public: std::map m_ERCSeverities; std::set m_ErcExclusions; // Serialized excluded ERC markers std::map 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]; /** * Weights for electrical pins used in ERC * to decide which pin gets the marker * in case of a multi-pin erc pin-to-pin error. */ std::map m_PinTypeWeights; /** * The type of sorting used by the ERC checker * to resolve multi-pin errors. */ ERC_PIN_SORTING_METRIC m_ERCSortingMetric; }; /** * An implementation of the RC_ITEM_LIST interface which uses the global SHEETLIST * to fulfill the contract. */ class SHEETLIST_ERC_ITEMS_PROVIDER : public RC_ITEMS_PROVIDER { private: SCHEMATIC* m_schematic; int m_severities; std::vector 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 GetItem( int aIndex ) const override; std::shared_ptr GetERCItem( int aIndex ) const; void DeleteItem( int aIndex, bool aDeep ) override; private: void visitMarkers( std::function aVisitor ) const; };