reactions

verbogen

Georg Fischer — Tue, 12 Jan 2010 23:50:11 +0000

In den Weihnachtsferien hatte ich eigentlich vor, einen boxsack zum Eingabegerät umzufunktionieren. Leider habe ich die dafür benötigten Drucksensoren erst heute bekommen, deshalb habe ich mich mit anderen Sensoren und ihren Möglichkeiten beschäftigt.

In der letzten Woche habe ich einige Berichte über die CES in Las Vegas gelesen. Großes Thema dort waren neben unter anderem auch E-Book Lesegeräte. Diese mehr oder weniger flachen Geräte können Texte angenehm lesbar auf ihren Bildschirmen anzeigen und sollen (irgentwann mal) das Buch als medium ablesen. Diese Geräte haben sicher einige Vorteile gegenüber den normalen Büchern, allerdings scheint mir die Nutzung noch etwas gewöhnungsbedürftig. Die E-Book Reader haben im Moment alle noch eine feste Oberfläche, im gegensatz zum Buch, dessen Seiten man verbiegen kann. Verbiegbare Bildschirme sind technisch möglich (wenn im Moment auch noch etwas teuer) und deshalb habe ich mich mit Steuerungsmöglichkeiten von verbiegbaren Oberflächen beschäftigt.

Dazu habe ich mir zwei Biegesensoren besorgt und sie an einem Stück Papierblock befestigt. Meine Biegesensoren können nur Biegung in eine Richtung messen, weshalb ich auf jeder Seite des Blocks einen Sensor angebracht habe. Ich habe ein Stück Block verwendet, um das Papier zu stabiliesieren und um sicherzustellen, dass es wieder in die Ausgangsform zurückgeht.

Der arduino Code

int XPin = 0;
int YPin = 1;
 
void setup()
{
    Serial.begin(9600);
    pinMode(YPin, INPUT);
}
 
void loop()
{   
    Serial.println(map(analogRead(YPin), 0, 1024, 0, 100));
    Serial.println(map(analogRead(XPin), 0, 1024, 101, 200));
    delay(50);
}

Der Processing Code (diesen Artikel zum Thema Maps in Processing sollte man ich vorher anschauen)

import processing.serial.*;
Serial myPort;
 
    int upperCounter = 0;
    int lowerCounter = 0;
 
//mode: 0=start, 1=map, 2=text, 3=draw
int mode = 1;
PFont font;
 
//map specs
InteractiveMap map;
ZoomButton out = new ZoomButton(5,5,14,14,false);
ZoomButton in = new ZoomButton(22,5,14,14,true);
PanButton up = new PanButton(14,25,14,14,UP);
PanButton down = new PanButton(14,57,14,14,DOWN);
PanButton left = new PanButton(5,41,14,14,LEFT);
PanButton right = new PanButton(22,41,14,14,RIGHT);
 
// all the buttons in one place, for looping:
Button[] buttons = {in, out, up, down, left, right};
 
boolean gui = false;
 
void setup()
{
    size(1300, 800);
    smooth();    
    font = createFont("Helvetica", 12);
 
//serial stuff
    myPort = new Serial(this, Serial.list()[0], 9600);
    myPort.bufferUntil('\n');
 
//map setup
//http://maps.google.com/maps?f=q&source=s_q&hl=de&geocode=&q=W%C3%BCrzburg&sll=40.580585,-42.890625&sspn=37.44158,80.419922&ie=UTF8&hq=&hnear=W%C3%BCrzburg,+Bayern,+Deutschland&ll=49.788783,9.93284&spn=0.000977,0.002454&t=h&z=19
    map = new InteractiveMap(this, new Microsoft.AerialProvider());
    map.setCenterZoom(new Location(49.789, 9.933), 3);
 
    addMouseWheelListener(new java.awt.event.MouseWheelListener()
    { 
        public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt)
        { 
            mouseWheel(evt.getWheelRotation());
        }
   });
}
 
void draw()
{
    background(80);
 
 
    if(mode == 1)
    {
        map.draw();
        boolean hand = false;
 
        if(gui)
        {
            for (int i = 0; i < buttons.length; i++)
            {
                buttons[i].draw();
                hand = hand || buttons[i].mouseOver();
            }      
        }
 
        cursor(hand ? HAND : CROSS);
 
        if (keyPressed)
        {
            if (key == CODED)
            {
                if (keyCode == LEFT)
                {
                    map.tx += 5.0/map.sc;
                }
 
                else if (keyCode == RIGHT)
                {
                    map.tx -= 5.0/map.sc;
                }
 
                else if (keyCode == UP)
                {
                    map.ty += 5.0/map.sc;
                }
 
                else if (keyCode == DOWN)
                {
                    map.ty -= 5.0/map.sc;
                }
            }  
 
            else if (key == '+' || key == '=')
            {
                map.sc *= 1.05;
            }
 
            else if (key == '_' || key == '-' && map.sc > 2)
            {
                map.sc *= 1.0/1.05;
            }
        }
 
        if (gui)
        {
            textFont(font, 12);
            Location location = map.pointLocation(mouseX, mouseY);
            fill(0);
            noStroke();
            rect(5, height-5-g.textSize, textWidth("mouse: " + location), g.textSize+textDescent());
            fill(255,255,0);
            textAlign(LEFT, BOTTOM);
            text("mouse: " + location, 5, height-5);
            location = map.pointLocation(width/2, height/2);
            fill(0);
            noStroke();
            float rw = textWidth("map: " + location);
            rect(width-5-rw, height-5-g.textSize, rw, g.textSize+textDescent());
            fill(255,255,0);
            textAlign(RIGHT, BOTTOM);
            text("map: " + location, width-5, height-5);
 
/*
    location = new Location(51.500, -0.126);
    Point2f p = map.locationPoint(location);
 
    fill(0,255,128);
    stroke(255,255,0);
    ellipse(p.x, p.y, 10, 10); */
        }
    }
 
    smooth();
}
 
void keyReleased() 
{
    if (key == 'g' || key == 'G')
    {
        gui = !gui;
    }
 
    else if (key == 's' || key == 'S')
    {
        save("modest-maps-app.png");
    }
 
    else if (key == 'z' || key == 'Z')
    {
        map.sc = pow(2, map.getZoom());
    }
 
    else if (key == ' ')
    {
        map.sc = 2.0;
        map.tx = -128;
        map.ty = -128; 
    }
}
 
void mouseDragged()
{
    boolean hand = false;
 
    if(gui)
    {
        for (int i = 0; i < buttons.length; i++)
        {
            hand = hand || buttons[i].mouseOver();
            if (hand) break;
        }
    }
 
    if(!hand)
    {
        map.mouseDragged(); 
    }
}
 
void mouseWheel(int delta)
{
    if (delta > 0)
    {
        map.sc *= 1.05;
    }
 
    else if (delta < 0)
    {
        map.sc *= 1.0/1.05; 
    }
}
 
void mouseClicked()
{
    if (in.mouseOver())
    {
        map.zoomIn();
    }
 
    else if (out.mouseOver())
    {
        map.zoomOut();
    }
 
    else if (up.mouseOver())
    {
        map.panUp();
    }
 
    else if (down.mouseOver())
    {
        map.panDown();
    }
 
    else if (left.mouseOver())
    {
        map.panLeft();
    }
 
    else if (right.mouseOver())
    {
        map.panRight();
    }
}
 
class Button
{  
  float x, y, w, h;
 
  Button(float x, float y, float w, float h) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
  } 
 
  boolean mouseOver() {
    return (mouseX > x && mouseX < x + w && mouseY > y && mouseY < y + h);
  }
 
  void draw() {
    stroke(80);
    fill(mouseOver() ? 255 : 220);
    rect(x,y,w,h); 
  }
 
}
 
class ZoomButton extends Button {
 
  boolean in = false;
 
  ZoomButton(float x, float y, float w, float h, boolean in) {
    super(x, y, w, h);
    this.in = in;
  }
 
  void draw() {
    super.draw();
    stroke(0);
    line(x+3,y+h/2,x+w-3,y+h/2);
    if (in) {
      line(x+w/2,y+3,x+w/2,y+h-3);
    }
  }
 
}
 
class PanButton extends Button {
 
  int dir = UP;
 
  PanButton(float x, float y, float w, float h, int dir) {
    super(x, y, w, h);
    this.dir = dir;
  }
 
  void draw() {
    super.draw();
    stroke(0);
    switch(dir) {
      case UP:
        line(x+w/2,y+3,x+w/2,y+h-3);
        line(x-3+w/2,y+6,x+w/2,y+3);
        line(x+3+w/2,y+6,x+w/2,y+3);
        break;
      case DOWN:
        line(x+w/2,y+3,x+w/2,y+h-3);
        line(x-3+w/2,y+h-6,x+w/2,y+h-3);
        line(x+3+w/2,y+h-6,x+w/2,y+h-3);
        break;
      case LEFT:
        line(x+3,y+h/2,x+w-3,y+h/2);
        line(x+3,y+h/2,x+6,y-3+h/2);
        line(x+3,y+h/2,x+6,y+3+h/2);
        break;
      case RIGHT:
        line(x+3,y+h/2,x+w-3,y+h/2);
        line(x+w-3,y+h/2,x+w-6,y-3+h/2);
        line(x+w-3,y+h/2,x+w-6,y+3+h/2);
        break;
    }
  }
 
}
 
void serialEvent (Serial myPort)
{
    // get the ASCII string:
    String inString = myPort.readStringUntil('\n');
 
    if (inString != null)
    {
        inString = trim(inString);
        float inByte = float(inString);
        //println(inByte);
 
        if(inByte < 100)
        {
            if(inByte < 50)
            {
                if(upperCounter < 1)
                {
                    upperCounter++;
                    //println("UPPER" + upperCounter);
                }
 
                else
                {
                    map.sc *= map(inByte, 15, 36, 1.3, 1.00);
                    //map.zoomIn();
                    upperCounter = 0;
                    println("ZOOM IN");
                }               
            }
        }
 
        else if(inByte > 100 &&
                inByte < 155            
        )
        {
            if(
                inByte < 135)
            {
                if(lowerCounter < 1)
                {
                    lowerCounter++;
                    //println("LOWER" + lowerCounter);
                }
 
                else
                {
                    //map.zoomOut();
                    map.sc *= 1.0/map(inByte, 115, 137, 1.3, 1.00);
                    lowerCounter = 0;
                    println("ZOOM OUT");
                }
            }
        }
    }
}

Energie

Georg Fischer — Tue, 08 Dec 2009 22:45:33 +0000

Für die Arbeit in dieser Woche habe ich mich mit dem Thema Energie beschäftigt. Da man Energie ja nicht direkt wahrnehmen kann, sondern immer nur ihre Auswirkungen, möchte ich mich in den kommenden Wochen damit weiter auseinandersetzen. Dazu habe ich mir einige Fragen gestellt.

Welche physikalische Form hat Energie?
Wo ist Energie?
Wie lässt sich Energie visualisieren und begreifen?

Ich habe ich zu diesem Thema einen Versuch aufgebaut. Man kann eine kleine Lampe “ausblasen”.

Der Arduino Code:

int sensorPin = 0;
int LEDPin = 8;
int var;
int counter;
boolean light = true;
 
void setup() 
{
    Serial.begin(9600);
    pinMode(sensorPin, INPUT);
    pinMode(LEDPin, OUTPUT);
    digitalWrite(LEDPin, HIGH);
}
 
void loop() 
{
    var = analogRead(sensorPin);
    Serial.println(var, DEC);
 
    if(var > 50)
    {
        light = true;
    }
 
    else
    {
        light = false;
    }
 
   if(light == true)
   {
       digitalWrite(LEDPin, HIGH);
   }
 
   else
   {
       digitalWrite(LEDPin, LOW);
   }   
}

Fühlbare Hologramme

Georg Fischer — Mon, 07 Dec 2009 09:45:41 +0000

Bei golem habe ich eine eine interressantes Projekt gefunden:

Video: Airborne Ultrasound Tactile Display – fühlbare Hologramme (2:37)

Mail

Georg Fischer — Tue, 01 Dec 2009 23:36:36 +0000

Ich habe die Suche nach Anwendungen für das “Nagelbrett” fortgesetzt. Letzte Woche hatte ich mich mit dem Thema Wetterdaten & Temperatur beschäftigt, diese Woche habe ich mit Email und Textmitteilungen beschäftigt. Dazu habe ich zunächst eine neue Email-Adresse angelegt (snorpey@gmail.com) und diese mit Hilfe eines Processing-Sketches abgefragt (Code folgt unten).

Je nach dem, wie viele neue Mails ich bekommen habe, verformt sich die Oberfläche mehr oder weniger. Ein Klick auf das Fenster simuliert das Lesen der neuen Nachrichten, die Oberfläche ist dann glatt.

Die Verformung und das “Nagelbrett” sind natürlich nur ein unfertiges, fehlerhaftes Modell und stehen für die Überlegung, was passieren würde, wenn mobile Endgeräte ihre Form bei Erhalt von Nachrichten änderten. Dabei wäre sicher auch interressant, ob und wie die Verformung auf den Inhalt und den Absender der Nachricht Bezug nimmt.

Es folgt der Code zum Email-Abrufen Sketch (funktioniert leider nur mit gmail-Adressen, für andere Mailadressen sind andere Sicherheitseinstellungen nötig, die ich leider nicht ermitteln konnte.)

import javax.mail.*;
import javax.mail.internet.*;
import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;
 
int mailCount;
int mailUnread = 0;
int mailNew = 0;
int counter = 0;
PFont font;
 
void setup()
{
    frameRate(30);
    size(350, 150);
    mailCount = mailCount();
    font = createFont("LucidaGrande", 24);
}
 
void draw()
{
    background(255);
 
    if(counter &gt;= 500)
    {
        int mailsChecked = mailCount();
 
        if(mailsChecked &gt; mailCount)
        {
            mailNew++;
            mailUnread = mailNew;
            mailCount = mailsChecked;
        }
 
        counter = 0;
    }
 
    stroke(80, 30);
    strokeWeight(150);
    strokeCap(SQUARE);
    line(0, height/2, map(counter, 0, 500, 0, width), height/2);
    noStroke();
 
    counter++;
 
    fill(80);
    textFont(font);
 
    if(mailUnread &gt; 1)
    {
        text(mailUnread + " neue Emails", 50, (height / 2) + 10);
    }
 
    else
    {
        text("keine neuen Emails", 50, (height / 2) + 10);
    }
}
 
void mouseClicked()
{
    if(mailUnread &gt; 0)
    {
        mailUnread = 0;
    }
}
 
public class Auth extends Authenticator
{
    public Auth()
    {
        super();
    }
 
    public PasswordAuthentication getPasswordAuthentication()
    {
        String username, password;
        username = "YOURNAME@gmail.com";
        password = "YOURPASSWORD";
        System.out.println("authenticating. . ");
        return new PasswordAuthentication(username, password);
    }
}
 
int mailCount()
{
    int returnValue = 0;
 
    try
    {
        Properties props = System.getProperties();
        props.put("mail.pop3.host", "pop.gmail.com");
        props.put("mail.pop3.port", "995");
        props.put("mail.pop3.starttls.enable", "true");
        props.setProperty("mail.pop3.socketFactory.fallback", "false");
        props.setProperty("mail.pop3.socketFactory.class","javax.net.ssl.SSLSocketFactory");
 
        Auth auth = new Auth();
 
        Session session = Session.getDefaultInstance(props, auth);
        Store store = session.getStore("pop3");
        store.connect();
 
        Folder folder = store.getFolder("INBOX");
        folder.open(Folder.READ_ONLY);
        returnValue = folder.getMessageCount();
 
        folder.close(false);
        store.close();
    } 
 
    catch (Exception e)
    {
        e.printStackTrace();
    }
 
    return returnValue;
}

Online-Daten

Georg Fischer — Mon, 23 Nov 2009 17:41:18 +0000

In der vorletzten Woche hatte ich mit online-Datenquellen für meine Ausgabemedien beschäftigt. Dabei habe ich zum einen die Google Weather API und zum anderen die GeoNames API ausprobiert. Dabei ist folgender Sketch entstanden (auf das Bild klicken).

Man kann einen Ort auf der Weltkarte per Klick auswählen, zu dem dann (soweit möglich) die Temperatur angezeigt wird. Die Zuordnung der Punkte stimmt teilweise noch nicht ganz, das liegt an der Verzerrung der Weltkarte, die ich verwendet habe.

Ich habe mich dann weiter damit beschäftigt, wie ich meine Ausgabemedien sinnvoll einsetzen kann, ob und wie ich es in Zusammenhang mit den Daten aus dem Internet bringen kann. Dabei hatte ich die Idee, eine große, “fühlbare” Weltkarte zu bauen und dabei das Prinzip zu verwenden, dass ich schon beim Nagelbrett genutzt hatte. So wäre eine Region, je nach ihrer aktuellen Temperatur herausgehoben bzw. heruntergesetzt.

Übrigens: Um einem Java-Applet, das Online ist den Zugriff auf das Internet zu erlauben muss man es signieren. Dazu gibt es eine Anleitung bei processing:hacks.

Servo Productions Ltd.

Georg Fischer — Tue, 17 Nov 2009 22:01:03 +0000

Im Anschluss an die Arbeit der letzten Woche habe ich mir diese Woche Gedanken zum Thema Oberflächen gemacht. Dabei habe ich diesmal versucht das “(Nacken)haare aufstellen” zu simulieren. Dazu habe ich zunächst einen einfachen Test gemacht, und dann die Fläche vergrößert und sie an einen Servo angeschlossen.

Leider ist der Servo heute abend kaputt gegangen, das Zahnrad aussen dreht sich nicht mehr. Für die beiden Servos aus der Villa, die ich ausgeliehen habe, braucht man einen Adapter, um sie ans Arduino anzuschließen, den ich (noch) nicht habe.

Ich hatte eigentlich geplant, den Servo an einen Bewegungssensor anzuschliessen, so dass die Oberfläche ähnlich reagiert wie eine Mimose: Bei Erschütterungen richten sich die “Haare” und fallen dann langsam wieder zusammen. Die neuen Servos sind schon auf dem Weg, ich hoffe, dass ich die Simulation bis nächste Woche fertig bekomme.

Nagelbrett

Georg Fischer — Tue, 10 Nov 2009 21:24:32 +0000

Im Anschluss an die Arbeit der letzten Woche habe ich mir weiter Gedanken über thermorektive Interfaces gemacht. Dazu habe ich versucht, die im Kurs schon mehrfach angesprochene Gänsehaut bei kalter Temperatur mit den mir zu Verfügung stehenden (sehr einfachen) Mitteln zu bauen.
Einige Bilder vom Zusammenbau:

Das “Gerät” ist noch nicht fertig; zum einen fehlt im Moment noch die Kopplung mit einem Wärmesensor, zum anderen noch ein vernünftiges, nachvollziehbares Verhalten. Beim Zusammenbau sind mir noch einige Ideen gekommen, die ich gerne ausprobieren würde:

Wie wäre es, wenn die Oberfläche nicht nur zittern und Gänsehaut bekommen, sondern auch schwitzen, die Farbe und die Oberflächentemperatur ändern könnte?

Einige technische Details: Im Moment macht der Servo eine Vierteldrehung vorwärts und rückwärts, um das Nagelbrett zu heben und zu senken. Wenn das Nagelbrett anghoben ist, kann man die Gänsehaut sehen (und noch besser spüren). Ist das Nagelbrett gesenkt, sieht und spürt man nur eine weiche Oberfläche. Der Code im Arduino entspricht im wesentlichen dem Beispiel auf der Arduino-Webseite, lediglich die Gradzahl habe ich angepasst.

// Sweep
// by BARRAGAN  
 
#include  
 
Servo myservo;  // create servo object to control a servo 
 
int pos = 0;    // variable to store the servo position 
 
void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 
} 
 
void loop() 
{ 
  for(pos = 0; pos < 90; pos += 1)  // goes from 0 degrees to 90 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 
  for(pos = 90; pos>=1; pos-=1)     // goes from 90 degrees to 0 degrees 
  {                                
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 
}

Würfel

Georg Fischer — Wed, 04 Nov 2009 00:11:07 +0000

Ich habe mir die letzte Woche über weiter Gedanken zum Thema thermoaktive und thermoreaktive Interfaces gemacht. Dabei habe ich mich insbesondere mit der Wirkung von Wärme und Kälte auf Menschen beschäftigt.

Um einen Nutzer einzuladen, sich mit einer Sache zu näher beschäftigen, ist es sinnvoll, wenn diese Sache “lebendig” wird, oder zumindest Verhaltensweisen von Lebewesen imitiert. So bekommt es der Nutzer mit vertrautem Verhalten zu tun und reagiert (hoffentlich) intuitiv darauf.

Dazu habe ich folgenden Versuch vorbereitet: Ein Würfel wird mit einem Vibrationsmotor und einem Wärmesensor ausgestattet. Sobald die Umgebungstemperatur auf einen bestimmten Wert fällt, “friert” der Würfel, steigt die Temperatur wieder, geht der Motor aus.

Hier einige Bilder von der Baustelle:

Und ein Video mit dem Würfel in Aktion:

Der Code für den Würfel:

/*
 hardware: LilyPad Vibe, LilyPad Temperature Sensor
 author:    Georg Fischer
 source:   http://www.fishnation.de/reactions/wuerfel
 
 lilyPad vibe connected to digital pin 7 and ground,
 temperature sensor connected to analog pin 0, 5V and ground
*/
 
int sensorPin = 0;
const int vibePin = 7;
 
int sensorValue = 0;
 
void setup()
{
  Serial.begin(9600);
  pinMode(vibePin, OUTPUT);
}
 
void loop()
{
  sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue);
 
  if(sensorValue < 130)
  {
    digitalWrite(vibePin, HIGH);                    
  }
 
  else
  {
    digitalWrite(vibePin, LOW);
  } 
}

Kalt & Warm

Georg Fischer — Tue, 27 Oct 2009 20:39:38 +0000

Ich habe micht entschieden, das Thema Interaktion mit thermischer Komponente, das ich Letzte Woche mit dem Video vorgestellt habe, weiter zu verfolgen.

Dazu habe ich mir zunächst die möglichen Akionen der “Maschine” bzw. des Computers vorgenommen und mir folgende Fragen gestellt:

Wie genau können wir als Menschen Temperaturunterschiede feststellen?
Spielt dabei eine Rolle, wie schnell diese Temperaturänderungen vonstatten gehen?
Wird unsere Temperaturwahrnehmnung durch das Material beeinflusst?

Auch mit den Reaktionen habe ich mich beschäftigt und mir einige Fragen gestellt:

Wie ganau kann man mit dem Temperatursensor Unterschiede in der Temperatur feststellen
Wie schnell kann der Temperatursensor auf die Unterschiede reagieren?

Um die Fragen zu beantworten habe ich einige Experimente durchgeführt. Dazu habe ich mir zunächst einen 100er-Pack Teelichter besorgt. Aus einigen Teelichtern habe ich das Wachs und den Docht herausgenommen und sie mit Wasser und Wassereis gefüllt.

Einige Ergebnisse meiner Versuche:

Ohne Hilfsmittel kann man nur relativ große Temperaturunterschiede (> 5°) spüren. Ändert sich die Temperatur langsam, wird es schwierig eine Änderung festzustellen.
der Temperatursensor, den ich verwende, Lilypad Temperature Sensor, reagiert auf Temperaturänderungen erst nach einigen Sekunden (Das kann aber auch mit meiner Konstuktion zusammenhängen)

Bis jetzt habe ich die Versuche nur mit Wasser durchgeführt; Experimente mit anderen Materialien stehen noch aus. Auch zu einer technischen Umsetzung habe ich mir noch keine Gedanken gemacht.

Slides vom 21.10.2009

Georg Fischer — Wed, 21 Oct 2009 08:00:50 +0000