Getting Started in KiCad 7.0
docs.kicad.org
docs.kicad.org
If you’re working in a big team, or making really complex stuff like telecom equipment or server motherboards, then I can see the appeal of shelling out for PADS or Altium with their library management and package automation tools.
But, I’ve designed hardware on a consulting basis before using Kicad as my EE CAD package of choice. It was more than enough for my needs. That includes simple two layer boards all the way to pretty complicated six layer embedded Linux systems.
I particularly like that it comes with an embedded 3D viewer. Coming from only ever using ORCAD before that, it was a huge breath of fresh air, and significantly cut down on the number of connector mistakes I’ve made since.
Personally, I thought 5.0 was a big pain to use. With 6.0 it actually got kinda decent, but I still had to write custom code to work around a few of its warts. However, 7.0 shows that it is rapidly moving towards being a serious threat to the proprietary market leaders, and I can't wait to see what the future will bring!
It's really all so enjoyable to observe from the armchair. I'm not embedded into the Kicad community/project, but it certainly feels like the momentum is there.
I love these tentpole moments/projects in the overall fabric of the industry, when an open source project reaches "momentum escape velocity" after sticking around long enough to snowball and eventually eclipse the proprietary alternatives in terms of sheer scale. For example, it's very hard to outcompete the Linux kernel for general applications now simply because everyone's working on it, and no single company can build and retain a team that can outcompete an entire ecosystem, outside of picking very particular battles (e.g. QNX<>Linux).
Cynics will point out that this often describes an area of software simply commodity-fying enough that FOSS can now catch and keep up, and pragmatists will point out that the commercial packages often still retain a key feature for e.g. a leading edge/high-end application you can't get from anything else. But be that as it may, it's still beautiful.
I like to identify and start watching the projects that may be on the verge of becoming this in their particular domain. For example, Blender may get there or is already there. Could Krita? 20 years from now, could this be Bevy for the game engine space? There's usually certain markers, e.g. healthy governance (this is what gives the project the legs to make it long enough), good mission statement, hygienic tech stack, that sort of thing.
For young programmers, this is the type of project to find and join. You end up running an industry when you grow up, and, if that's important to you (there can be other priorities, e.g. shipping important products in general), your hard labor won't die and disappear one day with a company.
Well, we pulled the plug on Altium when KiCad 6.0 was released and have not looked back. We got really sick of Altium nonsense, just had enough of it. Their focus on cloud to sell the company really caused damage and every release broke something new.
We do everything from relatively simple four layer boards to complex multi-GHz boards with challenging signal and power integrity constraints. KiCad has no problem at all providing the tools we need to complete these designs. I can't see ever going back to Altium.
As far as libraries are concerned. Professional organizations rarely (I would say, never) use built-in libraries. The reason for this is that you are responsible for reliability, manufacturability and product life-cycle. This means every component needs to be qualified and fully vetted to the extent required by the nature of the product. Which, in turn, means that you are always going to want to define all the components and use internally-built libraries you can trust. There are other reasons for this, that's just the basics.
Built-in component libraries are always going to be incomplete, and literally all of them kinda suck. Professional PCB designers almost always have to either create their own footprints from the datasheet, or get them from someone else who did. Trusting third-party footprints is probably the easiest way to end up with fundamentally broken prototypes which are nothing more than fancy desk decorations - I can unfortunately speak from experience.
The built-in libraries are basically only used for trivial things like resistor footprints, 2.54mm headers, or solder jumpers. KiCad's libraries are more than good enough for that.
But yeah, a lot of chip footprints are quite standard, or require only small modifications from those standard footprints. I do still have to hand-draw quite a few of them, but that's because my designs are usually quite heavy on relatively obscure peripherals.
I have never understood the concern about the built in library. Professionals barely use it. You MIGHT use it for some SMDs, but that’s about it. Everything else you are going to get or make or download the specific footprint.
Your (cad tool) component library is your most valuable resource, and in my opinion more valuable than schematics/layouts. You have your own proven set of components that you know will work in manufacturing. Even the standard passive SMD footprints need to be tweaked for your specific requirements (ISO, design for manufacturing etc).
In regards to Kicad... great tool for 90% of designs. I would say as a rule of thumb, if your design can be manufactured at one of those online, cheap PCB manufacturers (for say, $10-$20) then Kicad will cover it. Once that calculator tool starts going higher you're probably doing someone more complicated that warrants the more expensive tools.
I assume many vendors also offer parts libs/files in EDA formats, but are those proprietary or is there any de-facto standard like Gerber files?
It'd also be nice to browse datasheets' other contents in a consistent interface right in the EDA or in a web app instead of dealing with a zoo of PDFs in vendor-specific styles.
Maybe it's this kind of thing we'll automate using LLMs/models ... give it a description of the scripting API of the EDA, give it the PDF, make it map a footprint from one to the other. Or to a standard format. For back catalogs that could be useful ...
It would be great if part manufacturers would just make the footprint files and 3D files available for the parts, because I have no doubt that in 99% of cases the manufacturer has those files somewhere. I've tried to social engineer this out of some companies with very little success. I don't care what format they come in, I'll get it sorted out. I have collected an arsenal of file format conversion tools.
>Maybe it's this kind of thing we'll automate using LLMs/models
I have no doubt that at some point in the future you'll just give the AI the PDF and it will spit out a PCB footprint in any file format you want. We're not close to that though.
Maybe part of the inertia is that it pays too many people's meals, since you can buy this as a service ...
https://resources.sw.siemens.com/en-US/technology-overview-p...
I've personally enjoyed using DipTrace, very intuitive and easy to pick up, it's far less than $1000. I've been hearing good things about Flux but haven't tried it myself yet. I hear it's not complete, but coming along quick.
Why would anyone want to use an old, proprietary program like DipTrace when KiCAD is free, cross-platform, open source, and arguably just plain better? DipTrace has a Mac version, but all of the discussions I see online indicate that it still hasn’t been updated to work properly on Apple Silicon.
It’s been probably 7 or 8 years since I last saw someone using DipTrace, and I wasn’t impressed then. It’s also $995 for the full version (the closest to KiCAD’s feature set), which is hardly “far less” than $1000, but the absolute minimum version I would even consider would be $400. I’m amazed at how their website seems to be exactly as I remember it from so long ago.
Looking through their marketing site, I literally don’t see a single thing that is better than KiCAD. I personally just don’t understand why anyone would buy DipTrace in 2023. So, it’s hard to respond without just coming off as dismissive. I wish I could provide a more balanced comment that makes it seem like DipTrace is still competitive, well-maintained software… but that isn’t what I believe. I’m sure it’s fine for basic use cases, but KiCAD is great for those use cases and so much more.
Flux seems gimmicky at first, but browsing through their materials, I am at least impressed at the effort they seem to be putting in. They even had a comparison page against KiCAD, but this attempt to sell against KiCAD ended up being some disappointing nebulous statements that didn’t seem to have much merit, apart from the real time collaborative nature of their product, which seems to be their one actual advantage.
Different people can have different opinions, of course, but KiCAD is great quality software with a lot of momentum.
If you want to share what features you like most about DipTrace, or what you think it does better than KiCAD, that would certainly be interesting to hear.
Using Diptrace I've appreciated the reasonable pricing $150 for thr lite version), the online library integrations have been working well for me both in ease of finding what I need and dropping it right in, but also in the quality of the footprints, etc.
I also prefer thr UI interface. Many ecad solutions are clunky and old school to use in their UI. In Diptrace the whole thing is basically achieved by left and right clicking, selecting from context menus.
As for Flux.ai, that one is new and I've been out of the pure PCB world for a little bit so have not messed around with it. To be honest, I'm not a fan of browser-based tools, personally. Even Altium 365's new features (though some are certainly useful), take some getting used to - I suppose I don't really like the "data in the cloud" prospect that much. That being said, I did link Flux.ai first on my recent survey of AI/ML-based PCB tools [1] as they seem to be quite far along.
The problem is that PCB design tools all lie on a spectrum from "jump in and design the board right away" to "you'd better spend a while getting your libraries and environment ready to go". Tools like PADS seem to be more towards the latter, while Altium and KiCad are closer to the former. OrCAD is probably around the middle or so. It can be tough to give a tool a fair assessment if it takes more effort to get going on a design.
[1] https://wiki.shielddigitaldesign.com/High_Speed_Design_Wiki/...
Dump it.
Inlaid out an 8-layer board with diptrace… ABSOLUTELY NEVER AGAIN.
Each PCB is a bit of money after all, and if you are inevitably going to make a mistake it's better to breadboard.
But as far as difficulty goes, things like KiCad exist for a reason. Computer automation and checks help, as well as parts libraries for you to download/copy rather than building your own footprints.
So feel free to start KiCad + ordering boards the moment you are willing to lose money on your mistakes!!! It's not any harder IMO. Just costlier.
----------
As far as learning Kiad, this guide is good but it's missing the broad overview IMO. So here's my broad overview:
1. Build symbols representing each chip or part you plan to use. Standard parts (like resistors) already exist in KiCAD7.0 library, but inevitably there will be a few missing parts for your project. This may be called symbol editing, but perhaps it's more accurate to call it pin-naming.
2. Hook up the parts together in the schematic editor. Double check symbols and their pinouts now. Fix symbol mistakes now. This creates a computerized set of nets (connections) that KiCad will try to enforce moving forward.
3. Choose the footprints for every part in your schematic. Beginners should probably use 0805 (inches) parts or larger. (equivalent to 2012 metric). Like #1, there is a footprint library for common parts, but you will inevitably have to create at least one or two footprints of your own for your personal projects. Footprints tell KiCad where pins are located physically (inches or mm) here vs there.
4. PCB layout begins. KiCad has a 'rats nest' based on your schematic. As long as #1, #2, and #3 are correct (ie: correct symbols / pinouts, correct schematic, and finally correct footprints) you probably can't make a mistake anymore. Assuming a low speed beginner circuit anyway (the professional would focus on physical issues like heat, noise, EMI, crosstalk and other such issues. Beginners can likely ignore all of that assuming you chose a suitable beginner project).
By step#4, KiCAD knows the name of every pin (#1), which pins should be connected to which pins (#2), and where each pin is located physically (#3). All that's left to do is draw your wires together in step#4.
As you say, a few parts are missing (particular vacuum tubes). Unfortunately, every time I start implementing stuff in kicad, that's where I get overwhelmed... And to someone who's not a hardware guy, I'm completely stymied. Can you suggest what I should do?
Once you are happy with the schematic, and parts are roughly placed where you want them on the board, you can go ahead and jump into the footprint editor, make a project library in there with the same name, and draw the physical copper layout for your tubes or whatever else to attach to based on datasheets or caliper measurements. Then you run footprint assignment to match up all the symbols with their corresponding footprint, and update the PCB to populate it with parts to lay out. Once the parts are placed logically where routing will be sane, follow the ratsnest connection lines to get your board routed.
Last you want to go to your manufacturer's website, look up all their specifications on board construction [0], and make sure all their recommended design rules and board stackup are plugged into board setup. This may mean going back and changing some trace sizes, trace placements, vias, and so on to pass design checks. Later you will do this earlier, but it's better not to get bogged down at first and just start designing, and you'll learn why things are routed as they are.
After this, spend time inspecting your board, looking for errors, making sure all checks pass and everything makes sense after a few reviews. Then export your gerbers and drill maps and send the zip to your manufacturer.
It's a little daunting at first because there are just a lot of steps between a schematic -- essentially a cartoon version of what your circuit will be, and a layout -- what your circuit will actually look like. You don't have to do every step at once and once you have the schematic drawn, you can just keep adding to it until you have something that works.
[0] https://docs.oshpark.com/design-tools/kicad/kicad-design-rul...
Yes, it's a lot to take at once. But fortunately, you only have to move forward one step at a time.
--------
Maybe starting at #2, Schematic, would be the only 'out of order' thing I'd recommend. There might be enough library parts to fill out a large section of your schematic (or maybe not...).
Inevitably, you will have to tackle #1 (symbol editor) and #3 (footprint editor) before you finish #2 and start step #4.
---------
I agree it's a lot to take in at once. But after you do all four steps and understand them, there is a sense of order and process. Especially as #1 (setting the pinout on a symbol), #2 (saying what pins are connected) and #3 (saying which pins belong where physically) are all accomplishing computerized checks to make #4 less error prone.
It's a lot of info to tell KiCad, and any other PCB editor will need all this information as well, so none of it was wasted effort.
It's just a lot of up front complexity that really is intimidating.
---------
#2 schematic editor might be a good starting point because it's what you expect to do. #1 and #3 are somewhat unintuitive steps.
One of the most confusing things when I started using KiCad is its two main features, EESchema and PCBnew, are basically two independent open source projects. So they're not tightly coupled, but works by importing and exporting files and manually assigning items in one side to the other.
Consider findig a makerspace nearby and see if they have some courses or people willing to help. There's one in my town and they have an active slack and weekly "maker evenings" where it's easy to get help.
Alternatively find some online communities where you can get some help.
As an example, this[1] YouTube channel has some great videos on layout and more with KiCad, as well as a very nice Discord community with newbies and professionals. I'm sure there are others, but that's where I got some great help when I got my feet wet.
Consider keeping it open as you try to achieve your recreation.
-------
From my experience, breadboards and protoboards are for simpler learning projects. But you rather quickly grow beyond what a breadboard can offer.
Breadboard when you are at breadboarding level. But once you graduate to greater levels of complexity, you can only buy custom pcbs (and possibly 4 or even 6 layers at that). It's literally impossible to breakout a full square ~17x17 pin BGA on 4 layers, let alone dealing with EMI or signal integrity effects.
Find a useful sensor to some itch you have: temperature, pressure, weight, time, CO2, accelerometer, whatever is interesting to you. Make a design that reads the sensor and writes it to LEDs (red is bad, green is good), or 7-seg displays, screens or some other visual device.
Order 3 or 4 boards, low temperature lead free solder paste, no clean flux (bullshit, you should clean it off), solder wick, cheap isopropyl alcohol to clean the flux after the fact, a pancake grill, and 3 or 4 copies of all the chips you need.
If you stick with larger surface mount chips like 0805 inches or 2012 (metric), a soldering iron is sufficient for rework. Smaller chips require a hot air gun.
Try to stick with larger chips like SSOP or even SOIC chips. TQFP should be doable with the sloppy then flux+solder wick cleanup method but don't go any smaller as a beginner. SOT-23 is easy.
--------
Mess up your first attempt. That's fine, you have 2x more tries.
Build it successfully using pancake griddle reflow method (solder paste on the pads, be sloppy if you must. Place enough so all the components stick to the gel-like solder paste in place. Heat to 350F or 138C for low-temp solder paste (you can tell because it liquefies and all the components start floating).
Use a toothpick to push items back into place, turn off heat. When cool, use lots of flux, solder wick + solder iron to fix bridges (should be super easy. If it's not easy, use more flux and try again and/or buy new solder flux+wick. That stuff goes bad every 2 months).
Done. Except you probably made a mistake on your schematic. Fix that, order new parts, try again and be happy the time it finally works.
Keep your flux, wick, and solder paste refreshed (throw out old consumables, buy new every few months) and you should be good to go.
Order a x10 jewelers loupe or x15 or x25 to visually inspect these solder joints. If all looks well, grab your fire extinguisher and turn on your electronics project! Best of luck.
I use Lemmy.world to post here: https://lemmy.world/post/6104468
This is about a YouTube video that walks through a reference design for an STM32F1, a beginner friendly chip with very simple startup.
You only need the 100nF capacitors as indicated in the reference documents, but the video also adds a Ferrite Bead + Pi filter (1uF + Ferrite + 1uF), which is considered a good practice to reduce noise... but likely is optional and not needed at a beginner level.
KiCad desperately needs a stackup-aware constraints system, differential impedance/trace width computation, multi-trace routing, etc. in the same way that Altium has. I wish I had time to add the features I want: KiCad is so much more pleasurable to use on average.
Sounds totally black magic to me. Any starting points?
Today, I help colleagues get started in electronics. They often have some sort of science or non-EE engineering background. I recommend diving into the Arduino universe, perhaps by looking through the many tutorials at the Adafruit webiste. (And buying her stuff).
Learn, the way a lot of us old-timers learned to code: Take some working program, duplicate it, and make minor changes, and see what happens.
Even if your ultimate interest is analog rather than digital, the tools that you learn to make in the digital realm, such as measurement, will help you test your beginning analog circuits. On the other hand, if you're interested in analog, you may have a reason, such as audio or music electronics, in which case, there are a lot of documented projects out there to build and learn from.
Don't work with anything potentially dangerous at first, if ever. Things that can release a large amount of energy (voltage, current, mechanical, heat) if your code has a bug are worth leaving to the real engineers.
Don't stress about the electronics and certainly don't be intimidated by text books. When you're starting out you don't need to really know the theory of transistors, but maybe a few youtube videos on the basics won't go astray. Think about if you were learning to code... would you read a book and start stressing about computer architecture? Some people might, but most won't. They'll hit up create-react-app and mess around with that.
When you're learning it's important to get instant feedback. Just learn how to blink an LED and you've completed the hello-world of electronics.
If you can code, you can do electronics. Same for the reverse. The skill sets are closely aligned.
But my KiCad files are on a harddrive that is not my "/" drive, and Snap doesn't allow KiCad to read those files. I tried with a bind mount, but then the symlinks in my project files don't work ...
Now I'm thinking of compiling everything myself, but it seems a daunting task.
I meant the linked article specifically.