OMER@ITP

Here’s a quick way of pulling data from your Arduino sensors.

1. First, fire up your UNIX terminal. Stop being politically correct, you’re using OSX.
2. Now, get a list of what’s being passed around in tty. That’s a protocol that, among other things, is used to communicate with the arduino. Here’s how it’s done:

   $ ls /dev/tty.*

3. Now, check that you know what channel you’re working on. Mine appears to be:

   /dev/tty.usbmodem621

4. If you don’t know the way UNIX systems treat everything as a file, read about it. “Listening” to any file in this path will yield a stream of bytes. You can pass it to a file using > or view it and communicate with it using screen, which just opens a new serial terminal within that terminal:

   $ screen /dev/tty.usbmodem621

The screen program is very useful: it’s actually a full terminal. Read the documentation to be able to do some really useful stuff.

For example, here’s how you dump your arduino output to a file:

screen -L /dev/tty.usbmodem621 9600

with your device name replacing usbmodem621.

According to the internet, the source formula for notes is \[f_{b}\left(\tau\right)=b\cdot2^{\tau/12}\] with \(b\) being the base note frequency and \(\tau\) being the distance from it in half-tones. In this case we’ll use\[b=A_{1}=110_{\text{Hz}}\] as our base tone, so the formula for anything above \(A_{1}\) is: \[{f_{A_{1}}\left(\tau\right)=110\cdot2^{\tau/12}}_{\text{Hz}}\]

Ok, now here’s the thing: Arduino doesn’t like floating point operations. Also, you’re working on a limited set of note pitches. To make these calculations more reasonable, try precomputing a lookup table. There’s already one around called pitches.h, but if you want more control over the base pitch (or for educational purposes, here’s how to do it:

1. Pick your base frequency. Note that it doesn’t have to be the lowest frequency: moving \(-12\) half-tones gives \(110\cdot 2^{-1}=110\cdot \frac{1}{2}=55\) which is fine.
2. Write a for loop to generate text for your header (up soon).

All set.

Referring to Tom Igoe’s essay, Physical Computing’s Greatest Hits (and Misses), the assignment was to find some examples spotted in the wild, and say something about them.

Yeah, well, hold on.

Physical Computing is quite a general term. It’s so general that it’s one of the only two categories I can think of where Jell-o, rocks and keyboards can all fit comfortably. It certainly has enough space for more ‘Hits’ (and way, way, more misses).

So here’s a thing I’ve seen in the wild (bonus: wild also available in the thing):

The Nintendo Power Glove. 1989. Actually developed by Thomas Zimmerman and Jaron Lanier as the DataGlove. Lots of implementations exist. Even I made one for PComp class.

Most of the devices discussed in Igoe’s article share a common purpose: they were invented to measure a human activity in and translate it to a control or data collection. If that’s the case, I guess computer keyboards are fine as well. Humans tend to be kinetic (few exceptions exist). We’re only beginning to explore the space of human input (the mouse certainly isn’t a mandatory step in the evolution of physical computing. Had it not been around, I figure it would’ve been on this list), and it’s only reasonable that some of these devices become standard. Missing in the list: perspiration meter, EEGs.

The other part of the list involves output, and sometimes feedback. And that’s a completely different story, because the rest of the physical world is not human shaped. Here’s one I like: 

There’s huge potential in that. Getting feedback from the arduino and using it to balance the object, one day a cost-effective version of MIT Media Labs ZeroN could be easy to build and place in a classroom. Or all over my apartment.

Roundabouts. Yes, that’s technology. Someone had to invent it to solve a problem in modern life, people adopted it, engineers proved its efficiency. Roundabouts make a lot of sense. 

Here’s why: since its conception, the use of the roundabout is pretty much clear. There are rules of use, there are clear violations, set in law. Watching people use roundabouts in NYC is near impossible, so I’ll try my own experience.

Here’s how it should work:

• Car approaches roundabout.
• If there’s no car approaching at the run of the track (ordered by direction of driving) node, enter.
• Exit at your destination.

Under some assumptions (cooperation of all players, probable speed, clear vision, no malfunctions in vehicles) , that approach would work. In lots of countries, it does. Even in Israel (~500 killed in traffic accidents/year, 7mil population, 7*10^-5 ratio), the number of roundabout-related accidents is really low.

The Oramics was designed by Daphne Oram (BBC) and initially had a working model in 1957. It’s a synthesizer with an optically controlled oscillator and amplifier, which accepted transparent film as input. The envelope (and pitch) were drawn on the film in levels of black.

Here’s what the initial circuit construction looks like:

This is the first attempt at insulation: