Fritzing is an open-source electronic design tool
fritzing.org
fritzing.org
It's not an on-ramp, it's a time-wasting distraction detour from your actual on-ramp.
Every minute you spend figuring out how to do something in fritzing is a minute you could have spent figuring out the same thing in kicad, which you will end up doing eventually anyway, I promise you, garanteed. All this gets you is some badly designed boards and wasted time.
There are gobs of youtube videos for the absolute beginner which takes care of taking you from zero to simple pcb in a few minutes. Then you figure out a lot of other details as you encounter needs for them over time.
It doesn't have to be kicad either. If you don't mind a commercial proprietary product, Eagle is fine too. It's workflow is a little different but not bad. In fact it's an industry standard at a low level.
If your design is open-source, Altium CircuitMaker is a free version of Altium specifically for open-source hardware projects:
I would also suggest that anyone who cares about computers gets to know basic electronics. How do transistors work, what is a bus (e.g I2C or SPI) and how is it all connected? (Drumroll ... a PCB of course). There is a ton of tutorials on youtube that do it end to end. E.g Phils Lab https://www.youtube.com/watch?v=rLDqQ2L_mUQ for a PCB design. Or Ben Eaters excellent beginner tutorial "Hello World from Scratch" https://www.youtube.com/watch?v=LnzuMJLZRdU
The only merit Fritzings has against a thriving open ecosystem such as KiCAD is its dumbed down interface that would make it more accessible to beginners. However, if you want to use it without paying €8, you have to compile it from source, which makes this whole point mute.
And good luck with creating your own components!
Prior to the early computing CAD days, the traces were really rounded and flowing, and had teardrop fills. They were also done freehand, with transparencies, markers, and tape.
This is a good example of hand-designed boards: https://www.worthpoint.com/worthopedia/vtg-early-1970s-ampex...
The constraint is still there. Curved traces make your GUI ridiculously unmanageable. Ever tried to manipulate font outlines? It's like that on a PCB, only an order of magnitude worse. You have to operate control points for every single segment rather than just dragging a trace. All for effectively no benefit on 99.9% of all PCB designs.
In fact, the only good argument for using non-Euclidean traces is in the ultra-high-speed arena (think DDR4 bus or multi-GHz RF). If traces are small enough that they fit between the PCB weave, different traces can have enough difference in electrical permittivity that it will screw up the matching (trace 1 has an FR-4 fiber directly underneath while trace 2 only has cross fibers underneath and so has about 50% air underneath instead of 100% fiberglass). Consequently, you have to swing the angles to weird things like multiples of 7 or 13 degrees to prevent that.
For anyone with more questions in this area of high speed digital design, feel free to reach out to me (contact info in profile) - I love the topic.
[1] https://blog.lamsimenterprises.com/2011/01/08/fiber-weave-ef...
I guess it depends on who you are, but I tried it and noped away in under 30 minutes. I understand how this might be a valuable learning tool in a classroom environment, but the restrictions it has around components and design are too much for a hobbyist experimenting.
> which makes this whole point mute.
moot
For paid/non-free, some of Altium's offerings would be the next step up, along with Fusion-360. I haven't tried Fusion-360 ECAD. I do know that Autodesk bought Eagle, but it's not clear to me if Fusion-360 is using Eagle for schematic capture and PCB?
After that, it's big-boy tools like mentor or cadence. These are overkill for hobbyists unless the man is paying for your seat.
I've used it for mechanical and I found it extremely polished and intuitive and totally worth the subscription for that alone, but I have neither the time nor project (yet) to go down the rabbit hole of learning the ECAD functions of Fusion-360.
I've heard that the really expensive EDA tools are like Adobe Photoshop --- everyone experimenting/learning tends to just pirate them, and then end up at a company which does pay for them.
My impression is that Horizon-EDA is well worth following, but not as far along as KiCAD. It's a nice second option that some people prefer.
When adding components, add "LCSC" to overall schematic (BOM export will fail if added to each part separately (join issue)) and the part number in each part in order to use the JLCPCB assembly service. Only parts with LCSC column are exported in the JLCPCB BOMs.
.gitlab-ci.yml
...
tests:
image: setsoft/kicad_auto:dev_k6
stage: testing
script:
- "[ -f *.kicad_pcb ] && kibot -c test.kibot.yaml"
tags:
- docker
pcb_outputs:
image: setsoft/kicad_auto:dev_k6
stage: gen_fab
script:
- "[ -f *.kicad_pcb ] && kibot -c output.kibot.yaml"
only:
refs:
- master
artifacts:
when: always
paths:
- Fabrication/
tags:
- docker
...
kibot:
version: 1
preflight:
run_erc: false
update_xml: false
run_drc: true
check_zone_fills: true
ignore_unconnected: false
# Gerber and drill files for JLCPCB, without stencil
# URL: https://jlcpcb.com/
kibot:
version: 1
filters:
- name: only_jlc_parts
comment: 'Only parts with JLC (LCSC) code'
type: generic
include_only:
- column: 'LCSC'
regex: '^C\d+'
variants:
- name: rotated
comment: 'Just a place holder for the rotation filter'
type: kibom
variant: rotated
pre_transform: _rot_footprint
outputs:
- name: JLCPCB_gerbers
comment: Gerbers compatible with JLCPCB
type: gerber
dir: JLCPCB
options: &gerber_options
exclude_edge_layer: true
exclude_pads_from_silkscreen: true
plot_sheet_reference: false
plot_footprint_refs: true
plot_footprint_values: false
force_plot_invisible_refs_vals: false
tent_vias: true
use_protel_extensions: true
create_gerber_job_file: false
disable_aperture_macros: true
gerber_precision: 4.6
use_gerber_x2_attributes: false
use_gerber_net_attributes: false
line_width: 0.1
subtract_mask_from_silk: true
layers:
# Note: a more generic approach is to use 'copper' but then the filenames
# are slightly different.
- F.Cu
- B.Cu
- F.Paste
- B.Paste
- F.SilkS
- B.SilkS
- F.Mask
- B.Mask
- Edge.Cuts
- name: JLCPCB_drill
comment: Drill files compatible with JLCPCB
type: excellon
dir: JLCPCB
options:
pth_and_npth_single_file: false
pth_id: '-PTH'
npth_id: '-NPTH'
metric_units: false
output: "%f%i.%x"
- name: JLCPCB
comment: ZIP file for JLCPCB
type: compress
dir: Fabrication/JLCPCB
options:
files:
- from_output: JLCPCB_gerbers
dest: /
- from_output: JLCPCB_drill
dest: /
- name: ibom
comment: Interactive BOM
type: ibom
dir: Fabrication/ibom
options:
dark_mode: true
- name: 'JLCPCB_position'
comment: "Pick and place file, JLCPCB style"
type: position
dir: Fabrication/JLCPCB-BOM
options:
variant: rotated
output: '%f_cpl_jlc.%x'
format: CSV
units: millimeters
separate_files_for_front_and_back: false
only_smd: true
columns:
- id: Ref
name: Designator
- Val
- Package
- id: PosX
name: "Mid X"
- id: PosY
name: "Mid Y"
- id: Rot
name: Rotation
- id: Side
name: Layer
- name: 'JLCPCB_bom'
comment: "BoM for JLCPCB"
type: bom
dir: Fabrication/JLCPCB-BOM
options:
output: '%f_%i_jlc.%x'
exclude_filter: 'only_jlc_parts'
ref_separator: ','
columns:
- field: Value
name: Comment
- field: References
name: Designator
- Footprint
- field: 'LCSC'
name: 'LCSC part number'
csv:
hide_pcb_info: true
hide_stats_info: true
quote_all: true*It’s a modern take on electronics design with slick UX
Comes with a free tier as well as paid
Software engineers here are gonna love that components in flux are fully programmable from schematic/PCB all the way down to simulator models
And it's browser based. Opening any of the examples on the main page with firefox lifted up my PC like a hovercraft by the way the fans started to spin, with several seconds delay for any interaction (on a PC that's capable of running Altium and Orcad).
PS: I love the animation on the main page and how the mechanical engineer has no idea on what's going on!
Yeah, performance is on our radar now that the core product is mature enough to manufacture boards. Our goal is to get 200 component projects to work well on a regular 2017 generation machine and get to 1000 by end of year.
About vendor lock-in: we def don't want to lock anyone in...so data portability is big focus and we have import/export support for kicad and other formats like STL or Collada already. Planning to add support for Netlists, Altium, Eagle, etc too as well as a REST API.
You can also export your project as a json file today
Ultimately the power of flux is connectedness the collaboration that enables but we do plan to ship a standalone app that's unbundled from your web browser in parallel to the web version.
We also have plans to offer some amount of offline capabilities so solve for use cases such as being on a airplane.
Dev1: It works on my machine!
Dev2: Great, we'll ship your machine!
[0] https://lescinskas.lt/assets/img/posts/2019/docker-works-on-...
Plus Kicad is cool ;)
Original article has disappeared but is on archive.org: https://web.archive.org/web/20210615211240/https://bowero.nl...
Once you learn to solder you can make PCBs and work with higher-speed components than breadboards can support, then you'll want something that's actually slightly decent for PCB design. Fritzing is about the same level of help as manually cutting out mylar tape, you want something with actual design rule checking.
After several keyboard bashing episodes, for my own sanity, I decided either I make my own schematic design tool and simulator or I'll give up on this hobby. In a day I had proof of concept, in 2 weeks I had working prototype, in a month I had decent tool I could actually use for real stuff.
For comparison, the easiest and most stable for me was Caneda. But to change resistor value and see change in output you need 7 clicks ffs! It would take ages to design anything, my tool simply uses mouse wheel over component to change its value by 1% or 10% (shift). What takes me 30s would take me hours in other tools. And my tool doesn't even have autosave. It doesn't need it, it never crashes, ever! There are 3 unbound loops in my schematic editor, I know where they are and I added code that prevents it from freezing. It is literally impossible to crash it. Even during the development it rarely broke, I guess the "pro" tools are built differently. Then few weeks later as I was making more and more complex circuits I designed perfboard design tool and now I have everything I need. I've been really happy with it, no bugs, no crappy UI. I should have done it years ago. Designing circuits is now my happy place.
I think the authors of other design tools try to hide their bad core design by adding million features and thousands of components, but if the core products is crap, it will be crap even if you add 20'000 to92 transistors, it will just take you longer find component you need.
I was considering releasing it but it would take too much time to get it to the state others can use it and I don't have that kind of time (it runs in browser but needs locally running ngspice running in the background via php server). But if you are like me and you find all other tools garbage, make your own, seriously, is not that hard and it is very rewarding, my first POC was literally screenshot of scheme with wheel changing netlist values, running ngspice, showing transient analysis in chart.
Schematic design tool and simulator: https://de.catbox.moe/hcoapj.png
Perfboard tool: https://de.catbox.moe/uq8si4.png
I, too, have made progress on my own tool. Mostly focusing on just laying out Gerber files. I haven't made the progress you have made, but the idea that the tools trouble me enough to abandon them and just start from scratch, is interesting.
What's worse, is that having dabbled with both KiCad and Eagle (and probably others) and neither rises up above to a level that I was having any real success. They both look like they were cut from the same cloth, no doubt designed in the 80's and just working on "workflow momentum" of the industry, because they don't want to retrain anyone that's been doing this for 30 years.
KiCAD at least is heavily oriented around keyboard shortcuts. To change a resistor value, you mouse over the resistor, press `v`, type the value, and press enter. 0 clicks, 2 keys + however many digits in the value. And it doesn't autosave.
I once had to use a program that had no save feature at all. I don't know if each change was made immediately, or if it dumped at close. Of all my years using the software, I never even inquired about it. I just remember learning to use it and the lack of save was pointed out then thinking about how strange that was. After using the program, I never even thought about the no save again.
For about the first 30 monutes I did fight with with the basic navigation based on zooming out then back in, instead of just panning, but as long as I have an even minimally good mouse (mx anywhere 2, 2s, 3 for myself) it's fine. It's annoying on the track pad or a mouse without a good wheel.
And that's pretty much it. It only bothered me for the first few minutes to maybe an hour.
Everything else is just learning where a few settings or tools are, and getting a few basic ideas about how the schematic ties to the pcb. Those aren't really communicated very well by the app itself. I pretty much figured it out by just trying stuff and noticing what it did, but there are also tons of videos that just show you.
Almost immediately I was drawing pcbs and loving it.
Their breadboard view needs more work but it's by far the only reason to consider using it. Unfortunately the parts editor is a pain to use.
I was considering trying to fork it to remove everything that wasn't related to the breadboard view, and make the wire interface a little easier to manage, but that didn't get anywhere. (Yaks)
People are actually trying to use this as a proper EDA? Are you kidding?
I thought it was kind of cool, especially for prototyping how I’d put together a prototyping breadboard circuit, but by the time I got to it, I was already familiar with EAGLE and have since moved on to KiCad. To me, it’s a tool that is useful for beginners but complicates transitioning into another EDA tool. That actually makes me wonder if Altium users feel the same way about KiCad.
- quick and dirty Arduino / Adafruit / SeedStudio boards based projects
- first time software for electronic learners or in a classroom
The breadboard view is the selling point of Fritzing. Kikad, LibrePCB or EasyEDA do not really offer this feature. That said, calling Ftrizing an EDA is exaggerated but it has his usage when a full featured EDA is not needed (yet).
Fritzing is not in the same team, it belong more to the team of DIY Layout Creator and VeroRoute.
As a hardware founder (https://Loodio.com) I actually stuck with EasyEDA.com because it’s so damn quick and they have lots of ready made foot prints.
I even make the enclosure for Loodio with PCBs that I screw together with screw terminals. So every unit is 2 electrical PCBs + 6 “wall” PCBs.
You can do so much with circuit boards.
I even made my business card of a 0.6mm thick PCB with an NFC chip: https://youtu.be/_BSfO9LAIqg
I have gotten LibrePCB (had to build it, as there is no package available for Kubuntu) but I haven't really had a chance to try it out. Lots of other interesting suggestions here though!
PCBs aren’t a necessary step unless you want to make many copies of your work. They basically reduce the wiring you need to do & allow for a more compact circuit than a breadboard.
Next, you will eventually ask the question of how to make a production board, where you may go down the rabbit hole of programming the AVR directly (the microcontroller), which I recommend as a jumping off point into raw microcontrollers and using an ICSP which an Arduino UNO can also do for you.
Somewhere along this path, you will want to gather some more advanced knowledge of circuits and DC fundamentals. Pick up a set of 7400 logic chips and learn how logic gates work from the lowest level possible as well as op-amps, comparators, etc.
You'll find every chip (IC or integrated circuit) speaks in either a protocol/bus or just logic levels (pins going high or low). When more than a bit or so of data is required to be transferred, ICs will implement a general-purpose digital interface like I2C (most common), SPI, or UART. There are some additional ones like I2S (for audio), 1wire (for one wire communication), CAN bus (what your car likely uses), and there are some more advanced ones like PCI (the same kind bus your PCI slots in your computer uses), MII (media independent interface), etc. Most of the time, you are just connecting together devices on a bus (for example I2C can support multiple devices because it's addressed) or finding ways to convert one to another (for example, you might want to communicate in RS232 via your UART bus).
There is also analog which is a whole different beast.
This is all a big simplification, but honestly it's not that unapproachable these days, just start small and build from there.
Had it not been for the stock shields in the Arduino world, I probably never would have gone down the rabbit hole as far as I did. That's meant as a compliment.
Beyond that is outside of my experience, but building CPUs seems to be a bit of a hobby these days. I have found Ben Eater's videos to be enlightening. I think he built a CPU at one point, but even the tutorials using a 6502 are useful since he reasons through the construction of supporting circuitry. I haven't watched much of James Sharman's work, but he is building a CPU and carrying it through to the PCB stage. The videos I've watched (related to producing video signals) included reasoning through the design process.
EDIT: I'm not suggesting the microcontroller route since it sounds like you want to explore how to build a CPU. A microcontroller is a CPU with integrated memories and peripherals, which is too high level. (Granted, if you aren't interested in a particular aspect of CPU design you can use a microcontroller to fudge it.)
I recommend reading this write-up on Fritzing: https://hackaday.com/2016/10/11/creating-a-pcb-in-everything...
I'm thankful for the recommendation for KiCAD I got out here today. It seems promising to help me take it to the next level.
(Not being snarky, looking for some clues to get me going)
My intent is to produce single and perhaps double layer prototype boards using a CNC Router and hand soldered vias.
(And yes, I tried the autorouting java package. Ive also used other routing packages. Its so much MISS and very little HIT.)
How Fritzing is killing itself - https://news.ycombinator.com/item?id=21530891 - Nov 2019 (53 comments)
Fritzing - opensource circuit sketching tool for Arduino - https://news.ycombinator.com/item?id=606567 - May 2009 (12 comments)
Where are the others?