Buck converter board schematic capture

Timeline

We have several PCB-related activites going on this week. Please check the course calendar to make sure you don't miss anything.

• This week we do peer review of the sensor-board schematic and then do the layout
• This week we also draw the buck converter schematic

Several of these deadlines are only a few days away!

Learning Objectives

In this exercise, you'll create a schematic for a custom buck converter in KiCad. This will give you more experience with PCB design.

The power subsystem

We're eventually going to have three parts of our power subsystem:

• A battery manager that can charge a battery from USB or solar and power the rest of our system off the battery or solar or USB as needed
• A buck converter that will take the raw voltage coming off the USB (~5V) or battery (~3.7V) and output a clean 3.3V with enough current
• A fuel gauge that can monitor the battery state of charge

Here we're doing the buck converter portion of the subsystem. We're going to design all these bits as separate boards to give you experience with the process and to keep the design of each board relatively simple.

Specification and the LM3671

Since we've decided on a buck converter, we have to specify one. There are roughly 25,000+ buck converters available on DigiKey. How do we pick one?

This goes back to our specifications. For your semester project, you're going to have to specify what voltages & currents are needed by your components, what is your power source, size constraints, and so on. That will lead to a set of specifications for your power subsystem and the components on there, including any converters/regulators you want.

Here, we have several specifications:

• Converter type: buck as opposed to LDO.
• No. of outputs: 1. Some converters can make multiple different voltages.
• Input voltage: 3.5 V (for battery) to 5.2 V for USB. Here it's nice to select parts a little outside that range as well, say down to 2.7 V and up to 6 V, since those would also be fine. We do need to remember, though, that the buck isn't going to be able to output 3.3 V if the input voltage from the battery is <3.3V (it's not a buck-boost converter).
• Output voltage: fixed output of 3.3V. Some have an adjustable output, some are fixed. We know we need 3.3V, so just get a fixed one, which will require fewer external components.
• Output current: 600 mA output current. Our main power consumer is the ESP32C3. The datasheet specifies that the peak current during WiFi TX is 335 mA. We want some headroom above that, so let's pick 600 mA min (more is always better, though more $$$).
• Package: we want something surface mount (not thru-hole) that we can hand solder.
• We want something "in stock", "active" product status, and sold by DigiKey itself (so we're going to exclude Marketplace)

If you go to DigiKey and select the "Voltage Regulators - DC DC Switching Regulators" product segment, you'll see a bunch of filters show up. Basically, you want to start filtering based on your specs until you get to a reasonable list of products. Using all the filters listed above, I return 9 results. Then I either filter on "price" (cheap is good), or quantity avail (typically products with more avail are more popular, which means they're probably pretty good).

We've chosen the LM3671 from this list. But that's not enough: there are dozens of different LM3671 variants. We want the one with a fixed 3V3 output, in a SOT23 package. There are two variants of those in stock at DigiKey, so we pick the cheapest: LM3671MFX-3.3/NOPB.

Design the circuit

As opposed to the mostly digital sensor board, this board is power electronics, which are mostly analog, and often 2nd-order issues dictate performance. So we need to be more careful with the design, especially next week when we get to the layout.

Find the LM3671 datasheet online. There's lots on there, but we basically want to focus on section 8, which goes thru the design of a "typical" fixed-voltage application, which is exactly what we want. You'll see that not only the value of the L and Cs matter, but their composition and secondary characteristics. Luckily, the datasheet does recommend certain nominal values that work for typical designs such as ours.

On a piece of paper, draw out the circuit schematic. We'll want at least two output connectors (3 is even better) to provide power to a number of peripheral boards, and one input connector (providing the unregulated input voltage), along with testpoints, the passives, and at least one status LED (either on the output side or on both sides).

One thing that you'll need to sort out: how to connect that "EN" pin. That is the enable pin, and if it is low (<0.4 V), the buck will turn off. It's a great way to power off components downstream of the circuit. We won't use this functionality here, so you can tie it high to the input voltage. And put a TP on it!

Clone your repo

As with the sensor board, we'll use Git and github.mit.edu.

1. We will create a repository for you on github.mit.edu.

2. Open a terminal. Navigate to the directory (using cd) where you would like to store your PCB project. For example, that might be a directory named 6.900\psets in your home directory.

   • Windows users using WSL: Use your cdwin command that you created when setting up Git to navigate to your Windows folders. Since KiCad only has access to your Windows folders¹, you'll want to clone there.

3. Clone your repo. In your terminal, run the following command:

git clone git@github.mit.edu:6-900-S25/buckboard-None.git

The result should be a directory named buckboard-None.

If all works well, you're ready to start your design.

Schematic Capture

Fire up KiCad. Start a new project by clicking File -> New Project.

Navigate to the folder containing your repo, such as buckboard-None.

In the dialog box, type in a name for the File name. buckboard is not a bad choice.

Very important. Unselect the Create a new folder for the project checkbox, as shown below:

Hit return. KiCad will give you a warning about the selected folder not being empty. It's totally fine. Hit Yes.

Copy over the kicad.gitignore file from your sensorboard repo to this repo so we can re-use it.

Open the schematic file by clicking on the schematic editor icon.

Now add components and wire them up, same as for the sensorboard. As with the sensor board, you'll find that the LM3671 is not in the default KiCad library and you'll need to find it and add it.

There are two different voltages in this schematic, the 3V3 output, and the input, which can vary in voltage. For the 3V3 output, it's hopefully obvious which power port to use. For the input, you can use VPP, VCC, VBUS, anything like that.

For the connectors, because you're going to be connecting a power cable between this board and the sensor board (and, later on, other boards), you'll want to assign the same signals to the same connector pins (i.e., if you used pin 1 for 3V3 for the sensorboard, use pin 1 for 3V3 here).

Assigning footprints

When everything is wired up, assign footprints. For the capacitors, resistor, LED, use 0805 footprints. For the LM3671, use the footprint your acquired from the internet (which should basically be a SOT23-5 aka SOT753).

For the inductor, it has a non-standard footprint (package). The inductor we'll be using is one of the recommended ones from the datasheet, the CDRH2D14NP-2R2NC. Find that footprint online somewhere, add it to your library, and assign to the inductor.

For the connectors, use the same footprints as for the sensorboard.

ERC

Then run and make sure you pass your ERC.

Final Schematic Requirements

Before moving on, your schematic should meet the following requirements. Your schematic should have:

• 3-4 four-pin connectors.
  • 2-3 with 3V3 and GND connections.
  • One with VIN and GND connections.
• A LED (in an 0805 footprint) indicating when the board is connected providing output power. You could also have an LED on the input side if you want.
• Test points on input, output, and ground nets for debugging. A test point on the EN pin. The test points can be placed anywhere on those nets.
• Appropriately named nets for Input, GND, and 3.3V.
• Two caps and an inductor.
• All the correct footprints as noted above.

Send it on up

Now let's push all these files up to the github.mit.edu repo. It's actually good practice to go thru these steps after you make any major change to your design, not just when you are ready to do your final submission. By pushing changes along the way, you ensure you don't lose any work.

git add .

git commit -m 'a useful comment'

git push origin main

If all works well, your files should now be up on github.mit.edu. You can check on this by looking at the repo on your browser.

You can keep updating your project and pushing changes to the repo. We'll use the latest timestamp to assess lateness, so make sure your final push is before the due date!

What's next

Right after the schematic is due, we'll assign 3 people to review your schematic. We'll also assign you to review 3 student's schematics.