Altium Designer Best Practices (Part 2) - AltiumLive 2022

David Haboud
|  Created: February 3, 2022  |  Updated: February 24, 2022

This session will cover best practices of using the schematic to convey design intent using net classes and rules. Attendees will also learn to build complex design rules using priorities and classes for components, rules, and nets.


  • Working with the ActiveBOM document during the design process
  • Understanding design requirements 
  • Role of synchronization
  • Importance of appropriate clearance in the design process
  • Using rooms in the schematic

Additional Resources:

Article: Quickly Replicate Circuits with a Connection Room in Your PCB Layout
Design PCBs with a Free Trial of Altium Designer Here
Connect with David Haboud on LinkedIn
Six Basic Design Rules for Any PCB Design - Altium Whiteboard Videos


David Haboud:
Okay. Welcome, everyone. I'm David Haboud. I am a product marketing engineer here at Altium. Today, we are going to be discussing some best practices for Altium Designer. Keep in mind that this presentation is part two of our talk on Best Practices. So, if you are a newer user or you need to learn potentially some fundamentals of rule creation or output generation, I would recommend attending that Best Practices part one before we continue.    

So, we are going to start off today by talking about schematic directives, defining rules from the schematic side of things, before we bring them into the PCB. Then once we are in the PCB, we are going to discuss building complex rules, using things such as the query language in order to create complex scope for our rules, working with prioritization, generating rapports for these violations, and how we can navigate through the violations.    

From there, we're going to talk a little bit about design review. Some of the things you can do to make the process a little bit smoother when you have various stakeholders. During this section, I will be showing working with some projects in Altium 365. They will be hosted on a workspace. From there, we are going to look at some of the files that I recommend for generating output files. And then once we have those output files, we're going to see them once again, in the Altium 365 workspace web interface, and how we can take all of that information and provide it directly to manufacturing.    

So, let's get started. The very, the first thing we need to do when we are beginning the design process is getting a better understanding of our design requirements. When we are working with a new design, there are a couple challenges that we face when defining our requirements.    

The first thing that happens is once we define our general requirements, we have to learn how they interact with each other. A good example of this is edge connectors, making sure that you have proper rules for clearance, so that it will nicely situate itself within an enclosure. With that as well, once we have our rules defined, being able to find any violations that occur and resolve those violations, waive them if need be, and documents them, is something that becomes quite a challenge.    

So, that brings us into the realm of validation, validating our rules to ensure that our design intent is being conveyed and being taken care of accurately before we get over to manufacturing. And with that, creating documentation in order to provide proof to relevant stakeholders, that you are meeting these requirements.    

So, there are three points I like to emphasize when we're talking about design requirements. The first is synchronization. You have two parts to every design. You have the schematic side, which is going to define our logical requirements. That for example, is our connectivity. Defining differential pairs, different types of net classes. And that's what this presentation is going to focus on more heavily.    

So, from there, you have the other side of things, the PCB. Those requirements and those rules that we generate are going to translate to over into real world applications. So, those are very important to make sure that we have things such as appropriate clearance, as I mentioned earlier, for an enclosure, an appropriate width for an impedance profile.    

So, with that, once those requirements and know which side is going to be impacted, whether the schematic or the PCB, you can go to the next step, which is organizing these requirements into rules. What we need to do is categorize the requirement, for example, component clearance. And then, we have to define the scope. The scope is very important because if we create rules that are not scoped properly, they aren't going to provide the level of validation that we are intending. With that comes prioritization as well. There is a rule hierarchy that we will be discussing. And working on reducing conflicting scope is the next step of the process when we are defining our design requirements.    

So, let's start off by looking at synchronization. As I mentioned there are several aspects to the design process. We are working at bridging all realms of the design process with our requirements, with the corresponding rules that we are creating. Some of the rules we will be talking about, we are focusing today on schematic directives, of course, as I mentioned. So, the three main options we have from the schematic side are differential pairs, No ERC and parameter set directives.    

A differential pair, pretty obvious what it is, it just is a way to identify from the schematic side of things, any nets that should be associated with each other. And maybe you could create a rule in order to pass that over through the ECO process, over to the PCB. With that, match lengths for the differential pairs.    

No ERC simply is going to cover up any errors that we find are not relevant to our process, for example, floating pins. If you have a connector, a header that's 20 by two, not all of your header pins are going to be connected to a net. So, we can add a No ERC here on these floating pins to remove any issues.    

Lastly, parameter sets, with parameter sets, you can do things like create a new net class. Let's say you have various signals in a net for SPI, I2C, you can group those all together and create a parameter set to once again, define from the schematic side, the net classes required for PCB layouts.    

So, we've discussed some of the different ways we can place some directives. In a little bit, I'll be going through and showing that inside Altium Designer. But for now, let's step into the next side of things, which we're going to be talking about building complex rules. And to be fair, these five steps are not specifically for complex rules. This is a basic set for all rule creation. The first thing you would want to do is identify, as I mentioned earlier, categorize. When we're creating a new rule, all rules are grouped together by different types.    

So, the first thing we do, you see in this image, I find the type of rule I want. I want an electrical rule defining clearance. Once I have found the type of rule I want to work with, I need to create some type of identification. We start by creating a name that is as descriptive as possible. I recommend adding a comment as well. From there, we're going to look at the scope of things. As in this image, we have the first object in our rule, it has to correspond to the net class SPI. Whereas, the second object, we see here, a custom query. So, if you haven't worked with these before, this is what we're going to be discussing a little bit more in a little bit.    

So, let me just step through this and parse this a little bit. If you come in through the custom query, you see you have in net class SPI. And then with the parenthesis, the condition is, if it is in the components class for the schematic power supply or in the component class for processor interface, it will match that second item. And we're going to go through how to build these queries soon.    

From there, once we have defined the scope, we will now define the value. Very simple here, all of the rules have a graphical interface to help users define the rule properly. From there, you have the ability to adjust priority, as I mentioned earlier. Scope and priority are very important. If you have defined the correct scope, but your priority is out of order, then your rules will not apply properly.    

Note that the top level, the way priorities are handled, rules will follow by priority, starting from one, all the way to the bottom. As soon as an object meets one of the rule scopes, it will no longer go down the priority list. So, if you have a very generic rule at the top, you are going to be blocking all rules underneath it. So, generally, it is best to put the top priority rule as the most specific and come down, and become more generic as we go down.    

Next step, organization. We're stepping a little bit more into the discussion on rule scope. With scope, we have two things we're going to be focusing on in this conversation, classes, which can be component classes, rule classes, and net classes. What this is going to do is group together various design objects of the same type into a class, so that we can more easily find them in the future.    

Additionally, we're going to discuss rooms. Rooms are something that are often generated during the initial ECO process, when you are bringing in your schematic information into the PCB. This is configured in the project options. If you're not sure how to disable or enable rooms, I recommend you check out our documentation on that. But once you have rooms, what you are able to do, which is very convenient, is you can coordinate the rooms in conjunction with our rules to create specific rules, for example, under a BGA for neck down. You can specify keepouts, or you can specify areas where you want everything to remain in that area.    

Something very powerful about rooms is when they are created with the schematic, all of the components are automatically tied together. So, if you make something that you want to reuse, a design reuse block, rooms are very helpful to recreate the same type of layout over and over again.    

So, I mentioned that we're going to be focusing on the query language. There's two options here. You have the query builder and the helper. So, the builder is a little bit more in interactive. It is going to ask you for condition types that you are going to select from a dropdown. And from there, it will provide additional condition values.    

Earlier, we looked in an image, I showed a custom query. Here it is to become a little bit clearer. And you could see these two queries are the same. They are however built very differently. So, initially, it's nice to work with the builder, as you start learning more about the vocabulary of the query language and how to structure things based on the syntax of the query language. Then as you move forward, I often work in the query. It's probably my coding background. I prefer to work in this type of environment. So, we'll go into a little bit more detail soon.    

Going back to rooms. As I mentioned, a rule is essentially a region we have defined on the PCB. And when you combine it with rules, if you have a region plus a rule, you essentially have a room. But on top of that, you can combine rooms plus additional rules in order to create very specific placements, very specific routing, different types of rules.

So, essentially, our conversation is about how we can group together different types of design objects in order to make our rule scope easier. So, we've discussed classes and rooms, and they're going to be our main focus.    

Here, we have an image of a BGA. And you can see here, as soon as the trace hits the room, it necks down into a smaller width. If you look at the images on the right, you can see some custom queries utilized in order to create this effect. The part I want to focus on is in the bottom right corner. We have within room, our touches room. The way that these two options operate are different. So, make sure you are careful with which one you utilize within your query, within room is going to be something that is fully contained within the room, or as touches room, is a little bit more generic. So, just be very careful when you are using that to define your scope.    

Now, that we've talked about some of the different ways we can group together our rules, this is just a quick recap of six types of rules that I recommend you make sure you focus on throughout your design process. So, we have electrical clearance. This is including both on the traces themselves and the pads within the components.    

From there, we have width, the via styles. You have to know if you are working with just regular through whole vias, blind and buried vias. The different types of vias you're working with, learning more about how those are structured. From there, component clearance. Obviously, if you don't have clearance from your components, you have different types of issues. Either, it is not going to fit inside of your enclosure, or it's going to be impossible to actually manufacture the design when you get it to manufacturing.    

From there, we have polygon connect style. This is something that's very important in coordination with your vias. Defining how your polygon pores interact, for example, with a ground via is important, the way the current passes through and the heat dissipation is going to be different depending on the polygon connect style that you are utilizing.    

Lastly, solder mass expansion. I don't need to go into too much more detail on that. You could see, I created image to show a little bit more about the different types of physical constraints we have in our design. Here's the other side of that enclosure. So, we have height constraints here. We have things for the ventilation holes. We need to make sure alignment is appropriate throughout the design.    

So, the first thing we'll talk about is the rules and violations panel. As I mentioned, this is located within the PCB editor. There are three main things that the panel helps you accomplish, identification, navigation, and correction. So, first of all, the panel groups everything into 34 rule classes. This is going to allow you to run a DRC on an individual level or a batch level, if you want. So, you can run the clearance checks, all your clearance constraints at once. You can run individual rules. And this is going to help you minimize all of the information that is being brought on when you do a full DRC.    

When you are starting off your design, sometimes you can have hundreds of errors when you bring in your information from the schematic. So, it's really important to be able to easily identify the different errors. Once they have been identified, navigating through to them. We are able to cross probe from the violations and highlight over on the design itself. You'll notice at the top of the panel, there are a couple options for selection, zooming, and clearing based on the violations we have present.    

Another important thing is there are certain violations that are necessary. I'm going to go back once again to talking about an edge connector. And normally, you have a clearance between different components and the edge of a board or the board outline. That would be a use case in which you would want to waive a violation. All waived violations are recorded. You must add a comment, and then you are able to generate a report later with all violations and all waived violations.    

So, the biggest benefits of these verification reports is you are providing proof that your design requirements are being met both on a logical and a physical level. Any issues that remain are either pushed to the area with waived violations, or they are documented. That this is going to give you traceability for any issues. Let's say you have to come back to this design, you have to do another revision, anything, you have all of this information ready to go for next time. And best of all, you're able to share this information with anyone, be it a coworker, an important stakeholder like a manager, or if you need to send it over to your manufacturer.    

So quick, we're going to briefly touch on the design, the web design view inside the workspace interface. So, one of the main benefits of having your files, all of your design data hosted on the workspace is that it creates an environment that is accessible from any web browser. This is going to help you facilitate your design review. This goes in conjunction with the validation of all the rules, in that you must get to a point in your design where you feel comfortable, that all of the logical things that you have defined on the ECAD level will be able to be manufactured in the real world. So, having a way to come inside and take a look at things is really important. We're going to go into more detail about this when we're talking about release to manufacturing.    

So, for the demonstration aspect, we will be using the DT01 board. This is an old JTAG connector that was created by the old Altium's hardware team. This is actually something that we manufactured. I have one myself up on a shelf, as a nice memory of the past. So, I really enjoy working with this design. A lot of people are familiar with it.    

We're going to start off by looking at some schematic directives. If you haven't used schematic directives before, you can place them with a regular place menu, V for directives, and then, you have them there. If you are in the active bar, you can hold, left click and find a couple of different options.    

So, what we're going to use is a blanket. What the blankets allows us to do is everything contained within this blankets will now have the directives applied to them. So, do it around these two nets. And I'm going to do a parameter set, as always shift. There's space to move things around. If I hit tab, it opens up my properties for my item during placement. I am going to name this power nets.    

From there, we have the ability to add different parameters. The first parameter we're going to do, we're going to create a net class. I'm going to name this. You want to be as descriptive as possible, so that other people are able to understand this when they're referencing it. So, we have named it 1V8, 3V3 power. So now, I know these are the two nets associated with that. From there, I can add a rule. So, I want these two nets to have a specific, with constraints, come to routing, with constraints. And I am able to configure this as need be. Something that not a lot of people are familiar with. You could load in the layer stack information. You can utilize impedance profiles that are created in the layer stack manager. We won't have time to go over that today, but just to show you, if you have the impedance profile, that can help you out here. But for this instance, I will not be using that. I'm going to change this to 10, 20 and 15 mills.    

You see that information is filled out with the layer stack we have available. So, we have that set up. I can now finish my placements. And now, this directive is associated with these two nets. And we'll see, during the ECO process, how that information is passed over.    

From here, let's look at this differential pair. This is for the data of the USB. To create a differential pair from the schematic side of things, there is a specific differential pair directive. So, I click that, tab once again. And the way that the system identifies differential pairs, if they need to have this underscore negative and positive. So, make sure that your nets are named appropriately, in order to fully utilize the functionality of differential pairs.    

So, just to add a little bit more information, I'm going to create a differential paired net class, and I'm going to call it USB data. So, in this instance, it's only one differential pair. So, we don't necessarily need to make a class, but I wanted to show the functionality here. If you're defining multiple differential pairs, but they should be grouped together, we will be creating a class for them. Okay. That is done.    

I go to placements. And when I go to place the other one, you see the values have gone away. So, what I like to do is copy the existing one and place that. And you saw here, I had an issue because I just had one. If I hover over it, it says missing positive nets. So, simply click. And this is a good time to mention, make sure that when you're placing these directives, you get this little red X. That is showing that we have an electrical connection. If that is not properly connected, you are not going to be able to set up the connectivity that you want. You can see the little connection right here with those four dots. Okay?   

So, I have those two directives now. You'll see throughout this design, I have placed No ERCs. Let's say you have a specific issue at any time, if it's not an actual problem, you can do generic No ERC, and just place them as need be to suppress that violation. Okay.    

So, that's nice and set up. So, if we run the ECO process, when we run the ECO process, we can add net classes. We're adding a differential pair, a new rule, and a differential pair class. I can execute my changes, and see all of the DRCs are running.    

From here, we are going to go to the PCB itself. Our new information should be set up here. If I come over to the PCB panel, I can see my differential pairs. Since I created a differential pair class, I have USB. If I had multiple different types of differential pairs, they would be associated here. Notice that this differential pair was automatically named D, as that was the name of the nets for these data lines. So, it's important to be descriptive again. This is an older design and that wasn't set up, but I want to bring that up. That having that N and P will automatically extract that from the name. And then your differential pair will be named after the net name.    

Another thing not everyone is familiar with, when you actually click on a net, you are able to see the physical name and the net name. The net name will be the logical representation in your schematic, while the physical name is the representation on your PCB. Okay.    

With that, now we have a new rule set up. We're going to go to the PCB rules and violations panel. Here you are able to set a couple of options. You can do normal mask dim. I like to use mask. The really powerful thing about the rules and violations panel is it allows you to run DRCs based on rule class, as well as all of the rules. Once I get into a rule class, I can run an individual. If I would like, I could run an individual DRC. Whereas, if you use design rules and you run an ERC, it's going to run everything at once. So, you don't want to do that as much as possible.    

We're going to come back now that we're in the rules editor. Come back. And we have a couple of clearances. So, I'm going to go to the top level. So, as I mentioned, you have to make sure that your priorities are in order. You want to go from most generic, to least generic. Sorry. You want to go from most specific to least specific. And that is because, as soon as your design object meets a rule criteria, it will stop going down the priority. So, let's say you have a differential pair that's under the BGA, the differential pair clearance rule will come in first before the BGA rule. And so, again, you want to be most specific to least specific. As you see, this last one is essentially your catch all. So, the scope is all items.    

I'm going to go to width, since we created a new width rule. You can see here, it is identified by schematic with rule. If I click in, it is associated to the net class that I wanted to do a custom query, if you want to see hat the system is utilizing on the back end. We have the query helper here. So, let's say we wanted to build this out. We weren't totally sure. We can come through in the query helper. Well, what do I know? I know we have component classes. Okay. We have net classes. And it's very easy to find here that the name of the net class itself. So, I can easily create something here in order to easily define a scope through here.    

So, the alternative to this, since we defined that the net class contains net 1V8 and 3V3, we could also say instead of a net class, if we come into the builder, first condition belongs to net 1V8. Second condition, once again, belongs to net. And you'll notice here on the values, it knows all of the nets in our design. So, we can say this or this. And you can see if you have a lot of nets, it's easy to lose track of them. So, it's a little bit clearer. You can have this, or as we had it by net class.    

So, it's a lot easier to make a net class on the schematic side of things, if you know things need to be grouped together. The important thing is that all directives, everything placed from the schematic side is just a starting point to create the rules on the PCB design side, on the PCB layout. It's important to try and maintain rules in one environment. So, you wouldn't want to make changes here in the rules and try to push them back over to the schematic, because things are going to get confusing and they're not going to of work properly. But in this case, once again, I have 1V3, 1V8 and 3V3.    

So, with the prioritization that we talked about, we have the width constraints and then the BGA. So, now that we have a BGA constraint, this was already in place, I want to bring in the conversation on rooms.    

So, rooms will help us group things together by either the schematic or you can custom make one. In this case, I made BGA area. That room is created from the selection of the component.    

So, one thing to note is the difference between touches room and within a room. So, we have here, let's say touches room. And you see there's different options we have here. Everything that touches the room, it's going to be a bigger scope, than if we say within room. Just the query again. And you see the difference there in what is scoped.    

So, we're going to be doing a neckdown. So, I want this width to be associated like that. Here we have our power nets. I'm going to rename this now that on the PCB side of things, 1V8, 3V3 and power. Okay. So, I want that to take priority to the BGA side of things. So, I can do apply.    

Let's see. It's letting me know that there are issues, this rule on differential pairs. Now, that we created a new differential pair and come over to the differential pair class, USB data. It seems we'll set this up with the same eight, six and eight. Okay.    

So, now I'm scoped in differential pair, class of USB data. In our situation, that class only contains one differential pair. That means that this, again, in this specific situation, this will scope to the same thing as if I did diff pair, and just did that class. Of course, if you are working with a class, generally, you are moving things in and out of the class as you optimize. So, I would recommend as specific as you can be, take those chances to be specific. Okay.    

So, since I've made changes, it's going to run the DRC again. And the top level, we have our rule classes, then our individual rules that we can run, and then the violations. Coming here, we see we have 110 violations. That is quite a bit. The first couple ones are with constraint. So, to make things easier, let's go to the rule class, specifically, pertaining to rule constraints. And we can see that the biggest issue here, all of these nets belong to those powered nets. Let's say I wanted to change the priority, again, design rules once again. And if we come back over and we change the priority. Let's say this is priority one now. Priorities. I'm going to increase priority.    

So, once you see the different priorities, you come down here, you have the priority options. So, I changed my mind. Let's say the BGA is the most important. And when I apply this again, it will run. We have 86 constraints with constraint violations. And as it runs that, now that the priority has been changed, we see those violations have been altered.    

Okay. Let's go back over here. The nice thing with the rules and violations panel is as you select them, you are able to see the applicable scope for your rule. You also have the option to right click on a design and you can do applicable unary or binary rules. So, that is essentially the difference between those being, how the scope is defined. So, here you see, we only have one. Whereas, in this option, it's binary, right? As we have two separate options. Close that out.    

Okay. If we come through here, what we're able to see, we have this 3V3 nets. In order to make things a little bit easier, I'm going to go to our properties and change the selection filter. Shift C to clear. Okay. So, we can currently select components and rooms. I'm just going to do tracks. If I click, I hit tab, I select the whole net. What I can do here now is the gloss and retrace functionality, as soon as I do retrace, it is going to automatically apply the new rules that I have set up. So, I wanted the trace up here to be a certain size with that power net rule.    

And we see anytime we have a violation, we can do shift V, and it lets us know we have a clearance constraint issue. You can see a little bit more about that. Once I have gone through the majority of my rules... Oh, I wanted to also show you, we've been talking about edge connectors a lot. So, let's do board outline clearances. And we see here, there are a couple of items that are on the edge. These are all edge connectors. Well, these are LEDs. These two are edge connectors. So, I actually want to select them all. And I can waive the selected violations. It will have my author name, since I'm signed into my workspace here. It is associated with my name, the time of the violation, and when I am waving it. So, reason to waive must be... It's very hard to type when it's all the way to the left. I have to have my microphone. And must be by the board edge.    

Okay. So, once I do that, I have a whole new section that has all of my waived violations. At any point, I can click in here on our panel and select report, and it will give of me a report of all of the different rules that we have associated. I could also do the same over here. I can look through the properties of all of these violations I have waived. Highlight, jump everything.    

So, those are the basics of rule creation using schematic directives and grouping things together by net classes. So, now we can talk a little bit more about the definition of our outputs and bringing the outputs, making sure we can generate them all correctly, and that everyone, that all the keys stakeholders have access to them.    

So, when you are determining the outputs you need for your manufacturer, it's critical that you always talk to your manufacturer first. Every manufacturer, even depending on the project, who's taking care of the project within a company, they can have different requirements. So, always ask what they need first, before you proceed with any of these steps.    

As I already mentioned, this is part two of our Best Practices conversation. So, I'm not going to go into too much detail about all of the configuration of all of the individual files. As a matter of fact, I have a webinar, specifically dedicating to outputs that I can provide for everyone, if you want to learn more about and particularly configuring different outputs. But for now, we're just going to talk about a couple of the recommendations.    

So, as just very simple rules, I would always work with an ActiveBOM documents. The goal of the ActiveBOM document is to be more of a living document. BOMs have generally been thought of as an end of release type of documents. ActiveBOM allows you to work on your procurement throughout your design process. If you can easily identify supply chain issues, if you are working with managed components, hosted on your workspace or Concord Pro, Nexar, you are able to have the revision history put into the ActiveBOM documents. So, if any changes are made in the middle of your design process, you can easily update your designs, and your component definitions.    

With that, the draftsman document is a newer way to communicate fabrication and assembly drawings. So, those are the two documents I would recommend you go and learn more about. We will briefly look at them, but there won't be enough time in this talk to actually go into how to do everything you need to do in ActiveBOM and draftsman. Once again, we have a lot of webinars covering these topics. So, you can take a look at that and learn a little bit more.    

When you are working with a project and you do not have any OutJob set up, the system prompts you to include default OutJob templates. So, we're going to quickly go through those today when we're looking at the examples. The three OutJobs that are created by default are the assembly, documentation and the fabrication OutJobs.    

So, once you have defined your OutJobs, the next step is to associate it in the Release Manager. You must configure the Release Manager to include the OutJob based on the type of data you're trying to release.    

So, here's just a quick representation. We have an OutJob here to include assembly data with no variant. When you click details, you see all of the associated documentation that has been generated. If anything has failed, you can review it here. Any document that has been completed as well, you can open it up, and if you want to take a second look at it. It's always important after you have generated all of these documents to give them another look. And in a little bit, we'll look at the different ways that you can take a look at those outputs, those releases as they happen.    

This is stepping into the Release Manager. Hopefully, you have worked with this before, if you are in this class. If not, once again, please take a look at some of our webinars on the topic, specifically on the Release Manager, very in depth, but just a quick overview. As I mentioned, you have the different types of data packages here. You could see on the left side, I have highlighted in red. You have source data fabrication, assembly, and custom data. So, you can create custom data packages, as you see at the bottom. You can associate the data packages to different revisions of release and to different variants of the design.    

If you go to the bottom left, you see an options button. This is going to allow us to configure our release options, to associate the OutJobs that we have created with the correct type of data package.    

So, just here, you can see really quickly fabrication, has the fabrication output assembly, and the custom data at the bottom, the custom documents. I have created my own custom OutJob file for this design that I'm working on in this example. Once that is completed, you can simply prepare and release the information.    

And one issue that a lot of people have is once they have all of their documentation, all of their out jobs, what do they do with it? So, release to manufacturing can be a pretty significant problem when you are sharing content remotely. There are often issues with licensing, third party file viewers. Just coordinating everything that needs to happen in order for everyone to be operating with the same file revisions, operating with the same software can be quite a challenge.    

So, I created a little graphic here of going through the process of taking a look at some of these outputs. And one of the biggest issues of course, is licensing. Let's say everyone is using Altium Designer. If someone is using it purely for review, such as a manager, that can be an issue, if you have a limit number of licenses that are closely shared and monitored between your team.    

And one of the biggest advantages of working with Altium 365 is the ability to remotely access all of the shared content on the workspace. And besides no longer needing a license while you're in the web browser, you're able to view it remotely from any browser without that license. So, that's going to free up your Altium Designer license. It's going to give you the ability to share the design files with people, who traditionally would not have the software installed, and would need to use any third party information. Of course, anytime you're you're operating with third party applications, there are potential issues that can happen. Additionally, you are able to directly comment on any design that is hosted on your workspace and is shared with you.    

So, coming through here, we talked about releasing the files through the Release Manager. Once that release occurs, that release package is, if you're working with a workspace, of course, that release package is associated with that project. So, if you're using your work space, you are able to use some new type of functionality such as the Gerber compare. So, you can compare the Gerber across two different releases and see the differences between them. Of course, this is possible if you're not hosting the data on your workspace, but it is a more manual process. And of course, this interface is powered by the Altium 365 platform. So, the specific Gerber compare, you're going to have to go back to Camtasia, which is of course, integrated with Altium Designer.  

But I'm sure a lot of you have used Camtasia before, or Camtastic, not Camtasia. Camtasia is my recording software, Camtastic. Yeah. So, it's always nice to introduce some level of user interface that has been streamlined specifically for this use case.    

So, I highly recommend checking out that Gerber compare. We won't have time to go into too much detail on that. So, let's just skip over to that.    

So, once you have your data packages defined, you have released your data package. You now have a release package that can be shared with a manufacturer through the Altium 365 platform and through the Nexar ecosystem. So, this is something that we're working on coordinating with different companies, different manufacturers. Of course, we acquired PCB:NG a couple years ago. We're currently coordinating with MacroFab to work in conjunction on the next ecosystem together.    

So, once you have all of your data packages, you are able to select what information you want to send over to your manufacturer with a simple email. And they are able to access all of that through the web viewer and continue rather easily.    

I find this process to be a lot smoother than we had even three years ago, right? Before we would have to get all of our release packages, zip them up. Hopefully, we named them accordingly. If there was a small change that had to be made, you have to start all over. That is no longer a concern, incorporating all of this functionality through the Altium 365 platform.    

So, let's take a look at the tool again, and we will end off with some questions. The first thing we're going to take a look at is ActiveBOM. So, one of the biggest changes that I recommend taking a look at is the fact that we have added new document types that provide a more active dynamic picture of your design. They're actually linked to your design data directly. So, if you need to update something, all of that information is connected and you don't have to be constantly regenerating content.    

So, coming into this ActiveBOM document, we're not going to go into too much detail about how to set this up, but there are some things I wanted to highlight. You can see here, the revision status of a lot of my components. That means that my component is now in a managed state, and it is connected to my workspace. Anytime a new revision is created, I can just right click and update to latest revision. In this case, everything is updated. But what I want to show is when I have a specific part, I am able to right click and to add alternative item. And you see how it appears on our document here. It's a little bracket. If I click it, I'm able to see more or information on it.    

So, in this particular instance, I see that the manufacture life cycle states that my original component is end of life. So, that is an indicator here that I would prefer to use this component in my design. Additionally, there's alternate parts and alternative parts. So, these are different parts themselves. And then within each part selection, I have my part choices that are set up here. I can rank them as needed. Each of them has a manufacture lifecycle status, that if you are utilizing Altium 365 workspace, that information is tied into the IHS market data sets. We are working with them to make that communication more robust. But currently, there are a lot of parameters that are automatically provided to you as a user through this data set.    

Okay. We have these alternatives. I can rank them as I see fit. Even within them, everything is organized by manufacturer part number. And then within that manufacturer part number, I have individual supplier part numbers. I have stock information from all of them. I have price breakdowns. This is all included with the Altium parts provider and our preferences, if we go to parts. Under data management, parts providers, we can see here, we have all our trusted suppliers here. You could also create custom connections, but we won't be talking about that today.  

Another powerful thing here, you will notice that there is a status icon here for different issues. So, here I could see there's no manufacturer part number ranked. There's another thing. There's no suppliers. If I come over to the properties, I have different BOM checks. So, I can just select all of the suppliers that are missing, if I have a duplicate value, duplicate designator, all that type of information. You can also create different items. Again, I'm not going to go into too much detail. We have webinars specifically dedicated to ActiveBOMs. So, if you want more detail, I would recommend you check this out.   

 On the other side of things, the other document type I recommend is the draftsman document. Again, the best part about all of these documents or both of these documents, is that they are tied directly to your design data. So, if you make any changes, all you have to do is click and import the changes. And that can be said as well for the BOM document.    

And do refresh. Actually, since I'm back here, one thing you could also show with the solutions, you can edit the part choice. If you are using a workspace, you are able to define the part choice on the component level. So, anytime someone places a component, that specific component, the associated part number that was defined during creation will automatically be added. And then you could customize it as need be.    

You could also do operations. And you can change the component. So, in this instance, we see the two components. And I would want to work with my alternative component. I can do 2.2 microfarad. And if I want, I can change it and change that component. In this instance, I want to make sure I don't change anything since I'm releasing the design. So, I'm going to cancel out.    

But the whole point is the ActiveBOM document is a living document that you can work with during your design process, as opposed to how we have traditionally work with bill of materials, which is something at the end of the process as just a part list. So, it's a lot more interactive. You have a lot more control, a lot more information.    

Okay. Coming back, we have different types of documents. Another great thing is you can create a template out of any documents. Again, I'm not going to show that in this particular discussion, but all of our properties are here for this document type. And we can change things up as necessary. We have parameters. And we have page options. So, here's a couple of different documents I have.    

Okay. So, let's switch over to our OutJob. When you have completed your design and you want to release it, you can right click on a project name and go to the Project Releaser. So in this situation, I have moved out the OutJob that we're going to look at first outside of the project. So, I can show you if you do not have any documents, any OutJobs, you can add defaults, and it will automatically add two documents for us. One for fabrication and one for assembly. So, now that this is open, I can simply bring the other documents back in.    

Okay. Before we configure that, I want to show the differences between these documents. So, we have published a PDF. We have copied to PDF. The first thing, these are the traditional files. You have assembly drawings, bill of materials. So, let's switch over to that. Okay.    

So, the first thing we have here, these are the traditional method for creating these drawings. You could see it's very static. It's not a great overall picture of our design. This is the way things have been done for quite a while. If we come through to the same type of output generation, but we come through the... We see all of the different documents that have been associated, all of the different draftsman documents. I think it's quite clear to see the difference in legibility and readability between these two levels of documentation. And the fact of the matter that all of the parameter information is here, is really important.    

We have even images of our layer stack. We have notes. And the build materials still very similar, but you will see where the actual power of ActiveBOM comes in once we complete our release.    

So, let's go back to the Release Manager. Since we just created new OutJobs, you see that nothing has been specified here. I can click, open up the options since there's an issue. Alternatively, I can always hit options here. We see here, we have our source data. I'm going to associate that with that OutJob, I talked about earlier. And we have fabrication and we have assembly. And you see the release target. So, in this instance, I am releasing it to my workspace, Altium product marketing.    

We have a naming convention as well, to help differentiate between the different projects, as we have our release packages. Additionally, if you have variance that information can be tied here as well. You can do settings and get a little bit more information on that. Okay? So, those are connected.    

And you'll notice you can have the detail section here. If you want, you can configure them as need to be. Again, this conversation isn't about configuration. I have a full webinar on fabrication outputs, if you want to learn more about that. For now, prepare and release. So, it's going to output container, published a PDF, must have released. Okay. So, for this instance, I'm actually going to go back. I'm going to remove this, DT01, just to make sure I don't have any issues. Let's just close this out.    

Okay. Let's go back to our options and fabrication assembly. It looks like I moved out another one. Well, let's just go back here. Looks like I accidentally removed the assembly. So, just to speed things up, I'm going to leave just these two, come back to my options. Okay. So, prepare and release. Since it is on my workspace, it's going to commit all of the documents to version control and create items for these releases. So, I have source and fabrication. So, create the items. It's going to ask me to commit the changes. I'm going to have to put in a comment for those changes. Normally, you want to be very descriptive with your comments, because you are able to access them through the project history timeline.    

Okay. So, now it is going to process the creation of all of these documents. Let's give it a little bit of time. So, once all of this has been generated, you notice that there are six steps. Because I am working with a workspace, all this information is going to be added to my project profile in my workspace. That means that it will be accessible through web browser. Anyone that I provide access to will be able to access both the original design, add comments to the design, and view all of these outputs.    

Okay. Report the polygon. Okay. So, in this situation, it's failed. I can come through. I can get a little bit more details on everything. Let's see what's going on. And I have a report of the rules. I mentioned earlier, that we worked with earlier. We have our width constraints and we have our waived violations as well.    

So, let's move over to a package that has already been released. One of the best things about this process is that it is actively tied to our data and making sure that everything is generated correctly. But let's go back to a previous release that I have.    

Okay. So, now we are in the web interface. We see the entire design, the structure associated files with it. We have, this is currently an alpha. I just want to give you a sneak peek. Once again, everything is tied to the latest design data, which is very powerful for everyone, being able to see all of this documentation throughout our design process, as opposed to just at the end of the day. Same thing with the ActiveBOM documents. All of that information comes through here in the bill of materials area. There is also a library health. That's a different conversation. But just so you know, all of your component definitions are easily viewed here. You get more information on location of the component. You can see things, you can see it on the PCB, if you would like, or the schematic, and it will load up all that data.    

Additionally, I can add comments directly on here, if I want. I can place a comment anywhere on this design. There's some measurement tools. I can search around for things. Let's see. R16, since we're right there, you could see just that movement.    

And yeah, this is really powerful. You have the ability to download all of this. If I want to share, comment, I can do that very easily from here. And as I mentioned earlier, anyone who has access to this data set, doesn't have to be utilizing a license at any point while they're in the web browser. So, this opens up the possibilities as to who can take a look at your design. And it minimizes the risk of being in a conversation with someone else, where you are both working with different revisions, because you are both tied to the latest design data.    

You have layer information. Almost everything that you would have on a view level, you now have through the web browser. You have a supply area, very similar to the bill of materials, but slightly different perspective.    

And I mentioned earlier about project history. This is why you want to have more as descriptive as possible, the commit comments. In this case, we have our release here. Anytime you have a release, you can take a look. You can compare the schematics Gerber, and the bill of materials. You can download the snapshots as needed. And you could view the files.    

So, I could click view, and it is going to show me this specific release. Now, that I have this release, there's some more stuff here. We'll leave that for this conversation. But you can send to manufacturer. You can decide which files you want to send. I can add the files, configure as needed, give them the package name, the description, and the manufacturer email. And I can automatically send all of those outputs directly to my manufacturer. Once again, you are minimizing the risk of working with documents that are out of date, and you get all of your data all connected. And it increases the visibility of everything. And it facilitates communication.    

So, that is all I wanted to show for today. I'm going to open it up for questions.

About Author

About Author

David Haboud is a Product Marketing Engineer at Altium. He studied electrical engineering with an emphasis in computer architecture and hardware/software design at the University of Southern California. David began his career as an embedded software engineer in the aerospace industry and has always strived to make it easier for hardware and software engineers to communicate. During his tenure as an embedded software engineer, he focused on firmware development and data acquisition for auxiliary power units. In his spare time, David hosts and performs in improvisational and stand-up comedy nights in San Diego, California.

Recent Articles

Back to Home