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!


23 Comments »

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!


TEAGUEDUINO DETAILS

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!


54 Comments »

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.


51 Comments »

Creationstorming

| 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.

RULES FOR CREATIONSTORMING

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.


7 Comments »

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!


42 Comments »

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 »

Patchwork to the people

| Matt Wolfe

Patchwork

Today we’re releasing an Alpha version of Patchwork, our super-light image sharing service, free (as in beer) and open source (as in freedom).

Get Patchwork

Installation should be pretty painless and we have a very early user management and administration system in place based on OpenID. Be sure to follow the included Read Me and you should be up and running in no time.

SO, WHAT CAN I DO WITH IT?

We built patchwork to share images, but it’s certainly a little different than a blog. We love ours since it’s projected on our wall for everyone to see it. Which gets people in the office to share and respond to interesting things going on. But we would love to see what you come up with for it.

Own a coffee shop? turn a static display into a living, community fed wall for your customers. Running a project? Start a quick Patchwork and invite team members to share inspiration and ideas. Have multiple offices, but want to share one culture? Show a single patchwork in both offices and bring your employees together through a shared, indirect communication space. Photographers, designers, business owners, boutiques, classrooms, teams: what can you do with Patchwork?

THAT’S GREAT, BUT _________ IS BROKEN…

It’s true, Patchwork is a work in progress, and not everything’s done. The basics are there (we’ve been using it!), but not all of it works yet. For example, you can’t easily delete posts yet. But these things are coming. If you’d like to see something sooner than later, let us know! Just skip over to Get Satisfaction to post ideas, feature requests, or bugs and we’ll see what we can do. And since all of the code is open, you’re welcome to get your hands dirty (if you like that sort of thing) and change things directly.

Let us know what you do with Patchwork–whether you put it up on your own wall or write your own features–let us know in the comments below.

Be sure to keep your eye on your admin page, or follow this blog to be notified of any updates!

patchwork.teague.com


No Comments yet. Click to add one »

Meet Patchwork

| Matt Wolfe

Patchwork by Teague - Sharing is a beautiful thing

Let’s cut right to the chase: we like pretty things. Better yet, we like sharing pretty things with other people.

It’s this basic premise that led us to create Patchwork. Realizing that email was a cumbersome, intrusive, mildly annoying way of letting people know about things they wouldn’t find on their own, we set out to find a new way to share things we like, with people we like. And now, here we are, sharing pictures like popcorn at the movies.

Go on, have a look: labs.teague.com/projects/patchwork

Now, you might be wondering how we’re different in a world full of tumblrs and ffffounds. Well, really, we’re not all that different, but for us image is king, so we went ahead and made the image as big as we possibly could. So each new post, what we’re calling a patch, is the largest, most important thing you see. So big we decided to project it on our studio’s inspiration wall. Patches are easy to make anytime, either on the Patchwork itself or using our versatile, image grabbing bookmarklet.

Responses (stitches) can be other images, text or even YouTube videos. Stitches show up in real-time as comments are made, saving you all that hassle the internet calls reloading.

We’ve also added a couple simple image related features in a handy tools dropdown right beside the stitches. You can grab the full size image, go to the source page, find similar images, or generate a sweet (and useful!) swatch palette on the spot.

At any time, click anywhere on the left hand side to see a history of all the patches made so far.

Now, bear with us: Patchwork is young. We just got up and running and things are changing all the time (when we have a spare moment or two).

Here is where it gets awesomer. The link above is just our Patchwork; only we can post and comment. But once everything is a little more stable (hopefully soon!) we’ll release the code to anyone and everyone to do with as you want. Create your own Patchwork for your class, your friends, your coworkers or add your own features or themes. It’s all about sharing, right?

In the meantime feel free to follow along on our Patchwork and get a glimpse into what shows up on our studio wall everyday.


No Comments yet. Click to add one »

Paper Folding Structures

| Brian Conner

Teague - Paper Folding Structure

Here is a quick model we made for an internal project, showing a proposed structure for a public space, made out of a folded structure. The model itself is made from a piece of letter-sized paper that we took from our printer’s recycle bin, a foam core base, and hot glue.

The fold pattern makes only triangular surfaces. When the feet of the structure are glued to the base, the triangulation is complete, and the surfaces are remarkably rigid.  No printouts or fancy guidelines were needed; we just started folding and experimenting with various configurations until it behaved appropriately.

This combination of architecture and origami has been around for a long time, but the possibilities of what can be made are practically endless.  And because the form can be created from a single flat piece of material, fabrication, transportation, construction, and reusability are all benefited.

We’re also thinking of a few different applications for this approach, including dynamic structures, robotics, and sustainable product lifecycles.

See Richard Sweeney’s work and Do It 101’s Origami Links for some more inspiration and ways to get started.  Why not grab some paper and try it out yourself?


3 Comments »

Teensy vs. Arduino

| Adam Kumpf

We’re always on the lookout for cool new prototyping technologies to fold into our work.  Arduino-based tools are one of our staple platforms since they are fast to setup while still being easy to extend (there are currently more than ten different sizes and configurations of Arduino) and share with clients for further development.

We got our hands on a couple of Teensy and Teensy++ 2.0 development boards a few months ago, and these guys are incredibly small for all the functionality they provide.  They are Arduino-like (small, simple, can be programmed via Arduino software over USB with an add-on, and use an Atmel microcontroller), but also provide some additional features.  Instead of an off-board FTDI serial controller, the microcontroller has built in USB for programming; this frees up the chip’s serial port for other uses and also gives the Teensy the ability to emulate other USB devices (such as keyboard and mouse).  The Teensy still uses standard 0.1 inch pin spacing for breadboarding, but includes 25 I/O pins (and 45 on the Teensy++) within a very small footprint.  There’s also more PWM, memory, and analog inputs than the other small-form Arduinos.

Teensy is mostly open source (you can check out some code snippets, schematic, and PCB footprint, but not the full component layout or codebase), so you once you get your hand on some parts you can use them in new and unusual ways.  We’ve been experimenting with some add-ons for Teensy and look forward to sharing them with you in future posts.

In the meantime, we encourage you to check out Teensy (as well as other new microcontroller platforms) for projects that demand smaller sizes, higher pin counts, and USB device capabilities, but otherwise stick with Arduino (and keep that warm fuzzy feeling that hardware modifications are encouraged) when possible.


2 Comments »