Gruppe 7: Stefan, Kim, Rasmus og Nicklas

Navn: Wearaball

Hvad er jeres case, og hvorfor?

Vi adskiller os i nogen grad fra de andre grupper til denne portefølje, da vi i stedet for et helt nyt koncept udvikler videre på semesterprojektet. Dette blev godkendt, da vores semesterprojekt langt hen ad vejen opfylder kriterierne for PF2.

Projektets formål er at udvikle en augmenteret bold til legeformål. Den er dermed ikke en decideret wearable, men bruges dog alligevel til fysisk aktivitet, og det giver derfor mening ift. opgaveformuleringen.

Man kan dermed også sige, at vi ikke sigter efter at løse ét særligt problem med vores prototype, da “problemet” grundlæggende består i at opfordre til fysisk interaktion med den ydre form på vores produkt samt funktionaliteten – vi arbejder altså primært med et affordance-problem.

Brugskonteksten er som sagt leg. Indtil videre har vi ikke haft mulighed for at teste prototypen, så vi kan kun gisne om evt. type og væsen af leg, hvis vi antager at det vil være muligt eller relevant at sige noget herom. Det vil det sandsynligvis, men i første omgang er formålet såkaldt løs eller fri leg. Derudfra vil vi have mulighed for at formulere en mere konkret brugskontekst på baggrund af brugerobservationerne. Brugerne forventes at være børn af begge køn i alderen 3-6 år.

I forlængelse af ovenstående er det også svært at sige noget om den nøjagtige fysiske aktivitet, der vil forekomme under brug. En bold har som udgangspunkt en affordance, der inviterer til spark, kast, trillen hen ad jorden osv. Meningen er, at bolden skal reagere på bevægelse ved at afgive lys og lyd, der afhænger af det pågældende input. Resultatet af interaktionen er potentielt meget dynamisk og kompleks, hvor alle de muligheder der er for interaktion mellem bold og legende part kunne ske i samme lege-session, og desuden veksle mellem de forskellige lege-aktiviteter. Derfor kan det konkrete væsen af den fysiske aktivitet ikke blive mere specifik på nuværende tidspunkt end at sige, at vores produkt forventes brugt i interaktion med en fri og ikke regelbaseret kropslig udfoldelse.

Der er dog også muligheder for anden brug end leg, f.eks. genoptræning, hvor “rigtige” bevægelser giver Positiv feedback (eller evt. ingen) og bevægelser, der ikke understøtter genoptræningen, giver et negativt feedback. Dette kunne både være direkte gennem bolden med enten lys eller lyd, eller evt. via Processing-programmet, der kan give brugeren et anderledes visuelt resultat at forholde sig til. Derfor vil vi under Processing-opgaven fokusere på dette aspekt, selvom det ikke er produktets primære formål, ikke mindst for at demonstrere bredden af potentialet på vores produkt.

Hvad har andre lavet inden for samme kontekst?

Firmaet Orbotix har udviklet en augmenteret bold, der meget følger samme princip som vores egen – deres er dog væsentligt mere professionelt lavet, og har langt flere funktioner, som man også kunne forvente.

Sphero 2.0 kaldes bolden, og den benytter bl.a. farver som respons på sensorernes input, ligesom vores egen gør. Den anvender ikke lyd, men kan til gengæld bevæge sig vha. fjernstyring eller autonomt. Fjernstyringen sker via enten smartphone eller tablet, og gennem disse er det også muligt at vælge specifikke lege eller spil, der er udviklet på forhånd af producenterne.

Vi har haft samme idé, hvor vores bold skulle kunne invitere til fri leg, men efterfølgende også give mulighed for at vælge specifikke legesenarier eller mini-spil, for at forlænge interaktionen, og gøre vores produkt mere anvendeligt som et “komplet” legetøj/legeredskab.

De mange relevante funktioner, der er implementeret i Sphero 2.0 giver den mulighed for at være en central del af både barnets leg, men også den voksnes, og viser i forlængelse potentialet i vores eget koncept, hvis produktet udvikles yderligere. En promotion-video af Sphero 2.0 ses herunder.

http://www.gosphero.com/sphero-2-0/

Hvad er jeres design?

Det overordnede koncept er som sagt en augmenteret bold, der reagerer på input fra brugeren, og hvor boldens output gives i to tempi – lys og lyd. Den basale funktionalitet er, at hvis bolden ruller/bevæger sig langsomt, så lyser den i en “rolig farve” som blå eller grøn, mens den kommer med nogle mindre høje bit-lyde. Når bevægelsen er hurtig, skifter farven til rød, og lyden stiger i styrke.

Grunden til dette erførst og fremmest, at boldens output vil stemme overens med, hvad man “kunne forvente” fra de givne input. Hvis man f.eks. kører langsomt i en bil, vil lydene der skabes dermed også være lavere, end hvis man kører hurtigt. Høj fart associeres med høje lyde, og når vi følger det princip, får vores bold automatisk en fremtoning af ontologisk overensstemmelse med resten af verden – forventet output på specifik input.

Det samme gælder for farverne. Målgruppen er som sagt mindre børn, og noget af det første børn præsenteres for i f.eks. tegnefilm er, at rød betyder noget særligt ift. de andre farver (den røde knap er farlig, tyren angriber, hvis den ser rød, snehvide spiser det røde æble etc.). Rød er altså en socialt betinget indikator for noget, der på en eller anden måde er voldsomt, farligt, dynamisk, hurtigt eller særligt vigtigt. Det giver derfor mening, når vi bruger rød som det visuelle output for et input, der giver bolden høj fart.

For at registrere boldens bevægelse bruger vi en såkaldt “9 axis sensor”, der indeholder både accelerometer, gyrometer og kompas. Værdierne for de modtagne data kan studeres gennem Arduino-programmets mulighed for seriel overvågning, og ud fra disse fastsættes faktorerne for de break points, hvor lyd og farve ændres.

Komponenter:

Arduino R3, Sound Buzzer, Sparkfun Bluetooth “Bluesmirf”, Sparkfun logic level converter, Sparkfun “LSM9DS0” 3-Axis Accelerometer,

Interfacing:

InterfacingPic_Blue_Accel_LogCon_Buz

Sparkfun “LSM9DS0” 3-Axis Accelerometer + Bluetooth SETUP Code:

#include <SPI.h> // Included for SFE_LSM9DS0 library
#include <Wire.h>
#include <SFE_LSM9DS0.h>
#include <windows.h>
#include <SoftwareSerial.h> 

//Bluetooth Pin definitions// 
int bluetoothTx = 7;  // TX-O pin of bluetooth mate, Arduino D2
int bluetoothRx = 8;  // RX-I pin of bluetooth mate, Arduino D3
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);

///////////////////////////////
/////////I2C Setup/////////////
///////////////////////////////
// SDO_XM and SDO_G are both grounded, therefore our addresses are:
#define LSM9DS0_XM  0x1D // Would be 0x1E if SDO_XM is LOW
#define LSM9DS0_G   0x6B // Would be 0x6A if SDO_G is LOW
// Create an instance of the LSM9DS0 library called `dof` the
// parameters for this constructor are:
// [SPI or I2C Mode declaration], [gyro I2C address], [xm I2C address]
LSM9DS0 dof(MODE_I2C, LSM9DS0_G, LSM9DS0_XM);
///////////////////////////////
// Interrupt Pin Definitions //
///////////////////////////////
const byte INT1XM = 4; // INT1XM tells us when accel data is ready
const byte INT2XM = 5; // INT2XM tells us when mag data is ready
const byte DRDYG = 6;  // DRDYG tells us when gyro data is ready

// A boolean to keep track of whether we're printing raw (ADC)
// or calculated (g's, DPS, Gs) sensor data:
boolean printRaw = true;

int readString = 0;

void setup()
{ 
    ///////////Bluetooth setup////////////
   Serial.begin(9600);  // Begin the serial monitor at 9600bps
  bluetooth.begin(115200);  // The Bluetooth Mate defaults to 115200bps
  bluetooth.print("$");  // Print three times individually
  bluetooth.print("$");
  bluetooth.print("$");  // Enter command mode
  delay(100);  // Short delay, wait for the Mate to send back CMD
  bluetooth.println("U,9600,N");  // Temporarily Change the baudrate to 9600, no parity
  // 115200 can be too fast at times for NewSoftSerial to relay the data reliably
  bluetooth.begin(9600);  // Start bluetooth serial at 9600

//////////////////Acclerometer setup/////////////////
  pinMode(A0, OUTPUT);  // Buzzer pin declaration //Used in Buzzer Sound System
  // Set up interrupt pins as inputs:
  pinMode(INT1XM, INPUT);
  pinMode(INT2XM, INPUT);
  pinMode(DRDYG, INPUT);

 Serial.begin(115200); // Start serial at 115200 bps
  // Use the begin() function to initialize the LSM9DS0 library.
  // You can either call it with no parameters (the easy way):
  uint16_t status = dof.begin();
  Serial.println(status, HEX);
}
///////////////////////////////////////////////////////////////////////////

 

LOOPING SOUND SYSTEM WITH BUZZER IN A 4 STEP ACCLERATION INTERVAL Code:

 // LOOPING SOUND SYSTEM WITH BUZZER IN A 4 STEP ACCLERATION INTERVAL //
void loop()                                                                                          // LOOPING SOUND SYSTEM WITH BUZZER IN A 4 STEP ACCLERATION INTERVAL 
{ 
    //læs data fra accelerometeret
    dof.readAccel();

    //Omskrivning til vektor (fra rå data til G). 
    float x = (dof.calcAccel(dof.ax)*dof.calcAccel(dof.ax)); 
    float y = (dof.calcAccel(dof.ay)*dof.calcAccel(dof.ay));
    float z = (dof.calcAccel(dof.az)*dof.calcAccel(dof.az)); 

 float Accel = sqrt(x+y+z);

if(bluetooth.available())  // If the bluetooth sent any characters
  {
    // Send any characters the bluetooth prints to the serial monitor
    Serial.print((char)bluetooth.read());  
  }
  if(Serial.available())  // If stuff was typed in the serial monitor
  {
    // Send any characters the Serial monitor prints to the bluetooth
    bluetooth.print((char)Serial.read());

}

  //int værdier med læsninger fra accelerometeret.
int firstSensor = dof.ax;
int secondSensor = dof.ay;
int thirdSensor = dof.az;

    bluetooth.print(firstSensor);  //skriv via bluetooth værdierne til processing i en string delt af komma.
    bluetooth.print(",");
    bluetooth.print(secondSensor);
    bluetooth.print(",");
    bluetooth.print(thirdSensor); 
 bluetooth.print("\n");

                                                                                                    // SLOW ACCLERATION WITHIN 
 //Tænder og slukker for frekvensen(lyd)
  frekvenc_count++;
   if (frekvenc_count  >= frequency/2)
    {
      digitalWrite(A1,HIGH);
    }

   else if (frekvenc_count  >=  frequency)
    {
     digitalWrite(A1, LOW);
     frekvenc_count =0;
   }       

  //********************************   TEST LYS OG LYD   *************************************************

  if  (Accel < 1.5)     //accelerationen Under 1.5G - Ingen lys
     {  
        Tlc.clear();
        Tlc.update();
     }

 if ((Accel > 1.51) && (Accel < 2.099))     //accelerationen mellem 1.51G og 2.099 - blåt lys
     { 
        frequency = 4;

        Tlc.clear();    
        Tlc.set(2,4095);
        Tlc.set(4,4095);
        Tlc.set(9,4095);  //blå
        Tlc.set(12,4095);      
        Tlc.update();
        delay(100);
     }

   if ((Accel  > 2.100) && (Accel  < 2.5)) //accelerationen mellem 2.1 G og 2.5G - lilla lys

    { 
  Tlc.clear();
        Tlc.set(3  ,4095);
        Tlc.set(5,4095);
        Tlc.set(7,4095);       //Rød
        Tlc.set(10,4095);      

        Tlc.set(2,4095);                                      //Lilla
        Tlc.set(4,4095);
        Tlc.set(9,4095);  //blå
        Tlc.set(12,4095);      
        Tlc.update();      
      delay(100);

    }

  if ((Accel  > 2.51) && (Accel  <2.899)) //accelerationen mellem 2.51G og 2.899 - grøn lys

    {  
        frequency = 8;

        Tlc.clear();
        Tlc.set(1,4095);
        Tlc.set(6,4095);
        Tlc.set(8,4095);        //Grøn
        Tlc.set(11,4095);
        Tlc.update();  
     delay(100);   
    } 

  if ((Accel  > 2.9) && (Accel < 5))  //accelerationen over 2.9G  - rødt lys
    {
       frequency = 12;

    //  for (int i = 1; i > 10; i++){      

        Tlc.clear();
        Tlc.set(3  ,4095);
        Tlc.set(5,4095);
        Tlc.set(7,4095);       //Rød
        Tlc.set(10,4095);
        Tlc.update(); 
     //   delay(100);     

    //  }

Bluetooth read accelerometer looping system:

void loop()                                                                        { 
dof.readAccel();

if(bluetooth.available())  // If the bluetooth sent any characters
  {
    // Send any characters the bluetooth prints to the serial monitor
    Serial.print((char)bluetooth.read());  
  }
  if(Serial.available())  // If stuff was typed in the serial monitor
  {
    // Send any characters the Serial monitor prints to the bluetooth
    bluetooth.print((char)Serial.read());

}

int firstSensor = dof.ax;
int secondSensor = dof.ay;
int thirdSensor =dof.az;

    bluetooth.print(firstSensor);
    bluetooth.print(",");
    bluetooth.print(secondSensor);
    bluetooth.print(",");
    bluetooth.print(thirdSensor); 
 bluetooth.print("\n");

    }

Processing code for sending accelerometer data via bluetooth:

import processing.serial.*;

Serial port;  // Create object from Serial class

int[] sensors = new int[5];  //et array til senere brug for de readings der kommer fra accelerometeret(Arduino)

String myString;  //den string med  readings der kommer fra accelerometeret(Arduino) 

int ax;    //readings'ne fra arduino divideret med 400 for at gøre tallene nemmere at arbejde med
int ay;    //readings'ne fra arduino divideret med 400 for at gøre tallene nemmere at arbejde med
int az;    //readings'ne fra arduino divideret med 400 for at gøre tallene nemmere at arbejde med

int counter = 0;  //opretter en counter til at gemme antallet af gange man overskrider tilladte acceleration

void setup() 
{
  size(640, 480);
  // Open the port that the board is connected to and use the same speed (9600 bps)
  port = new Serial(this, "/dev/tty.RasmusBluetooth-RNI-SPP", 9600);
  //values_front = new int[width];
  //values_back = new int[width];
  smooth();

  port.bufferUntil('\n');
}

void draw() {
  // Draws 2 bars to represent incoming data in patriotic fashion

  background(150);

  textSize(20);
  text(counter, 20, 80); //antallet af overskredet accelleration

  textSize(32);
  text("Antal ujævnheder:", 10, 30);

  /*textSize(32);
  text(ay, 10, 70); //accelleration på y-aksen

  textSize(32);
  text(az, 10, 110); //accelleration på z-aksen
*/
  cirkel();    //kalder funktionen cirkel nedenunder
  count();    //counteren

  if (counter>=1) {    //if sætninger til at ændre cirkelstørrelse ift. counts
    fill(#00ff00);
    ellipse(320, 240, 130, 130);
  }
  if (counter>30) {
    fill(#00ff00);
    ellipse(320, 240, 200, 200);
  }
  if (counter>60) {
    fill(#00ff00);
    ellipse(320, 240, 270, 270);
  }

  if (counter>100) {
    fill(#ff0000);
    ellipse(320, 240, 330, 330);
    textSize(32);
    text("DØD!!", 300, 480);
    fill(255);
  }
}

void count() {  //counterfunktionen
  if ((ax*400>19000)|| (ax*400 <-19000) || (ay*400 >19000)||(ay*400 <-19000)|| (az*400 >19000)|| (az*400 <-19000)) {
    counter++;
  }
}

void cirkel() {  // cirkelen
  ellipse(320, 240, 70, 70);
}

void serialEvent(Serial port) { 
  // læs serial buffer:

  String myString = port.readStringUntil('\n');

  // if you got any bytes other than the linefeed:

  myString = trim(myString);
  println(myString);

  // del stringen ved kommaer og konvertere til INT
  int sensors[] = int(split(myString, ','));

  // Skriv værdierne:
  for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
    print("Læsning " + sensorNum + ": " + sensors[sensorNum] + "\t");
  }
  // add a linefeed after all the sensor values are printed:
  println();

//Opretter variabler fra sensorværdier og del dem med 400
  if (sensors.length > 1) {
    ax = sensors[0]/400;
    ay = sensors[1]/400;
    az = sensors[2]/400;
    //ypos = map(sensors[1], 0,1023,0,height);
    //fgcolor = sensors[2];
  }
  // send a byte to ask for more data:
  //port.write("A");
  //  }
}

Buzzer Sound System Code:

void setup()
{
  pinMode(A0, OUTPUT);  // Buzzer pin declaration
}
void loop()                                                                                          // LOOPING SOUND SYSTEM WITH BUZZER IN A 4 STEP ACCLERATION INTERVAL 
{ 
 dof.readAccel();  //Start reading the accelerometer data
                                                                                                    // SLOW ACCLERATION WITHIN 
 if (((dof.ax) > 20000) && (dof.ax) < 25000 | ((dof.ax) < -20000 && (dof.ax) > -25000))
  {
    tone(A0, 1000);
    delay(100);
    noTone(A0);    
   }
if (((dof.ay) > 20000) && (dof.ay) < 25000 | ((dof.ay) < -20000 && (dof.ay) > -25000))
   {
    tone(A0, 1000);
    delay(100);
    noTone(A0);
   }
  if (((dof.az) > 30100) && (dof.az) < 35000 | ((dof.az) < -30100 && (dof.az) > -35000))
  {
    tone(A0, 1000);
    delay(100);
    noTone(A0);
   }
}

Første test af “Wearaball”: (Grundet manglende strøm på batteriet, sidder usb stikket i – Bluetooth virker)

Flowdiagram

Screen Shot 2014-05-13 at 12.47.31

Konklusion

Vores udgangspunkt var, som tidligere beskrevet, at udvikle en augmenteret bold til legeformål, men at den i forbindelse med denne portefølje også skulle kunne anvendes som et evt. genoptræningsredskab, hvor vi benytter Processings mulighed for visuel vekselvirkning mellem bruger og brugsgenstand.

Til genoptræningsdelen benytter vi os kun af det audielle aspekt afbolden, og bruger altså ikke dioderne, da de kun ville tjene noget formål ift. legen, men ikke når vi arbejder med genoptræningen. Denne del virker dog i nogenlunde tilfredsstillinde grad, men kunne godt forbedres. Problemet er, at vi har haft svært ved at finde en algoritme, der samler alle input-værdierne til et simpelt tal, der beskriver bevægelsen. Derfor er reaktionen ikke så præcis som vi kunne have ønsket os, men man kan dog se princippet bag den umiddelbare brug af bolden til genoptræningsforål. På videoen ses skærmbillede fra Processing, hvor der er en counter der tæller hvor mange gange bolden er blevet bevæget for hurtigt. På skærmbilledet er der også tegnet en grøn bold der bliver større og større jo mere brugeren bevæger den for stærkt. Når brugen har gjort det for meget bliver bolden rød, hvilket er en metafor for at “spillet” slut.

Mht. videreudvikling af bolden til genoptræning, kunne man tilpasse boldens funktion til forskellige øvelser. Bevægelserne i øvelserne skulle stemme overens med konstruktive bevægelsesmønstre, der understøtter muskulaturens genoptræning.

bold

 

Links:

Datablad til TLC5940:

https://www.sparkfun.com/datasheets/Components/General/tlc5940.pdf

Datablad til Bluetooth HID:

https://www.sparkfun.com/products/10938

Datablad til accelerometer:

https://cdn.sparkfun.com/assets/f/6/1/f/0/LSM9DS0.pdf

 

Leave a Reply