KiCad PCB EDA Suite
Loading...
Searching...
No Matches
erc_settings.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2024 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Jon Evans <[email protected]>
7 *
8 * This program is free software: you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <erc/erc_item.h>
23#include <erc/erc_settings.h>
24#include <schematic.h>
25#include <sch_marker.h>
26#include <sch_screen.h>
28#include <settings/parameters.h>
29
30
32
33
34
35#define OK PIN_ERROR::OK
36#define ERR PIN_ERROR::PP_ERROR
37#define WAR PIN_ERROR::WARNING
38
43{
44/* I, O, Bi, 3S, Pas, NIC, UnS, PwrI, PwrO, OC, OE, NC */
45/* I */ { OK, OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR },
46/* O */ { OK, ERR, OK, WAR, OK, OK, WAR, OK, ERR, ERR, ERR, ERR },
47/* Bi */ { OK, OK, OK, OK, OK, OK, WAR, OK, WAR, OK, WAR, ERR },
48/* 3S */ { OK, WAR, OK, OK, OK, OK, WAR, WAR, ERR, WAR, WAR, ERR },
49/*Pas */ { OK, OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR },
50/*NIC */ { OK, OK, OK, OK, OK, OK, OK, OK, OK, OK, OK, ERR },
51/*UnS */ { WAR, WAR, WAR, WAR, WAR, OK, WAR, WAR, WAR, WAR, WAR, ERR },
52/*PwrI*/ { OK, OK, OK, WAR, OK, OK, WAR, OK, OK, OK, OK, ERR },
53/*PwrO*/ { OK, ERR, WAR, ERR, OK, OK, WAR, OK, ERR, ERR, ERR, ERR },
54/* OC */ { OK, ERR, OK, WAR, OK, OK, WAR, OK, ERR, OK, OK, ERR },
55/* OE */ { OK, ERR, WAR, WAR, OK, OK, WAR, OK, ERR, OK, OK, ERR },
56/* NC */ { ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR }
57};
58
59
71{
72/* I, O, Bi, 3S, Pas, NIC, UnS, PwrI, PwrO, OC, OE, NC */
73/* I */ { NOD, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
74/* O */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, DRV, DRV, NPI },
75/* Bi */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
76/* 3S */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
77/*Pas */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
78/*NIC */ { NOD, NOD, NOD, NOD, NOD, NOD, NOD, NOD, NOD, NOD, NOD, NPI },
79/*UnS */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
80/*PwrI*/ { NOD, DRV, NOD, NOD, NOD, NOD, NOD, NOD, DRV, NOD, NOD, NPI },
81/*PwrO*/ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, DRV, DRV, NPI },
82/* OC */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
83/* OE */ { DRV, DRV, DRV, DRV, DRV, NOD, DRV, NOD, DRV, DRV, DRV, NPI },
84/* NC */ { NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI }
85};
86
87
88ERC_SETTINGS::ERC_SETTINGS( JSON_SETTINGS* aParent, const std::string& aPath ) :
89 NESTED_SETTINGS( "erc", ercSettingsSchemaVersion, aParent, aPath )
90{
92
93 for( int i = ERCE_FIRST; i <= ERCE_LAST; ++i )
95
96 // Error is the default setting so set non-error priorities here.
122
123 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "rule_severities",
124 [&]() -> nlohmann::json
125 {
126 nlohmann::json ret = {};
127
128 for( const RC_ITEM& item : ERC_ITEM::GetItemsWithSeverities() )
129 {
130 wxString name = item.GetSettingsKey();
131 int code = item.GetErrorCode();
132
133 if( name.IsEmpty() || m_ERCSeverities.count( code ) == 0 )
134 continue;
135
136 ret[std::string( name.ToUTF8() )] = SeverityToString( m_ERCSeverities[code] );
137 }
138
139 return ret;
140 },
141 [&]( const nlohmann::json& aJson )
142 {
143 if( !aJson.is_object() )
144 return;
145
146 for( const RC_ITEM& item : ERC_ITEM::GetItemsWithSeverities() )
147 {
148 int code = item.GetErrorCode();
149 wxString name = item.GetSettingsKey();
150
151 std::string key( name.ToUTF8() );
152
153 if( aJson.contains( key ) )
154 m_ERCSeverities[code] = SeverityFromString( aJson[key] );
155 }
156 },
157 {} ) );
158
159 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "erc_exclusions",
160 [&]() -> nlohmann::json
161 {
162 nlohmann::json js = nlohmann::json::array();
163
164 for( const wxString& entry : m_ErcExclusions )
165 js.push_back( { entry, m_ErcExclusionComments[ entry ] } );
166
167 return js;
168 },
169 [&]( const nlohmann::json& aObj )
170 {
171 m_ErcExclusions.clear();
172
173 if( !aObj.is_array() )
174 return;
175
176 for( const nlohmann::json& entry : aObj )
177 {
178 if( entry.is_array() )
179 {
180 wxString serialized = entry[0].get<wxString>();
181 m_ErcExclusions.insert( serialized );
182 m_ErcExclusionComments[ serialized ] = entry[1].get<wxString>();
183 }
184 else if( entry.is_string() )
185 {
186 m_ErcExclusions.insert( entry.get<wxString>() );
187 }
188 }
189 },
190 {} ) );
191
192 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "pin_map",
193 [&]() -> nlohmann::json
194 {
195 nlohmann::json ret = nlohmann::json::array();
196
197 for( int i = 0; i < ELECTRICAL_PINTYPES_TOTAL; i++ )
198 {
199 nlohmann::json inner = nlohmann::json::array();
200
201 for( int j = 0; j < ELECTRICAL_PINTYPES_TOTAL; j++ )
202 inner.push_back( static_cast<int>( GetPinMapValue( i, j ) ) );
203
204 ret.push_back( inner );
205 }
206
207 return ret;
208 },
209 [&]( const nlohmann::json& aJson )
210 {
211 if( !aJson.is_array() || aJson.size() != ELECTRICAL_PINTYPES_TOTAL )
212 return;
213
214 for( size_t i = 0; i < ELECTRICAL_PINTYPES_TOTAL; i++ )
215 {
216 if( i > aJson.size() - 1 )
217 break;
218
219 nlohmann::json inner = aJson[i];
220
221 if( !inner.is_array() || inner.size() != ELECTRICAL_PINTYPES_TOTAL )
222 return;
223
224 for( size_t j = 0; j < ELECTRICAL_PINTYPES_TOTAL; j++ )
225 {
226 if( inner[j].is_number_integer() )
227 {
228 int val = inner[j].get<int>();
229
230 if( val >= 0 && val <= static_cast<int>( PIN_ERROR::UNCONNECTED ) )
231 SetPinMapValue( i, j, static_cast<PIN_ERROR>( val ) );
232 }
233 }
234 }
235 },
236 {} ) );
237
238 // Pin weights used for sorting. Take care, sorting is descending!
239 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_NIC, 11 );
240 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_UNSPECIFIED, 10 );
241 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_PASSIVE, 9 );
242 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR, 8 );
243 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OPENEMITTER, 7 );
244 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_INPUT, 6 );
245 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_TRISTATE, 5 );
246 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_BIDI, 4 );
247 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_OUTPUT, 3 );
248 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_POWER_IN, 2 );
249 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_POWER_OUT, 1 );
250 m_PinTypeWeights.emplace( ELECTRICAL_PINTYPE::PT_NC, 0 );
251
252 m_ERCSortingMetric = ERC_PIN_SORTING_METRIC::SM_HEURISTICS;
253}
254
255
257{
258 if( m_parent )
259 {
261 m_parent = nullptr;
262 }
263}
264
265
266SEVERITY ERC_SETTINGS::GetSeverity( int aErrorCode ) const
267{
268 // Special-case duplicate pin error. Unique pin names are required by KiCad, so this
269 // is always an error.
270 if( aErrorCode == ERCE_DUPLICATE_PIN_ERROR )
271 {
272 return RPT_SEVERITY_ERROR;
273 }
274 // Special-case pin-to-pin errors:
275 // Ignore-or-not is controlled by ERCE_PIN_TO_PIN_WARNING (for both)
276 // Warning-or-error is controlled by which errorCode it is
277 else if( aErrorCode == ERCE_PIN_TO_PIN_ERROR )
278 {
279 wxASSERT( m_ERCSeverities.count( ERCE_PIN_TO_PIN_WARNING ) );
280
282 return RPT_SEVERITY_IGNORE;
283 else
284 return RPT_SEVERITY_ERROR;
285 }
286 else if( aErrorCode == ERCE_PIN_TO_PIN_WARNING )
287 {
288 wxASSERT( m_ERCSeverities.count( ERCE_PIN_TO_PIN_WARNING ) );
289
291 return RPT_SEVERITY_IGNORE;
292 else
294 }
295 else if( aErrorCode == ERCE_GENERIC_WARNING )
296 {
298 }
299 else if( aErrorCode == ERCE_GENERIC_ERROR )
300 {
301 return RPT_SEVERITY_ERROR;
302 }
303
304 wxCHECK_MSG( m_ERCSeverities.count( aErrorCode ), RPT_SEVERITY_IGNORE,
305 wxS( "Missing severity from map in ERC_SETTINGS!" ) );
306
307 return m_ERCSeverities.at( aErrorCode );
308}
309
310
311void ERC_SETTINGS::SetSeverity( int aErrorCode, SEVERITY aSeverity )
312{
313 m_ERCSeverities[ aErrorCode ] = aSeverity;
314}
315
316
318{
319 memcpy( m_PinMap, m_defaultPinMap, sizeof( m_PinMap ) );
320}
321
322
324{
325 bool operator()( const SCH_MARKER* item1, const SCH_MARKER* item2 ) const
326 {
327 wxCHECK( item1 && item2, false );
328
329 if( item1->GetPosition() == item2->GetPosition() )
330 return item1->SerializeToString() < item2->SerializeToString();
331
332 return item1->GetPosition() < item2->GetPosition();
333 }
334};
335
336
337void SHEETLIST_ERC_ITEMS_PROVIDER::visitMarkers( std::function<void( SCH_MARKER* )> aVisitor ) const
338{
339 std::set<SCH_SCREEN*> seenScreens;
340
341 for( const SCH_SHEET_PATH& sheet : m_schematic->BuildUnorderedSheetList() )
342 {
343 bool firstTime = seenScreens.count( sheet.LastScreen() ) == 0;
344
345 if( firstTime )
346 seenScreens.insert( sheet.LastScreen() );
347
348 std::set<SCH_MARKER*, CompareMarkers> orderedMarkers;
349
350 for( SCH_ITEM* item : sheet.LastScreen()->Items().OfType( SCH_MARKER_T ) )
351 orderedMarkers.insert( static_cast<SCH_MARKER*>( item ) );
352
353 for( SCH_ITEM* item : orderedMarkers )
354 {
355 SCH_MARKER* marker = static_cast<SCH_MARKER*>( item );
356
357 if( marker->GetMarkerType() != MARKER_BASE::MARKER_ERC )
358 continue;
359
360 std::shared_ptr<const ERC_ITEM> ercItem =
361 std::static_pointer_cast<const ERC_ITEM>( marker->GetRCItem() );
362
363 // Only show sheet-specific markers on the owning sheet
364 if( ercItem->IsSheetSpecific() )
365 {
366 if( ercItem->GetSpecificSheetPath() != sheet )
367 continue;
368 }
369
370 // Don't show non-specific markers more than once
371 if( !firstTime && !ercItem->IsSheetSpecific() )
372 continue;
373
374 aVisitor( marker );
375 }
376 }
377}
378
379
381{
382 m_severities = aSeverities;
383
384 m_filteredMarkers.clear();
385
386 ERC_SETTINGS& settings = m_schematic->ErcSettings();
387
389 [&]( SCH_MARKER* aMarker )
390 {
391 SEVERITY markerSeverity;
392
393 if( aMarker->IsExcluded() )
394 markerSeverity = RPT_SEVERITY_EXCLUSION;
395 else
396 markerSeverity = settings.GetSeverity( aMarker->GetRCItem()->GetErrorCode() );
397
398 if( markerSeverity & m_severities )
399 m_filteredMarkers.push_back( aMarker );
400 } );
401}
402
403
405{
406 if( aSeverity < 0 )
407 return m_filteredMarkers.size();
408
409 int count = 0;
410
411 const ERC_SETTINGS& settings = m_schematic->ErcSettings();
412
414 [&]( SCH_MARKER* aMarker )
415 {
416 SEVERITY markerSeverity;
417
418 if( aMarker->IsExcluded() )
419 markerSeverity = RPT_SEVERITY_EXCLUSION;
420 else
421 markerSeverity = settings.GetSeverity( aMarker->GetRCItem()->GetErrorCode() );
422
423 if( ( markerSeverity & aSeverity ) > 0 )
424 count++;
425 } );
426
427 return count;
428}
429
430
431std::shared_ptr<ERC_ITEM> SHEETLIST_ERC_ITEMS_PROVIDER::GetERCItem( int aIndex ) const
432{
433 SCH_MARKER* marker = m_filteredMarkers[ aIndex ];
434
435 return marker ? std::static_pointer_cast<ERC_ITEM>( marker->GetRCItem() ) : nullptr;
436}
437
438
439std::shared_ptr<RC_ITEM> SHEETLIST_ERC_ITEMS_PROVIDER::GetItem( int aIndex ) const
440{
441 return GetERCItem( aIndex );
442}
443
444
445void SHEETLIST_ERC_ITEMS_PROVIDER::DeleteItem( int aIndex, bool aDeep )
446{
447 SCH_MARKER* marker = m_filteredMarkers[ aIndex ];
448 m_filteredMarkers.erase( m_filteredMarkers.begin() + aIndex );
449
450 if( aDeep )
451 {
452 SCH_SCREENS screens( m_schematic->Root() );
453 screens.DeleteMarker( marker );
454 }
455}
456
457
const char * name
Definition: DXF_plotter.cpp:62
static std::vector< std::reference_wrapper< RC_ITEM > > GetItemsWithSeverities()
Definition: erc_item.h:76
Container for ERC settings.
Definition: erc_settings.h:132
ERC_PIN_SORTING_METRIC m_ERCSortingMetric
The type of sorting used by the ERC checker to resolve multi-pin errors.
Definition: erc_settings.h:232
std::map< wxString, wxString > m_ErcExclusionComments
Definition: erc_settings.h:211
std::map< ELECTRICAL_PINTYPE, int > m_PinTypeWeights
Weights for electrical pins used in ERC to decide which pin gets the marker in case of a multi-pin er...
Definition: erc_settings.h:226
static PIN_ERROR m_defaultPinMap[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL]
Default Look up table which gives the ERC error level for a pair of connected pins.
Definition: erc_settings.h:219
SEVERITY GetSeverity(int aErrorCode) const
ERC_SETTINGS(JSON_SETTINGS *aParent, const std::string &aPath)
void ResetPinMap()
void SetSeverity(int aErrorCode, SEVERITY aSeverity)
virtual ~ERC_SETTINGS()
PIN_ERROR GetPinMapValue(int aFirstType, int aSecondType) const
Definition: erc_settings.h:177
std::map< int, SEVERITY > m_ERCSeverities
Definition: erc_settings.h:209
std::set< wxString > m_ErcExclusions
Definition: erc_settings.h:210
static int m_PinMinDrive[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL]
Look up table which gives the minimal drive for a pair of connected pins on a net.
Definition: erc_settings.h:215
void SetPinMapValue(int aFirstType, int aSecondType, PIN_ERROR aValue)
Definition: erc_settings.h:189
PIN_ERROR m_PinMap[ELECTRICAL_PINTYPES_TOTAL][ELECTRICAL_PINTYPES_TOTAL]
Definition: erc_settings.h:213
std::vector< PARAM_BASE * > m_params
The list of parameters (owned by this object)
void ReleaseNestedSettings(NESTED_SETTINGS *aSettings)
Saves and frees a nested settings object, if it exists within this one.
bool IsExcluded() const
Definition: marker_base.h:93
std::shared_ptr< RC_ITEM > GetRCItem() const
Definition: marker_base.h:107
enum MARKER_T GetMarkerType() const
Definition: marker_base.h:91
NESTED_SETTINGS is a JSON_SETTINGS that lives inside a JSON_SETTINGS.
JSON_SETTINGS * m_parent
A pointer to the parent object to load and store from.
Like a normal param, but with custom getter and setter functions.
Definition: parameters.h:295
A holder for a rule check item, DRC in Pcbnew or ERC in Eeschema.
Definition: rc_item.h:79
SCH_SHEET_LIST BuildUnorderedSheetList() const
Definition: schematic.h:117
SCH_SHEET & Root() const
Definition: schematic.h:140
ERC_SETTINGS & ErcSettings() const
Definition: schematic.cpp:363
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:168
wxString SerializeToString() const
Definition: sch_marker.cpp:90
VECTOR2I GetPosition() const override
Definition: sch_marker.h:102
Container class that holds multiple SCH_SCREEN objects in a hierarchy.
Definition: sch_screen.h:758
void DeleteMarker(SCH_MARKER *aMarker)
Delete a specific marker.
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
int GetCount(int aSeverity=-1) const override
void SetSeverities(int aSeverities) override
void visitMarkers(std::function< void(SCH_MARKER *)> aVisitor) const
void DeleteItem(int aIndex, bool aDeep) override
Remove (and optionally deletes) the indexed item from the list.
std::shared_ptr< ERC_ITEM > GetERCItem(int aIndex) const
std::vector< SCH_MARKER * > m_filteredMarkers
Definition: erc_settings.h:245
std::shared_ptr< RC_ITEM > GetItem(int aIndex) const override
Retrieve a RC_ITEM by index.
const int ercSettingsSchemaVersion
#define ERR
#define WAR
#define OK
#define DRV
Definition: erc_settings.h:120
@ ERCE_UNSPECIFIED
Definition: erc_settings.h:37
@ ERCE_DRIVER_CONFLICT
Conflicting drivers (labels, etc) on a subgraph.
Definition: erc_settings.h:65
@ ERCE_SIMILAR_POWER
2 power pins are equal for case insensitive comparisons.
Definition: erc_settings.h:51
@ ERCE_UNCONNECTED_WIRE_ENDPOINT
A label is connected to more than one wire.
Definition: erc_settings.h:89
@ ERCE_GROUND_PIN_NOT_GROUND
A ground-labeled pin is not on a ground net while another pin is.
Definition: erc_settings.h:71
@ ERCE_SIMILAR_LABELS
2 labels are equal for case insensitive comparisons.
Definition: erc_settings.h:50
@ ERCE_FIRST
Definition: erc_settings.h:38
@ ERCE_ENDPOINT_OFF_GRID
Pin or wire-end off grid.
Definition: erc_settings.h:40
@ ERCE_SAME_LOCAL_GLOBAL_LABEL
2 labels are equal for case insensitive comparisons.
Definition: erc_settings.h:54
@ ERCE_LAST
Definition: erc_settings.h:91
@ ERCE_SIMILAR_LABEL_AND_POWER
label and pin are equal for case insensitive comparisons.
Definition: erc_settings.h:52
@ ERCE_LABEL_SINGLE_PIN
A label is connected only to a single pin.
Definition: erc_settings.h:72
@ ERCE_BUS_ENTRY_CONFLICT
A wire connected to a bus doesn't match the bus.
Definition: erc_settings.h:66
@ ERCE_FOOTPRINT_LINK_ISSUES
The footprint link is invalid, or points to a missing (or inactive) footprint or library.
Definition: erc_settings.h:79
@ ERCE_DUPLICATE_PIN_ERROR
Definition: erc_settings.h:93
@ ERCE_NOCONNECT_NOT_CONNECTED
A no connect symbol is not connected to anything.
Definition: erc_settings.h:48
@ ERCE_FOUR_WAY_JUNCTION
A four-way junction was found.
Definition: erc_settings.h:87
@ ERCE_SIMULATION_MODEL
An error was found in the simulation model.
Definition: erc_settings.h:75
@ ERCE_LIB_SYMBOL_MISMATCH
Symbol doesn't match copy in library.
Definition: erc_settings.h:78
@ ERCE_GENERIC_ERROR
Definition: erc_settings.h:99
@ ERCE_NOCONNECT_CONNECTED
A no connect symbol is connected to more than 1 pin.
Definition: erc_settings.h:47
@ ERCE_PIN_TO_PIN_WARNING
Definition: erc_settings.h:94
@ ERCE_MISSING_INPUT_PIN
Symbol has input pins that are not placed.
Definition: erc_settings.h:59
@ ERCE_MISSING_UNIT
Symbol has units that are not placed on the schematic.
Definition: erc_settings.h:61
@ ERCE_MISSING_BIDI_PIN
Symbol has bi-directional pins that are not placed.
Definition: erc_settings.h:60
@ ERCE_LIB_SYMBOL_ISSUES
Symbol not found in active libraries.
Definition: erc_settings.h:77
@ ERCE_FOOTPRINT_FILTERS
The assigned footprint doesn't match the footprint filters.
Definition: erc_settings.h:81
@ ERCE_GENERIC_WARNING
Definition: erc_settings.h:98
@ ERCE_SINGLE_GLOBAL_LABEL
A label only exists once in the schematic.
Definition: erc_settings.h:53
@ ERCE_LABEL_MULTIPLE_WIRES
A label is connected to more than one wire.
Definition: erc_settings.h:88
@ ERCE_PIN_TO_PIN_ERROR
Definition: erc_settings.h:95
PIN_ERROR
The values a pin-to-pin entry in the pin matrix can take on.
Definition: erc_settings.h:104
#define NOD
Definition: erc_settings.h:122
#define NPI
Types of drive on a net (used for legacy ERC)
Definition: erc_settings.h:119
#define ELECTRICAL_PINTYPES_TOTAL
Definition: pin_type.h:56
SEVERITY
@ RPT_SEVERITY_WARNING
@ RPT_SEVERITY_ERROR
@ RPT_SEVERITY_UNDEFINED
@ RPT_SEVERITY_EXCLUSION
@ RPT_SEVERITY_IGNORE
bool operator()(const SCH_MARKER *item1, const SCH_MARKER *item2) const
@ SCH_MARKER_T
Definition: typeinfo.h:159
wxString SeverityToString(const SEVERITY &aSeverity)
Definition: ui_common.cpp:67