diff options
Diffstat (limited to 'eeschema/class_netlist_object.h')
| -rw-r--r-- | eeschema/class_netlist_object.h | 483 |
1 files changed, 483 insertions, 0 deletions
diff --git a/eeschema/class_netlist_object.h b/eeschema/class_netlist_object.h new file mode 100644 index 0000000..3e726d4 --- /dev/null +++ b/eeschema/class_netlist_object.h @@ -0,0 +1,483 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr + * Copyright (C) 2013 Wayne Stambaugh <stambaughw@verizon.net> + * Copyright (C) 1992-2013 KiCad Developers, see AUTHORS.txt for contributors. + * + * 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, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/** + * @file class_netlist_object.h + * @brief Definition of the NETLIST_OBJECT class. + */ + +#ifndef _CLASS_NETLIST_OBJECT_H_ +#define _CLASS_NETLIST_OBJECT_H_ + + +#include <sch_sheet_path.h> +#include <lib_pin.h> // LIB_PIN::PinStringNum( m_PinNum ) +#include <sch_item_struct.h> + +class NETLIST_OBJECT_LIST; +class SCH_COMPONENT; + + +/* Type of Net objects (wires, labels, pins...) */ +enum NETLIST_ITEM_T +{ + NET_ITEM_UNSPECIFIED, // only for not yet initialized instances + NET_SEGMENT, // connection by wire + NET_BUS, // connection by bus + NET_JUNCTION, // connection by junction: can connect to + // or more crossing wires + NET_LABEL, // this is a local label + NET_GLOBLABEL, // this is a global label that connect all + // others global label in whole hierarchy + NET_HIERLABEL, // element to indicate connection to a + // higher-level sheet + NET_SHEETLABEL, // element to indicate connection to a + // lower-level sheet. + NET_BUSLABELMEMBER, /* created when a bus label is found: + * the bus label (like DATA[0..7] is + * converted to n single labels like + * DATA0, DATA1 ... + * These objects are living only in the current + * NETLIST_OBJECT_LIST, not in shematic. + */ + NET_GLOBBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a + // global bus label is found + NET_HIERBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a + // hierarchical bus label is found + NET_SHEETBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a + // pin sheet label using bus notation + // is found + NET_PINLABEL, /* created when a pin is POWER (IN or + * OUT) with invisible attribute is found: + * these pins are equivalent to a global + * label and are automatically connected + */ + NET_PIN, // this is an usual pin + NET_NOCONNECT // this is a no connect symbol +}; + + +/* Values for .m_FlagOfConnection member */ +enum NET_CONNECTION_T +{ + UNCONNECTED = 0, /* Pin or Label not connected (error) */ + NOCONNECT_SYMBOL_PRESENT, /* Pin not connected but have a NoConnect + * symbol on it (no error) */ + PAD_CONNECT /* Normal connection (no error) */ +}; + + +class NETLIST_OBJECT +{ +public: + NETLIST_ITEM_T m_Type; /* Type of item (see NETLIST_ITEM_T enum) */ + EDA_ITEM* m_Comp; /* Pointer to the library item that + * created this net object (the parent) + */ + SCH_ITEM* m_Link; /* For SCH_SHEET_PIN: + * Pointer to the hierarchy sheet that + * contains this SCH_SHEET_PIN + * For Pins: pointer to the schematic component + * that contains this pin + */ + int m_Flag; /* flag used in calculations */ + SCH_SHEET_PATH m_SheetPath; // the sheet path which contains this item + SCH_SHEET_PATH m_SheetPathInclude; // sheet path which contains the hierarchical label + int m_ElectricalType; /* Has meaning only for Pins and + * hierarchical pins: electrical type */ + int m_BusNetCode; /* Used for BUS connections */ + int m_Member; /* for labels type NET_BUSLABELMEMBER ( bus member + * created from the BUS label ) member number. + */ + NET_CONNECTION_T m_ConnectionType; // Used to store the connection type + long m_PinNum; // pin number ( 1 long = 4 bytes -> 4 ascii codes) + wxString m_Label; // Label text (for labels) or Pin name (for pins) + wxPoint m_Start; // Position of object or for segments: starting point + wxPoint m_End; // For segments (wire and buses): ending point + +private: + int m_netCode; /* net code for all items except BUS + * labels because a BUS label has + * as many net codes as bus members + */ + NETLIST_OBJECT* m_netNameCandidate; /* a pointer to a label connected to the net, + * that can be used to give a name to the net + * or a pin if there is no label in net + * When no label, the pin is used to build + * default net name. + */ + +public: + +#if defined(DEBUG) + void Show( std::ostream& out, int ndx ) const; // override + +#endif + + NETLIST_OBJECT(); + NETLIST_OBJECT( NETLIST_OBJECT& aSource ); // Copy constructor + + ~NETLIST_OBJECT(); + + // Accessors: + void SetNet( int aNetCode ) { m_netCode = aNetCode; } + int GetNet() const { return m_netCode; } + + /** + * Set the item connection type: + * UNCONNECTED Pin or Label not connected (error) + * NOCONNECT_SYMBOL_PRESENT Pin not connected but have a NoConnect + * symbol on it (no error) + * PAD_CONNECT Normal connection (no error) + */ + void SetConnectionType( NET_CONNECTION_T aFlg = UNCONNECTED ) + { + m_ConnectionType = aFlg; + } + + NET_CONNECTION_T GetConnectionType() + { + return m_ConnectionType; + } + + /** + * Set m_netNameCandidate to a connected item which will + * be used to calcule the net name of the item + * Obviously the candidate can be only a label + * when there is no label on the net a pad which will + * used to build a net name (something like Cmp<REF>_Pad<PAD_NAME> + * @param aCandidate = the connected item candidate + */ + void SetNetNameCandidate( NETLIST_OBJECT* aCandidate ); + + /** + * @return true if an item has already a net name candidate + * and false if not ( m_netNameCandidate == NULL ) + */ + bool HasNetNameCandidate() { return m_netNameCandidate != NULL; } + + /** + * Function GetPinNum + * returns a pin number in wxString form. Pin numbers are not always + * numbers. \"A23\" would be a valid pin number. + */ + wxString GetPinNumText() + { + // hide the ugliness in here, but do it inline. + return LIB_PIN::PinStringNum( m_PinNum ); + } + + /** For Pins (NET_PINS): + * @return the schematic component which contains this pin + * (Note: this is the schematic component, not the library component + * for others items: return NULL + */ + SCH_COMPONENT* GetComponentParent() const + { + if( m_Link && m_Link->Type() == SCH_COMPONENT_T ) + return (SCH_COMPONENT*) m_Link; + + return NULL; + } + + /** + * Function IsLabelConnected + * tests if the net list object is a hierarchical label or sheet label and is + * connected to an associated hierarchical label or sheet label of \a aNetItem. + * + * @param aNetItem A pointer to a NETLIST_OBJECT to test against. + * @return A bool value of true if there is a connection with \a aNetItem or false + * if no connection to \a aNetItem. + */ + bool IsLabelConnected( NETLIST_OBJECT* aNetItem ); + + /** + * Function IsLabelGlobal + * @return true if the object is a global label + * (i.e. an real global label or a pin label coming + * from a power pin invisible + */ + bool IsLabelGlobal() const; + + /** + * Function IsLabelBusMemberType + * @return true if the object is a bus label member build from a + * schematic bus label (like label[xx..yy], xx and yy are the first and last + * bus member id) + * bus label members have specific properties: + * they do not live in schematic + * they have specific properties in connections: + * 2 bus label members can be connected connected only if they have the same member value. + */ + bool IsLabelBusMemberType() const; + + /** + * Function IsLabelType + * @return true if the object is a label of any type + */ + bool IsLabelType() const; + + /** + * Function GetNetName + * @return the full net name of the item, i.e. the net name + * from the "best" label, prefixed by the sheet path + */ + wxString GetNetName() const; + + /** + * Function GetShortNetName + * @return the short net name of the item i.e. the net name + * from the "best" label without any prefix. + * 2 different nets can have the same short name + */ + wxString GetShortNetName() const; + + /** + * Function ConvertBusToNetListItems + * breaks the text of a bus label type net list object into as many members as + * it contains and creates a #NETLIST_OBJECT for each label and adds it to \a + * aNetListItems. + * + * @param aNetListItems A reference to vector of #NETLIST_OBJECT pointers to add + * the bus label NETLIST_OBJECTs. + */ + void ConvertBusToNetListItems( NETLIST_OBJECT_LIST& aNetListItems ); +}; + + +/** + * Type NETLIST_OBJECTS + * is a container referring to (not owning) NETLIST_OBJECTs, which are connected items + * in a full schematic hierarchy. It is useful when referring to NETLIST_OBJECTs + * actually owned by some other container. + */ +typedef std::vector<NETLIST_OBJECT*> NETLIST_OBJECTS; + + +/** + * Class NETLIST_OBJECT_LIST + * is a container holding and _owning_ NETLIST_OBJECTs, which are connected items + * in a full schematic hierarchy. It is helpful for netlist and ERC calculations. + */ +class NETLIST_OBJECT_LIST : public NETLIST_OBJECTS +{ + int m_lastNetCode; // Used in intermediate calculation: last net code created + int m_lastBusNetCode; // Used in intermediate calculation: + // last net code created for bus members + +public: + /** + * Constructor. + * NETLIST_OBJECT_LIST handle a list of connected items. + * the instance can be owner of items or not. + * If it is the owner, the items are freeed by the destructor + * @param aIsOwner true if the instance is the owner of item list + * (default = false) + */ + NETLIST_OBJECT_LIST() + { + // Do not leave some members uninitialized: + m_lastNetCode = 0; + m_lastBusNetCode = 0; + } + + ~NETLIST_OBJECT_LIST(); + + /** + * Function BuildNetListInfo + * the master function of tgis class. + * Build the list of connected objects (pins, labels ...) and + * all info to generate netlists or run ERC diags + * @param aSheets = the flattened sheet list + * @return true if OK, false is not item found + */ + bool BuildNetListInfo( SCH_SHEET_LIST& aSheets ); + + /** + * Acces to an item in list + */ + NETLIST_OBJECT* GetItem( unsigned aIdx ) const + { + return *( this->begin() + aIdx ); + } + + /** + * Acces to an item type + */ + NETLIST_ITEM_T GetItemType( unsigned aIdx ) const + { + return GetItem( aIdx )->m_Type; + } + + /** + * Acces to an item net code + */ + int GetItemNet( unsigned aIdx ) const + { + return GetItem( aIdx )->GetNet(); + } + + NET_CONNECTION_T GetConnectionType( unsigned aIdx ) + { + return GetItem( aIdx )->GetConnectionType(); + } + + /** + * Set the item connection type: + * UNCONNECTED Pin or Label not connected (error) + * NOCONNECT_SYMBOL_PRESENT Pin not connected but have a NoConnect + * symbol on it (no error) + * PAD_CONNECT Normal connection (no error) + */ + void SetConnectionType( unsigned aIdx, NET_CONNECTION_T aFlg = UNCONNECTED ) + { + GetItem( aIdx )->SetConnectionType( aFlg ); + } + + /** Delete all objects in list and clear list */ + void Clear(); + + /** + * Reset the connection type of all items to UNCONNECTED type + */ + void ResetConnectionsType() + { + for( unsigned ii = 0; ii < size(); ii++ ) + GetItem( ii )->SetConnectionType( UNCONNECTED ); + } + + /* + * Sorts the list of connected items by net code + */ + void SortListbyNetcode(); + + /* + * Sorts the list of connected items by sheet. + * This sorting is used when searching "physical" connection between items + * because obviously only items inside the same sheet can be connected + */ + void SortListbySheet(); + + + #if defined(DEBUG) + void DumpNetTable() + { + for( unsigned idx = 0; idx < size(); ++idx ) + { + GetItem( idx )->Show( std::cout, idx ); + } + } + + #endif + +private: + /* + * Propagate aNewNetCode to items having an internal netcode aOldNetCode + * used to interconnect group of items already physically connected, + * when a new connection is found between aOldNetCode and aNewNetCode + */ + void propageNetCode( int aOldNetCode, int aNewNetCode, bool aIsBus ); + + /* + * This function merges the net codes of groups of objects already connected + * to labels (wires, bus, pins ... ) when 2 labels are equivalents + * (i.e. group objects connected by labels) + */ + void labelConnect( NETLIST_OBJECT* aLabelRef ); + + /* Comparison function to sort by increasing Netcode the list of connected items + */ + static bool sortItemsbyNetcode( const NETLIST_OBJECT* Objet1, const NETLIST_OBJECT* Objet2 ) + { + return Objet1->GetNet() < Objet2->GetNet(); + } + + /* Comparison routine to sort items by Sheet Number + */ + static bool sortItemsBySheet( const NETLIST_OBJECT* Objet1, const NETLIST_OBJECT* Objet2 ) + { + return Objet1->m_SheetPath.Cmp( Objet2->m_SheetPath ) < 0; + } + + /** + * Propagate net codes from a parent sheet to an include sheet, + * from a pin sheet connection + */ + void sheetLabelConnect( NETLIST_OBJECT* aSheetLabel ); + + void pointToPointConnect( NETLIST_OBJECT* aRef, bool aIsBus, int start ); + + /** + * Search connections between a junction and segments + * Propagate the junction net code to objects connected by this junction. + * The junction must have a valid net code + * The list of objects is expected sorted by sheets. + * Search is done from index aIdxStart to the last element of list + */ + void segmentToPointConnect( NETLIST_OBJECT* aJonction, bool aIsBus, int aIdxStart ); + + + /** + * Function connectBusLabels + * Propagate the net code (and create it, if not yet existing) between + * all bus label member objects connected by they name. + * Search is done in the entire list + */ + void connectBusLabels(); + + /** + * Set the m_FlagOfConnection member of items in list + * depending on the connection type: + * UNCONNECTED, PAD_CONNECT or NOCONNECT_SYMBOL_PRESENT + * The list is expected sorted by order of net code, + * i.e. items having the same net code are grouped + */ + void setUnconnectedFlag(); + + /** + * Function findBestNetNameForEachNet + * fill the .m_NetNameCandidate member of each item of aNetItemBuffer + * with a reference to the "best" NETLIST_OBJECT usable to give a name to the net + * If no suitable object found, .m_NetNameCandidate is filled with 0. + * The "best" NETLIST_OBJECT is a NETLIST_OBJECT that have the type label + * and by priority order: + * the label is global or local + * the label is in the first sheet in a hierarchy (the root sheet has the most priority) + * alphabetic order. + */ + void findBestNetNameForEachNet(); +}; + + +/** + * Function IsBusLabel + * test if \a aLabel has a bus notation. + * + * @param aLabel A wxString object containing the label to test. + * @return true if text is a bus notation format otherwise false is returned. + */ +extern bool IsBusLabel( const wxString& aLabel ); + +#endif // _CLASS_NETLIST_OBJECT_H_ |