Ladies and gentlemen, welcome back to this mini series in The Factory design a product with us. Where we design a product from scratch before your very eyes, we are designing the PiicoDev servo driver. If you recall from the last episode, we assembled and drove our prototype PCBs with the hello world code that we developed earlier in the series.

Between now and then, I've actually made some significant upgrades to the hardware design in preparation for production. So, in this episode, I'll walk you through the experiments that I did to decide on whether to upgrade or not. We upgraded from three channels to four channels, ran a bunch of experiments to see if that was like a responsible thing to do with the amount of power that we could drive with this unit. This included a bunch of features and artwork on the PCB and it is now ready for analyzing.

This is the design as it stands. You can see we have some beautiful silk fonts here, we've squeezed in a fourth channel, there's an address switch and we have a breakout header. So, this is a lot more general purpose and maker appropriate. Join me after the intro to see how we arrived at this upgraded design.

Okay, so this new design features the fourth channel. In the last episode, I was kind of like, "Oh four channels, it might be a bit too much," but we decided to go for it because it'd kind of be rude not to, right? To give people the option. We also recognize that you might be driving these smaller servers which don't draw as much current and so having four channels could be a real enabler. And then it's just up to how much torque your servers are delivering, how many there are, and how powerful they are. A lot of the last episode was spent fixing the fact that I didn't have an address switch on the prototype. I've opted for a two-pole J lead address.

Which for a couple of reasons, it actually fits on the board. Two Poles will give you four addressable options which I think is ample for the servo driver, even though you could go as high as six switches it's starting to get a bit silly and we already have this part. It's great to reuse parts that are already on the machine, we already stock manage them so I think two poles is the sweet spot for the servo driver. That will mean you have a maximum of 16 servers connected to your PIC of project before we get into like muxing the I2C bus or anything like that.

Now the eagle-eyed among you might realize that I have regressed this three pin header to the non-rotationally symmetric footprint in one of the previous episodes. I created that symmetrical footprint so that if we wind up not being able to get this part and actually have pin one on the other side, it won't matter, we can still put the part down. But to get this fourth channel in, I've kind of squeezed them all together. You can see they're actually overlapping each other. If on the courtyard's layer you can see the courtyards overlap by quite a bit and like that's not a big deal, you just get some warnings when you run the design rule checker, but these are pretty conservative and I can see that they're going to place just fine.

Now if you're familiar with KiCad, you might be looking at the text on the board and thinking this text looks pretty good. And this all comes from an open source plugin called KiBuzzard that we just love to use for its beautiful silk labels. So rather than using the text tool to enter some text and just having this like very, you know, very kind of flat uninspiring font, we can use this plugin tool here to create labels for you. You can even install your own fonts. I quite like the Fredoka one that's built in.

This just makes artwork for your PCB much more appealing. Though you can't edit it like a normal text element, you have to actually select what is now a virtual footprint and click the Key Buzzard plugin box. This will pull up the text box that you've selected and has been a game changer for making attractive designs. To spend a bit of time rerouting the board and managing these power rails, everything is just looking a lot nicer and more considered. Before we panelize it, I'll walk you through the experiments that I ran to get to this point.

I set up an experiment with the server driver being powered by the Otii Arc. The Otii Arc is like a power characterization tool, supplying power to your project and also analyzing that power. We've got the Pico W connected to the servo driver and a server connected to that server driver. Everything is being powered by the Otii Arc, supplying the 5 volt power to the servo driver and these other two wires are just some voltage sense wires.

I ran some code to drive the server back and forth a few times and got the following plots. I wanted to get a vibe check on the project, looking at the current and the sense plus voltage. The peaks are at about 2.5 amps, which is pretty serious for just one server. Remember, we could potentially connect four servos. These graphs are pulsing because the server is being driven back and forward.

One of these pulses is the moment where the server is being told to drive. We've got some stall current and then as the server gets up to speed, it's drawing less and less current until it reaches a constant velocity and then turns off. In fact, this code is driving the server quickly enough that it never comes to rest. So, on the next pulse, it has to resist the motion of the motor to move backwards and forwards.

We can see we have some pretty serious Peaks up around 2.5 amps and the V sense we're getting a drop of up to half a volt for that stall current which isn't really surprising. So, I thought hey we've got like a capacitor on board let's just Chuck on a 220 mic capacitor additionally. A big through hole component just to see what happens and I'll also put on a 100 nanofarad cap right across the terminals of that servo just to see how we go.

Uh, once I introduced that large Reservoir cap it basically didn't make any difference. Here you can see the two plots and I've overlaid them over each other. There might be like some small offsets but you can see these Peaks are about the same height which is no surprise for the current. I mean it takes a lot of energy to drive the motor but as well in this voltage plot the voltage dips go to about the same point as well.

So, what got me thinking? You know I've got this Reservoir cap it's not really doing anything like it takes so much energy to run a motor that like a tiny little 47 mic cap the energy unit is just going to evaporate instantly. Now I re-ran these tests with a 9g server. You know it is these little hobby servers that you often see in like remote control airplane and this is this is like pretty pleasing to see actually. The 9g servo with no capacitance no nothing this is on like a purely.

Naked board where I've actually removed the reservoir cap, this guy is only getting up to peak around 800 milliamps and that's a lot more appropriate for a four channel servo driver. And just for completeness, I re-ran that same experiment with the 220 mic and 100 nanofarad cap and the current waveforms look exactly the same, which is no real surprise. What's really interesting are the oscilloscope captures. So here we have the big servo with lots of capacitance and we get a dip on the scope, you know much higher bandwidth measurement we get a dip on the scope of like nearly a volt. About a volt. Here's the same again with no caps and we get exactly the same response. After doing a few more experiments looking at noise on the power lines, I just decided to remove the caps entirely, which is great. You know, the project still works and we have a simpler board for it. It's one less component that we have to load onto the reels, stock, manage, assemble, test, etc. So we've upgraded our board, we're at our production version and that just brings us to panelization.

This is another particular module, the RFID module. You don't just assemble a module like this as a single PCB, that would be really difficult to just even handling something like this to assemble it would be quite difficult. So instead, for production, you tile this PCB in what's called a panel. So here we have a panel of 27 units all together and this is a much more manageable size for machines. Panels have features like these rails that can ride on conveyor belts in an assembly line. So this whole panel can go into a machine, we assemble 27 at the same time, goes through the oven and then at the other end we just break it apart or de-panel it. When we started doing this a couple of years ago, I had to actually hand make these.

We start a panel with an empty PCB project and run the panelize plugin, the kick it plugin. We select our input file and we can begin. Now if we just have zero for these spacing parameters, let's just start with a two by two panel just to see what things look like. I'll just enter two by two, can we hit panelize? We need to make sure that we're very concise with our data entry.

Okay, so that is a two by two panel with no space between components. You can see that kick it has actually changed the names of these nets so that you don't have ERC problems. You actually have unique nets for every single board and that way there's no like Nets not connected to Nat's problems.

All right, let's work on some other features. We're still in two by two but let's introduce some space. We'll put in a three millimeter Gap horizontally and vertically and now our units have slid apart just a little bit. You can see we actually have automatically generated some tabs from kick it which are quite naively placed but I mean cool, this is all just defaults so far so good. We'll build this panel out little by little to get to the full size.

I just want to show you each of the panels by copying and pasting the design or tiling it as an array and hand drawing this panel framework because KeyCAD just didn't have a built-in tool. Now of course KeyCAD is open source software and has documentation on how to create plugins. So the open source Community being what it is, a very industrious user by the name of Ian put together kick it which is a KeyCAD plug-in that generates PC CV panels. And I gotta tell you, without without this project we would have spent just dozens more hours on what is a pretty mundane task to have to do at the end of your project, the panelization.

If you're watching Yan, we love you, we appreciate you. Kick it is amazing. little bit easier to see and now we have just one tab per side

Tabs kind of suck because you have to break them off. It's a lot nicer to use a backbone. A backbone is this feature here where you see how this unit connects to this unit, but not through a tab. It's actually through a backbone that connects to every other unit. This way you get like a stiffness cross coupling between these strips. It also means there's fewer unique things to break off by hand and that's like a non-trivial part of the deep paneling process. It's just snapping off all the tabs. You can imagine if you made a thousand of these things, you've got a process like maybe two four tabs per unit. It's no joke.

So let's increase the horizontal space by synchronic drilling 2.5 plus 2.5 plus 3 is 8 millimeters. Let's make the horizontal space eight millimetres and put in a three millimeter vertical backbone. We've sacrificed a little bit of density, but we have this vertical backbone that couples the modules together. The reason I'm putting in a vertical backbone that runs this way is because it will keep the board nice and stiff about this axis so that it doesn't sag in the conveyor belt as this material heats up. It actually does soften a little, the resin will soften and the weight of the components included as well if there are heavy parts can make the board bow in the oven. Having this backbone that goes across the conveyor rather than along the conveyor will help with that stiffness.

So this is a great start. Let's fix the tabs next. If we select fixed tabs, we can choose the number of tabs per side. So I want one tab vertically and one tab horizontally and let's just make these 12 millimetres for each. Click penalize again. Okay, now we're getting somewhere. Now we have just a single point of contact on each edge. I'll select the edge cuts layer to make things a little bit easier to see and now we have just one tab per side. to get a much better result

I'm going to bring the panel to its full width now, so I'll increase the number of rows to three. That will be our full width. I hit panelize and this is where we're going to add these rails, these top and bottom rails that will bring the panel out to its full width. I can use the measure tool and go from edge to edge and we have 162 millimetres and I want 190, so I'm going to go to framing rails top bottom. I think we want a space of 2.5 millimetres and a width, the width is the variable here to bring us out to our 190. 11.5 millimeters. I'm also going to include a three millimeter chamfer. Let's see what this looks like. There it is, we have a panel that is exactly 190 millimetres wide and now we can just tile this out to the full length, nine columns.

This is why I was doing this with a much smaller number before; it takes significantly longer to penalize more units. I can see here that I have these single tabs that still joining the modules together. Perhaps it would be better to have no tabs joining the modules and have two tabs on the backbone, that way there's still just one thing to snap. So we have vertical count zero, horizontal count two. Now you might have seen some artifacts in previous shots as I was penalizing, but once you run the post processing, which is what basically sets the minimum Mill radius to give you these like curved tool paths, those artifacts go away.

So here's the panel as it stands currently and we are so very close. You might notice that these end units are just kind of like dangling out here, flapping in the breeze. They're only supported by a backbone on one side and so really we ought to be using the frame type instead of the Rails top bottom framing type. If we change this to frame and leave all those parameters the same, re-panelize, we ought to get a much better result.

To get a nice end tab on this side of the panel, there's our panel and it's even the right size - how nice! Now for the V Cuts, we want V cuts and we want them on the Edge Cuts layer - that's what our manufacturer prefers. You can see now Kick It has inserted all of these Edge cut lines and they're even all annotated for the manufacturer. It's even put in these two additional cuts to allow the top and bottom rails of that frame to be snapped off.

Now of course the reason we do all this is so if there's a design upgrade that we make to the part, then we don't need to reinvent the panel - we can just copy and paste these parameters straight in and we get exactly the same panel as a previous revision. And that also means that if no parts moved around, we use the same stencil as well - everything is deterministic and still in exactly the same place.

In that little time lapse you just saw me add a few features like the tooling holes and traditionals. These are just for manufacturing and assembly - basically the fiducials are the optical alignment so the pick and place machine and the stencil machine can find where the panel is in space. There's always three of them on our panels because if you load the thing in backwards, it'll go looking for that fiducial and it won't find it and it'll let you know that there's a problem. So that's like a little bit of a built-in error checking. Tooling holes we don't really use them, but they're just there because it's a bit of a convention and it might be useful for something later on.

I'm doing my final check of the panel - I've put on all the metadata. I can see that this fiducial is overlapping the text a little bit, so I'll just move that text. And of course we don't see any of the geometries here because KeyCAD won't render all the cutouts.

When the V-cut lines are on the edge cuts layers, you can push those back to another layer to see the beautiful routing, but I'm satisfied seeing it within the PCB editor and so this is ready for Gerber export to the manufacturer. And so there you have it, from prototype to panel we designed this from the scratch. We started with the schematic, we did the design verification on the prototypes, did some Hello World coding.

I'm not sure if there's going to be any more installments to this series, absolutely let me know if you have any questions. If you want to discuss anything, just see us on our forums. What do you want to see out of this series? Do you want to see how we put together more of the MicroPython code or does that start to feel a bit heavy-handed? Let us know.

In any case, I think that's a pretty good spot for us to stop in today's episode. We've got a producible panel that we can send to the manufacturer and then we can start placing some parts. Thanks for joining us for this little product development journey. I hope you've enjoyed and of course, until next time, thanks for watching.