KiCad PCB EDA Suite
erc.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) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2011-2016 Wayne Stambaugh <stambaughw@verizon.net>
6  * Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, you may find one here:
20  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21  * or you may search the http://www.gnu.org website for the version 2 license,
22  * or you may write to the Free Software Foundation, Inc.,
23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25 
31 #include <fctsys.h>
32 #include <class_drawpanel.h>
33 #include <kicad_string.h>
34 #include <sch_edit_frame.h>
35 
36 #include <netlist.h>
37 #include <netlist_object.h>
38 #include <lib_pin.h>
39 #include <erc.h>
40 #include <sch_marker.h>
41 #include <sch_sheet.h>
42 #include <sch_reference_list.h>
43 
44 #include <wx/ffile.h>
45 
46 
47 /* ERC tests :
48  * 1 - conflicts between connected pins ( example: 2 connected outputs )
49  * 2 - minimal connections requirements ( 1 input *must* be connected to an
50  * output, or a passive pin )
51  */
52 
53 
54 /*
55  * Electrical type of pins:
56  * PIN_INPUT = usual pin input: must be connected
57  * PIN_OUTPUT = usual output
58  * PIN_BIDI = input or output (like port for a microprocessor)
59  * PIN_TRISTATE = tris state bus pin
60  * PIN_PASSIVE = pin for passive components: must be connected, and can be
61  * connected to any pin
62  * PIN_UNSPECIFIED = unknown electrical properties: creates always a warning
63  * when connected
64  * PIN_POWER_IN = power input (GND, VCC for ICs). Must be connected to a power
65  * output.
66  * PIN_POWER_OUT = output of a regulator: intended to be connected to power
67  * input pins
68  * PIN_OPENCOLLECTOR = pin type open collector
69  * PIN_OPENEMITTER = pin type open emitter
70  * PIN_NC = not connected (must be left open)
71  *
72  * Minimal requirements:
73  * All pins *must* be connected (except PIN_NC).
74  * When a pin is not connected in schematic, the user must place a "non
75  * connected" symbol to this pin.
76  * This ensures a forgotten connection will be detected.
77  */
78 
79 /* Messages for conflicts :
80  * PIN_INPUT, PIN_OUTPUT, PIN_BIDI, PIN_TRISTATE, PIN_PASSIVE,
81  * PIN_UNSPECIFIED, PIN_POWER_IN, PIN_POWER_OUT, PIN_OPENCOLLECTOR,
82  * PIN_OPENEMITTER, PIN_NC
83  * These messages are used to show the ERC matrix in ERC dialog
84  */
85 
86 // Messages for matrix rows:
87 const wxString CommentERC_H[] =
88 {
89  _( "Input Pin" ),
90  _( "Output Pin" ),
91  _( "Bidirectional Pin" ),
92  _( "Tri-State Pin" ),
93  _( "Passive Pin" ),
94  _( "Unspecified Pin" ),
95  _( "Power Input Pin" ),
96  _( "Power Output Pin" ),
97  _( "Open Collector" ),
98  _( "Open Emitter" ),
99  _( "No Connection" )
100 };
101 
102 // Messages for matrix columns
103 const wxString CommentERC_V[] =
104 {
105  _( "Input Pin" ),
106  _( "Output Pin" ),
107  _( "Bidirectional Pin" ),
108  _( "Tri-State Pin" ),
109  _( "Passive Pin" ),
110  _( "Unspecified Pin" ),
111  _( "Power Input Pin" ),
112  _( "Power Output Pin" ),
113  _( "Open Collector" ),
114  _( "Open Emitter" ),
115  _( "No Connection" )
116 };
117 
118 
119 /* Look up table which gives the diag for a pair of connected pins
120  * Can be modified by ERC options.
121  * at start up: must be loaded by DefaultDiagErc
122  * Can be modified in dialog ERC
123  */
125 
134 {
135 /* I, O, Bi, 3S, Pas, UnS, PwrI, PwrO, OC, OE, NC */
136 /* I */ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR },
137 /* O */ { OK, ERR, OK, WAR, OK, WAR, OK, ERR, ERR, ERR, ERR },
138 /* Bi*/ { OK, OK, OK, OK, OK, WAR, OK, WAR, OK, WAR, ERR },
139 /* 3S*/ { OK, WAR, OK, OK, OK, WAR, WAR, ERR, WAR, WAR, ERR },
140 /*Pas*/ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR },
141 /*UnS */ { WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, ERR },
142 /*PwrI*/ { OK, OK, OK, WAR, OK, WAR, OK, OK, OK, OK, ERR },
143 /*PwrO*/ { OK, ERR, WAR, ERR, OK, WAR, OK, ERR, ERR, ERR, ERR },
144 /* OC */ { OK, ERR, OK, WAR, OK, WAR, OK, ERR, OK, OK, ERR },
145 /* OE */ { OK, ERR, WAR, WAR, OK, WAR, OK, ERR, OK, OK, ERR },
146 /* NC */ { ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR }
147 };
148 
149 
161 {
162 /* In Out, Bi, 3S, Pas, UnS, PwrI,PwrO,OC, OE, NC */
163 /* In*/ { NOD, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
164 /*Out*/ { DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NPI },
165 /* Bi*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
166 /* 3S*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
167 /*Pas*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
168 /*UnS*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
169 /*PwrI*/ { NOD, DRV, NOD, NOD, NOD, NOD, NOD, DRV, NOD, NOD, NPI },
170 /*PwrO*/ { DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NPI },
171 /* OC*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
172 /* OE*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NPI },
173 /* NC*/ { NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI, NPI }
174 };
175 
176 
177 int TestDuplicateSheetNames( bool aCreateMarker )
178 {
179  SCH_SCREEN* screen;
180  SCH_ITEM* item;
181  SCH_ITEM* test_item;
182  int err_count = 0;
183  SCH_SCREENS screenList; // Created the list of screen
184 
185  for( screen = screenList.GetFirst(); screen != NULL; screen = screenList.GetNext() )
186  {
187  for( item = screen->GetDrawItems(); item != NULL; item = item->Next() )
188  {
189  // search for a sheet;
190  if( item->Type() != SCH_SHEET_T )
191  continue;
192 
193  for( test_item = item->Next(); test_item != NULL; test_item = test_item->Next() )
194  {
195  if( test_item->Type() != SCH_SHEET_T )
196  continue;
197 
198  // We have found a second sheet: compare names
199  // we are using case insensitive comparison to avoid mistakes between
200  // similar names like Mysheet and mysheet
201  if( ( (SCH_SHEET*) item )->GetName().CmpNoCase(
202  ( ( SCH_SHEET* ) test_item )->GetName() ) == 0 )
203  {
204  if( aCreateMarker )
205  {
206  /* Create a new marker type ERC error*/
207  SCH_MARKER* marker = new SCH_MARKER();
208  marker->SetTimeStamp( GetNewTimeStamp() );
210  ( (SCH_SHEET*) test_item )->GetPosition(),
211  _( "Duplicate sheet name" ),
212  ( (SCH_SHEET*) test_item )->GetPosition() );
215  screen->Append( marker );
216  }
217 
218  err_count++;
219  }
220  }
221  }
222  }
223 
224  return err_count;
225 }
226 
227 
229 {
230  int errors = 0;
231  std::map<wxString, LIB_ID> footprints;
233  aSheetList.GetMultiUnitComponents( refMap, true );
234 
235  for( auto& component : refMap )
236  {
237  auto& refList = component.second;
238 
239  if( refList.GetCount() == 0 )
240  {
241  wxFAIL; // it should not happen
242  continue;
243  }
244 
245  // Reference footprint
246  wxString fp;
247  wxString unitName;
248 
249  for( unsigned i = 0; i < component.second.GetCount(); ++i )
250  {
251  SCH_COMPONENT* cmp = refList.GetItem( i ).GetComp();
252  SCH_SHEET_PATH sheetPath = refList.GetItem( i ).GetSheetPath();
253  fp = cmp->GetField( FOOTPRINT )->GetText();
254 
255  if( !fp.IsEmpty() )
256  {
257  unitName = cmp->GetRef( &sheetPath )
258  + LIB_PART::SubReference( cmp->GetUnit(), false );
259  break;
260  }
261  }
262 
263  for( unsigned i = 0; i < component.second.GetCount(); ++i )
264  {
265  SCH_REFERENCE& ref = refList.GetItem( i );
266  SCH_COMPONENT* unit = ref.GetComp();
267  SCH_SHEET_PATH sheetPath = refList.GetItem( i ).GetSheetPath();
268  const wxString& curFp = unit->GetField( FOOTPRINT )->GetText();
269 
270  if( !curFp.IsEmpty() && fp != curFp )
271  {
272  wxString curUnitName = unit->GetRef( &sheetPath )
273  + LIB_PART::SubReference( unit->GetUnit(), false );
274 
275  SCH_MARKER* marker = new SCH_MARKER();
276  marker->SetTimeStamp( GetNewTimeStamp() );
277  marker->SetData( ERCE_DIFFERENT_UNIT_FP, unit->GetPosition(),
278  wxString::Format( _( "Unit %s has '%s' assigned, "
279  "whereas unit %s has '%s' assigned" ), unitName, fp, curUnitName, curFp ),
280  unit->GetPosition() );
281  marker->SetMarkerType( MARKER_BASE::MARKER_ERC );
282  marker->SetErrorLevel( MARKER_BASE::MARKER_SEVERITY_WARNING );
283  ref.GetSheetPath().LastScreen()->Append( marker );
284 
285  ++errors;
286  }
287  }
288  }
289 
290  return errors;
291 }
292 
293 
294 void Diagnose( NETLIST_OBJECT* aNetItemRef, NETLIST_OBJECT* aNetItemTst,
295  int aMinConn, int aDiag )
296 {
297  SCH_MARKER* marker = NULL;
298  SCH_SCREEN* screen;
299  ELECTRICAL_PINTYPE ii, jj;
300 
301  if( aDiag == OK )
302  return;
303 
304  /* Create new marker for ERC error. */
305  marker = new SCH_MARKER();
306  marker->SetTimeStamp( GetNewTimeStamp() );
307 
310  screen = aNetItemRef->m_SheetPath.LastScreen();
311  screen->Append( marker );
312 
313  wxString msg;
314 
315  if( aMinConn < 0 )
316  {
317  if( aNetItemRef->m_Type == NET_HIERLABEL || aNetItemRef->m_Type == NET_HIERBUSLABELMEMBER )
318  {
319  msg.Printf( _( "Hierarchical label %s is not connected to a sheet label." ),
320  GetChars( aNetItemRef->m_Label ) );
322  aNetItemRef->m_Start,
323  msg,
324  aNetItemRef->m_Start );
325  }
326  else if( aNetItemRef->m_Type == NET_GLOBLABEL )
327  {
328  msg.Printf( _( "Global label %s is not connected to any other global label." ),
329  GetChars( aNetItemRef->m_Label ) );
330  marker->SetData( ERCE_GLOBLABEL,
331  aNetItemRef->m_Start,
332  msg,
333  aNetItemRef->m_Start );
334  }
335  else
336  {
337  msg.Printf( _( "Sheet label %s is not connected to a hierarchical label." ),
338  GetChars( aNetItemRef->m_Label ) );
340  aNetItemRef->m_Start,
341  msg,
342  aNetItemRef->m_Start );
343  }
344 
345  return;
346  }
347 
348  ii = aNetItemRef->m_ElectricalPinType;
349 
350  wxString cmp_ref( "?" );
351 
352  if( aNetItemRef->m_Type == NET_PIN && aNetItemRef->m_Link )
353  cmp_ref = aNetItemRef->GetComponentParent()->GetRef( &aNetItemRef->m_SheetPath );
354 
355  if( aNetItemTst == NULL )
356  {
357  if( aMinConn == NOC ) /* Only 1 element in the net. */
358  {
359  msg.Printf( _( "Pin %s (%s) of component %s is unconnected." ),
360  aNetItemRef->m_PinNum,
361  GetChars( GetText( ii ) ),
362  GetChars( cmp_ref ) );
364  aNetItemRef->m_Start,
365  msg,
366  aNetItemRef->m_Start );
367  return;
368  }
369 
370  if( aMinConn == NOD ) /* Nothing driving the net. */
371  {
372  if( aNetItemRef->m_Type == NET_PIN && aNetItemRef->m_Link )
373  cmp_ref = aNetItemRef->GetComponentParent()->GetRef(
374  &aNetItemRef->m_SheetPath );
375 
376  msg.Printf( _( "Pin %s (%s) of component %s is not driven (Net %d)." ),
377  aNetItemRef->m_PinNum,
378  GetChars( GetText( ii ) ),
379  GetChars( cmp_ref ),
380  aNetItemRef->GetNet() );
381  marker->SetData( ERCE_PIN_NOT_DRIVEN,
382  aNetItemRef->m_Start,
383  msg,
384  aNetItemRef->m_Start );
385  return;
386  }
387 
388  if( aDiag == UNC )
389  {
390  msg.Printf( _( "More than 1 pin connected to an UnConnect symbol." ) );
392  aNetItemRef->m_Start,
393  msg,
394  aNetItemRef->m_Start );
395  return;
396  }
397  }
398 
399  if( aNetItemTst ) /* Error between 2 pins */
400  {
401  jj = aNetItemTst->m_ElectricalPinType;
403 
404  if( aDiag == ERR )
405  {
407  errortype = ERCE_PIN_TO_PIN_ERROR;
408  }
409 
410  wxString alt_cmp( "?" );
411 
412  if( aNetItemTst->m_Type == NET_PIN && aNetItemTst->m_Link )
413  alt_cmp = aNetItemTst->GetComponentParent()->GetRef( &aNetItemTst->m_SheetPath );
414 
415  msg.Printf( _( "Pin %s (%s) of component %s is connected to " ),
416  aNetItemRef->m_PinNum,
417  GetChars( GetText( ii ) ),
418  GetChars( cmp_ref ) );
419  marker->SetData( errortype, aNetItemRef->m_Start, msg, aNetItemRef->m_Start );
420  msg.Printf( _( "pin %s (%s) of component %s (net %d)." ),
421  aNetItemTst->m_PinNum,
422  GetChars( GetText( jj ) ),
423  GetChars( alt_cmp ),
424  aNetItemRef->GetNet() );
425  marker->SetAuxiliaryData( msg, aNetItemTst->m_Start );
426  }
427 }
428 
429 
431  unsigned aNetItemRef, unsigned aNetStart,
432  int* aMinConnexion )
433 {
434  unsigned netItemTst = aNetStart;
436  int erc = OK;
437 
438  /* Analysis of the table of connections. */
439  ELECTRICAL_PINTYPE ref_elect_type = aList->GetItem( aNetItemRef )->m_ElectricalPinType;
440  int local_minconn = NOC;
441 
442  if( ref_elect_type == PIN_NC )
443  local_minconn = NPI;
444 
445  /* Test pins connected to NetItemRef */
446  for( ; ; netItemTst++ )
447  {
448  if( aNetItemRef == netItemTst )
449  continue;
450 
451  // We examine only a given net. We stop the search if the net changes
452  if( ( netItemTst >= aList->size() ) // End of list
453  || ( aList->GetItemNet( aNetItemRef ) !=
454  aList->GetItemNet( netItemTst ) ) ) // End of net
455  {
456  /* End net code found: minimum connection test. */
457  if( ( *aMinConnexion < NET_NC ) && ( local_minconn < NET_NC ) )
458  {
459  /* Not connected or not driven pin. */
460  bool seterr = true;
461 
462  if( local_minconn == NOC &&
463  aList->GetItemType( aNetItemRef ) == NET_PIN )
464  {
465  /* This pin is not connected: for multiple part per
466  * package, and duplicated pin,
467  * search for another instance of this pin
468  * this will be flagged only if all instances of this pin
469  * are not connected
470  * TODO test also if instances connected are connected to
471  * the same net
472  */
473  for( unsigned duplicate = 0; duplicate < aList->size(); duplicate++ )
474  {
475  if( aList->GetItemType( duplicate ) != NET_PIN )
476  continue;
477 
478  if( duplicate == aNetItemRef )
479  continue;
480 
481  if( aList->GetItem( aNetItemRef )->m_PinNum !=
482  aList->GetItem( duplicate )->m_PinNum )
483  continue;
484 
485  if( ( (SCH_COMPONENT*) aList->GetItem( aNetItemRef )->
486  m_Link )->GetRef( &aList->GetItem( aNetItemRef )-> m_SheetPath ) !=
487  ( (SCH_COMPONENT*) aList->GetItem( duplicate )->m_Link )
488  ->GetRef( &aList->GetItem( duplicate )->m_SheetPath ) )
489  continue;
490 
491  // Same component and same pin. Do dot create error for this pin
492  // if the other pin is connected (i.e. if duplicate net has another
493  // item)
494  if( (duplicate > 0)
495  && ( aList->GetItemNet( duplicate ) ==
496  aList->GetItemNet( duplicate - 1 ) ) )
497  seterr = false;
498 
499  if( (duplicate < aList->size() - 1)
500  && ( aList->GetItemNet( duplicate ) ==
501  aList->GetItemNet( duplicate + 1 ) ) )
502  seterr = false;
503  }
504  }
505 
506  if( seterr )
507  Diagnose( aList->GetItem( aNetItemRef ), NULL, local_minconn, WAR );
508 
509  *aMinConnexion = DRV; // inhibiting other messages of this
510  // type for the net.
511  }
512  return;
513  }
514 
515  switch( aList->GetItemType( netItemTst ) )
516  {
518  case NET_SEGMENT:
519  case NET_BUS:
520  case NET_JUNCTION:
521  case NET_LABEL:
522  case NET_HIERLABEL:
523  case NET_BUSLABELMEMBER:
526  case NET_SHEETLABEL:
527  case NET_GLOBLABEL:
529  case NET_PINLABEL:
530  break;
531 
532  case NET_NOCONNECT:
533  local_minconn = std::max( NET_NC, local_minconn );
534  break;
535 
536  case NET_PIN:
537  jj = aList->GetItem( netItemTst )->m_ElectricalPinType;
538  local_minconn = std::max( MinimalReq[ref_elect_type][jj], local_minconn );
539 
540  if( netItemTst <= aNetItemRef )
541  break;
542 
543  if( erc == OK )
544  {
545  erc = DiagErc[ref_elect_type][jj];
546 
547  if( erc != OK )
548  {
549  if( aList->GetConnectionType( netItemTst ) == UNCONNECTED )
550  {
551  Diagnose( aList->GetItem( aNetItemRef ),
552  aList->GetItem( netItemTst ),
553  0, erc );
554  aList->SetConnectionType( netItemTst, NOCONNECT_SYMBOL_PRESENT );
555  }
556  }
557  }
558 
559  break;
560  }
561  }
562 }
563 
564 int NETLIST_OBJECT_LIST::CountPinsInNet( unsigned aNetStart )
565 {
566  int count = 0;
567  int curr_net = GetItemNet( aNetStart );
568 
569  /* Test pins connected to NetItemRef */
570  for( unsigned item = aNetStart; item < size(); item++ )
571  {
572  // We examine only a given net. We stop the search if the net changes
573  if( curr_net != GetItemNet( item ) ) // End of net
574  break;
575 
576  if( GetItemType( item ) == NET_PIN )
577  count++;
578  }
579 
580  return count;
581 }
582 
583 bool WriteDiagnosticERC( const wxString& aFullFileName )
584 {
585  wxString msg;
586 
587  wxFFile file( aFullFileName, wxT( "wt" ) );
588 
589  if( !file.IsOpened() )
590  return false;
591 
592  msg = _( "ERC report" );
593  msg << wxT(" (") << DateAndTime() << wxT( ", " )
594  << _( "Encoding UTF8" ) << wxT( " )\n" );
595 
596  int err_count = 0;
597  int warn_count = 0;
598  int total_count = 0;
599  SCH_SHEET_LIST sheetList( g_RootSheet );
600 
601  for( unsigned i = 0; i < sheetList.size(); i++ )
602  {
603  msg << wxString::Format( _( "\n***** Sheet %s\n" ),
604  GetChars( sheetList[i].PathHumanReadable() ) );
605 
606  for( SCH_ITEM* item = sheetList[i].LastDrawList(); item != NULL; item = item->Next() )
607  {
608  if( item->Type() != SCH_MARKER_T )
609  continue;
610 
611  SCH_MARKER* marker = (SCH_MARKER*) item;
612 
613  if( marker->GetMarkerType() != MARKER_BASE::MARKER_ERC )
614  continue;
615 
616  total_count++;
617 
619  err_count++;
620 
622  warn_count++;
623 
624  msg << marker->GetReporter().ShowReport();
625  }
626  }
627 
628  msg << wxString::Format( _( "\n ** ERC messages: %d Errors %d Warnings %d\n" ),
629  total_count, err_count, warn_count );
630 
631  // Currently: write report using UTF8 (as usual in Kicad).
632  // TODO: see if we can use the current encoding page (mainly for Windows users),
633  // Or other format (HTML?)
634  file.Write( msg );
635 
636  // wxFFile dtor will close the file.
637 
638  return true;
639 }
640 
641 
642 void NETLIST_OBJECT_LIST::TestforNonOrphanLabel( unsigned aNetItemRef, unsigned aStartNet )
643 {
644  unsigned netItemTst = aStartNet;
645  int erc = 1;
646 
647  // Review the list of labels connected to NetItemRef:
648  for( ; ; netItemTst++ )
649  {
650  if( netItemTst == aNetItemRef )
651  continue;
652 
653  /* Is always in the same net? */
654  if( ( netItemTst == size() )
655  || ( GetItemNet( aNetItemRef ) != GetItemNet( netItemTst ) ) )
656  {
657  /* End Netcode found. */
658  if( erc )
659  {
660  /* Glabel or SheetLabel orphaned. */
661  Diagnose( GetItem( aNetItemRef ), NULL, -1, WAR );
662  }
663 
664  return;
665  }
666 
667  if( GetItem( aNetItemRef )->IsLabelConnected( GetItem( netItemTst ) ) )
668  erc = 0;
669 
670  //same thing, different order.
671  if( GetItem( netItemTst )->IsLabelConnected( GetItem( aNetItemRef ) ) )
672  erc = 0;
673  }
674 }
675 
676 
677 // this code try to detect similar labels, i.e. labels which are identical
678 // when they are compared using case insensitive coparisons.
679 
680 
681 // A helper struct to compare NETLIST_OBJECT items by sheetpath and label texts
682 // for a std::set<NETLIST_OBJECT*> container
683 // the full text is "sheetpath+label" for local labels and "label" for global labels
685 {
686  bool operator() ( const NETLIST_OBJECT* lab1, const NETLIST_OBJECT* lab2 )
687  {
688  wxString str1 = lab1->m_SheetPath.Path() + lab1->m_Label;
689  wxString str2 = lab2->m_SheetPath.Path() + lab2->m_Label;
690 
691  return str1.Cmp( str2 ) < 0;
692  }
693 };
694 
696 {
697  bool operator() ( const NETLIST_OBJECT* lab1, const NETLIST_OBJECT* lab2 )
698  {
699  return lab1->m_Label.Cmp( lab2->m_Label ) < 0;
700  }
701 };
702 
704 {
705  bool operator() ( const NETLIST_OBJECT* lab1, const NETLIST_OBJECT* lab2 )
706  {
707  return lab1->m_SheetPath.Path().Cmp( lab2->m_SheetPath.Path() ) < 0;
708  }
709 };
710 
711 // Helper functions to build the warning messages about Similar Labels:
712 static int countIndenticalLabels( std::vector<NETLIST_OBJECT*>& aList, NETLIST_OBJECT* aLabel );
713 static void SimilarLabelsDiagnose( NETLIST_OBJECT* aItemA, NETLIST_OBJECT* aItemB );
714 
715 
717 {
718  // Similar labels which are different when using case sensitive comparisons
719  // but are equal when using case insensitive comparisons
720 
721  // list of all labels (used the better item to build diag messages)
722  std::vector<NETLIST_OBJECT*> fullLabelList;
723  // list of all labels , each label appears only once (used to to detect similar labels)
724  std::set<NETLIST_OBJECT*, compare_labels> uniqueLabelList;
725  wxString msg;
726 
727  // Build a list of differents labels. If inside a given sheet there are
728  // more than one given label, only one label is stored.
729  // not also the sheet labels are not taken in account for 2 reasons:
730  // * they are in the root sheet but they are seen only from the child sheet
731  // * any mismatch between child sheet hierarchical labels and the sheet label
732  // already detected by ERC
733  for( unsigned netItem = 0; netItem < size(); ++netItem )
734  {
735  switch( GetItemType( netItem ) )
736  {
737  case NET_LABEL:
738  case NET_BUSLABELMEMBER:
739  case NET_PINLABEL:
741  case NET_HIERLABEL:
743  case NET_GLOBLABEL:
744  // add this label in lists
745  uniqueLabelList.insert( GetItem( netItem ) );
746  fullLabelList.push_back( GetItem( netItem ) );
747  break;
748 
749  case NET_SHEETLABEL:
751  default:
752  break;
753  }
754  }
755 
756  // build global labels and compare
757  std::set<NETLIST_OBJECT*, compare_label_names> loc_labelList;
758  std::set<NETLIST_OBJECT*>::const_iterator it;
759 
760  for( it = uniqueLabelList.begin(); it != uniqueLabelList.end(); ++it )
761  {
762  if( (*it)->IsLabelGlobal() )
763  loc_labelList.insert( *it );
764  }
765 
766  // compare global labels (same label names appears only once in list)
767  for( it = loc_labelList.begin(); it != loc_labelList.end(); ++it )
768  {
769  std::set<NETLIST_OBJECT*>::const_iterator it_aux = it;
770 
771  for( ++it_aux; it_aux != loc_labelList.end(); ++it_aux )
772  {
773  if( (*it)->m_Label.CmpNoCase( (*it_aux)->m_Label ) == 0 )
774  {
775  // Create new marker for ERC.
776  int cntA = countIndenticalLabels( fullLabelList, *it );
777  int cntB = countIndenticalLabels( fullLabelList, *it_aux );
778 
779  if( cntA <= cntB )
780  SimilarLabelsDiagnose( (*it), (*it_aux) );
781  else
782  SimilarLabelsDiagnose( (*it_aux), (*it) );
783  }
784  }
785  }
786 
787  // Build paths list
788  std::set<NETLIST_OBJECT*, compare_paths> pathsList;
789 
790  for( it = uniqueLabelList.begin(); it != uniqueLabelList.end(); ++it )
791  pathsList.insert( *it );
792 
793  // Examine each label inside a sheet path:
794  for( it = pathsList.begin(); it != pathsList.end(); ++it )
795  {
796  loc_labelList.clear();
797 
798  std::set<NETLIST_OBJECT*>::const_iterator it_aux = uniqueLabelList.begin();
799 
800  for( ; it_aux != uniqueLabelList.end(); ++it_aux )
801  {
802  if( (*it)->m_SheetPath.Path() == (*it_aux)->m_SheetPath.Path() )
803  loc_labelList.insert( *it_aux );
804  }
805 
806  // at this point, loc_labelList contains labels of the current sheet path.
807  // Detect similar labels (same label names appears only once in list)
808  std::set<NETLIST_OBJECT*>::const_iterator ref_it;
809 
810  for( ref_it = loc_labelList.begin(); ref_it != loc_labelList.end(); ++ref_it )
811  {
812  NETLIST_OBJECT* ref_item = *ref_it;
813  it_aux = ref_it;
814 
815  for( ++it_aux; it_aux != loc_labelList.end(); ++it_aux )
816  {
817  // global label versus global label was already examined.
818  // here, at least one label must be local
819  if( ref_item->IsLabelGlobal() && (*it_aux)->IsLabelGlobal() )
820  continue;
821 
822  if( ref_item->m_Label.CmpNoCase( (*it_aux)->m_Label ) == 0 )
823  {
824  // Create new marker for ERC.
825  int cntA = countIndenticalLabels( fullLabelList, ref_item );
826  int cntB = countIndenticalLabels( fullLabelList, *it_aux );
827 
828  if( cntA <= cntB )
829  SimilarLabelsDiagnose( ref_item, (*it_aux) );
830  else
831  SimilarLabelsDiagnose( (*it_aux), ref_item );
832  }
833  }
834  }
835  }
836 }
837 
838 // Helper function: count the number of labels identical to aLabel
839 // for global label: global labels in the full project
840 // for local label: all labels in the current sheet
841 static int countIndenticalLabels( std::vector<NETLIST_OBJECT*>& aList, NETLIST_OBJECT* aLabel )
842 {
843  int count = 0;
844 
845  if( aLabel->IsLabelGlobal() )
846  {
847  for( unsigned netItem = 0; netItem < aList.size(); ++netItem )
848  {
849  NETLIST_OBJECT* item = aList[netItem];
850 
851  if( item->IsLabelGlobal() && item->m_Label == aLabel->m_Label )
852  count++;
853  }
854  }
855  else
856  {
857  for( unsigned netItem = 0; netItem < aList.size(); ++netItem )
858  {
859  NETLIST_OBJECT* item = aList[netItem];
860 
861  if( item->m_Label == aLabel->m_Label &&
862  item->m_SheetPath.Path() == aLabel->m_SheetPath.Path() )
863  count++;
864  }
865  }
866 
867  return count;
868 }
869 
870 // Helper function: creates a marker for similar labels ERC warning
871 static void SimilarLabelsDiagnose( NETLIST_OBJECT* aItemA, NETLIST_OBJECT* aItemB )
872 {
873  // Create new marker for ERC.
874  SCH_MARKER* marker = new SCH_MARKER();
875 
876  marker->SetTimeStamp( GetNewTimeStamp() );
879  SCH_SCREEN* screen = aItemA->m_SheetPath.LastScreen();
880  screen->Append( marker );
881 
882  wxString fmt = aItemA->IsLabelGlobal() ?
883  _( "Global label \"%s\" (sheet \"%s\") looks like:" ) :
884  _( "Local label \"%s\" (sheet \"%s\") looks like:" );
885  wxString msg;
886 
887  msg.Printf( fmt, GetChars( aItemA->m_Label ), GetChars( aItemA->m_SheetPath.PathHumanReadable() ) );
888  marker->SetData( aItemA->IsLabelGlobal() && aItemB->IsLabelGlobal() ?
890  aItemA->m_Start, msg, aItemA->m_Start );
891 
892  fmt = aItemB->IsLabelGlobal() ? _( "Global label \"%s\" (sheet \"%s\")" ) :
893  _( "Local label \"%s\" (sheet \"%s\")" );
894  msg.Printf( fmt, GetChars( aItemB->m_Label ), GetChars( aItemB->m_SheetPath.PathHumanReadable() ) );
895  marker->SetAuxiliaryData( msg, aItemB->m_Start );
896 }
Definition of the SCH_SHEET class for Eeschema.
Class SCH_SHEET_LIST.
KICAD_T Type() const
Function Type()
Definition: base_struct.h:209
bool IsLabelGlobal() const
Function IsLabelGlobal.
SCH_SCREEN * GetNext()
Definition: erc.h:43
#define ERCE_SIMILAR_LABELS
Definition: erc.h:61
void TestOthersItems(NETLIST_OBJECT_LIST *aList, unsigned aNetItemRef, unsigned aNetStart, int *aMinConnexion)
Perform ERC testing for electrical conflicts between NetItemRef and other items (mainly pin) on the s...
Definition: erc.cpp:430
#define ERCE_HIERACHICAL_LABEL
Definition: erc.h:58
NETLIST_ITEM_T GetItemType(unsigned aIdx) const
Acces to an item type.
NETLIST_OBJECT * GetItem(unsigned aIdx) const
Acces to an item in list.
int DiagErc[PINTYPE_COUNT][PINTYPE_COUNT]
Definition: erc.cpp:124
const wxString CommentERC_H[]
Definition: erc.cpp:87
wxString ShowReport() const
Function ShowReport translates this object into a text string suitable for saving to disk in a report...
Definition: drc_item.h:210
int CountPinsInNet(unsigned aNetStart)
Counts number of pins connected on the same net.
Definition: erc.cpp:564
#define ERCE_PIN_NOT_DRIVEN
Definition: erc.h:55
void Diagnose(NETLIST_OBJECT *aNetItemRef, NETLIST_OBJECT *aNetItemTst, int aMinConn, int aDiag)
Performs ERC testing and creates an ERC marker to show the ERC problem for aNetItemRef or between aNe...
Definition: erc.cpp:294
#define ERCE_PIN_NOT_CONNECTED
Definition: erc.h:54
SCH_SHEET_PATH m_SheetPath
ELECTRICAL_PINTYPE m_ElectricalPinType
SCH_SCREEN * LastScreen() const
Function LastScreen.
NETLIST_ITEM_T m_Type
SCH_ITEM * Next() const
Field Name Module PCB, i.e. "16DIP300".
void SetConnectionType(unsigned aIdx, NET_CONNECTION_T aFlg=UNCONNECTED)
Set the item connection type: UNCONNECTED Pin or Label not connected (error) NOCONNECT_SYMBOL_PRESENT...
void SetData(int aErrorCode, const wxPoint &aMarkerPos, const wxString &aText, const wxPoint &aPos, const wxString &bText, const wxPoint &bPos)
Function SetData fills in all the reportable data associated with a MARKER.
bool WriteDiagnosticERC(const wxString &aFullFileName)
Function WriteDiagnosticERC save the ERC errors to aFullFileName.
Definition: erc.cpp:583
enum TYPEMARKER GetMarkerType() const
Definition: marker_base.h:150
Class NETLIST_OBJECT_LIST is a container holding and owning NETLIST_OBJECTs, which are connected item...
wxString Path() const
Function Path the path uses the time stamps which do not changes even when editing sheet parameters a...
#define DRV
Definition: erc.h:70
Definition: erc.h:42
timestamp_t GetNewTimeStamp()
Definition: common.cpp:160
Definition: erc.h:44
MARKER_SEVERITY GetErrorLevel() const
Definition: marker_base.h:138
int TestDuplicateSheetNames(bool aCreateMarker)
Function TestDuplicateSheetNames( ) inside a given sheet, one cannot have sheets with duplicate names...
Definition: erc.cpp:177
int GetNet() const
#define ERCE_SIMILAR_GLBL_LABELS
Definition: erc.h:62
SCH_SHEET * g_RootSheet
Definition: eeschema.cpp:55
SCH_FIELD * GetField(int aFieldNdx) const
Returns a field in this symbol.
void TestforSimilarLabels()
Function TestforSimilarLabels detects labels which are different when using case sensitive comparison...
Definition: erc.cpp:716
#define ERCE_GLOBLABEL
Definition: erc.h:60
#define ERCE_DUPLICATE_SHEET_NAME
Definition: erc.h:53
const DRC_ITEM & GetReporter() const
Function GetReporter returns the DRC_ITEM held within this MARKER so that its interface may be used...
Definition: marker_base.h:203
#define ERCE_DIFFERENT_UNIT_FP
Definition: erc.h:63
const wxString & GetText() const
Function GetText returns the string associated with the text object.
Definition: eda_text.h:128
wxString PathHumanReadable() const
Function PathHumanReadable returns the sheet path in a human readable form, i.e.
void TestforNonOrphanLabel(unsigned aNetItemRef, unsigned aStartNet)
Function TestforNonOrphanLabel Sheet labels are expected to be connected to a hierarchical label...
Definition: erc.cpp:642
wxString GetText(GRAPHIC_PINSHAPE shape)
Definition: pin_shape.cpp:33
Definition: erc.h:45
int GetUnit() const
Class SCH_SHEET_PATH.
#define ERCE_PIN_TO_PIN_ERROR
Definition: erc.h:57
void SetMarkerType(enum TYPEMARKER aMarkerType)
accessors to set/get marker type (DRC, ERC, or other)
Definition: marker_base.h:145
const wxString GetRef(const SCH_SHEET_PATH *aSheet)
Return the reference for the given sheet path.
std::map< wxString, SCH_REFERENCE_LIST > SCH_MULTI_UNIT_REFERENCE_MAP
Type SCH_MULTI_UNIT_REFERENCE_MAP is used to create a map of reference designators for multi-unit par...
SCH_COMPONENT * GetComponentParent() const
For Pins (NET_PINS):
static int countIndenticalLabels(std::vector< NETLIST_OBJECT * > &aList, NETLIST_OBJECT *aLabel)
Definition: erc.cpp:841
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:209
void GetMultiUnitComponents(SCH_MULTI_UNIT_REFERENCE_MAP &aRefList, bool aIncludePowerSymbols=true)
Function GetMultiUnitComponents adds a SCH_REFERENCE_LIST object to aRefList for each same-reference ...
SCH_ITEM * GetDrawItems() const
Definition: sch_screen.h:138
#define NOC
Definition: erc.h:73
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
NET_CONNECTION_T GetConnectionType(unsigned aIdx)
static int MinimalReq[PINTYPE_COUNT][PINTYPE_COUNT]
Look up table which gives the minimal drive for a pair of connected pins on a net.
Definition: erc.cpp:160
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
ELECTRICAL_PINTYPE
The component library pin object electrical types used in ERC tests.
Definition: pin_type.h:37
void Append(SCH_ITEM *aItem)
Definition: sch_screen.h:140
#define max(a, b)
Definition: auxiliary.h:86
SCH_SHEET_PATH GetSheetPath() const
void SetErrorLevel(MARKER_SEVERITY aErrorLevel)
accessors to set/get error levels (warning, error, fatal error..)
Definition: marker_base.h:133
#define NPI
Definition: erc.h:69
size_t i
Definition: json11.cpp:597
static wxString SubReference(int aUnit, bool aAddSeparator=true)
Class SCH_COMPONENT describes a real schematic component.
Definition: sch_component.h:69
wxPoint GetPosition() const override
Function GetPosition.
int DefaultDiagErc[PINTYPE_COUNT][PINTYPE_COUNT]
Default Look up table which gives the ERC error level for a pair of connected pins Same as DiagErc...
Definition: erc.cpp:133
const wxString CommentERC_V[]
Definition: erc.cpp:103
errortype
Definition: erc.h:40
SCH_SCREEN * GetFirst()
int GetItemNet(unsigned aIdx) const
Acces to an item net code.
#define NET_NC
Definition: erc.h:71
#define ERCE_NOCONNECT_CONNECTED
Definition: erc.h:59
#define ERCE_PIN_TO_PIN_WARNING
Definition: erc.h:56
Definition of the NETLIST_OBJECT class.
SCH_COMPONENT * GetComp() const
SCH_ITEM * m_Link
int TestMultiunitFootprints(SCH_SHEET_LIST &aSheetList)
Test if all units of each multiunit component have the same footprint assigned.
Definition: erc.cpp:228
Class SCH_ITEM is a base class for any item which can be embedded within the SCHEMATIC container clas...
Class SCH_REFERENCE is used as a helper to define a component&#39;s reference designator in a schematic...
void SetAuxiliaryData(const wxString &aAuxiliaryText, const wxPoint &aAuxiliaryPos)
Function SetAuxiliaryData initialize data for the second (auxiliary) item.
Definition: marker_base.h:187
wxString DateAndTime()
Function DateAndTime.
Definition: string.cpp:229
static void SimilarLabelsDiagnose(NETLIST_OBJECT *aItemA, NETLIST_OBJECT *aItemB)
Definition: erc.cpp:871
Container class that holds multiple SCH_SCREEN objects in a hierarchy.
Definition: sch_screen.h:503
#define NOD
Definition: erc.h:72
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:214