I/O Prototyping Tools

From CS294-84 Spring 2013
Jump to: navigation, search

Reading Responses

Valkyrie Arline Savage, PhD - 3/9/2013 23:18:40

The theme of the papers this week is prototyping I/O devices. It’s too bad we didn’t have them for our class last semester!

The .NET Gadgeteer paper focuses on providing a system which offers flexibility, accessibility/extensibility, and versatility. The system offers a collection of little components that are built with physically identical connection points that communicate over whatever protocols are required by the devices being broken out. There is also an OO software development environment for programming the devices being prototyped, and a CAD plugin which assists the designer in developing a casing for them. I think this is actually a really awesome addition: they don’t talk that much about it, but certainly things are moving in the direction that software developers are moving into hardware devices, which leads to less engineering and optimization on the hardware side (and, thus, the need for enclosures optimized for the parts used for prototyping). I wonder if this means that we’ll eventually have a bunch of crappy hardware built by software engineers... Anyway, they did a lot of evaluation on their kit, and they are effectively doing more all the time since it’s a commercial product now. Well done!

VoodooIO is a pretty sweet concept. It talks about “graspable digital information” and how to make it so easily: basically by creating a substrate which communicates with input devices as soon as they are connected to it and can be used to create custom and remappable tactile interfaces. They offer a lot of different control types already for use with this substrate, and suggest many places in which such a user-creatable interface could be useful. This sort of reminds me of end-user programming, but actually it’s more like end-user design. I wonder if they will be able to create UIs of any usefulness...

The Midas paper is perfect. That’s it! Just kidding.  :) We could certainly have tried to explore the inclusion of something awesome like TeslaTouch to provide haptic feedback on the little printed prototypes, and of course I know secrets about how the cutter never worked properly... but I am excited to see what other people say about this paper and to explore further into 3D with Sauron.

Ben Zhang, PhD - 3/31/2013 11:47:40

  • .NET Gadgeteer (Villar)

.NET Gadgeteer is targeting at creating new prototyping platform for both research and education. The whole idea behind is to have a uniform interface (socket) to connect central processor with peripheral sensors to achieve accessibility, flexibility and versatility. The software architecture for such systems are built around event-driven object-oriented programming, which makes application writing intuitive and easy. The paper also talks about a solidworks extension which assists the process of assembling components. And the hardware, software, tools altogether forms the essential contribution of .NET Gadgeteer platform.

The process of designing and implementing customized hardware isn't really as flexible as software. And apparently these fast prototyping tools are trying to bridge the gap. This paper identifies some of the key requirements in these prototyping process. From my experience, sometimes the form factor can be a huge consideration while many other prototyping toolkits fall short in enabling. The ribbon cable, and the uniform sockets in Gadgeteer makes the development easy and users are free to glue components around for their purpose. Though not perfect, Gadgeteer does give freedom for device construction.

From their evaluation, it seems developers can easily get used to their system and start building things. What might be extremely complicated can be simplified because of the modular approach. But this usually comes with some specific tasks that has predefined library (drivers). What might be interesting to see is the complication to develop drivers for this platform. Such drivers will hide lower level details from users, but how would manufacturers deal with the requirement of additional driver? If someone has the demand, how much effort does he need to complete this task? I believe some C# programming would then be necessary. Another important factor which the author didn't discuss at all is the price. A quick search online will give an estimate of using this platform. It doesn't seem to be too expensive. I am just thinking adding such information into the paper would make it more complete.

Overall, I like many concepts behind this work. And I feel there has been many effort put in to make this platform easy to use.

  • Midas (Savage)

Midas describes its complete procedure of creating prototypes from capacitive touch sensors. The software tools support design, routing and exporting the work. Fabrication can be then done and the event sensing flow is through WebSocket for additional use. The major difference of Midas with other approaches like Gadgeteer or Arduino is the flexibility in customizing sensing pads. To simplify mapping from gestures to actions, a record-and-play mechanism is used to define the interaction. An informal user study is conducted, and participants were able to design their own media players using Midas. Also many valuable suggestions are received through this study to improve the work.

Midas is a complete toolkit which helps from the design to the assembling. The possibility enabled by freely routing and designing sensing pads may empower many customized design for non-professionals. One question I have during the reading is the comparison between manufactured sensors and capacitive tapes. The latter seems easier for prototyping, and with some simple tools like scissors/knives, you can also achieve what has been proposed in this paper. One major advantage of going electronic is the ability of sharing the design remotely, but simply for prototyping purpose, I haven't been fully convinced of the necessity of Midas.

  • A Malleable Control Structure (Villar)

The malleable control structure utilize network substrate that turns any component on it being able to communication, thus function as sensing and actuation. In this paper, four major controls (buttons, sliders, dials and joysticks) are available to be brought together for prototyping purpose. The 1-Wire specification as the underlying communication protocols provides such flexibility of reducing the pins needed. For illustrating purpose, mixing desk, map navigator, gaming cockpit and data clipboard are discussed as motivating examples of using this system.

Different from the previous papers we have read about creative use of screens (like shape-changing device), this paper focuses more on the existing physical gadgets that can be glued in a novel way. The 1-wire and network substrate makes the arrangement of controls flexible. You can add a button when you need for specific purpose, and the placement would fit whatever the application needs, such as the dedicated control in the gaming cockpit example. Though when communication takes place inter-substrate, you still need cable to connect them; I feel like the malleable ability in this paper being enough for many scenarios.

This paper majorly discusses the controls (button-like input), outputs or actuations on the network substrate are limited to LED behaviors. However, it seems to be intrinsic to this design that the connections are mostly limited to the nearby few components. Remote control-like actuations wouldn't be too appropriate unless the substrate is largely deployed (not a bad idea though... embed parts into the carpet?). Another consideration is that the substrate should have "free zone" so that you can attach pins without interferencing ongoing connections, but this might be too detail.

Again, some concepts in this paper, like using 1-wire protocol to minimize the connections, are inspiring.

David Burnett - 4/1/2013 20:22:52

"A Malleable Control Structure for Softwired User Interfaces"

This paper describes reconfigurable set of controls that can be jammed into a squishy substrate, allowing a single input device to have many forms. This reconfigurability allows the creation of arbitrary "control sets" which can be highly customized for a particular application, obviating the need for single-use hardwired controllers or sticker sets (such as a video editing shortcut key reference). It also allows creation of corporeal controllers for which there is no hardwired or sticker equivalent, such as a LabView VI. With the popularity of GUI interfaces for custom applications, an inexpensive real-world version would likely greatly reduce user confusion as is common in LabView and such applications. The choice of 1-wire bus makes sense for a wired substrate, but the paper fails to make a compelling argument for even having wired devices in the first place. For binary and continuous inputs alike, a lightweight wireless transceiver could communicate the final value to a base station, confirm receipt, and power down in a cycle that could allow even a small battery to last years. This would allow the inputs to truly be installed anywhere. Secondly, the substate foam/pin combination doesn't allow very efficient UI design. The foam lends itself to imprecise alignment when adding an input leading to wobbly rows of buttons, pins and foam will drift and wear out much faster than hardwired controllers, and the assembly/disassembly of a control set can't be done quickly and precisely. These nonideal features lead to a good tool for prototyping, but not for easy switching between control sets.

".NET Gadgeteer: A Platform for Custom Devices"

.NET Gadgeteer is a project with a serious amount of work behind it, encompassing an electronics hardware platform, a simplified programming language and associated libraries, and software to generate 3D enclosures to make a finished project. From the examples presented, it allows complex devices to be prototyped very quickly with quality results. As a result of its significant polish within a small team, the individual components are matched to each other and seem to interoperate well, eliminating common headaches involving importing various libraries or convincing two pieces of software to export & import compatible files. Unfortunately, the .NET implementation choice will greatly limit the user base because so many prototyping types use non-Windows operating systems. It also attempts to basically reinvent the Arduino platform in a less open-source manner and less well-advertised; given the widespread penetration of Arduino into prototyping groups, this will also limit uptake of the project. These two attributes may restrict users to the late adopters of at-home device prototyping.

"Midas: Fabricating Custom Capacitive Touch Sensors to Prototype Interactive Objects"

As if this week's presenter needs to know what her own paper was about, Midas allows designers to easily add touch-sensitive controls to arbitrary surfaces through a toolchain of design & autorouting, fabrication, assembly, and input mapping. Through some miracle of controller design a ground node isn't necessary for these contact systems, so user-defined buttons are actually as advertised. The layout assistance portion is a nice convenience, but I find the actually powerful part to be the "defining events" step. Most new input systems totally skip making the input actually useful for prototyping or real use, and including an input mapping assistant turns this project from a copper autorouter to a prototyping tool. As is noted in the paper, the heavy equipment necessary for the user feedback loop limits device testing outside the lab, and the software layers in the feedback loop slow detection which makes some types of input difficult.

arie - 4/2/2013 0:58:43

The Gadgeteer provides a flexible, extensible and versatile framework and

 2 collection of sw/hw building blocks facilitating the development of new
 3 devices for researchers with less experience in device design. While the
 4 idea of having an integrated hw/sw toolkit is naturally appealing, the
 5 question of flexibility vs. integration scale arises. What makes this
 6 system different from arduino is a higher level of its integration. Having
 7 said that, since the platform is intended at a wide audience, a key factor
 8 for its acceptance would be the development of a critical mass community
 9 which will be able to support it and move it further as application needs
10 evolve. The Gadgeteer introduces the concept of sockets which allow
11 to interconnect components targeting less-technical audiences. I think this
12 makes the need in a supportive community even more pronounced.
14 The Malleble UI introduces a flat surface made of conductive substrate which
15 acts as a canvas for digitally connected UI widgets allowing rapid
16 prototyping of novel UI concepts. I found the missing user experience
17 study somewhat concerning. The flexible surface pad can be thought of as
18 a more free-form extension of breadboard. I could not convince myself
19 of a real need to use this technology because it binds you to the specific
20 set of control elements developed by the authors, but I can see how UI
21 designers might enjoy this approach due to its flexibility and elegance.
24 Finally MIDAS demonstrates a process for developing custom made, low cost,
25 capacitive touch sensors which allow rapid prototyping of touch-based
26 interfaces. The idea of leveraging existing technologies such as
27  auto-routing and keeping the MFG process in mind was insightful. Since our
28 project is attempting to use conductive ink for somewhat related purposes
29 as midas, the paper was a source of inspiration.

Sean Chen - 4/2/2013 1:57:11


Gadgeteer is a platform designed to make hardware prototyping easier. The design includes solder-less hardware components, OO programing languages, and 3D design tools.

This is quite different than the papers we read in the past. We saw many papers that had one or two really novel ideas but has a lot of rooms for refinement and without clear use cases. This research is pretty well-rounded and they took care many details in various aspects. For examples, they designed the sockets so that connecting incompatible ones wouldn't cause the hardware to fail permanently. And the use of event-driven API. You can tell that they spent a lot of time trying to make every part as perfect as possible. And the goal is also very clear, to make prototyping faster and easier. However, that somehow makes it more like a refining a product rather than coming up with a completely new idea.

I actually recognize their work that tries to improve every step of the process. And I believe this will lower the learning curve. Part of it is due to shifting the effort to the upper stream, such as making the hardware developers provide software drivers. I'd like to know the cost this platform comparing to others.

It's a pity that there weren't more user evaluation. They showed examples of what people built with it. But it'll be better to compare with other tools, or to find users that have worked with Arduino and discuss the differences.


Midas is a toolkit for designing and implementing flexible capacitive touch sensors. It helps the designer to layout, fabricate, and program interactions by using adhesive-backed copper foil and vinyl.

This design provides a quick and easy way to produce touch input while making prototypes. It uses clever ways to mimic continuous slider and 2D touch pad and makes the process much faster. It not only handles the first part of design, but also provides a program to connect the interactions. I like the record-and-play design. A lot of our time in prototyping was spent on wiring and setting the pins. This would simplify that process.

As the paper mentioned, this approach is probably not best suit for inputs that requires a very high resolution or has many complex sensing parts. I think this is all right. For designs that detailed and complicated, they might prefer other customized prototyping approaches, while this method is good for more low-res and easier sensing inputs that can be built quickly for PoC or iterative designs.

I like how it discusses the related works and showing the differences. The paper also did a good job at explaining the design decisions, its limitations, and drawbacks, allowing others to build upon this research.


VoodooIO is a system that provides a malleable control structure. It has a set of controllers that can be arbitrarily placed on the substrate and then everything would just work.

The substrate provides a good mean for multiple purposes: fix locations, communicating, and power supplies. This is really clever. However, they mentioned that it was years of works so not sure how much of that part is invented by the authors.

This reminds me of the SLAP. The difference is that SLAP is for tabletops and VoodooIO is for any physical surfaces. Every user has unique use on the applications and it's hard to remember all the keyboard shortcuts. Some of the shortcuts are even too difficult to press. With this flexible tangible input that can be adjusted to various applications, I can see quite some professionals benefit from it.

Although the paper provides several use cases, it didn't really evaluate how well they work. I think the real contribution of this paper lies on the substrate and how it communicates with the controls, which make the wiring much easier. Without this part, it's pretty similar to what an Arduino can do.

Joey Greenspun - 4/2/2013 8:50:17


Elliot nahman - 4/2/2013 13:27:37