Jasonmcdermott » sensing

Phidget Interface Kit + Processing

Jason — Thu, 13 Aug 2009 06:51:52 +0000

Here’s a simple example for connecting a PhidgetInterfaceKit 8/8/8 to a computer, using Processing.

You will need to download the phidget21.jar package from the phidgets website, find it in the ‘Programming’ section in the java examples section. Once downloaded, just use Sketch>Add File… to add the file to your sketch. Connect via USB and you’re ready to go. I’ve labelled variables based on the sensors I was using, feel free to reassign and use as you will;…


import com.phidgets.*;
import com.phidgets.event.*;
InterfaceKitPhidget ik;// swap these labels for the actual sensors you have
float mot;
float temp;
float hum;
float light;
int xPos;
void setup(){
size(400,300);
setupIK();
smooth();
}
void draw(){
// the main interfaces for data input /
outputreadIK();
// clear the previous frame,
// draw a new background of greyscale value 200
background(200);
// draw the sensor input
datamot = map (mot,0,1000,0,height);
fill(255,0,0);
noStroke();
ellipse(xPos,(height-mot),10,10);
// this controls the graph position onscreen,
// it animates the graph and refreshes to the 0 position
// when the graph goes offscreen
if (xPos >= width){xPos = 0;}else {xPos++;}}
void setupIK() {
try{
ik = new InterfaceKitPhidget();
ik.openAny();
println("Waiting for Phidget");
ik.waitForAttachment();
println("OK ready to go");
}
catch(Exception e){println("ERROR");
System.out.println(e);}
}
void readIK(){try{
// the ports are considered an array, with 8 ports in total
// the first port is array number 1, but it is addressed as port 0
// since it is 0 elements away from the start of the array.
// make sure your 'motion' sensor is located at sensor port 1 (number 0)
// and your 'light' sensor is at sensor port 2 (number 1)
mot = (float)ik.getSensorValue(1);//
light = (float)ik.getSensorValue(1);//
hum = (float)ik.getSensorValue(2);//
temp = (float)ik.getSensorValue(3);}
catch (Exception e){println(e.toString());}
}

Phidget Servo motor output via Processing

Jason — Wed, 12 Aug 2009 12:04:14 +0000

I’m currently preparing for a short piece of processing tutoring in the Bachelor of Architecture course, commencing tomorrow. The course is a 1st year construction subject, in which the year group is designing modular structures from found objects (read; whatever they can find in large amounts at Reverse Garbage), with a 12-15 unsuspecting students are going to be shown the slippery slope that is processing, all in the aim of augmenting small construction projects with responsive elements.I’ve used the standard phidget servo motors with max/msp before, but I’ve decided to switch focus to processing so such solutions will no longer suffice. There are some benefits to not using max/msp in the university context;

Runtime – i can’t count the number of times we’ve built test prototypes and final projects only to see them fall over due to the small number of licences we’ve access to on campus. The runtime solution is acceptible for last minute, last chance, last straw moments but it’s just not good enough for day to day use or experimentation.
The extraordinary cost of licensing – the licences bought by the university come at a ridiculous cost, not to mention the involved installation process. Processing by comparison is such a simple install – for both the core components and the additional libraries.
Extensibility – max/msp additional objects are always a welcome addition to the program, however the objects themselves tend to be closed off, limited in how much they reveal of their inner workings and can be fairly slow.

To this end I’ve enjoyed the processing learning curve, there’s been more than enough learning resources available online and in book form, so I’m definitely pushing for its’ inclusion in the syllabus in the arch. faculty. Anthony Burke has been teaching processing in the master of architecture course this semester (with assistance from the computation whiz-kid Ben Coorey), so along with the arduino hardware the transition from proprietary to open-source projects is well under way in the DAB.So to proceed with the real agenda of this post, I was searching for simple code to interface with the PhidgetServo motor output units we’ve been using, this time working in processing. I couldn’t find any decent examples online so had to cobble together one myself.Read on for more;…


import com.phidgets.*;import com.phidgets.event.*;
// Declare Variables - a ServoPhidget object called 'sp',
// a Double called 'pos' and an integer called 'xPos'ServoPhidget sp;
// Declare the servophidgetdouble pos;
// this is a type of number, which can store more decimal
// place values than the standard floating point value,
// check the referennce pageint xPos;
// Set size, video framerate, connect to and open phidget object
void setup(){
frameRate(20);
size(400,300);
try{
// Create & Assign the servophidget
sp = new ServoPhidget();
sp.openAny();
println("Waiting for Phidget");
sp.waitForAttachment();
// if you do not see this below in the console,
your phidget is not connected
println("OK ready to go");
} catch(Exception e){
println("ERROR");
System.out.println(e);
}
}
void draw(){
background(200);
// map the mouse x coordinate to the
// available range of the servophidget
pos = map(mouseX,0,width,-22.9,232.0);
// read the data from the phidget
try{
sp.setPosition(0,pos);
sp.getPositionMax(0);
// checking the max and min values for the servophidget
double helloMax = sp.getPositionMax(0);
double helloMin = sp.getPositionMin(0);
// print a line to the console to display the data as it arrives
println("min is: " + helloMin + ", max is: " + helloMax + ", current position is: " + pos);
} catch(Exception e) {
println("ERROR");
System.out.println(e);
}
// the double variable is not used in processing,
// but is needed to send to the servophidget.
// to display this data as a graph onscreen you need
// to convert it to a floating point number
float fPos = (float)pos;
fPos = map(fPos,-22.9,232.0,0,height);
stroke(0);
//  line(xPos,0,xPos,height-fPos);
// Un-comment out the line above to draw a vertical graph of the motor
stroke(50);
line(mouseX,0,mouseX,height);
// this controls the graph position onscreen,
// it animates the graph and refreshes to the 0 position
// when the graph goes offscreen
if (xPos >= width){xPos = 0;}else {xPos++;}
}

note this requires the phidget21.jar core library file, which is included on the phidgets programming download page, just look for the Java examples download.[Update] Download the phidget jar archive here.When downloaded, copy+paste the above code into a new sketch, then select Sketch>Add File... to add the phidget21.jar file to your sketch.  After that, plug in the phidget servo + a motor and you're ready to go.



fluid blobs
Jason — Fri, 07 Aug 2009 18:15:06 +0000
Linked below are some early results from a new series of sketches I’ve been working on using Processing.  These sketches continue in a long line of projects I’ve completed recently using simple camera tracking algorithms to infer interesting patterns of movement in urban spaces.The first example is a calibrated blob tracking experiment, using the excellent and very well documented OpenCV library for processing.  A few simple modifications to the setup parameters allow for a very customisable tool, able to withstand many of the constraints live webcam installs can throw up.  I’ve tested this in a number of places (my bedroom wall, lit by a single lamp tends to be the best contrast) and will have more to say on the nature of live webcam video in the future.
OpenCV blob tracking – calibrated from Jason McDermott on Vimeo.
The second example is a first attempt at combining the live blob tracking with the wonderfully funky and playful MSA Fluid library also for processing.  This lib is geared towards touch screen interfaces and screen based mouse interactivity – but I immediately thought it would be the perfect partner for my webcam based projects (or even accelerometer/phidget/slider/midi sensor data).  It wasn’t very difficult to swap out the mousex/pmousex variables for centroid x/y data, so the first test has been deemed a success.  I showed this yesterday to Frank/Ale/Amy/george/anyone who would stop for more than 2 minutes in the interactivation studio and it was a big hit  

OpenCV + MSA Fluid (Processing) from Jason McDermott on Vimeo.
The third example is significant for a couple of reasons – it is another combination this time using recorded video of an actual installation space (filtration fields / DAB courtyard) thus requiring another version of the calibration – but also my first experiments in putting together an arrayed interface between the blobs and the fluid.To explain further; Firstly it’s easy to switch out the mouse for ‘something else’ and inferring movement velocity for a single object/blob is simple.  Secondly I wasn’t so sure about the way to apply this singular blob mousex/pmousex-esque technique to many objects at once.  Thirdly I wasn’t sure if it would all explode in one big fluorescent, particle mess!
OpenCV + MSA Fluid (processing) test 3 from Jason McDermott on Vimeo.
[Update]< >In the end I’d say it’s mission accomplished, certainly with calibration tweaks to occur before I’m happy to unleash this on an unsuspecting public.  I’d be interested to see how this could influence peoples’ behaviour in the space – whether or not we would see people dancing/swimming/painting the space of the courtyard.  I’m curious also to see how this kind of new interaction with the space of the DAB could filter into a new perception of the building as not merely a space to move through but one which is open to new forms of physical conversation.



Smart Light Fields
Jason — Wed, 05 Aug 2009 16:46:11 +0000
In addition to my involvement with the janus project for the Smart Light Sydney Festival, Joanne Jakovich and I were invited to collaborate with the NSW Department of Planning in an ambitious short term project during the festival.  The Department of Planning, along with Metropolis and D-City had the initiative to setup a small amount of resources for live event data tracking to be visualised for the duration of the festival.  Our first taste of this was in an email inviting us to join, with a specific aim towards generating realtime visual information using passive bluetooth tracking technology.I’d worked before with bluetooth tracking (in the 2008 UTS MDA masterclass Street as Platform), and I’d recently mastered the small monster of embedded MySQL insert queries so it felt quite appropriate to combine these two techniques in producing the visualisation.  In essence, the project asked for the following;

Networked and located sensor nodes, tracking any visible devices nearby
Central storage and collation,
regular output of recent activity (the last 3 hours)
visualisation of current activity and any paths of movement picked up by the sensors

The project had been allocated resources for sensor nodes, internet connections, software programming and some kind of visual output – in this case a projector.  Joanne managed to secure space in Customs House for the project to live, we arranged for the hardware and software combination to be installed and we were off the ground.  Ben Coorey (who had been a stellar student in the streetasplatform masterclass) came onboard to help us produce the visualisation in what ended up being a solid fortnight of work.  We went from concept through design and installation in just over two and a half weeks – not an insignificant feat!This project marked a first in many regards – it was the first time I’d worked in this capacity as an artist/designer with an external client, providing data surveillance and visualisation with aesthetics and information.  It was the first time I’d been given access to such a large data set, with potentially hundreds of thousands of visitors making their way to the SLSF precinct during the three weeks of festival activity.It happened to produce the first meaningful coalescence of a body of researchers Joanne and I had been working to pull together for the last 6 months – into the newly founded and launched anarchi.org.  We were now an organisation, able to pull in assistants and coders, all within the framework of a budgeted project, able to provide payment for their time.  This mightn’t seem like much of an achievement, but having worked with friends and colleagues for some time now (relying on generosity and willingness to help), it gave me a huge sense of pride in being able to offer a small sum of money to repay the hours of work put in.See Also;anarchi.orghttp://www.designbuildblog.com/2009/06/16/smart-light-fields/http://www.australiandesign.org.au/



wireless
Jason — Sun, 22 Mar 2009 12:40:58 +0000
Sorry, that should have read; wireless data which does or doesn’t want to behave predicably.Any comments/suggestions are welcome!



The Street as Platform
Jason — Sat, 22 Nov 2008 01:00:46 +0000
The Street as platform – a street rendered in data.
November has been a busy month! Along with Anthony Burke, Dan Hill and Mitchell Whitelaw, I’ve been running an intensive masterclass studio in the Master of Digital Architecture program at UTS.  The masterclass is based on one of Dan’s earlier posts called The Street as Platform, in which the notion of the static street in contemporary urban planning and architecture is discussed as an anachronistic idea and one in dire need of reform.  The street as platform talks about the dynamically linked nature of the modern street, where mobile communication, ubiquitous computing and traditional number crunching merge as a new kind of informational street ecology that exists just outside of our normal consciousness.As students and teachers of architecture, it could well be said that the dynamism of the street in it’s inhabitation and occupation is implicitly known and explored, but never clearly articulated as a driver – in it’s own right – of architectural decision making regarding form/content.
With this in mind, we set out to investigate the lived inhabitation of the street in an attempt to visualise and understand the hidden seams of activity, an attempt to make the invisible visible.Along with Dan, Anthony and Mitchell, we had a selection of super keen students and a handful of sensor equipment with we set about taming the data beast of Harris St.  Our aim was to produce some meaningful information, based on corellated data sets gleaned and generated from our surrounds.  The students searched for data on Harris st from a number of sources relative to Harris St (google, flickr, youtube, newsrolls, blogs) and then used processing to scrape, munge and visualise the data.  Also included into the mix were a number of sensors we wired up to collect site specific data such as light/temperature/humidity/rainfall levels over the last week, Bluetooth devices in the vicinity, webcam images from the street as well as audio readings and a magnetic sensor.
All up the live data feeds were a bit of a mixed bag with plenty of teething problems, but over the next fortnight these issues will look to be sorted.The students presented their work on Friday to an invited panel including marcus trimble, andrew vande moere and kirsty beilharz, one of our new professors in Design at UTS.  The presentations went very well, showcasing some very good work and sparking much discussion amongst the invited guests.The students have diligently been updating a blog with images of the process workand sketch ideas throughout the last two weeks, which can be found at http://streetasplatform.wordpress.com.  The studio will be exhibiting some of the work at the upcoming UTS Architecture exhbition on the 4th December, so come see some of the live feeds being visualised on the night.
See also; http://offshorestudio.net/ http://cityofsound.com/ http://theteemingvoid.com/



pixeltag
Jason — Sat, 22 Nov 2008 01:00:07 +0000
pixelTag is an experimental working prototype for creating digital art using hand-held devices and radio signals.The current pixelTag prototype uses the Nintendo Wii remote controller, in conjunction with Osculator and Max/Msp.  The prototype generates pixel graphics in real time,  based on x/y/z motion information sent to Max by the Wii remote.  The prototype has the ability to incorporate up to 4 artists at the same time.pixeltag has been in existence for just over a week now and so far it’s generated a small amount of buzz.
Thanks to the DAB Lab opening night schedule (which happily coincides with the weekly experimentation playtime in the interactivation studio), I’ve had the opportunity to demo the project to a widely varying audience.  Last week at the Convergence exhibition opening I was able to test the project with none other than Charles Rice, Desley Luscumbe, Adrian Lahoud and Sam Spurr as my hapless guinea pigs.  Many others were also subjected to my user testing and the feedback was generally positive.  I’m excited to see that a project in such baby steps can take on a life such as this, allowing fantastic possibilities such as collaboration and further refinement.I’ve been posting videos of the project in action to vimeo, but in case you’re in lock-down mode, I’ll be looking to embed content directly into my posts rather than linking to 3rd party software.  We’ll see how things go, watch this space.pixeltag 081106 ft. Tony Curran from Jason McDermott on Vimeo.



pixeltag playtime
Jason — Thu, 06 Nov 2008 01:00:53 +0000
Here’s the latest update from the Real Perspective show at TAP Gallery.‘pixeltag’ (2008). from Jason McDermott on Vimeo.Wicked!



Interface Edinburgh
Jason — Thu, 06 Nov 2008 01:00:37 +0000
The interface only exists between a body and it’s environment.Come to this place and see that we are outsiders, foreigners in a new land‚ naive and blissfully innocent of this place.   We seek to make a connection, an understanding, to learn from the city by touch and by feel.  By striking, pulling and tearing.  Each time we impact, resonate and crash through the layers of a city’s resistance, we learn something more of its limit.  It is conversation, but not spoken.  This information is physical.In the space of the gallery, the interface folds back on itself.  The results of our exploration are projected onto canvas‚ but only when the canvas is activated by touch.  Curious onlookers (and the many other outsiders) do not passively observe but become involved in revealing the city’s unspoken surprises.  Strangers are offered the chance to play the city instrument.  We touch, scratch and pound the canvas in the gallery, we hammer and kick and make noise.   The interfacing is deemed a success!It is the same thesis that drives a child’s desire to test unseen boundaries, we want to know our (?) place and not by mere observation.  The interface always reveals itself informed, regardless of environment – it is both body and information in one. We touch, scratch and pound the surfaces, at all times looking for an answer.  Our in-situ interface is given over to new form or understanding.  The city and gallery converse via the active canvas and the information it holds. We interface with the city in as many ways imaginable.  We play the city’s instruments, be they playful, curious or sinister.We attack and wait for response.Interface: Edinburgh (2008) from Jason McDermott on Vimeo.



pixeltag update
Jason — Thu, 30 Oct 2008 01:00:28 +0000
The pixeltag project has progressed once again;* the interface has been amended slightly to allow for yaw input (not just roll) as the ‘x’ axis data,* the ‘cursor’ item has been implemented, allowing the user to see where they are about to draw prior to doing so,* The up/down ratios have been adjusted to allow for nicer wrist movement.Tony Curran came by the studio today to give the pixeltag a test drive – he seemed pleased with the current level of interaction and novelty of the system, but asked for the following things;* IR sensor location for the ‘z’ axis (depth into/off the screen)* different input sensors (such as any one of the many phidget interfaces)* tighter control over strokes* pressure sensitivity for subtle differences (computer intuition, perhaps?) between strokesthis last point is an interesting one, as it would allow for varying conditions to be created by the user’s own interaction with the system, rather than a simple closed system with a predefined output.  I have some ideas for the nunchuck that could work well with the wii as a dual mode interface (left/right hands doing different things..!)