Once in a while we’ll get an email along the lines of, “Hey! What happened to the Bluetooth Arcade Controller? I couldn’t find it on your website or your store.” After answering a few of these recently, we decided to make a blog post about it here.
The Bluetooth Arcade Controller (BTAC) was the core component of a neat little project called “Coffee Table MAME Console” in Make Magazine vol 28, that let you build your own arcade-style control panel, and connect it to your computer or Raspberry Pi using a wireless Bluetooth connection.
The world of hobbyist-grade embedded bluetooth keyboard interfaces has advanced greatly in the past couple years since we created the BTAC kit, and it’s no-longer the best solution, in our opinion. We’d suggest trying Adafruit’s new Bluefruit EZ-Key product, which is better in every way (except for number of button inputs) than the BTAC. Plus it’s only $19.95.
They even have some great tutorial documentation on how to get started with it.
If you need more than 12 inputs, you can connect the Bluefruit module to an Arduino Mega or other microcontroller and use the RX/TX connections to send ASCII characters to the bluetooth module, which will then transmit that character as a keypress to the computer. You can even do raw USB HID keyboard or mouse reports to properly handle up to six concurrent keypresses.
Also, you can re-map the default 12 inputs using an FTDI cable and a processing sketch.
At the end of the day, we suggest going with the Bluefruit EZ-Key, as it’s cheaper, more flexible, and all-around better than our Bluetooth Arcade Controller was.
Wayne and Layne is a two person electronics company in Minneapolis. We design and sell electronic kits and projects for kids and adults, beginners and experts. Most of our products are sold online, but some of our products are sold in retail stores across the world!
So far, we’ve given away all our designs. This is so you can learn how we put it together, but we believe so much in giving the designs away that we’re willing to let you do anything with our designs–even to make your own kits for sale. We ask that if you use our designs, you give away your modifications too. (A link and some credit would be nice too!) This is called open source hardware.
We also do design work for other people, like Kickstarters and museum exhibits. Most of this work isn’t open source, but it helps fund our open source work. (We also explicitly reserve the right to release new products that are not open source.)
It might not look like it from our blog, shame shame, but 2014 has been an amazing year for Wayne and Layne! We finished a lot of awesome projects with clients, got an office, put a bunch of cool tools in it, worked on new products, and improved a lot of things behind-the-scenes. On top of that, we worked on open source software like Kicad that everyone can use for free, and your purchases of our products helps us volunteer!
We have an office!
Up until April or so, all of Wayne and Layne was at Adam or Matthew’s apartments, and we’d meet with clients at coffee shops or hackerspaces. This worked great when Wayne and Layne was just starting out, but now that we’re more established, we were outgrowing the space we could carve out of our apartments. It also meant we had to buy twice as much of everything, or ship things around and it seemed like we never had what we needed where we needed it. Now that Matthew and Adam both live in Minneapolis, this seemed like a waste. This came to a head when Adam had to clear out his Wayne and Layne office to turn it into a nursery. (!!!) We tried storing all our inventory in a storage unit, continuing to work from our apartments, but after a month, we decided to look for an office. We looked at some online listings, then put the call out on Twitter, and it didn’t take long before we found a great spot.
We have some space in Minneapolis that isn’t fancy but
- has a great landlord
- is on good bus lines
- we can afford
- is across from a Chinese place that serves xiao long bao
so really, we can’t ask for more!
We have some awesome equipment in our office!
In our new space, we have a pick and place machine, reflow oven, hot air station, stereo microscope souped up for assembly, as well as a laser cutter, an Othermill, and a reliable 3D printer! We also have less fancy equipment, like a shipping station with label printer, laser printer, scale, and barcode scanner. We don’t plan on doing large manufacturing runs in our space, but we’ve definitely leveled up on the prototyping we can do in-house!
We finished our work on the Choosatron!
The Choosatron is a little interactive fiction gaming device funded on Kickstarter. Jerry brought us in before the Kickstarter launched to help with the PCB layout and to help design for manufacturing. It’s just about ready to ship, and it’s turned out even better than we expected.
We made more museum exhibits!
We continued our partnership with a local museum exhibit design company, and helped with lots of new exhibits. Our exhibits this year are all over the US, including right here at the Minnesota State Fair! We had our hand in quite a few of the exhibits you see in the Energy Building. With the museum exhibits, we began to see some patterns in our “one-off” designs, and are investigating how to turn some of those into products. We have some exciting news about our partnership, but can’t reveal it yet. (You can see examples of our museum work at http://www.wayneandlayne.com/exhibits/)
We invented new wearable visual effects with Dessa!
We did a pair of projects with Dessa! We had talked previously on a project that fell through due to scheduling issues with overseas suppliers. This year, she came to us with some rough ideas of wearable visual effects she wanted for a show. (One idea was a still from a cartoon.) We completely blew it out of the water! Everyone was really impressed (including us) by how awesome they turned out. More details here!
We presented at Maker Faire NY!
We were unable to make it to Maker Faire SF this year–Adam was too close to becoming a new dad that his wife couldn’t fly and he couldn’t risk being away, but we did make it to Maker Faire NYC in September. We gave two presentations, one on Lego and Arduino robotics, and another on low-cost pick-and-place machines where we announced our Kicad-to-TM240A converter program.
We supported open source software, like Kicad!
We often write patches for bugs we find in the software we use. We have a one or two line patch in Jenkins, for example. We don’t really keep track of those.
However, in 2014, there were some changes to the Kicad leadership, and we’ve been much more involved since then. We have been spending *lots of hours* since September working on getting usable Mac builds coming out of a continuous integration server. There is a Kicad dev team priority of an official “stable” release on Windows, OS X, and Linux. We’ve got team buy-in on a real feature freeze before stable release–it’s going to be slick, folks! Combined with the amazing work that CERN is doing, like the push-and-shove router, OpenGL acceleration, and the upcoming RF improvements, we are extremely excited to see what Kicad looks like at the end of 2015!
Some of the stuff we did is completely behind the scenes, for example:
We redid all our internal infrastructure.
We completely revamped almost all of our internal infrastructure. This doesn’t mean a lot to you, but we have an easier time getting the right stuff done that we need to in order to be successful. Our revamp also dramatically increases our disaster recoverability. After we did this, we had a 1TB SSD containing ten virtual machines completely die without warning, and we were back up and running within an hour or two! (With no website interruption, I might add!)
This was by no means a complete list of our work this year, just the highlights.
- Adam wrote two chapters for an upcoming book, “Maker Pro”: an interview with Emile Petrone of Tindie, and an essay about the Blinky Grid and Blinky POV retail launch.
- We taught a weeklong class at Leonardo’s Basement to teenagers on Minecraft and digital logic. We built things in Minecraft with Redstone, and in real life with breadboards, LEDs and switches, and 7400 logic chips.
- We taught a half-day class on working with EL wire at Leonardo’s Basement.
- Adam went to PyCon for the first time, and started a “Python + Embedded” room.
- We’re on an advisory board for an unannounced project that you’ll definitely hear about in 2015!
What’s coming up?
We don’t like to announce our stuff too far ahead of time, but we’re far enough along in some projects that we’ll let them slip out here:
- New Bricktronics hardware and software
We did a lot of Bricktronics work this year. We have new Bricktronics (our LEGO Mindstorms + Arduino line) products ready to be released. They’re waiting on the other cool Bricktronics thing we did this year, which was to revamp the software support and make it even more beginner friendly, while opening up some more options for more advanced programmers. This new software support relies on some features of the Arduino IDE which are not available in the official builds, but is coming soon.
- A stable, usable OS X Kicad release
- More products, and a new product line
We’re excited to get back to our roots with new products!
- More museum exhibits
- A new website
- A new shipping backend
This is probably boring to you, but it means means more accurate (cheaper) shipping, order status notifications, and your order will go from ordered to shipped even faster!
That’s about all–I have a brand-new Othermill to play with when I’m done with this post.
Happy hacking, folks!
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.
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.
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.
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: ./gerber_query.py 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 sys.exit() import re filename = sys.argv xmin = None xmax = None ymin = None ymax = None for line in file(filename): results = re.search("^X([\d-]+)Y([\d-]+)", line.strip()) if results: x = int(results.group(1)) y = int(results.group(2)) 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__": main()
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: