The lingua franca of electronic design is the schematic. I can pick up a datasheet written in Chinese (a language I do not read or speak) and usually get a half-decent idea of what the part is all about from the drawings. Unfortunately, even as my design experience has grown over the years, I haven’t quite learned to think in schematics — I need to see it on paper (or on a screen) to analyze a circuit. Whether it’s literally on the back of an envelope or sketched in the condensation on the shower stall, actually drawing a design or idea makes a huge difference in being able to understand it. And, if you’ve ever tried to explain a circuit without a schematic — in an on-line forum or over the phone, for instance — you know how difficult it is.
So, given the importance of the schematic for design and communication, you’d think choosing a tool to draw them would be an easy task. Not so. There are dozens of choices, from dedicated schematic drawing programs to using the schematic-capture facilities of simulation or PCB design tools, or even old-fashioned pencil-and-paper and its modern equivalents. Each one has its pros and cons, and may be better suited to one specific application, but you have to choose something.
So, readers of Hackaday, what do you use to convey your electronic design ideas to the world?
Continue reading “Ask Hackaday: How Do You Draw Schematics?”
Last time we talked about a KiCAD tool it was to describe a way to make the zen-like task of manual assembly more convenient. But what about that most onerous of EE CAD tasks, part creation? Home makers probably don’t have access to expensive part library subscriptions or teams of people to create parts for them, so they are left to the tedium of creating them by hand. What if the dream tool existed that could read the darn PDF by itself and make a part? It turns out [Sébastien] made that tool and it’s called uConfig.
uConfig has a pretty simple premise. It scrapes manufacturer datasheets in PDF form, finds what it thinks are diagrams of parts with pin names, functions, etc, and emits the result as parts in a KiCAD library. To aid in the final conversion [Sébastien] added rules engine which consume his custom KiCAD Style Sheets which specify how to categorize pins. In the simple case the engine can string match or use regex to let you specify things like “all pins named VDD[A-C] should be power pins”. But it can also be used to move everything it thinks belongs to “GPIOB” and stick them on the bottom of the created symbol. We could imagine features like that would be of particular use breaking out gigantic parts like a 400 ball BeagleBone on a chip.
Thanks for the tip [arturo182]!
The popularity of KiCad keeps increasing, and not only are more people converting to it and using it for their projects, but there’s also a growing number of folks actively contributing to the project in the form of libraries, scripts and utilities to improve the work flow.
[Dave Vandenbout] a.k.a [xesscorp] has written a couple of utilities for KiCad. When working with large multi pin parts such as micro-controllers, creating a schematic symbol from scratch using the traditional KiCad schematic library editor can be quite tedious. KiPart is a python script that uses a CSV table as its input to generate the KiCad schematic symbol and is able to create multi-part symbols too. Usage is quite simple. The csv file needs a part name on its first row. The next row contains the headers. ‘Pin’ number and Pin ‘Name’ are the minimum required. Additionally, you can add in ‘Unit’, ‘Side’, ‘Type’, and ‘Style’. Unit is used when defining multi-unit parts. Side decides the location of the pin, Type its function, and Style is its graphic representation. Running the KiPart python script then results in a nice KiCad schematic symbol. Besides, KiPart can specifically generate schematic symbols for the Xilinx 7-Series FPGAs and the Cypress PSoC5LP. There are a whole host of options to customize the final output, for example ordering pin placement based on pin number, or pin name or pin function. Source files can be obtained from the [xesscorp] Github repository.
Another useful utility from [xesscorp] is KiCost. It is intended to be run as a script for generating part-cost spreadsheets for circuit boards developed with KiCad. The one piece of information you need to add to your schematic parts is a manufacturers part number. The KiCost Python script then processes the BOM XML file, reading the manufacturer part number, scraping the web sites of several popular distributors for price and inventory data, and creating a costing spreadsheet. You can grab the source files from the KiCost Github repository.
Check the two videos below where [Dave] walks through the two utilities.
Thanks to [RoGeorge] for sending in this tip by commenting on the Open Source FPGA Pi Hat built by [Dave] that we featured recently.
Continue reading “KiCad Utilities Generate Parts; Track Costs”
A lot of great schematics wind up on the back of bar napkins or diner place mats. When inspiration strikes, you have to capture it, after all. Today, you are as likely to draw schematics on a computer and there are plenty of options for that; if you can install software your options are almost limitless. And if you have a modern Web browser, there are lots of good options that don’t even require an install.
Continue reading “The Worst CAD Package Ever Is Still Handy”
The guys over at hackshed have been busy. [Carl] is making programmable logic design easy with an 8 part CPLD tutorial. (March 2018: Link dead. Try the Wayback Machine.) Programmable logic devices are one of the most versatile hardware building blocks available to hackers. They also can have a steep learning curve. Cheap Field Programmable Gate Arrays (FPGA) are plentiful, but can have intricate power requirements. Most modern programmable logic designs are created in a Hardware Description Language (HDL) such as VHDL or Verilog. Now you’ve got a new type of device, a new language, an entirely new programming paradigm, and a complex IDE to learn all at once. It’s no wonder FPGAs have sent more than one beginner running for the hills.
The tutorial cuts the learning curve down in several ways. [Carl] is using Complex Programmable Logic Devices (CPLD). At the 40,000 foot level, CPLDs and FPGAs do the same thing – they act as re-configurable logic. FPGAs generally do not store their configuration – it has to be loaded from an external FLASH, EEPROM, or connected processor. CPLDs do store their configuration, so they’re ready as soon as they power up. As a general rule, FPGAs contain more configurable logic than CPLDs. This allows for larger designs to be instantiated with FPGAs. Don’t knock CPLDs though. CPLDs have plenty of room for big designs, like generating VGA signals.
[Carl] also is designing with schematic capture in his tutorial. With the schematic capture method, digital logic schematics are drawn just as they would be in Eagle or KiCad. This is generally considered an “old school” method of design capture. A few lines of VHDL or Verilog code can replace some rather complex schematics. [Carl’s] simple designs don’t need that sort of power though. Going the schematic capture route eliminates the need to learn VHDL or Verilog.
[Carl’s] tutorial starts with installing Altera’s Quartus II software. He then takes the student through the “hardware hello world” – blinking an LED. By the time the tutorial is done, the user will learn how to create a 4 bit adder and a 4 bit subtractor. With all that under your belt, you’re ready to jump into big designs – like building a retrocomputer.
[Image via Wikimedia Commons]