Concevoir un système en utilisant un Multi-Board Project - AltiumLive 2022
Plongez dans la conception de systèmes et la mise en œuvre de plusieurs circuits imprimés et découvrez comment réaliser un Multi-Board Project tout en respectant les contraintes de CAO mécanique avec Altium Designer.
Principaux points abordés :
- Démonstration en détail de la conception dans Altium
- L'intérêt d'utiliser des outils de conception capables de gérer la synchronisation des interfaces
- L'importance de prendre en considération les exigences environnementales dès le début du processus de conception
- Présentation générale de la gestion de la connectivité
- Mieux comprendre l'utilisation de chemins de retour pour réduire l'impédance
Autres ressources :
- Concevez des circuits imprimés en profitant d'un essai gratuit d'Altium Designer en cliquant ici
- Retrouvez Chris Carlson sur LinkedIn
- Introduction à la conception de circuits imprimés multi-cartes - Altium Academy (en anglais)
- Conception de systèmes multi-cartes - Ajustement, forme et construction - Altium Academy (en anglais)
- Altium Designer et les contraintes CAO mécanique-CAO électronique | Comment utiliser Altium Designer (en anglais)
Transcription (en anglais)
Welcome to Altium. My name's Chris Carlson, I'm one of the engineers here at Altium. And in this session, I'm going to be talking about system development with a multi-board project. All right. So first we'll talk a little bit about why multi-board, then we'll go through some of the design concerns and I'll give you my take on PCD partitioning and we'll cover connectivity management and connectors and form factors, and then I'll follow up with a detailed demonstration, an Altium designer doing a multi-board project from start to finish.
So by modularizing products various subsystems can be used across multiple product lines. So for instance, a CPU board with all of its ancillary hardware, clocks, bypass, maybe some serial flash can be designed to create an engine which can be used across multiple product lines leading to a bomb cost advantage. Also by modularizing a design, the product can offer variance with respect to the feature set.
You can have different IO modules or user interfaces for instance. This also lends itself nicely to upgrading a product as components become obsolete or newer components become available. You'll only have to replace or upgrade one module and not the entire system.
So divide and conquer, this is the team approach. By dividing up a system into functional blocks, a team can divvy up the workload and reduce the complexity in terms of what's by individual contributors. This also allows the team to reuse subsystems that have already been developed for previous products and ultimately bring a product to market much faster. Okay, so form fit.
Often the mechanical constraints of a system drive the form factor and it becomes necessary to divide the system up into functional blocks which are integrated or stacked into a mechanical housing to meet the products' mechanical housing specifications.
Obfuscation is another good reason to modularize. Developing modules which can be conformally coded in such a way as to hide or obfuscate. The circuit topology is one way you protect your IP and make the subsystem much harder to reverse engineer. I've actually done tear downs where I've come across modules like this, and I'm not sure that they were ported in, but I actually ended up destroying the device trying to satisfy my curiosity.
And this type of obfuscation also gives an opportunity to address environmental concerns in terms of protecting the subsystem from harsh environments. So when you open up any product, you generally find various subsystems scattered around the box. In this image can identify a power supply, some sort of a system board with a processor on its own module and then a few controls going to a panel.
And when I think of the various tear downs I've done over the years, this is generally what I find. Products with multiple subsystems all wired together is pretty much the norm and what we're already doing. So let's talk about multi-board design concerns. So form factor compatibility. Using common form factors bring several advantages to the table, especially when getting a prototype up and running.
The electrical interface standards generally support both signal and power on the same connector and many of these standards support high speed signaling. The board form factor templates can be downloaded for custom hardware defined with pre-defined board outlines, pre-positioned connectors and mounting holes and often these are designed to create a nice clean stackable product.
You can also get COTS modules for single board computers, memory, off the shelf solutions to get you up and running quickly. It really speeds things up when you're trying to get a prototype up and running. Then while your software is being developed, you can go back and replace the COTS modules with your own designs in the same form factor. The prototype platform could even go to market as a product while you're designing out those COTS modules.
So space and clearance concerns. When you're designing a multi-board system, electrical and mechanical collaboration's paramount. Your tools need to be able to interface all of the subsystems together, both electrical and mechanical and check for proper mechanical fitment between the individual boards and their components. When collisions have been identified, a decision needs to be made to determine where the resolution takes place.
In other words, which PCB best facilitates the movement of components or allows for changes in the board outline to accommodate the overall system fitting together mechanically while still meeting performance specifications and maintaining the electrical interfaces. Okay, signal management. So planning what functions will reside on each board will drive the interface specification and determine what signals are required as well as what power requirements need to be provided to each subsystem.
This is something that you need to work out and agree upon early in the design. And then this needs to somehow be documented and maintained as the design evolves. Each subsystem undergoes pin swaps on connectors or signals are added and removed. This has to be communicated across the team and in a well-managed way so you don't end up with crisscrossed or missing signals in the final product.
Now, connectivity management. When you're managing these interfaces between boards, pin swapping is often necessary to get a palatable routing solution. And differential pair can often start out crisscrossed and need to be swapped. These changes to the interfaces need to be synchronized between subsystems so that proper connectivity is maintained. And as signals transition from one board to another, the signal pin out will often need to be mirrored between boards.
So your design tools have to be able to handle the synchronization of interfaces between the boards as things change. Then generating reports of the interface pin outs is another requirement for traceability and should be included in any form of a design review process. Signal integrity. Any high edge rate signals will have signal integrity issues when transitioning between the boards.
It's hard enough to get an acceptable signal integrity solution on a single board, let alone from a driver across the PCB through a connector, through another connector on the adjacent board, then across that board to the receiver and the entire signal path has to be considered and analyzed. Connectors often play an important role in signal integrity and the connector manufacturers often provide S-parameter data and analysis tools to simulate the signal path through their connector offerings. Seek out these tools when available.
This image is from an analysis I ran on Samtec's website using their tool Channelyzer. Basically what you do is browse for various families of connectors, which are intended for your specific application then you use this tool to run the analysis with the specific Samtec part number. So this is the result of the analysis I ran with the Samtec tool just right off their website. This will give you some useful insight into the insertion effects of specific connectors.
This is, again, something you should consider in the early stages of the design. Iterating the analysis with different connector options to find the right device to meet your signal integrity needs will drive other areas of the design from 3D modeling to simply the board real estate considerations. So look into signal integrity requirements early on. And Samtec's not the only connector manufacturer with these tools available.
Power integrity. Since most likely be providing the power through the interface, it's another important consideration. Understanding the shielding on connectors you'll be using in the design is critical as well. Return signal and return power pads may impart flow through these shields. And knowing this upfront will give you some guidance to avoid those. Current flowing through the shields can lead to EMI crosstalk and ground loops. So return path currents flowing through shields is something to be avoided.
PDN analyzer. If you're using the Altium power distribution network analyzer and power is being supplied through a connector like an edge connector on a board, that connector becomes this source to the analysis to properly parameterize the connector as a source, you need to know the ampacity of the connector pins, as well as their series resistance, something you can get generally right out of a data sheet.
Then given the loads to the power rails, the tool will reveal to you if you've reserved enough connector pins to source the current required for proper operation of your module or if the connector pins are going to become a giant fuse. Okay. So let's talk about partitioning the board. So there are a lot of reasons to partition the design into a multi-board system.
Mechanical constraints are often driving the form factor, prototyping with existing systems like Raspberry Pi, et cetera, that can get your design up and running really quickly. And I've actually seen products go to market with these little off the shelf processor boards. Design for reuse. Once you have designed a module, you can use that across multiple product lines.
When you want self-contained modules, the modular system approach provides optimization to iterate modules and improve them over time and can be useful for bomb optimization as well. If you're using the same little micro controller engine in a bunch of different products, you're going to enjoy high volume pricing on that particular module or that piece of your design.
And it can also allow for low cost customization for the end user. It makes it real easy to come up with a custom product for your customer. Just redesign one module and you've got a new product. So when not to partition. This is pretty easy. When cost reduction is a primary goal, you're reducing connectors, protection circuitry, et cetera. And sometimes just a single board with everything on the board in a reasonable form factor is just the right solution. It just can be a real quick engineering call. And then there's sometimes when the form factor just demands that you don't.
Okay. So now typically a top level system block diagram for a complex system will define various subsystems which can kind of stand on their own. In this case, the block diagram becomes the roadmap for partitioning the subsystem into their various functional blocks. This is a very common and logical way to partition a system, and this allows for the various subsystems then to be allocated to individual contributors with specific skill sets.
For instance, power trains can be allocated to the power electronic specialist whereas a different skill set may be necessary for analog signal processing and another for designing the CPU. So the dumb cut as I call this. This comes into play when you need to refactor a product into a new physical configuration. Now, by keeping all like functions on the same PCB when you divide this up, it'll reduce susceptibility to crosstalk from digital signals getting into analog inputs and EMI from power switching devices from getting into other low level signals on the board.
This is also an opportunity to make some design choices as to the interface standard, the signals you're transferring from one board to another. For example, rather than designing a parallel data and address interface, a single PCIE channel, it only needs four signal pins, power ground, and a differential pair. So again, this is an opportunity to make some design choices leading to potentially a more robust product.
Now I mentioned standard form factors earlier, but off the shelf COTS boards allow for quick prototyping. There's Arduino, Raspberry Pi and others with a custom shield to get your prototype up and running quickly. So you can start billing out software, your control algorithms, et cetera. As you know, the trade here is that you'll generally have unused hardware which takes up space and adds costs. Custom designs will also be a cleaner solution every time.
So once the prototype hardware is up and running, you'll have the opportunity to redesign your micro controller to optimize the bomb and make it your own custom design. Okay planning all of this is key. All disciplines need to be involved. Each team needs to work together to divvy up the workload and agree on how the system is to be partitioned and what the interfaces are on both the electrical and mechanical sides.
Any environmental requirements must be addressed in the planning phase as well. This will include things such as ambient temperature ranges, humidity, shock and vibration as well as environmental contaminants which may be present. This will drive things like conformal coding requirements, heat sinking, and other cooling requirements, and any other factors to keep your design robust in its operating environment.
Then as this will be a system which will come together as various pieces into the fabrication assembly process, those fabrication assembly partners need to have a review of the system early on to address any potential issues in integrating the system as a final product. And don't forget the final packaging, right? All right. Communication is paramount. As the design evolves from a system standpoint, interfaces on both the electrical and mechanical side may evolve as well.
Someone needs to take a top level ownership of the product and make sure the documented specifications of the interfaces are being met. This all needs to be properly managed and communicated, and communication must be maintained across the team. As we'll see, Altium designer has a multi-board system level project which can handle the management of the interfaces from both electrical and mechanical domains, but someone still needs to own the project from the top level and ensure that as interfaces change, this information is pulled from child projects, analyzed and properly communicated across the team.
Okay, connectivity management. Now, when you're defining the electrical interfaces, if you can, stick to standards. The standards are there to ensure success. If custom interfaces are required, keep it simple and use mechanical interfaces, connectors which provide the proper signal integrity, impedance requirements. Additionally, some other basic rules of thumb will help drive the system to a successful completion, things like keep signals and processing on the same boards. This'll help with crosstalk and EMI and ground loops.
Consider any high speed and impedance driven design characteristics upfront to make sure the proper interfaces and connectors are used throughout the signal paths. Shorter routing paths are always better. And when it comes to return paths through the interface, more ground pins is always better. More ground pins than you think are necessary probably are.
Now when considering your interfaces, simpler is always better when you can get away with it. Fewer signals crossing the barrier between boards reduces the pin count on connectors hence cost and increased reliability. Fewer signals can come with a trade though in signal integrity. High speed signal interfaces like PCIE will result in fewer signals to manage. However, it will take some consideration on the layout.
PCIE can however utilize edge connectors. So sometimes this comes with a cost advantage because then you only need a real costly connector on one side of the interface. Another really important consideration is where your return paths flow. Not managing your return path can result in EMI, crosstalk and ground loop issues. Cost is always a big consideration. How many signals do I really need? What kind of performance do I need on the interface and what connectors are available and at what cost?
If you can get away with it, also consider rigid flex. This will reduce a potential number of connectors and there can be a potential cost advantage there. So managing the return path across the interface is critical. Keeping the power and signal return path separate is important to minimize the impact of any power supply ripple on the signals, as well as again, reducing crosstalk and EMI issues.
Grounding and proper consideration of return path is paramount for signal integrity. Differential signaling will help to improve signal integrity and decouple your signal from noise on the grounding structure, but keeping again, those power and signal return path separate is really critical. The signal return path is going to flow through the path of least impedance through the grounding structure.
So utilizing one signal return path causes a higher impedance for that signal return path and can cause signal return current to find its way into the supply return. Noise and, or ripple on the supply return, can this find its way into signal returns causing undesirable results on the interface and potentially leading to SI, EMI and crosstalk issues?
Now coupling one signal path to another, if you have multiple signals on the interface sharing the same return path, coupling between those signals can occur in that return path leading to crosstalk. This with the potential for signal returns also somehow coupling into the supply can cause multiple issues, which I'll stack up against you.
The best solution is to provide at least one return path pin for each signal on the interface. This will yield the lower impedance return path that you need for signals, minimizing the return current mixing with other supply current and the return paths mixing between signals, the possibility of EMI, ground balance. Additionally, it'll help keep the return paths of each signal separate, again minimizing that possibility for crosstalk on the return path.
So this is a DDR edge card connector pin out, and we can see an implementation of this methodology. When examining the bus structure, notice there is a ground pin on each side of every signal pin and differential pair and then this is what the layout would look like. Again, you can see a ground pin on each side of every signal and differential pair on the entire interface.
Now by routing power and signals through the same connector, you can control the return paths of each, reducing the possibility ground loops due to alternate cabling paths for power and signal and the return paths can be then well controlled. The trade off is that this is going to result in more pins on the interface. If the signal edge and rise times are sufficiently low though, a standard edge connector may be all that's required which results in a lower cost solution because you really only have one connector on one side of the interface.
However, if signal integrity is a real issue and you've got a lot of really high speed signals, this may result in a very expensive back plane connector. So all aspects of the design need to be considered.
So when choosing the proper interface between various subsystems, it's really good to be familiar with various interface standards and the advantages they bring to the table. These are just a few representative examples and the engineering designers should investigate what's available. The standard will not only specify the signaling to be implemented on the interface, but also the mechanical interface itself such as various forms of edge connectors or more costly back plane connectors.
And I stated earlier, when you choose a standard and designed to its specifications, the end product will work with a really high degree of confidence. So this is my list of considerations when choosing the right connector. What are the power requirements? If you're going to be... Well, most likely you're going to be sharing power and signal on the same connector, can the connector handle the ampacity necessary to actually power your module?
And what are the signal edge rates involved? Can you get away with an edge connector like DDR4 or do you really need to go to something like an expensive back plane connector? What is the electrical length limitation of your specific connections or your routed trace? The connector has to be considered in that and the impedance of that connector, signal integrity, everything needs to be thought about with respect to that connection.
What are your EMI and EMC requirements? In the data sheets, you can get a handle on some parametric information that can help you decide if that connector is the right solution for your application. What is the crosstalk susceptibility? Again, putting a ground pin in between every signal pin is a really good idea. And if cost versus performance, if you can tolerate it, you should do it. And again, you always have to consider the cost. That's the world we live in. The trade off is cost versus performance, right?
Okay, connectivity and form factors. Now when choosing a proper connector for the interface, power and signals with their potential signal integrity all have to be considered. Now the pins have to have enough ampacity to deliver the required current for the load while at the same time providing good signal integrity at the signal pins.
There's kind of a trade there. Using standard or custom interfaces will also drive the decision as to which connector type to use. The standard will call out a particular mechanical interface. Now, if you're using headers and sockets, the library needs to be properly configured to mirror the pin out of the sockets to the pin.
Now, okay, so think about plugging a set of header pins into a header socket. The numbering of the footprints are mirrored, right? From one board to the other because it kind of flips over. So while the schematic symbol still needs to align pin one to pin one on the mirrored halves of the header just for readability on the schematic, you need to mirror the schematic symbol to the footprint in the library.
So in other words, if you don't do this, there's going to be confusion when you're reading the schematic, right? Okay, so some other form factors to consider for subsystem development or the board on board configurations. Using a castellated board or single inline package, LGA, BGA, you can lay that stuff out on a board and that can actually be placed and re-flowed. So that's something to consider as well.
Now your library management is one of the most important aspects of any E-card design activity. If your libraries aren't golden, you can't design a manufacturable product without significant time spent in cleaning everything up. And again, when creating board to board headers, you must mirror the pin numbering between the symbol and the footprint just as I discussed and you need to decide upfront if you're going to standardize on mirroring the pins or the sockets and then stick with it, otherwise again, your libraries are going to get to be really confusing and you're just going to end up with a big mess.
Spending a lot of time up front with your libraries is going to save you a lot of time and headache in the backside of all of this. 3D models are an absolute requirement in order to guarantee that all subsystems fit together in the final product. IBIS models are also useful to add parametric information to the components in your library so that your designs are simulation and analysis ready right up front.
Okay, so supply chain, some rules of thumb, never single source connectors, especially how the supply chain industry is falling apart right now. High volume, high production rate components, your suppliers just can't get them, right? And you don't want a single source in, actually you don't want to ever single source in any component into any E-card design if at all possible. Investigate the long term manufacturer's life cycles.
You don't want to design any connector that's going to be end of life anytime soon if your final product is going to be manufactured for years. And check supply chain. Is this a really popular connector, a really useful connector and everybody in the world is using it? And this just seemed like a good place to mention duty cycle. How often are you going to mate and unmate your connectors?
Is this a product where modules are going to be plugged in and removed very often or are you going to pretty much put this together once and live with it until you have to do upgrades to the system? Connectors do have a duty cycle specification and you should familiarize yourself with that upfront and think about your application and how often are you going to plug this connector, right?
Then I've got a kind of an anecdotal story for you. In years past, Altium has developed hardware. And we had a nano board product and the motherboard for the nano board had daughter cards. And in kind of the 2000 timeframe, there was a laptop docking station connector was really popular. And it worked really well in our application and we used it all over the place in the nano board. About halfway through the life cycle of that product, Molex end-of-lifed that connector.
So we had to have that reverse engineered and manufactured in China and we had to do that with permission from Molex. How long do you think all of that took and how long do you think we had product back ordered? I don't know. It comes down to all of your supply chain issues. Just don't let this one bite you because if you don't consider it, you will have problems, okay?
Now you should also explore alternatives. Rigid flex is something to consider. It may not be the right solution for your signal integrity needs and so on. But this is actual... This chart is actual data from a quote from a fab house. Now, something you should do up front when you're in the design stage and you're considering connectors and the layout and things, get some high volume quotes up front and then as you iterate the design and things change, keep getting those quotes because you may find a very low cost solution that actually meets all of your performance needs.
Now, if you stare at this chart for a minute, you'll notice that at real low volumes, the rigid flex is definitely a higher cost solution. But as you go up, there's kind of a place where those two graphs cross kind of in the hundred of units produced here and then the cost goes down with respect to the rigid flex as you kind of go up into the hundreds and thousands.
Now this doesn't look like a huge cost savings, but in the 250 to thousand unit area, that's like $2 per unit. And if you're producing thousands of these, that can be a significant amount of money over a high volume product. So it's just something to consider, okay? Explore the alternatives. Okay, a few stacking form factors to consider. Again, as I said earlier, using COTS modules can be a quick way to get a prototype complete for product development.
And the Arduino form factor is really simple, really cheap and has become somewhat of a defacto standard. Again, it's quick, it's easy to design with and shields are readily downloadable as templates. So you could come up with your own hardware design and use the Arduino as your engine and now you're into the software development stage.
As I stated earlier, the trade off with using COTS modules is that you're going to have potentially hardware that's not used but also the Arduino's not really meant for high speed design, neither the processor or the actual board layout. So here's what that interface looks like. Now, this is a very simple interface.
And if you look what's available here, I've got a bunch of data and address lines and some I2C on, who knows? This is really useful for a lot of little products. And this will get a lot of things up and running really quickly. So it's definitely something to consider. And then again, once you've got your product, you could even go into the market with this. And then as you're generating some revenue, turn around and re-spin the processor and come up with your own custom piece of hardware to replace the off the shelf COTS unit.
Another form factor to consider is PC-104. Now these have a really nice stacking form factor and there are enclosures made for this as well. I actually released an industrial control product years ago in a PC-104 form factor. And they made these nice, neat little metal housings that went around each board and the metal housings actually stacked and interlocked.
And then there was a cap that went on in each side and there were little metal housings that would facilitate connectors coming in and whatnot, and I had this really great brick of a control unit. So it's definitely something to consider. Now, the PC-104, it's inexpensive and it's also really simple to design with. The templates for the board form factor with the connector locations and mounting holes, all predefined, they're readily available and downloadable.
And this is what the interface looks like. There's a lot more power here and there is a PCIE variant of this that's available. So this is good for high speed design implementations as well. So definitely something to consider, some of these other off the shelf form factors. So pop quiz, how fast can you drive a 0.1 pitch header?
It's probably faster than you think, and yes, it does depend on the driver and how you organize the pin out and how well you lay out the board. But the IEEE 1392 standard drives a 0.1 pitch header at 480 megabits per second, and USB too. That's also on a 0.1 header platform and that's 480 megabits per second. I don't know if you did the layout right and utilize the pins properly, I don't know, maybe a gigabit per second. It's cheap, it's easy and definitely something to consider.
Okay. SMARC 2.0 and QSEVEN are a couple of really popular form factors. These are on edge connectors. So it's an inexpensive solution. These do support high speed design. The QSEVEN spec calls out that this interface will actually support 12 watts of power. So you can power a pretty extensive little module with this, and you can find all kinds of COTS processors and things that are already readily available on this interface.
You can download templates for this. So develop your own custom hardware on this, get an off the shelf processor and then reverse engineer the processor... Well, not reverse engineer, but come up with your own custom design on that interface. It's something to consider to get you up and running quickly on a fairly robust and inexpensive interface. And don't forget about DDR4 and PCIE.
These are really common, DDR4 being a parallel interface and PCIE being a high speed serial interface. And just because you're using a DDR4 specification doesn't mean that you're necessarily developing a RAM card. You could put a processor on this form factor and develop a product around that particular interface, same thing with PCIE.
All right. So that's what I've got for you in this part of the presentation. So it's demo time. Okay, here we are in Altium designer. Now, when you're working with a multi-board design, we actually have a special multi-board project. Now with a regular PCB design, you add to that project schematics, PCBs, basically all of the files to generate a PCB. When you're working with a multi-board project, then you're actually adding complete Altium designer designs to that.
So for instance, here, I have a PC motherboard. I have a SODIMM memory card, and I have a little wifi module. These are all independent Altium designer projects and to themselves and I've got a multi-board directory here where we will put all of the multi-board files. Now you create a multi-board project the same way you do any other project, file, new project, only instead of a PCB, we're going to do a multi-board project.
Okay. Now let's go ahead and start loading this up with our various PCB project. So right click add existing to project, because we want to add those existing designs. I'll start with the motherboard. And I'm browsing to the PRJ PCB file. And I'll go ahead and open that PCB and we can have a quick look at it. Now this is a standard PC motherboard and what we basically have are edge connectors on our SODIMM memory card and our wifi module and those are going to be inserted into the connectors here on the PC motherboard.
So let's close that up a little bit and we'll add another existing. This time we'll grab the SODIMM card. You'll notice we've got two slots for that. So we'll actually be adding two instances of that to our multi-board project. And we'll add one more here, a little wifi module.
Okay so this is our wifi module, this is our SODIMM memory card. Look at that in 3D, pretty standard little memory module. Now the wifi you'll notice also has an edge connector down here. Now I'm going to open the schematic for the wifi board. This is where some of the magic behind all of this begins. You'll notice I've got a little STM32 micro control. That's a little engine for this, but it's ancillary hardware, a little LED. It'll let us know we're actually running.
Then I have a wifi module chip here and then little PCIE connector here with a differential pair for our data that we'll be transferring to our wifi module. Now here in the connector, we have a parameter down here, system connector. So basically just add another parameter, give it the name of system and then the value of connector. Now you can set all of your connectors up in your libraries this way.
And even if you don't use this, it's not going to affect anything. But what this basically does is tell the system that this connector is an inter-connect between boards. Now this could be an edge connector as it is in our case. It could be headers and pretty much any other kind of a connector that you're going to use for board interconnect. Okay?
All right. So let's start loading up our multi-board project. So first thing I'm going to add new to project is a multi-board schematic. Now this is where we place various virtual instances of our board and wire them all together. Make sure I save that and we'll make sure we put that in our multi-board project. Okay. So the first thing we're going to do is place a module.
We'll place a module for each of our boards so that'll be my PC motherboard, then I'll put a couple of instances of my SODIMM memory card in here and my wifi module. Oops, straighten these up just a little bit. Just kind of neaten things up a little. There we go. Okay, now we're going to back load each of these modules with the actual PCB. So this is going to be our mini PC.
It's just a title. The actual connection happens through the designator of this. Okay, and this is one of our SODIMMs. And we can give both of these the same title because again, it's the designator that performs all the interconnectivity and stuff. So there doesn't have to be anything unique in the title. Oops, pick the board or the design, then this is our wifi. And we'll pick our little wifi module. And let's... just a little neater.
Now the connectors with that system connector parameter will invoke the system to actually give us a little entries in here that we can wire everything together with. So we'll go to design and we will import from child projects.
And anytime we transfer the design from one domain to the other, we always get the engineering change order dialogue, just as if I were updating a PCB document from a schematic, where schematic and PCB are always dynamically linked just like this multi-board schematic is always dynamically linked to the child projects. I'll go ahead and execute that. And now we have these little connectors, these basically electrically connect to the interface connectors in the child project. Bring these around here just to make things easier to wire up. Oops. Oh, come on. I get a little mouse happy sometimes.
Okay, now the next thing we're going to place is a direct connection. Actually let's have a look at this first. Let's make sure that we've got these kind of in the right order. So I'm going to select J8 here. I don't really remember what that goes to in the schematic. So let's cross probe to the schematic and make sure that's really a SODIMM connector. We'll do the same thing with J20. It's also a SODIMM connector.
And then just for completeness, we'll make sure J13 is really going to the right place. So there's our PCIE connector. And we'll go ahead and close that group because we don't need them anymore for right now. Okay, now let's go ahead and wire these up. It's pretty simple. Just like it says, direct connect. Okay. Now when I select one of these interfaces, I can go to my properties panel and I can see all of the signals or nets that are on that connector and I can see where it goes to and from in the various child projects.
Okay, that's pretty much all there is to it. Okay. Now let's add new to project... Whoops, add new to project. This time we're going to do a multi-board assembly and I'm just going to hit save all here. Put it in our multi-board project. Okay. Now we're going to import the changes from our multi-board project. And again, we go through the ECO dial. So it's going to bring our mini PC in and our two SODIMM boards and our wifi module.
This'll bring in... It'll bring these in in 3D and then we can place the edge connectors of the daughter boards into the motherboard and we can have a look then around and look at various nets and some interconnectivity of the copper and so on. This takes a few seconds because it really is bringing in an awful lot of data.
This is when we could use a little bit of jeopardy music. Okay, so there's the motherboard, one, two SODIMMs and our wifi module. Okay, now we have a panel that's our multi-board assembly and we can select each of the boards in here. We can browse to various components. We can look at the net connectivity of the copper. So we can basically investigate everything about each one of these.
Now we're going to want to add some mates to these. Now I'm going to start out with one of these SODIMM cards. Now this is module M2. So let's go back to our multi-board schematic and module M2 connects to J8 or slides into slot J8. If we zoom in here, that's the top slot. Now we can add mates to these. Now you'll notice I can drag this linearly in the Y and the X directions and there's also a Z-axis drag here.
And I can also rotate this by clicking on the little arc here, and I can rotate this to any angle and it kind of snaps into the 90 degree positions. So what I'm going to want to do is add mates to this SODIMM card and the motherboard, and actually that will fit the card into its slot. Now, when you're doing this, this SODIMM has an access and so does the motherboard. And they're a little different.
If I set a mate on the SODIMM card and then add the accompanying mate to the PC motherboard, it's going to move the PC motherboard to the memory module. But I actually want to insert the memory module into its slot, leaving the motherboard where it is. So I'll place the first instance of the mate on the motherboard. So let's zoom in here a little bit.
Now there are a couple of places where we can do mating under tools. We can create a mate or up here on the active bar, we have an icon for mating. Now I'm going to choose this surface. Now you'll notice I've got different handles here, basically all of the corners and the centers, in between them. And I actually want this mate to be right in the center of this object. And soon as I do that, you'll notice it leaves behind a little purple emblem indicating that that's where a mate exists.
So now we'll drag this around and we'll put a mate again right in the center of this one. And those two are connected. Okay. Probably should have done the bottom one first but that's okay. We can get in here. So I'll do the same thing here. Let's get in here where we can see this. And I want to put it right in the center of that.
So there we have our two memory modules placed. Now let's grab the wifi just to make things a little easier. Whoops. I'll drag it up here close to where it's going to go and will rotate that around just to make it easier to find the target for our mate. Now you'll notice that pretty much any surface in here, I can mate things too. So I could have chosen this inside surface or some other feature. It's just I've done this a couple of times and this is a real convenient place to put that. And whoa, where am I?
Okay, that was kind of a wild ride. And come in here and we'll mate that. All right, so now we have our design put together. Now again, we can look at some of the net connectivity through this. I can see how the nets go through the connector into the memory module, can view various pieces of copper in here, I can highlight layers. So let's do top copper internal planes and so on. So you can investigate your design at this level.
Okay, now we can run some interference checks. You'll notice I do have a collision between this connector and the wifi board. So let's go ahead and check for collisions. So this will run for a little bit here and then our messages panel will show us any collisions that we have. Now this has to do with collisions from board to board, components to board, pretty much any 3D model in here that collides with another 3D model will actually be flagged for us.
And we can investigate these here. So now you'll notice that the collisions are highlighted in kind of this gray color. So it's kind of a translucent gray. So this is the edge connector down below on the lower memory module and here it is on the upper memory module. Now you'll notice it's flagging a collision because the teeth of this connector are digging into the edge connector of the board. But in reality, that's really what we want.
So it's good to know from this collision check that the tool or the design is doing what we want it to. There's another one. So we're having a collision with this board and its connector, which we would expect. Now it's flagging the collision between this connector and the wifi module and again, the other SODIMM card and there are two pieces of this connector that are colliding here.
So let's go ahead and fix this. So I can select the board and then under... Let's see, actually it's under edit, edit selected part. Now the part being the mini PC board that I have selected. So I'll go ahead and choose that. And this basically unlocks all of the components so I can move them. And I'm going drag right along the X-axis here and I put this in this general vicinity. If we have to fix this up a little more, we can do that actually in the mini PC motherboard.
Now, when I click finish editing part, it's actually going to transfer this information to J16 in the mini PC PCB doc. So I go ahead and execute that. Now this will take some time because as you can see, when we were investigating the layers, this board has quite a few layers in it, and there are copper pores on a lot of the layers.
And so you'll notice removing polygon from database, that's basically saying it's modifying a polygon. And so this is going to take some time here. Another good time for jeopardy music. Now, this is actually a very powerful tool if you notice. Since the multi-board schematic, the multi-board assembly and the child boards are all dynamically linked, we can make changes in one domain and then push those changes to the opposing domain. And so this is all interactive and this would work very well for team collaboration as well.
As we get a little more into this design, I'll show you how we're going to actually modify the signals on one of the interfaces and then push that from one board up through the multi-board schematic and down into the opposing child PCB design. Okay, it looks like this is getting done. I'm looking at the status bar. There we go. Okay, so let's look at this design in 2D. Look at that. I got that lined up pretty well. Okay.
So really all that's left to do is kind of edit the routing here a little bit. Let me zoom in a little closer so I kind of see what I'm doing here. There we go. Ah, I'm kind of persnickety. Let me get that a little nicer. And the polygons little report and that's looking pretty good. Okay. So I'm going to go ahead and save the board. Now let's go back to our assembly and let's pull that change in.
So we'll go to edit and we will update all parts meaning the actual modules that we brought in, this is another one that'll take a few seconds here, that it'll actually bring all of that change that we just made including the routing then into the assembly here. Okay. That's looking pretty good. All right. Now, I'm going to come down back to the mini wifi board.
And notice we've got a differential pair here, the positive net is on pin 38 and the negative net is on pin 36. What I'm going to do is some pin swapping on the interface here. Now this is a properly routed differential pair. Typically, if you're going to do pin swapping, it's to keep things from being tangled up and untangle them. But for this example, I'm actually going to tangle these two. And we'll do some tools, pin part swapping, interactive, and I'll swap those two.
Now, yes, those are crisscrossed. Again, normally you would execute pin swapping to untangle things, but I just want you to see how these changes propagate through the multi-board project. Now, again, you'll notice up here in the schematic my positive net is on top and my negative net's on the bottom. Now when we perform the pin swapping and push that back to the schematic, we have some options here, two actually.
We can add and remove net labels or we can change schematic pins. I tend to tell people to kind of ignore this one and pretend this doesn't exist because the tool will actually renumber the pins on the schematic symbol. But then if you ever update that component from the library, you'll lose that pin swap information. So what I like to do is with things like this where you may be doing some pin swapping, rather than wiring up your connections, I like to substantiate those connections through net labels so that we can perform that swap.
Okay, so we'll go to design update schematic. Again, we'll have to go through the ECO process. I don't want to modify any footprints so we'll disable that group and we'll go ahead and execute this and we'll go back to the schematic and you'll notice that swap those net labels forming. Now, we'll go back to our multi-board schematic and we'll select the wifi module, right mouse click, go to design and import from selected child project, meaning the one that the wifi module that I just selected here.
And again, we're going through the ECO process, execute that. Now we know that we've got a couple of signals that are crisscrossed now on this bus. But in order to sort this stuff out, we actually have a connection manager here. You'll notice the button says show changes only. Soon as I click that, now it says show connections, meaning all connections. So that's basically just a toggle. And if I click over here, it's showing me my crisscrossed signals.
Now I can revert meaning I'll push that back to the wifi module if for some reason, the PCB designer of the motherboard couldn't tolerate that, and somebody's got to go back and figure out a better way to route the wifi module, we could revert but I'm going to go ahead and swap the pins and now the signals are straightened out, apply those changes. And I want to come back to the connection manager again because I want to export a report here.
Now let me bring Windows Explorer but this is the report we just generated and this'll give me a spreadsheet that didn't get filled out. Hold on, let me do that again. Let's show connections. Okay, this has to be turned on. Now we will generate the report and this should be populated.
And this shows me, okay, so this is my connection C1 and as we scroll down here, here's connection C2 and then the wifi module will be the connection C3. So you can generate reports on these, just another way to track the evolution of your design. Okay, now what I can do is right click design and then update the selected child project. That would then swap the net labels in the schematic of the mini PC, then I would push that to the board and then I'd do some rerouting to facilitate that swapped differential pair.
Okay, now what I want to do now is I want to bring the enclosure in for this and place the design into the enclosure and check for proper fitment. So let's go to design and import a step. I've got a step model of the enclosure of this. So I've got the case bottom and the case top. So we'll bring the bottom in first and we'll go ahead and add a mate to this.
Now, when I'm adding a mate to something like a mounting hole, you'll notice I can add the mate to the top of the hole, or if I push down geometrically, it can add the mate to the top of the hole. Well, in this case, I want the bottom of my mounting hole to mate to the structure that was intended for it. Okay, now we can see the mate is still selected here, but it didn't exactly rotate it properly. So now I can use the space bar. As long as that mate is selected and I press the space bar, it'll rotate the object around that mate.
Okay. So now let's bring the top cover in, case top, and we'll perform a similar feature. Now, these little mounting posts here are the mounting structure for this. So here's the mating structure to that post over there. So I'll go ahead and add a mate. I don't want to do it this way. Well, I guess it won't matter at this point. And then I can come over here and add the mate and then rotate it into place. Okay, so here's our finished design. I can look around, make sure that all of my connectors fit. I can also do a collision check at this level as well.
Now I also have a section view of this. It didn't come out so hot. Let's pull this down here so we can see this, do this so we can look around inside. Okay, now I can browse around in here. I can actually see the pins or the fingers of the edge connector that are making good physical contact with my connector there. I can also see that I don't have any tall components that would be blocking the airflow of my ventilation.
And so I can kind of look around in here and check for proper fitment. Again, I can run another collision check and just make sure that this all looks good the way I want it to. And whoops, there is our finished product. Three boards all fit together. Their fitment has all been checked and verified.
Again, we can move components around in the assembly and push that back to the board and then rework the board a little bit. If any of our interfaces change, we can handle that through the multi-board schematic, and then we can actually fit our final product into its enclosure and make sure that our product is manufacturable. Well, that's what I've got for you. I really appreciate your time.