The components and how they are connected are what creates your unique, electronic product. The components are the basic building blocks of that product. So what exactly is a component and where are they stored?
In the real world, components are tangible objects and are, therefore, relatively easy to identify. But in the virtual world of design, components have to be abstracted into a range of models that can be used across the various design domains. During the design capture and implementation processes, a component is represented as a symbol on the schematic, as a footprint on the PCB, as a SPICE model for simulation, as a signal integrity description to analyze the quality of the signals, and as a three-dimensional model for 3D component and PCB visualization. One component, with a different representation for each design domain.
Each design domain requires a specialized model. For schematic capture, the model is referred to as a symbol. Because the design environment is built around the idea that the design starts with the schematic, the schematic symbol is used to tie the various models together.
Parameters then add the additional detail needed to identify the real-world physical component, such as the wattage, tolerance, purchasing details, datasheet references, etc.
Each type of model and component needs to be stored in a model file or library. Some of these use a standardized file format, like SPICE, while others use a proprietary format, like the SchLib file used to store schematic symbols or components.
Some model kinds, like SPICE, are stored one-model-per-file, these are referred to as model files. Others, like Altium PCB footprints, are stored in a file that accepts one or many footprints, these are referred to as model libraries.
Supporting the broad range of the design tasks performed through the electronic development process requires numerous model-kinds and library formats.
Below is a summary of each model and library kind.
|Design Domain||Model or Library Kind||File Extension||Notes|
|Schematic capture||Symbol||*.SchLib||Altium schematic symbol - can be just a symbol, or other models linked and parameters added to define a complete component.|
|PCB design||Footprint||*.PcbLib||Footprint or pattern that defines the components mounting and connection points on the PCB - can store both the fabricated elements (pads, silk, mask, etc.,) as well as an optional 3D representation of the fitted component.|
|3D PCB design||3D Body||*.PcbLib||Altium design object - place one or more 3D bodies on the footprint to build a 3D model of the component in the *.PcbLib file.|
|STEP||*.STEP, *.STP||Standard STEP format 3D model - can be imported into a PCB 3D Body object and placed on the footprint in the *.PcbLib file.|
|Parasolid 3D©||*.X_T, *.X_B||Parasolid format 3D model (ASCII or binary) - can be imported into a PCB 3D Body object and placed on the footprint in the *.PcbLib file.|
|SOLIDWORKS 3D©||*.SldPrt||SOLIDWORKS format 3D model - can be imported into a PCB 3D Body object and placed on the footprint in the *.PcbLib file.|
|Circuit simulation||SPICE3f5 / XSpice / PSpice model||*.mdl||SPICE 3f5 model file - describes a component's behavior using the SPICE syntax.|
|*.ckt||SPICE sub-circuit file - a SPICE-format netlist detailing a circuit that models the behavior of the component.|
|SimCode model||*.txt + *.mdl||ASCII Digital SimCode model file/library and the intermediate model linkage (MDL) file required to map the digital model to the symbol - used for modeling digital components in a mixed-signal circuit simulation.|
|*.scb + *.mdl||Compiled Digital SimCode model file/library and the intermediate model linkage (MDL) file required to map the digital model to the symbol - used for modeling digital components in a mixed-signal circuit simulation.|
|Signal Integrity analysis||IBIS model||*.ibis||Input/output Buffer Information Specification file - a behavioral model that describes the electrical characteristics of an input or output pin.|
|Component creation||Altium Integrated Library||*.IntLib||Compiled library - stores all model kinds within it. An IntLib is the compiled output from a LibPkg project.|
|Component creation||Altium database linked library||*.DbLink||Database link interface file - uses parametric data stored in SchLib components, to query an external ODBC data source for a suitable record (e.g., a part number, or the resistance, wattage and package). The data from fields mapped in the DbLink is retrieved and added to the component during placement.|
|Component creation||Altium database library||*.DbLib||Database library file - presents an external ODBC data-source as an Altium component library, allowing components to be placed directly from the database. The data from fields mapped in the DbLib is retrieved and added to the component during placement. Requires the Altium models (symbol, footprint, etc.,) to be specified in each database record.|
|*.SVNDbLib||DbLib with version control - interfaces to an SVN repository for version control of the schematic and PCB models.|
A component can range from something simple, like a two-pin resistor, to a large FPGA with hundreds and hundreds of pins. To give flexibility over how the components can be organized on the schematic sheets, the software includes a number of useful, display-related features.
Once you have linked in other domain models and add parameters, the symbol becomes a component. Many designers continue to refer to it as a symbol when they see it on the schematic because that's what they see but attached to that symbol are the other domain models and parametric details that define it as a component. This document uses the term symbol to describe the graphical objects and pins that are placed in the schematic library editor. In all other situations, it is referred to as the component.
The symbol is created in the schematic library editor. As soon as you add a link in models and add parameters, it becomes a component. The component detail can be added in the schematic library editor, or if you use a DbLink or DbLib type library, the detail can be extracted from a database and added to the symbol during placement on the schematic (more on these later). Alternatively, the detail can be added after the symbol has been placed on the schematic sheet.
The symbol is created in the schematic library editor. It is created by placing graphical objects to build the required shape then the pins are added. It is the pins that bring electrical intelligence to the component. They are what the software identifies as the electrical connection points and what are mapped to the pads on the PCB footprint.
Notes about symbol creation:
The software supports different display representations of the same component. For example, some of your customers might prefer to have their resistors drawn as a rectangle, while others prefer a wavy line.
Each of these representations is referred to as a display Mode. You can define additional symbolic representations for a component by adding a new Mode, either from the schematic library editor Tools menu or via the Mode toolbar (right-click on the menu bar to control the display of toolbars).
The required mode is chosen when the component is placed from the library onto the schematic sheet using the Mode selector in the Graphical region of the Properties panel. The default placement mode is the mode that was displayed in the library editor when the library was last saved.
In some instances, it is more appropriate to divide the component into a number of symbols, each of which is referred to as a Part. Examples include each resistor in a resistor network; the coil and contact sets in a relay; each I/O bank in a large FPGA; or each pin in a connector, for example, if you prefer to place connector pins throughout the sheet, rather than routing the wiring to a single connector symbol.
These components are referred to as multi-part components. Each part is drawn individually in the schematic library editor and pins are added accordingly. The image below shows the same resistor network drawn as a single part then as four separate parts.
Notes on working with multi-part components:
In a design environment, you may also need to create design entities that are not necessarily components that will be mounted on the finished PCB. For example, there might be an external module that connects to the board that you would like to draw as a component and include on the schematic for design clarity but you do not want this to be included in the BOM for this board. Or there might be mechanical hardware, such as a heat sink and mounting screw that must be included in the BOM but you do not want to include on the schematic.
These situations are managed by setting the component's Type. For the example just described, the component type could be set to
Graphical. Another special class of component would be a test point – this component is required on both the schematic and the PCB. It should be checked during design synchronization but is not required in the BOM. In this case, the component Type is set to
Standard (No BOM).
As well as being used to determine if a component should be included in the BOM, the Type field is also used to determine how that component is managed during component synchronization. All of the
Net Tie and
Jumper Types are fully synchronized, meaning the component is passed from the schematic to the PCB and the net connectivity is checked. For the Mechanical and Graphical Type, the component is not passed from schematic to PCB. If a component with one of these types has been placed manually in the PCB and the matching Type option has been chosen, then component-level synchronization is performed but no net-level connectivity checks are performed.
Refer to the Component mode of the Properties panel for detailed information about the various Type options.
Much of the detail that describes a component is defined as parameters. Parameters allow you to define additional textual information about the component. This can include electrical specifications (i.e. wattage or tolerance), purchasing or stock details, designer notes, references to component datasheets - basically any purpose you choose.
Parameters can be defined in the schematic library editor during component creation. They can be added automatically during placement if the component is placed from a database-type library (more on this later), or they can be added manually once the component has been placed on the schematic.
For an individual component, parameters are added in the Parameters region of the Properties panel (in Component mode). As mentioned, this can be done in the library or once the component has been placed on the schematic sheet.
User-defined parameters can be displayed on the schematic alongside the component, if required, by clicking the visibility icon () next to the parameter name. Edit the visible parameter to enable the display of the parameter name as well.
The Parameters region of the Properties panel (in Component mode) allows you to add a link by clicking the Add drop-down then selecting Link. This feature can be used to include links to a datasheet or a manufacturer website, for example. Any number of links can be defined for a component.
Links displayed in the panel are live, so when you click on the link text, the URL will load into your preferred browser. To edit an existing link, click anywhere in the cell away from the link text then click the edit button.
Links can be accessed via the context menu when you right-click on the placed schematic component.
Links can also be included in a PDF generated from the schematic, either via the Smart PDF feature or a PDF generated from an OutputJob file. The image below shows how the list of component parameters display in the PDF. Any that are URLs can be clicked on to browse from the PDF to that location.
The default component parameters that are displayed on the schematic are the Designator and Comment. When the design is transferred from the schematic editor to the PCB editor, the Designator and Comment strings are also the default strings that can easily be displayed on the board.
To allow you to display the value of any component parameter on the schematic and PCB, for example, to display the value of a parameter called Capacitance, you can map any component parameter into the component's Comment field using a technique known as string indirection.
This is done by entering the parameter name in the form
=ParameterName. For example, to map the value of the component parameter Capacitance into the component's Comment field, enter the string
=Capacitance into the Comment field of the Properties panel, as shown below. A string defined using this syntax,
=ParameterName, is referred to as a special string.
Special strings are automatically converted for on-screen display. If a parameter that is mapped as a special string does not have a value, the parameter name is displayed in a gray color instead if the Display Names of Special Strings that have No Value Defined option is enabled on the Schematic - Graphical Editing page of the Preferences dialog. If this option is disabled, nothing is displayed.
Parameters are a key element of each component, and it is common for many of the parameters to be used across multiple components. As well as adding them individually to each component, you can also use the Parameter Manager command (Tools » Parameter Manager) to add them to multiple components. As well as adding removing parameters, the values of parameters can also be edited across multiple components.
Notes about editing multiple parameters:
Main article: Linking to Supplier Data
From the electronic product designer's perspective, one of the most important aspects of component creation is linking from that component to the real-world component that it represents. This linkage can range from entering the component's Part Number as a component parameter to linking to the purchased component in your company database via a DbLink or DbLib file (details below). Another approach is to link directly from the design component to the component's supplier via the Linking to Supplier Data feature.
The key to linking to supplier data is a pair of component parameters, namely Supplier n and Supplier Part Number n. Using these, the software connects to the Altium cloud services where it can access detailed information about the part including manufacturer, manufacturer part number, price, voltage rating, etc. The software has direct access to web-hosted information for a number of major component suppliers and are configured on the Data Management - Parts Providers page of the Preferences dialog.
Your interface into the supplier linking feature is the Manufacturer Part Search panel. Click the Panels button at the bottom right of the design workspace then select Manufacturer Part Search to open the panel.
To work with the panel:
Supplier links can be added to an existing component, or a new component can be created by configuring the workspace as described below then right-clicking on the component in the Manufacturer Part Search panel and selecting the appropriate command.
To work between the panel and a:
At the schematic stage, the design is a collection of components that have been connected logically. To test or implement the design, for example, circuit simulation, PCB layout, signal integrity analysis, etc., it needs to be transferred to another design domain. To achieve this, there must be a suitable model of each component for the target domain.
As part of the process of linking the model, information about the component must be mapped from the schematic to the target model.
The domain-specific information resides in model files that have a predefined format, such as IBIS, MDL and CKT files. There is other information needed for the system to access that domain-specific information, such as the pin-mapping and net listing between the schematic symbol and the domain-specific model. This information is defined in a domain-specific model editor, which opens when a model is added or edited. As well as referencing the model file, it will also include any pin mapping or netlisting information required for that model kind.
At the top of each model dialog there is a Name field, which must contain the name of the model file. You can enter the name directly or use the Browse button to find it. At the bottom of the dialog, there is a text string that shows where that model was found.
The software's ability to find the model is influenced by the setting that defines where it can look for models. This is the setting just below the model name. The label of this area of the dialog will change depending on the model type. The options range from Any, meaning search all available libraries for this model, to Integrated Library or Server, which indicates that the model can only be used from the specified integrated library or server.
Although they vary slightly from one model type to another, the model editor dialogs generally include these options:
|Library Option||Behavior||Dialog Setting|
|Any||Searches all available libraries for a matching model.|
|Library name||Only searches available libraries of this name for a matching model.|
|Library path||Only searches a library of this name, in this location, for a matching model.|
|Integrated library||Only searches for the model in the integrated library that the component was placed from. The integrated library must be available.|
|Server||Only searches for the model in the server from which this component was placed from. The software must be connected to that server.|
Managed components are placed directly from a managed content server. Once a connection to the server has been made, you can browse or search for a component in the Components panel. For a managed component, the model location setting is Use <ModelKind> from component library <ServerName>.
The most common approach for traditional library-based component models is that they are sourced from any of the libraries that are currently available. This is the function of the Any setting detailed above, which searches for the named model in all available libraries.
The list of available models and libraries is managed in the Available File-based Libraries dialog. Open the dialog by clicking in the Components panel then selecting File-based Libraries Preferences.
The dialog has three tabs. All of the libraries and model locations defined in these tabs are collated to make up your list of available libraries. When an action is performed that requires searching for a model, such as transferring the design from schematic to PCB layout, the libraries are searched in the order of the tabs, then within each tab in the order that the libraries/models are listed. As soon as the correct model is located, the searching process ceases.
Libraries that are part of the current project are listed under the Project tab of the Available File-based Libraries dialog when that project is the active project in the software. The advantage of project libraries is that whenever the project is opened, the model/libraries will automatically become available. The disadvantage is if the models/libraries are not stored in the same project folder structure as the design files, they can easily be forgotten if the project files are moved.
Libraries and models that have been made available in your installation of the software are referred to as installed libraries. These are listed in the Installed tab of the Available File-based Libraries dialog. These models/libraries are available for any design currently open in your installation of the software. Note that this list of libraries is saved with the environment, not with any of the open projects.
Installed Libraries can be listed using an absolute path, or a path relative to the Library Path Relative To: setting. The advantage of using a relative path is that this lets you create a common sub-environment across multiple PCs and you can therefore easily move the design files between them. Additionally, installed libraries can be temporarily deactivated by clearing the Activated checkbox rather than needing to be removed.
The Search Path tab presents a list of libraries that have been located according to the path settings defined on the Search Paths tab of the Project Options dialog, which is accessed by clicking the Paths button in the Search Paths tab in the Available File-based Libraries dialog. Each search path defines a folder and can include sub-folders if the Recursive option is enabled (available on the Search Paths tab of the Project Options dialog after a path is added). All model and library files found on the search path will be available. Search paths are saved with the project.
Retrieving models using search paths can be slow if there are a large number of files in the search path folder(s). For this reason it is not recommended to use this approach for PCB libraries as they can be large files containing many footprints. The feature was developed to provide a way of referencing available simulation and signal integrity models.
When a component is placed from a library into a design, it is cached in the design file so that the document can still be opened at any location without requiring its source libraries to be present or loaded. This is helpful when moving a design from one location to another, since it is not necessary to move the libraries as well. Note that the original source library name and the model names are also stored within the placed component's properties.
Models and components are stored in libraries. Altium's design software supports a number of different types of libraries. How do you decide which library type is best for your company?
In the early days of electronic design automation, there were two design domains: schematic capture and PCB layout. The outputs from schematic capture were a set of printed schematic sheets and the outputs from the PCB layout were the PCB fabrication and assembly files.
To support this, the designer needed to be able to create and store the schematic symbols, ready to be placed on the schematic sheet. Details such as the component's value, voltage, wattage, footprint, etc., were often added after the symbol was placed from the symbol library onto the schematic sheet.
As for the footprints, the focus of the editing capabilities was implementing the design as a set of layers that contain the shapes needed for the photo-tools. This output-driven focus dictated what shapes were supported, down to the font used for the designator and other silkscreen strings.
These simple symbols and footprints were created and stored in libraries, with both types initially having the file extension *.Lib. Once Windows relaxed the three-character limit on file extensions, these were changed to *.SchLib for schematic symbols and *.PcbLib for footprints.
Main article: Working with Integrated Libraries
Over time, there was a growing desire to be able to separate the component creation process from the product design process. Instead of adding the component detail after the symbol had been placed on the schematic sheet, design teams wanted to fully define the component in the library. Other design domains, such as circuit simulation, were also being developed, and therefore, models for these domains also needed to be supported. As part of creating ready-to-use components, you also need to be able to verify the symbol-to-model mapping, then deliver these components in a single, ready-to-use library file.
To satisfy these requirements, the integrated library (*.IntLib) was developed. The integrated library carries all model kinds in a single file. The source for an integrated library is a library package (*.LibPkg), which is a design project that brings together the source symbols, footprints and simulation models. When the library package project is compiled, the symbol-to-model mapping is verified and the Integrated Library is created. Using an IntLib means that the library becomes something from which you place ready-to-use components, which delivers a good solution for medium to large organizations that want to separate component creation from product design.
Main article: Working with Database Libraries
The integrated library delivered a good alternative to simple model libraries and solved the challenge of managing the component data separately from the product design process. What it did not solve was the ever-increasing desire to create a bridge between the electronic design domain and the broader company component data systems. To solve this challenge, there needs to be a way of linking from the component into the company database.
This is not a trivial problem to solve as there is no single approach used to define, store and manage large volumes of component data. The databases that companies use are varied, and are often custom-built to suit the needs of that organization. To provide a connection from the electronic design environment into a company database, the ODBC standard was chosen.
To create the link, a new interface file was developed, known as the Database Link file (*.DbLink). Strictly speaking, this is not a library. Instead, it is a project settings file that provides an interface between the parametric data in the design components (stored in standard model libraries) and the records in the database. Database records can be queried either by using a single key lookup, such as a part number, or a user-defined Where clause. By using a Where clause, the designer does not need to search the database, find the part number, and include it in their schematic component. Instead, they define a where clause that queries the database based on component data, such as the Value, Voltage, Current, Footprint, etc.
The DbLink file defines the:
Using this approach, you can have simple design libraries, particularly for discrete components. For example, your capacitor library might have a single capacitor component. The designer places the capacitor on the schematic, enters the capacitance, voltage and tolerance, and selects the required footprint from a list of pre-defined footprints. They then query the database. The Where clause defined in the DbLink file is used to create an ODBC query, the database is queried, and returns the requested data from the found record, such as the part number, relevant company BOM data, etc., which is added to the placed component.
The simple, generic component that was placed is now a fully described, BOM-ready company component.
The strength of this approach is that it gives a view into the company's component database without requiring electronic design-type data to be entered into that database. The ability to use a Where clause also means that you are free to place a loosely-specified (generic) component that does not get locked down until you perform the query process. The database can be queried at any time during the design process, including during BOM generation, when additional database parameters can also be added.
Main article: Working with Database Libraries
The Database Link document delivered an excellent solution for connecting the company component data directly into the electronic design components. However, for companies that want to create a one-to-one link between the company component record and the design component (using a single key lookup, typically the component part number), using a DbLink requires the design librarian or designer to manually trawl through the database, extract the part number, and add it into each design component.
These companies want a data-centric solution rather than the design-software-centric solution delivered by the DbLink file.
To deliver this, the Database Library (*.DbLib) was developed. The DbLib allows the component record in the database to be the component. Rather than operating as a linkage file between the electronic design library and the company database, the DbLib installs as a design library, sourcing its data from the company database and displaying it directly in the Components panel.
The DbLib is installed in the same way as a schematic library or an integrated library. Acting as a window between the design environment and the company database, it displays data sourced directly from the company database inside the design environment. Using a DbLib, the designer is able to browse or search component records and place a component directly from the database into their design. When the Place button is clicked, the symbol referenced in that record is located in the SchLib, and the mapped data loaded into the component's parameters. In essence the electronic design component is assembled as it is being placed on the schematic sheet.
This approach requires the database records to include references to the electronic design models (symbol, footprint, simulation model, etc.). The models themselves continues to reside in standard Altium libraries, such as SchLibs and PcbLibs.
Another common requirement of larger companies is to be able to version control the intellectual property that the company creates. A Version Control System (VCS) is an excellent way of managing changing electronic data as well as holding a secure copy of the last committed version of your data, it also allows you to roll-back to any previous version.
Working with an SVNDbLib is essentially the same as working with a DbLib. Install the SVNDbLib as a library using the Available File-based Libraries dialog. The only difference is that the models are under version control. That means the models must be stored in a repository and a working copy checked out. It is the working copy that is displayed in the Components panel and used when the Place button is clicked.
The use of the version-controlled models is transparent. Place the required component from the Components panel. To ensure that the latest revision of a model is placed, whenever the Place button is clicked the repository is queried and if necessary, the working copy of the model is automatically updated. The working copy can also be refreshed at any time via the Components panel right-click context menu.
The management of the version-controlled models is also straightforward. You can edit a model via the context menu in the Components panel. Right-click on a component in the list to edit the symbol; right click on a footprint in the model list to edit that footprint. Once editing is complete, the model file is saved. You then right-click on the model's name in the Projects panel and use the Version Control sub-menu to commit the changes to the repository. Your changes will immediately be visible in the Components panel.
Main article: Working with Managed Components
Each of the component storage systems described so far requires you to organize all of the various elements, including creating the models, components and libraries, managing their versioning and history, and maintaining the connections into the supply chain. For this reason, these components are referred to as unmanaged components because the software does not provide integrated support for all of these tasks.
Altium appreciates that designers would be far more efficient if there were software solutions that bring these diverse elements together, particularly when the designers are part of a larger, dispersed team. An integrated solution was developed and the concept of the managed component was born.
To deliver managed components (and other design content) requires:
Altium includes a comprehensive, globally-accessible, electronic design-oriented, data storage and access (server) system, which is accessed through the Explorer panel.
A managed component references all of the required design domain models with visible and traceable history and lifecycle and is also coupled into the component supply chain. Each managed component can be raised from being a simple design component to being a truly unified component by adding part choices to it - essentially choosing which real-world manufactured part(s) can be used for that component on the assembled board. Supply chain intelligence is coupled, in real-time, courtesy of configured part sources, of which the default source (the Altium Parts Provider) provides an aggregate parts database, which itself interfaces to and gathers the parts from enabled Suppliers. Supplier, price, stock levels, minimum order quantities - all of the typical supply chain details, are available for managed components. You can then include this real-time data directly in your BOM using an ActiveBOM.