KiCAD has been making leaps and bounds recently, especially since CERN is using it almost exclusively. However, while many things are the same, just enough of them are different from our regular CAD packages that it’s hard to get started in the new suite.
[Chris Gammell] runs Contextual Electronics, an online apprenticeship program which goes from concept to assembled electronics covering everything in between. To take the course you pay a nominal fee, but [Chris] posted a very excellent ten-part video series made during the last run of classes which you can watch without charge. The videos go through the basics of KiCAD while hitting the major points to consider when designing and manufacturing your electronics.
The project [Chris] chose is a simple circuit that blinks an LED with a 555. The first videos cover navigating KiCAD’s component schematic editor and library system. Next comes creating circuit schematics and component footprint creation. [Chris] covers PCB layout, the generation of Gerber files, and finally ordering the design from OSH Park — the purveyors of purple boards we’ve come to know and love. The series finishes up with simulating the circuit in LTSpice, ordering the parts, and finally soldering and debugging of the board. If all goes correctly you should now have a single blinking LED.
If the bright summer sun is burning your delicate skin, and you’d rather be locked inside with solder fumes, add this to your watch list now!
Continue reading “It’s Time to Finally Figure Out How to Use KiCAD”
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”
Making that final push to button up your projects can be a bit daunting. It’s kind of like the punch list on a construction project — add switch plates, fill nail holes in baseboards, screw in light bulbs, clean windows — that stuff adds up quickly. But having a set of best practices in mind throughout the development phase will cut down on that burden. [Caleb P.] just published a quick guide using a recent project as an example.
First and foremost is the label seen on the project box lid. How many times have you pulled out a circuit board from a year or two earlier and not been able to figure out the pinout? As with ancient televisions and radios, including the service schematic will save you big time! He also mentions that the size and orientation of the components in the case was in the back of his mind the whole time. That paid off because everything fits like a glove. [Caleb] makes sure the battery is easy to get to, and the each component has some type of connector so that it may be removed and serviced/replace without soldering. There’s certainly nothing groundbreaking in this guide. But ask yourself: have I been following all of these guidelines in my own work?
This heavily populated PCB is a recreation of the original arcade version of Pong. That is an important distinction because the home version of Pong used a specialized chip to do much of the work. This is basically all stock logic, which explains the high component count. We wonder how many quarters it took just to pay for all 66 chips at the time?
[Pong74ls] was the person who took on this project. There is an original schematic available, but it’s incredibly crowded and rather difficult to figure out. Fortunately [Dan Boris] has already done a lot of the heavy work. He took the one-page nightmare and turned it into a sixteen page plan for building the original board (look for the schematic link under technical details).
Before the board could be laid out some redesign work was necessary. It sounds like some of the original chips are out of production and suitable replacements needed to be found. The board was then laid out in Eagle before sending the design off to a fab house. There was just one error which didn’t allow the ball to bounce when hitting a paddle while travelling downward. A couple of jumper wires fixed that right up!
[Original Reddit Post]
We’re really not supposed to start a feature like this; but this hack is awesome. It’s a game of Snake implemented by an FPGA dev board. It uses a 16×16 LED matrix as the display and an SNES controller for input. So far it sounds like a very normal version of the game. But as you start to hear how it works in the presentation after the break you fall in love with what’s going on here.
First of all, it’s not written in VHDL — the predominant programming language for FPGAs. Instead, [Darrell] used the schematic-only approach to build the logic. Okay, that’s starting to get more interesting. As he continues to explain the circuit we get to see how the control input works (pretty simple since the SNES controller uses a parallel-to-serial shift register) and how the display is multiplexed. But the actual game logic is where things really take off. Each pixel in the display has its own individual logic circuit. Basically every cell is its own processor which reacts both to what is passed into it, as well as to a random seed. That seed system is called the ‘bucket brigade’ and passes a chance to spawn a piece of food from one cell to the next. All of this together makes for one simple game that is eloquently executed. Continue reading “FPGA Snake game uses no VHDL at all”
Version 6 of the popular schematic and PCB layout software EAGLE is now in beta testing. The most notable change is the migration to XML file formats that we looked at last month.
[PT] didn’t waste any time getting his hands on the software and giving it a thorough test drive. The image seen above shows the files of a MintyBoost. It’s impossible to make out at this resolution, but it is indeed spitting out human-readable (well maybe) XML in the windows below instead of the ‘no trespassing’ binaries they used to use.
Earlier today when working on a feature we had to jump on a different computer that had EAGLE installed in order to look at a .SCH file. We wonder if someone will put out a rendering package that can parse the new format and spit out a quick PNG? At the very least, we expect to see some useful hacks for part replacement or pin swapping. It shouldn’t be too hard to poke around and figure out what happens when changing some of the stored values. Got anything in mind that you can do by editing these by hand?
Oh, we almost forgot! The biggest benefit you get from this is the increased version control compatiblity since programs like git will be able to perform diff functions on the files.
Occasionally when a device breaks, the defect is obvious. Whether it is a blown fuse or a defective capacitor, generally the easy to see stuff is easy to fix. When a problem is more subtle, or when doing some more advanced tasks like adding functionality to a device, greater knowledge about a circuit board is required. While there might be details hidden in lower levels of PCB, often just knowing the mounted components and layout of the outside layers can be enough to create a rough schematic of a device. [Throbscottle] has put together an excellent guide for procedurally breaking down a photo of a board and turning it in to something useful. The guide utilizes some open source image processing software such as the GIMP, Inkscape, and Dia, all of which are widely available. Keep in mind this reverse engineering can be a time consuming process, but will almost definitely reward those patient enough to work through it.
[Thanks to everyone who sent this in!]