POPG02 Gruppe 6
Navn på wearable: Dancedance musen
Gruppe medlemmer: Anders Christiansen, Malte Borges og Miki Nguyen
Udseende: Vores handske ser ud som en handske, med forskellige sensorer på.
Billede
Case:
Vi vil lave en handske, som skal bruges som en mus med flere funktioner. De forskellige funktioner på handsken havde vi tænkt os at tilføje til sensorerne, pressure og motion sensor. Formålet med at lave handsken er at man skal kunne slippe for at holde musen, som dermed så skal forebygge museskader der kan forekomme ved at bruge musen hyppigt. Ved så at bruge handsken bliver hånden afslappet mens man sidder ved PC’en.
http://www.museskade.dk/symptomer.asp
http://www.museskade.dk/forebyggelse.asp
Hvad andre har lavet indenfor samme kontekst:
The Peregrine: http://theperegrine.com/product
Peregrine er en gaming handske som skal gøre det muligt at udføre forskellige handlinger inde i spillet, ved forskellige håndbevægelser. Peregrine er en mer avanceret version af vores handske, bliver bare ikke brugt som en mus. Peregrine indeholder 38 touchpoints som man kan tilpasse til diverse knapper. Desuden består handsken af noget godt materiale som giver ventilation til hånden.
Keyglove: http://www.keyglove.net/
Keyglove er en handske som skal fungere ligesom Peregrine, men har desuden også en motion sensor. Består af 37 kontakt sensorer som er placeret forskellige steder på handsken og motion sensorer. Formålet med Keyglove er at den skal kunne bruges til gaming, design, music osv. Er lavet sådan så man bruger få lette håndbevægelser, så handsken kan bruges til handicappede eller nogen med skader. Kan give feedback vha. vibrationer, lyd og lys.
Vores design:
Handsken består af 5 pressure sensorer og én motion sensor. Hvor man ved at trykke på de forskellige pressure sensorer vil udføre forskellige handlinger og ved at holde øje med hvilken retning man holder hånden.
De 5 pressure sensorer sidder på fingerspidserne. Her vil vi måle når man trykker på dem, vil de forskellige sensorer give udslag, som så skal udføre den handling den pressede sensor er programmeret til.
Motion sensoren sidder ovenpå hånden, og bruges til at måle hvilken retning man har hånden i. Her skal den måle om man drejer hånden i de forskellige retninger, hvor man eksempelvis i et spil vil bevæge sig til højre eller venstre.
Hardware
Diagramtegning:
Billede:
Beskrivelse af delkomponenterne:
Motion sensor:
LSM9DS0 IMU Breakout – 9DoF https://www.sparkfun.com/products/12636
Bruges til at måle bevægelser.
Indeholder 3-axis accelerometer, 3-axis gyroscope, and 3-axis magnetometer. Hver sensor i LSM9DS0 understøtter en bred variation af rækkevidder.
Accelerometer skala går fra ± 2, 4, 6, 8, or 16 g
Gyroscope understøtter ± 245, 500, and 2000 °/s
Magnetometer skala går fra ± 2, 4, 8, or 12 gauss
Kan forsynes med 2.4V til 3.6V – skal bruge Logic Level Converter Bi-Directional da den ikke kan tåle 5V fra Arduinoen.
Logic Level Converter Bi-Directional:
https://www.sparkfun.com/products/12009
Bruges sammen med LSM9DS0
Konvertere 5V til 3.3V
Pressure sensor:
Force Sensitive Resistor 0.5″ https://www.sparkfun.com/products/9375
Bruges til at måle når man presser på den. Er ikke særlig præcis, så man burde bruge dem til at måle når man presser på den og ikke som en skala.
Bluetooth:
Bluetooth Modem – BlueSMiRF Silver https://www.sparkfun.com/products/12636
Bruges til at lave en trådløs bluetooth forbindelse – op til 100m.
Har en bluetooth transceiver, dvs. den både kan sende og modtage data.
Kan forsynes med 3.3V op til 6V.
Serial communications: 2400-115200bps
Problemer:
Vi havde problemer med at accelerometers precision, derudover var der ikke syndelige problematikker med udførelsen.
Opførsel
Arduino
#include <SPI.h> // Included for SFE_LSM9DS0 library
#include <Wire.h>
#include <SFE_LSM9DS0.h>
///////////////////////
// Example 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);
///////////////////////
// Example SPI Setup //
///////////////////////
//#define LSM9DS0_CSG 9 // CSG connected to Arduino pin 9
//#define LSM9DS0_CSXM 10 // CSXM connected to Arduino pin 10
//LSM9DS0 dof(MODE_SPI, LSM9DS0_CSG, LSM9DS0_CSXM);
///////////////////////////////
// Interrupt Pin Definitions //
///////////////////////////////
const byte INT1XM = 2; // INT1XM tells us when accel data is ready
const byte INT2XM = 3; // INT2XM tells us when mag data is ready
const byte DRDYG = 4; // 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;
#include <SoftwareSerial.h>
int bluetoothTx = 5; // TX-O pin of bluetooth mate, Arduino D2
int bluetoothRx = 6; // RX-I pin of bluetooth mate, Arduino D3
int xValue = 0;
int yValue = 0;
//Data pins på Arduinoen
int sensor_3 = A4;
int sensor_0 = A1;
int sensor_1 = A2;
int sensor_2 = A3;
int sensorValue_0 = 0; // variable to store the value coming from the sensor
int sensorValue_1 = 0;
int sensorValue_2 = 0;
int sensorValue_3 = 0;
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);
void setup()
{
// Set up interrupt pins as inputs:
pinMode(INT1XM, INPUT);
pinMode(INT2XM, INPUT);
pinMode(DRDYG, INPUT);
Serial.begin(9600); // 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();
// Or call it with declarations for sensor scales and data rates:
//uint16_t status = dof.begin(dof.G_SCALE_2000DPS, dof.A_SCALE_6G, dof.M_SCALE_2GS);
// begin() returns a 16-bit value which includes both the gyro and
// accelerometers WHO_AM_I response. You can check this to make sure
// communication was successful.
Serial.println(status, HEX);
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
}
void loop()
{
// read the value from the sensor:
sensorValue_0 = analogRead(sensor_0);
sensorValue_1 = analogRead(sensor_1);
sensorValue_2 = analogRead(sensor_2);
sensorValue_3 = analogRead(sensor_3);
if (digitalRead(INT1XM)){
dof.readAccel();
//tryksensor output
bluetooth.print(sensorValue_0);
bluetooth.print(",");
bluetooth.print(sensorValue_1);
bluetooth.print(",");
bluetooth.print(sensorValue_2);
bluetooth.print(",");
bluetooth.print(sensorValue_3);
bluetooth.print(",");
//accelerometer output
xValue = dof.ax;
yValue = dof.ay;
bluetooth.print(xValue);
bluetooth.print(",");
bluetooth.println(yValue);
}
delay(100);
}
void printAccel()
{
// Only read from the accelerometer if the accel interrupts,
// which means that new data is ready.
if (digitalRead(INT1XM))
{
// Use the readAccel() function to get new data from the accel.
// After calling this function, new values will be stored in
// the ax, ay, and az variables.
dof.readAccel();
Serial.print("A: ");
if (printRaw)
{
Serial.print(dof.ax);
Serial.print(", ");
Serial.print(dof.ay);
Serial.print(", ");
Serial.println(dof.az);
}
else
{
Serial.print(dof.calcAccel(dof.ax));
Serial.print(", ");
Serial.print(dof.calcAccel(dof.ay));
Serial.print(", ");
Serial.println(dof.calcAccel(dof.az));
}
}
}
Processing – hvad der sker på PC
import processing.serial.*;
Serial port; // Create object from Serial class
int[] sensors = new int[5];
String myString; //sting til indkomne data
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, "COM6", 9600);
port.bufferUntil('\n'); //buffer indtil der modtages en ny linie
}
void draw()
{
//Tegner rektangler som skifterfarve nå tryksensorene bliver aktiveret
//tryksensor 0
if (sensors[0] < 700){
stroke(0);
fill(255,0,0);
rect(50,50,75,100);
}else{
stroke(0);
fill(0,255,0);
rect(50,50,75,100);
}
//tryksensor 1
if (sensors[1] < 700){
stroke(0);
fill(255,0,0);
rect(50,150,75,100);
}else{
stroke(0);
fill(0,255,0);
rect(50,150,75,100);
}
//tryksensor 2
if (sensors[2] < 700){
stroke(0);
fill(255,0,0);
rect(50,250,75,100);
}else{
stroke(0);
fill(0,255,0);
rect(50,250,75,100);
}
//tryksensor 3
if (sensors[3] < 700){
stroke(0);
fill(255,0,0);
rect(50,350,75,100);
}else{
stroke(0);
fill(0,255,0);
rect(50,350,75,100);
}
}
//methoe der trigger hver gang der modtages data over serielporten
void serialEvent(Serial port) {
// read the serial buffer:
String myString = port.readStringUntil('\n');
// if you got any bytes other than the linefeed:
myString = trim(myString);
println(myString);
// split the string at the commas
// and convert the sections into integers:
int sensors[] = int(split(myString, ','));
// print out the values you got:
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
}
// add a linefeed after all the sensor values are printed:
println();
}
Vi havde problemer med at få skrevet data over bluetooth. Første problem var at vi brugte Serial.write istedet for bluetooth.write. Vi fandt en løsning med at sende dataen i individuelle bytes, hvilket gav en del problemer med vores accelerometer data. Løsningen blev at skifte til at sende et datasæt med alle vores data, som en string, på en gang.
Konklusion
Hvad er det for et problem I ville løse med jeres wearable?
I vores gruppe bruger vi alle for meget tid foran computerskærmen, og dermed er vi storforbrugere af muse, dertil kommer dog et stigende problematik med hånd, arm og ryg skader der kommer fra for meget computer mus brug, en af de største problematikker er at man som udgangspunkt er sat til at skulle arbejde i en stilling i forhold til musen, da den skal have en overflade for at kunne opfange bevægelse, dette ville vi imødekomme ved at skabe en trådløs wearable, der udelukkende tager udgangspunkt i hvad brugeren finde som en behagelig stilling til brug af muse funktionaliteten.
Løser jeres wearable dette problem?
Som udgangspunkt løser vi problemet med at musen er stationær, der er dog andre problematikker med at selve accelerometeret er temmelig stort i sig selv, og derved måske ikke skaber den frihed og komfort vi ønskede at opnå, men det er jo som udgangspunkt også en prototype lavet med en arduino.
På hvilke punkter kan den forbedres – og evt. hvordan?
Ved fx kun at havde de moduler der skal bruges på selve prototypen, altså ikke at have en printplade til at holde sammen på de sensore og andre elementer der gør hele musen mindre, og derved skaber mere komfort, dertil kommer et lang mere precist accelerometer, som kan opfange de små og fine bevægelser man laver med en mus.
Video
bliver opdateret efter fremvisning tirsdag!