Database library altium

Database library altium DEFAULT

Author Topic: Database library problems  (Read times)

0 Members and 1 Guest are viewing this topic.


Share me

Digg  Facebook  SlashDot  Delicious  Technorati  Twitter  Google  Yahoo

Smf


 


There was an error while thanking

Thanking


Sours: https://www.eevblog.com/forum/altium/database-library-problems/

CELESTIAL ALTIUM LIBRARY IS
EASY, 3D, PROFESSIONAL, POWERFUL, COMPREHENSIVE

Over components! Open Source & free.

GET STARTED NOW

The largest collection of high quality production ready components that are supplier linked.
Build your products with real, sourceable components that fit and reflow perfectly during prototype and production.

Design

Designed for production use. Symbols and Footprints are real world proven.

1

Cloud Hosted

The Database is hosted in the cloud with no software required on your computer.

BOM Export

Place real parts from a supplier. Your BOM will be fully populated ready to the order parts you placed.

Pick and Place

Component centres are the correct spot for a Pick and Place machine to collect the part, meaning less programming, less rework.

3D Models

Every part has a beautiful 3D model built to the manufacturers dimensions. Your board previews never looked so beautiful.

Footprint Size

Footprints are all sized to the manufacturers specifications. You can be sure the parts fit and reflow perfectly.

Part Search

Thanks to full parametric information and Altium's filtering, it's fast to find the appropriate component in the library.

Real Components

Placing real components protects you from adding a part or value combination that does not exist in the real world.

OVER USERS TRUST OUR DATABASE

Hundreds of Universities, Government and Private organisations rely on this library for their daily work. The library's high quality, accurate parts and excellent production success rates are strongly valued by our users.

GET STARTED

High Quality Data

This library was built to have the highest quality of data from the start. Fully accurate 3D Models, footprints and parametric data.

Never place a component value that doesn't exist again. Your BOM will generate with all the actual components you placed, complete with supplier links and supplier SKUs.

The library is production proven, footprints are designed to the manufacturers specifications so parts fit and reflow perfectly. Components pick and place correctly thanks to correct component centroid information.

Every part has complete parametric data (all the technical specs) as well as supplier and datasheet links available directly from within Altium.

Open Source Altium Database Library

Cloud hosted database gives you the largest selection of components from any database library available. Completely open source, and free to use in commercial projects. Save yourself the time of building libraries, get back to the business of designing electronics.

Try now, access is free!

Take the database library for a test run it's fully featured and ready to use. Registering an account is free, and always will be.

Get Started

Sours: https://altiumlibrary.com/
  1. Aluminum panels home depot
  2. Gerber knife
  3. Acer monitor sound bar
  4. Free smoking pipes
  5. Macbook pro essentials guide 2020

Celestial Altium Library

Library Component CountBuilt for AltiumWebsitePortal

The Celestial Altium Library is a massive, free, open source database library for Altium Designer created by Altium Industry Expert Mark Harris. The database is hosted on a dedicated cloud platform built for the library, to ensure you always have the latest components.

The Celestial Altium Library was designed from conception to contain high-quality data, with accurate footprints and exceptional 3D models. It is free to use, and open source. The Celestial Altium Library contains a vast array of components already, and is under active development to expand component coverage.

Build your next project faster, create beautiful schematics and stunning 3D PCBs with the Celestial Altium Library.

Love electronics? Need help with the library? Join us on Discord!

Discord

You can register for free access on the Altium Library Portal.

For full instructions, see the Celestial Library Website.

The Celestial Altium Library database is cloud-hosted; as new components are added to the library, they are immediately available in Altium. The library's schematic symbols and PCB footprints are hosted in GitHub allowing you to quickly clone the latest library files to your computer if they are needed for the new components.

A database library creates the linkage between a schematic symbol and PCB footprint on your computer, and also provides all of the technical parameters and pricing data for a component. This connection allows the library to contain every real-world capacitor, resistor, and other component types, with relatively few files on your computer.

Altium Database libraries make you design your schematic with the part you are going to use, rather than a generic schematic symbol/footprint combination. Rather than selecting "RJ45 Jack," you instead choose Amphenol Commercial Products part number RJCSE This component selection is reflected in your Bill of Materials - the entire BOM fills itself out, meaning no more trying to remember exactly what part you intended to put in there was, or what voltage that capacitor was. Even if you are using an ActiveBOM in your project, the library will save you time as you do not need to set component properties after placing each component.

Without the Celestial Altium Library, you might find yourself looking for passive components on supplier websites to find a low-cost option, and then searching for those parts in the Manufacturer Part Search panel in Altium. Once you find the part you want, you can assign the properties to the schematic symbol in your project. With the library, however, you can rapidly sort through thousands of components to narrow down the list of relevant parts and then place the cheapest in-stock option directly into your design - all with Altium. Components added with the library will generate an excellent bill of materials for your project with or without ActiveBOM.

Save time on the design, and significantly reduce errors by placing real-world parts directly from the library.

Data

All components in the database contain all relevant technical parameters, allowing you to search/filter within Altium for the part you require. If your design calls for a uF, 25V ceramic capacitor, open the ceramic capacitors list, group by value, then by voltage, and sort by price to find the cheapest option available.

enter image description here

Each component in the database contains a link to supplier pages and a link to the datasheet allowing rapid access to reference materials. As all technical parameters and pricing data is available, your BOM can be populated automatically with all relevant information for purchasing.

Footprints

Every component has a footprint that matches the manufacturer's recommended footprint, or if a recommendation is not available, an IPC Compliant footprint for the specific package sizing. Only highly standardized passive components utilize generic footprints; all other parts have manufacturer-specific land patterns.

Each footprint features a high quality, dimensionally accurate, correctly colored 3D model. Every 3D model in the library is created from scratch to the manufacturer's drawings. This attention to detail ensures excellent 3D collision checking and eases MCAD integration when designing enclosures and associated parts.

Every part's center position is where a pick and place machine's head should collect the component. For companies running an in house Pick and Place machine, this is very convenient and allows faster machine setup. Your pick and place export list for products built with the Celestial Altium Library contains centers in the correct location.

Symbols

Library symbols are standardized as much as possible. This standardization ensures you will find pins where you expect them to be, such as VCC in the top left, GND in the bottom left, user function pins on the right (controllable inputs/outputs). Standard protocols like SPI have the pins in the same order in every part where other library standards don't have a higher priority. All components within a database category have similar pin layouts/groupings where possible. This preciseness makes it extremely easy to read and follow schematics created with the library.

All passive components, such as resistors and capacitors, all have the same size symbol lead span, keeping your schematics tidy.

Want to contribute? Great! Join us on Discord and let the community know what you can do, we'll find something for you!

License

The library does not follow a specific open-source license. The Celestial Altium license is simple:

  • You may use this library commercially in contract work, products for sale, or any other commercial project not related to selling footprints/symbols/3D models.
  • You may not charge anyone for the footprints, 3D models, or schematic symbols contained in this library.
  • You should give your clients a copy of this library, and you must attribute the source back to this website.
  • You may not claim credit for the work in this library unless you have contributed it yourself.

Sours: https://github.com/issus/altium-library
Altium Database Library - Part 1

Trending AI Articles:

A telltale story of how I created an Altium Database library for our company with the help of Python programming.

How it started
Recently I had started a couple of small projects in our company. And while I was designing schematic and PCBs in Altium, there was a thing that was bothering me. As in most of the projects, most of the components in my projects were getting reused from our existing design. However, in order to use those components, I was having to recall which projects might have used the part which I was needing for my project, open its Altium project, copy the schematic symbol and footprint for the component from existing project’s library files, copy them in my new project’s library file and finally link newly pasted schematic symbol to PCB footprint. This in itself was annoying, but there were couple more things which were bothering me.
For cookie-cutter parts like SMD resistor and capacitors, we would be using a generic schematic symbol in schematic and assign one of the standard footprints we had created for them and then update value and company and manufacturer part number details. This was also time-consuming and error-prone as sometimes I would miss updating some of the details.
And thirdly, while in the middle of my new projects, we found out that one of the footprints we were using for an existing project was a little incorrect. It was for an oscillator component and there was a chance that one of the alternate parts we were using would not fit into our footprint. For this, I basically had to do the reverse process of what I had described earlier. I had created a new footprint for my project and had to update the existing project’s PCB library.
All these things finally lead me to start exploring about creating a centralized library for all EEs in our company. Incidentally, at the same time, I came across a presentation from Robert Feranec at Altium live (you can watch it here) in which he presented his survey about how libraries are maintained in different organizations. While there are lots of interesting things presented in the speech, the one thing which stood out to me was, as per Robert’s study, in almost all the companies it was always an initiative by one or two individual engineers which has led to the creation of centralized libraries. Someone starts by creating a library, presents it to the group and once the group and management see that it’s already in motion, then everyone starts using and contributing to it. And I knew it then and there itself that this is what was required for our company too. Something to get started with and then it will pick up the pace by itself. And hence, I decided to start creating an Altium component library for all the Electronic parts which were used by our company.

Step 1: Get all Company level part numbers
Most of the companies have their own part number system where the same parts (drop-in replacement to each other) are given just one company level part number. E.g. all 1KOhms W, 5% resistor will have the same xxx company part number. Luckily for me, our company had an excel file containing all the company level part numbers that are used by engineering, and that was all I needed to get started.
Result: Got all company level part numbers in an excel file.

Step 2: Get actual vendor details from company part numbers.
Our company uses an Oracle system to store all documentation. My next challenge was to get the actual manufacturer name and part numbers from our Oracle system for every part. This is where I started using Python. I specifically used pyautogui and openpyxl libraries. I didn’t automate from A to Z, as this was just for my one-time personal use and it was easier to click one button to open the tool once rather than write 10 lines of Python code. So, I opened our Oracle tool and ran a few lines of codes that will automate mouse movement and clicks. Unfortunately, as I couldn’t show you screenshots of our tool, I created a small gif using powerpoint to show the steps involved in getting vendor details from the tool.

Steps shown in the above gif can be coded in python with the help of pyautogui as will be explained below. But before we start to code, there is one thing which we need to know, and that is how to find the location of a particular element, like a button (Find Vendor details, Search and Close), text box, etc. on our PC screen. We can do that by just using a single line of code available in pyautogui, which is pyautogui.position(). Just place your mouse pointer on top of the button or text box whose location you want to find and run pyautogui.position() in your python terminal. For more information on how to use pyautogui, refer to their documentation here.

1. Natural Language Generation:
The Commercial State of the Art in

2. This Entire Article Was Written by Open AI’s GPT2

3. Learning To Classify Images Without Labels

4. Becoming a Data Scientist, Data Analyst, Financial Analyst and Research Analyst

And there I had it, an excel file with all company part numbers with corresponding vendor details. Well, as you could have imagined, not all parts had valid vendor details, and many of the parts were actually just internal documents or some mechanical components. As with any data engineering kind of job, I had to do clean up the data as we will see below.
Result: I had a file with the manufacturer name and part number updated against company part numbers.

Step 3: Remove internal document parts
Part numbers which were our internal documents (like row# 11 in the above screenshot) had our company’s part number itself in ‘Mfr Name’ field mentioned in the above step. So it was easy to filter them out. I just search for parts that had our company part number itself in vendor name and marked it with “Internal part / Document.” I used a script similar to that given below to get this result.

Result: Internal parts / Documents identified.

Step 4: Identify the component type.
I wanted to organize our database according to the type of components. This would allow engineers to search for a component from the database using its type and value. So as the first step for that, I had to go through each vendor part number, search for the component in Digikey and mark its type. In order to use a web browser (and Digikey website), we will be using webdriver module from selenium library in Python. You can learn more about this library here
The most important part in order to surf through a website using selenium is to find the ‘path’ of the element (again, like button, text box, etc.) on a webpage. It’s very much similar to how we had to find x, y location of button, etc. in the above section. There are multiple ways to find location/path of an element, one among them is to use something called ‘XPath’.
You can see the process of using XPath to find an element on a webpage in below couple of gifs.

Coming to the coding part, first I go to Digikey, search for the ‘search’ bar using it’s XPath, paste the manufacturer part number from my Company_Database excel file, and press enter. After waiting for a couple of seconds to allow the page to load, I would extract the type of component from the following field in the Digikey page. While looking for the best way to find the type of component, I had decided it would be best for me to use the classification used by Digikey itself, rather than me trying to decipher it from the part description. After a few long stares at Digikey pages for various components, I observed that Digikey will identify a component in the hierarchy of three levels. The Below picture shows how a Capacitor, Resistor, Crystal, and a Diode will be categorized in Digikey.

Once I saw this, then it was easy, I again ran through all parts (this time excluding parts marked as “Internal parts / Documents” and copied the third entry in the above-shown product categorization.
Result: All components now have a ‘Component Type’ associated with them.

Step 5: Get one Key parameter for each component.
After identifying the type of components, I wanted to know it’s principle value, like resistance for a resistor, capacitance for a capacitor, oscillating freq for the crystal, and so on and so forth. Again, this was an exercise in going through a few parts of each type and finding where can I find the value of its key parameter along with the footprint. Key-value and Footprint were the two parameters that I wanted to include in the database library to help to sort out the components. I first of all sorted the Company_Database excel file with “Component Type”, then manually decided which parameter I want to use for each type of component.

Once I knew which parameter I want to get from Digikey for every type of component, I wrote the function shown below to get the respective value and Footprint for the components. As you can see in the below function, first we check what type of component it is. And then depending on the type of component, I take values from two of its parameters from Digikey using their XPath. Below are a couple of screenshots that show examples of where to get the value and footprint for Resistor and Capacitor type of components.

With this, the majority of electronics components in our database got sorted out according to their type, value, and footprint. Whatever little were reaming, I updated their values and footprint manually. These components were one-off types like Buzzer, Cable Ferrite, displays, and so on.
Result: All valid part numbers have a type, value, and a footprint associated with it.

Step 6: Components Not Found in Digikey.
After the above step, there were few components for which its type, and hence its value and footprint could not be obtained from the script. This was happening because of the following three scenarios.
a) Component not found in Digkey. In this case, it was obvious for it to be not categorized.

b) In some cases, there was an exact manufacturer part number provided in our database and hence Digikey will directly take me to a single product page like this. As the location (XPath) of component’s type, value and footprint will be different in this kind of page than the ones shown in above steps, the script was not able to identify components which had a complete part number.

c) Partial part number components, for which Digikey had multiple types of products with a same part number like shown below.

Take note that categories ‘a’ and ‘c’ are different. In ‘a’ Digikey is sure that it doesn’t have any part matching our part number, whereas in ‘c’ it could find multiple options. As there were a relatively lesser number of components left combined in ‘a’, ‘b’, and ‘c’ categories, I decided to update details for them manually. For ‘a’ and ‘c’, the script would have been too much complicated for the scope of this project. And for ‘b’, there were just not enough components left. Even if there were 10 components of the same type with scenario ‘b’, I would have started writing function similar to the one in step 5. The only difference in this new function would be the XPath of the element from where I would be getting component details.

Step 7: Company_Database Excel File Structure
Before I get into the next section of getting Schematic Symbol and Footprint details for components from existing Altium projects. I would like to show all the columns I planned to have in the Company_Database excel file. These are slightly bit different from the example screenshot I have been sharing with you before. E.g. in my actual Company_Database excel file, I have columns for second manufacturer details along with Column G for ‘Owner’ of the part. I had derived this additional info from our internal repository tool.
They are not arranged in the best order, as I have seen that when I import this excel file in Altium, the columns would get rearranged and I would anyways need to arrange them in Altium. The second reason for why my columns were in such an order was because of the sequence in which I was populating this file. In step# 1 when I first got all company part numbers, they obviously got populated in Column A. In step# 2 where we got manufacture details from the internal database system, I was retrieving them in the order of categories entered in Column B to H.
Column A — Company Part Number
Column B — Manufacturer Name
Column C — Manufacturer Part Number
Column D — Manufacturer 2 Name
Column E — Manufacturer 2 Part Number
Column F — Company Description
Column G — Owner (Engineer who had created this company part number)
Column H — Date (G & H were coming from internal database system. Thought no harm in having them)
Column I — Project (Will be updated in later steps)
Column J — Component Type (As updated by script in step 4)
Column K — Parameter Type (As updated by script in step 5)
Column L — Parameter Value (As updated by script in step 5)
Column M — Footprint (As updated by script in step 5)
Column N — Library Path (Altium Schematic Library path)
Column O — Library Ref (Altium Schematic Symbol Name)
Column P — Footprint Path (Altium Footprint Library path)
Column Q — Footprint Ref (Altium Footprint name)
Column R — Footprint Path 2 (Altium Footprint Library path if multiple footprint are available)
Column S — Footprint Ref 2 (Altium Footprint Name if multiple footprint are available)
Column T — Datasheet# 1 Link (Link to additional information like datasheet or app note)
Column U — Datasheet# 2 Link (Link to additional information like datasheet or app note)
Column V — Signal Integrity (For future use)
Column W — Simulation (For future use)
Column X — Created by (Engineer who created this Altium part)

Step 8: Get footprints from existing Altium Projects.
First, we were working on an internal repository tool, then with the Digikey website and now finally we get our hands on Altium Designer. After getting manufacturer details for all electrical parts used in our company, it was time to get Altium footprint for the components from the few projects we have already completed since we changed to Altium. As I said in the opening sections, right now in our Altium projects, we are using all sorts of libraries, like those created by individual engineers, or an integrated library, or library borrowed from other projects. To make the problem of getting a Schematic symbol and PCB footprint easier, I generated one Schematic and PCB library for each project. By doing this it would get easier for me to get a schematic symbol and footprint for each component. Instead of trying to find it from different libraries, I would have to search for it in only one project library.
Creating Schematic and Footprint libraries from the project is very easy in Altium. Just open up your Altium project — Open schematic page — go to the Design tab — Click on Make Schematic Library.
Similarly for PCB library, open PCB file — Go in Design — Click on “Make PCB Library”.

After creating libraries, I generated BOM from Altium projects having the following fields — Company Part Number, LibRef (gives me names of the schematic symbol), and Footprint (gives me footprint name for Column Q).

Step 8: Remove Duplicate Part Numbers from Project BoMs
After getting BoM for each project, I vertically stacked them together as shown in the below example screenshot. I also added a couple of columns manually to each BoM having the name of the Schematic and Footprint library which I generated for each project in the above step. After stacking them together, I used Excel’s ‘Conditional Formatting’ tab to highlight duplicate parts to identify multiple instances of the same Company Part, and deleted them.
Result: Now I have a clean list of parts, organized by Company Part Numbers, for which I have Altium Schematic symbol and Footprints.

I arranged my database folder as shown below. It had a simple folder structure. The reason for this is because while creating our Altium Database library, we need to provide the location address of the Schematic symbol and Footprint for each part. You will get more clear about it when we populate Columns N to S in our Company_Database excel file.
Database Folder
— (Folder) PcbLibraries
````````— (Altium PCB Library) Project_1.PcbLib
````````— (Altium PCB Library) Project_2.PcbLib
````````— (Altium PCB Library) Project_3.PcbLib
— (Folder) SchLibraries
````````— (Altium Schematic Library) Project_1.SchLib
````````— (Altium Schematic Library) Project_2.SchLib
````````— (Altium Schematic Library) Project_3.SchLib
— (Altium Datbase Library File) Company_Database
— (Ms Excel 97– Worksheet) Company_Database

With a list of Altium parts created in step# 8, I wrote a simple function to execute the following steps.
a. Take Company Part Number form Altium Parts List.
b. Search for that part in the Company_Database excel file.
c. Update column I with column A from the Altium Parts List file for matched parts in the Company_Database excel file.
d. Update Columns O and Q by columns C and D from Altium Parts List — Name of Schematic Symbol and PCB Footprint respectively.
e. Update Column N with “SchLibraries\” + Column E from Altium Parts List. E.g. for parts matched from project 1, Column N in Company_Database will be updated as SchLibraries\ Project_1. SchLib. This will provide the complete address of the library where the Schematic symbol for this part is kept.
f. Update Column P with “PcbLibraries\” + Column F from Altium Parts List. E.g. for parts matched from project 2, Column P in Company_Database will be updated as PcbLibraries\ Project_2. PcbLib. This will provide the complete address of the library where the PCB Footprint for this part is kept
g. Update Column X with the name of the project from Column A of Altium Parts List.
Columns N & O and Columns P & Q provide Altium with complete address of the Schematic symbol and footprint for each component. We will see how we tell Altium that these are the columns from where it should take the addresses and names of symbol and footprint respectively in a later step.
But once we do that, columns N and P will provide Altium with a complete path to the library of the part. As you can see, this is a relative address with respect to the location where the Altium database library itself is stored. For e.g. on seeing SchLibraries\ Project_1. SchLib and PcbLibraries\ Project_1. PcbLib in Columns N and P, Altium will traverse through folders SchLibraries and PcbLibraries and access Project_1. SchLib and Project_1. PcbLib respectively. After that, it will use Columns O and Q to search for actual Schematic Symbol and corresponding Footprint for the part.
Result: In this step, we took our Altium parts list from step# 8 and updated Company_Database excel file with Schematic Symbol and Footprint details for the parts contained in Altium parts list.

Step Update Schematic Symbol and Footprint for gelly bean parts
As you could imagine, in our Company_database excel file, there are tons of parts like Resistor, Capacitor, and Inductors in standard packages like , , respectively. These packages are standard throughout the industry and there is little risk in copying schematic symbols and footprints from one part with the same package to another. And that’s what we are going to do next. There is no need to write any function for this as this can be easily done in excel itself. In the Company_database file, I filtered Column J (Column G in screenshot examples), for e.g. to only show “Ceramic Capacitors”. Then sort Column M (Column J in screenshot examples) in the “A to Z” order. This will group all parts with the same package together. Now I just took the part which had Altium schematic symbol and footprint available, copied its Columns N to X, and pasted them in corresponding columns of the parts with the same package.
Repeat this for all components and packages you feel are compatible, like Resistors in , and packages etc. and you are done with creating database file for your parts.
Pat yourself on the back 😊 as most of the hard work is done and now we just need to set up this newly created Company_database file as Altium library.

Step Create Altium Database library
Create a new Altium database file by going to File » New » Library » Database Library from the main menu. On getting below dialog box, select “Microsoft Excel” in the dropdown box and select your “Company_database” excel file.

If your MS-Office / Office is a bit version, you may get an error. Refer to this link to work around it. You can use “Advanced PCB Library Management” article from Altium to know more about using the Database library in Altium.

With that, it’s a wrap. Hope you liked the article and can use it to make yours and your fellow EEs life easier by creating component library yourself for your company. Feel free to drop me a message in case you got any questions, suggestions, concerns …or even just to say Hi.

Till next time….cheers!!!! 😊

Sours: https://becominghuman.ai/use-python-to-create-altium-database-library-2b2aff9af

Library altium database

Working with Database Libraries in Altium Designer

Parent page:More about Components and Libraries

Altium Designer provides the ability to place components directly from a company database, by creating and using a Database Library. Placement is carried out from the Components panel which, after installing the database library, acts as a browser into your database.

After placement, design parameter information can be synchronized between placed components and their corresponding linked records in the database, using the Update Parameters From Database command. Full component updates - including the graphical symbol, model references, and parameters, can be performed using the Update From Libraries command. Parametric information from the database can also be included in the final Bill of Materials (BOM), ready for component procurement.

The Move from bit to bit Software

With the release of Altium Designer version and Altium NEXUS version , the design software became bit. To link from design components to a database in a bit version of Altium software, the backend database engine must also be bit. If you use Microsoft Access or Excel to manage the backend data and have a bit version of Office installed, it is possible to install the bit Microsoft Access database engine as well. For detailed information about how to do this, follow the instructions in the Using Database Libraries with bit and bit Altium Design Software on the same Computer article.

If you attempt to connect via the bit Microsoft Access database engine, the following error message will appear.

Error dialog, reporting that a bit version of the Microsoft Access Database engine is required for database linking

Note that certain connection errors, such as incorrect syntax in the details of the Connection String, can result in the wrong database engine being called and the error dialog shown above appearing, after installing the bit database engine.

Managed Components that are Connected to the Supply Chain

If you are using Database Libraries because you need to have well managed components, you might like to explore Altium's Managed Component solutions. Stored in a Managed Content Server, managed components offer lifecycle management, revision management, and real-time integration into the supply chain.

Direct Placement - Beyond Mere Linking

Altium Designer provides three methods of linking from a component to a database - using either a Database Link file (), a Database Library file (), or an SVN Database Library file () respectively. The DbLink approach provides an efficient means of linking and keeping the components used in your design (or libraries) synchronized with the data entered in the database. The DbLib/SVNDbLib approach takes this proven linking efficiency and adds to it the freedom to be able to place a component directly from the database - in essence creating the component dynamically from the information stored for it in the corresponding database record.

Before launching into the greater depths of the database library feature, it is worth discussing the differences between these methods, in regard to the way you use them.

Linking using a Database Link file

Related page:Linking Existing Components to Your Company Database

  • Using this method, the Database Link file () defines linkage between the schematic component and a matched record in a database. The record match is established by key field linking, which can be a single key field (for example a part number), or multiple key fields (by defining a Where clause).
  • With this method of linking, the model and parameter information for the component must be predefined as part of the Altium Designer library component. The library component must also include the necessary key field information as part of it's definition. Once this has been defined you add a Database Link file to your Library Package, or Design project, then you can synchronize the component information (parameters) with the contents of fields in the database.
  • Although each physical component defined by each database record does not need to map to a unique Altium Designer library component - many database components can share the same component symbol - this method of linking would typically be used in a "one database record-to-one Altium Designer component" fashion. The unique Altium Designer component can either be an instance placed on a schematic sheet, or a unique component in a component library.
  • With DbLink-style database linking, you include the Database Link file with the library package, or design project.

Linking using a Database Library file

  • Using this method, the Database Library file () also defines the linkage between the schematic component and a matched record in a database. Again, the record match is established by key field linking, which can be a single key field (for example a part number), or multiple key fields (by defining a Where clause).
  • The key difference with this method of linking is that the component symbol, model, and parameter information for a component is stored as part of the record definition for that component in the external database. The referenced schematic component (stored in an underlying component library ()) is only the symbol; it has no linked models, and no defined design parameters.
  • When the component is placed, its parameter and model information is created on-the-fly, using the corresponding fields in the matched database record, and in accordance with defined mapping. One or more of these parameters will then be used to maintain an ongoing link back to the database, as per the matching criteria defined, enabling future synchronization after placement.
  • This method of linking, due to its dynamic creation of components at the time of placement, lends itself very well to being used in a "many database records-to-one Altium Designer component" fashion.
  • Unlike the DbLink-style of database linking, whereby the DbLink file must be included with the library package (or design project), the DbLib/SVNDbLib file need not be added to the project. The database library (DbLib) is included in the Available File-based Libraries - accessible by the Components panel. Remember, the Available File-based Libraries can consist of Project Libraries, Installed Libraries, or libraries found along specified search paths.
  • You would typically configure DbLib/SVNDbLib files in a library-oriented fashion. For example you might have one for all the resistors detailed in your company database, another for capacitors, and so on.

Reflecting the different way you work with Database Link files compared to Database Library files, when a DbLink is added to a project it appear in the sub-folder, whereas the DbLib and SVNDbLib files appear in appropriate sub-folders under the folder, as shown below. This reflects how the DbLink acts as a interface, or linkage file, between the components and the relevant database records, while the DbLib-type files are used like a library, allowing the designer to browse through the component records in the database.

Projects panel showing where each type of database link/library file is included in the project structure

DbLib vs SVNDbLib

An SVN Database Library is an extension of the Database Library model, with the difference being that the source symbol and models are stored under version control.

The source libraries are created, added-to, and maintained within, a Subversion-based repository. The link to the repository, and to the external database, is defined within an SVN Database Library file (). And since this approach is an extension of the Database Library, it is often referred to as a Version-Controlled Database Library.

Librarian or Designer?

There are essentially two modes in which you can work with a version-controlled database library - as a Librarian, or as a Designer.

As a Librarian, not only will you need to set up and maintain the external source control repository of symbol and model libraries, but you will also be responsible for setting up the SVN Database Library file. This entails:

  • Connecting to the external component database.
  • Defining database record to component parameter/model mapping.
  • Specifying the link to the SVN repository in which the symbol and model libraries are stored.

As a Designer, you will take the SVNDbLib file generated by the Librarian, and make it available in the Components panel - by adding it to the Available File-based Libraries list - so that you browse and place the database components.

Altium Designer in no way prohibits a Designer from performing Librarian-based activities. Access rights/permissions defined for the source control repository will ultimately define how far the Designer can drive the Librarian 'car'. For example, the Designer may be able to checkout, open and modify a library, but is prevented from committing the change to the repository.

The use of these roles will differ from company to company. A larger company may have a dedicated library center which will, in the role of Librarian, solely be involved with the setup and maintenance of the symbol and model libraries in the source control repository, and the generation of the SVN Database Library file(s). The SVNDbLib file(s) will then be made available to the Designer(s) within that company, who will install and use the library files from which to place the components in their designs.

In a smaller company, both roles may be filled by the same person. Not only will that person setup and maintain the repository of libraries, but will also use the defined SVNDbLib(s) in their design work.

The Source Control Repository

Related article:Version Control and Design Repositories

The symbol and model library files need to be added to a Subversion (SVN) repository. Altium Designer includes an SVN Version Control Provider, this is enabled and configured in the Data Management - Version Control page of the Preferences dialog. Once the SVN Version Control Provider has been enabled, a repository can be created on the Data Management - Design Repositories page of the Preferences dialog.

SVN repositories can also be created and managed outside of Altium Designer using an external SVN client and server, such as TortoiseSVN. An existing repository can be connected to in the Data Management - Design Repositories page of the Preferences dialog.

One important thing to note when adding files to the repository, is that each symbol and model must be stored in its own library file. In a regular library - which can hold any number of symbols/models - changing a single entry would result in all being marked by the version control system as having been modified. Having one symbol/model per library file plays to the nature of version control, allowing you to keep track of exactly what has been modified and what has not.

For the purposes of this document, it is assumed that the repository has already been created.

For more information on the use of the particular SVN client you are using, refer to the relevant documentation associated with that software. For more information on version control, see Version Control and Design Repositories. When reading this document, remember that for a version-controlled database library, the source control system used must be Subversion.

Using the Library Splitter Wizard

Dialog page:Library Splitter Wizard

If the libraries for the symbols and models are being newly created, there is no problem ensuring only one symbol/model per file. Typically however, the source libraries will already exist. To simplify the job of separating these libraries into single-entity files for addition to the SVN repository, Altium Designer provides a splitting tool - the Library Splitter Wizard. The wizard is accessible from the Tools menu when editing a PCB or Schematic library document.

Library Splitter Wizard, use this to split multi-model library files into single-model library filesSplit source libraries into one symbol/model per file, using the Library Splitter Wizard.

Setting up for the splitting process involves the following steps:

  1. Adding the required source library files.
  2. Specifying the output directory. By default, the output directory will be set to the same directory in which the source library is stored. Care should be taken if the original source libraries are all stored in the same source directory folder. If the output directories are not specified and are left at their defaults - pointing to the same source directory folder - you can end up with a very large mixture of single symbol and model libraries. Sifting through these when creating the repository structure may prove very time consuming.

As the split library files will be added to the SVN repository, it can be a good idea to setup the folder structure that you want in the repository - in terms of the symbol/model files - locally on your hard disk. Once the structure is defined, copy the source libraries to their respective folders within that structure. You can then just leave the output directory settings for each source library at their defaults. After the split, the generated single library files will already be in the correct locations. You can then delete the original source library from each folder and add the folders to the repository, using the SVN client you have decided to use.

  1. Configure additional options to control how the source libraries are split. These include, for a schematic component library, options that allow you to strip the parameter and/or model information from each constituent component - leaving just the bare symbol.
  2. Once the source libraries and options have been specified the wizard will perform an analysis, the result of which is the set of single symbol/model libraries that will be created, listed for you to review. The name of each split library to be generated is shown. The name used for a library will be the same as that used for the constituent component/model.

If any of the following characters have been used in the component/model name, they will be replaced by an underscore when creating the library name: '\', '!', ''', '[', ']'.

  1. Review the list of libraries to be created and then click Next to proceed with the splitting process and ultimately obtain the libraries to be added to the source control repository.

Using the SVN Database Library Conversion Wizard

Dialog page:SVN Database Library Conversion Wizard

Another approach for converting existing libraries into an SVN-type database library is the SVN Database Library Conversion Wizard. This Wizard converts schematic, PCB, database and integrated libraries into SVN database libraries. The Wizard has a number of conversion-related options, including how the source libraries should be split, in which directories of which repository they should be stored, and the output directory for the created SVNDbLib and MDB database file. 

The wizard is accessible from the Tools menu when editing a PCB or Schematic library document.

The Wizard splits model libraries & checks them into a repository, and creates the SVNDBLib and the Access database filesThe Wizard splits symbol and footprint libraries and checks them into a repository, and creates the SVNDbLib and the Access database files.

Creating the Database Library File

The backbone of the database library feature is the database library file. This comes in two forms, depending on whether you are using a standard database library, or a version-controlled database library:

  • Standard Database Library - the Database Library file. This file is created and managed using Altium Designer's DatabaseLib Editor. This editor becomes available when the active document in the main design window is a file.
  • Version-Controlled Database Library - the SVN Database Library file. This file is created and managed using Altium Designer's SVNDatabaseLib Editor. This editor becomes available when the active document in the main design window is a file.

The database library file is the interface between the design software and the databaseExample DbLib file, open in the DatabaseLib Editor. Hover over the image to see an example SVNDbLib file, open in the SVNDatabaseLib Editor.

Create a new file of these types by choosing the File » New » Library » Database Library command, or File » New » Library » SVN Database Library command, from the main menus.

For a standard Database Library, if a default document has been specified on the System - New Document Defaults page of the Preferences dialog, the Database Library file will be created using that default as a template. A different default can be assigned, for a Database Library file created as part of a PCB project, Integrated Library Package, or created as a free document.

Connecting to an External Database

Table and mapping data will only appear in an Editor's main display window after the active Database Library/SVN Database Library file is successfully connected to the required external database. Connection is defined using the controls provided in the Source of Connection region.

Configuring the Connection Source, example of using the Select Database Type optionSpecifying the connection to the external database through a DbLib file. Hover over the image to see connection through an SVNDbLib file.

Any database which provides OLE DB support can be connected to. The options provided in this region each use an OLE DB connection string to connect to the target database. Some databases may not offer OLE DB support. However, virtually all Database Management Systems in use today can be accessed through the Open Database Connectivity (ODBC) interface. The database link feature uses Microsoft's ODBC provider, which allows an ADO (ActiveX Data Object) to connect to any ODBC data source. The result is that any ODBC database can be connected to. The OLE DB provider for the ODBC database is specified as part of the connection string.

Connection can also be defined on the Connection tab of the Database Connection dialog, accessed from the main Tools menu, or by clicking the Advanced button (to the right of the Connect button, at the bottom of the region).

Fast Connection to Access and Excel Databases

The Select Database Type option offers an expedited method of creating a connection string when the target database has been created using Microsoft Access, or Microsoft Excel. Using this option, select the database type and then browse to and select the required database file. The corresponding connection string will automatically be composed and entered into the field for the Use Connection String option.

The full path can be specified, or you can opt to store the path relative to the Database Library/SVN Database Library file.

Building a Connection String

If your company database is not Access or Excel-based, and you want to build the connection string explicitly, enable the Use Connection String option and then click the associated Build button to the right. The Data Link Properties dialog will appear.

Data Link Properties dialog, a Microsoft dialog used to configure the Connection String optionBuilding a connection string through the Data Link Properties dialog.

The dialog opens at the Connection tab. The OLE DB Provider is set by default on the Provider tab of the dialog. This is the default provider setting for new Database Library/SVN Database Library files and is also used to connect to Access database files (). Change the provider as necessary.

From the Connection tab enter the name (including path) of the database you wish to connect to.

If your database requires login permission, enter this as required, along with any other advanced settings available from the Advanced tab of the dialog. The All tab provides a summary listing of link options defined, as well as extended options relating to the chosen OLE DB Provider. Options can be modified as required from this tab.

Once link options have been defined you can check for successful connection by clicking on the Test Connection button (on the Connection tab). A successful connection will yield a confirmation dialog to that effect.

The Data Link Properties dialog is a Microsoft dialog and, as such, pressing F1 or using the available Help button will gain access to the Microsoft Data Link Help file. This file is not part of Altium Designer's documentation set.

Specifying a Data Link file

If the data source to which you wish to connect is described using a Microsoft Data Link file (), enable the third of the connection options - Use Data Link File - and click the associated Browse button to locate the required file. A Data Link File is essentially a storage vessel for a connection string.

Proceeding with Connection

After defining the connection to the external database, the text of the Connect button will become bold, signifying that you can proceed with the connection. If the connection details are correct, the table and mapping information for the target database will be loaded into the Database Library/SVN Database Library file. The text on the Connect button will change to and the button will be grayed-out.

If there is a problem with the connection details, for example a connection string is built incorrectly, or a path is entered erroneously, connection will fail and a message will appear alerting you to this fact. Check your connection settings and click the Connect button again.

Examples of incorrect connection settings that result in a connection failureExamples of flagging connection failure in a database library.

If you change the connection settings whilst connected to a database, live connection will be lost and the text on the Connect button will change to Reconnect. Click to re-establish the connection.

After successful initial connection, and after saving the Database Library/SVN Database Library file, the connection will be made automatically each time the file is opened, provided the target database's location and filename are not changed.

Specifying the Link to the Version Control Repository (SVNDbLib Only)

With a DbLib, the symbol and model libraries are stored on your hard disk, or other local/network medium. Remember that for an SVNDbLib, these libraries are stored under version control in a Subversion repository. As part of the SVNDbLib file, you must define the link to this repository. The connection to the SVN repository is defined on the SVN Repository tab of the Database Library Options dialog (Tools»Options). This dialog can also be accessed by clicking the Options button in the Field Settings region of the document view.

Database Library Options dialog, configuring the SVN repository settingsExample connection to a file-based SVN repository.

Database Table Listing

After successful connection to the external database, table and mapping data will be loaded. The left-hand side of the DbLib/SVNDbLib document lists all tables that exist in the connected database.

For an Excel-based database, a table is actually a sheet in that linked spreadsheet. The name of the table will have the suffix .

If the target database has been created using multiple Excel spreadsheet files (), there is a limit of 64 sheets that can connect, due to ODBC driver limitations.

The connected database can contain multiple tables, the settings for each used table are configured separatelyTables existing in the connected database.

The Enable option next to each table entry allows you to control whether or not that table is to be part of the resulting database library. When the database library is added to the list of Available File-based Libraries for browsing in the Components panel, each table will appear as a separate library entity. So although only one database library is added in real terms, from the perspective of the Components panel it is as though you have added multiple, distinct libraries. For more information, see Making the Database Library Available.

As you click on a table entry in the list, its icon changes from Database table icon, inactive table to Database table icon, active table in order to distinguish it as being the currently active table. The table - with all its data - appears on the Table Browser tab of the document. This is an editable view of the table, and allows you to quickly refer to its contents, and edit where required, without having to launch the external database itself.

Browsing a source table in the active database, in an open DbLink fileBrowsing a source table in the connected database.

To enlarge the area of the Table Browser (as shown in the illustration above), collapse the entire area above (connection and field settings) by clicking the Collapse icon - collapse a region of the database library documentcontrol, at the top-right of the document view. Click Expand icon - expand a region of the database library documentto expand. The table also supports familiar grouping, sorting, and filtering features.

Specifying Matching Criteria

After a component has been placed from the external database, there needs to be some way of retaining the link between that placed component and the database record whose information was used to create it. In essence, the two need to be matched.

When a component is placed, its parameter information is created on-the-fly, using the corresponding fields in the database record. The post-placement link between the schematic component and the database record is established using one or more of these parameters. The Field Settings region of the document allows you to define the matching criteria - either a simple, single key lookup, or a more advanced match using a Where clause.

Matching criteria is specified on a per-table basis.

Configuring the matching criteria to use a single key field lookupControlling post-placement matching criteria.

Single Key Lookup

If the Single key lookup option is enabled (default) the Database field and Part parameter fields become available. The former lists all of the available field names (column headers) in the active table of the database. As the parameters for a schematic component are added as it is placed, the Part parameter field will reflect whatever database field is chosen.

Typically, the lookup key field used is something that uniquely identifies each component in the external database, such as a Part Number. The chosen lookup field is distinguished on the Field Mappings tab of the document by the Design Parameter entry shown as grayed-out.

Mapping between the component parameters and the database, using a single key lookupSingle key mapping by Part Number.

When using the Update Parameters From Database feature at some stage after placement, information is read from the chosen key parameter in the placed schematic components and then searched for in the chosen (key) field of the database - across all enabled tables. When there is a match, information from other cells in that record of the parent table can then be taken back to the mapped parameters in the schematic component.

Advanced Matching - the Where Clause

While the Single key lookup option works well if there is a unique part number/id to match on, it is not so effective when matching by a parameter that is not unique, such as capacitance or resistance. In this case the more advanced Where clause should be used, enabling you to specify multiple key matching in order to link the schematic component to its source database record.

In its simplest form the Where clause (written using SQL syntax) reflects the chosen entries that define the single key lookup. For example if the Database field was chosen to be - the default - the Part parameter field would automatically be set to also, and the entry for the Where clause would be :

The square brackets around the database field (table column) are quote characters, as specified on the Advanced tab of the Database Connection dialog. Access this dialog either by clicking on the Advanced button in the Source of Connection region of the document, or from the main Tools menu.

Mapping between the component parameters and the database, using a Where clauseThe Advanced tab of the Database Connection dialog provides additional SQL options for quoting
tables, or using table schema names, in a constructed Where clause.

When quoting tables, the specific quote characters used will depend on the database you are using. For example, square brackets [ ] are only usable in Microsoft databases like Access, Excel via ADO, or MSSQL (later versions). MYSQL would use the ` (backtick) character for quoting. You really only need to quote column names, in any database, if they include spaces or are reserved words (for that database). Check the documentation for your particular database software to see which quote characters are used (if any).

The curly brackets (braces) specify that the entry being referenced is a design parameter. The single quotes are used to specify the design parameter be treated as a string, as opposed to a number (no quotes). The type matching is very important, as SQL is type sensitive. The design parameter should be made the same type as the column in the database.

Using standard SQL syntax, the Where clause can then be extended to match using multiple Database field/Part parameter entries, for example:

In this case a single record in the relevant table of the database would be linked to, using three different design parameters. Notice that the entry for the design parameter is not quoted. This means that the column type in the associated table of the database is and not .

Using standard SQL syntax you can conceivably make the Where clause as simple or as complicated as you like.

Mapping Database Fields to Design Parameters

Design parameters for a component placed from a database library are created/added at the time of placement. Which parameters are actually created, and the options used to update their information after placement - using the Update Parameters From Database command - is determined by mapping and update information specified in the Database Library/SVN Database Library file. These settings are performed on the Field Mappings tab of the main document view.

Mapping and update options are specified on a per-table basis.

Field Mappings tab of the database library fileSpecify parameter mapping and update options on the Field Mappings tab of the DbLib/SVNDbLib document.

Model and Parameter Mapping

The first two columns (from the left) on the Field Mappings tab are used to control which information from the database is to be mapped to the component's attributes, models and parameters.

  • Database Field Name - this column lists all field (column) names in the currently active table of the database.
  • Design Parameter - this column defines how each corresponding field in the database is to be used. This could be to source a component's symbol or footprint model (it will be enclosed in square brackets), or if it is to be included as a component parameter (these are not enclosed in brackets).

When you open a DbLib/SVNDbLib document that has been connected to a database, you will notice that some Design Parameters include square brackets and others do not. The square brackets denote a reserved name, such as . This data is used to populate the component's attributes and models. Design Parameters that do not include square brackets become component parameters.

Initial mapping is performed automatically upon connection to the database, with all database fields mapped.

Note that the automatic mapping assumes that the Database Field Names match the reserved name used in Altium Designer. If they do not, then the mapping must be manually configured.

Attributes & Models

If the database field name is one of the following reserved names, the corresponding attribute/model mapping entry will be automatically set in the Design Parameter field:

  • Description
  • Footprint Ref
  • Footprint Path
  • Footprint Ref n
  • Footprint Path n

Unlimited footprint model references (and paths) can be specified in a database table and mapped in the DbLib/SVNDbLib file. In the reserved names, represents a positive integer starting from .

  • Library Ref
  • Library Path
  • Orcad Footprint
  • Orcad Library

These references are used when importing an OrCAD CIS configuration file and libraries, and generating a standard database library (DbLib).

  • PCB3D Ref
  • PCB3D Path

References to PCB3D refer to the legacy 3D viewer, these should not be used for new designs. The PCB Editor's native 3D engine can render component bodies and imported 3D model files associated with component footprints.

PCB3D model mappings can be defined in an SVNDbLib file, however storage of PCB3D model libraries in the Subversion repository is not supported.

  • Sim Description
  • Sim Excluded Parts
  • Sim File
  • Sim Kind
  • Sim Model Name
  • Sim Netlist
  • Sim Parameters
  • Sim Port Map
  • Sim Spice Prefix
  • Sim SubKind

Only one simulation model link can be defined for a component in an external database. Typically there will only ever be a single simulation model linked to a component. Should you wish to set up multiple simulation model links, the other links will need to be defined and stored with that component in the source schematic library file.

Linked simulation models are supported for a version-controlled database library (SVNDbLib), however storage of simulation model files in the Subversion repository is not supported.

These mappings define the component attribute and model information for the component. When the component is placed, the schematic symbol specified by the corresponding database record's field will be extracted from the specified schematic library. Similarly, PCB footprint and Simulation model information stored in the record will be added to the component as linked footprint and simulation models respectively.

The entry must exist in the Design Parameter column and be mapped to the Database Field Name that specifies the schematic symbol, to be able to place a component from the Database Library/SVN Database Library onto a schematic. If the database table contains the symbol reference under a different Database Field Name, for example , you will need to manually set the associated Design Parameter entry for this field to , using the available drop-down list for that cell.

Similarly, if model reference information is entered into the database using different field naming, you will need to manually map by choosing the appropriate Design Parameter entry (, , , , and so on) from the drop-down list, for each field in turn.

Mapping the symbol and footprint models from the database to the design componentIn order to define the symbol and model information for a component upon placement, it is the symbol and model reference fields in the database that are the crucial
mapping entities - ensure that there is a symbol and at least one PCB footprint reference as part of the defined mapping.

As mentioned, multiple PCB models can be mapped. The Database Field Name that is mapped to Design Parameter will be the default footprint when the component is placed on the schematic. It is this footprint that will be placed when the design is transferred to the PCB domain.

When mapping symbols and models for a DbLib/SVNDbLib file, path information in the external database is optional. For more information see Specifying Symbol and Model Library Locations.

Parameters

All other database field names will be automatically mapped to design parameters using the same names. For example, if a field in the database is called , a design parameter with the name will be mapped to it. You can change the name for a design parameter by clicking in its cell and typing the new name directly. It is these design parameter names that will appear in the Parameters region of the component's associated properties dialog, once it has been placed on a schematic sheet.

You may have a large number of data fields associated with a component in the database, not all of which you will want, or even need, added as design parameters to the component when placed on a schematic sheet. Much of this information may only be required when generating a Bill of Materials. The Report Manager dialog allows you to add parameter information to a BOM, directly from a linked database - allowing you to reduce the amount of information that gets 'carried' with the schematic source documents. For more information, refer to the section Adding Database Information Directly to a BOM.

For fields that you explicitly do not want mapped from the database, set the Design Parameter entry to . Unmapped database fields are distinguished on the tab by the use of a red cross icon (Cross icon, indicating that a database field is not mapped to a component parameter). Mapped database fields are distinguished by a green tick icon (Tick icon, indicating that a database field is mapped to a component parameter).

Example of how to un-map a database field from a component parameterConfigure parameter mapping as required. Set to to prevent a parameter in the database being mapped to the placed component.
Un-mapped parameters can be included directly in the BOM, if required.

To quickly remap an unmapped field, click inside the row for that field and use the Ctrl+D keyboard shortcut. Note that for model mappings you will need to manually select from the associated Design Parameter drop-down.

Parameter Update Options

The remaining columns on the Field Mappings tab allow you to specify the actions taken for parameters, when placing a component from the database library for the first time, or updating a component after it has been placed using the Update Parameters From Database command.

The four columns are as follows:

  • Update Values - a cell in this column is used to determine the action that should be taken if the parameter exists both on a schematic sheet and in the database, but the values are currently different. Choose to update the parameter of the placed component with the value stored in the database (), or not to update at all (). This option is obeyed when using the Update Parameters From Database command, after the component is placed.
  • Add To Design - a cell in this column is used to determine the action that should be taken if the parameter is found in the database, but does not exist for the placed component. You can choose to add the parameter (), not add the parameter (), or add the parameter only if it has a value assigned to it in the database (). This option is obeyed both when initially placing the component from the database library and when using the Update Parameters From Database command, after the component has been placed.
  • Visible On Add - a checkbox in this column is used to determine whether a newly added parameter, resulting from initial placement or update after placement, is made visible for the component on the schematic sheet (enabled) or not (disabled).
  • Remove From Design - a cell in this column is used to determine the action that should be taken if the parameter is found to exist for the placed component, but either is not in the database, or is, but has no value. You can choose to not remove the parameter at all (), or only remove it if it has no value assigned to it in the database (). This option is obeyed when using the Update Parameters From Database command, after the component has been placed.

Initially, the Update Values, Add To Design, and Remove From Design fields - for each mapped database field - will be set to the entry , and the Visible On Add option will be disabled, as illustrated in the following image.

Field Mappings tab of the database library file, showing where the update behavior is configuredInitial (default) parameter update options.

Looking at the image, there are four important points to make regarding update options:

  1. Unmapped database fields will have no associated update options.
  2. Attribute and Model based mappings (entries with square brackets in the Design Parameter column) will have no associated update options, as these are not design parameters.
  3. The key field (e.g. in the image) will have no associated update options. This field is solely used for parameter matching purposes.
  4. A setting of causes an update option to follow its corresponding default definition, as specified on the Default Actions tab of the Database Library Options dialog (Tools » Options). This dialog can also be accessed by clicking the Options button in the Field Settings region of the document view.

Database Library Options dialog, showing the Default Update optionsDefine default parameter update options in a central location for a DbLib. Hover over
the image to see the equivalent for an SVNDbLib.

The fourth point is beneficial in that it allows you to specify update options from a central location, and then point to that location when defining the update options for each mapped field. That is why the entry is loaded automatically into the relevant update fields upon mapping a database field to a design parameter.

Should you wish to override the default setting for an update option, click inside the relevant update field, on the Field Mappings tab, then click again to access a drop-down providing the applicable update choices.

Field Mappings tab, showing the options available to resolve the situation when a database field does not match a parameterParameter update options can be manually overridden, if required.

In this way, you have full control over how the parameters in the design are updated. You can set all fields to and make the required update decisions from the Database Library Options dialog, set each update field individually, or have a mixture of the two - the decision is entirely yours to make as you see fit. For placed components the update, when performed, is carried out through use of an Engineering Change Order dialog. If at this stage there are updates that you would prefer not to make, you can opt to not include those particular changes - giving you the final, and ultimate say, in which design parameters get updated.

Specifying Symbol and Model Library Locations

When you place a component from a database library its symbol - specified by the mapping - is extracted from the specified schematic library (). Similarly, any model references (footprint, PCB3D, simulation) specified in the database will reside in underlying PCB Library (), PCB3D Library () and Simulation Model (, ) files. The paths to these files can be specified explicitly in the database by:

  • Entering an absolute path to the file.
  • Entering a relative path to the file.

If you have defined fields in your database for path information, these fields need to be mapped to the appropriate design parameters - , , , , and so on (refer back to Model and Parameter Mapping).

Entering paths - even relative - in a database table can be a little restrictive. If you move the location of a library or model file, you would need to update the database table accordingly. To give you greater freedom, you have the ability to specify library search information within the DbLib/SVNDbLib file itself. This allows you to specify the name of the source library or model file in the database, or not to define it at all.

Using Search Paths with a large number of symbol/model files - while search paths offer greater flexibility and simplicity for configuring how the symbols and models are located, this approach is not recommended when there are a large number of symbol or model files present in the search location. Depending on the file naming scheme used, Search Paths can require that every library/model file present in the path is searched every time a symbol/model is required, for example when browsing components or transferring the design from schematic to PCB.

For a Database Library

For a DbLib, library search paths are defined on the Symbol and Model Search Paths tab of the Database Library Options dialog (Tools»Options). This dialog can also be accessed by clicking the Options button in the Field Settings region of the document view.

Database Library Options dialog, configuring the search paths for the symbol and footprint modelsSpecifying search paths for symbol and model libraries.

To add a path to the list:

  1. Either type the path directly into the field below the Library Search Paths region, or click on the Browse for a folder button button to access the Browse for Folder dialog, from where you can locate the directory in which the required library/model file(s) reside.
  2. You can add either as a full path, or as a relative path (relative to the location of the DbLib file). Control this using the Add/Update As Relative Path option.
  3. After specifying the required path, add it to the search paths list by clicking the Add button.
  4. Continue adding additional search paths as required.

For direct entry, if you specify an incorrect path (e.g. to a folder that does not exist) the entry can still be added but will appear grayed-out in the list, to indicate that it is an invalid search path. If you find that you have entered a path erroneously, you can select it in the list and either click the Remove button, or modify its path definition and click the Update button.

The library search paths determine where library and model files can be found when placing form the database library and when searching for a model after placement. The specific model that is used will depend on how you have set up your library search paths and whether you have added specific library information into your database. The searching will proceed in the following order:

  1. If a full path exists in the mapped path field for the symbol or model, use that library/model file and extract the symbol or model specified in the applicable reference field.
  2. If a relative path exists in the mapped path field for the symbol or model, use that library/model file and extract the symbol or model specified in the applicable reference field.
  3. If only a library/model file name exists in the mapped path field for the symbol or model, use the search paths to locate the first library/model file that matches the specified name and which contains a match for the symbol or model specified in the applicable reference field.
  4. If no library/model file information exists in the database, use the search paths to locate the first library/model file containing a match for the symbol or model specified in the applicable reference field.

For an SVN Database Library

For an SVNDbLib, the base directories within the Subversion repository - in which the symbols and footprint models reside - are specified on the SVN Repository tab of the Database Library Options dialog (Tools»Options). This dialog can also be accessed by clicking the Options button in the Field Settings region of the document view.

Database Library Options dialog, showing where the model search locations are defined for an SVNDbLibSpecifying base repository directories for symbols and footprints.

Use the available fields in the Models Location region to specify the base directory for the symbols and footprints. Click the Click the ellipsis button to select the repository folder for the symbols and footprints button at the right of a field to access the Browse for directory dialog - a window into the linked repository. Use this dialog to select the required folder.

Configure the location of the symbols and footprints in the SVN repositoryBrowsing for the relevant directory in the linked SVN repository.

It is important to stress that the symbols and footprints must reside within the base repository directories specified. They can of course be in sub-folders of those directories and the paths specified for both symbols and footprints can point to the same directory in the repository.

The model locations determine where library and model files can be found when placing form the version-controlled database library and when searching for a model after placement. The specific schematic symbol and footprint model(s) used will depend on how you have set up these locations, and whether you have added specific library information into your database. The searching will proceed in the following order:

  1. If a full path exists in the mapped path field for the symbol or footprint model (e.g. ), use that library file and extract the symbol or footprint specified in the applicable reference field.
  2. If a relative path (relative to the root of the repository) exists in the mapped path field for the symbol or footprint model (e.g. ), use that library file and extract the symbol or footprint specified in the applicable reference field. The URL for the repository - specified in the Repository Server Connection region of the dialog - will be prefixed to the path you enter, to give the absolute address.
  3. If only a library file name exists in the mapped path field for the symbol or footprint model (e.g. ), use the specified model locations within the repository to locate the first library file that matches the specified name, and which contains a match for the symbol or footprint model specified in the applicable reference field.

When searching for a symbol/model match, the flattened folder paths in the base symbol or footprint directory are sorted and searched alphabetically. If the Library Splitter Wizard is used, there will always be a corresponding library with the name of the actual symbol/footprint.

  1. If no library file information exists in the database, use the specified model locations to locate the first library file containing a match for the symbol or footprint model specified in the applicable reference field.

When locating the symbol/footprint, the system will initially look for the first library named like the symbol or footprint itself. For example, if the logical symbol name in the database (specified by the mapping) is , the system will look for the first file named and look for the symbol within this file. If the symbol/footprint cannot be found in this way, the system will look for a match in all libraries.

Modifying a Database Table

The occasion will often arise where a change is required to a component record in the database. An existing component may need one or more of its fields updated to better reflect its current status. A new component may be available for use and therefore needs to be added to the relevant database table. Supply chain information may need to be added to components. A component may have been marked as 'obsolete' and, no longer to be used in designs, is required to be deleted from the database altogether.

Both the DatabaseLib Editor and the SVNDatabaseLib Editor enable you to perform these actions directly, through the Table Browser, eliminating the need to open the external database. With the required table selected, commands for manipulating its entries in the database are available from the right-click menu.

Note that if an Excel spreadsheet is used as the source database, commands for adding, modifying and removing components will not be available.

The records in the linked database can be edited directly from the Table Browser tab of the database library fileAccessing commands to modify the selected table in the linked database.

Editing an Existing Component

An existing component record in a linked database table can be modified in two ways:

  • In-place Editing - click within the required field and modify its value as required. Press Enter, or click away from the field when done, and click Yes in the subsequent dialog that asks you to confirm committal of the change (committing it to the database).
  • Dialog-based Editing - right-click on the entry for the required component record, and choose the Edit Component command from the context menu. An editing dialog for that component will appear, listing all of the fields for the parent database table, along with their values. Click on a Field Value entry to edit it. Click OK when you have finished modifying the desired fields, to commit the changes back to the database.

Demonstration video showing how a database record can be edited through the Table Browser in the database library editorDemonstrating component record field editing, using the two editing methods.

Adding a New Component

To add a new component to a database table, right-click anywhere within the Table Browser and choose the Add New Component command from the context menu. The New Component dialog will appear, with all of the fields for the parent database table listed. Enter the information for this new physical component as required, then click OK. The new component will be added to the bottom of the table.

Demonstration video showing how a new component record can be added to the database, using the Database Library editorDemonstrating the addition of a new component to a table in the linked database.

Removing an Existing Component

To permanently remove an existing component from a database table, right-click on its entry in the Table Browser and choose the Delete Component command from the context menu. A confirmation dialog will appear - click Yes to proceed with the removal.

Managing Supply Chain Information

Related page:Linking to Supplier Data

Using Altium Designer's Live Supplier Data feature, you have the ability to search supplier databases from within Altium Designer, and link your design components to matching Supplier Items. For any given Supplier Item found through a search, you can also import its parameters, data sheet links, pricing, and stock information, as parameters of a target component in a DbLib/SVNDbLib). In addition, you can also create whole new components in the targeted database table - directly from Supplier Items! The linked supplier data can be included at design release time, in a Bill of Materials - especially useful from a project costing and procurement perspective.

At the heart of this feature is the Supplier Link. This fundamental entity provides the live link between an Altium Designer component and an item in a Supplier's database of electronic components.

Creation of a Supplier Link involves the addition of two parameters to the target Altium Designer component involved:

    is an integer suffix, used to distinguish between Supplier Items, where multiple links are added to the same component.

    Adding Supplier Links

    Creating a Supplier Link is a straightforward process. In a manual fashion, this process is facilitated most easily by using the Manufacturer Part Search panel to search for the required part. Once found, click to select the chosen item in the results region of the panel, when it is selected it will display a SPN dropdown (Supplier Part Number), as shown in the image below. Click the dropdown to display the SPN tiles, each tile details real-time information about the price and availability of the selected part, from that supplier.

    Click the SPN link to display a set of tiles showing the suppliers of that partAny of the suppliers shown can be added as a Supplier Link to the Database library.

    Using the Manufacturer Part Search panel, a Supplier Link can be created in one of the following ways:

    • By clicking and holding on the Supplier tile in the Manufacturer Part Search panel, and dragging and dropping it onto the component record in the Table Browser of the database library (shown in the animation below).
    • By right-clicking on the Supplier tile in the Manufacturer Part Search panel, and choosing the Add Supplier Link To command. With the DbLib/SVNDbLib file active, the Supplier Link will be added to the focused component record.
    • By right-clicking on the Supplier tile in the Manufacturer Part Search panel, and choosing the Add Supplier Link And Parameters To command. This command is used to add parameters, data sheet links, pricing and stock information for the selected Supplier Item, along with a Supplier Link to that item, all in the one step. With the DbLib/SVNDbLib file active, the parameters and Supplier Link will be added to the focused component record.
    • When creating a new library component, by right-clicking on the Supplier tile in the Manufacturer Part Search panel, and choosing the Import Into LibraryName As ComponentName / PartNumber command. This command is used to create a new component in the target library DbLib/SVNDbLib directly from the selected Supplier Item. The ComponentName/PartNumber for the new component will be named using the Supplier Item's Manufacturer Part Number parameter. A Supplier Link to the item will be added to the component record, along with all parameters for that item (parameters, data sheet links, pricing and stock information).

    Demonstration video showing how a supplier link can added to the database record, in the Database Library editorDemonstrating the addition of a Supplier Link to a component record in the linked database.

    Viewing/Editing Supplier Links

    The Supplier Links currently defined for a database component can be viewed and edited using the Supplier Links for dialog. To access this dialog, right-click inside the record for the component, on the Table Browser tab of the active DbLib/SVNDbLib file, and choose the Edit Supplier Links command from the context menu.

    Existing supplier links can be edited via the right-click menuAn example of editing the currently defined Supplier Links for a selected database component. Click Add to open the Add Supplier Links dialog, and search for an additional supplier.

    The Supplier Links for dialog lists all of the currently defined supplier links for the component.

    In the dialog you can:

    • Select a supplier and click the delete button ( Delete button, click to delete the selected supplier ) to remove that supplier.
    • Click and drag a supplier to change its position in the order of suppliers.
    • Click the Add button to add an additional supplier. The Add Supplier Links dialog will appear, from where you can search for, and add an additional Supplier Link. Searching for Supplier Items is performed in the same way as when using the Manufacturer Part Search panel.

    Click the Gear button, click to configure the currency and the preferred suppliers button to configure the currency and the preferred suppliers in the Manufacturer Part Search panel or the Add Supplier Links dialog.

    Modifying Symbols and Footprints

    Besides maintaining the content within the database itself, there is also a requirement to maintain the referenced symbols and models, as and when necessary. This involves making modifications to the schematic symbols and the footprint model(s). And for a standard database library (DbLib), the definitions in simulation model files.

    Both types of database library - standard and version-controlled - provide the ability to access the referenced symbol and footprint model for editing, directly from within the main DbLib/SVNDbLib document view when open as the active document. The following sections take a look at how to do so, which is a little more involved, but also a little more powerful, when using an SVNDbLib.

    Note that only the symbol and default footprint for a component record can be accessed for editing through the respective (and active) database library file. Remember that the default footprint model is the one entered into the Database Field Name that is mapped to Design Parameter.

    When using a DbLib

    To open a component's referenced symbol/footprint model library file for editing, right-click on the component's entry in the Table Browser, then select the appropriate command - either Open Symbol, or Open Footprint - from the context menu. The applicable library file will be opened and the symbol/footprint presented as the active entity in the workspace, ready for you to perform your edits.

    The library opened will be the one in which the referenced symbol/footprint is found - either specifically, if library information is present in the database, or if this is not present, by using the defined paths on the Symbol and Model Search Paths tab of the Database Library Options dialog. Refer back to the section on Specifying Symbol and Model Library Locations for a Database Library.

    Once changes have been made as required, save the library file.

    The referenced schematic symbol can be opened for editing from the Database Library fileExample of accessing a database component's referenced symbol, directly from within the DbLib.

    The source library file could also be accessed outside of the DbLib file. Either use the library editor's File » Open command to browse to and open, the required library, or drag-and-drop the library file from Windows Explorer directly into Altium Designer.

    When using an SVNDbLib

    As mentioned, the ability to access and edit the symbols and models referenced by database components, and accessed through an SVNDbLib file, is a little more complex, but also more powerful. Modifications are made to local working copies of the libraries stored in the SVN repository.

    Specifying a Local Workspace

    To make modifications to component symbols and footprint models, you will need to check the files out from the repository into a local working directory. Specify the required directory to be used on the Data Management - SVN Libraries page of the Preferences dialog. A default working folder location is defined - . Change this as required by either clicking the Button used to browse and select the repository working folder button to browse to an existing folder, or by entering a path to the folder directly.

    The folder nominated as the local working directory should only be used to contain a copy of the version-controlled files. Other files, such as , , and , should be located in a different directory, as these are not under version control.

    Specifying the location of the working copy of the symbol and footprint model files, referenced from an SVNDBLibSpecifying a local working directory.

    The default working folder location does not physically exist by default. This will be created when checking out files from the repository. This will also be the case if you specify a folder (through direct path entry) that does not currently exist.

    To quickly check out all symbol and footprint model libraries from the repository into the nominated local working folder, run the Check Out All Working Folders command from the SVNDatabaseLib Editor's main Tools menu. The folders checked out will be those specified in the Models Location region, on the SVN Repository tab of the Database Library Options dialog.

    Image showing where to specifiy the location of the models in the SVN repository, and where they are checked out toAn example of the symbols and footprints - stored within the SVN repository and specified as part of the Database Library Options - checked out to a local working folder.

    Making Changes

    Once the symbol and footprint model libraries have been checked out to your designated local working folder, you can then make modifications as and when required. This involves making modifications to the local copy of the schematic symbols and footprint models, then committing these changes back to the SVN repository.

    As with a DbLib, the following methods of accessing a symbol/model for editing are available:

    • Within the SVNDbLib document, right-click on the component's entry in the Table Browser, then select the appropriate command - either Open Symbol, or Open Footprint - from the context menu.

    The local library opened will be the one in which the referenced symbol/footprint is found - either specifically, if library information is present in the database, or if this is not present, by using the defined model locations on the SVN Repository tab of the Database Library Options dialog. Refer back to the section on Specifying Symbol and Model Library Locations for a Database Library.

    • If the SVNDbLib is added to the Available File-based Libraries list, you can access edit commands directly through the Components panel. Select the required component entry, then use the Edit Symbol command (on the right-click context menu for the Components region) or Edit Footprint command (on the right-click context menu for the Models region), respectively.
    • Use the library editor's File » Open command to browse to and open, the required library (in your local working folder).
    • Drag-and-drop the library file (in your local working folder) from Windows Explorer directly into Altium Designer.

    In each case, once changes have been made as required, save the library file.

    However, the main interface between the folders and files checked out to the local working folder, and the repository itself, is the Storage Manager panel. When the SVNDbLib file is the active document, the Storage Manager panel will populate with the symbol and model folders checked out to the local working folder. The exact folders listed will be those specified in the Model Locations region, on the SVN Repository tab of the Database Library Options dialog.

    The Storage Manager panel shows the model files checked out in the SVN working foldersThe Storage Manager panel reflects the local working folder - provided the SVNDbLib file is the active document within Altium Designer.

    To open a library file for editing, right-click on its entry in the All Files region of the panel, and choose Open from the context menu that appears. Make changes as required and save the file as normal using the associated Editor's standard Save command.

    Committing Changes to the Repository

    Panel page:Storage Manager

    Although there are different ways to open a library for editing, committal of any changes made - from within Altium Designer - can only be carried out through the Storage Manager panel.

    Within Altium Designer, the controls for committing to, and updating from the repository, are solely available through the Storage Manager panel. Of course, you can also commit, update, and check for modifications outside of Altium Designer, using the features and functionality of your external SVN client.

    One of the most important things to remember when using the Storage Manager panel, is to refresh the status of the link between the local working folders/files (displayed in the panel) and the corresponding folders/files in the source control repository. For an individually-selected library, this is achieved using the Refresh command, available from the right-click menu in the All Files region of the panel. To quickly refresh the status of an entire folder, use the Ctrl+F5 keyboard shortcut.

    Refreshing the status of the source libraries becomes even more important in a multi-librarian environment, where several people may be responsible for maintaining the repository of source symbol and model files.

    Status entries pertinent to working with the local libraries of symbols and models are:

    For more information on working with version control, see Using Version Control.

    Physical Comparison of Revisions

    Physical comparison can be performed between any two revisions of the same symbol (model library). This allows you to clearly see, in a visual manner, the changes that have been made - between consecutive or non-consecutive revisions of the file.

    Within the Storage Manager panel, comparison is performed from the VCS Revisions region at the bottom of the panel.

    The VCS Revisions section of the Storage Manager is used to manage and review the version historyThe Storage Manager panel presents two views for the history of a selected file, with separate regions for the VCS Revisions and Local History.

    Comparison can be made between any two revisions. Using the Windows Ctrl+click selection technique, select the two revisions of the library you wish to compare in the VCS Revisions region of the panel, right-click, and choose Compare.

    Once the Compare command is invoked, the two selected document revisions will be opened side-by-side in the workspace, the graphical comparison is made, and any differences detected between the two will be listed in the Differences panel.

    A graphical comparison of two versions can be performed, the Differences panel details all of the detected differencesGraphical comparison directly in the library editor workspace.

    Making the Database Library Available

    Like any other library, a standard (or version-controlled) database library is made available through the Components panel by adding it to the Available File-based Libraries list. From the Components panel, click the Menu button ( Settings button, click to add libraries or perform more complex searches ) at the top right to open the menu, and select the File-Based Libraries Preferences command. The Available File-based Libraries dialog will open. The DbLib/SVNDbLib can be added as a project library, or as part of the installed libraries - making it available to all projects and not just the active one. Alternatively, you can specify a search path to the folder in which the DbLib/SVNDbLib file resides.

    Database libraries are made available by adding them in the Available File-based Libraries dialogMaking a database library available for use by adding it as an installed library.

    The Components panel now becomes a 'browsing window' into the linked external database, and the table(s) of components it contains.

    Browsing the Database Components

    Once the DbLib/SVNDbLib has been added to the Available File-based Libraries list, the components in the database will become available for browsing in the Components panel. Although only a single DbLib/SVNDbLib file is added, each table in the linked database will present as if it were a distinct library.

    Remember that if the target database has been created using multiple Excel spreadsheet files (), there is a limit of 64 sheets that can connect, due to ODBC driver limitations.

    The top drop-down list in the panel will populate with entries of the form:

    • or where your database has tables
    • or where your database is comprised of sheets in an Excel spreadsheet.

    Select the active library from the dropdown at the top of the Components panelExample of a loaded DbLib with three tables, another with one table, and an SVNDbLib with one table.

    Each component entry in the panel corresponds to a record in that particular table of the database. In fact when browsing loaded database libraries, the Components panel behaves like a direct database browser. Symbol and model information is populated from the underlying symbol and model libraries pointed to by the relevant fields of the database (and in conjunction with search paths/locations defined).

    Through the Components panel, the database library gives access to the components stored in the linked databaseBrowsing components in an external database linked through a database library.

    By default, only the and fields are displayed in the component listing region of the panel. To 'expose' other fields in the database table, right-click in the region and choose Select Columns from the context menu. This will give you access to the Select Columns dialog, from where you can enable the display of any of the additional fields in that table.

    Searching for a Component

    The external database that you have connected to may include a number of tables, each with a sizeable amount of component records. Being able to place directly from a database is one thing, locating the specific component that you want to place can be more challenging. The Components panel supports two approaches to searching.

    In-Panel Searching

    The Components panel includes a Search field, enter a string and press Enter to search the current library for that string, anywhere within the visible component parameters.

    A search can be performed directly in the Components panelYou can perform a search directly in the Components panel.

    Performing Detailed Searches

    For more detailed searching, the File-Based Libraries Search dialog is used.

    Click the Menu button at the top of the panel to open the File-Based Libraries Search dialog, from where you can conduct a search of database components in a single table of an installed DbLib/SVNDbLib file. To enable searching of database components, set the Search in field to and select the required Table. Note that the available Fields, listed in the drop-down above, will change to reflect the column headings available in the chosen table. The remaining options in the dialog become grayed-out, as they are not relevant when searching database libraries.

    Database libraries can also be searched in the File-based Libraries Search dialogAccessing the File-based Libraries Search dialog.

    The detailed search facility essentially offers two 'levels' of searching - Field-based and SQL-based querying.

    Field-Based Search

    This is a 'coarse' search that will return all database components found in the specified table. Click the Search button, at the bottom-left of the File-based Libraries Search dialog, to begin the search. The dialog will close and the results of the search will be listed back in the Components panel. After performing a search, the libraries drop-down list will contain the entry , indicating that this list is the search results.

    Search results are listed in the Components panelExample results after conducting a field-based search.

    SQL Query Search

    To perform an SQL query search, click the >>Advanced link in the Libraries Search dialog. The dialog will change, to look like that illustrated in the following image. This level of searching offers a 'fine' search based on a specified query expression, where you can enter an SQL query directly into the query editor section of the dialog.

    Click Advanced in the File-based Libraries Search dialog to perform a SQL-based query searchHover over the image to see how the dialog changes when you click Advanced, giving you access to a more
    powerful SQL-based query search. Click Advanced again to come back to the simple-style search.

    Localized Caching (SVNDbLib Only)

    When an SVNDbLib file is added to the Available Libraries list, the symbol and model libraries in the repository are cached in a temporary folder, local to the Designer's computer. When an action in the software calls for the use of a schematic symbol, or model, that symbol/model is retrieved from the local cache.

    Automatic Cache Update

    The libraries in the cache will be automatically updated with the latest from the source control repository, when performing any of the following actions within the software:

    Although the update is automatic, it can be controlled by the use of an option available on the Data Management - SVN Libraries page of the Preferences dialog, highlighted in the following image.

    The frequency that the repository cache is refreshed is configured in the Preferences dialogSetting a minimum update time threshold for the local cache.

    This option essentially provides an 'update timer' for the local cache. If the specified time has elapsed since the last time the cache was updated, then the cache will be updated automatically when one of the listed actions is performed. If an action is performed within this time, the current content of the cache will be used, which may be out of date compared to the content in the repository.

    Manually Forcing an Update of the Cache

    There may be times when you wish to force an update of the local cache, to ensure you have the most up-to-date libraries that are currently stored in the source control repository. For example, when gearing up to transfer the design from the schematic to the PCB.

    You can force an update of the cache, manually, using one of the following methods:

    • Using one of the Refresh commands available from a right-click menu in the Components panel.
    • Uninstalling and re-installing the SVNDbLib file to the Available Libraries list.

    Whenever you restart Altium Designer, the local cache will be automatically refreshed with the latest libraries stored in the SVN repository.

    Placing a Component

    Placement is performed as it is for any other library loaded and available in the Components panel. With the target schematic sheet open as the active document, select the component you want to place from the panel and either right-click and select the Place command, or drag-and-drop the component directly onto the sheet. The component is built on-the-fly, with the following actions taking place:

    • The schematic symbol specified in the database record is retrieved from the relevant schematic component library.
    • Any referenced footprint model(s) are linked in (and any referenced simulation models, if using a DbLib).
    • The design parameters specified in the DbLib/SVNDbLib file are added (in accordance with the associated Add To Design update setting) to the component.

    After placement, double-click on the component on the schematic to open the Properties panel, where you can edit the component properties. On the General tab of the panel you will see:

    • The value for Design Item ID (Component Name / Part Number). This is the chosen key field defined in the Field Settings region of the DbLib/SVNDbLib file, and is typically the part number.
    • The name of the parent DbLib/SVNDbLib file - and the specific database table in which the component resides.
    • The linked footprint and symbol models.

    The design parameters will be detailed on the Parameters tab of of the panel.

    Image showing how the component is built as it is placed from the details in the database recordInformation added to a component placed from a database, linked-to using a DbLib file. Hover over the image to see the example when placed from a database that is linked-to
    using an SVNDbLib file.

    You can change the placed component to another from the same table by clicking the ellipsis button in the Design Item ID field ( Click the ellipsis button in the Design Item ID field to open the Replace Component dialog ). This will open the Replace dialog, initially listing all components in the same table. In fact, you can change to a component in a different table of the same DbLib/SVNDbLib file, browse to one in a different File-based library, or place from an available Managed Content Server. The region will update accordingly with the new information for the chosen component.

    Clicking the Validatebutton ( Validate button, click to check that the component-to-database linking is correct) will query the database for the component, returning in which table (and through which mapping file) the component is found.

    Ensuring Synchronicity

    After placement, the chosen key field parameter is used to ensure that the placed component on the schematic, retains its link to the corresponding record for that component in the external database. This means that at any stage in the future, changes to parameter and model information in the database can be easily passed back to the placed component, synchronizing the two.

    If you want to update parameter information, use the Update Parameters From Database command, available from the Schematic Editor's main Tools menu.

    To perform a full update, including parameters, model and graphical attributes of schematic symbols, use the Update From Libraries command (also available from the Schematic Editor's main Tools menu).

    In the PCB Editor, use the Tools » Update From PCB Libraries command to update placed footprints with the latest information stored in the source libraries.

    Dual Synchronization - DbLib/SVNDbLib and DBLink

    You may have an existing design project where the majority of the placed parts have been linked to an external database using a DbLink file. Design changes may result in additional circuitry, the components for which might be placed using the Database Library feature. The associated DbLib/SVNDbLib file could, quite conceivably, point to a different external database.

    When using the Update Parameters From Database command, all linked parameters for placed components will be queried - across all linked databases, irrespective of the linking method used - and detected differences for those parameters displayed in the Select Parameter Changes dialog.

    If the same database field has been used for matching in both the DbLink and DbLib/SVNDbLib files, the database linked by the DbLink file will be searched first for a match, followed by the database linked to by the DbLib/SVNDbLib file. If the component is present in both databases, you could quite possibly match and update from the wrong external record.

    Adding Database Information Directly to a BOM

    Related page:BOM Configuration in the Report Manager

    Source information for a Bill of Materials (BOM) has, in the past, been taken from the parameter information of the placed components for the design. But that can lead to a lot of information attached to a schematic that is only ever used for the BOM. If your placed Altium Designer components are linked to an external database using a database library file, the BOM Generator is able to extract any other record information that has not been added to the components as design parameters.

    Parameters can be included from an external database, irrespective of the method employed to link to that database - DbLink, DbLib, or SVNDbLib.

    When configuring the Bill of Materials report using the Report Manager dialog, click the Database Parameters button ( Database Parameters source button, click to make linked database parameters available in the Report Manager ) in the Columns tab of the dialog to include them as a Source for the BOM, as shown below. This option will only be available if one or more components in your design are linked to an external database.

    In the Columns listing, the Database icon, indicates that this parameter comes from the database icon is used to distinguish a parameter that exists for one or more placed components in a linked external database. Click the visibility icon so it becomes an eye ( Visibility icon ), to include that column (parameter) in your BOM.

    Report Manager dialog, showing how to include additional database information in the BOMInclude additional component information that exists only in an external database.

    For a design that includes Variants, the parameters used to query the database are varied in the Variant Management dialog. Since those parameter values only exist in the Variant Management dialog, they are only used to query and match records in the database when a BOM is being configured for generation. To do this, ensure the sub-option - Include DB Parameters in Variations - is enabled in the General tab of the Report Manager properties.

    Altium Designer also includes a power BOM editor, called ActiveBOM. ActiveBOM has a full suite of BOM management features, including the ability to add additional BOM items, as well as tight integration with the component supply chain.

    ► Learn more about ActiveBOM

     

    Sours: https://www.altium.com/documentation/altium-designer/working-with-database-libraries-ad
    Altium Designer Library Installation - Celestial Altium Library free open source library

    Database Library Migration Tools Available in Altium Designer

    Parent page:Working with Database Libraries

    Altium Design Software provides the ability to place components directly from a company database by creating and using a database library. The type of database library used will depend on how you want to handle your source symbol and model libraries. If the libraries are to be kept in a location on a hard disk or network drive, you would simply use a Database Library (DbLib). If, on the other hand, you want to place your libraries under source control using a Subversion repository you would use an SVN Database Library (SVNDbLib).

    Regardless of the type of database library used, the underlying principal of the feature remains the same in each case - the ability to place directly from the linked external database. To make this powerful feature as accessible as possible, tools are provided that enable you to quickly move existing libraries into the database library structure. These tools allow you to migrate from:

    • An Integrated Library to a Database Library (DbLib or SVNDbLib).
    • A Database Library (DbLib or SVNDbLib) to an Integrated Library.
    • Source Schematic/PCB libraries to an SVN Database Library.
    • A Database Library to an SVN Database Library.
    • An OrCAD Component Information System (CIS) to a Database Library (DbLib).

    The following sections take a closer look at how these migrations are performed within the software.

    Creating a Database Library From an Integrated Library

    Integrated libraries are, by nature, inherently secure. Added to this is their ideal portability for designs that leave your company site. If the design is to be kept on-site and/or you want to have your Altium Design components tightly coupled to your company database, then Database Libraries are the perfect choice. The software provides the ability to quickly convert your company integrated libraries into the Database Library (DbLib) or SVN Database Library (SVNDbLib) structure . Multiple integrated libraries may be included in the conversion, with each one being added as a separate table to the target database.

    Converting to a DbLib

    Creating a standard database library (DbLib) from an integrated library (IntLib) is performed using the Integrated Library to Database Library Translator Wizard. The wizard essentially decompiles nominated integrated libraries, with each library used to build a separate database table in a chosen target database, complete with parameter and model information extracted from the components within. A specified database library file is then used to provide a connection to that database.

    The Wizard also can be used to effectively import/append additional components into an existing database, which is linked to using an existing DbLib file.

    Conversion supports the use of an Access-type database only.

    Integrated Library to Database Library Translator WizardBringing one or more source integrated libraries into the database library structure is a streamlined process, using the Integrated Library to Database Library
    Translator
    Wizard.

    The process involves the following steps:

    1. Create a new or open an existing database library file (). Typically, you would use an existing DbLib file when converting one or more integrated libraries into an existing Access database to which that DbLib file is currently connected.
    2. With the Database Library file () open as the active document, choose the Tools»Import From Integrated Libraries command from the main menus to access the Integrated Library to Database Library Translator Wizard.
    3. Use the initial page of the Wizard to specify the target database - either a new Access database or an existing one. If creating a new database, click on the folder symbol to the right of the Database Location field to access a standard Open dialog. Use this dialog to determine where and under what name the new database is to be created. The chosen name/path will be entered into the Database Location field.

    If the Wizard has been accessed from an existing DbLib file, the Existing Access Database option will be selected by default and the Database Location field will be pre-filled with the database to which that DbLib file connects.

    1. Use the next page of the Wizard to specify the target database library file. Either specify the path and name for a new DbLib file to be created, or browse to and open an existing file. By default, the active DbLib file will be prefilled into the field.

    If you do use an existing DbLib file and the target database is changed, after the Wizard finishes, the DbLib file will be connected to the new target database.

    1. Use the following page of the Wizard to specify the integrated libraries that you want to convert. Use the Add button to open the Select Source Integrated Libraries dialog from where you can browse to and select the required libraries. The constituent schematic symbol and model libraries (where they exist) will be extracted and saved into the location specified in the Destination Folder field.

    By default, the Destination Folder will point to a sub-folder - - below the folder containing the DbLib file (nominated on the previous page of the Wizard).

    1. After choosing the source integrated libraries, click Next to proceed with the conversion. A progress bar will be displayed along with information on the current library being translated. After the conversion has completed, click Finish on the last page of the Wizard to make the specified DbLib file active in the main design window (if not already).

    Each integrated library involved in the conversion will result in a separate table in the database, named after the integrated library. For an existing database, if a table already exists with the same name as the integrated library, the information from that library will be appended to the existing table.

    Resulting DbLib fileResulting DbLib file after the translation process has completed.

    With the translation process complete, you can then go into the source schematic libraries and remove all parameter and model information from the symbols. Then you can make any fine-tuning configuration changes to the field mappings in the DbLib document to reference the appropriate database columns, as required. For more information, refer to the Mapping Database Fields to Design Parameters section of the Working with Database Libraries document.

    The Wizard will only extract footprint model information in terms of model reference and path to the defined model(s). For Simulation models, link information will need to be entered manually into the external database.

    Ensure that your schematic library components in the IntLib do not possess a parameter. The Part Number information entered into the database (to identify each component record) is sourced from the schematic component's Design Item ID field in the Properties section on the General tab of the Properties panel when browsing the properties of the selected library component. To enter it as a parameter as well will result in conversion failure due to duplicated values.

    Converting to an SVNDbLib

    Creating a version-controlled database library (SVNDbLib) from an integrated library (IntLib) is performed using the SVN Database Library Conversion Wizard. The Wizard essentially decompiles nominated integrated libraries with each library used to build a separate database table in a new target database complete with parameter and model information extracted from the components therein. A specified SVN database library file is then created, which is used to provide connection to that database. The constituent Schematic and PCB libraries are split and committed to specified directories in a nominated SVN version control repository, which are referenced by the SVNDbLib file.

    Conversion supports the use of an Access-type database only.

    SVN Database Library Conversion WizardBringing one or more source integrated libraries into the SVN database library structure is a streamlined process, using the SVN Database Library Conversion Wizard.

    The process involves the following steps:

    1. Access the SVN Database Library Conversion Wizard. This is done by:
    • Choosing the Tools » SVN Database Library Maker command from the schematic library editor, PCB library editor, or database library editor main menus.
    • In the Projects panel, right-clicking on the entry for a project library (SchLib, PcbLib, or IntLib) then choosing the SVN Database Library Maker command from the context menu.
    1. Use the Libraries to Convert page to specify the integrated libraries that you want to convert. The list will initially be pre-populated with one or more libraries (the active library or all project libraries that have been added to the project depending on the method of access used). Remove these from the list before choosing the integrated libraries you want to convert. Use the Add button to access the Library Files dialog from where you can browse to and select the required integrated libraries.
    2. Use the Options page to define conversion-related options including how the source libraries should be split, in which directories of which repository they should be stored, and the output directory for the SVNDbLib file. For a schematic library, two options are also provided that allow you to strip the parameter and/or model information from each constituent component leaving just the bare symbol.

    The SVN repository and its folder structure must be defined beforehand. You are simply targeting it and the folders within its structure into which to store the split library files. Repository and folders are not created on-the-fly.

    1. After choosing the source integrated libraries and setting the related conversion options as required, click Next to proceed with the conversion. A progress bar will be displayed along with information on the current library being converted. The conversion process involves:
      1. Extraction of the source libraries from the supplied integrated libraries.
      2. Splitting the schematic and PCB libraries into single symbol/footprint library files.
      3. Committing the split symbol and footprint libraries to the repository in the specified base directories.
      4. The Wizard will only extract footprint model reference information. Linked simulation models are supported for a version-controlled database library (SVNDbLib), however, storage of simulation model files in the Subversion repository is not supported. Where such links exist, they will be added as parameters.
      5. Building a separate database table in the generated Access database (which takes the same name as that specified for the SVNDbLib) for each integrated library being converted, complete with parameter and model information extracted from the components therein. Each table is named using the name of the name of the integrated library with an suffix (e.g., ).
      6. Creating the specified SVNDbLib file, connecting to the database and repository.
    2. After the conversion has completed, click Finish to close the Wizard and make the SVNDbLib file the active document.

    Resulting SVNDbLibResulting SVNDbLib file after the conversion process has completed.

    Ensure that your schematic library components in the IntLib do not possess a parameter. The Part Number information entered into the database (to identify each component record) is sourced from the schematic component's Design Item ID field in the Properties section on the General tab of the Properties panel when browsing the properties of the selected library component. To enter it as a parameter as well will result in conversion failure due to duplicated values.

    Creating an Integrated Library from a Database Library

    Database Libraries are an ideal choice if you want your Altium Design components to be tightly coupled to your company database. If the design needs to leave your company site or if you prefer to have your designers work from secure integrated libraries, this can be readily achieved. The software provides the facility to compile an integrated library directly from a database library either a standard database library (DbLib) or a version-controlled SVN database library (SVNDbLib). In this way, your CAD librarians can still use database libraries, while your designers use regularly-regenerated integrated libraries working in an 'offline' fashion as it were.

    Conversion is performed using the Offline Integrated Library Maker. The process is carried out on a per-database table basis with full control over which tables in the database are considered. A separate integrated library will be generated for each included table.

    Offline Integrated Library Maker
    Convert your database libraries (DbLibs or SVNDbLibs) to 'offline' integrated libraries using the Offline Integrated Library Maker.

    The process involves the following steps:

    1. With the Database Library file () or SVN Database Library file () that you want to convert open as the active document, choose the Tools»Offline Integrated Library Maker command from the main menus to access the Offline Integrated Library Maker.
    2. Use the Library to Convert page to specify the DbLib or SVNDbLib to be processed. The active library from which the Offline Integrated Library Maker was accessed will be specified as the library to convert by default. You can freely browse for and choose a different database library if required.
    3. Use the Options page to specify which of the tables in the linked database are to be included in the conversion. All database tables are included by default. To exclude a table, ensure that its associated Convert option is disabled. This page also enables you to nominate an output directory in which the generated integrated libraries will be stored. Enter the path to this base directory directly or click the Browse icon icon to the right of the field to access a dialog from where you can browse to and select the required directory. The generated output (integrated library) for each included database table will be stored in its own sub-folder within the specified output directory, which is named using the table's name.
    4. After choosing the database library and setting the related conversion options as required, click Next to proceed with the conversion. A progress bar will be displayed along with information on the current database table being converted. Remember that the conversion process is carried out for each database table you have nominated to convert. The following is essentially a breakdown of this process:
      1. An integrated library package () is created and opened in the Projects panel. The package is named using the name of the table. For a table named , for example, this would give .
      2. A schematic library document is created and added to the LibPkg. The schematic is again named using the table's name (e.g., ).
      3. Each record in the table is then considered and the appropriate Altium Design component is built. To do this, the referenced schematic symbol is retrieved from the appropriate source library and added as a component to the new schematic library document. Parameter and model link information defined in the record is then added to that component.
      4. The referenced footprint model(s) for the record are retrieved and added to a PCB library document. This document is again named after the table (e.g., ). The PCB library document is then added to the LibPkg.
      5. If the source library is a DbLib, and Simulation model links have been defined in the database record, the referenced Simulation model files are also added to the LibPkg. The location of such models remains unchanged. The full path to a model is specified as part of its corresponding model link.
      6. The LibPkg is then compiled to give the integrated library (e.g., ), which is subsequently added to the software's Installed Libraries.

    Resulting files
    Results of the conversion process - library package projects with constituent symbol and footprint model documents, and the compiled IntLibs, which are also added as installed libraries, and therefore made available to all PCB design projects.

    Creating an SVNDbLib from Source Libraries (SCHLib/PCBLib)

    You may have opted to use source schematic and PCB libraries added to the design project rather than compiling them into an integrated library. Perhaps you want to edit the source components in these libraries frequently and prefer not to decompile and recompile the corresponding IntLib each time. Version-controlled database libraries (SVNDbLib) offer a similar deal - the ability to quickly access the source libraries for modification, coupled with the security of having those libraries stored in a source control repository.

    The software facilitates the quick and simple conversion from your existing source schematic and PCB libraries into the SVN Database Library structure. Conversion is performed using the SVN Database Library Conversion Wizard in much the same way as when converting an integrated library. Multiple libraries of each type may be included in the conversion with each schematic library added as a separate table to the target database.

    Conversion supports the use of an Access-type database only.

    SVN Database Library Conversion WizardBringing one or more source schematic and PCB libraries into the SVN database library structure is a streamlined process using the SVN Database Library
    Conversion
    Wizard.

    The process involves the following steps:

    1. Open the SVN Database Library Conversion Wizard in the following ways: 

    The Wizard pre-populates with library entries based on from where it is accessed, therefore, to save time, launch the Wizard from the appropriate editor as outlined below.

    • From the schematic library editor - with the source schematic library open, click Tools » SVN Database Library Maker from the main menus. However, if you want to involve the linked footprint models in the conversion, you will need to browse for and add the respective PCB footprint library(ies).
    • From the PCB library editor - with the source PCB library open, click Tools » SVN Database Library Maker from the main menus. However, conversion of the PCB footprint libraries alone is not a typical scenario and you will therefore need to browse for and add the respective schematic component libraries.
    • From the Projects panel - right-click on the entry for a library file then choose the SVN Database Library Maker command from the context menu. The Wizard will automatically load all project libraries. This is by far the easiest method and requires that the source schematic and PCB libraries are added to a project. Quite often, this will be the case when integrated libraries have not been used.
    1. Use the Libraries to Convert page to specify the source schematic and PCB libraries that you want to convert. The list will initially be pre-populated with one or more libraries (the active library or all project libraries that have been added to the project depending on the method of access used). Modify the list as required. Use the Add button to open a dialog from where you can browse to and select required source schematic and PCB libraries.
    2. Use the Options page to define conversion-related options, including how the source libraries should be split, in which directories of which repository they should be stored, and the output directory for the SVNDbLib file. For a schematic library, two options are also provided that allow you to strip the parameter and/or model information from each constituent component, leaving just the bare symbol.

    The SVN repository and its folder structure must be defined beforehand. You are simply targeting it and the folders within its structure into which to store the split library files. Repository and folders are not created on-the-fly.

    1. After choosing the source schematic and PCB libraries and setting the related conversion options as required, click Next to proceed with the conversion. A progress bar will be displayed, along with information on the current library being converted. The conversion process involves:
      1. Splitting the schematic and PCB libraries into single symbol/footprint library files.
      2. Committing the split symbol and footprint libraries to the repository, in the specified base directories.
      3. The Wizard will only extract footprint model reference information. Linked simulation models are supported for a version-controlled database library (SVNDbLib), however, storage of simulation model files in the Subversion repository is not supported. Where such links exist, they will be added as parameters.
      4. Building a separate database table in the generated Access database (which takes the same name as that specified for the SVNDbLib) for each schematic library being converted, complete with parameter and model information extracted from the components therein. Each table is named using the name of the schematic library with an suffix (e.g., ).
      5. Creating the specified SVNDbLib file, connecting to the database and repository.
    2. After the conversion has completed, click Finish to close the wizard, and make the SVNDbLib file the active document.

    Resulting SVNDblibResulting SVNDbLib file after the conversion process has completed.

    Ensure that your schematic library components do not possess a parameter. The Part Number information entered into the database - to identify each component record - is sourced from the schematic component's Design Item ID field in the Properties section on the General tab of the Properties panel when browsing the properties of the selected library component. To enter it as a parameter as well will result in conversion failure due to duplicated values. While the process will complete, any schematic component that has this parameter will not be created in the database and will therefore not appear in the listing of database components on the Table Browser tab of the SVNDbLib document.

    Converting a DbLib to an SVNDbLib

    You may already be enjoying the power of the Database Library feature after having converted your existing integrated libraries to the DbLib structure or having created a DbLib from scratch. Extending on this, you may want to move your source symbol and footprint libraries under the protective and secure wing of a source control repository. The software provides the means to effect this migration from your current standard database library (DbLib) to a version-controlled database library (SVNDbLib).

    Conversion is performed with the SVN Database Library Conversion Wizard in much the same way as when converting an integrated library.

    SVN Database Library Conversion WizardConverting an existing standard database library (DbLib) to a version-controlled database library (SVNDbLib) is a streamlined process using the SVN Database
    Library Conversion
    Wizard.

    The process involves the following steps:

    1. Open the existing DbLib to be converted then choose Tools » SVN Database Library Maker from the main menus. The SVN Database Library Conversion Wizard will open.
    1. Use the Libraries to Convert page to specify the source database library that you wish to convert. The Database Libraries option will already be enabled, with the associated field pre-populated with the path to the active library. If you want to convert a different DbLib, click the Browse icon button and use the resulting dialog to browse for it.
    2. After clicking Next, the chosen DbLib file is analyzed and a confirmation dialog appears, notifying you that the backend database may be modified. Click Yes to continue.
    3. Use the Options page to define conversion-related options including how the source libraries should be split, in which directories of which repository they should be stored, and the output directory for the SVNDbLib file. For a schematic library, two options are also provided that allow you to strip the parameter and/or model information from each constituent component leaving just the bare symbol.

    The SVN repository and its folder structure must be defined beforehand. You are simply targeting it and the folders within its structure into which to store the split library files. Repository and folders are not created on-the-fly.

    As the external database already exists - linked to the original DbLib file - one will not be created. The database will remain in its current location. If you want to have the generated SVNDbLib file and the database in the same location, you basically have two options. The first is to set the output path for the SVNDbLib to be the same directory in which the database currently resides. The second option is to generate the SVNDbLib in a different directory then move the database to that directory. In this case, you will need to remember to modify the connection within the SVNDbLib file to point to the database in its new location and reconnect.

    1. After choosing the source DbLib file and setting the related conversion options as required, click Next to proceed with the conversion. A progress bar will be displayed along with information on the library being converted. The conversion process involves:
      1. Splitting the schematic and PCB libraries, referenced by the component records in the linked database, into single symbol/footprint library files.
      2. Committing the split symbol and footprint libraries to the repository in the specified base directories.
      3. Creating the specified SVNDbLib file, connecting to the database and repository.
    2. After the conversion has completed, click Finish to close the Wizard and make the SVNDbLib file the active document.

    Resulting SVNDBLibResulting SVNDbLib file after the conversion process has completed.

    A Word about Field Mappings

    In the generated SVNDbLib, the mappings defined between fields in the database and design parameters on the Field Mappings tab remain as they were originally defined in the DbLib.

    Field Mappings tabField mappings remain the same between the original DbLib and the generated SVNDbLib.

    There are, however, two important areas to highlight:

    • Any defined path mappings for symbols and footprint models are ignored. The SVNDbLib uses only the mapped reference fields - and - for locating the required symbol and footprint within the libraries committed to the repository. The path information defined in the database is ignored as it points to libraries located on a hard disk or other local/network medium.

    If you want to still include path information in the database, modify the information to point to the libraries in the repository. It is worth remembering that not specifying library path information in the database makes it much more robust. The repository location and/or its internal folder structure could be changed and the database would not need to be updated.

    • Any defined simulation model mappings also will remain defined in the SVNDbLib file. However, storage of simulation model files in the Subversion repository is not supported. Although the model links will be added to a component instance when placed, the models themselves will not be found.

    Direct OrCAD® CIS Support

    Built on the foundation of the database library system, the software provides full support for connection to and use of existing OrCAD Component Information Systems (CIS). The CIS structure is essentially converted into Altium Designer's Standard Database Library structure (DbLib).

    From OrCAD to Altium Designer - Translations Required

    To provide the facility for direct placement from the external database (, ), the following file translations are required:

    • The OrCAD CIS Configuration File (), which handles the link to the external database and includes the database field-to-design parameter mapping information, must be translated into an Altium Designer Database Library file ().

    Altium Designer currently only supports OrCAD CIS .dbc files in binary format.

    • The relevant OrCAD library files must be translated into Altium Designer library files:
      • OrCAD Capture Library () > Schematic Library ().
      • OrCAD Max Library File () > PCB Library ().

    Creating the Database Library Automatically

    The simplest and most efficient method to create the DbLib file and source Altium Designer libraries is to use the Import Wizard (File»Import Wizard). On the second page of the Wizard, ensure that the entry is selected as the import file type.

    Import Wizard Select Files
    Use the Import Wizard to quickly translate your CIS Configuration file and related OrCAD libraries into Altium Designer DbLib and source library (SchLib and PcbLib) files.

    Follow the subsequent pages of the Wizard in which you are required to specify:

    • The location of the external database.
    • The location of the CIS Configuration File () - remember this must be in binary format and not XML.
    • Where and under what name the target DbLib file is to be created.
    • The OrCAD Schematic and/or PCB libraries referenced by the external database.

    When specifying the OrCAD source libraries, you also have control over where the resulting Altium Designer libraries are saved. By default, these libraries will be saved to the sub-folder  located in the same directory as the target DbLib file.

    ORCAD CIS Import Wizard
    Follow the pages of the Wizard, specifying the database, CIS Configuration file, source OrCAD libraries, and the target DbLib file.

    After specifying the source and target files and directories as required, click Next to proceed with the import. After the import is completed, click Finish to close the Wizard and make the DbLib file the active document.

    Resulting DBLib
    Resulting DbLib file, after the import process has completed.

    Things to be aware of:

    • A library search path is automatically added to the DbLib file on the Symbol & Model Search Paths tab of the Database Library Options dialog, which points to the directory containing the translated library files.
    • The parameter mapping information - including the defined lookup key - is taken directly from the OrCAD CIS Configuration file.
    • Two model mapping entries are automatically set. Example database field names for these and the Design Parameter entries assigned are:
      • >
      • >

    These entries provide the link to the source schematic symbol for a particular component record in the external database and the applicable PCB Footprint model linked to that component.

    Creating the Database Library Manually

    1. Creation of the DbLib file using the Import Wizard is the fastest method, but not the only method. You also can create the DbLib file manually. To do so:
    2. Create a new DbLib file, connecting it to the external database, and defining the mapping and parameter update options as required.
    3. You will then need to import the OrCAD libraries. This can be achieved by using the Import Wizard to translate the OrCAD library files (, ) into Altium Designer libraries (, ).
      1. When choosing the file types to import, select the entry.
      2. Skip the page for Importing OrCAD Designs and proceed to the page for Importing OrCAD Libraries. Add all source OrCAD libraries referenced by the database.
      3. Skip other subsequent pages relating to the import of design files.
      4. On the Output Library Options page, leave the default Output Libraries as PCB Project option enabled.
      5. On the Output Libraries page, specify the output directory for the generated library files.

    Orcad Designs and Libraries
    Importing the OrCAD source libraries, containing the symbols and footprints referenced within the database.

    1. After the import is complete, a folder titled  will be generated in the nominated directory. You can move the generated Altium Designer libraries to another location as required. For example, you may want to move the libraries to a folder named created within the directory containing the DbLib file.
    2. Once you have the symbol and footprint libraries, you will need to go back to the DbLib file and set up the library search paths (on the Symbol & Model Search Paths tab of the Database Library Options dialog) to point to the directory folder in which those libraries are stored.

     

    Sours: https://www.altium.com/documentation/altium-designer/database-library-migration-tools-ad

    Similar news:

    Celestial Altium Library

    An exceptional, open source database library for Altium, currently supporting MSSQL and SQL Azure as the backend for easy use within teams, and no data corruption unlike MS Access.

    Current part count in live database: 29, in over packages.

    This library has been built for high quality data, with high quality footprints and high quality 3D models.

    Download the Desktop Manager for Azure access and to manage your own firewall rules

    Join us on Slack

    You can now download the Celestial Altium Database Desktop manager (see above) to create an account and setup your own firewall rules. This will allow you to also keep your firewall rule up to date as you move between locations or if you have a dynamic IP address. One click and your firewall rule is automatically set. Please raise an issue on that project if you have problems with the desktop software.

    Digital Signing/Windows SmartScreen Warning

    Note: The installer and software are not digitally signed. Windows SmartScreen will tell you this, you need to click "More Info" before you can click "Run Anyway". The community has raised funds for a code signing certificate, so this will be getting implemented as soon as it is issued!

    What the Desktop Manager does for you

    In addition to registering for AzureSQL access and managing your own firewall rule, the software will also setup the DbLib and UDL files for you. You just point it at the location you cloned or downloaded this library to, and it will take care of the rest.

    If you want to view the database through SQL Management Studio/Visual Studio you can use the credentials in the UDL file, or the UDL file directly.

    Altium Database libraries make you design your schematic with the part you are going to use, rather than a generic part with the same footprint. Rather than selecting "RJ45 Jack" you instead select Amphenol Commercial Products part number RJCSE This is reflected in your BOM - the entire BOM fills itself out, meaning no more trying to remember exactly what part you actually meant to put in there was, or what voltage that capacitor was.

    Prior to using a DBLib, it would often take me half a day to fill out the bill of materials. I'd have to find each resistor on the supplier's website, list it down with the supplier's part number, manufacturer, manufacturer name, etc Now I just generate the BOM in the output job, and everything is done. No more trying to remember "was that 33uF cap 25V or 50v?", or finding out after the fact that no, that capacitor isn't available as a 47uF 50V variant in that package, despite the fact you were sure it was!

    Basically: You save time on the design, and you greatly reduce errors occurring from specifying a part you didn't actually use (who hasn't accidentally specified a right angle connector variant when it was really vertical on the board - oops?)

    Why use this library over something like Ultra Librarian?

    Ultra librarian doesn't have high quality 3d models or parametrics. If all you need is basic footprint, Ultra librarian is what you want. If you want something open source, ultra high quality parts and with all the data fields you desire.. then you'll probably really like this library.

    If you're integrating your electronic design into a housing or designing injection moulded cases for it - you need accurate 3d models or your mechanical engineers will spend a lot of time making sure the case fits your design files.

    Data

    All parts in the database are matched with every relevant parameter that Digi-Key has for the part, so you can search/filter within Altium for the part you require. If you are looking for low Rds(on) N-Ch fets, just add the Rds(on) column to the Altium library window and sort by it.

    Every part has a link to the part on Digi-key, and has a link to the datasheet for the part for ease of design. Both the Digi-Key part number, price, and manufacturer name/part number are stored, now your BOM will be completely filled out automatically.

    Footprints

    Every part has a footprint created to match it's manufacturers recommended footprint by the manufacturer, or lacking that, an IPC Compliant footprint for the manufacturers specific package sizing. There are no generic footprints within this library, everything is manufacturer specific.

    Every footprint has a high quality, dimensionally accurate, accurately coloured 3d model. For complex parts (connectors like modular jacks), the manufacturers model is preferred however is always fully coloured and checked for accuracy against their drawings and modified as required. I've found issues with the accuracy of the manufacturer issued model from most models, where they do not match the datasheet - every instance has been checked with the manufacturer and many have re-issued their 3d models because of these checks.

    Basic parts (TSSOP/SOP/Resistors etc) I have created every model from scratch in SolidWorks, if the manufacturers dimensions vary from the JEDEC standard, they receive their own version of the 3d model (see SOT) For ultra basic parts with no features (QFN/DFN), a black basic Altium 3D extrusion is used of the correct size.

    Every part's centre position is where the Pick and place head should grab the part. For companies running their own Pick and Place machine, this is very convenient compared to centres at pin 1/centre of pads - your pick and place export list now has centres in the correct location.

    Symbols

    Every symbol in the library is somewhat standardised as to where pins are located, such as VCC in the top left, GND in the bottom left, user function pins on the right (controllable inputs/outputs). Standard protocols like SPI have the pins in the same order in every part - however manufacturer datasheet labeling is kept (DOUT rather than MISO for example) to make it easier to reference the datasheet. All components within a database category should have similar if not identical layouts/pin groupings where possible. This makes it much easier to switch out components.

    All passive components, such as resistors and capacitors all have the same size symbol lead span, keeping your schematics tidy.

    There are currently over parts in the library, this number sounds quite large but when you consider you need every value of resistor in 1%, %, %, % and %, in , , , and you're now looking at over resistors.

    Generally only SMT parts are in the library, except connectors, buttons and displays which have a mixture.

    There are currently parts from over manufacturers in the database.

    Currently there are database views for:
    • ADC - Programmable
    • Audio - Amplifier
    • Battery Holder
    • Button - Push
    • Button - Slide
    • Button - Tactile
    • Capacitor - Aluminium
    • Capacitor - Aluminium Polymer
    • Capacitor - Aluminium Through hole
    • Capacitor - Ceramic
    • Capacitor - RF
    • Capacitor - Tantalum
    • Capacitor - Tantalum Polymer
    • Charger
    • Chip LED
    • Connector - Backplane
    • Connector - Barrier Block
    • Connector - Card Edge
    • Connector - Dev Board
    • Connector - Modular
    • Connector - Modular w/Magnetics
    • Connector - Rectangular
    • Connector - RF
    • Connector - SD
    • Connector - Terminal Block
    • Connector - USB
    • Digital Isolator
    • Digital to Analogue Converter
    • Diode - Rectifier
    • Diode - TVS
    • Ferrite Chip
    • Gate Driver
    • Inductor - Power
    • Inductor - RF
    • Interface - CAN
    • Interface - Ethernet
    • Interface - RS
    • IR Receiver
    • LCD Display - Graphic
    • LED Driver
    • Light Pipe
    • MCU - ARM
    • MCU - AVR
    • Memory - EEPROM
    • Memory - FLASH
    • Motor Driver - Controller
    • Motor Driver - Stepper
    • Mounting Bracket
    • Multiplexer
    • N-Channel Dual FET Array
    • N-Channel FET
    • Optoisolators
    • Oscillator - Crystal
    • Oscillator - MEMS
    • Oscillator - TCXO
    • Oscillator - VCTCXO
    • Oscillator - XO
    • P-Channel Dual FET Array
    • P-Channel FET
    • Power Module
    • Reset Supervisor
    • Resistor - Chip
    • Resistor - Current Sense
    • Resistor - Potentiometer
    • RF Amplifier
    • RF Antenna
    • RF Attenuator
    • RF Detector
    • RF Filter
    • RF Module
    • RF Switch
    • Sensor - Current
    • Sensor - Magnetic
    • Sensor - Motion
    • Sensor - Pressure
    • Sensor - Temperature
    • Sensor - Thermocouple
    • Switch - DIP
    • Test Point
    • Thermistor - NTC
    • Video
    • Voltage Reference
    • Voltage Regulator - Linear
    • Voltage Regulator - Switchmode
    Currently on my ToDo list:
    • STM32F series (STM32F4, STM32F3, STM32F0)
    • Si Labs Gecko series
    • Current Sensors (more of)
    • Dual Row Headers
    • Larger Terminal Blocks (5/mm pitch)
    • Capacitance to Digital Converters
    • More LPC series of M0/M3/M4 (LPC)
    • Opto-isolators
    • RF SoC (EZR32WG, CC, nRF5)
    • RGB LEDS

    Want to contribute? Great!

    I'd really like to find someone with some free time and ASP.Net MVC experience to help me build out a management interface, please contact me - [email protected]

    To contribute parts: Please ensure your 3d models are completely accurate to the manufacturer's specifications. Do not submit parts with 3d models that are not sourced from the manufacturer, or that you have not created yourself from the manufacturers drawing. Parts sourced from the manufacturer should be correctly coloured in, most manufacturers give you colourless or very oddly coloured models (Hirose and JST especially.)

    Standard colours:

    • Black: SolidWorks [Plastics -> Medium Gloss -> Black Medium Gloss Plastic] R G B
    • Tin/Lead/other "silver" plating: SolidWorks [Metal -> Zinc -> Polished Zinc] R G B
    • Gold: SolidWorks [Metal -> Gold -> Polished Gold] R G B
    • White: SolidWorks [Plastics -> Medium Gloss -> White Medium Gloss Plastic] R G B

    The only time you should need to stray from these colours is for LEDS. Use SolidWorks Medium Gloss plastics for these colours.

    • Red: R B25 G25
    • Green: R73 G B84
    • Blue: R2 G61 B
    • Yellow: R G B35

    If you cannot colour your 3D model, do not submit it, ask someone (me?) to colour it for you.

    All models should have fillets, drafts and features as the real device would. If you can see it in the manufacturers drawing, it should be in the model. If you can see it in a photo or render on Digi-Keys site, it should be in the model. This library should only contain high quality parts.

    All footprints should match the specific parts manufacturer drawing, either as their recommended land pattern, or if that does not exist, then the generated IPC Compliant footprint that Altium made. Please ensure pin 1 is clear marked - a single dot to mark pin 1 is not clear enough, it can be easily lost on high density boards. Check what other similar parts have.

    Symbols should be laid out with pins in logical groups, not as they appear on the package or in their pin order. Do not use generic symbols for specialised parts. If an ISO/ANSI standard symbol exists for a type of component (transistor for example), use it.

    Altium License

    I have been asked several times if I have a legal Altium license - yes I do, my Altium user profile is here (must login to view)

    The profile is pretty empty, because Altium don't bother with bug fixes so I don't bother reporting them (existing DBLib issues have been around for 5+ years).

    License

    You may use this library commercially in commercial designs, however you may not charge your clients for component design time if you are just going to use a part from this library. You may not charge anyone for the footprints, 3d models or schematic symbols contained in this library. You may give you clients a copy of this library, as long as you attribute the source back to this GitHub Repository. You may not claim credit for the work in this library unless you have contributed it yourself, you must give attribution where it is due.

    Sours: https://gitee.com/codcat/altium-library


    1178 1179 1180 1181 1182