Washington DC has a vibrant hardware hacking community and it was out in force on Saturday night. We had over one hundred people through the door at Nova Labs in Reston, Virginia (DC metro area). This sleek and spacious hackerspace opened their doors for a Hackaday Meetup as part of a weekend packed full of activities.

The building that Nova Labs moved into not too long ago is a really well-suited area for a Hackerspace. The front half of the building includes a huge open space which has plenty of room for people to set up the hardware they wanted to show off. The back has a full woodshop, machine shop, and more, with classrooms and conference rooms in between.

Above are a set of hats with addressible LED strings wrapped around them which [ArsenioDev] brought along with him. Several members of the Wyolum team are involved with Nova Labs and they were showing off some LED matrix-based projects like the marquee cube and a 3-player reaction time game. And clacking away all night long is a vintage teletype machine that [Bob Coggeshall] fixed and connected to a Raspberry Pi.

There was pizza and beer for all to enjoy. This kegerator was just outfitted with an ESP8266 module which used Amazon SNS to report each time the tap was pulled. The tablet behind is displaying real-time data on these events.

Last month when we were in Boston someone brought on an InMoov robot and there was a different one here. I haven’t run into these very often but two in a row makes me want to take a second look at the project.

And there was a freestanding photo booth but in kiosk format. It included LED panels that lit up different colors to snap a collection of [Andy Warhol]-esque colored portraits.

I’m fortunate enough to run across some of my favorite hackers in the world thanks to travels with Hackaday. It was a pleasant surprise to meet [Charles Lohr] whom you may know by the alias [cnlohr]. He’s the one who built a Minecraft server on a glass-slide PCB he fabbed himself. Recently he’s been killing it with the ESP8266, including a bare-metal programming guide he wrote for Hackaday. Above you can see him demonstrating the features he’s added to his ColorChord project. In this case it’s an ESP8266 performing DSP on an electret mic input. It drives a WS2812 strip for great visualizations while plotting the waveform on his phone via WiFi. You know… just the easy stuff.

Also on hand is Hackaday.io celeb [ArsenioDev] who was mentioned above for his blinky hat. He was showing off something much more serious though, an active control system for rockets. He’s coming along quite well with his feedback loop that pairs IMU with four servos for rocket fins. His next test will be driving a car down the runway at the local airport (with permission) while mounting the rocket on a stick for testing. Unfortunately some of this work is ITAR restricted so he’s limited on how much he can publish about the project.

There were a ton of other interesting and notable hackers on hand, like [Alex Rich] of Stickvise fame. You’ve got to make it to one of these events to understand how awesome the Hackaday community is when we’re able to get together for an evening of fun!

 The Workshops

This weekend was highlighted by a 3-day KiCAD workshop which [Anool Mahidharia] presented. I was fortunate enough to sit in and it was spectacular. I’ve used KiCAD for years and have spun boards from my design, but [Anool] is master at both PCB design and KiCAD itself.

On Friday afternoon and Saturday morning he walked everyone through a demonstration circuit based around a pair of linear regulators. He’s a remarkable teacher and included several gotchas to illustrate all aspects of KiCAD. For instance, he used a barrel jack in the design which has an oblong through-hole footprint that isn’t supported by OSH Park’s fab process. This way he was able to talk about how to change out the footprint and it was immediately applicable.

The rest of the weekend each participant worked on their own circuit and layout. I’m happy to say that everyone managed to get a design sent of for fabrication by the end day on Sunday! A render of my hastily-conceived design (I didn’t plan ahead on what I wanted to make) is seen above.

If you missed the post on Saturday, you’ll want to click through to read about the surface mount soldering workshops which [Bob] conducted several times on Friday and Saturday.

Many People to Thank

Thank you to [Bob Coggeshall] and all the Nova Labs members. They opened their door to us and made sure the place was packed and help make the event run smoothly.

[Anool] had this workshop planned long before the rest of the Hackaday ever thought of being there. Thanks for letting us join in on the fun and for making Open Hardware such a big part of what you and Wyolum do!

A big thanks to [Andrew Albosta] for taking all the photos of the meetup. He has a ton of cool builds written up on his blog, including several really cool carbon-fiber items like the wine bottle holder where were part of a composites class at Nova Labs.

And of course, thank you Hackaday Prize sponsors Atmel, Freescale, Microchip, Mouser, and Texas Instruments and to Hackaday’s parent company Supplyframe for making Hackaday live events and educational opportunities possible.

Sometime back, we announced start of a new project under the “Developed on Hackaday” series – a Badge for the Hackaday community. At its core, this badge is a single node in an Internet of Badges. At every event this badge is deployed at, a Hackaday Sub-Etha mesh network will be created, and each badge will be able to transmit and receive messages from other badge wearers. There are plans for an Sub-Etha to Internet gateway, so even if badge wearers are on the other side of the world, they’re still connected through the HaDge network.

Things have been moving along quickly, so I thought of doing a quick round-up and share progress with the community. First off, it has a name. HaDge, as in HackaDay Badge. Our objectives up until now were to set up a team, name the project, set up repositories and lock down on a working bill of materials. Within a few weeks, we’ve got all of that tied down. The HaDge group chat channel has been super active, and everyone’s been pitching in with ideas and suggestions. A spreadsheet seemed like a good idea – it let everyone add in their suggestions regarding candidate parts, create a feature list and then talk about it on the channel.

We realized early on that building the hardware is going to take some time. So in the interim, we need a dev kit platform to get in to the hands of the software developers so they can start working on the smarts that will power the HaDge. [Michele Perla] had already built JACK (Just another Cortex kit) – a development kit powered by the Atmel SAM D21. It’s pretty bare bone with just the bare minimum of parts to make it work while keeping an eye on reliability. The microcontroller+radio on the HaDge is the Atmel SAM R21 – a close relative of the D21, so it made sense to respin the JACK and create HACK (Hackaday Cortex kit) – a development kit powered by the Atmel SAM R21 that is going to be used as the core of the HaDge. [Michele] has worked hard single-handedly to complete the design and it is now ready to go for PCB fabrication soon. We are just awaiting some feedback and review of the Antenna part of the design. None of us on the hardware team have a strong RF-fu so we don’t want to make an avoidable mistake. If you’d like to review and help vet the HACK design, grab the design files from the github repo and let us know.

Once HACK board layout is cleared for fabrication, we’ll work on building kits that can be sent out to the software folks. We will also be working on porting the HACK design in to KiCad and this is something I have already stared work on. I started by using the neat Eagle2KiCad conversion tool by [LachlanA]. It’s not perfect, but it does reduce the work involved in porting over from Eagle to Kicad. Once that is done, hardware development for the actual HaDge will see some progress – keep a watch on the project page.

A couple of days back, we wrote about the HACK – a prototyping platform designed by [Michele Perla] based on the Atmel SAM R21 MCU. It’s one of the new breed of devices consisting of an ARM Cortex-M0 MCU + IEEE 802.15.4 Wireless radio bundled together. This was exciting since we could pack a lot of punch in the HaDge hardware. We planned to use the same design later to power the HaDge. Building HACK would have allowed us to get it in the hands of the software team, while the hardware folks worked on the real HaDge layout.

The HACK design was ready for review and we asked around to verify the antenna layout, which was the part we were not too sure about.  We asked Atmel for help with verifying the layout. That’s when we had the facepalm moment. They asked us – “What about FCC certification?” Since we plan to build the badges in quantities of a few hundred at the very least, it’s obvious we cannot escape from FCC certification. A design based around the R21 is ruled out – the cost of obtaining approval is pretty high. This means we need to punt the R21 and instead use an off-the-shelf radio module which is already FCC certified. Sigh.

Now the good news. This is a setback in terms of time, and effort put in by [Michele]. But beyond that, we’re good to go back to the drawing board and start afresh. First off, we decided to revert back to the Atmel D21 as the main controller. It’s a fairly decent MCU, and there’s a fairly robust tool chain available that a lot of people are familiar with. For the Radio, we are looking at some of these available options :

• https://www.anaren.com/air/products/24ghz-solutions
• http://www.nordicsemi.com/eng/Products/2.4GHz-RF
• https://www.adafruit.com/products/2471
• http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en535967

The last one from Microchip looks quite promising. But we’re open for better and cheaper suggestions, so please chime in with your comments.

Open source EDA software KiCad has been gaining a lot of traction recently. CERN has been devoting resources to introduce many new advanced features such as differential pair tracks, push and shove routing and this plenty more scheduled in the pipeline. One important requirement of EDA packages is a seamless interface with mechanical CAD packages by exporting 3D models in industry common formats. This improves collaboration and allows further engineering designs such as enclosures and panels to be produced.

KiCad has had a 3D viewer available for quite a long time. But it uses the VRML mesh format (.wrl files) and there are compatibility issues which prevent it from rendering certain versions of VRML files. Moreover, the VRML mesh export is not particularly useful since it cannot be easily manipulated in mechanical CAD software. Recent versions of KiCad now offer IDFv3 format export – the Intermediate Data Format, a mechanical data exchange specification for the design and analysis of printed wiring assemblies. Taking advantage of this new feature, [Maurice] created KiCad StepUp – an export script that allows collaborative exchange between KiCad and FreeCAD.

A FreeCAD macro and a corresponding configuration file are added to the KiCad project folder. You start with .STEP files for all the components used in the KiCad design. The next step is to convert and save all .STEP files as .WRL format using FreeCAD. On the KiCad side, you use the .WRL files as usual. When you want to export the board, use the IDFv3 option in KiCad. When [Maurice]’s StepUp script is run (outside of KiCad) it replaces all instances of .WRL files with the equivalent .STEP versions and imports the board as well as the components in to FreeCAD as .STEP models. The result is a board and its populated components which can be manipulated as regular 3D objects.

To get started, download the StepUp source from the Sourceforge repository. [Maurice] has also built a large library of 3D models designed using FreeCAD’s parametric capabilities, consisting of .STEP and .WRL models for each component. If you require additional resources, check out online services such as GrabCAD and 3DContentCentral from where you can obtain .STEP models for almost all of the commonly used components. The StepUp download contains a Demo project and User Guide to help you get started. [Maurice] also includes another FreeCAD macro to help with scaling, moving and rotating models.

The script configuration file lets you set the path to your 3D models folder and assign a color to the PCB. It’s also possible to ignore certain classes of components (such as the smallest ones or those non-critical to mechanical layout) from being imported into FreeCAD. This can be useful to reduce loading time and file sizes. We took a shot at trying out this new script and work flow, and after a few hiccups, were able to successfully perform the transfer. If you have any feedback to provide, [Maurice] is keen to hear you out over at the kicad.info forum. The forum would also be a good place to ask for any help you need with KiCad StepUp.

The first video here shows installation and use of the StepUp script and the second one demonstrates it in action exporting the CrazyFlie quadcopter from KiCad to FreeCAD.

There’s a new documentary series on Al Jazeera called Rebel Geeks that looks at the people who make the stuff everyone uses. The latest 25-minute part of the series is with [Massimo], chief of the arduino.cc camp. Upcoming episodes include Twitter co-creator [Evan Henshaw-Plath] and people in the Madrid government who are trying to build a direct democracy for the city on the Internet.

Despite being a WiFi device, the ESP8266 is surprisingly great at being an Internet of Thing. The only problem is the range. No worries; you can use the ESP as a WiFi repeater that will get you about 0.5km further for each additional repeater node. Power is of course required, but you can stuff everything inside a cell phone charger.

I’ve said it before and I’ll say it again: the most common use for the Raspberry Pi is a vintage console emulator. Now there’s a Kickstarter for a dedicated tabletop Raspi emulation case that actually looks good.

Pogo pins are the go-to solution for putting firmware on hundreds of boards. These tiny spring-loaded pins give you a programming rig that’s easy to attach and detach without any soldering whatsoever. [Tom] needed to program a few dozen boards in a short amount of time, didn’t have any pogo pins, and didn’t want to solder a header to each board. The solution? Pull the pins out of a female header. It works in a pinch, but you probably want a better solution for a more permanent setup.

Half of building a PCB is getting parts and pinouts right. [Josef] is working on a tool to at least semi-automate the importing of pinout tables from datasheets into KiCad. This is a very, very hard problem, and if it’s half right half the time, that’s a tremendous accomplishment.

Last summer, [Voja] wrote something for the blog on building enclosures from FR4. Over on Hackaday.io he’s working on a project, and it’s time for that project to get an enclosure. The results are amazing and leave us wondering why we don’t see this technique more often.

If you’re a KiCad user, as many of us here at Hackaday are, you’ll be elated to hear that KiCad 4.0 has just been released! If you’re not yet a KiCad user, or if you’ve given it a shot in the past, now’s probably a good time to give it a try. (Or maybe wait until the inevitable 4.0.1 bugfix version comes out.)

If you’ve been using the old “stable” version of KiCad (from May 2013!), you’ve got a lot of catching-up to do.

The official part footprint libraries changed their format sometime in 2014, and are all now hosted on GitHub in separate “.pretty” folders for modularity and ease of updating. Unfortunately, this means that you’ll need to be a little careful with your projects until you’ve switched all the parts over. The blow is softened by a “component rescue helper” but you’re still going to need to be careful if you’re still using old schematics with the new version.

The most interesting change, from a basic PCB-layout perspective, is the push-and-shove router. We’re looking for a new demo video online, but this one from earlier this year will have to do for now. We’ve been using various “unstable” builds of KiCad for the last two years just because of this feature, so it’s awesome to see it out in an actual release. The push-and-shove router still has some quirks, and doesn’t have all the functionality of the original routers, though, so we often find ourselves switching back and forth. But when you need the push-and-shove feature, it’s awesome.

If you’re doing a board where timing is critical, KiCad 4.0 has a bunch of differential trace and trace-length tuning options that are something far beyond the last release. The 3D board rendering has also greatly improved.

Indeed, there are so many improvements that have been made over the last two and a half years, that everybody we know has been using the nightly development builds of KiCad instead of the old stable version. If you’ve been doing the same, version 4.0 may not have all that much new for you. But if you’re new to KiCad, now’s a great time to jump in.

We’ve covered KiCad hacks before, and have another article on KiCad add-on utilities in the pipeline as we write this. For beginners, [Chris Gammell]’s tutorial video series is still relevant, and is a must-watch.

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.

KiPart

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

KiCost

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.

One barrier for those wanting to switch over from Eagle to KiCad has been the lack of a way to convert existing projects from one to the other. An Eagle to KiCad ULP exists, but it only converts the schematic, albeit with errors and hence not too helpful. And for quite some time, KiCad has been able to open Eagle .brd layout files. But without a netlist to read and check for errors, that’s not too useful either. [Lachlan] has written a comprehensive set of Eagle to KiCad ULP scripts to convert schematics, symbols and footprints. Board conversion is still done using KiCad’s built in converter, since it works quite well.

Overall, the process works pretty well, and we were able to successfully convert two projects from Eagle. The entire process took only about 10 to 15 minutes of clean up after running the scripts.

The five scripts and one include file run sequentially once the first one is run. [Lachlan]’s scripts will convert Eagle multi sheet .sch to KiCad multi sheets, place global and local net labels for multi sheets, convert multi part symbols, build KiCad footprint modules and symbol libraries from Eagle libraries, create a project directory to store all the converted files, and perform basic error checking. The Eagle 6.xx PCB files can be directly imported to KiCad. The scripts also convert Via’s to Pads, which helps with KiCad’s flood fill, when Via’s have no connections – this part requires some manual intervention and post processing. There are detailed instructions on [Lachlan]’s GitHub repository and he also walks through the process in the video.

Work on HaDge – the Hackaday con badge, continues in bits and spurts, and we’ve had some good progress in recent weeks. HaDge will be one conference badge to use at all conferences, capable of communicating between badges.

Picking up from where we left off last time, we had agreed to base it around the Atmel D21, a 32-bit ARM Cortex M0+ processor. To get some prototype boards built to help with software development, we decided to finish designing the HACK before tackling HaDge. HACK is a project that [Michele Perla] started that we have sort of assimilated to act as the prototyping platform for HaDge. We wanted a compact micro-controller board and hence opted for the SAM D21E – a 32 pin package with 26 IO’s.

[Michele Perla] had earlier designed HACK based on the larger 32 pin SAM D21G and used Eagle to draw the schematic and layout. Using the Eagle to KiCad script, he quickly converted the project and got on to making the board layout. I took up the rear guard, and worked on making his schematic (pdf) “pretty” and building up a schematic library of symbols. While [Michele] finished off the board layout, I worked on collecting STEP models for the various footprints we would be using, most of which I could get via 3dcontentcentral.com. The few I couldn’t were built from scratch using FreeCAD. The STEP models were converted to VRML using FreeCAD. Using [Maurice]’s KiCad Stepup script, we were able to obtain a complete STEP model of the HACK board.

HACK is now ready to go for board fabrication and assembly. We plan to get about 20 boards made and hand them out to developers for working on the software. The GitHub repository has all the current files for those who’d like to take a look – it includes the KiCad source files, PDFs, gerbers, data sheets and images. The board will be breadboard compatible and also have castellated pads to allow it to be soldered directly as a module. Let us know via group messaging on the HACK project page if you’d like to get involved with either the software or hardware development of HaDge.

In a forthcoming post, we’ll put out ideas on how we plan to take forward HaDge now that HACK is complete. Stay tuned.

Recently I’ve been getting curious about interesting PCB shapes. In the past I’ve always used simple Polygons, perhaps rounding out the corners to make the design a little more aesthetically pleasing. The board to the right was my introduction to the possibilities of oddly shaped boards. It’s designed to couple with a piezo buzzer (used as an actuator). I’ve been planning to have it fabricated out of FPC (Flexible Printed Circuits), but with fabrication being so cheap I sent it to OSHPark to see what they’d make of it. OSHPark doesn’t have hard specs around internal routing, but in my experience they’re up to try anything (and they’re quality is always great). The width of the prongs on the PCB shown is 5mm. I figured it was a risk, and that it was likely the FR4 could break, but it came back great!

This has led me to the realization that my boards could look much more exciting than they do currently, and that our highly optimized modern PCB fabrication process provides a lot of room for experimentation. This article will discuss some of the options available when creating non-traditional PCBs.

The board to the left is for a simple solar lantern. The LEDs sit on the end of the wiggly tracks, with the driver IC sitting in the center. I designed it to try and push the process, see if a PCB could be made to look a little less sterile and more like a craft object. The traces going to the LEDs were left unmasked, to allow them to come out in gold with ENIG. I think the fabricated board looks ok, but for the next revision I’ll retain more mask, which should make the traces stand out. Gratifyingly I now have an even better idea of the weird board shapes OSHPark can cope with (and will try and push the process even further).

Most layout tools, KiCad included, are not designed with the fabrication complex edges or components in mind. While the edges in the coupler above were created in KiCad it was an unpleasant process. So for the solar lantern I opted for external tools.

First, I designed the flower shaped edge cut in Inkscape. In recent versions of KiCad it’s pretty easy to import the edgecuts. Firstly create your edges in Inkscape, ensure that the design is a simple line drawing and save it as a DXF file. Then just select “File->Import->DXF” in KiCad, and import the DXF into the Edges layer.

Creating wiggly traces in KiCad is more difficult, in fact it’s not possible. KiCad has no concept of non-straight traces, and limited pad geometries.

KiCad incorporates a tool called “Bitmap2Component” while many have used this to good effect to add logos to their boards it’s not ideal when working with vector image data and has limited functionality. To solve this shortfall we look to svg2mod. This tool allows you to convert an svg into a KiCad footprint using a simple command line tool. On Linux you can use it as follows:

./svg2mod.py -i ~/design.svg -o ~/design.mod -p 0.1

As KiCad only uses straight lines, the curves in your original svg will be broken down into straight line segments. The “-p” parameter determines how many segments a curve is broken into, and may require some experimentation. svg2mod works with layered svg files. You can create separate layers in your svg for copper, mask and silk, producing complex component footprints. For the PCB above I used this to remove the mask from all the wiggly traces. Eagle users may want to check out svg2poly which appears to provide similar functionality.

This is my first attempt at creating more aesthetically pleasing boards, but Saar at Boldport has been making great looking PCBs for years.

Some of his designs (like the one shown to the right). Are hardly recognizable as a slab of FR4. Marie Claire commissioned this and other boards like it for a photo shoot called Haute circuits, which used the boards as a backdrop for pieces of luxury jewelry.

Boldport’s designs are always unique and beautiful. Characteristically, there’s never a straight trace to be found. Producing such designs in a traditional layout package would be almost impossible.

For this reason Saar took the audacious step of designing his own layout software from scratch. The tool is called PCBMode and is free and open source. It’s very much designed for Saar’s unique workflow and takes a little getting used to, but is worth checking out.

Rather than having its own interface PCBMode schematics are represented in a series of JSON files. These are then processed into an SVG which can be edited in Inkscape to produce an aesthetically pleasing design. The svg is then finally processed to create gerbers ready for fabrication.

PCBMode produces beautiful boards, but takes a significant investment of time to get used to. If you enjoy PCBMode’s beautiful boards, you might want to check out Saar’s beautiful kits which he’ll be providing on subscription starting in March. All lovingly designed in PCBMode.

There’s one more time honored tradition we should mention, albeit with a modern twist. Before the rise of computerized layout tools, it was of course pretty common to layout boards by hand.

These old boards with their wildly irregular (generally maskless) tracks still have a certain visual appeal. For hackers etching at home this is of course easy to replicate. But you can also accomplish a similar aesthetic using a commercial fab and a tool to convert svgs directly to gerbers.

For this purpose Cenon works well.. You’ll have to separately create and convert svgs for each layer and edges. You’re also left with the problem of creating your own drill file. Of the processes I’ve investigated so far, svg2mod with KiCad works best for me, allowing you to easily create complex, multi-layered vector component footprints in Inkscape to be imported into KiCad and combined with more traditional circuit elements. The process of creating and importing footprints and edges works well, even if it’s a slightly clunky process.

I’d love to hear about your favorite innovate PCB layouts, and any tools you’ve found to aid in the process of designing novel PCBs. Please comment below!

When boards were larger and components mostly through hole, designers could put a lot of information on the silk legend – reference designator, values, additional text and so on. But with surface mount components becoming smaller and board real estate at a premium, modern boards do not have a lot of information marked on the silk layer. If you are building and distributing a short run of kits, perhaps for a round of beta testing, then [Adam Greig]’s StickerBOM python script for KiCad can be really handy. StickerBOM is a KiCad BOM exporter designed for people stuffing boards by hand. It generates a PDF for printable sticky labels, where each label reflects one BOM line from a supplier. You then stick these labels on the bags from your supplier, and they show you where the parts go.

The labels get printed with the reference designator, quantity, component value, package, vendor and part number. It also adds a drawing of the PCB with the relevant parts highlighted for easy location identification. To use it, schematic symbols must have the supplier field and part number added. The script can be run from the command line, or from the BOM manager in eeschema. The script is set up for Avery L7164 labels, but this setting can be changed. It’s still work in progress so there’s a couple of bugs to be aware of. It cannot process the bottom layer of the board, and the result is only as good as the data you provide. And if you have a large board with components spread all over, the resultant graphic printed on the label may not be ideal.

We are hoping this, and other scripts such as the Part generator and Cost spreadsheets or the script for mechanical CAD export, get added to future releases of KiCad. The KiCad version 5 Developer’s road map document already has some really nice feature additions in the works.

KiCad ya es una gran herramienta para la captura esquemática y el diseño de PCB, pero el software sólo funciona si es posible utilizarlo. Para los mil millones de personas que no hablan inglés, esto significa que el idioma es la barrera más grande al momento de utilizar el mejor software para desarrollo de hardware. En los últimos meses, [ElektroQuark] ha estado liderando esfuerzos de localización al español de KiCad y estos se encuentran finalmente completados. También ha iniciado un foro de KiCad en idioma español para llevar el desarrollo de software hacia uno de los idiomas más hablado del planeta.

Mientras que ha habido otros intentos por localizar KiCad a otros idiomas, la mayoría de estos proyectos se encuentran incompletos. En una actualización de KiCad hace algunos meses, la localización al español ya contaba con algunas cadenas ya traducidas, pero no demasiadas. Los esfuerzos de [ElektroQuark] han acercado KiCad a millones de hablantes nativos de español, no solo algunos de sus menús.

El español es la segunda lengua más hablada del planeta, mientras que el inglés es la tercera. Teniendo en cuenta solamente este hecho, parece absurdo que casi todas las herramientas de software para capturas esquemáticas y diseño de PCB sean localizados sólo al chino o al inglés. Los esfuerzos de [ElektroQuark] por localizar KiCad al español son un gran avance para un ya impresionante software.

KiCAD remains a popular tool for designing PCBs and other circuits, and with good reason: it’s versatile and it’s got pretty much everything needed to build any type of circuit board you’d want. It also comes with a pretty steep learning curve, though, and [Jeff] was especially frustrated with the bill of materials (BOM) features in KiCAD. After applying some Python and Kivy, [Jeff] now has a BOM manager that makes up for some of KiCAD’s shortcomings.

Currently, the tool handles schematic import, like-component consolidation, and a user-managed parts database that can be used to store and retrieve commonly used parts for the future. All of the changes can be saved back to the original schematic. [Jeff] hopes that his tool will save some time for anyone who makes more than one PCB a year and has to deal with the lack of BOM features native to KiCAD.

[Jeff] still has some features he’d like to add such as unit tests, a user guide, and a cleaner user interface. What other features are you anxious to see added to KiCAD?

This script is a great tool for anyone who has had similar frustrations. KiCAD is popular to modify and expand, too: there have been tools for mechanical CAD export, a parts-generator and cost-tracker, and an Eagle to KiCAD converter if you’re thinking of making the switch.

Chris Gammell is a guy that should need no introduction around these parts. He’s a co-host on The Amp Hour, and the guy behind Contextual Electronics, a fabulous introduction to electronics and one of the best ways to learn KiCad. If you want to talk about the pedagogy of electronics, this is the guy you want.

Chris’ talk at the Hackaday | Belgrade conference was on just that – the pedagogy of electronics. Generally, there are two ways to learn how to blink an LED. The first, the bottom-up model taught in every university, is to first learn Ohm’s law, resistance, current, voltage, solve hundreds of resistor network problems, and eventually get around to the ‘electrons and holes’ description of a semiconductor. The simplest semiconductor is a diode, and sometime in the sophomore or junior year, the student will successfully blink a LED.

The second, top-down method is much simpler. Just wire up a battery, resistor, switch, and LED to a breadboard. This is the top-down model of electronics design; you don’t need to know everything to get it to work. You don’t need to do it with a 555, and you certainly don’t have to derive Maxwell’s equations to make something glow. Chris is a big proponent of the top-down model of learning, and his Belgrade talk is all about the virtues of not knowing everything.

Chris begins his example by going through the process of building a car. In the bottom-up model, you would begin building a car by first learning thermodynamics. The top-down method of building a car is much simpler – you don’t need to know thermodynamics to build an engine, because you can just buy an engine and put it in a chassis. For every part you need, you can just go to the car store and buy some wheels, an engine, and a steering wheel.

For every electronic project you build, each piece of your block diagram is available as a module. If you need a boost converter, that’s a black box you can buy from Digikey, Mouser, or China. If you need a better boost converter, you’re still able to design your own, but you’re not starting by learning all the theory.

Chris’ solution to learning electronics isn’t learning theory and equations. This gives you tunnel vision, a simple problem – an LED that fails to light – leads to a rabbit hole of textbooks and Wikipedia. Four hours later, the student still has no idea why the LED doesn’t work and is simply aggravated. Instead, Chris suggests taking things apart and looking at how they work. This takes the learning process up one abstraction layer, and after looking at a few dozen circuits with LEDs, the problem isn’t one of remembering equations and theory. The problem becomes pattern matching. Humans are very, very good at matching patterns, making this the ideal way to learn.

Effectively, this is Just In Time learning – you don’t need to know everything at the start, you just need to know what to do to get to the next step. How do you do this? Expert systems, or more specifically, the Hackaday.io community, the EEVblog forums, or any of a dozen other electronics communities around the web.

Compared to learning a bunch of theory and then futzing around trying to get a circuit to work, Chris is saying you should dive in and iterate quickly. It’s not going to change the pedagogy of universities, but it will get you blinking an LED faster, and that’s what we’re all about anyway.

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!

[Via Hacker News]

Gerrit and I were scoping out the Intel booth at Bay Area Maker Faire and we ran into Nolan Moore who was showing of his work to mash together a Nintendo Power Glove with an AR Drone quadcopter. Not only did it work, but the booth had a netted cage which Nolan had all to himself to show off his work. Check the video clip below for that.

The control scheme is pretty sweet, hold your hand flat (palm toward the ground) to hover, make a fist and tilt it in any direction to affect pitch and roll, point a finger up or down to affect altitude, and point straight and twist your hand for yaw control. We were talking with Nolan about these controls it sounded sketchy, but the demo proves it’s quite responsive.

The guts of the Power Glove have been completely removed (that’s a fun project log to browse through too!) and two new boards designed and fabbed to replace them. He started off in Eagle but ended up switching to KiCAD before sending the designs out for fabrication. I really enjoy the footprints he made to use the stock buttons from the wrist portion of the glove.

A Teensy LC pulls everything together, reading from an IMU on the board installed over the back of the hand, as well as from the flex sensors to measure what your fingers are up to. It parses these gestures and passes appropriate commands to an ESP8266 module. The AR Drone 2.0 is WiFi controlled, letting the ESP8266 act as the controller.

Is your business card flashy? Is it useful in a pinch? Do they cost $32 each and come with an ePaper display? No? Well, then feast your eyes on this over-the-top business card with an ePaper display by [Paul Schow]. Looking to keep busy and challenge himself with a low-power circuit in a small package, he set about making a business card that can be updated every couple of months instead of buying a new stack whenever he updated his information.

Having worked with ePaper before, it seemed to be the go-to option for [Schow] in fulfilling the ultra-low power criteria of his project — eventually deciding on a 2″ display. Also looking to execute this project at speed, he designed the board in KiCad over a few hours after cutting it down to simply the power control, the 40-pin connector and a handful of resistors and capacitors. In this case, haste made waste in the shape of the incorrect orientation of the 40-pin connector and a few other mistakes besides. Version 2.0, however, came together as a perfect proof-of-concept, while 3.0 looks sleek and professional.

[Schow] advises the assistance of a magnifying glass or microscope in soldering to such a small board — lucky for him there was one available at the nearby TinkerMill – The Longmont Makerspace. He also ran into trouble with the display dimming due to lack of power, but solved it by adding a TLV61225DCKR boost converter. A light on the back flashes when the image is being changed for added effect. While this is a singular and ‘usefulness optional’ business card, don’t hand too many of these out if you care for your wallet.

For other cool electronic business cards, check out this mass-storage business card — or maybe this emergency toolkit card!

You know about the Hackaday Superconference, right? It’s the greatest hardware con ever, and it’s happening on November 5+6. Details incoming shortly.

The Hackaday Retro Edition exists. It’s the Hackaday blog, HTML-1-izized for weird and old computers? Why did I do this? Because Google is the quickest page to load on a Powerbook 180. There’s a new Retro Success, this time coming from @LeSpocky and his Nokia 3109c phone from 2008.

This is your official notice. The Open Hardware Summit is less than a month away. It’s going down in Portland, OR. Why Portland? The Ｖａｐｏｒｗａｖｅscene, of course. Hackaday, Tindie, and the rest of the crew will be out in Portland next month getting the latest news on the state of Open Hardware. We won’t be sitting in church pews this year, but then again there is no lady made out of soap.

Speaking of OHS, [Dave] just solved all their problems. The ‘problem’ with Open Hardware, if you can call it that, is that people use it as a bullet point on a sales deck. That neat gear logo can be marketing wank, without any of the sources, schematics, or anything else that makes a project Open Hardware. Last year, OSHWA announced they would be creating a certification process, with a trademarked logo, so they can sue people who don’t post schematics and mechanical designs (slightly inaccurate, but that’s the jist of the program). [Dave] is suggesting keeping the cool gear logo, but adding letters the teeth of the gear to designate what makes something Open Hardware. Add an S for schematic, add a B for a BOM, sort of like the creative commons logo/license. Is it a good idea? If OSHWA keeps using the gear logo for the ‘official’ Open Hardware logo/designation, there’s no recourse for when people misuse it. I’m of several minds.

[Colin Furze] is famous for his zany builds. His latest Youtube is anything but. It’s a shed. Of course, it’s the entry for his underground bunker, but this is a quality shed with a concrete pad, a few bits to keep it off the ground, and insulation. The roof is slate (because why not?), but if your design decisions are based on the phrase, ‘you only live once,’ copper may be a better choice.

The ESP32 has been released. The ESP32 is the follow-on to the very popular ESP8266. The ’32 features WiFi and Bluetooth, dual core processors, and a few undisclosed things that will make it very interesting. You can buy ESP32 modules right now, but no one has them on their workbench quite yet. To get you started when they finally arrive, [Adam] created an ESP32 KiCad Library for the ESP32 chip, and the ESP32-WROOM and ESP3212 modules.

You do not know how to make a PCB unless you can make your own parts. [Jan] knows this, but like everyone else he checked out the usual online sources for a footprint for an SD card socket before making his own. It turns out, this SD card socket bought from an online marketplace was completely undocumented. Not only was an Eagle or KiCad footprint unavailable, but CAD files showing the dimensions of the part were non-existent. A solution had to be devised.

Instead of taking calipers and finely measuring all the pads on this SD card socket – a process that would surely fail – [Jan] decided to use a flatbed scanner to trace out the part. The part was placed on the glass and scanned at 300 dpi with a convenient reference object (a public transport card) in the same picture. This picture was imported into a CAD package, scaled to the correct ratio, and exported as a DXF. Since KiCad readily accepts importing DXFs, the CAD file was easily accessed, traced over, and a new part created.

From start to finish, making the footprint for this no-name, off-brand SD card socket took fifteen minutes. That’s nothing compared to the time it would take to manually measure each of the pads, draw a footprint, and print out the footprint at 1:1 scale to see if it matched up several times. It’s awesome work, and a great reminder that the best tools are usually right in front of you.

[Elliot] (no relation, but hey, cool name!) wrote in with his OpenFixture model for OpenSCAD. It’s awesome because it takes a small problem, that nonetheless could consume an entire day, and solves it neatly. And that problem is making jigs to test assembled electrical products: a PCB test fixture.

In the PCB design software, you simply note down the locations of the test points and feed these into the OpenSCAD model. ([Elliot] shows you exactly how to do it using KiCAD.) There are a few more parameters of the model that you can tweak to match your particulars, but you should have a DXF outline for a test jig in short order. Cut that out, assemble, and test.

If you have to make more than a few handfuls of a complicated circuit, it becomes worth it to start thinking about testing them systematically. And with this OpenSCAD model, you can have the test jig up and running before the first prototype boards are back in from the fab. How cool is that?