This Instructable documents the exploratory process that I carried out to design and fabricate a device for quickly prototyping interactive systems that incorporate off-the-shelf electronic input and output components. I call this device Pixel.

This project was quite large in scope, and while doing it, I faced a number of ongoing challenges because the final design of the device was not known. My experiences designing Pixel show that exploratory design can be challenging to do because it is riddled with questions and uncertainty. Through trial and error, I learned strategies for navigating through this process that I believe will be useful for anyone undertaking a large exploratory project. In this Instructable, I share some of these strategies and describe how I used them in the design of Pixel. I also document the the process I took to fabricate Pixel.

I hope that this Instructable serves as an example of one way to create a device. I hope that this can provide makers and designers interested in large projects with a framework that helps them navigate the inherent uncertainty in their projects.

Step 1: Plan Your Exploration. Create a Design Trajectory.

I set out to build Pixel with a basic idea. I wanted to be able to build a range of interactive systems more quickly and with fewer physical constraints.

After thinking about this idea for a while, I realized that Pixel should be general purpose, capable of being used to build other systems, and that it should be able to move around with me in the physical environment and useful for modifying the system from any position in the environment. In other words, using Pixel should feel more like using common craft materials than connecting circuits or typing code on a computer. This was a departure from the usual way of building interactive systems, which involves programming and building circuits away from the materials that are used in the project and separate from the context where it will be deployed.

To help limit the expansive number of possible designs, I found it helpful to first consider the ideals underlying my interest in building Pixel then determine a small number of properties that I wanted to be present in the final design.

These led to the following design properties:

  1. Modular. There should be only one device design.
  2. There should be a single way to quickly connecting and interchanging input and output components. For this, I drew inspiration from my experiences using the MaKey MaKey. Sticking with the idea of the single design, I decided to add a single input and a single output to each module.
  3. Any number of modules should be usable and they should communicate with each other wirelessly.

I wasn't exactly sure what Pixel would look like when I started building early prototypes. However, I was able to sketch a few designs based on these properties.

Step 2: Build Early Prototypes Focused on Achieving the Design Properties.

My early prototypes were done in the spirit of exploration and to get a feel for the idea I was trying to realize. Because I wasn’t sure what I should build, I decided to focus on certain features that were important to me in the design. I built early prototypes to explore the connection interface for connecting electronics, module size, and module functionality.

My first exploration focused on modularity and the feeling of controlling a modular system. I had access to several 2x2 button pads, so I decided to use them for the first prototype. The first prototype is pictured in the first and second photos. As you can see in the photo, the prototype did not allow connecting electronic components. However, it did include a fixed kind of input (buttons) and output (sound) so I could start developing a sense of controlling inputs and outputs with a modular system. This prototype used point-to-point mesh communication.

My second exploration built on the first one. I added capacitive input to enable quick control by touch (similar to a button) and terminal blocks to connect an additional input and an output. Like the first exploration, this one used wireless point-to-point mesh communication. In this prototype, I felt the the terminal blocks took too long to use to hook components. This prototype is pictured in the third photo.

I had experience using the MaKey MaKey, which used alligator clips, so I decided to replace the terminal blocks with a similar connection interface in the next design.

Step 3: Reflect on Your Early Explorations and Refine Your Design Strategy.

Having outlined a set of design properties and exploring their potential with some early prototypes, I learned about their feasibility as well as the feasibility of achieving the desired device design with the electronics I used for early exploration.

In addition to designing to achieve the properties I outlined previously, I was constrained in certain ways by the need to embed custom electronics inside the enclosure. I knew from my prototyping that I would likely use a small development board and a few breakout boards to achieve the desired functional properties for each module. I knew I could eventually create a custom PCB, but I also knew I wanted to explore a range of designs, and that would require me to decide on a specific design. I wanted to take advantage of the flexibility afforded by breakout modules for electronics. As a result, I could estimate the size of the modules and, therefore, prototype the modules as I also prototyped the electronics.

Being able to prototype these in parallel proved useful as it enabled me to consider both (1) the design of the enclosure based on how it was influenced the selection of electronic components, and (2) the selection of electronic components based on how prototypes felt with the electronics embedded within them. In other words, it created "feedback loops" between me and these two facets of design that were important parts of this project.

I started building the first prototype in this way.

Step 4: Start Prototyping.

Reflecting on how I was going about my exploratory design process helped me identify good and bad aspects of it and adapt to make the process work more effectively. However, the advantages and disadvantages evolved with the state of the project.

In the early stages, for example, I made the decision to omit almost all of the electronics from the enclosure. Instead, I placed all electronics on breadboards and strung bundles of long jumper wires between the breadboarded circuit and the few components inside the module (i.e., the light for feedback and the IMU for sensing the orientation and motion of the modules). I did this for a number of reasons. First, I could easily access and change the circuit as I needed to, without taking the the need to disassemble the enclosures and take out the electronics. I figured this would take a lot of time since I was still experimenting with components and was still using a breadboard. At the same time, this . For me, the lesson here is that making compromises in one facet of the prototyping process (electronics) can result in accelerating another facet (reducing the size of the enclosure to approximate the eventual size), thereby also changing the context in which you consider the facets individually ("oh the electronics actually won't fit, so I need to reconsider my approach" and "oh that enclosure size feels about right when I hold it in my hand") and together ("to make it feel about this good in my hand, the electronics need to be shrunk a lot"). This kind of thinking was continuous throughout the design of the system.

These prototypes were very useful for developing a feeling for how it felt to move the modules and for how responsive they could be to specific motions performed with the modules. After experimenting with these modules, I simplified the set of gestures (shown in the next step).

Step 5: Reflect on How You Work. Determine the Advantages and Disadvantages of Your Approach.

In hindsight, I believe this approach offers some advantages and disadvantages.

The advantages are that it contextualizes the design of the facet of interest (e.g., electronics) as it relates to the larger system. It also makes it easier to envision what the final product might look like provided it is constrained in the same ways as the prototype in its current incarnation and therefore exposes challenges that must be addressed before the desired product is achievable.

The disadvantages are that this is a considerably more complex process, as it involves the concepts, materials, and skills to do very different kinds of work. For my project, this meant sketching physical prototypes on paper, designing them in CAD, and using 3D printers while prototyping the enclosure while connecting electronic components into circuits, writing the firmware code to control them.

Of course, both of these were driven by a larger aesthetic concern—that is, the way using the prototype feels and the kinds of systems that it can be used to build. Although, this added an additional dimension to the complexity of the prototyping process, it actually served as a clarifying force in my consideration of both the electronics and the enclosure. For example, when considering the electronics, I was forced to think about the cumulative size of the circuit, including prototyping materials like jumper wires, breadboards, and the dimensions of alternative breakout boards that provided certain functionality.

Step 6: Combine the Elements of Your Design Into a Single Prototype.

Once I was comfortable with the selection of components I was using and the general design of the enclosure, I started to enclose the electronics into the module.

Step 7: Reflect on the Complete Prototype and Plan Revisions to the Design.

The design of the final enclosure drew heavily on my experiences combining the electronics into a the enclosure for the previous revision.

Having combined the electronics into a number of modules, I decided to machine PCBs using a CNC machine, in attempt to create templates for the PCBs for quicker assembly, now that the design was less likely to change.

  1. Machine the PCBs on a CNC machine.
  2. Populate and assemble the PCB layers and connect them to one another.
  3. Revise and print the enclosures.

Step 8: Revise the Electronics. Machine the PCBs With a CNC Machine. Assemble the PCBs.

Once I determined how to position the components and designed the PCB layout, I decided to manufacture the PCBs using a ShopBot Desktop CNC machine.

I chose to do this because it was available to me and because I wanted to use the CNC machine to develop a sense of making the PCBs as directly as possible and see the PCBs made before my eyes. Because I was working very near the CNC machine, I could also see if the machine didn't act as expected, the boards weren't being produced as expected, and to rapidly iterate on the design in either case.

Tip: I found that it helps to organize the components when doing multiple identical pieces into containers that are easy and quick to access. I organized my components into plastic cups since I could easily see what was in them and I could easily grab components out of a cup.

Step 9: Revise, Print, and Assemble the Enclosures.

After I assembled a single PCB and verified its complete functionality, I measured it and began to update the enclosure design in Tinkercad so they could be printed while I etched the PCBs on the CNC machine and assembled devices.

Step 10: Share Your Work to Evaluate Your Design.

Once I finished assembling my prototypes, I ran a workshop to show them to a small group of people. Their response to Pixel was inspiring because they imagined using it in ways that I hadn't considered to build systems that were very personal and unique.

I drew some images based on my favorite uses for Pixel. This situation is described below.

“Here’s a problem I have. I have a cherry tree. Just when the cherries get real ripe, the birds come and eat them. Now, if I can make some sounds or some kind of flashes or something—a scarecrow, right?—then the birds will not come. Now even a scarecrow that you have, it has to have moving parts on it, or, they say, you can buy a plastic owl and put it somewhere, but if the plastic owl is not moving at all then it won’t work. The birds will learn and it’s useless. So, if one had these kinds of things, and one of them has a motion detector, gets a motion from the birds around or something, then it can signal the other ones which would be on several branches in the tree. Something like that.”

<p>Cool project.</p>
<p>Thanks! It was a really fun project and I learned a lot while working on it.</p>

About This Instructable



More by mokogobo:Exploratory Design and Fabrication for Custom Devices 
Add instructable to: