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