Teagueduino is now on Kickstarter!

| Adam Kumpf & Matt Wolfe

Teagueduino has officially launched! Check out all of the details and support the Teagueduino project on Kickstarter to get your very own kit to play with.

Thanks to everyone who came out last night for the launch party. It was great to see so many interested makers, artists, teachers, and students in Seattle.

And for those who couldn’t make it, here’s a launch party recap via photos on flickr.

Let’s spread the word and help bring Teagueduino to the broader community of makers, learners, and teachers — the future of making things is going to rock!

No Comments yet. Click to add one »

Teagueduino Launch Party!

| Adam Kumpf

The time has come to make Teagueduino real!

Teagueduino is an open source hardware platform that makes Arduino a whole lot easier! There’s realtime feedback, always-valid code creation, and no soldering required. Teagueduino is designed for anyone interested in quickly making electronic projects, regardless of their background.

On Monday, August 22nd we’ll officially make Teagueduino available for pre-order (by supporting the project on Kickstarter). To kick things off, we’ll be sharing Teagueduino at Metrix Create Space in Seattle for anyone to play with, hack, and experiment. Of course, we’ll be around to help answer any questions as you create something awesome.

If you’re curious about what people have been making so far, check out the growing collection of Teagueduino photos on flickr.

So… come to Metrix anytime between 6pm-9pm on Monday and we’ll be there. There’s no need to RSVP, just show up and start making things.

Launch party when/where:

Monday, August 22nd
Metrix Create Space (Capitol Hill)
623A Broadway East
Seattle, WA 98102


Teagueduino Workshop – Let’s do it again!

| Adam Kumpf & Matt Wolfe

Thanks to everyone who joined us for our first Teagueduino workshop in Seattle!

Particpants made a wide range of projects including: an interactive game, harmonic music generator, 3-bit binary counter, light-controlled servo, laser experiments, and LED light shows — just to name a few. It was great fun and we definitely learned a lot from all of the questions, discussion, and feedback.

In fact, we enjoyed it so much we’re going to do it again next week. Drop us a line if you’ll be in Seattle and would like to be a beta-tester for our next Teagueduino workshop.

Hope to see you there!

Monday, August 15th
6pm – 8pm
RSVP teaguedslabs@gmail.com

No Comments yet. Click to add one »

Teagueduino Early Access Workshop (it’s free!)

| Matt Wolfe

Calling all designers, builders, artists, students, teachers, tinkerers, thinkers, and makers! Over the last month or so we’ve been hard at work making Teagueduino even better, and in a few weeks it will be available on Kickstarter for anyone who wants one.

In the interim we want some feedback, so we’re hosting a workshop for 10 participants to come visit our downtown Seattle office and play with Teagueduino for a little while. The workshop is free and open to anyone, plus one lucky beta tester will take home a prototype Teagueduino kit!

Teagueduino aims to make Arduino and embedded electronics easy and available to anyone. Don’t know how to solder? Can’t code? No problem.

If you’ll be in or around Seattle next Monday night and would like to join, drop us an email at teaguedslabs@gmail.com and let us know what you’re interested in.

Hope to see you there!

Monday, August 8th,
6pm – 8pm

The August 8th workshop is now full.


Muze: a musical instrument that plays with you

| Josh Maruska & Adam Kumpf

A couple of us started talking about the state of musical instruments, digital music creation, and how so much of it buckles under the weight of heavy user interfaces and the desire for more knobs, buttons and faders. What if we were to create a device that sings to you and has its own musical inclinations, yet can also engage in a two way dialog with another musician? Not something that can be controlled as much as be guided and influenced – and as a result guides and influences the user.

The proposition is relatively simple. We have educated Muze with a palette of notes that it can in-turn interpret and compose into various rhythms and phrases that are strung together to form something musical. The user can then influence these strings of notes and rhythms to create entirely new compositions. Much like you would a tune a radio to get a new song, Muze can be tuned to provide new and different melodies.

But Muze also has its own desire to explore and will continually improvise on the melodies it creates with you. It is out of this ability for it to self-create that Muze becomes a partner and not just an instrument. For instance, we have played with it and then left it to play over lunch. When we return it has come-up with something completely new, yet derivative. Sometimes what Muze creates is enjoyable, sometimes not. At which point you give Muze a little nudge and it creates something new.

In the interest of keeping Muze from becoming another knob laden techno-fest of an instrument, we have limited the interaction to one input. The input takes the form an aperture into which the user places a color coded knob. There are 6-8 knobs (still a work in progress) and each colored knob represents a new way to nudge Muze into a deviation. No single knob controls a single function, but rather a blend of functions. In playing in a band, you might suggest to a fellow guitarist to pick-up the tempo during a jam, and he not only speeds up, but becomes more syncopated, or staccato, or loud. How a musician picks-up the pace is not just a function of mathematics, but style and mood. Muze, likewise, is free to interpret your suggestions to give back to the creative process.

Technically, Muze is still evolving and growing. All of the code and circuits are open source, so feel free to check out the Arduino code and Eagle circuit schematic if you’re curious and want to try it out yourself. There’s still plenty of work to make it more musical, robust, and simple. If you have thoughts, we’d love to hear them!


Teagueduino 0.1: Arduino just got a whole lot easier!

| Adam Kumpf

Writing code is like riding a bike; it’s super easy, once you know how.

But before you know how, writing code can be scary and bewildering. There are so many things to think about. Where do you start? How do you make things happen? Read an input from a sensor? Control an output signal? What’s the proper syntax? Why won’t my code compile? Where did my code get stuck? Arrrrg! And not to mention that electrical signals aren’t easily seen or heard…

That’s where training wheels come in. By slightly constraining the set of possible actions, there’s no longer a fear of totally wiping out; it’s like a dynamic safety net that lets you move freely unless you lose your balance. And once you learn the ropes, taking off the extra wheels doesn’t seem that scary after all.

Teagueduino is about making Arduino a whole lot easier:

1. There’s no soldering required. Inputs and outputs simply snap into place.
2. Realtime programming and feedback shows the effects of changes as they are made.
3. Simple, always-valid code creation means programs always runs.

Want to make a device’s charging light breathe in a very particular way? Create haptic feedback to enhance touchscreen interactions? Use knobs and buttons to control an acoustic etch-a-sketch? How about servo mounted lasers controlled by sunlight? Or even begin experimenting with some basic DIY home automation (did someone say homemade yogurt maker?).

Teagueduino can do that, and so can you!


We work with a lot of small embedded devices built on Arduino and other similar platforms, some of them quite complex and involved… but surprisingly, the majority of the projects don’t require much fancy footwork — they’re often centered on informing a very specific aspect of a larger experience without requiring the entire system to be constructed. Teagueduino aims to empower the broader creative community to begin taking on these specific explorations because they can directly inform design decisions and are fundamentally important to the communication of those creative ideas to others.

Teagueduino comes from a long line of hacks and experiments within our design studio and across the open source Arduino/Freeduino community (particularly inspiring were LittleBits and the Grove System). While the more engineering-minded among us have been quick to dive into Arduino, it has become increasingly clear that Arduino is still too technical and daunting for the majority of other creative types just getting started. Teagueduino is our first major step toward an embedded development stepping-stone that makes building projects simple, while exposing key details (such as code syntax, electrical signal values, and physical hardware integration) that provide a scaffolding for learning more advanced systems and tools.

The realtime interpreter for Teagueduino was built on top of the Computerless Arduino. Changes include more input/output ports (8×8), additional instruction words (while, waituntil, negative constants, and random), Pause/Reset capabilities, and a bunch of minor bug fixes to increase robustness.

The Teagueduino editor makes using the Teagueduino super easy. Code and signals are viewed in realtime — what you see is exactly what’s on the board. Since each code instruction is chosen from a dropdown menu, there’s no worry of breaking your program or writing things that don’t compile (although, there’s still plenty of room for debugging when something isn’t quite what you intended). There’s also an execution pointer to show you where your your program is currently executing (super handy for infinite loops)… and, you can even edit your program while it’s running!

The Teagueduino board integrates with the Teensy++ 2.0 microprocessor, providing full USB integration for communication, 4k of EEPROM (program memory for the realtime interpreter), and a very small package size. And since the core processor of Teagueduino is Arduino-capable, users that grow beyond the limits of the system are encouraged to repurpose the board as an Arduino via the Teensyduino application.

All inputs and outputs are pre-soldered to buckled 3-pin connectors for simple plug-and-play use with the Teageuduino. The electrical connections were also potted with a non-conductive thermoplastic adhesive (hot glue!) so that fellow designers in the studio wouldn’t need to worry about shorting things out. Here’s a short list of the I/O components we included:

Inputs: Buttons (small and medium), Switches (small and large), Rotary knobs (rotary potentiometer), Sliders (linear potentiometer), Light sensors (CdS LDR), Magnetic sensors (ratiometric), Temperature sensors (thermistor), Force (fsr), and Audio level (microphone with peak detector).

Outputs: Speakers (piezo), LEDs (blue, red, and tri-color), Lasers (point and line), and Servos (small and medium), Motors (via servo control), and a Switchable AC plug (power switch tail) to control higher current devices.

As always, here’s the complete source code, schematic, pcb, etc. for your enjoyment (all released as open source and creative commons). Enjoy!


Computerless Arduino for under $50

| Adam Kumpf

Here’s a fun hack we’ve been experimenting with — a computerless Arduino! It’s small, inexpensive, and doesn’t require a computer to change the code, so you can take it with you and make awesome things anywhere.

The Computerless Arduino consists of two major components; an Arduino-compatible microcontroller loaded with a realtime code interpreter, and a stand-alone 5 button LCD display to display port values and manipulate code. The display can be connected to the Arduino via a 4-pin port at any time to peek at In/Out values, view the current code, and make changes as desired.

By keeping the display separate, it’s possible to have many dedicated Arduino modules (we’re using one of the smallest, cheapest, and most-capable Arduino clones, the Teensy2.0 for $18), without needing to spend much on each additional device. For the display we’re using the super small uLCD-144 (by 4D Systems for $29), and the system could easily be modified to use a larger display or computer if desired.

The programming instruction set for the Computerless Arduino is quite small, making it easy for novices to get started while still working with real code. Navigating the user interface is a bit tedious on such a tiny display, but it’s easy to learn and provides everything you need — a basic multichannel signal scope, a code page for the setup() function which runs once at startup, and 8 pages of code for the loop() function which provides the main functionality and runs over-and-over forever.

The code for the Computerless Arduino is still quite experimental, but it’s all here. As always, Labs work is open source and creative commons, so if you’re curious to play with it yourself or build derivative work, have at it!

We’re still noodling on where to take it next, but there definitely seems to be something interesting about non-conventional approaches to embedded development.



| Matt Wolfe & Adam Kumpf

There’s plenty of literature out there on how to brainstorm lots of ideas, but unfortunately, the hard part still remains: how to pick the right ideas from a wall of sticky notes and actually turn them into something real? Should that wild idea for a “toaster with wings” really stick around (retro screensavers aside)?

For a handful of internal projects, we’ve been experimenting with a completely different approach. We call it creationstorming, and we’ve found it to be super useful when timelines are tight, resources are scarce, and our heads are otherwise stuck in the clouds.

Fundamentally, creationstorming is about making concrete decisions. Ideas are critically debated in the moment, balancing feasibility and impact with respect to the project’s timeframe and goals. Best of all, the team walks out with something that has actually progressed and become closer to real, not a scattering of ideas that demand regrouping after-the-fact; creationstorming uses thinking and debate as a way to start making in-situ.

We’re still tooling the basic structure, but here’s our approach so far.


1. There are bad ideas.
It’s okay to disagree with an idea. Encourage critical debate: challenge others, defend yourself. Wild ideas are welcome, but be prepared to back them up.

2. One idea to rule them all.
Keep the focus on building one solid idea that progresses. Ideas can fork and merge, but don’t lose sight of the goal for the session.

3. Time is short. Think fast, talk faster.
Sessions should be kept as short as possible, so be on your toes and be concise. Interrupt long-winded digressions to keep things on track.

In addition to the rules, we’ve also been sure to include three other components on a cheatsheet in each creationstorming session: the overall project goal, a list of constraints, and some brief background information to keep the dialog moving.

There is certainly a time and a place for blue-sky generation leading to studio walls full of wild ideas, but for everything else — when there are real-world constraints and complex problems to sort out — consider creationstorming as a productive step forward.


DIY Arduino Water Meter

| Adam Kumpf

Working with the interaction design team, a bunch of us at Teague have been tinkering with measuring water, analyzing usage data in realtime to affect behaviors, and storing it to see patterns over time.

At the heart of the exploration was a need to cheaply measure water from the tap.  Water meters vary quite drastically in price (from $250+ for industrial grade sensors to $6 for garden hose attachments that limit total usage based on rough estimates).  We settled on a $20 water meter used for PC cooling systems (the INS-FM17N by Koolance) due to its accuracy, low price, small size, and electronic sensing method that could be easily measured by a microcontroller (such as an Arduino).

The meter comes with an electronic control box, but we found that integrating directly with the sensor was simple enough and saved us some additional wiring and space.  As water passes through the flow meter,  an impeller rotates and toggles an output line which can be used to calculate the amount of water used.  In addition to measuring the quantity, we also included a thermister (thermally-controlled resistor) to sense temperature.

Since we  wanted to have an internet connected data-stream of our water usage, we decided to try out the YellowJacket Arduino with built-in WiFi.  Data was then sent to the server at regular intervals when the water source was in use (from 1-15 seconds depending on the wireless setup and resolution desired).  Using a GET request with ID and usage information, the server was then able to store and retrieve sensor data.  The complete circuitry and code (see download link below) were both conceptually straight-forward and easy to implement.

Over a quick 2-hour build session with the team, we created 4 working units.  Each consisted of the WiFi Arduino, temperature sensor (shown on the right connected to the yellow wire), the flow meter, and two fitting adapters (for use in the shower).  We also hooked one up to our kitchen faucet, which ended up providing the most interesting data due to its frequent usage throughout the day.

To visualize the data and make sense of water usage patterns over time, we also put together a simple HTML5 graphing tool, called Flow.  Using a modular design, we were able to dynamically layout the content to fit screens of all sizes, from iPhone and iPads to laptops and projectors.  This allowed us to place a small display next to the faucet for immediate feedback, while still offering us a more holistic view to compare multiple sources and look at first-order trends.

And finally, to try it out yourself, here’s a ZIP file with the Arduino project, Eagle circuit schematic, and PHP/HTML5 code.  The files are tuned for our quick prototype setup, but should also be helpful if you’re just getting started with hooking up a flow meter or Arduino WiFi data connectivity.

Here’s a video that shows the entire system in action.

Photos and video courtesy of our very own IxD guru, Brian Monzingo.  Also, be sure to check out Teague’s Give Water initiative.  Enjoy!


Radioball 2.0: Work in progress

| Ben Collette

On Wednesday, October 13, 2010, Fast Company will be holding the Masters of Design 2010 event at Industria Superstudio in New York. Check out the Masters of Design 2009 to preview the past year’s event http://www.fastcompany.com/tag/masters-design-event. Teague will be exhibiting the Radioball.

We’ve been working on a more polished and capable version of the Radioball in our Seattle studio. By adding a digital gyroscope to the control board, a slow twist on any facet will turn the volume up or down. We also added a larger battery and easy accessible mini USB slot for recharging the device.

We created a closed compartmental structure to house the components to allow the sound quality to resonate through the two speakers. This was a huge difference compared to the original prototype.

In considering the hardware development, we’ve been exploring a couple possibilities and printed a SLA central structure with two cast urethane parts for the outer “mesh” material. To get the parts accurately printed, we started with a classic 3D print; the resolution isn’t fantastic but allowed us to verify technical details.


Then the fun stuff began. As you can see, we’ve been exploring different material durometers, colors, and transparencies for the outside mesh. The internal structure is in SLA and then polished and painted —everything is held together with magnets.

As of today, we are finalizing Radioball 2.0 for the Masters of Design 2010. However, this little prototype-to-finish project shows the potential for a small production product. Here are links to the original Radioball project.

Stay tuned …

No Comments yet. Click to add one »