beelinemousetracker

[beelinemousetracker]

Yui put the music together and Tara and Callum did the text for the video to finish it off!

[beelinemousetracker]

Yui put the music together and Tara and Callum did the text for the video to finish it off!

[beelinemousetracker]

Yui then worked with all the footage and edited and cut together the final movie which included the animation Yui already rendered

[beelinemousetracker]

After we assembled all the parts we all went and did our filming

Tara drew up a rough story board. Callum was the model with Yui behind the camera and Anna and Tara helping with what angles and shots to do.

[beelinemousetracker]

We decided to spray paint the prints to make them look more polished

[beelinemousetracker]

We got the prints off the following day and Callum did most of the sanding with the help of Anna and Tara. Anna also worked on the components so it was ready to go inside the prints with the help of Tara.

[beelinemousetracker]

We decided to make digital packaging and render it in keyshot

Yui made and rendered the packaging and also made an animation showing the product in the packaging.

The packaging is white and contrasts the black product and the blue lining highlights the blue of the pod. It also shows the branding inside and out.

[beelinemousetracker]

We then all set up different prints and made sure they were printing correctly

[beelinemousetracker]

Tara and Anna sketched ideas for the form that ended up with the idea of a holder for the components that need to plug into the computer which then also holds the pod that attaches to the users head

Callum and Tara explored the form in fusion and finalized the design

[beelinemousetracker]

Yui looked at making packaging out of material and featuring a large zip

[beelinemousetracker]

With some help Anna got the components we already had with the addition of an arduino nano, transmitter and receiver to function exactly how we wanted with a new code. We can now control the mouse with our components remotely and one this is in the form the product will be working

Here is the code for the receiver

#include <RH_ASK.h>

#include <SPI.h>

RH_ASK RF_driver (2000, 3, 6); // RF_driver (name), speed (2000; default), 3 (RX pin), 6 (TX pin)

#include <Mouse.h>

struct xyz // make a structure of three variables (x, y and z) and give it a name (xyz)

{

int x;

int y;

int z;

}Received;

int xPosMin = 1023; // minimum point on x axis

int xPosMax = 0; // maximum point on x axis

int yPosMin = 1023; // minimum point on y axis

int yPosMax = 0; // maximum point on y axis

int zPosMin = 1023; // minimum point on z axis

int zPosMax = 0; // maximum point on z axis

int xPosCentre = 0; // centre point on x axis

int yPosCentre = 0; // centre point on y axis

int zPosCentre = 0; // centre point on z axis

int xSpeed = 2; // pointer speed on x axis (change accordingly)

int ySpeed = 2; // pointer speed on y axis (change accordingly)

int zSpeed = 2; // pointer speed on z axis (change accordingly)

int xTolerance = 10; // size of centre zone on x axis (change accordingly)

int yTolerance = 10; // size of centre zone on y axis (change accordingly)

int zTolerance = 10; // size of centre zone on z axis (change accordingly)

int Delay = 2; // delay

void setup() {

Serial.begin(9600);

// if (!RF_driver.init())

// Serial.println("Initialisation Failed");

RF_driver.init(); // wireless Rx: initialise the rf module (RF_driver)

Mouse.begin(); // initialise mouse

}

void loop() {

uint8_t buf[RH_ASK_MAX_MESSAGE_LEN]; // wireless Rx: define the buffer memory

uint8_t buflen = sizeof(buf); // wireless Rx: define the length of the information

RF_driver.recv(buf, &buflen); // wireless Rx: receive these values

// if (RF_driver.recv(buf, &buflen))

// {

int i;

// RF_driver.printBuffer("Received:", buf, buflen);

memcpy(&Received, buf, sizeof(Received)); // copy these three values from the memory

int xPos = Received.x; // assign x value received to position on x axis

int yPos = Received.y; // assign y value received to position on y axis

int zPos = Received.z; // assign z value received to position on z axis

if (xPos < xPosMin) { // compare position to the minimum point on x axis

xPosMin = xPos; // new minimum point on x axis

}

if (xPos > xPosMax) { // compare position to the maximum point on x axis

xPosMax = xPos; // new maximum point on x axis

}

if (yPos < yPosMin) { // compare position to the minimum point on y axis

yPosMin = yPos; // new minimum point on y axis

}

if (yPos > yPosMax) { // compare position to the maximum point on y axis

yPosMax = yPos; // new maximum point on y axis

}

if (zPos < zPosMin) { // compare position to the minimum point on z axis

zPosMin = zPos; // new minimum point on z axis

}

if (zPos > zPosMax) { // compare position to the maximum point on z axis

zPosMax = zPos; // new maximum point on z axis

}

xPosCentre = (xPosMax + xPosMin) / 2; // calculate center point on x axis

yPosCentre = (yPosMax + yPosMin) / 2; // calculate center point on y axis

zPosCentre = (zPosMax + zPosMin) / 2; // calculate center point on y axis

if (xPos > xPosCentre + xTolerance) { // if position is outside central zone on x axis (to maximum point)

Mouse.move(xSpeed, 0, 0); // move mouse pointer on x axis (to maximum point)

}

else if (xPos < xPosCentre - xTolerance) { // if position is outside central zone on x axis (to minimum point)

Mouse.move(-xSpeed, 0, 0); // move mouse pointer on x axis (to minimum point)

}

else { // if position is inside central zone on x axis

Mouse.move(0, 0, 0); // do not move mouse pointer

}

if (yPos > yPosCentre + yTolerance) { // if position is outside central zone on y axis (to maximum point)

Mouse.move(0, -ySpeed, 0); // move mouse pointer on y axis (to maximum point)

}

else if (yPos < yPosCentre - yTolerance) { // if position is outside central zone on y axis (to minimum point)

Mouse.move(0, ySpeed, 0); // move mouse pointer on y axis (to minimum point)

}

else { // if position is inside central zone on y axis

Mouse.move(0, 0, 0); // do not move mouse pointer

}

Serial.print("xPos: ");

Serial.print(xPos);

Serial.print(", xPosMin: ");

Serial.print(xPosMin);

Serial.print(", xPosCtr: ");

Serial.print(xPosCentre);

Serial.print(", xPosMax: ");

Serial.print(xPosMax);

Serial.print(" | yPos: ");

Serial.print(yPos);

Serial.print(", yPosMin: ");

Serial.print(yPosMin);

Serial.print(", yPosCtr: ");

Serial.print(xPosCentre);

Serial.print(", yPosMax: ");

Serial.print(yPosMax);

Serial.print(" | zPos: ");

Serial.print(zPos);

Serial.print(", zPosMin: ");

Serial.print(zPosMin);

Serial.print(", zPosCtr: ");

Serial.print(zPosCentre);

Serial.print(", zPosMax: ");

Serial.println(zPosMax);

// Serial.print("X: ");

// Serial.print(Received.x);

// Serial.print(" | Y: ");

// Serial.print(Received.y);

// Serial.print(" | Z: ");

// Serial.println(Received.z);

delay(Delay); // delay between mouse pointer moves

}

And the code for the transmitter

#include <RH_ASK.h>

#include <SPI.h>

RH_ASK RF_driver (2000, 3, 6); // RF_driver (name), speed (2000; default), 3 (RX pin), 6 (TX pin)

const int xAxis = A7; // analog input pin for X axis

const int yAxis = A6; // analog input pin for Y axis

const int zAxis = A5; // analog input pin for Z axis

struct xyz // make a structure of three variables (x, y and z) and give it a name (xyz)

{

int x;

int y;

int z;

}toSend; // this name is defined below

byte tx_buf[sizeof(toSend)] = {0}; // wireless Tx: define the length of the information

void setup()

{

Serial.begin(9600);

if (!RF_driver.init()) // wireless Tx: initialise the rf module (RF_driver)

Serial.println("Initialisation Failed");

}

void loop()

{

toSend.x = analogRead(xAxis); // read the value xAxis

toSend.y = analogRead(yAxis); // read the value yAxis

toSend.z = analogRead(zAxis); // read the value zAxis

memcpy(tx_buf, &toSend, sizeof(toSend)); // copy these three values from the memory

RF_driver.send((uint8_t *)tx_buf, sizeof(toSend)); // wireless Tx: send these values

RF_driver.waitPacketSent(); // wireless Tx: wait for a while until sending finishes

Serial.print("X: ");

Serial.print(toSend.x);

Serial.print(" | Y: ");

Serial.print(toSend.y);

Serial.print(" | Z: ");

Serial.println(toSend.z);

}

[beelinemousetracker]

After discussing our concept idea with Tara's Auntie who has no use of her arms and occasionally her pinky finger, she thought this would be really useful and was a great idea that would help alot

[beelinemousetracker]

Tara came up with the branding and name Beeline Shades because the mouse was making a beeline across the screen. Once we decided not to have it strictly on glasses the name became Beeline. It also adds a level of playfulness to the product as well as keeping it technology based.

The branding used a cursor so show the intent of the product along with the name which is intentionally not descriptive. The name didn't need to describe what the product did but be something people remembered.

The font remained plain and slightly square to make it look like a technical product. It is black and white to keep it sleek.

The cursor is attached to the L which shows the tracking mouse.

[beelinemousetracker]

Anna adjusted the code for another invalid test that worked better

This is the code

#include <Mouse.h>

const int xAxis = A1; //analog sensor for X axis

const int yAxis = A2; // analog sensor for Y axis

const int zAxis = A3;

int range = 12; // output range of X or Y movement

int responseDelay = 2; // response delay of the mouse, in ms

int threshold = range / 4; // resting threshold

int center = range / 4; // resting position value

int minima[] = {1023, 1023}; // actual analogRead minima for {x, y}

int maxima[] = {0, 0}; // actual analogRead maxima for {x, y}

int axis[] = {xAxis, yAxis}; // pin numbers for {x, y}

int mouseReading[2]; // final mouse readings for {x, y}

void setup() {

Mouse.begin();

}

void loop() {

// read and scale the two axes:

int xReading = readAxis(0);

int yReading = readAxis(1);

// move the mouse:

Mouse.move(xReading, yReading, 0);

delay(responseDelay);

}

/*

reads an axis (0 or 1 for x or y) and scales the

analog input range to a range from 0 to <range>

*/

int readAxis(int axisNumber) {

int distance = 0; // distance from center of the output range

// read the analog input:

int reading = analogRead(axis[axisNumber]);

// of the current reading exceeds the max or min for this axis,

// reset the max or min:

if (reading < minima[axisNumber]) {

minima[axisNumber] = reading;

}

if (reading > maxima[axisNumber]) {

maxima[axisNumber] = reading;

}

// map the reading from the analog input range to the output range:

reading = map(reading, minima[axisNumber], maxima[axisNumber], 0, range);

// if the output reading is outside from the

// rest position threshold, use it:

if (abs(reading - center) > threshold) {

distance = (reading - center);

}

// the Y axis needs to be inverted in order to

// map the movemment correctly:

if (axisNumber == 1) {

distance = -distance;

}

// return the distance for this axis:

return distance;

}

[beelinemousetracker]

We all discussed the form we want it to take as to whether we wanted it attached to glasses or a hat or at the back or the head or have it attachable to anything. We didn't decide on anything in particular but decided to explore all options and see what we like the best depending on how small or large the components are.

Callum did some ideation of form and where it would sit.

[beelinemousetracker]

With the components Anna then adjusted a code so that it would work for the mouse tracking and set different parameters in order to get the mouse remotely controlled.

It was very sensitive but the overall idea was working and just needed further adjusting and development.

[beelinemousetracker]

Now we have been looking at the components we need to make the accelerometer work in a circuit so that we can control the mouse.

Yui ordered the compents online and Anna, Yui and Tara went to pick them up and Callum got the arduino pack so testing could start.