Creating A PCB In Everything: KiCad, Part 2

This is the continuation of a series where I create a PCB in every software suite imaginable. Last week, I took a look at KiCad, made the schematic representation for a component, and made a schematic for the standard reference PCB I’ve been using for these tutorials. Now it’s time to take that schematic, assign footprints to parts, and design a circuit board.

The completed schematic for our board
The completed schematic for our board

All PCB design tools have different methods of associating the schematic view of a component with how it will be represented on the finished board. Eagle uses libraries that contain both a schematic view and PCB view of a component. In the prehistory of PCB design software, Autotrax simply ignored the schematic view.

Click this button to run PCBnew
Click this button to run PCBnew

KiCad has a clear separation between a symbol (the schematic view) and a footprint (the PCB view). If we were to take our schematic and create a new PCB by running PCBnew, nothing would happen – our symbols aren’t associated with any footprints.

Click this button to run CvPCB
Click this button to run CvPCB

To associate symbols with footprints, we need to run CvPCB. This sub-program tucked inside KiCad gives us the ability to associate footprints with our schematic symbols.

CvPCB, with another window open allowing you to view the footprints

It’s like the cloud, only not complete shit

CvPCB is a new feature for KiCad 4.0. Instead of every other PCB design tool we’ve taken a look at so far, KiCad effectively stores all of the footprints in Github. In the Github repo for KiCad, you’ll find a bunch of files with a .pretty file name. These are the footprints for nearly every component you can imagine. If you’re running a fresh install of KiCad, everything shows up in CvPCB automagically – there’s nothing you need to worry about, and footprints just happen.

There’s a subtle brilliance about this implementation. It’s like the cloud, only it’s completely verifiable, and if a part doesn’t work, you can fix it and submit a pull request. Already, this is phenomenally better than the Eagle paradigm, where millions of footprints are available in thousands of different libraries scattered around the Internet. If you’re reading through this series in order, take note: this ‘Github as the cloud’ will be a major point of comparison when we get to other cloud-based PCB design tools.

viewfootprintWith that said, we need to associate footprints with the symbols on our schematic. To do that, go down the list in the center of the CvPCB window that contains a list of all the components in our schematic and associate a footprint with each part. Footprints are on the right, libraries (or categories) are on the left. To view the selected footprint in a new window, click the ‘view selected footprint’ button.

Selecting a footprint for the USB port

Getting Libraries In Order

The footprint editor window The footprint editor, found in the launcher

This project is using (mostly) all through-hole parts, and as such, I could easily select a DIP8 footprint for the ATtiny85 and be done with the whole thing. This is a tutorial, though, and I need to demonstrate how to make a part – schematic and PCB view – from scratch.

To make a footprint, KiCad offers a Footprint Editor. This can be accessed from either PCBnew or the launcher. Click on that, select File -> New Footprint, enter a name for this footprint (‘ATtiny85’ will do), the name of the footprint and a reference designator is placed onto the footprint editing window.

selectfplbLibraries are important, and since KiCad is now running on ‘not-shit cloud technology’, we have to create a library for this project that won’t be saved along with our copies of the standard Github libraries. Select File -> Save Footprint In New Library, save this library wherever the rest of the files are for this project, and give the library a name.

We have just created a new library, but that doesn’t mean KiCad knows what library we’re working with. In the Footprint Editor, select Preferences -> Footprint Libraries Manager, and click on the ‘Project Specific Libraries’ tab. Hit the ‘Append Library’ button, and drop the path to the library we just created in the ‘Library Path’ field. That’s more KiCad weirdness, but once we’re done we can finally create a footprint.


Making The Footprint

Now that we have the Footprint Editor open, a part name and a reference for the footprint, and the library all set up, it’s time to actually put some pads down. There are a few relevant buttons on the screen:

Add a pad Add a line Add an arc Add a circle

The most important, obviously, is the ‘Add a pad’ button. Click that and drop some pads down where they should be. This is a standard DIP8, or two rows of four pins 0.3″ apart. The default grid, as you may have noticed, is 50mils.

padproperties footprintdone

After placing the pads, use the hotkey ‘E’ to edit the properties of each pad. Here, you can change a through-hole part to an SMD, change the dimensions of the pad, hole, and shape of everything. Importantly, the Pad Properties window allows you to change the number of the pad. The number of the pad is how KiCad connects the schematic representation of a part with the footprint. Get this right, or else nothing will work.

Add a few lines to the footprint, save your work in the project library, and go back to the schematic. You’re done. That’s how you make a footprint.

From Schematic To Board

Now that the schematic has footprints associated to everything, it’s time to open up PCBnew, move parts around, and put some traces between parts. Do that. Oh, nothing shows up. Why is that? You need to generate a netlist in the schematic view, and import it in PCBnew. There’s a button with ‘NET’ written on it in both programs. Click those. Now, what do we get when the netlist is successfully imported into PCBnew? The worst mess you’ve ever seen in any sort of design program:

This is fine.
I desperately want to see someone import a netlist for a large project in KiCad.

movemodeWe end up with a gigantic mess on our hands. No worries, ‘M’ is the hotkey to move the parts around. You can also use the ‘Move Footprint’ mode to automagically place these parts. Reference the PCB we designed for the introduction to this series and move some parts around until we get something resembling the board below. The relevant hokeys are ‘M’ for move and ‘R’ for rotate. As always, there’s the ‘?’ hotkey that tells you everything you need to know.


That’s close, but it looks horrible. Deselect Footprint mode, use your cursor, and move all those labels and references around. We don’t need “CONN-01×04” on the board, and it’s really helpful to have the values of resistors inside their own footprint. With a little bit of work and deleting those labels, you’ll have something that looks like this:


Holy crap, that actually looks like something. All the resistors and diodes are labeled with their value, all the superfluous references are gone, and this actually looks good. You can’t do this in Eagle easily.

layersWith the layout pretty much figured out, it’s time to finally draw some traces. This requires a description of the layers.

  • F.Cu and B.Cu are the top and bottom copper layers. The hotkeys for these layers are PgUp and PgDn
  • Edge.Cuts is the equivalent of the ‘Milling’ layer in Eagle. This is the outline of your board.
  • F.SilkS and B.SilkS is the silkscreen – the text and outlines of your components.
  • F.Mask and B.Mask is the soldermask. It’s usually green, or purple from OSHPark.
  • F.Adhes and B.Adhes is glue applied to SMD components.
  • F.Paste and B.Paste is where solder paste will be applied.

For a simple board that won’t be sent off to an assembly house, the only layers you need to worry about are the copper layers, the Edge.Cuts, and the silkscreen.

The first thing to do to complete the board is to draw the ‘edge’ or milling layer. Select the ‘Add a graphic line’ button on the right hand toolbar, and draw a rectangle around all our parts. That’s simple enough.

Now it’s time to actually put some traces down. You can select which copper layer to use in the top toolbar, and the relevant hotkey is ‘X’. Hit ‘X’, click on a few airwires, and route them just like the reference PCB. Don’t worry about power or ground traces – we’re going to do those with copper fills. When you’re done, you should have something like this:


filledzoneThat’s pretty much all there is to it, save for the copper fills. To do that, we need to add a ‘filled zone’ or ‘copper pour’ or a ‘polygon’. By any other name, it’s just a big area of copper that is connected to a single net in the schematic.

Click on the ‘Add filled zones’ button, and a ‘Copper Zone Properties’ window will show up. Here, you can assign a layer of copper to a specific signal. Our board puts +5V on the back copper, and GND on the front copper. In the Copper Zone Properties, select the B.Cu layer, the +5V net, hit Ok, and trace around the edge of the board. Do the same with the F.Cu layer and the GND net. When those fills become hatches around the edges of the board, hit the ‘B’ hotkey to render the copper fills.

layout4 copperzoneprop

That’s it. We are technically done. If you save and drag the .kicad_pcb file onto the OSHPark web page you’ll get a pretty purple PCB in a week or two. That’s not to say this PCB actually works – I screwed up the USB signals in the schematic, and that propagated over to the PCB. No matter, because no one is actually going to build one of these boards.

This just about concludes the ‘Creating A PCB in Everything’ tutorial for KiCad. If you’ve been reading along for the last five thousand words, you have an excellent introduction to KiCad, and should at least be able to build a breakout board. This doesn’t mean I’m done with KiCad quite yet – there are a few more tricks to go over including DRC and ERC, a demo of how freakin’ awesome the routing in KiCad is, and I need to put a keepout on the decoupling cap in on the board, anyway. Creating a PCB in Everything: KiCad Part 3 (the optional part) will be out sometime next week.

Thoughts on KiCad

This series of posts serves two purposes. First, it is a quick tutorial for various PCB design tools. After reading these posts, you should be able to guess your way through a PCB design tool and build a simple PCB. Second, each of these tutorials serves as a pseudo-review of each PCB design tool. Each of these posts serves to illuminate the quirks of a PCB design tool, and serves as a notice that I still have an unclaimed bounty for the first person to create a part for an ATtiny85 from scratch in Fritzing. Don’t use Fritzing, it sucks.

Coming from Eagle, KiCad is downright weird. That’s not to say it’s difficult, though – it’s generally the same as any other PCB design tool. The interface, like nearly every Open Source project, is obtuse, and there are five non-obvious ways to complete any task. There is zero reason why parts imported from a netlist into a board are squished together. Custom libraries can and should be automatically imported. The KiCad community especially rancorous. The UI suffers from an intangible wrongness about it, although that seems to lessen after working with it for a few hours. In a sense, KiCad is exactly what you would expect from an Open Source project that is decades old, very mature, and has features packed to the gills: it’s very powerful, but not friendly to the beginner.

Although the KiCad beginner will struggle to wrap their heads around the interface, it will be one of the most powerful PCB design tools I’ll use in this series of posts. No other free (beer) program will give you 32 copper layers and unlimited routing space. Nothing else uses the cloud/GitHub like KiCad. It’s brilliant.

A few months ago, if someone asked me to suggest a PCB design tool, I’d give Eagle or KiCad as suggestions. Eagle is easy enough to learn, and will be getting better since the Autodesk acquisition. KiCad is robust, and even in the best case of Eagle development, Autodesk may only ever reach parity with what KiCad can do.

Now, KiCad is growing on me. I have a secret project where I need to build and manufacture a thousand relatively complex boards. My previous go-to was Eagle, but I think I’m going to do this board in KiCad.

Filed under: Hackaday Columns, how-to, Skills

G-code controlled drawing plotter

pics-DrawingPlotter -600

A how-to on making a 2 axis, G-code controlled drawing plotter from TheSuperSewcio, project instructables here:

Here I’ll show you how to make 2 axis, gcode controlled drawing plotter.
I’ve already made a delta 3D printer which is awesome, the only thing that wasn’t made by me was the Arduino program. This program was very long and complicated, so I’ve downloaded it from the Internet. I’ve started to think if I am able to also make it myself. But why should I start with something so hard, firstly let’s make something easier – Plotter!

Check out the video after the break.


How to run your ESP8266 for years on a battery


Here’s a detailed article on how to run an ESP8266 for a long time on a battery by Marco Schwartz:

For most of the projects I am building with the ESP8266 WiFi chip, I usually don’t care too much about the power consumption aspect. I for example build data loggers that are constantly connected to the mains electricity, and appliances controller which also have an easy access to power. However, in some cases, we want to build projects that are only powered by batteries. This is for example the case for a motion sensor that you will install in your home, or a data logger you would put in a remote location.

More info at Open Home Automation.

Life on Contract: How to Fail at Contracting Regardless of Skill

I believe higher quality learning happens from sharing failure than from sharing stories of success. If you have set your mind to living on contract, I present this cheat sheet of some of the most simple and effective ways to muck it all up that have surprisingly little or nothing to do with your technical skill, knowledge, or even deliverables.

The previous installment of Life on Contract discussed how one might find clients as an engineering contractor or consultant while also taking a bit of time to pull apart the idea of whether life on contract is appropriate as opposed to, for example, bootstrapping a business instead. Assuming you are set on working as a contractor, let’s talk about what happens after you have found a prospective client (or perhaps more likely: after they have found you.)

WARNING: this article features an utter lack of success tips and tricks. Partly because those can be found in any seminar or business self-help book, but mostly because I do not have a foolproof recipe for success, and cheat codes to unlock easy mode still elude me. But I have witnessed (or committed) and reflected on many excellent ways to fail at contracting; or at the very least succeed in not being invited back.

Just because I won’t be sharing success stories doesn’t mean success has no learning value. Got a success story, or a better way to fail? Tell us about it in the comments!

How to Fail (or at Least Not be Invited Back)

The kind of contracting or consulting I’m discussing is mainly about solving problems. Put another way, I have found that successful contracting is mostly about taking problems away, and making your client’s life easier. They should see you as money well spent.

Failing at contracting is all about making life harder for your client. Barring actual negligence or incompetence, there are plenty of ways this can happen.

Talk the Client Out of Wanting You

Clients will have problems, and one or two of them will happen to be ones they want you to solve; that’s why they are seeking expert help. Their problem may be specific — “we need someone to convert these from through-hole to surface mount” — or it may be something broader — “we’ve been making these in our garage but need to make them faster and cheaper, how do we do that?”. There’s always a clear need, even if the client is having trouble articulating it.

quote-not-helping-communication-causes-failureThe simplest and most efficient way to fail is to nip the whole contract in the bud. A client decides against hiring you when they don’t see you as an added value. The reasons for failing in this way (again, barring negligence or incompetence) always come down to a tragic failure to communicate. You may genuinely fail to understand the client’s needs, you may fail to communicate to them that you do understand, or you may otherwise fail to present yourself as a viable solution to any of their problems.

Let’s examine some excellent and common ways to make a client decide against hiring you:

  • Don’t speak the client’s language. You don’t know their terms and don’t understand anything about their industry. If they are a print shop, you have no idea how print shops operate or do business. If they are artists, you speak only in engineering terms and jargon. Being unable to relate makes clients feel that they are out of their depth, or that you’re just from a different and less-compatible world. It ensures that explaining things always takes maximum effort, and a client is never really certain you’re actually on the same page. Avoid this by studying the client’s industry and terminology.
  • You aren’t on the same wavelength. If a client is focused on wanting to understand how to best do a small in-house production run versus offloading it to a contract manufacturer, then focusing on specific yet irrelevant details like the finer points of injection molding, or KiCad vs Eagle, can lead to failure. You’re on the same topic, but not at all in tune to what they actually want to do or know. Avoid this by taking time to ensure you understand what advice the client is actually seeking, even if they haven’t asked for it in the most direct way.
  • Be a Magic 8-Ball whose only answer to every question is “it depends.” If you can’t provide direct answers to most questions, then regardless of how correct your waffling is you’re probably not understanding what the client needs from you. In all likelihood, what your prospective client actually needs is an understanding of a situation or process they are facing. Put another way, they don’t need exact numbers and you’re not being asked to commit to a deadline; they’re asking because they need to understand what has to happen and when, so they can budget and plan. You are being asked because they want someone who has been-there-done-that to “get” what they are doing and be a guide. Waiting patiently while prospective clients ask you question after question (to which every answer is some form of “it depends”) is an excellent way to talk a client out of contracting you, because it makes it clear you won’t be making their problem or uncertainty go away.

The best thing about these methods of failure is that they don’t require all that much effort. In fact, simple inattention or inaction is most of what’s needed. So long as you’re not actively trying to help communication in an initial meeting, things have an excellent chance of going wrong all on their own.

Give the Client Second Thoughts After You Get the Contract

An engineering contractor is not normally involved in a client’s day-to-day business operations; at least, not in the kind of contracting and consulting we’re talking about. Your work and the expectations from you — both explicit and implicit — are different from those of an employee. Failing to meet those expectations is the key to making your client wonder if contracting you was a mistake.

For example, let’s say a client has a product and you have been hired to optimize the board layouts and reduce PCB costs. Showing up on the first day with open hands and an open heart, brightly asking “Okay! Where do you want me to start?” is a great way to make your client think twice about hiring you as an expert; someone who was supposed to know more than they did themselves.

In addition to whatever you were officially hired for, you need to be money well spent. If you are not actively solving or removing problems in some way, then you are probably not clearly adding value. You may even be making your client’s life harder instead of easier.

It may remain unsaid, but as a contractor or consultant you are at least partly being hired for your judgment. The less effectively you wield your judgment, the more your client will start to think you were a mistake. Here are some great ways to ensure that happens.

  • Constantly halt what you’re doing with “how do you want me to…” questions for your client. The more this happens, the more likely you are to plant second thoughts in the mind of the client. Asking this for what seems like every conceivable detail, and at every possible fork in the road and failing to gather information you need up front will raise red flags. It’s bad form to be seeking approval and direction for issues you should be able to handle yourself if you actually understood the client’s needs and problem scope. This behavior makes sure that the problems stay front and center, and very much still on the client’s plate. As a bonus, you will almost certainly appear to be “winging it” instead of having experience and a plan.
  • Be overly focused on details unrelated to your client’s actual needs. If your client thinks you’re focused on irrelevant details, they won’t see that your work has any value. If the details in question actually are relevant (but perhaps not obviously so) then you must ensure your client understands the relevance. You may be extremely knowledgeable, but that doesn’t mean you can’t spend the first weeks of a contract installing and minutely benchmarking every possible different database backend to find out which one yields marginally better performance, only to find out that your client isn’t actually willing to change database software and (shocker!) frankly doesn’t see how a marginal improvement could possibly be worth all that effort when they just wanted you to integrate a live stock count into their e-commerce site.
  • Be unable to actually get something done. Having a poor sense of proportion can hobble your measurable progress. If firmware on a given microcontroller architecture is 90% working, throwing it all out to begin again the instant a newer and faster part comes out is a great way to fail. There is such a thing as smart people who are unable to get a job done. In the business world where everything is a trade-off because everything costs in one way or another, clients are well aware that there is “good” and there is “good enough.” Does a solution do the job? Can it be achieved within the budget and time allowed, without painting you into an unacceptable corner? If so, then that’s Good Enough. Smart, knowledgeable people who can crank out high-quality work quickly may still never actually get anything done because they constantly take off like a heat-seeking missile after the latest and greatest, or obsess over details irrelevant to making something work.

Have you managed to get a job done despite all that? Don’t worry, there’s still a chance to fail!

Make Sure You Don’t Get Invited Back

Life on Contract: How to Find Clients as an Engineering Contractor matched my own experience, particularly in the observation that a good portion of your work will come from referrals. That means that if you really want to make a go of life on contract, leaving a client feeling like you didn’t really add value is a really great way to snatch failure from the jaws of success.

quote-work-that-nobody-knows-happenedIf your client doesn’t feel that you were worth the money, or that you were just too hard to work with, you won’t be invited back — either to more work, or to conversations that begin with “who can we talk to about…”

Here are ways to tarnish the shine of a completed project:

  • You didn’t do things when you agreed they would be done. Failing to keep deadlines or to report on your progress is a great way to get ejected from a client’s contact list. If your estimates and progress reporting become known for not being reliable, even if your work is of outstanding quality, you may simply be judged Too Hard To Work With. As covered in Life On Contract: Estimating Project Time, estimates are important for planning and budgeting both time and money. Making sure yours aren’t reliable is a great way to cause cascading disruption in other people’s work every time it happens.
  • You didn’t take (or make) time to polish the results of your work. Finishing touches on something go a long way to communicating value and the work that went into it. Whether it’s software or hardware, you may know it inside out by the time you’re done but most people won’t be seeing it as a raw expression of function. Leave your work looking like a hack job, and you’ll be thought of as one.
  • Let the value you added go unnoticed. There is a somewhat cynical saying about work that no one knows was done: it might as well not have happened. As a contractor there will always be some pressure to show you were worth what you charged. You may be making tremendous progress and adding excellent value, but if your client is unaware of any of it, they won’t know you were responsible for that value. Modesty may be a virtue, but also another way to fail at getting called back.

All of this type of behavior will ensure that if you find a client, they won’t hire you. If they do, they’ll regret it. And if your contract completes, they won’t want you back. Since a good chunk of work will come from people knowing you as “the person who knows about that stuff and can get it done”, falling into these bad habits will virtually guarantee you are free from clients.

These are of course from my own observations in both the working and hiring ends of contracting, but they are still only my own narrow slice of a wide and varied field. Have you got your own success or failure stories to add or admit to? You know you do; share them in the comments.

Filed under: Business, Featured

Creating A PCB In Everything: KiCad, Part 1

This is the continuation of a series of articles demonstrating how to Create A PCB In Everything. In this series, we take a standard reference circuit and PCB layout — a simple ATtiny85 board — and build it with different PCB design tools. Already, we’ve taken a look at the pre-history of PCB design with Protel Autotrax, we learned Fritzing is a joke for PCB design, and we’ve done a deep dive into Eagle. Each of these tutorials serves two purposes. First, it is a very quick introduction to each PCB design tool. Second, this series provides an overall comparison between different PCB design tools.

Now, finally, and after many complaints, it’s time for the tutorial everyone has been waiting for. It’s time for KiCad.

No, like the head of the Bajoran clergy

Although KiCad (pronounced ‘Kai-Cad’ like the head of the Bajoran clergy, not ‘Key-Cad’ like the thing that goes in a lock) is the new hotness when it comes to PCB design. The amazing growth of KiCad installations over the past few years is a long time coming. In development since 1992, KiCad has cemented itself as the premier Open Source PCB design suite, and since 2013 CERN has been making contributions to the project. More recently, the KiCad project has been showing off some amazing new features. These include 3D rendering of boards, interactive routing, push-and-shove, simulation, and dozens of other features that put it on a path to being on par with the top of the line EDA suites. Add in some great community contributions, and you have something really, really amazing. All of this is wrapped up in an Open Source license, free as in speech and beer. If you’re looking for the future of PCB design, Eagle is going to get very good but KiCad is almost there now while being Open Source.

The KiCad Overview

As I said in the introduction to this series of posts, this tutorial will be broken down into three main parts. The first will be how to create a part — specifically a DIP8 ATtiny85 — as a schematic symbol and how to create the schematic we need. The second part of this KiCad tutorial will assign footprints to our symbols and turn the schematic into a board you can send off to a fab house. Finally, we’ll take a look at the cool features of KiCad, such as push and shove routing and 3D rendering.

For this part of the KiCad tutorial, we will only concern ourselves with making a part for a DIP8 ATtiny85. Download KiCad and let’s get started.

Your first view of KiCad
Your first view of KiCad

Just like Eagle – and every other PCB design tool, for that matter – there are several different editors in KiCad. They are:


Eeschema – the schematic editor


schlibraryedThe Schematic library editor – used for editing part libraries


pcbnewPcbnew – the ‘board’ editor


pcbfootThe PCB footprint editor – used for editing footprints (the physical package) of parts


An introduction to the terminology of PCB design might be in order. A schematic is the abstract design file, showing the electrical connections between all the components in your circuit. The schematic is not sent to the fab house.

PCB or board describes the layout of the components, holes, pads, traces, connections, mechanical design, and silkscreen. Designing a board is the end game of all PCB design work, and it is this file that gets sent off to a fab house for manufacturing.

The schematic for our project The board we will eventually build in KiCad. This board was made in Eagle.

Before we put together a schematic and design a board, we must learn how to build our own parts. To start, install KiCad, select File -> New Project, and name it ‘Nanite’, or ‘Some Trash I’ll Never Do’

Making A Part

All of these tutorials demand making a part from scratch. Right now, that means making a part and footprint for a DIP8 ATtiny85. From the main KiCad window, open up the Part Library Editor, and you have a window that looks like this:


When you first open the Part Library Editor, no libraries are loaded. You would think it would be possible to simply create a new library, and design some parts, but KiCad is weird. To make your own library in KiCad, you must first select an existing library and save it as your own. Yes, it’s a bit weird and one of the many oddities of the KiCad UX, but at least it’s better than Fritzing.

createanewcompSave this library you just ‘created’, select File -> Current Library, and select the library you just saved. Now we can begin to make a part.

Click the ‘Create a new component’ opamp icon, and you’re presented with a window asking you to name your part. For small, simple, jellybean components, you won’t have to bother with anything except for the name. Name your part ATtiny85 and click okay. The name and designator of the part will be dropped into the window. Now we’re ready to add pins to our part.



Oh God Everything Is Backwards And My Mouse Doesn’t Do Anything


hotkeysIf you’re following along with this tutorial, this is the first time you’ll actually use the KiCad interface. KiCad has a reputation for being incomprehensible for the beginner. Want some proof of that? Click on the ‘ATtiny85’ label and try to move it. You would think just clicking it would do something, but that only opens up some options (bold, italic, size, justification) for the text. If the ‘ATtiny85’ and ‘U?’ overlap, clicking on both of them opens up a dialog box.

There’s a reason for this: KiCad, like almost every other PCB design tool, is based on hotkeys. This is the reason KiCad gets the reputation for not being user-friendly, but there’s a solution: just type a question mark. The list of hotkeys will pop up, and now you’ll always know what keys you need to hit to do what you want to do. To move the ‘ATtiny85’ and ‘U?’ label off to the side, hit ‘M’ while hovering the mouse over each label.

pinsNow it’s time to add pins. Click the ‘Add pins to Component’ button on the right side of the window. Next, click anywhere on the Part Library Editor window.


The Pin Properties window is where you assign a name, number, and graphical style to all of the pins in the schematic representation of your part. We’re doing a very simple part with power and ground on one side, and all the IO on the other side. As long as the pin names are correct, and all the pins correspond to the correct numbers on the footprint, you shouldn’t have much trouble. The only thing that might trip you up is the orientation of the pins; here, the circle at the end of each pin designates where the pin connects to a net on the schematic.

Drop eight pins down and make your part look something like what we made in the Eagle tutorial. You’ll end up with something like this:



With the pins dropped into the window and correctly labeled, all we need to do to finish the part is to draw a rectangle. Click on the ‘draw a rectangle’ icon, click once in the corner, drag, and click again to finish the rectangle. Hit File -> Save Current Library, and we’re done making the schematic symbol for this part.

From Symbol To Schematic

Now that we have a symbol for the ATtiny85 we’re going to use in this board, it’s time to make a schematic. From the main KiCad window, open up the Electronic Schematic Editor, and you’ll be presented with the following window:


Again, the hotkeys are going to kill you. To add a component, press ‘A’. You might also want to hit ‘?’ and bring up the list of hotkeys.

At this stage, we’re not concerned with footprints, or the physical dimensions of the components we’re eventually going to place on the board. All we want are symbols. There are hundreds of different varieties of USB connectors, but right now we don’t care. All we need to do is drop a few resistors, diodes, connectors, and other parts onto the schematic. To do that, press ‘A’, and the window below will pop up.



Since we’re directly copying the reference schematic from the introduction to this series, we need the following components:

  • Two 1×4 connectors
  • Two Zener diodes
  • Four resistors
  • One LED
  • One USB port (OTG)
  • One unpolarized cap
  • One ATtiny85
  • A smattering of +5V and GND symbols

For each of those components, press ‘A’ to add a part, search for the part, and drop it onto the schematic. If you’re really good, you can use the ‘P’ hotkey to add power and ground parts. When you’re done, you should have something that looks like this:

That looks about right

The important hotkeys to know are ‘A’ to add a part, ‘M’ to move a part, and now ‘W’ to add a wire between parts. Again, pressing ‘?’ displays a list of hotkeys. Of special interest is the ‘K’ hotkey to stop drawing a wire.

thingpcbschWith all the wires drawn, it’s time to label these wires to connect them into ‘nets’ Check out the reference schematic to the right. The wires coming off the USB/Zener/resistor chunk of the schematic are labeled ‘PB4’ and ‘PB3’. These are nets connected to the PB4 and PB3 pins on the ATtiny, and are used for USB communications. The 1×4 headers are connected directly to every pin on the ATtiny, so we label them accordingly.

To label these wires and turn them into nets, use the ‘L’ hotkey, and select a name for each of your nets. Drop this label over the open connection on each wire to turn them into nets. When you’re done, you’ll have something that looks like this:


annotateWe’re almost done with the schematic. All we need to do now is add values to the relevant parts. The resistors must be labeled with the right value, the capacitor should 22nF or thereabouts, and the Zeners should have a ‘3.6’ label. It’s time for hotkeys again, this time brought to you by the letter ‘V’. Press ‘V’ over all the caps, resistors, diodes, and the LED and assign values. This takes care of the values for each part, but we still need to give each part a name. To do this, we’re going to use the ‘Annotate Schematic’ tool available in the top toolbar.

The Annotate Schematic tool automatically assigns a letter (D for diodes, L for inductors, R for resistors, Q for transistors…) to each part, along with a number. There are options to set how these numbers are assigned, but this is a very simple circuit and simply pressing the ‘annotate’ will suffice.

With that, our schematic is done. We haven’t set any footprints up for each part, and we haven’t even started on the board yet. This post is already two thousand words long, though, and Hackaday readers have the entire Internet has no attention span.

In the next part of this KiCad tutorial, we’re going to take a look at assigning footprints (the physical representation of components) to the parts in our schematic. We’re going to make a board, after which we’ll take a look at DRC, and a few of the neat tricks in KiCad including 3D rendering, turning the board into a bunch of Gerbers, and send off to a fab house.

Filed under: Hackaday Columns, how-to, Skills

Creating A PCB In Everything: Protel Autotrax

Protel Autotrax is a PCB design tool first released for DOS in the mid-80s. Consider this a look at the history of PCB design software. I’m not recommending anyone actually use Protel Autotrax —  better tools with better support exist. But it’s important to know where we came from to understand the EDA tools available now. I’m rolling up my sleeves (about 30 years worth of rolling) and building our standardized test PCB with the tool. Beyond this, I suggest viewing EEVblog #747, where [Dave] digs into one of his old project, Borland Pascal, and Protel Autotrax.

This is the continuation of a series of articles demonstrating how to Create A PCB In Everything. In this series, we take a standard reference circuit and PCB layout — a simple ATtiny85 board — and build it with different PCB design tools. We’ve already covered Eagle in this series. We learned Fritzing is a joke for PCB design, although it is quite good for making breadboard graphics of circuits. Each of these tutorials serves as a very quick introduction to a specific PCB design tool. Overall, this series provides for a comparison between different PCB design tools. Let’s dig into Protel Autotrax.

A short history of Protel, Altium, and Autotrax

The company we know as Altium today was, for the first fifteen years of its existence, known as Protel. Back in the day, PCB design on a computer required a dedicated workstation, a lot of hardware, light pens, and everything was extraordinarily expensive. Protel was a reaction to this and the first product, Autotrax, was a DOS-based program that brought PCB design to the PC. A freeware version of Autotrax is still available on the Altium website and can be run from inside a DOS virtual machine or DOSBox.

Interestingly, Protel Autotrax is not the only PCB design software named Autotrax. A company called DEX 2020 has also has a PCB design software called AutoTRAX. This is weird, confusing, and I can’t figure out how this doesn’t violate a trademark. If anyone has any insight to what the Protel / Altium legal department was doing a few decades ago, your wisdom is welcome in the comments.

The splash screen for Protel Autotrax. Autotrax' main screen

Workflows Modern And Ancient

There are three major steps to creating a PCB in any piece of software. First, you create the schematic. This schematic is simply a collection of parts and symbols tied together with nets. Second, this schematic is turned into a board file, where parts and pads are placed, nets are turned into traces, and the mechanical definitions of the board are created. Third, this board is exported into something a plotter, laser printer, or OSH Park can understand. These three processes are found in every single PCB design tool to varying degrees.

Autotrax is ancient, and with that, we should expect some weirdness. Autotrax does not have a ‘schematic creation’ mode. Instead, schematics should be created in another CAD program (Protel Schematic would be the best for Autotrax), the netlist exported, and the board built from that. Alternatively, pen-and-paper DaveCAD will suffice.

If this tutorial were about designing a circuit board from scratch, this would be a very bad thing. The good news is we already know what the circuit is and what the board looks like. It’s a simple circuit in any event. Therefore, we can use most of the parts out of the standard Autotrax library, duplicate our board, and everything should work.

How To Autotrax

The first few components placed. Here, you can see the ATtiny85, a decoupling cap, and a 1×4 pin headers found in the reference board for this series.

Autotrax is the digital equivalent of layers of mylar, tape, and an Xacto knife. To place a part, you place a package. This is highly unusual compared to modern PCB design tools, but with Autotrax, the onus of getting the circuit right is on the designer. In the above graphic, I’ve already placed the ATtiny85, the pin headers, and a decoupling cap. The next task is to place a few 0.3″ axial components for the resistors, a few packages for the diodes, a button, and a USB micro port.

pcPlacing the resistors for this circuit is as simple as using the Place Component hotkeys and looking through the library. Here, all the packages you would expect from a 1980s design tool can be found. PGAs were popular back then, and while SMD resistors can be found in the depths of the standard component library, it’s obvious through hole axial components are the rule.

resistorsAfter selecting the desired component, you need to select a component designator. This is the part name, usually numbered sequentially, and usually with a one-letter prefix (R for resistor, C for cap, U for a chip of some kind, L for an inductor, etc). Once the component designator is assigned, you give the part a comment — a value. I’m using 68Ω and 1.5kΩ resistors, so my comment for these resistors is ’68’ and ‘1k5’. In the interests of sanity and legibility, I’m going to remove these designators and comments from here on out.

Making a part

All of the posts in this series cover making a part from scratch. Usually, this means recreating the ATtiny in whatever software package I’m working with. Autotrax is weird, though, and I already have a DIP8 in the component library. Therefore, I’m going to create a package for the universal tact switch used in the reference design.

The ubiquitous tact switch. This is taken from the Apem Inc. MJTP-series datasheet
The ubiquitous tact switch. This is taken from the Apem Inc. MJTP-series datasheet

tactSaving the work I’ve done so far, I need to clear everything that’s currently in the Autotrax window. Then, it’s a simple matter of placing pads and top overlay (top silkscreen) tracks where they should go. I think I got it pretty close.

Turning this collection of pads and tracks into a part requires defining a new block, drawing a rectangle around the part, and creating a new library to store the new part. After that, I load up the PCB file I was working on and drop the part in:

I will not be adding the USB port to this board. That’s not to say I *can’t* add the USB port, I just don’t want to.

Since I won’t be adding a micro USB port to this board, I’m done placing the parts. All I need to do is draw traces between each part, and draw a board outline.


Like placing components, placing traces is an adventure in hotkey madness. Select Place, Trace, and draw the lines where they should go. Once that’s done, you can add fills for ground and power planes, and finally connect pads to those planes by editing individual pads.



Although the title of this series of posts is, “Creating A PCB In Everything”, this specific post does not go over step by step how to create the reference circuit and PCB in Protel Autotrax. To be honest, I’ve completely ignored the USB port on the reference circuit, the circuit itself doesn’t work, and turning this design into a PCB requires a physical plotter or software I don’t have. This is by design. You shouldn’t use Autotrax for Real Work™ in the year 2016. Consider this post a benchmark of what PCB design was in 1988.

Protel Autotrax was one of the first pieces of software that brought PCB design to the masses. As such, the UX is the closest thing to tape, mylar, sharpies, sensitized copper clad board, and Xacto knives that DOS has to offer. This is the beginning of an entire industry. Over the last three decades, the state of the art in PCB design has improved enormously. Now, we have parts libraries that include parts, and not just packages. We have push and shove routing. We have mice with two buttons and displays with better than EGA resolution. Autotrax is where it started, though, and until I can find a source of Rubylith or those neat IC tape sticker things, this will remain the pre-history of how to Create A PCB In Everything.

Filed under: Hackaday Columns, how-to, Skills

Stormtrooper Voice Changer Helmet uses Teensy to Mangle Audio

Halloween has come and gone, but this DIY voice changing Star Wars Stormtrooper helmet tutorial by [Shawn Hymel] is worth a look for a number of reasons. Not only is the whole thing completely self-contained, but the voice changing is done in software thanks to the Teensy’s powerful audio filtering abilities. In addition, the Teensy also takes care of adding the iconic Stormtrooper clicks, pops, and static bursts around the voice-altered speech. Check out the video below to hear it in action.

Besides a microphone and speakers, there’s a Teensy 3.2, a low-cost add-on board for the Teensy that includes a small audio amp, a power supply… and that’s about it. There isn’t a separate WAV board or hacked MP3 player in sight.

Making everything fit nicely in a project takes planning, and not only is the entire system self-contained in the helmet but there’s even ducted blower fans to help stave off heat exhaustion. The whole thing is beautifully done, and nicely shows off the capabilities of the Teensy when it comes to applying the audio filtering abilities.

We’ve seen voice changers using the Raspberry Pi + USB sound board, and even an Arduino + WAV shield in the past, but a Teensy based unit completely self-contained in a helmet is a first.

[via Sparkfun Blog]

Filed under: how-to, wearable hacks

Digipeater hardware build video

Kenneth Finnegan writes:

This is the hardware build of a new digipeater one of my friends asked me to put together for him. The transceiver is a GM300, with a KAM plus TNC modulating it. If we didn’t happen to have a KAM+ on hand, I would have probably used an OT3m from Argent Data.
He’ll provide the computer, but for testing I have it hooked up to a Qotom Q310G4 running Aprx.
As mentioned in the video, when I’m working with CAT5 cable, I love using the GreenLee 4908 toolkit.

Pi Cart: 2,400 Games In One

What’s the quickest way to turn one game into 2,400? Cram a Raspberry Pi Zero running RetroPie into an NES cartridge and call it Pi Cart.

This elegant little build requires no soldering — provided you have good cable management skills and the right parts. To this end, [Zach] remarks that finding a USB adapter — the other main component — small enough to fit inside the cartridge required tedious trial and error, so he’s helpfully linked one he assures will work. One could skip this step, but the potential for couch co-op is probably worth the effort.

Another sticking point might be Nintendo’s use of security screws; if you have the appropriate bit or screwdriver, awesome, otherwise you might have to improvise. Cutting back some of the plastic to widen the cartridge opening creates enough room to hot glue in the USB hub, a micro USB port for power, and an HDMI port in the resulting gap. If you opted to shorten the cables, fitting it all inside should be simple, but you may have to play a bit of Tetris with the layout to ensure everything fits.

Using a Back To The Future game cartridge encapsulates the essence of this project, considering its contents would be nearly science fiction back in the 1980’s — a nice touch. We’ve featured plenty of RetroPie setups — each with their own unique flair — but if you’re looking for a more period appropriate gaming station, you could simply gut an NES for the purpose.

Filed under: how-to, Raspberry Pi