tisdag 9 mars 2010

Slut

Kursen är slut, och trots allt arbete blev bordet ganska enkelt till slut.

Visst hade produkten ett egenvärde i att vara relativt monolitisk, och black-box-artad. Man förstod inte riktigt vad man skulle göra, och besökarna på mässan tyckte att det var kul och roligt ett tag eller så. Men frågan är om de kom för skärmen eller för teet och kakorna :)

Bland annat pongspelet lyckades med en mycket intrikat interaktion med tämligen enkla medel - de hade inte ens behövt sina poängstaplar. Vårt bord blev betydligt enklare på det sättet.

Vi hamnade i "sensor-koma" två gånger under kursen. Dels för hypnosmaskinen, och delvis under bordsbyggandet. Att ha två olika sensorer för att detektera tekopparna var tämligen krångligt och i efterhand ganska ondödigt. Mycket hade kunnat göras med bara fotosensorer (faktum var att man med finurlig programmering hade kunnat läsa av otroligt mycket med dem).

Nåja, det var bara prototyper. Jag har lärt mig väldigt mycket, som jag trodde att jag redan kunde, det var en befrielse att äntligen få hålla på med arduino och liknande.

Vad hade jag gjort annorlunda till nästa gång? Jag hade tittat ännu mer på vilken interaktion som varit önskvärd, och gjort ordenliga skisser redan från början, vi började någonstans och sedan såg vi vad det blev. Att vi var tre i gruppen, med lite olika önskemål, gjorde också sitt till för att få en sammanhängade tanke bakom det hela.

Intryck och upplevelse
Effekter då? Fick man en bra upplevelse? Jag upplevde att skärmen var svår att arbeta med på ett sätt, vi hade stora problem med att hitta motiv som inte kom upp och ner för en av användarna. Det problemet förekommer ju inte i datordesign som den ser ut idag (eftersom att alla ser skärmen med samma orientering). Hur det skulle användas på ett kreativt sätt var svårt. Vi försökte dels med symmetriska motiv, och dels med sådana som syntes uppifrån.

En av de mest intressanta applikationerna var att visa bilder från en webkamera i bordet. Att ha en dedikerad maskin som inte riktigt är en dator som man känner till den, som visar bilder någon annanstans, det kändes lite magiskt. Vi provfikade bordet samtidigt som vi filmade ut mot Valhallavägen, och blev efter en stund varse bussar och små människor, trafikens växlingar, fåglar som flög och annat man vanligtvis inte ser.

Det vore fantastiskt spännande att göra mer genomtänkt implementation med det innehållet - alltså bilder utifrån. I synnerhet i rum med dålig utsikt.

Tekniska lösningar
Att använda olika programmeringsspråk och utvecklingsmiljöer var ett visst problem. Genom att vara väldigt van vid Processing tog jag mycket av programmeringsarbetet, vilket gjorde uppgiften på ett bra sätt.

Att använda Arduino var också väldigt bra, den känns ganska robust, och vi använde Firmata, och kunde ganska enkelt debugga och konfigurera med ett exempelprogram för debugging som följde med i arduinobiblioteket.

Sensorerna tejpades och löddes hejvilt. Det blev bra till slut. Vi upptäckte att man egentligen hade kunnat dektera mycket mer med bara fotocellerna, medans värmesensorerna var mycket långsammare i att "svara".

Det var vissa problem med att programmera på dedikerad hårdvara. Bara en dator var konfigurerad för ändamålet, vilket gjorde det svårt för andra att få någon direkt känsla för den till slut ganska röriga koden.

Det finns stor kommersialiseringspotential i sådana här saker.

Bilder och mer kommer.

måndag 1 mars 2010

Bordet nästan klart - för mycket sensorer


Hidden and forgotten underside of the table. Screen + breadboard + arduino.
Another groups marvellous artwork. I love it.
Our table in action, a self laying puzzle! You can se the two magic cup-places, and the screen with the pussle "Afrika".

The table did also work as a workspace for the project, very practical. It was nice for the other teammembers to see and discuss the same source code as the one programming. That made the programming faster.






I helgen programmerade jag e bildbytesalgoritm för bordet. Den kan ta serier av bilder (tio i varje) och växla mellan dem genom transparens och så.

Idag lyckades vi få till det så att den blev temperaturkänslig och faktiskt kunde känna av om det stod koppar eller inte på bordet.

Vi la även till en snygg bordsduk och ett antal nya serier.

Från början var tanken att man skulle få upp citat på bordet, så att man kunde diskutera kring dem. Det verkar numera vara möjligt, och Johan byggde några snygga citat här på kvällskvisten.

Det var betydligt svårare än jag trodde att få programmeringen hyffsad. Interaktionen är ganska bra, men det är alltid en avvägning om den är för snabb eller för långsam. Några användartestar har vi inte hunnit med, förutom att prova bordet själva - vilket har varit mycket mycket lärorikt. Så fort man ställer undan datorn det kör på, märker man vilken dålig kontroll man har, och vilka brister som finns. Interaktionsmöjligheterna är ju dessutom verkligen små.

Om man är lite efterklok skulle man kunna ha tidsinställt allt, så att det enda som spelade in på vilka bilder som visades är hur länge kaffekopparna har stått på ett ställe - det är egentligen det enda viktiga. Alltså har vi gjort en hel del i onödan, kanske för att vi inte prototypade ordentligt innan. Då hade vi kanske kommit fram till att den funktionalitet vi ville ha, egentligen bara krävde ljus-känsliga sensorer idag.

Bildvisningen är inte heller optimal - transparensen gör att bilderna liksom försvinner iväg mellan varven. Det duger för en prototyp, dock. Hade jag gjort bordet igen, hade jag nog bara använt ljus-sensorer.

Redovisningen ska vi arbeta hårt med, den kan göras väldigt bra.

De andra grupperna hade väldigt ambitiösa byggen, och nästan alla var betydligt större än vårt. Kanonen var nog ett av de mest spännande, med tanke på hur enkelt det egentligen var. Pongspelet hade en elegant enkelhet (vi diskuterade att man skulle kunna implementera det på vårt kaffebord också, genom att låta racketet åka uppåt när det var ljus, och ner när det var mörkt).

Apropå galna extraimplementationer, har vi diskuterat otroliga mängder saker man fakitskt kan göra med bordet, allt från spel till väldigt platsspecifika roliga saker, till exempel att det springer runt en mus och äter ost, eftersom det finns ett litet "råtthål" vid skärmen för att kunna slå på skärmen.

Tyvärr har vi inte fått med minnesfunktionen - att när det fanns koppar på bordet, skulle det byggas upp någon typ kristall i närheten av den koppen, så att bordet kunde fungera som en historia - och berätta vad som hänt tidigare under dagen.

onsdag 24 februari 2010

halvfärdigt bord


Bord med skärm - rolig idé, men inte så ergonomiskt för Jonas.
Provar temuggsdetektor.



Efter vår session igår, när vi gjorde skärmen i bordet (bilder kommer), blev jag helt förhäxad av att man kunde använda bordet för att visa bilder. Bilderna fick en helt annan närvaro när de visades liggandes på bordet av någon anledning.

Vi satte in fotosensorer och värmesensorer i bordet, som är kopplade till en arduino som sedan är kopplat till processing.

Efter en kort brainstorming kom vi fram till att bordet ska känna av om någon ställer en kopp på bordet och då börja visa en bildserie. Bildserien ska sedan gå framåt ju varmare sensorerna blir. Om man ställer på bara en kopp, får man se ungefär halva serien, om två koppar får man se hela.

När sensorerna svalnar igen går "filmen" baklänges.

Arbetar på att få till kul saker att visa och göra en enkel bildbytare i Processing.

måndag 22 februari 2010

A hole in the table

Today I saw what my projekt mates had decided and programmed during the week away.

A really good job, with some really nice processing code that morphed in and out a text, and fun interface based on heat and simple object detection with photocells.

Today we essentially just made a about A4-sized hole in a table bought by Johan and a screen also brought by Johan. Really good job of him to buy it.

I'm really happy my project mates didn't use my idea of using a medusa lamp, because that would not bring good interaction in a simple way. I have to explore the medusa lamp interaction system further, but with another project.

We had good help from elab with drills and so on for making the hole. Unfortunantley they didn't have a "stich saw" (sticksåg) which made it nescessary to use a drill and saws in a creative way. We missed some holes for the On-button for the screen - embarrasing. Luckily we can go drill tomorrow as well.

Tomorrow we will maybe paint the table (but where?) and make sure the interaction works as expected.

We also have problems with configuring the sensors to map well to the program (especially since the light condition "always" changes, depending on the position and so on). I will investigate a way to dynamically adjust the "strengt" of the "light" by some simple integration method from control theory. The main problem seems to be to detect when a photocell is covered (and hence not should be integrated to compensate) and when a photocell is open to the light. We need to explore that with some different dataseries. Hopefully some processing and controlled experiments can give answers to good limits. This is engineering!

måndag 8 februari 2010

two entries for the main blog

I made two entries for the main course blog, one about photosynth, and one about the interesting libavg.

onsdag 3 februari 2010

Dagsrapport 3 feb







Genomgångar av Arduino och lite elektronik.

I jämförelse med Phidgets tycker jag att Arduino verkar vara en dröm att programmera. Men den har andra problem. Till exempel stötte vi direkt på patrull när vi ville överföra flera data på en gång från Arduinon till datorn. Direkt måste man börja ta hänsyn till vilken datatyp det är etc.

Kanske är Firmata något för oss.


Böjsensorer genom spänningsdelare (1 k motstånd) in i Arduinon. Bara ett av motstånden används!

Böjsensoroutput i processing (utgick från potentionmeter-exempel från Arduinos hemsida)


Arduino inkopplad. Bara ett av motstånden används!

Exempel (med dåligt ljud) som visar det hela in action.

Dagens källkod:

Arduino
/*
Graph
A simple example of communication from the Arduino board to the computer:
the value of analog input 0 is sent out the serial port. We call this "serial"
communication because the connection appears to both the Arduino and the
computer as a serial port, even though it may actually use
a USB cable. Bytes are sent one after another (serially) from the Arduino
to the computer.
You can use the Arduino serial monitor to view the sent data, or it can
be read by Processing, PD, Max/MSP, or any other program capable of reading
data from a serial port. The Processing code below graphs the data received
so you can see the value of the analog input changing over time.
The circuit:
Any analog input sensor is attached to analog in pin 0.
created 2006
by David A. Mellis
modified 14 Apr 2009
by Tom Igoe and Scott Fitzgerald

*/


void setup() {
// initialize the serial communication:
Serial.begin(9600);
}
void loop() {
// send the value of analog input 0:
Serial.println(analogRead(3));
// wait a bit for the analog-to-digital converter
// to stabilize after the last reading:
delay(100);
}

Processing:
Instansierar en sinusoscillator och ritar grafen på skärmen. Vid varje serial-event uppdaterar den kurvhöjd och sätter frekvensen på skärmen.

// Graphing sketch


// This program takes ASCII-encoded strings
// from the serial port at 9600 baud and graphs them. It expects values in the
// range 0 to 1023, followed by a newline, or newline and carriage return

// Created 20 Apr 2005
// Updated 18 Jan 2008
// by Tom Igoe

import processing.serial.*;

Serial myPort; // The serial port
int xPos = 1; // horizontal position of the graph


// SOUND:

import ddf.minim.*;
import ddf.minim.signals.*;
Minim minim;
AudioOutput out;
SineWave sine;

void setup () {
// set the window size:
size(400, 300);

// List all the available serial ports
println(Serial.list());
// I know that the first port in the serial list on my mac
// is always my Arduino, so I open Serial.list()[0].
// Open whatever port is the one you're using.
myPort = new Serial(this, Serial.list()[0], 9600);
// don't generate a serialEvent() unless you get a newline character:
myPort.bufferUntil('\n');
// set inital background:
background(0);
//sound
minim = new Minim(this);
// get a line out from Minim, default bufferSize is 1024, default sample rate is 44100, bit depth is 16
out = minim.getLineOut(Minim.STEREO);
// create a sine wave Oscillator, set to 440 Hz, at 0.5 amplitude, sample rate from line out
sine = new SineWave(440, 0.5, out.sampleRate());
// set the portamento speed on the oscillator to 200 milliseconds
sine.portamento(200);
// add the oscillator to the line out
out.addSignal(sine);
}
void draw () {
// everything happens in the serialEvent()
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

if (inString != null) {
// trim off any whitespace:
inString = trim(inString);
// convert to an int and map to the screen height:
float inByte = float(inString);
inByte = map(inByte, 0, 1023, 0, height);

// draw the line:
stroke(127,34,255);
line(xPos, height, xPos,map(inByte,9,34,0,height));
//System.out.println(inByte);
float freq = map(inByte, 9,34, 1500, 60);
sine.setFreq(freq);

// at the edge of the screen, go back to the beginning:
if (xPos >= width) {
xPos = 0;
background(0);
}
else {
// increment the horizontal position:
xPos++;
}
}

}

void stop()
{
out.close();
minim.stop();
super.stop();
}


MIDI from Processing to Ableton Live!


There was success! I can now send MIDI messages from Processing to Ableton Live.
I use the MidiBus for Processing, which had some basic example that got me started, and the internal Midi loopback device in Mac OS X (called busses, reachable from Applications/Utilities/Sound and Midi. It's just to go into the Midi View through the Window menu and be sure that the IAC-driver is enabled, like in the picture.

Then it's just to enable that midi-input as a Track (or remote) in Ableton.

The Basic.pde, that followed midibus, shows the following devices:

Available MIDI Devices:
----------Input----------
[0] "Buss 1"
[1] "Port 1"
[2] "Real Time Sequencer"
----------Output----------
[0] "Buss 1"
[1] "Port 1"
[2] "Real Time Sequencer"
[3] "Java Sound Synthesizer"
If i initialize the midi-object with the Buss1 as output, I can speak to Live with midi!

I found a handy midi-reference (but then I know midi from before quite well). This one is on bit-level. This one is also on bitlevel, and is the Midis own.

However, there are some problems involved in handling midi-events. First and foremost: Notes have to be turned of. This can be solved by using some kind of queue for all the events. A more serious problem is that every program handles midi in different ways - after all, it has very rudimentary "data types" - notes on, control changes and patch-changes.

This can be overcomed by making a special setup in Live, which always is loaded when one want to work with the prototype. That's acceptable.

Now - it's just to start working! :)