Developing a new prototype is never an easy or simple task, putting it together can be one of the most time consuming aspects of developing a new project. Since the Brisbane Makes competition I've been talking to David Lyon who has developed the Clixx.IO open source hardware system to help simplify the whole process.
This post covers the problems inherent with the prototyping process and covers my initial work with Davids solution.
The Problems with Prototyping
One of the more common methods (and my personal favourite) is to use a solderless breadboard. This allows the reuse of components (to an extent, component pins eventually wear out and break off and the breadboard itself will degrade over time) and makes it relatively simple to quickly put together a circuit. It has some inherent problems with circuits using more modern components though - breadboards suffer from stray capacitance and high resistance on the contacts making them unsuitable for low power or high frequency circuits.
Breadboards only support through hole components (such as DIP format IC's) and using more modern SMT devices require the use of a breakout adaptor to simulate a DIP format for these devices.
More complex circuits can be a problem as well due to the strict layout requirements, something with a lot of components or that uses wide communication buses can quickly devolve into a rats nest of wires which becomes difficult to maintain and debug. I've had to spend many hours trying to figure out why a circuit wasn't working only to find the problem wasn't with my design but because I had wired it incorrectly. Using a tool like Fritzing can help with this but it is still an ongoing problem.
Using stripboard addresses some of the issues involved in using a breadboard - layout is a lot more flexible and stray capacitance and resistance issues are heavily reduced. It still suffers from some of the same limitations though - only through hole components can be used so breakout boards is still a requirment. Large circuits are still cumbersome and reusing components is more difficult (unless you are much better at unsoldering components than I am). The time and effort required to build a circuit are dramatically increased and making changes is significantly more difficult.
Some devices such as the Arduino and Stellaris Launchpad solve this issue by providing a well defined adaptor board specification allowing third parties to develop additional external circuitry that can be used with the host CPU board. In the case of the Arduino these are called shields and for the Launchpad they are called BoosterPacks.
This method goes a long way towards simplifying the process but still has some limitations. One of the most important is that they are device specific - using an Arduino Shield with anything but an Arduino can be very difficult (and not all Arduino variants have the same physical layout so using some shields with a different model of Arduino can be a problem as well). If the core processor board you are using changes during the design stage (while developing the Benchtool I went from Launchpad and Arduino to Raspberry Pi and Arduino before I finally settled on the Raspberry Pi and Launchpad combination) you may no longer be able to use the same shields or BoosterPacks you started with. You also have to consider the fact that the peripheral boards you are using don't come with a circuit diagram or are not released under a fairly permissive license it may not be easy to incorporate their design into your final project implementation.
Luckily the Clixx.IO system addresses most of these issues.
The Clixx.IO system provides a device independent interface to dedicated peripheral boards with a very well defined electrical and physical specification. All the details are open source which allows you to build (and sell) your own peripheral boards, host adaptors and software.
David has been developing the ClixxIO system over the past two years (the projects previous name was Hackerpads so if you are searching for more information that might be a good term to use). After talking to him and looking through the available code and documentation he has provided I'm convinced that it's an excellent system for prototyping.
Before I go into more detail I'd like to make a few things clear - David has done a lot of excellent work on this project but it is still definitely a work in progress - finding detailed information can be a little difficult and commercial availability of the system is limited at this time (David has been building the devices by hand and selling samples to those requesting them). There are a few rough edges still in terms of documentation and software but he is working on resolving them - as anyone who has worked on a large project before knows doing up the documentation can often take much more time and effort than developing the project itself.
Another important point to make is that I have not actually used the system yet. David has been kind enough to send me some sample boards to play with and I'm expecting them to arrive this week. So far I have been going through his design notes and the available documentation and getting things ready so I can start using the boards immediately when they arrive. At this stage I have a high enough confidence in his design to transition my Benchtool prototype to a Clix.IO based system in order to simplify the final prototype.
Terminology seems to be a little bit inconsistent for the project so I'm going to define some terms here to make it clear what I'm talking about. Clixx requires that the host processor board provides a dock into which you can insert a peripheral board. There are two types of interface - a four wire connection (a SingleTab interface) and a 5 wire connection (a TwinTab interface). The dock is usually very simple - a one to one mapping to IO pins on the host processor. The dock can be as simple as a set of pin headers or it can be a physical socket that the boards clip into. The image to the left shows the host adaptor for a Raspberry Pi - as you can see the Clixx interfaces are simply broken out to some female headers. Peripherals can be plugged directly into the headers or the headers can be connected to a dock.
The image to the right shows physical docks for both SingleTab and TwinTab peripheral boards. The advantage of using the physical docks is that you don't need to use a host adaptor - you can connect the dock directly to the pin headers of your board. OpenSCAD source and STL files have been provided for the docks so you can easily print your own (at your local hackerspace or from a friend with a 3D printer). A combination of the two (physical dock and host adaptor board) would probably be best though.
The pin numbers for the two types of peripheral boards are shown in the image to the left. The numbering is from left to right while looking at the top of the board as it is inserted into a dock. There are four types of SingleTab boards, their pin definitions are as follows:
Board Type | Pin 1 | Pin 2 | Pin 3 | Pin 4 ---------- | ----- | ----- | ----- | ----- Analog | Out | In | GND | VCC Digital | Out | In | GND | VCC Serial | TX | RX | GND | VCC I2C | SDA | SCL | GND | VCC
For a TwinTab board there are five types of boards with the following pin definitions:
Board Type | Pin 1 | Pin 2 | Pin 3 | Pin 4 | Pin 5 ---------- | ----- | ----- | ----- | ----- | ----- Analog | GND | VCC | Extra | In | Out Digital | GND | VCC | Extra | In | Out Serial | GND | VCC | Extra | RX | TX I2C | GND | VCC | Extra | SDA | SCL SPI | GND | VCC | CLK | DI | DO
The directionality of the pins is relative to the peripheral board - the input pins for the analog and digital pins must be connected to an output on the host CPU. Likewise the TX pin for a serial peripheral must be connected to the RX pin on the host CPU.
At the moment there is very little to speak of. Most of the examples available use a variation of Wiring as used by the Arduino platform (there are implementations available for the Raspberry Pi and the Launchpad as well). Hopefully this will be something that will be addressed in the future.
Preparing for Clixx
To start using Clixx I prepared a set of physical SingleTab docks. I modified the provided OpenScad files to suit the limitations of my printer and printed one out as a default. David obviously has access to a far more capable printer than I do - I had to change the orientation of the print to minimise overhang as well as simplify the cable cavity. You can see an example being printed in the image to the left.
Once I was happy with the final output I printed out a set of six to use as a dock station. You can see the final result in the image to right. For cabling I simply used superglue to attach wires with female pin sockets on the ends into the cable cavity and then used PVA wood glue to attach all the docks to a piece of MDF I cut to size previously. My next step will be to make some stripboard cable multiplexers for each of the three pairs - a common VCC and GND for each pair as well as the input and output signals for each dock. This will allow me to attach it directly to any type of device as I experiment with the system.
I also used the instructions provided here to create a set of four stripboard based peripheral boards. I'll use at least one of these as a breakout to a breadboard to develop some of my own peripheral boards. The others will probably be used to interface to some specific hardware I need for the Benchtool project such as the DC current sensor as an analog SingleTab board.
I can see the Clixx system becoming a very useful tool when it comes to developing prototypes. Although the need for breadboard and stripboard development will never go away it can be limited to the development of small and very specific purpose circuits that, when implemented as a Clixx module, can be used over and over again.
The ability to reuse modules with a range of host CPU systems is a definite plus and the ease of interfacing with any system that provides direction access to IO ports without the need for an interface board is great as well. I think David has come up with an excellent idea and it's well worth keeping an eye on.
That said, there are a few issues I'd like to see addressed. A lot of them come down to the fact that this is still a project in development but will need to be dealt with to get any wide acceptance. The following list details my personal observations only - please don't take them as general criticisms of the project.
- The project has obviously gone through a number of name changes and refactoring over time. The end result is that it can be very difficult to discover definitive information and figure out how to use it. Setting up a central repository of documentation and specifications would be a great bonus and help to get more people involved. The main site is still pretty much a place holder and doesn't really tell you much about the system.
- The host interface boards I've seen so far seem to have connectors placed willy nilly all over the place. It would be nice to have a generic dock board with a well defined interface (a defined set of pins in a header for example) and all host adaptor boards providing that header. This would give you the option of connecting directly to the interface pins of the host or using a host adaptor which does the pin routing for you. it would still allow people to print out their own docks and connect them to either the host adaptor or directly to the CPU board they are using.
- Creating stripboard based peripheral boards was be far the most time consuming and frustrating process of the whole experience. Providing a set of Gerber files for prototyping using either strips or dots would make life a lot easier (after using a Dremel to cut and shape stripboard to match the required board footprint I would be more than happy to buy a box of 10 premade boards or download Gerbers I could send to a PCB service). Providing a simple breakout board with links that can be connected directly to a breadboard would be great for other peripheral developers as well.
- The availability of some cross platform Clixx specific software would make a huge difference as well. If it was packaged as an add-on for currently available software for the various common platforms that would be even better. For example you could have a Clixx library that you add to the Arduino development environment or the Launchpad development environment with a common API so you could easily switch between platforms without having to make major modifications to your code. This is certainly something I'd love to contribute to.
- I've already mentioned to David the possibility of a USB interface to a Clixx host hub that you could use from a PC or Mac (it's an idea he has been considering for a while as well). This would be great for the education environment which (in Australia at least) seems to favour Windows machines. The ability to download a copy of Visual Studio Express, install the Clixx library and then start controlling hardware from C# code would open up a much larger range of consumers (not everyone want's to learn how to program in C/C++ or learn Linux to be able to do hardware experimentation).
The main repository needs to include sample projects (including PCB layouts) for Fritzing and Eagle so it is easier for people to create their own peripherals. David has mentioned that he would like to provide a central service for people to sell their own peripheral boards - given that service like Seeed Fusion have a minimum of 10 boards it would be nice if that service included the ability to sell excess boards as well (I know I have sets of boards from Seeed that I will only use 3 or 4 of, the rest will be added to the collection of 'surplus' components - if I could sell these on or trade them for other interesting things I'd be very happy).
Overall this looks like an awesome project and I can't wait to get more hands on with it. I'd love to see it go to Kickstarter or something similar to raise enough funds to go into production mode.
There will definitely be more posts on this in the future. Thankfully the code and documentation has been made publicly available so even if it doesn't progress I'll certainly be using it as a model for my own projects.