haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add clearance sources to some DRC violation reports.

This commit is contained in:
Jeff Young 2020-04-26 13:21:37 +01:00
parent a56191b658
commit f7e518dbc6
10 changed files with 130 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
pcbnew/board_connected_item.cpp
View File

@ -79,15 +79,16 @@ bool BOARD_CONNECTED_ITEM::SetNetCode( int aNetCode, bool aNoAssert )
}
int BOARD_CONNECTED_ITEM::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
int BOARD_CONNECTED_ITEM::GetClearance( BOARD_CONNECTED_ITEM* aItem, wxString* aSource ) const
{
int myClearance = m_netinfo->GetClearance();
NETCLASSPTR netclass = GetNetClass();
int myClearance = netclass->GetClearance();
if( m_netinfo->GetNet() == 0 )
myClearance = GetBoard()->GetDesignSettings().GetDefault()->GetClearance();
if( aSource )
*aSource = wxString::Format( _( "%s netclass clearance" ), netclass->GetName() );
if( aItem )
return std::max( myClearance, aItem->GetClearance() );
if( aItem && aItem->GetClearance() > myClearance )
return aItem->GetClearance( nullptr, aSource );
return myClearance;
}

6
pcbnew/board_connected_item.h
View File

@ -157,10 +157,12 @@ public:
* returned clearance is the greater of this object's NETCLASS clearance and
* aItem's NETCLASS clearance. If \a aItem is NULL, then this objects clearance
* is returned.
* @param aItem is another BOARD_CONNECTED_ITEM or NULL
* @param aItem is an optional BOARD_CONNECTED_ITEM
* @param aSource [out] optionally reports the source as a user-readable string
* @return int - the clearance in internal units.
*/
virtual int GetClearance( BOARD_CONNECTED_ITEM* aItem = NULL ) const;
virtual int GetClearance( BOARD_CONNECTED_ITEM* aItem = nullptr,
wxString* aSource = nullptr ) const;
/**
* Function GetNetClass

42
pcbnew/class_pad.cpp
View File

@ -634,32 +634,38 @@ bool D_PAD::IncrementPadName( bool aSkipUnconnectable, bool aFillSequenceGaps )
}
int D_PAD::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
int D_PAD::GetClearance( BOARD_CONNECTED_ITEM* aItem, wxString* aSource ) const
{
// A pad can have specific clearance parameters that
// overrides its NETCLASS clearance value
int clearance = m_LocalClearance;
int myClearance;
if( clearance == 0 )
// A pad can have specific clearance that overrides its NETCLASS clearance value
if( m_LocalClearance )
{
// If local clearance is 0, use the parent footprint clearance value
if( GetParent() && GetParent()->GetLocalClearance() )
clearance = GetParent()->GetLocalClearance();
myClearance = m_LocalClearance;
if( aSource )
*aSource = wxString::Format( _( "pad %s clearance" ), GetName() );
}
if( clearance == 0 ) // If the parent footprint clearance value = 0, use NETCLASS value
return BOARD_CONNECTED_ITEM::GetClearance( aItem );
// We have a specific clearance.
// if aItem, return the biggest clearance
if( aItem )
// A footprint can have a specific clearance value
else if( GetParent() && GetParent()->GetLocalClearance() )
{
int hisClearance = aItem->GetClearance();
return std::max( hisClearance, clearance );
myClearance = GetParent()->GetLocalClearance();
if( aSource )
*aSource = wxString::Format( _( "%s footprint clearance" ), GetParent()->GetReference() );
}
// Return the specific clearance.
return clearance;
// Otherwise use the baseclass method to fetch the netclass setting
else
{
myClearance = BOARD_CONNECTED_ITEM::GetClearance( nullptr, aSource );
}
if( aItem && aItem->GetClearance() > myClearance )
return aItem->GetClearance( nullptr, aSource );
return myClearance;
}

6
pcbnew/class_pad.h
View File

@ -467,10 +467,12 @@ public:
* returned clearance is the greater of this object's clearance and
* aItem's clearance. If \a aItem is NULL, then this objects clearance
* is returned.
* @param aItem is another BOARD_CONNECTED_ITEM or NULL
* @param aItem is an optional BOARD_CONNECTED_ITEM
* @param aSource [out] optionally reports the source as a user-readable string
* @return int - the clearance in internal units.
*/
int GetClearance( BOARD_CONNECTED_ITEM* aItem = NULL ) const override;
int GetClearance( BOARD_CONNECTED_ITEM* aItem = nullptr,
wxString* aSource = nullptr ) const override;
// Mask margins handling:

4
pcbnew/class_track.cpp
View File

@ -117,11 +117,11 @@ BITMAP_DEF VIA::GetMenuImage() const
}
int TRACK::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
int TRACK::GetClearance( BOARD_CONNECTED_ITEM* aItem, wxString* aSource ) const
{
// Currently tracks have no specific clearance parameter on a per track or per
// segment basis. The NETCLASS clearance is used.
return BOARD_CONNECTED_ITEM::GetClearance( aItem );
return BOARD_CONNECTED_ITEM::GetClearance( aItem, aSource );
}

8
pcbnew/class_track.h
View File

@ -199,12 +199,14 @@ public:
* returned clearance is the greater of this object's clearance and
* aItem's clearance. If \a aItem is NULL, then this objects clearance
* is returned.
* @param aItem is another BOARD_CONNECTED_ITEM or NULL
* @param aItem is an optional BOARD_CONNECTED_ITEM
* @param aSource [out] optionally reports the source as a user-readable string
* @return int - the clearance in internal units.
*/
virtual int GetClearance( BOARD_CONNECTED_ITEM* aItem = NULL ) const override;
int GetClearance( BOARD_CONNECTED_ITEM* aItem = nullptr,
wxString* aSource = nullptr ) const override;
virtual wxString GetSelectMenuText( EDA_UNITS aUnits ) const override;
wxString GetSelectMenuText( EDA_UNITS aUnits ) const override;
BITMAP_DEF GetMenuImage() const override;

27
pcbnew/class_zone.cpp
View File

@ -454,26 +454,31 @@ bool ZONE_CONTAINER::HitTest( const EDA_RECT& aRect, bool aContained, int aAccur
}
int ZONE_CONTAINER::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
int ZONE_CONTAINER::GetClearance( BOARD_CONNECTED_ITEM* aItem, wxString* aSource ) const
{
int myClearance = m_ZoneClearance;
// The actual zone clearance is the biggest of the zone netclass clearance
// and the zone clearance setting in the zone properties dialog.
int myClearance = m_ZoneClearance;
if( aSource )
*aSource = _( "zone clearance" );
if( !m_isKeepout ) // Net class has no meaning for a keepout area.
{
NETCLASSPTR myClass = GetNetClass();
NETCLASSPTR myClass = GetNetClass();
if( myClass )
myClearance = std::max( myClearance, myClass->GetClearance() );
if( myClass->GetClearance() > myClearance )
{
myClearance = myClass->GetClearance();
if( aSource )
*aSource = wxString::Format( _( "'%s' netclass clearance" ), myClass->GetName() );
}
}
// Get the final clearance between me and aItem
if( aItem )
{
int hisClearance = aItem->GetClearance( NULL );
myClearance = std::max( hisClearance, myClearance );
}
if( aItem && aItem->GetClearance() > myClearance )
return aItem->GetClearance( nullptr, aSource );
return myClearance;
}

3
pcbnew/class_zone.h
View File

@ -110,7 +110,8 @@ public:
*/
const EDA_RECT GetBoundingBox() const override;
int GetClearance( BOARD_CONNECTED_ITEM* aItem = NULL ) const override;
int GetClearance( BOARD_CONNECTED_ITEM* aItem = nullptr,
wxString* aSource = nullptr ) const override;
/**
* Function IsOnCopperLayer

29
pcbnew/drc/drc.cpp
View File

@ -1329,11 +1329,6 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
// Ensure the hole is on all copper layers
dummypad.SetLayerSet( all_cu | dummypad.GetLayerSet() );
// Use the minimal local clearance value for the dummy pad.
// The clearance of the active pad will be used as minimum distance to a hole
// (a value = 0 means use netclass value)
dummypad.SetLocalClearance( 1 );
for( D_PAD** pad_list = aStart; pad_list<aEnd; ++pad_list )
{
D_PAD* pad = *pad_list;
@ -1381,14 +1376,16 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
PAD_SHAPE_OVAL : PAD_SHAPE_CIRCLE );
dummypad.SetOrientation( pad->GetOrientation() );
int minClearance = aRefPad->GetClearance( &dummypad );
int actual;
wxString source;
int minClearance = aRefPad->GetClearance( nullptr, &source );
int actual;
if( !checkClearancePadToPad( aRefPad, &dummypad, minClearance, &actual ) )
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_HOLE_NEAR_PAD );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
source,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
@ -1409,14 +1406,16 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
PAD_SHAPE_OVAL : PAD_SHAPE_CIRCLE );
dummypad.SetOrientation( aRefPad->GetOrientation() );
int minClearance = pad->GetClearance( &dummypad );
int actual;
wxString source;
int minClearance = pad->GetClearance( nullptr, &source );
int actual;
if( !checkClearancePadToPad( pad, &dummypad, minClearance, &actual ) )
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_HOLE_NEAR_PAD );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
source,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
@ -1456,14 +1455,16 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
continue;
}
int minClearance = aRefPad->GetClearance( &dummypad );
int actual;
wxString source;
int minClearance = aRefPad->GetClearance( nullptr, &source );
int actual;
if( !checkClearancePadToPad( aRefPad, pad, minClearance, &actual ) )
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_PAD_NEAR_PAD1 );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
source,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );

87
pcbnew/drc/drc_clearance_test_functions.cpp
View File

@ -149,11 +149,8 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
wxString msg;
SEG refSeg( aRefSeg->GetStart(), aRefSeg->GetEnd() );
NETCLASSPTR netclass = aRefSeg->GetNetClass();
LSET layerMask = aRefSeg->GetLayerSet();
int refNetCode = aRefSeg->GetNetCode();
int refSegWidth = aRefSeg->GetWidth();
int refSegClearance = netclass->GetClearance();
/******************************************/
@ -171,7 +168,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TOO_SMALL_MICROVIA );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (board minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), dsnSettings.m_MicroViasMinSize, true ),
MessageTextFromValue( userUnits(), refvia->GetWidth(), true ) );
@ -186,7 +183,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TOO_SMALL_MICROVIA_DRILL );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (board minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), dsnSettings.m_MicroViasMinDrill, true ),
MessageTextFromValue( userUnits(), refvia->GetDrillValue(), true ) );
@ -203,7 +200,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TOO_SMALL_VIA );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (board minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), dsnSettings.m_ViasMinSize, true ),
MessageTextFromValue( userUnits(), refvia->GetWidth(), true ) );
@ -218,7 +215,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TOO_SMALL_VIA_DRILL );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (board minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), dsnSettings.m_ViasMinDrill, true ),
MessageTextFromValue( userUnits(), refvia->GetDrillValue(), true ) );
@ -237,7 +234,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_VIA_HOLE_BIGGER );
msg.Printf( drcItem->GetErrorText() + _( "(diameter %s; drill %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (diameter %s; drill %s)" ),
MessageTextFromValue( userUnits(), refvia->GetWidth(), true ),
MessageTextFromValue( userUnits(), refvia->GetDrillValue(), true ) );
@ -305,7 +302,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TOO_SMALL_TRACK_WIDTH );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (board minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), dsnSettings.m_TrackMinWidth, true ),
MessageTextFromValue( userUnits(), refSegWidth, true ) );
@ -350,9 +347,11 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
slotEnd.y += ( pad->GetDrillSize().y / 2 ) - slotHalfWidth;
}
SEG slotSeg( slotStart, slotEnd );
int widths = slotHalfWidth + ( refSegWidth / 2 );
int center2centerAllowed = refSegClearance + widths;
wxString clearanceSource;
int minClearance = aRefSeg->GetClearance( nullptr, &clearanceSource );
SEG slotSeg( slotStart, slotEnd );
int widths = slotHalfWidth + ( refSegWidth / 2 );
int center2centerAllowed = minClearance + widths;
// Avoid square-roots if possible (for performance)
SEG::ecoord center2center_squared = refSeg.SquaredDistance( slotSeg );
@ -362,8 +361,9 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
int actual = std::max( 0.0, sqrt( center2center_squared ) - widths );
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TRACK_NEAR_THROUGH_HOLE );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), refSegClearance, true ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
clearanceSource,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
drcItem->SetErrorMessage( msg );
@ -381,18 +381,20 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
continue;
// No need to check pads with the same net as the refSeg.
if( pad->GetNetCode() && refNetCode == pad->GetNetCode() )
if( pad->GetNetCode() && aRefSeg->GetNetCode() == pad->GetNetCode() )
continue;
SEG padSeg( pad->GetPosition(), pad->GetPosition() );
int minClearance = std::max( refSegClearance, pad->GetClearance() );
int actual;
wxString clearanceSource;
int minClearance = aRefSeg->GetClearance( pad, &clearanceSource );
SEG padSeg( pad->GetPosition(), pad->GetPosition() );
int actual;
if( !checkClearanceSegmToPad( refSeg, refSegWidth, pad, minClearance, &actual ) )
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TRACK_NEAR_PAD );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
clearanceSource,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
@ -418,17 +420,18 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
TRACK* track = *it;
// No problem if segments have the same net code:
if( refNetCode == track->GetNetCode() )
if( aRefSeg->GetNetCode() == track->GetNetCode() )
continue;
// No problem if tracks are on different layers :
if( !( layerMask & track->GetLayerSet() ).any() )
continue;
SEG trackSeg( track->GetStart(), track->GetEnd() );
int minClearance = std::max( refSegClearance, track->GetClearance() );
int widths = ( refSegWidth + track->GetWidth() ) / 2;
int center2centerAllowed = minClearance + widths;
wxString clearanceSource;
int minClearance = aRefSeg->GetClearance( track, &clearanceSource );
SEG trackSeg( track->GetStart(), track->GetEnd() );
int widths = ( refSegWidth + track->GetWidth() ) / 2;
int center2centerAllowed = minClearance + widths;
// Avoid square-roots if possible (for performance)
SEG::ecoord center2center_squared = refSeg.SquaredDistance( trackSeg );
@ -461,7 +464,8 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
int actual = std::max( 0.0, sqrt( center2center_squared ) - widths );
DRC_ITEM* drcItem = new DRC_ITEM( errorCode );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
clearanceSource,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
@ -492,13 +496,14 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
if( !( layerMask & zone->GetLayerSet() ).any() )
continue;
if( zone->GetNetCode() && zone->GetNetCode() == refNetCode )
if( zone->GetNetCode() && zone->GetNetCode() == aRefSeg->GetNetCode() )
continue;
int clearance = std::max( refSegClearance, zone->GetClearance() );
wxString clearanceSource;
int minClearance = aRefSeg->GetClearance( zone, &clearanceSource );
SHAPE_POLY_SET* outline = const_cast<SHAPE_POLY_SET*>( &zone->GetFilledPolysList() );
int error = clearance - outline->Distance( testSeg, refSegWidth );
int error = minClearance - outline->Distance( testSeg, refSegWidth );
// to avoid false positive, due to rounding issues and approxiamtions
// in distance and clearance calculations, use a small threshold for distance
@ -509,9 +514,10 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TRACK_NEAR_ZONE );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), clearance, true ),
MessageTextFromValue( userUnits(), clearance - error, true ) );
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
clearanceSource,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), minClearance - error, true ) );
drcItem->SetErrorMessage( msg );
drcItem->SetItems( aRefSeg, zone );
@ -528,9 +534,17 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
{
SEG testSeg( aRefSeg->GetStart(), aRefSeg->GetEnd() );
int clearance = std::max( refSegClearance, dsnSettings.m_CopperEdgeClearance );
wxString clearanceSource;
int minClearance = aRefSeg->GetClearance( nullptr, &clearanceSource );
if( dsnSettings.m_CopperEdgeClearance > minClearance )
{
minClearance = dsnSettings.m_CopperEdgeClearance;
clearanceSource = _( "board edge clearance" );
}
int halfWidth = refSegWidth / 2;
int center2centerAllowed = clearance + halfWidth;
int center2centerAllowed = minClearance + halfWidth;
for( auto it = m_board_outlines.IterateSegmentsWithHoles(); it; it++ )
{
@ -550,7 +564,7 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
if( !test_edge || test_edge->GetLayer() != Edge_Cuts )
return SEARCH_RESULT::CONTINUE;
if( test_edge->HitTest( (wxPoint) pt, clearance + halfWidth ) )
if( test_edge->HitTest( (wxPoint) pt, minClearance + halfWidth ) )
{
edge = test_edge;
return SEARCH_RESULT::QUIT;
@ -565,8 +579,9 @@ void DRC::doTrackDrc( TRACK* aRefSeg, TRACKS::iterator aStartIt, TRACKS::iterato
int actual = std::max( 0.0, sqrt( center2center_squared ) - halfWidth );
DRC_ITEM* drcItem = new DRC_ITEM( DRCE_TRACK_NEAR_EDGE );
msg.Printf( drcItem->GetErrorText() + _( "(minimum %s; actual %s)" ),
MessageTextFromValue( userUnits(), clearance, true ),
msg.Printf( drcItem->GetErrorText() + _( " (%s %s; actual %s)" ),
clearanceSource,
MessageTextFromValue( userUnits(), minClearance, true ),
MessageTextFromValue( userUnits(), actual, true ) );
drcItem->SetErrorMessage( msg );