Comment by dragontamer | Hacker News Reader

Comment by dragontamer | Hacker News Reader

Parent Full thread

I think KiCad is suitable for beginners, even if you haven't breadboarded yet, but note that Breadboards exist to give you lots and lots of practice before you start spending money on PCBs.

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.

I would even recommend decoupling the processes a bit. That is - start with a known good schematic, ideally one that exists as KiCad schematic already (look for KiCad projects on Github). Practice creating a board outline, placing some parts and routing traces, make yourself familiar with the tools around that (how to deal with layers; how to use the design ruler checker; the 3D preview to find blatant mistakes with connectors or so; how to export the files (if necessary - Aisler accepts KiCad files for example)). If you want, export it and order it. At JLCPCB that should be $2/2€ + shipping if five pieces and HASL is good enough. Then maybe enter a known good schematic oneself. Then create a simple circuit on breadboard, turn it into a schematic, enter that. ...

I'm brand new to this. I've got a relatively simple schematic from the 1950s I want to reimplement, to have a functioning thing on my desk.

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?

A couple people had some great comments that should get you started; I'd just like to add that you don't need to do everything at once either and your workflow can be flexible. When I'm making a board with weird parts, I like to first just go into the symbol editor, make a new project library, and draw out whatever I need for my project with the correct pin assignments. Then at least you can focus on copying the schematic over and getting the ball rolling.

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...

Each of the steps I outlined above, #1, #2, #3 and #4, are a new set of keyboard buttons and GUIs to learn for KiCad.

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.

In addition to the other recommendations in the thread, it may be useful to learn how the whole process works (KiCad, ordering or making PCBs, and assembling everything) with an even simpler circuit with just a few components. Making a simple battery + LED + resistor + switch circuit would involve learning almost the same amount about KiCad etc. as a more complicated circuit (within reason), with a lot less opportunity to be overwhelmed by component selection, PCB layout, etc. It would also be fairly cheap to make mistakes, since the PCB could be quite small and would probably cost only a few dollars even from a fairly high-end PCB manufacturer (I like OSH Park, but they can be expensive for large boards; see pcbshopper.com for price comparison).

I think you can just use CONN_01X00 pin header parts to represent tubes on the circuit schematics, then define just the footprint for the tube, either from its datasheet or ANSI/ISO/DIN/GOST connector specification. Then that footprint can be assigned to corresponding J0 on the imported PCB file. You can also print the PCB to visually test fitment. That might not be the correctest way but nor should be the wrongest approach.

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.

For me it helps a lot to get some one-on-one to get me rolling.

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.

[1]: https://www.youtube.com/c/MicroTypeEngineering

Can you share the schematic? I'm not familiar with KiCad or other similar software, so take this with a grain of salt, anyway I think that for simple schematics, especially that old, meaning all tht parts, single side pcbs, unless one is recreating a complex circuit, probably the "by hand" approach is a lot faster than using software.

This original article is a pretty complete reference for everything you need.

Consider keeping it open as you try to achieve your recreation.

Or read a section first (e.g. how to create a footprint or symbol) to better understand what is happening and then watch a tutorial video of someone doing exactly that to see it in action.

Start by building a prototype proof of concept on a breadboard or prototyping board!

I'm not sure why you position things as if it's either KiCAD or breadboards. Whenever I've designed a PCB, I've gone from breadboard, to schematic, to PCB (the last two in KiCAD). The breadboard is a necessary first step to make sure that the circuit works in the real world, not just in theory.

These days, with $5/sq-inch 2 layer boards and cheap prices for 4 or 6 layer boards... This makes 40+ pin microcontrollers and 200+ pin BGAs even are well within the means of a modern Hobbyist today in 2023. But there is no hope for these chips to ever be adequately placed on a breadboard.

-------

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.

That's true, I guess my designs are rather more basic than that. I never managed to figure out how to work with these slightly more complicated chips, though I'd like to.

Start with a 32-pin beginner uC like STM32G0, AVR64DD32 (more modern version of AtMega328pb), PIC, or other such chip.

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.

Thanks for this! I've already soldered and designed a lot, I just don't know how to find the microcontrollers' "boilerplate" (eg all the pull-ups and pull-downs it needs to boot, capacitors, stuff like that). It also doesn't help that my C isn't great, but I guess I can write Rust on the STM32 nowadays.

It's hard to keep going back and forth on YCombinator.

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.

This is very helpful, thanks!

Reply on news.ycombinator.com