Skip to content
Oct 27 14

“Run After Tests” Plugin for IntelliJ IDEs

by Wayne

blink(1) is an open source hardware USB RGB LED indicator by ThingM. I wrote a plugin “Run After Tests” for IntelliJ-based IDEs like PyCharm and CLion so it can display the status of your tests as different colors.

blink(1), an open source hardware USB RGB LED indicator

blink(1), an open source hardware USB RGB LED

The blink(1) has a variety of control mechanisms, including a command-line tool, blink1-tool. It’s as open source as things come, really, and it’s by Mike Kuniavsky and Tod E. Kurt. I’ve talked with Tod a few times–we were stationed in the Maker Shed next to each other at a few Bay Area Maker Faires, so when I saw a tweet where someone got blink(1) working with a Ruby IDE to indicate test status, I decided to extend the blink(1) ecosystem and write a plugin for my favorite IDEs.

While I still write a lot of code in vim, if I’m not in vim, I’m in PyCharm or CLion. PyCharm and CLion are tools by JetBrains, and are based upon the IntelliJ IDE. IntelliJ is written in Java, something I don’t particularly enjoy working with, but it’s a testament to how great PyCharm and CLion are that they don’t trigger my Java allergy.

Today, I spent a little more than an hour, opened some docs, and wrote an IntelliJ plugin “Run After Tests” for automatically running arbitrary commands after a test suite completes, with one configuration for when all the tests pass, and a second configuration for one when some of the tests fail. It seems to work for me.

I can see this being used a few different ways–including with blink1-tool so I can see the status of my tests at a glance!

I have posted the project and a binary release, and I’d appreciate some feedback. I would like to submit it to the JetBrains Plugin Repository, but I want to make sure the tool works for other folks first.

After writing the plugin and testing it, I purchased two blink(1)s. As soon as they arrive, I’ll update the post with the two commands you’ll need to get this working with a blink(1).

Sep 21 14

Kicad converter for TM-240A Pick-and-Place machines

by Layne


In the summer of 2014, Wayne and Layne purchased a Pick-and-Place machine, specifically the Neoden TM-240A. After doing a few small prototype production runs, we decided to create a presentation at the 2014 World Maker Faire in NYC, to share the tips and tricks we’ve learned about working with this PnP machine, as well as an honest analysis of its capabilities, strengths, and limitations. You can also download our slides (PDF). The PDF slides don’t include the embedded video, but that video has been posted to YouTube.

The Pick-and-Place machine needs to know where to place each part, and we have created some software to help convert the PCB design data from our favorite ECAD tool, KiCad, into the proper file format needed for these PnP machines. The documentation for this software is below. We hope that it’s useful for your needs.


tm2x0 is a Python package for working with Neoden TM220A and TM240A pick and place machines.

It currently has a script for generating a .CSV input file for the PnP from a KiCad .pos file, using an interactive command-line menu.

It was developed by Adam Wolf and Matthew Beckler of Wayne and Layne, LLC, with no affiliation with Neoden other than we own one of their machines.


tm2x0 is a Python module. You should be able to install it through pip or however you normally install Python modules.

Let us know if you have problems.

read more…

Jan 15 14

Nice review of Blinky POV from BigMessO’Wires

by Layne

Steve over at Big Mess O’ Wires wrote up a nice review of our Blinky POV kit. A few excerpts are below, you can read the whole thing at the Big Mess O’ Wires blog post.

My oldest daughter Alice has an occasional interest in electronics, and as her dad I try to encourage her without becoming too annoying. We’ve done some past projects like Snap Circuits experiments, building a Drawdio pen, and constructing an animated Halloween LED display. Recently we had a chance to build a Blinky POV from Wayne and Lane. Or more accurately I should say she had a chance to build it, since my role was limited to talking her through the steps and taking photos. It’s impressive what an 11-year-old can do with a soldering iron!

The main reason I selected Wayne and Lane’s Blinky POV instead of another similar one was the novel method used to program it. Instead of a PIC programmer, a serial connection, or some other conventional interface, it uses a pair of photo sensors to program new messages using flashes of light. Go to the Blinky Programmer web page, design some pixel or text-based messages, and click “go”. A clever bit of javascript flashes two squares on the screen, and when the Blinky POV is held near these flashing squares, it reprograms the stored messages in about 30-60 seconds. In our experience this method was very reliable, and much less hassle than dealing with virtual serial ports or other wired interfaces. And it actually made programming fun – like magic! The web page interface is surprisingly versatile, too. You can design pixel art or text messages, adjust the scrolling speed, switch between multiple stored messages, and define what should happen at the end of each message.

Reprogramming using photo sensors

This is starting to sound like a Wayne and Lane commercial, so I should probably add that I have no affiliation with them other than being a satisfied customer. If there’s a young builder in your life who might enjoy a simple but fun-filled electronics project, give Blinky POV a try.

Read more:

Jan 12 14

Bricktronics Breakout Board review by Xander at Bot Bench

by Layne

Xander at Bot Bench wrote up a nice review of our Bricktronics Breakout Boards:

These adapters would definitely be indispensable if you’re planning to do any kind of tinkering with your Arduino and whatever NXT peripherals you had in mind.

I had a lot of fun putting them together and they plugged into the breadboard very easily and sat very snugly afterwards. They’re very reasonably priced at just $4 a piece. They come with the required 82K Ohm resistor, which you will need for the pull-up.

Read more:

Jun 11 13

Nice review of Blinky POV SMT kit by MobileWill

by Layne

MobileWill posted a great review of our Blinky POV SMT kit!


The Blinky POV SMT is similar to the Blinky GRID but it only has one row of LEDs. By waving the Blinky in the air you can see the design/text due to the effect of persistence of vision. This happens because your retina sees the image slightly longer than it is being displayed. Read more about persistence of vision.

Last Thursday I came home and there it was, waiting for me to rip it open! Since I was leaving for a weekend trip, I decided I would assemble it that night so I could show it off. So at 10:30pm I got started.


Read more: MobileWill: Blinky POV SMT

May 18 13

New Bricktronics Updates!

by Layne

Today at the Bay Area Maker Faire, we are announcing a couple of cool new projects we’ve been working on with the Bricktronics Kits.

1. Bricktronics Megashield – Build robots and contraptions! Experiment with mechatronics using Arduino and LEGO Mindstorms NXT! Our latest kit, the Bricktronics Megashield, to connect up to and to an Arduino Mega. Works with the standard LEGO NXT motors and the touch, ultrasonic, and color sensors. Uses the same easy-to-use software interface as the original Bricktronics Shield, but supports more motors and supports all types of sensors on all ports.


The Megashield is available for purchase at the Maker Faire this weekend, and is now available for purchase from the Wayne and Layne store!

2. Project codename “Trifrost” – We created a small python web framework for connecting local serial devices (such as an Arduino) to Linux computers (such as the RaspberryPi and the BeagleBone) to get real-time web dashboards and interactivity. This is still a work in progress, and we have tons of ideas for extending and enhancing it, so stay tuned.

3. Bricktronics + RaspberryPi = Awesome! – The Raspberry Pi and other low-cost embedded Linux single-board computers are all the rage these days! We combined an Arduino with Shields, and connected them to a RasberryPi, to create a high-power interactive robotics platform. Using a WiFi adapter and a tablet computer, you can use the touchscreen to wirelessly interact with the motors and sensors.


We also created a mobile robot platform, using a LEGO tank platform, an Arduino with Bricktronics Shield, and a Raspberry Pi. Again using the WiFi network connection and a tablet, you can wirelessly drive the tank and read the sensor values.


Once we get more hardware information about the upcoming LEGO Mindstorms EV, we’ll be working on a single-board solution for bringing the power of embedded Linux to LEGO Mindstorms electronics.

For more information about any of these cool projects, subscribe to our RSS feed, or check back in the future for more info.

Note: Wayne and Layne, LLC and our products are not connected to or endorsed by the LEGO Group. LEGO, Mindstorms, and NXT are trademarks of the LEGO Group.

Apr 2 13

Script to query Gerber file outer dimensions

by Layne

At Wayne & Layne, we design a lot of circuit boards. During the request-for-quote (RFQ) process for getting a PCB fabricated, the outside dimensions of the PCB are an important driver of the overall per-unit price. As part of the W&L “prepare PCB for RFQ” process, we have a little script that uses the PCB’s board outline Gerber file to determine the dimensions of the PCB’s bounding box.

Pass in the filename of the PCB “board outline” Gerber file, and it will print out the dimensions in both the original units (decimills for Gerbers exported from Kicad) as well as inches (again, assuming decimills). It does this by analyzing all the lines of the gerber file, and determining the minimum and maximum in both x and y directions. The script is based on a little chunk of code written by @laen on Twitter (who makes no claim to the code, and also runs the most excellent OSH Park PCB service). We’re releasing this script into the Public Domain, use it however you like.

#!/usr/bin/env python
# Gerber query script
# Usage: ./ board_edges.gbr
# Written by Matthew Beckler for Wayne and Layne, LLC
# Based on a script from @laen
# Released into the Public Domain. Have fun
def main():
    import sys
    if len(sys.argv) < 2:
        print "Usage: %s gerberfile" % sys.argv[0]
    import re
    filename = sys.argv[1]
    xmin = None
    xmax = None
    ymin = None
    ymax = None
    for line in file(filename):
        results ="^X([\d-]+)Y([\d-]+)", line.strip())
        if results:
            x = int(
            y = int(
            xmin = min(xmin, x) if xmin else x
            xmax = max(xmax, x) if xmax else x
            ymin = min(ymin, y) if ymin else y
            ymax = max(ymax, y) if ymax else y
    print "Board dimensions:"
    w = xmax - xmin
    h = ymax - ymin
    w_in = w / 10000.0
    h_in = h / 10000.0
    w_mm = w_in * 25.4
    h_mm = h_in * 25.4
    print "  (%d, %d) original units" % (w, h)
    print "  (%.4f, %.4f) inches" % (w_in, h_in)
    print "  (%.4f, %.4f) mm" % (w_mm, h_mm)
if __name__ == "__main__":
Feb 27 13

Kicad Tutorial: Gerber file generation

by Layne

This is part of a series of short tutorials on advanced topics of using Kicad, the favorite schematic/PCB design software here at Wayne and Layne.

Once you’ve finished working on your PCB and are ready to send it off for fabrication, one step remains: “Plotting” the PCB design to Gerber files. The Gerber file format is a very old format with its roots in the 1960s, and is used to completely describe a single layer of a PCB design. You need to generate one gerber file per layer of your PCB design (Copper, SolderMask, and SilkScreen, for both the top and bottom sides, plus the PCB Edges layer). The information about where the holes are drilled, and what size the hole should be, are stored in a separate file with a different format, called the Excellon format, named after the market leader in CNC drilling machines during the 1980s.

To generate the gerber and drill files for production, click on the Plot toolbar button in PCBNEW. It is located in the top toolbar and looks like a printer with a “P” overlaid. This brings up the plot dialog box. (Click to enlarge image.)


Here, ensure that the “Plot format” is “Gerber”. Leave the “Output directory” field blank, and it will default to saving the files into the project directory. Make sure you check all the layers you want to send to production. If you didn’t use back-side silkscreen, or don’t want to use any back-side silkscreen (some places charge extra for that), you can un-check the B.SilkS layer. The other checkmark boxes are the defaults, but ensure that “Exclude PCB edge layer from other layers” and “Use proper filename extensions” are checked. Press “Plot” to generate the files, one per layer. You will see output in the “Messages:” box at the bottom. When that is finished, click “Generate Drill File” to bring up the next dialog box. (Click to enlarge image.)


Again, leave the “Output directory” text field empty. The settings here are very important, especially the Drill Units (Inches), Zeros Format (Suppress leading zeros), and Options (Minimal header). You absolutely must check “Minimal header” and un-check “Mirror Y-Axis”. Since we aren’t making a drill map, the “Drill Map File Format” option doesn’t matter. Click the “Drill File” button to generate the drill file. Then press “Close” and “Close”.

Now you can zip up the generated gerber/drill files and send them off for fabrication. At Wayne and Layne, we really like the prototype PCB fabrication services from OSH Park. They describe themselves as

This is a community printed circuit board (PCB) order. We take designs from lots of people, put them all together on a panel and then order the panel from a fab. Since we’re all splitting the panel setup cost, this lets us make circuit boards inexpensively.

This service grew out of the DorkbotPDX PCB Order run by @laen and now comprises of a two-layer panel every other day, a four-layer panel every three weeks and a periodic two-layer medium run service for people needing more than 150 square inches of board.

They have very inexpensive rates, decent production time, and very high-quality output. Plus, the gold and purple boards just look very nice! Here are the details about pricing and design rules (minimum clearance and trace width, minimum hole size, etc).

Other tutorials in this series:

Feb 27 13

Kicad Tutorial: Using the autorouter

by Layne

This is part of a series of short tutorials on advanced topics of using Kicad, the favorite schematic/PCB design software here at Wayne and Layne.

Routing, the process of connecting all the pads of a printed circuit board (PCB) layout, can be a time-consuming and tedious process. To avoid the time and frustration of manually routing your PCB, there are various software tools called autorouters which can do this for you. This post will show you how to use the external autorouter from the FreeRouting website.

First, ensure that you have selected the proper trace thickness and clearance values in Kicad’s PCBNEW application, by going to “Design Rules”->”Design Rules”. Once you have confirmed the design rule settings, press the “traffic sign” icon in the top toolbar to bring up the FreeRoute interface.


The three buttons on the left will let us export the DSN file that is input to the autorouter, launch the autorouter application, and finally import the SES file that was exported from the autorouter. To start with, press the top button on the left, “Export a Specctra Design (*.dsn) File”. This will open up a file save dialog box, and you can just accept the filename as the default filename is correct.


Now, click the second button to launch the autorouter. This utilizes the Java Network Launching Protocol (JNLP), which downloads a small XML file that is used by your Java system to download the rest of the autorouter. You may see a browser window open up briefly when the JNLP file is downloaded. Chrome gives a warning about the file type, you can press “keep” to retain the file for use. Your browser might do the Right Thing with the .jnlp file, and open it with Java. If not, you can probably double-click the downloaded freeroute.jnlp file to launch it, or on Linux you can type “javaws freeroute.jnlp”. When the Freerouter window opens up, click “Open Your Own Design”.


Due to the Java security restrictions, unsigned applets downloaded from the web are not trusted very much, so you have to give it permission to read files on your machine. For whatever reason, on my computer it won’t let me check “Always allow this action”, so it asks me every time.


Click “Allow” and then navigate to select the .dsn file you exported from PCBNEW earlier. Click on “Open” and it will load your design.


When your design has finished loading (which may take a minute or two) all you need to do is to click the “Autorouter” button, then sit back and watch the magic happen. The autorouter will do an initial route, then go through a series of optimization steps to try and reduce the number of vias used, as well as trying to reduce the total trace length.


You can wait for the optimization steps to finish, or you can click once in the board area to interrupt the optimization if you are in a hurry, or the results are already good enough.


When you are satisfied with the routing, use the “File”->”Export Specctra Session File” menu option to save the routing results to the .ses file. You will likely get another security warning, click “Allow” to continue. Navigate the file system to where you found the .dsn file, and save as the same filename but with a .ses extension.


In PCBNEW, select the third and final button on the left. It will open a file select dialog box, and it should already have selected the .ses file you just exported from the autorouter. Accept the filename and Kicad will load the file into your design. It will ask if you want to reload the board connectivity. I’m not exactly sure what this means, but I always click “Yes”.

As a side note, some people dislike autorouters, considering their own manually-routed designs to be superior, and there’s some truth to that feeling. Sometimes the autorouter makes silly decisions, sometimes I can spot ways to route things different and save a via or two, but generally I prefer to let the autorouter have a go at it, then clean up the results.

Other tutorials in this series:

Feb 26 13

Kicad Tutorial: Copper pours / fills

by Layne

This is part of a series of short tutorials on advanced topics of using Kicad, the favorite schematic/PCB design software here at Wayne and Layne.

A copper pour or fill refers to an area on a printed circuit board where the original copper is not etched away, and remains in place, usually electrically connected to the Ground signal, producing a “Ground Plane”. This has a number of advantages, including decreasing the amount of etching fluid required during manufacturing, as well as reducing the amount of electrical noise and signal crosstalk experienced by the circuit elements.

It is relatively easy to create a copper fill in Kicad. We usually add fills after having already drawn in the PCB outline in the Edges layer. First, ensure that you have selected one of the copper layers (such as “Front” or “F.Cu”). Then, select the “Add Filled Zones” from the toolbar on the right side of the screen.

Select Tool

Next, click in one corner of the PCB outline to start drawing the copper fill.

Click board corner

Once you click in the first corner, the following properties box will appear. Select the relevant copper layer (here, either “F.Cu” or “B.Cu”) and the desired net for the fill (usually you want “GND”, but sometimes you might want some other net, or “<no net>” which will make an isolated copper fill). The settings in the bottom half are important for controlling the drawing of the filled area as well as the “thermals”. One potential problem with adding ground fill is that the ground pads will become very difficult to solder, as the ground plane will suck away all the heat from your soldering iron, and the pad won’t ever heat up hot enough for the solder to flow. To avoid this problem, you almost always want to add “thermal relief” to your ground pads, which means there is a keep-out area adjacent to each ground pad where there is no fill, and instead each ground pad is connected by a number of thinner traces. This still provides a very good electrical connection for the ground pad, but makes it much easier to solder. The “Clearance” setting controls the general clearance between the filled area and pads/traces of other nets. The “Minimum width” setting controls the thinnest that the fill can be when flowing around other pads/traces. The “Thermal Reliefs” settings control the clearance around the ground pads (0.040″ here) and the width of the traces connecting from the fill to the ground pads (0.009″ here). We’ve found these settings to work pretty well for most of our projects. You also want to select “Arbitrary” for the “Outline Slope” setting to make it easier to draw the zone outline. Click “OK” to close this window and continue drawing the fill outline. (Click the image to enlarge)

Zone properties

Once you have closed the zone properties window, click once in each of the other three corners (in order) on the board outline. Then, to complete the final segment, double-click on the original corner to end the zone. You should see red or green hatching (depending on which copper layer you used) on the edges of your PCB indicating the filled region, as shown in the image below.

Outline hatching

Generally you want to have a copper fill on both the top and bottom of the PCB. To add the fill on the other side, the easiest way is to right-click on the existing board edge, select “Zone outline”, then go to “Zones”->”Duplicate Zone”. This brings up the zone properties box for the new zone, so select the other copper layer and press “OK”.

To see the copper fills in your design, click on the “Show filled areas in zones” button, the 10th button in the left-size toolbar. The button below that will hide the fills. Then, you can run the DRC tool (Ladybug Checkmark in the top toolbar) which will fill all your zones. You should see something like the image below. The brown-yellow color is the combination of red (top side) and green (bottom side) copper fills. We can see the 20 mil clearance between the fill and non-ground copper, and the larger 40 mil clearance between the fill and GND pads.

Finished fills

Other tutorials in this series: