{"id":697,"date":"2009-10-10T13:02:38","date_gmt":"2009-10-10T18:02:38","guid":{"rendered":"http:\/\/itp.indiamos.com\/blog\/?p=697"},"modified":"2017-12-28T01:01:01","modified_gmt":"2017-12-28T06:01:01","slug":"pongbox","status":"publish","type":"post","link":"https:\/\/itp.indiamos.com\/blog\/2009\/10\/10\/pongbox\/","title":{"rendered":"Pongbox"},"content":{"rendered":"

For week 2 of Understanding Networks<\/a>, a newly created class that keeps shifting between abstraction and application, leaving me sadly uncertain as to whether I understand what Tom’s talking about at any given moment, our terrifying assignment was as follows:<\/p>\n

Socket exercise: communicating in realtime. I will give you a game platform and the protocols to log in and communicate with it. Make a client to log in and play. Work in Processing, Flash, Arduino or whatever environment is comfortable to you. You will not play with your own client, but you’ll show someone else how to use it.<\/p><\/blockquote>\n

As Tom apprised us of this mission, I felt a panicky fit of rage welling up, and in my head I started to whine. This is such a pure ITP experience: spend two and a half hours trying to follow a discussion about something totally vague, and in the last two minutes get an assignment that’s way over my head, with absolutely no instruction in how to do it. Fucking PhysComp<\/a> all over again.<\/em><\/p>\n

I stomped out of the room and headed to my next activity alternately fuming and telling myself, Shut up, shut up, shut up! Stop bitching about how you can’t do this, and instead think about what you’re going to do! Because at midnight on the night before the thing is due, you know you’re going to bite the bullet and start doing something. How about starting early, for once, instead of wasting time being indignant?<\/em><\/p>\n

Yeah, this is how things are in my head these days.<\/p>\n

So I thought about it, and I decided not to overthink it. I wanted to avoid fucking with Processing<\/a> (an ongoing aversion, apparently developed sometime in the first semester, although I enjoyed ICM<\/acronym><\/a>), so I would just make a simple device that would have an obvious physical mapping: an accelerometer-based controller that would move the Ping-Pong paddle right when you tilted your hand to the right, left when you tilted your hand to the left, up and down blah blah, with a switch to restart the game or whatever. I thought I’d make it as small and light as possible, wearable on the back of the hand. Tr\u00e8s elegant.<\/p>\n

Well. Once I’d figured that out, I panicked less. So much less that I still didn’t feel a need to start the project until the afternoon before it was due. Curses! Foiled again!<\/p>\n

I gathered all my electronics crap on Wednesday afternoon and took it to school, which I’d heard was a place where some people do their homework. On the way, I picked up a peppy red accelerometer<\/a> at the NYU computer store. I set up in one of the least comfortable and work-friendly parts of the lounge and started casually wiring stuff together. I have conductive thread and enjoyed sewing the circuit for the drawing glove last fall, but I also wanted to follow the very wise advice that Peter Raymond<\/a> had given in Wearables<\/a> this spring\u2014which is the same advice a lot of people give, but for some reason the way he said it sunk in\u2014and focus on knocking together a prototype as quickly and dirtily as possible, so that I could get a sense of whether it worked before<\/em> I started to obsess about making it look nice.<\/p>\n

So I took the LilyPad and USB-mini cable I’d bought last spring out of their plastic baggies, dug up the Sparkfun FTDI Basic Breakout board<\/a> I’d bought a year ago, and\u2026noticed that the pins on the breakout board and the LilyPad didn’t match. Because although the LilyPad, which I’d gotten at the NYU store, was in a baggie labeled with the current Sparkfun part number<\/a>, it was, in fact, the LilyPad Arduino 02<\/a>, which has four pins to the breakout board’s six.<\/p>\n

\"LilyPad<\/a><\/p>\n

That Arduino was old when I started<\/em> at ITP, and I’d deliberately avoided buying one from the NYU store last fall, because I’d read about the new six-pin version on Sparkfun and noticed that the local store still had old stock. By the time I bought LilyPad one the following spring, though, they should have been through with them\u2014and perhaps they didn’t realize that they weren’t, because the thing was in a baggie labeled with the wrong part number. The result was a pain in my ass, leaving me with a device I couldn’t easily plug into a USB cable. I stared at the schematic, and at the breakout board, and the LilyPad itself, using a loupe so that I could read the labels on the pins in the by the lounge’s dingy evening light. Then Zach Taylor<\/a> looked at it with me and confirmed my hope that I could use wires to connect the pins on the Arduino to the relevant pins on the breakout board. Then I found a packet of female-to-female jumper wires among my electronics junk, and I thought my problem was solved. I hooked up the accelerometer using pliers and wire, plugged everything in, and . . .<\/p>\n

\"Ghetto<\/a><\/p>\n

It didn’t work.<\/p>\n

I couldn’t get Arduino-the-app to talk to Arduino-the-board. The LED on the board lit up, and it did a bit of blinking, but it didn’t seem to be listening. Having had similar issues with the Arduino NG which the NYU store had sold me\u2014another instance of their selling outdated hardware, and the current board (and the one they sold to everyone else in my PhysComp class) was then the Diecimila\u2014I tried pressing the reset button at various times before and after clicking the upload button in the app. Meanwhile, Snow Leopard was giving me a message about a new something-something being installed everytime I plugged the Arduino in, and I wasn’t sure what that was about. I spent some time looking at posts on arduino.cc troubleshooting forum<\/a>, but without another board to use for testing, I couldn’t tell where the problem might lie\u2014was it my ad-hoc cable adapter, or Snow Leopard, or the finicky LilyPad? So I took the whole mess home, so I could try again with my known-to-be-functional Duemilanove.<\/p>\n

The Duemilanove worked eventually, of course, but it’s too big to wear on the back of your hand, so I switched from a wearable model to a handheld device. So I ended up cutting some holes in a Sparkfun box, taping the board in place inside, and printing a label for the top. Simple cue: if the text is upside-down when you’re holding the box, you’ve got it facing the wrong way.<\/p>\n

\"Pong<\/a><\/p>\n

The final Processing code, infinitesimally modified from what Tom supplied to us<\/a>:
\n[java]
\n\/*
\n Serial String Reader + Simple net Client
\n Language: Processing<\/p>\n

Reads in a string of characters from a serial port until
\n it gets a linefeed (ASCII 10). Then splits the string into
\n sections separated by commas. Then converts the sections to ints,
\n and prints them out.<\/p>\n

* Starts a network client that connects to a server on port 8080,
\n * sends any keystrokes pressed.<\/p>\n

created 2 Jun 2005
\n modified 6 Aug 2008
\n by Tom Igoe
\n modified 24 September 2009 by India Amos
\n *\/<\/p>\n

import processing.serial.*; \/\/ import the Processing serial library
\nimport processing.net.*; \/\/ import the Processing networking library<\/p>\n

Serial myPort; \/\/ The serial port<\/p>\n

Client myClient; \/\/ instance of the net Client
\nString data; \/\/ string to hold incoming data
\nString ipAddress = “128.122.151.178”; \/\/ address of the server
\nString myKey1; \/\/ the virtual keypress generated by the x-pin of the accelerometer
\nString myKey2; \/\/ the virtual keypress generated by the y-pin of the accelerometer
\nString myKey3; \/\/ the virtual keypress generated by the switch
\nString myKeyBuffer; \/\/ all the virtual keys pressed by a single bleat from the Arduino <\/p>\n

float bgcolor;\t\t \/\/ Background color<\/p>\n

void setup() {
\n \/\/ establish the background and foreground:
\n size(200, 200);
\n background(50);
\n fill(200);<\/p>\n

\/\/ Connect to server on port 8080
\n myClient = new Client(this, ipAddress, 8080);<\/p>\n

\/\/ List all the available serial ports
\n println(Serial.list());<\/p>\n

\/\/ I know that the first port in the serial list on my mac
\n \/\/ is always my Arduino module, so I open Serial.list()[0].
\n \/\/ Change the 0 to the appropriate number of the serial port
\n \/\/ that your microcontroller is attached to.
\n myPort = new Serial(this, Serial.list()[0], 9600);<\/p>\n

\/\/ read bytes into a buffer until you get a linefeed (ASCII 10):
\n myPort.bufferUntil(‘\\n’);
\n}<\/p>\n

void draw() {
\n}<\/p>\n

\/\/ serialEvent method is run automatically by the Processing applet
\n\/\/ whenever the buffer reaches the byte value set in the bufferUntil()
\n\/\/ method in the setup():<\/p>\n

void serialEvent(Serial myPort) {
\n \/\/ read the serial buffer:
\n String myString = myPort.readStringUntil(‘\\n’);
\n \/\/ if you got any bytes other than the linefeed:
\n if (myString != null) {<\/p>\n

myString = trim(myString);<\/p>\n

\/\/ split the string at the commas
\n \/\/ and convert the sections into integers:
\n int sensors[] = int(split(myString, ‘\\t’));<\/p>\n

\/\/ print out the values you got:
\n print(sensors[0] + “,”); <\/p>\n

\/\/ If there’s incoming data from the client:<\/p>\n

if (myClient.available() > 0) {
\n \/\/ get the data:
\n data = myClient.readString();
\n println(data);
\n }<\/p>\n

if (myKeyBuffer != null) {
\n \/\/ send out anything that’s typed:
\n myClient.write(myKeyBuffer);
\n }
\n if (keyPressed) {
\n \/\/ send out anything that’s typed:
\n myClient.write(key);
\n }
\n }
\n}[\/java]<\/p>\n

The final Arduino code, cribbed from Arduino.cc<\/a>:
\n[csharp]
\n\/*
\n ADXL3xx<\/p>\n

Reads an Analog Devices ADXL3xx accelerometer and communicates the
\n acceleration to the computer. The pins used are designed to be easily
\n compatible with the breakout boards from Sparkfun, available from:
\n http:\/\/www.sparkfun.com\/commerce\/categories.php?c=80<\/p>\n

http:\/\/www.arduino.cc\/en\/Tutorial\/ADXL3xx<\/p>\n

The circuit:
\n analog 0: accelerometer self test
\n analog 1: z-axis
\n analog 2: y-axis
\n analog 3: x-axis
\n analog 4: ground
\n analog 5: vcc
\n digital 2: push-button switch<\/p>\n

created 2 July 2008 by David A. Mellis
\n modified 26 June 2009 by Tom Igoe
\n modified 24 September 2009 by India Amos<\/p>\n

*\/<\/p>\n

\/\/ these constants describe the pins. They won’t change:
\n const int groundpin = 18; \/\/ analog input pin 4 — ground
\n const int powerpin = 19; \/\/ analog input pin 5 — voltage
\n const int xpin = 3; \/\/ x-axis of the accelerometer
\n const int ypin = 2; \/\/ y-axis
\n const int zpin = 1; \/\/ z-axis (only on 3-axis models)
\n const int pushbuttonpin = 2; \/\/ digital input <\/p>\n

void setup()
\n {
\n \/\/ initialize the serial communications:
\n Serial.begin(9600);<\/p>\n

\/\/ Provide ground and power by using the analog inputs as normal
\n \/\/ digital pins. This makes it possible to directly connect the
\n \/\/ breakout board to the Arduino. If you use the normal 5V and
\n \/\/ GND pins on the Arduino, you can remove these lines.
\n pinMode(groundpin, OUTPUT);
\n pinMode(powerpin, OUTPUT);
\n pinMode(pushbuttonpin, INPUT);
\n digitalWrite(groundpin, LOW);
\n digitalWrite(powerpin, HIGH);
\n }<\/p>\n

void loop()
\n {
\n \/\/ print the sensor values:
\n Serial.print(analogRead(xpin));
\n \/\/ print a tab between values:
\n Serial.print(“\\t”);
\n Serial.print(analogRead(ypin));
\n \/\/ print a tab between values:
\n Serial.print(“\\t”);
\n Serial.print(analogRead(zpin));
\n \/\/ print a tab between values:
\n Serial.print(“\\t”);
\n Serial.print(digitalRead(pushbuttonpin));
\n Serial.println();
\n \/\/ delay before next reading:
\n delay(50);
\n }
\n[\/csharp]<\/p>\n

And here’s the software we played against<\/a>, more or less.<\/p>\n","protected":false},"excerpt":{"rendered":"

For week 2 of Understanding Networks, a newly created class that keeps shifting between abstraction and application, leaving me sadly uncertain as to whether I understand what Tom’s talking about at any given moment, our terrifying assignment was as follows: Socket exercise: communicating in realtime. I will give you a game platform and the protocols … Continue reading Pongbox<\/span> →<\/span><\/a><\/p>\n","protected":false},"author":6,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false},"categories":[12,11,4,6,45],"tags":[],"jetpack_featured_media_url":"","jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/s3qY10-pongbox","_links":{"self":[{"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/posts\/697"}],"collection":[{"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/comments?post=697"}],"version-history":[{"count":18,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/posts\/697\/revisions"}],"predecessor-version":[{"id":944,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/posts\/697\/revisions\/944"}],"wp:attachment":[{"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/media?parent=697"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/categories?post=697"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itp.indiamos.com\/blog\/wp-json\/wp\/v2\/tags?post=697"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}