
## Intro

> Appreciate the ends without understanding the means.

In this jam, you'll design a small trinket. Don't know what it is yet, but discovering it will be part of the activity.

Instead of "Learn to make a hacker card" or "Learn to make a digital level", we're going to make something perfectly useless!

## Random part picker!

You're going to go to this [magical part picker site](https://component-hat-site.hackclub.dev/), 

1. **First roll the dice** get a random input, output, and power source.
2. **Come up with an idea** that combines the components into a fun useless gadget.
3. **Draw some art** to put on your board

Here's an example of what you might end up with (EXCEPT YOU'RE NOT GOING TO HAVE THIS SAME IDEA & THE SAME COMPONENTS):

Combine a **Light Sensor**, **Rumble Motor**, and **Battery** to make a rattle snake that rumbles whenever you put it in the light.

![rattleSnake](https://cloud-62nxyioni-hack-club-bot.vercel.app/0drawing__7_.png)

No one has ever sat down to learn web dev & made the next facebook. Similarly, if you sit down thinking "I'm going to make something as helpful as an iPhone", you're destined for failure...

But sit down to make some trash, and you'll end up with this treasure:

![board color](https://cloud-plhykfmfn-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_3.23.48_pm.png)

## Get In Your Workspace

Now it's the time to open up good ol' [easyeda](https://easyeda.com/)

Step 1: create an account or login with google (tapping Register in the top right corner)
![loginWithGoogle](https://cloud-8c6bzxhxx-hack-club-bot.vercel.app/0registereda.gif)

Step 2: Tap on Easy EDA Designer Open the "STD" (student) edition of EasyEDA
![STDEdition](https://cloud-8lt1ycvzx-hack-club-bot.vercel.app/0easyeda_designer.gif)

Step 3: Start A New Project
![NewProject](https://cloud-3oval3xig-hack-club-bot.vercel.app/0newproject.gif)

## Add In Your Components

Add your components to the schematic zone (the non-creative zone).

You can do this by pulling up [this component library](https://hackclub.github.io/OnBoard/site/index.html) we made and then selecting the components you drew out of the hat. 

Once you select a component
1. Get the part number from the markdown 
2. Open up EasyEDA Library (on the side bar)
3. Search for your component (tap search icon)
4. Select your component and place it anywhere on your schematic

![Light Sensor](https://cloud-lvwqcxzv9-hack-club-bot.vercel.app/0getcomponentid.gif)

Repeat this step for all 3 of your components

![your components](https://cloud-ecs518tqh-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_2.48.02_pm.png)

## Wire the components up

Look at the documentation for each component in the [component library](https://hackclub.github.io/OnBoard/site/index.html), and see how it is wired up. Follow the documentation examples to wire up your input, output, and power source.

Use R to rotate your elements and drag them around. Remember this is the NO CREATIVITY ZONE because your design will be totally moved around when you convert it to a PCB. 

![wired up](https://cloud-gsil8fuxg-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_2.48.14_pm.png)


## Convert to PCB

Save your design (control S or CMD S)

Tap Convert To PCB under Design -> "Convert To PCB"
![conver to schematic](https://cloud-g1kkox8xj-hack-club-bot.vercel.app/0converttoschematic.gif)

Rotate your components to minimize the rat lines (these subtle blue lines) crossing over each other. It's okay if it happens sometimes, but minimize the amount of times. 

![noRatsCrossing](https://cloud-3ts8mn0bw-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_2.57.23_pm.png)

Then use the Track Tool (W) to begin connecting the rat lines

![connectRats](https://cloud-q6a3ktc2y-hack-club-bot.vercel.app/0connectrats.gif)

## Getting Artistic 

Now, throw your art into the schematic! This will be on a silk layer, so it will not impact your wiring.

![Make First Pcb](https://cloud-l9r67m3n3-hack-club-bot.vercel.app/0add_in_the_art.gif)

You now need to make you art into a silk layer

![makeYellow](https://cloud-pihem7ix9-hack-club-bot.vercel.app/0silklayer.gif)

Next, move your components to make them fit your design.

![movedAround](https://cloud-d4z0ripa1-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_3.18.18_pm.png)

It's time to cut out your board! 

![cut out](https://cloud-7kaunz432-hack-club-bot.vercel.app/0outline.gif)

Now you may have some loose wires or some rat lines that are not connected yet. Connect all of your loose wires to components and fix any of the yellow xs (that means your lines are crossing in a way that will cause a problem)

![Here is a snake](https://cloud-8uy971i40-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_3.45.18_pm.png)

Boom... now you have a PCB!

![board color](https://cloud-plhykfmfn-hack-club-bot.vercel.app/0screenshot_2024-03-13_at_3.23.48_pm.png)

You should now go & order this board! 

## Ready to buy?

You can get your board made for free with Hack Club's OnBoard project.

Check out the steps for getting your board for free [here](https://onboard.hackclub.com/).

Let's build a hacky electronics gizmo -- but with a twist -- you can only use three components that you draw out of a cap! You'll learn the basics of designing a PCB, and you can get the cards made for free, with Hack Club's OnBoard.

Make Your Own Electronic Trash Out Of A Magical Hat


Reva went through this workshop & the components in a hat workshop and ended up making a custom pcb project for her club! For a bit of inspiration: check it out [the slides](https://www.canva.com/design/DAF_cqpJG9U/DPYFvBbpFErhEzrQPm4iwQ/view?utm_content=DA[…]G9U&utm_campaign=designshare&utm_medium=link&utm_source=editor).

> This workshop will take about 60 minutes to design. After that, in a seperate 60 minute session you can order your board for manufacturing using [the OnBoard grant tutorial](https://jams.hackclub.com/jam/onboard-grant).

Printed Circuit Boards - PCBs -  are in nearly all electronics, from phones to cars! It's super easy to make your own, and make them not just functional, but also you can get creative with how they look. 

In this jam, you'll design your own business card -- but with a twist -- it can transmit a URL on tap and light up! You'll learn the basics of designing a PCB, and you can get the cards made for free, with [Hack Club's $100 OnBoard grant](https://hackclub.com/onboard). With these skills, you'll be able to tackle even more complex boards, such as a custom macropad or fidget toy.

## Schematic

The first step is creating a schematic for your PCB design. A schematic shows the components that will be used in the circuit, as well as how each of these components connect to each other. An important thing to note -- a schematic is only a diagram of what connects to what, not where the components are actually placed on the board, so don't worry about placement at this stage!


First, let's open up [EasyEDA](https://easyeda.com), which is a browser-based (and free) PCB design tool. 
It can be a little bit tricky to get used to, so we made a [very short video](https://youtu.be/lEcN3JnTge4).

When you go to the website, you should see a screen like this. Click `Sign Up` to create an account, if you don't already have one.

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/8new-project.png)

Click on the `EasyEDA Designer` button in the Navbar to open up the schematic editor. 

Once you've logged in, select `File` > `New` > `Project` to create a new project.
![](https://cloud-qega55fyl-hack-club-bot.vercel.app/8new-project.png)

This will open up the schematic editor. Some important parts:

- `Library` on the left toolbar: This is where we will search for components and place them into our schematic.
- `Wiring Tools` panel: We'll be using the wire tool to connect the components together.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/3schematic.png)

## Placing components into the schematic

For our card, we'll want a capacitor, a resistor, a 2V LED and a NFC chip:

- A [NT3H2111W0FHKH](https://jlcpcb.com/partdetail/NxpSemicon-NT3H2111W0FHKH/C710403) NFC Chip: this will be the main component of our card -- it both handles the NFC functionality as well as harvests energy from the phone to light up the LED
- An ~2V LED. I'm using [C2296](https://jlcpcb.com/partdetail/Hubei_KentoElec-17_21SUYCTR8/C2296), but feel free to pick a different color (note: this part may also be called 17-21SUYC/TR8)
- A [47Ω resistor](https://jlcpcb.com/partdetail/23909-0603WAF470JT5E/C23182)
- A [220nF capacitor](https://jlcpcb.com/partdetail/21832-CL10B224KA8NNNC/C21120)

Click the `Library` button to open the parts picker. Search for a part (the part number works best), and make sure `JLCPCB Assembled` is selected. This will make sure we're choosing parts from JLCPCB's parts library, as this is currently Hack Club's Onboard PCB manufacturer. 

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/4searching-for-parts.png)

Select the part, then hit the `Place` button to add it to your schematic. Repeat for all 4 of the parts listed above.

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/9parts-on-schematic.png)

> Note: The EasyEDA parts library may not always be helpful when finding parts for your own future projects, so feel free to search the internet for parts and their codes. You can also create your own parts, but that's a bit more advanced.

### Adding the antenna

The NFC chip needs an antenna to work. We'll be using a PCB trace (a line of copper in the board) as the antenna, so we'll need to add that to our schematic.

Note: this is not an actual part, so it doesn't need to be assembled onto the board -- it's formed by the copper traces on the PCB.

To add the antenna, search for `25X48MM_NFC_ANTENNA` in the Library, and instead of `JLCPCB Assembled`, select `User Contributed`. Select one of the options (check the preview to make sure it looks similar to the one I used here, but most of them should work), and place it on your schematic.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/5selecting-antenna.png)

## Wiring up the components

Now that all of our components are placed, let's connect them together! Make sure to save your work (command-s or control-s) as you go along.

The `Wire` tool indicates an electrical connection between the different parts -- this is similar to how you would connect wires on a breadboard. On the actual PCB, copper traces will go where we added wires, to form those electrical connections.

We'll reference the NFC Chip's Datasheet (yes, that obscure, horrifyingly detailed document), specifically [this explanation](https://www.nxp.com/docs/en/data-sheet/NT3H2111_2211.pdf#page=38) for creating an energy harvesting circuit.

The datasheet says

> A complete total connected capacitor in the range of typically 150 nF up to 220 nF
> maximum shall be connected between VOUT and GND

So we'll connect the capacitor between `VOUT` and GND (the `VSS` pin).

<video src="https://cloud-bfxdnmxrd-hack-club-bot.vercel.app/1wire-tool.mp4" controls="controls" style={{ maxWidth: "480px" }}></video>

- The pins `LA` and `LB` are for the antenna, so we'll wire up the antenna between those two pins.
- > If NTAG I2C also powers the I2C bus, then VCC must be connected to VOUT

  Since the NFC chip will use the power transmitted from the phone to power the chip itself, we'll connect `VCC` to `VOUT`.

- Finally, to complete the circuit and light up the LED, we'll connect the LED and resistor between `VOUT` and GND (the `VSS` pin).

Your schematic should look something like this when completed:

> Note that your schematic may look a bit different from mine -- that's okay! As long as the connections are the same, it should work. So feel free to experiment with different layouts, maybe keep the antenna on the right or change the position of LEDs and resistors? It's up to you!

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/3completed-schematic.png)

> Friendly reminder to save (`command + s` or `control + s`) your work! You can also click `Project` > `Save Project` to save your schematic. 

# Designing the PCB

Now that the schematic is complete, we can start designing the actual PCB. In this step, we'll place the components onto the board, in the exact shape and configuration that the final board will be. The schematic is our guide to how to connect the components together.

## Converting the schematic to a PCB

To convert the schematic into a PCB design file, click `Design` > `Convert Schematic to PCB`. You may get a warning about unfinished nets -- this is fine, just click "No, Keep Going."

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/5convert-schematic-to-pcb.png)

This will open up the PCB editor, as well as a popup window to specify the board's dimensions. (If the popup window doesn't show up for any reason, you can find it through `Tools` > `Set Board Outline`.)

Here are the dimensions I'll be using, but feel free to make your business card a different size! Bonus: try making your business card a custom shape (not circular or rectangular). You should have the tools to do that by the end of the jam.

- Board Outline: Round Rectangular
- Width: 88.9mm
- Height: 50.8mm
- Radius: 4mm

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/6set-board-outline.png)

## Functionality: Making a working PCB card

Once you set the board outline, you should see something like the image below. There's the outline of the board in pink, a bunch of components in red, and some thin blue lines connecting the components. Let's talk about what these are, and what the colors mean!

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/0pcb-editor.png)

### Layers

A PCB like a sandwich -- it's made up of many different layers. We're designing a 2-layer PCB, which has the following layers:

- The **substrate** is in the middle. This makes up the foundation of the PCB, and is usually made of FR-4 (fiberglass).
- On either side of the substrate are **copper layers** (since this is a 2-layer PCB, there are 2 copper layers: one on top and one on the bottom). In our PCB designer, these are indicated by the `TopLayer` (red) and `BottomLayer` (blue) layers. The copper layers are where electrical connections happen! You should place **traces** (lines that form electrical connections between components) on the `TopLayer` and `BottomLayer`.
- On top of the copper layers are **soldermask** layers. This is what gives PCBs their color -- common soldermask colors are green or black, but white, purple, blue, red, yellow, and more are also possible. Soldermask is added to the entire surface of the board (both the top and the bottom) by default. If you want to **remove** the soldermask (which will reveal the copper underneath), use the `TopSolderMaskLayer` or `BottomSolderMaskLayer` (for the top and bottom of the board, respectively).
- On top of the soldermask layers are **silkscreen** layers. Silkscreen is usually white, and is generally used to label and identify components, but we'll be using it for ✨ PCB art ✨. We can use this to add contact info, a QR code, or even some illustrations to our business card. In EasyEDA, silkscreen is added on the `TopSilkLayer` and `BottomSilkLayer`.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/1pcb-layers.png)

### Components

You'll notice that the PCB designer already has your components populated on the board. By converting the schematic to a PCB design, EasyEDA automatically places the **footprints** of the components on the board. Try dragging these around! You're able to place them anywhere, but keep in mind that they must be placed within the pink board outline. This is exactly how the components will be placed on the final board.

Some helpful tips:

- You can hit the `R` key to rotate a component 90 degrees.
- The thin blue lines indicate where electrical connections need to be made; so try to rotate components so that the lines do not cross
- Don't worry if the yellow marks cross (that's just silkscreen), but the red parts should not be touching! (That's the copper layer, and if they touch, it will cause a short circuit.)

Drag the components around until you're happy with the placement. Here's what mine looks like, but don't copy it directly; almost anything will work!

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/4components-placed.png)

### Routing traces

Now, we have a bunch of components on the card. If we were to have the card manufactured right now, it wouldn't work -- the components are not connected to each other! We need to add **traces** to connect the components together.

It's best practice to manually route your traces, using the first button in the PCB tools panel: the `Track` tool.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/2pcb-tools.png)

However, to speed up the jam a bit, we'll be using EasyEDA's auto-router. Select `Route` > `Auto Route...` and click `Run` to watch the magic happen...

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/0auto-router.png)

...Except, it seems like the magical autorouter 🪄 wasn't 100% successful :(. We'll finish up the last bit with some manual routing.

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/1autorouter-results.png)

In my case, the autorouter was able to connect most of the components, but there's still one thin blue line (representing an unrouted connection). Can you find it?

Zooooming in, we see that it's between the antenna loop and pin #8 on the NFC chip. Here's how to route it:

1. Click the `Track` tool in the PCB Tools panel
2. On the right sidebar, set `Routing Conflict` to `Ignore`. This step is generally not needed (for normal manual routing), but there's a small issue with the footprints that makes it necessary here.
3. Click between the two pads that need to be connected. The thin blue line should disappear, and a red trace should connect the two pads.

<video src="https://cloud-bfxdnmxrd-hack-club-bot.vercel.app/0manual-routing.mp4" controls="controls" style={{ maxWidth: "480px" }}></video>

Now, your PCB card is functional. Woooo! 🎉

_WARNING: Make sure your design has no short circuits_
<Dropdown title="Hey, what's a short circuit and how can I prevent it?">  
           Short circuits is a circuits that allow current to travel along an unintended path. 

          Heres a simple example:
          ![](https://cloud-m5qt0nitx-hack-club-bot.vercel.app/0image.png)
          In this circuit, the path of least resistance is the path in red. It flows through the led and the battery, thus the LED will light up

          However, in this circuit:
          ![](https://cloud-abtjpv714-hack-club-bot.vercel.app/0image.png)
          The wires cross paths and make a new path of least resistance, that does not go through the LED. This causes the led to not light up.
        
</Dropdown>
 <Dropdown title="We don't want that! How can I see if I have a short circuit?">  
          The first thing to check for is if you have any traces(wires) that intersect or overlap, such as these 2 examples
          ![](https://cloud-5hfwliwe8-hack-club-bot.vercel.app/0image.png) ![](https://cloud-2hhbo4z62-hack-club-bot.vercel.app/0image.png)
          If you don't see any of these, you should be fine. However, if you want to be extra careful, do a Design Rule Check, by going to Design -> Check DRC
          
          Most of the errors are not actual issues, but if you click through them and find something that unsure of, consider asking around on the #Onboard channel on slack.
</Dropdown>
<Dropdown title="I have a short circuit! How do I get rid of it?">  
  You should check to see if there is a different path the wire could take so it doesn't intersect, kind of like the battery and led example from above. If this is not   possible, then don't worry. This is why our board as multiple layers!

The PCB below has many shorts
![](https://cloud-nggsler3h-hack-club-bot.vercel.app/0image.png)
The solution is to move the wire from the top layer to the bottom layer!
First, select the wire you want to move
![](https://cloud-grp5qt7qm-hack-club-bot.vercel.app/0image.png)
Next, in the top right, select TopLayer, and change it to BottomLayer
![](https://cloud-ny3wmd3c4-hack-club-bot.vercel.app/0image.png)
The wire should turn blue, or another color.

The last step is to change the pads to multilayer. First select the area where the wire and component intersect
![](https://cloud-hzdm59xgm-hack-club-bot.vercel.app/0image.png)

Select top layer, and change it to multilayer
![](https://cloud-k7tdushgc-hack-club-bot.vercel.app/0image.png)

Finnally, repeat for the other pad. 

</Dropdown>

Remember to save your progress! We can check out a preview by clicking the `3D` button in the top toolbar. Hmmm... doesn't look like a business card yet. Let's add some personality to it!

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/2card-preview.png)

## Aesthetics: Personalizing your card

We'll mostly be using the silkscreen layer to add our information and designs. Select the `TopSilkLayer` by clicking the yellow rectangle in the Layers and Objects panel. This will make sure that you're on the silkscreen layer.

### Adding text

In the PCB Tools panel, select the `Text` tool. If you want to make it a business card, you can add your name and contact info -- or add any other text you want. Select the text object you just placed, and change the font, line width, and size in the right sidebar.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/8text-properties.png)

Drag the text to where you want it on your board. Here, I've added my name, website, and GitHub. If you need ideas: you can add your email, phone number, or other social media handles.

![](https://cloud-lagxcclbp-hack-club-bot.vercel.app/7text-added.png)

### Adding a QR Code

EasyEDA also supports importing images! I'll use this to add a QR Code that links to my website. I used [QRCode Monkey](https://www.qrcode-monkey.com) to generate a QR Code, then use the `File` > `Import` > `Image` option to import it.

Just like Text objects, you can select the image to modify the properties (width, height, etc.) on the right sidebar.

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/6import-image.png)

Note: we've been placing everything on the yellow `TopSilkLayer`. This means that they will all appear on the top side of our board. If you want to add anything to the bottom, use the green `BottomSilkLayer`! Keep in mind that the bottom layers of the board are a top-down, see through view, which is essentially flipped -- use the 3D viewer to check that all your text and images are oriented correctly.

### Bonus: Textures and other effects

Thus far, we've only used silkscreen to add designs and text to our board. The silkscreen will show up white on the manufactured board, but it's also possible to achieve a variety of other effects by combining different layers!

Here are some examples -- try incorporating these techniques into your board.

- **White silkscreen**: this is what we've been using. Add things to the `TopSilkLayer` or `BottomSilkLayer` to achieve this effect.
- **Shiny silver or gold** (depends on the finish selected when ordering): add your object to both the `TopLayer` and `TopSolderMaskLayer` (for the top of the board), or to both `BottomLayer` and `BottomSolderMaskLayer` (for the bottom of the board), and superimpose these layers on top of each other. The `TopLayer` or `BottomLayer` will put the shiny copper on your object, while the `TopSolderMaskLayer` or `BottomSolderMaskLayer` will **remove** the soldermask on the object, revealing the shiny copper underneath.
- **Textured, or with slight color variation**: add your object to only the `TopLayer` or `BottomLayer`. Without removing the soldermask, the copper will still be covered by the soldermask, but it may slightly lighten the soldermask color and will create a textured feel.
- **Translucent yellow** (color of the FR-4 material): add our object to only the `TopSolderMaskLayer` or `BottomSolderMaskLayer`. This will remove the soldermask on the object, revealing the yellow FR-4 material underneath. This technique is useful for allowing LEDs to shine from one side of the board to the other, or just for adding another color to your design.

![](https://cloud-qega55fyl-hack-club-bot.vercel.app/7layer-effects.png)

## Turn your design... into an actual card!

Now that you've got an amazing design, you can actually get your card manufactured and have it in your hands in a few weeks!

Hack Club's [OnBoard grant](https://hackclub.com/onboard/) gives high schoolers $100 to manufacture their own PCB designs, and you can use it to get your own card manufactured.

> If you're in a club or afterschool group that meets for an hour you're probably reaching the end of your meeting around now. Next meeting you can get started with [the OnBoard grant tutorial](https://jams.hackclub.com/jam/onboard-grant) to order your board for manufacturing.


Let's build a business card -- but with a twist -- it can transmit a URL on tap and light up! You'll learn the basics of designing a PCB, and you can get the cards made for free, with Hack Club's OnBoard.

Make your own PCB Hacker Card

Ever wondered how your phone knows when you tilt it? What makes an Arduino tick? With this jam, you'll level up your circuit skills by building your own Arduino-compatible level PCB! You can use it to measure angles, decorate your room, or do anything you can with an Arduino!


Let's design an Arduino Nano-compatible microcontroller board using KiCAD!

If you follow through these 4 jams, your finished SparkleTilt will look something like this - but with your very own design customizations!

![](https://cloud-izep2lpej-hack-club-bot.vercel.app/031picture.jpg)


<details>

<summary>Video Demo</summary>

<iframe width="560" height="315" rel="0" src="https://www.youtube-nocookie.com/embed/px2V8bZMeLI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
</details>

## Prerequisites

If you are not already familiar with the basics of using an ECAD tool like EasyEDA or KiCAD, check out another jam like [the PCB Hacker card](../../../jam/hacker-card). The rest of this workshop will assume you know how to draw a schematic from pictures.

{/* Ideally a better version of this video will be made by a Hack Clubber, but this is the best basic video we have now */}
[This YouTube video](https://www.youtube.com/watch?v=EPH23zhPg50) demonstrates the basics of navigating around KiCAD.

In addition, the rest of the workshop assumes you know basic electronics terms like:
1. Resistor: A resistor limits the electric current that flows through a circuit. Resistance is the restriction of current.
2. Capacitor: A capacitor stores charge, and thus energy. It's like a tiny battery that charges and discharges very quickly.
3. Diode: A diode only allows current to flow in one direction. It also drops a little bit of voltage, turning that energy into heat.
2. Microcontroller: A microcontroller (aka MCU) is a system on a chip that contains an integrated processor, memory, and input/output peripherals, which are used to interact with other electronic components.

## Part Selection

Step 0 of designing a board is to clearly define what problem you need the board to solve. Here, we are making a nice looking level. The primary goal is to demonstrate electronics and PCB concepts. A secondary goal is to have an attractive and fun level.

Step 1 of designing a board is selecting your core components:

1. Microcontroller: ATmega328P. The ATmega series is the most robust and common 8-bit MCUs, being used in many Arduinos since the beginning. Additionally, it requires very few external components and runs over a wide range of voltages (1.8V-5.5V). It's also one of the very few microcontrollers that is a *Basic Part* on JLCPCB. And, it's available in a QFP package so it can be hand-soldered. It doesn't have many fancy features, but it's simple and robust.

2. USB-Serial Interface: CH340N. Because the ATmega328P doesn't have a built-in USB interface, we need a USB-UART IC. The CH340C worked well for @Hugo[^1], and it's very cheap, so I'm using the CH340N. The CH340N is the cheapest IC from the CH340 series that has an integrated clock, meaning fewer components are needed.

3. Pinout: While not technically a component, we will follow the standard Arduino Nano pinout. This really doesn't matter— unless you value your future self's sanity when trying to wire up new components.

Now on to the actual circuit.
Make sure you have KiCAD downloaded, then set up a new project, and open the schematic editor.

## Core (Microcontroller)

First, we place the heart of our system, the ATmega328P-AU, in a TQFP package [Search: ATmega328P-A]. This is NOT the ATmega328PB, which is not backward compatible with the ATmega328P.

### Power

![](https://cloud-j48wmzjac-hack-club-bot.vercel.app/21.webp)

Then, we need to connect the power pins to power *nets* and place *decoupling capacitors*.

**Nets**: Nets like VCC and GND serve as abstractions for actual connections in our schematic. If we connected every single chip to a central VCC and GND point in our schematic, it would be very messy. These symbols tell the PCB Designer that we need to connect those pins while keeping the schematic clean.

**Decoupling Capacitors**: AKA Bypass Capacitors. A decoupling capacitor is placed very close to the chip that needs or supplies power. When a chip suddenly demands power, it provides it while the battery and other components ramp up, essentially like a dam controls a river. When there are voltage spikes or noise, it absorbs them, while letting normal DC power pass along. So, these have to be as physically close to their parent IC as possible in the PCB layout (in Part 2).

In the KiCAD parts list, search `C` and after placing it change the *value* field to the correct number and units, 100nF in this case.

Your *reference designator* numbers for C may be different from the image (C1 and C2). VCC and GND are also parts that can be imported like any other parts. And feel free to delete the labels on GND to reduce clutter.

### Clock

![](https://cloud-j48wmzjac-hack-club-bot.vercel.app/32.webp)
The datasheet for our crystal, C13738, shows that pins 2 and 4 are connected to ground [Search: Crystal_GND24].

Now that our MCU is powered, it needs a clock to tick to[^3]. We can configure the ATmega328P to use this 16MHz crystal rather than run at its default of 1MHz.

This crystal needs an accompanying capacitor connected to ground on each pin. 

<details>

<summary>How did I come up with the value of these capacitors?</summary>

```
C = 2 * CL - CS
```
Here, C is the capacitor we need, CL is the load capacitance specified by the crystal manufacturer, and CS is the stray capacitance of the microcontroller pin. In our case CL (of the crystal) is 9pF and CS (of XTAL1/2) is 6pF (as specified by the datasheet).

So, we use 12pF capacitors.
</details>

[^3]: Yes, while the ATmega328P does have an internal clock, it's kinda inaccurate and could cause issues with serial communications. The simple and safe choice is to use an external crystal which are typically accurate to 20 parts per million, a opposed to the 5% (5 parts per hundred) of the ATmega's intenal clock.

### Reset
![](https://cloud-j48wmzjac-hack-club-bot.vercel.app/43.webp)

The bar on top of RESET means that it is active low, GND (0V) will reset the MCU and it should be at VCC (5V) during normal operation. The SPST button here is JLCPCB's basic push button which connects RESET to ground when pressed [Search: SW_SPST]. 

The resistor R6 [Search: R] is a pull-up resistor, a high-resistance resistor that gently pulls the RESET pin HIGH without passing too much current through it. This allows the switch to pull the RESET pin down without causing a short circuit, while preventing random noise from pulling RESET down.

Labeling this wire as RESET connects it to the RESET *net*. If we place another RESET label somewhere else on this page, our ECAD tool will understand that these two points have to be connected, just like the GND and VCC nets. Press "L" to activate the label tool.


### Label Pinout

![image](https://cloud-j48wmzjac-hack-club-bot.vercel.app/54.webp)

After this, we need labels telling us which MCU pin is which Arduino Nano pin.

These are global labels. Unlike the RESET label, these work on all pages of the schematic. You can press "CTRL+L" to create a gloabl label.

## Headers

![](https://cloud-nbfq15yho-hack-club-bot.vercel.app/15.png)

First, we have the traditional Arduino Nano pinout [Search: Arduino_Nano_v3] connected to our labels, telling the ECAD software we want these headers connected to the prespecified microcontroller pins. Since this whole board is running at 5V, just mark 3V3 as NC (No Connect).

We also have the ICSP header [Search: Conn_02x03_Odd_Even], which is used for flashing the Arduino's bootloader. It has all the SPI pins in one neat package, MISO, MOSI, SCK, RESET, VCC, GND.

Once you have a label, you can press 'x' to flip it horizontally.

## USB

We start with the 16 Pin USB 2.0 Type C receptacle, C165948.

![image](https://cloud-mu5k1d6dk-hack-club-bot.vercel.app/1usb.png)

NC: SBU1/2 and Shield/Shell (shield is only for hosts).

GND goes to our ground net.

Mark VBUS with a net, and then run it through a diode [Search: D] to the VCC net, which powers everything else on this board. 

Since we will be powering a bunch of LEDs, I picked a big diode JLCPCB had as a basic part, C35722. Set the *value* field to the part number so you can find it later. This diode prevents current from going back into your computer if both USB and 5V pins are plugged in.

Then, to tell the USB-C port that we are drawing power from it, CC1 and CC2 have to each be connected through separate 5.1k resistors to ground[^4]. That tells the USB-C power adapter that we can draw up to 5V 3A.

You can download the KiCAD CH340N footprint here: [ch340n.kicad_sym](https://cloud-b6v3rkn29-hack-club-bot.vercel.app/0ch340n.kicad_sym). Then, put it in your project folder and add it to your symbol library in Preferences > Manage Symbol Libraries > Project Specific Libraries.

![](https://cloud-j48wmzjac-hack-club-bot.vercel.app/87.1.webp)
![](https://cloud-j48wmzjac-hack-club-bot.vercel.app/97.2.webp)

![image](https://cloud-mu5k1d6dk-hack-club-bot.vercel.app/0ch.png)

Now, we can connect our UART chip, the CH340N. Both D+ and D- from the USB-C connector go to D+/- on the CH340N. As specified in its datasheet, both V3 and VCC get 100nF decoupling capacitors. RTS goes to RESET through another 100nF capacitor; this capacitor makes the RESET pin briefly pulse low instead of staying low forever (avoiding bootlooping the MCU).

RXD and TXD (USB directionality), are connected to their microcontroller pins D1 (MCU's TX) and D0 (MCU's RX) respectively with some status LEDs [Search: LED, Value: GREEN/YELLOW].

[^4]: 5k1 is just a concise and clear EE way of saying 5.1k. The units are context dependent, so here it means kilo - ohms.

## Done!

Now you have a simple Arduino Nano-compatible board schematic! Check out Part 2 to turn this into a PCB, or jump to Part 3 to add more features to this board[^2].

![](https://cloud-mu5k1d6dk-hack-club-bot.vercel.app/201full-kicad.svg)

{/* footnotes */}

[^1]: Thanks to Hugo Hu for his instructable, this schematic is based on that design: https://www.instructables.com/ATmega328P-Corgi-Arduino/

[^2]: **WARNING**: You will need another microcontroller board to flash the bootloader on this ATmega328P before you can program this board. Ask in Slack if you have ANY questions about this.


Design an Arduino Nano-compatible microcontroller board in KiCAD

Microcontroller Circuit Design

Turn a microcontroller schematic into a real PCB layout

Turn a KiCAD Schematic into a PCB

Add useful sensors, chargers, and lights to your dev board

Adding Peripherals


In this jam, we will take a KiCAD PCB and order it through JLCPCB with assembly[^2].

If you're just jumping in, make sure you have your [DRC checked](./part-2#Design%20Rules%20Checker) from Part 2 of this jam series.


Here are some component notes[^3]:
- The grant allows you to purchase anything from one of the allowed suppliers, including JLCPCB.
- One of JLCPCB's sister/partner companies, LCSC, stocks virtually every generic component you'd ever need, and all of them can be assembled.
- Keep in mind that JLCPCB charges a $3 fee for every "extended component" type that they assemble.
- You will not be able to get specialized components from Adafruit or similar companies through the grant.
- A complete library of JLCPCB/LCSC components is available at [jlcpcb.com/parts](https://jlcpcb.com/parts).
- If following the ATMega328P workshop, you will need an Arduino, FTDI board, or any other AVR programmer to flash the bootloader before you can use the board's USB port. Verify what you need for your chip. ESP32s and RP2040s typically work out of the box.

## Install the Extension

Click on Plugin Manager on the KiCAD home page.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/111.webp)

Search for 'JLC'.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/122.webp)

Install 'Fabrication Toolkit' and apply changes.


## Assign Part Numbers

Open your schematic. Go to Bulk Edit fields.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/135.webp)

In the Field Editor window, click on 'Add Field' and add the field `LCSC`. It doesn't matter whether you have `Sim.*` or `Datasheet` fields or not.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/146.webp)

Then, search for your components at [jlcpcb.com/parts](https://jlcpcb.com/parts) and fill in the LCSC id.

For generic components, search for the Value and Footprint - `100nF 0805` - and check basic parts. You'll see a couple of different voltages, pick the lower (cheaper) one since we are only at 5V.

You don't *have* to necessarily specify the part number for generic components like 0805 resistors or capacitors, but I prefer to manually select it rather than leave it up to JLCPCB to decide.

The LCSC Part number (aka JLCPCB Part #) looks like `Cxxxx`.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/157.webp)

For more specific components, like the Atmega328P-AU, you should only have a couple of options and just pick the most popular one (Basic Part if possible).

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/168.webp)


Try doing this yourself before you look at my version below.

<details>

<summary>This is what your table should look like, and then Apply and Save.</summary>

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/179.webp)

Because A1 and J2 aren't real components - we only need their footprint and pin layout, not the component itself - they don't need an LCSC part number.
</details>
  
## Export files

Now, go back to the PCB view and sync it.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/110.webp)

Then, click on Tools > External Plugins > Fabrication Toolkit.


![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/211.webp)

Everything you need to order your board will now be in `your_kicad_project/production/`.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/312.webp)

Now, log in to [jlcpcb.com](https://jlcpcb.com). Go to [cart.jlcpcb.com/quote](https://cart.jlcpcb.com/quote) and upload `gerber.zip` into "Add Gerber file".

You should see something like this:
![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/413.webp)

Tips:
- 5 is the minimum number of PCBs you can order.
- You can change your shipping option on the right 'Shipping Estimate' sidebar.
- Sometimes, reducing the PCB thickness from 1.6 to ~1.0 will reduce the weight of the package, and thus the shipping price without increasing manufacturing price.
- If your PCB will be handled a lot consider selecting 'LeadFree HASL' for its surface; excessive exposure to lead can be toxic.

Leave the 'High-spec options' at their defaults, and then, enable assembly. 
- You can choose to only assemble 2 boards out of 5, in which case the other 3 bare boards will be shipped to you. If you only want one PCB, this can save money on parts.
- You can only assemble one side in Economic PCB assembly.
- Standard PCB assembly with both sides is very expensive  (~$65) and will use up most of your grant money. Try to design PCBs that have components on one side and don't use any 'Standard Only' components. Or, solder the other side by hand.


![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/514.webp)
Then, on the Bill of Materials page, upload bom.csv and positions.csv from your production folder. 

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/716.webp)

- You can save a lot of money on Extended Parts in the long run (if you plan on making many PCBs) by buying them directly and soldering them yourself [^1]. For example, basically every project has a USB-C connector and header pins, so it makes sense to buy a bunch yourself and avoid the $3 extended part fee every time you buy a board from JLCPCB.
- Virtual Components (only used for their through holes) like the Arduino Nano and ICSP header can be ignored.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/817.webp)
When it prompts you about unselected parts, just click 'Do not place'.

Zoom into your components on the 'Component Placements' screen and rotate them to the correct orientation if they're wrong.

If you get all parts assembled, this board (from part 2)[^4] ends up being around $33.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/918.webp)

With shipping, that's $45 for me.

![](https://cloud-9ctvo6cbs-hack-club-bot.vercel.app/1019.webp)

[^1]: You might want to edit the footprints of components you are hand-soldering. For example, to hand solder the USB-C connector, make the pads longer and remove unused ones like SBUS.
[^2]: There are a million different ways to export your files and order with different manufacturers, but for simplicity, this jam only focuses on one.
[^3]: by [@camdan.me](https://hackclub.slack.com/team/U04J96SRS5B)
[^4]: This is just the microcontroller board from parts 1 and 2. It does not include any of the peripherals such as th LEDs and accelerometer.

Learn how to convert a board design into an actual order

Ordering a KiCAD board from JLCPCB

SparkleTilt: Design a Digital Level PCB

Ever have a keyboard, mouse, and more to plug in but only one free USB port to use? You probably fixed it with a USB hub– but how do they work? In this jam you'll build your own from scratch.


_Want to just see the result? See the [Schematic](https://cloud-1we5i4we0-hack-club-bot.vercel.app/1schematic_schematic-usb-hub-2-port-jam_2023-08-10.pdf) and the [EasyEDA source](https://cloud-1we5i4we0-hack-club-bot.vercel.app/0sch_schematic-usb-hub-2-port-jam_2023-08-10.json)._

# Putting the "scheme" in schematic

![](https://cloud-j8bxr01tm-hack-club-bot.vercel.app/1usb_hub_needed.png)

_Has this ever happened to you? You really need a USB hub!_

Today we're going to make a USB splitter. It'll have 1 USB-A on one side, and 2 USB-A ports on the other side. It can transmit power as well as data.

We're starting with a schematic. They're like the blueprint for a PCB. It's a good way to figure out what's connected to what before you actually lay out the parts on your board.

![](https://cloud-6d6aarot8-hack-club-bot.vercel.app/0schematic_to_pcb.png)

> Schematics correspond to the parts of your PCB.

## Start a new project

Go to [EasyEDA](https://easyeda.com/editor) and create a new project (File > New > Project...). Name it `usb-hub`.

## Add the parts

For our design, we're going to need a USB-A connector that plugs into our computer. Click the `Libraries` button on the left toolbar, and search for `usb-a`.

![](https://cloud-mjv8qcmxc-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_12.12.42.png)

A bunch of options will show up with options like price, stock, and mounting type. You won't understand all the options yet & <b>that's ok</b>! I ended up using part number [`C404965`](https://www.lcsc.com/product-detail/USB-Connectors_SHOU-HAN-AM90_C404965.html). Once you select it, click the `Place` button to add the part to our project.

![](https://cloud-b1al1d09c-hack-club-bot.vercel.app/00screenshot_2023-08-08_at_12.20.04.png)

Yeah! You did it. Now let's add the other parts we'll need!

We'll need another USB-A connector, but this time a female connector for the devices we charge / plug in. Do another search for `usb-a`, but this time I used part number [`C46407`](https://www.lcsc.com/product-detail/USB-Connectors_Jing-Extension-of-the-Electronic-Co-903-131A1011D10100_C46407.html). This time, place 2 of them on the board.

Next up we need a main board to connect everything together. There are a bunch out there, but I ended up using the CoreChips SL2.1A with part number [`C192893`](https://www.lcsc.com/product-detail/USB-ICs_CoreChips-SL2-1A_C192893.html).

Now that we've got a great big pile of parts in our sandbox, the next step is to connect them together!

## Connect it together

We've got a whole list of parts to hook up now. Let's start with the USB-A male connector to the CoreChips SL2.1A. But what do we need to wire together?

<h2>~~*Connect it together*~~ <ins>Read the spec</ins>!</h2>
<div style={{display: "none"}}>
## Read the spec!
</div>

Let's find the spec for the CoreChips SL2.1A. A spec is kinda like a README for a part. Every part has one, and it's a great place to start when you're trying to figure out how to use a part.

Go to [lcsc.com](https://lcsc.com) and search for `C192893`. Click on the part and scroll down to the `Datasheet` section. Click on the link to download the datasheet.

_Just in case, [here's a link to the spec sheet for the SL2.1A](https://cloud-fa5e1sjdd-hack-club-bot.vercel.app/01811151645_corechips-sl2-1a_c192893.pdf)._

Now let's open it up and just start reading through the table of contents to find where <i>whoops</i> wait it's all in Chinese.

![](https://cloud-961a0s7fx-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_19.05.22.png)

That's fine! Many specs are in other languages and guessing/translating is part of the skill! The important part is in here, the list of pins and what they do. It looks like this:

![](https://cloud-h587v4g5f-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_12.37.30.png)

Printed Circuit Board (PCB) part-makers really like to use acronymns, which are the same in every language! We can use the acronymns to figure out what the pins do. Here's a list of the ones we'll need:

- VDD5: 5V power (also called VCC or VBUS)
- GND: ground
- DP: data positive (also called D+)
- DM: data negative (also called D-)

Great, now we know what we need to do on the chip side, let's find the spec for the USB-A!

The part I chose also had a spec in chinese, but it's a common part so I found [this by googling "USB-A pinout spec"](https://components101.com/connectors/usb-type-a-male-connector). It's a bit different than our pin numbers, but the names are the same. The only difference is that our ports HM1 & HM2 are also `GND` ports. You don't need to know why right now, but for the curious, google "grounded USB shield".

## Connect it together, for real this time!

Move the parts around so they're facing eachother (you can rotate them with the `R` key), the go ahead and connect `GND` on the usb to `GND` on the chip.

![](https://cloud-ntdzh89kj-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_12.48.41.png)

Now you can connect `VCC` on the usb to `VDD5` on the chip. They aren't labelled the same thing, but `VCC` just means a voltage source, and USB-A is a 5V source.

Next up, connect `D+` on the usb to `DP` on the chip, and `D-` on the usb to `DM` on the chip.

![](https://cloud-72qwemi78-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_12.54.13.png)

Hmmmm, this is looking a little like a bowl of spaghetti. Let's clean it up with nets!

![](https://cloud-j8bxr01tm-hack-club-bot.vercel.app/2spaghetti.png)

### Nets

Nets are a way to group together wires that are connected to eachother. They're a great way to make your schematic look cleaner and easier to read. Go ahead and remove the VCC & GND lines, then choose the GND net from the toolbar on the right.

![](https://cloud-m5x117vsl-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_12.56.40.png)

Connect the GND net to the GND pins on the USB-A and the CoreChips SL2.1A. See how clean that new wiring is?

![](https://cloud-7pzslk6qe-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_13.04.24.png)

Nets are kinda like portals– you can connect them from a distance as a way to keep from crossing your wires on your schematic. They're also good or connecting lots of things together– we're going to need to wire a lot of things to `GND` in a sec, and nets are a great way to do that.

Keep in mind though with nets, there are a lot of ways to write things. All the following are a way to say PIN 4 and PIN 5 are connected to `GND`:

![](https://cloud-d47mlqyh7-hack-club-bot.vercel.app/0gnd_net_types.png)

To prevent mistakes, try to keep your nets looking like mine for this tutorial, but in general everyone has their own style and that's ok.

![](https://cloud-j8bxr01tm-hack-club-bot.vercel.app/0gnd_nets.png)

## Ground the Shield

Go ahead and connect MH1 & MH2 to GND also. These aren't really ports- they're just the parts where the metal cover of the USB sticks into the board. We'll connect them to ground in case there's any static electricity.

![](https://cloud-7u8ahczmz-hack-club-bot.vercel.app/0screenshot_2023-10-11_at_13.27.24.png)

![](https://cloud-1vlpmdjo8-hack-club-bot.vercel.app/0screenshot_2023-10-11_at_13.30.41.png)

## Add the other USBs

Next up let's connect the other USB-A connectors!

I'll position my USB-A female ports and hook them up to the main chip's `DP` and `DM` pins. `DP1` goes to USB-1's `D+`. After getting the data lines wired, we'll connect the power using nets!

On these USBs, ports 5 & 6 are the same as ports MH1 & MH2. They're just the metal shield, so we'll connect them to `GND` as well.

![](https://cloud-6cwv1d324-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_15.16.16.png)

_Remember, with nets you can connect from a distance!_

## Power surges

The design is almost complete, and in a perfect world it would work just fine. But we aren't in a perfect world- we live in a world with static electricty and power surges. We'll need to now protect our circuit. If we don't, we could fry our hub or even our computer's USB port!

Knowing where these protective components go can be an art and hotly debated on many stackoverflow forms. Fortunately, the spec sheets we're using contain some example circuits for us to use. Let's take a look at the CoreChips SL2.1A spec sheet again:

![](https://cloud-a1u1u3jnb-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.32.45.png)

_This is a little hard to see, so we'll go through it step by step. For now, just know we're getting the following instructions from reading this image & adapting it a little for our own design._

First up we'll add a diode to protect from a surge coming _from the laptop_. That's a case where the laptop sends too much power and goes beyond the 5V we want. The Schottky (pronounced "shot-key") diode with part number [`C48192`](https://www.lcsc.com/product-detail/Schottky-Barrier-Diodes-SBD_onsemi-NSR0320MW2T1G_C48192.html) is perfect or this. Let's drop it in right after we take on the 5V power from the USB-A male.

_Diodes ensure power flows in 1 direction. We don't want an accidental spike to flow back into our laptop! This Schottky diode will also slightly resist the flow of electricity, which is good for protecting against power surges._

Now let's protect from power surges that make it past the diode. We'll use a capacitor for this– it's kinda like a resevior for power. It can store up power and then release it when it's needed. If there's a power fluctuation, this capacitor will let the extra power blead out to `GND` harmlessly. We'll use a 10uF capacitor with part number [`C19702`](https://www.lcsc.com/product-detail/Multilayer-Ceramic-Capacitors-MLCC-SMD-SMT_Samsung-Electro-Mechanics-CL10A106KP8NNNC_C19702.html). Let's drop it in right after the diode, and connect it to `GND`.

![](https://cloud-e0ekzo8gw-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.37.55.png)

_When using a capacitor to prevent overflows like this it's called a ["decoupling capacitor"](https://components101.com/articles/decoupling-capacitor-vs-bypass-capacitors-working-and-applications). I'll admit I don't 100% understand why, but this won't short 5V to GND._

Go ahead and use the same capacitors to protect the other USB-A ports. You can copy & paste the components, and then move them into place.

![](https://cloud-lr6vmvrrj-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.44.21.png)

## Unused ports

The SL2.1A chip we're using supports up to 4 USB ports, but we're making a smaller board for the tutorial so we won't be using the ports for "3" or "4". Go ahead and use the "no connection" tool to show in the schematic that these pins aren't being used.

_Making a 4-port USB hub is left as a challenge for you to do if you want to!_

![](https://cloud-4sab6gwqz-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.51.45.png)

All finished should have pins connected to some label or wire, even if it's just a "no connection" symbol. Your PCB will error if you try to send it to the manufacturer with any pins unlabeled.

![](https://cloud-me27qfpwb-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.51.54.png)

Next up are pins `VDD33` and `VDD18`. Sometimes components will have these to provide lower voltages for their internal circuitry. We don't need to worry about them for this design, but the spec shows that we need to bleed off the power to `GND` using another 10uF capacitor.

![](https://cloud-p9cf2w5jg-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_17.58.13.png)

Lastly, our chip provides clock circuitry through `XIN` and `XOUT` for advanced use if we wanted to overclock our USB ports. We aren't trying to do that, so we'll opt-out of it by connecting `XIN` to `GND` and marking `XOUT` as disconnected.

![](https://cloud-np517gxwl-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_18.02.06.png)

Now, let's check if all the pins are connected. Try converting the schematic to a PCB. If you see a warning pop up that means a net is missing or not connected. ![](https://cloud-dmskkj3bl-hack-club-bot.vercel.app/0screenshot_2023-08-08_at_18.36.08.png)

## Finished!

If all the schematic is connected you've done it!

![](https://cloud-4dr6xa7qz-hack-club-bot.vercel.app/0yay.gif)

   <Announcement
            copy="Now make your board"
            caption="Take your board and build a working USB hub."
            href="/batch/usb-hub/part-2"
            iconLeft="enter"
            color="primary"
          />

Now let's move into the PCB editor to make our board.

Get started making your schematic for your very own USB hub! Even if you're a beginner, you'll walk out of this jam with your very own schematic.


Get familiar with PCBs + Make a blueprint!


_If you haven't built a schematic yet, do so in [part 1](/usb-hub/part-1). Just in case you can start with the [Schematic](https://cloud-1we5i4we0-hack-club-bot.vercel.app/1schematic_schematic-usb-hub-2-port-jam_2023-08-10.pdf) and the [EasyEDA source](https://cloud-1we5i4we0-hack-club-bot.vercel.app/0sch_schematic-usb-hub-2-port-jam_2023-08-10.json) we're starting with. Want to see the final result of this project? Here's a link to the final [EasyEDA Design](https://example.com)_

# Building the board!

Now that we have our schematic, let's turn it into a board!

Our starting schematic should look like this: ![](https://cloud-dtcbpm4i4-hack-club-bot.vercel.app/2screenshot_2023-08-11_at_12.52.40.png)

This is what we're going to make: ![](https://cloud-dtcbpm4i4-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.11.34.png)

Once it's ordered, it'll look like this: ![](https://cloud-dtcbpm4i4-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_13.11.20.png)

## Step 1: Convert the schematic to a board

Click "Design > Convert to PCB" in the top right corner of EasyEDA. This will open up the board editor.

![](https://cloud-6cbfcd1xm-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.15.22.png)

Next, confirm all the settings are exactly the same as– JK! these settings don't matter, just hit "apply" and move on:

![](https://cloud-8ie7yt1k6-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.14.34.png)

We'll be confronted with our parts laying out in the editor kinda like when we started out with the schematic. We'll need to move them around to make them fit on the board.

![](https://cloud-8ie7yt1k6-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_13.14.44.png)

## Step 2: Move the parts around

We want our parts to be generally close to what they should be connected to before connecting everything all together. This will make it easier to route the traces (fancy phrase for "wire it all up") later.

We've got a handy little tool to help us figure out our positions though! Rat lines! These are the little blue lines that connect the pins of our parts together. We can use these to figure out where to put our parts.

_This is generated from our schematic, and is why we built our schematic first! If one of the blue lines ends up looking wrong it's usually because we're missing something in our schematics._

I moved the parts around a bit and ended up with this. A few things still overlap, but for the most part the lines have a clear route:

![](https://cloud-5c3t0a3re-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.20.04.png)

_Keep in mind you might need to rotate your parts. Go ahead and do it with the "R" key. You can also rotate by degrees in the "Rotation" field on the right toolbar._

## Step 3: Route the traces (wire up the dots)

Next up comes the fun part! Let's wire up our parts. This is more of an art than a science, but I recommend a couple tips:

- Do `GND` last. It's very important, but the easiest to do.
- You don't have to finish everything in one go. It usually takes a couple passes to get everything right & you'll end up with a better design if you don't force it all in one go.
- Don't be afraid to move your parts around if you need to.

First I'll select the "Track" tool on the toolbar:

![](https://cloud-ikeoztttt-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_13.26.54.png)

I'm starting with the +5V trace in this example:

![](https://cloud-ikeoztttt-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.27.39.png)

Lastly, this wire is a little thin for us, so let's <b>embiggen</b> it. Too small and the wire might burn out, but too big and it's hard to fit all your wires. There are a whole set of tables online that you can use to figure out the right width, but I usually just go with 0.8mm for my traces at +5V.

![](https://cloud-ikeoztttt-hack-club-bot.vercel.app/2screenshot_2023-08-11_at_13.27.10.png)

![](https://cloud-2dgv2s40z-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.31.56.png)

_Technically, you can add an extra "c" to "thicc" for every 0.4mm of width._

Take your time and route the traces you can. Here's how far I got after a couple passes:

![](https://cloud-l9gg41b78-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.38.20.png)

Notice that the +5V traces are still ratlined. I couldn't connect them without overlapping other traces, so I've left them unrouted for now. There's also part of the `GND` line that isn't connected yet.

## Step 4: Oh, how the turn tables!

Now we need more space to route our stuff! Let's break out our superpower– the other side of the board!

![](https://cloud-559tio290-hack-club-bot.vercel.app/0ezgif.com-video-to-gif_1_.gif)

That's right- the other side of the board can have a trace too! Some boards are pancaked together and have 4, 6, even 16 layers of traces! We're not going to be that fancy with this though– we can get away with just 2 layers for this project. Good for simplicity and keeping our costs down.

Let's use this tool to route the `D-` (for some reason showing up as `U3_9` in my screenshot) pin for the USB-A male.

![](https://cloud-2421gzzt3-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.48.30.png)

Add some traces to get the `U3_9` line as close as it can without overlapping anything.

![](https://cloud-p4gld99aq-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.50.20.png)

Switch to the "Via" tool and click the tip of the traces to add them to the tips. A "Via" is just a fancy way to say we're poking a whole through the board to the other side that's coated in copper so the current travels through it.

![](https://cloud-loxykkofo-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.50.39.png)

![](https://cloud-cbdjno25j-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.51.55.png)

To switch to the other side of the board, click the "edit" icon next to "BottomLayer" on the layer toolbar. It should look like a pencil

![](https://cloud-n59r7hpq4-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_13.46.16.png)

Now we can route our traces on the bottom layer. Go ahead and connect the 2 vias we just made:

![](https://cloud-8juvc3e6w-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_13.56.55.png)

Nice! Now the ratline has disappeared- that means we're all done with those pins!

Try doing the rest of them on your own before continuing. Or don't... I'm just text on a website, I can't stop you from scrolling down to see the finished version.

![](https://cloud-isdsylawg-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_14.00.12.png)
![](https://cloud-isdsylawg-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_14.00.24.png)

_I had to add some more traces on the "TopLayer" to get all my "BackLayer" pins to connect._

## Step 5: Cut that out!

Next up we'll need to cut out our board and give it a shape! We'll use the "BoardOutline" layer to do this. Weirdly enough, we'll still be using the route tool like before.

![](https://cloud-pxqhij3q1-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_14.02.31.png)

_You might already have a pink rectangle lying around from when you first imported your board from your schematic. Go ahead and delete that, we're making our own outline. A better outline!_

![](https://cloud-dmke8w78v-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_14.06.12.png)

I made my trace look like this, but yours can look different! Just make sure that it's a closed shape and has enough padding around the edges that we don't trim of anything important. Sometimes the cutting machine will be a little off, so it's good to have a little extra space on the sides.

Also, don't forget to even out your corners!

![](https://cloud-dmke8w78v-hack-club-bot.vercel.app/0ezgif.com-video-to-gif_2_.gif)

Now that we have the borders cut out, let's see the results! Click "View > 3D View" in the top toolbar.

![](https://cloud-kcfrggbze-hack-club-bot.vercel.app/0screenshot_2023-08-11_at_14.10.51.png)

![](https://cloud-kcfrggbze-hack-club-bot.vercel.app/1screenshot_2023-08-11_at_14.11.06.png)

Done! That's it. You don't have to go home, but you can't stay here.

Use a schematic to start building your own USB hub!


Start jamming out on "pcb" projects ⚡️

Here are some great multi-part jams to kickoff your club this fall 🍂

Make Your Own Electronic Trash Out Of A Magical Hat

Make your own PCB Hacker Card

SparkleTilt: Design a Digital Level PCB

Build a USB Hub