<mosaic.cnfolio.com>

Product Design Report

Team Fission Chips

Table of Contents:



1. Product Description
2. Design Requirements
3. Prototyping Analysis
4. Design Specifications
Reference list

1. Product Description


The McBox is a fully functional media controller capable of controlling both audio and video media. The controller interfaces with a computer via USB connection and will work with any of the main operating systems currently available, Linux, Windows and Macintosh. VLC player is required to be running on the computer however no other software or drivers are required to be installed, the device is simply recognised as a Human Interface device and works as plug and play.

The main functions the McBox implements are:
* Play/Pause
* Skip forward to next track
* Skip backwards to previous track
* Stop
* Volume Up
*Volume Down

Along side these functional controls that enable the user to communicate with the VLC media player a number of other features are also included. A number of LED's accompany the volume control giving visual feedback to the user, these LED's relate to the current volume state and more illuminate with increasing volume. Visual feedback is also given to the user for the play and pause button. A solid illumination indicates the media is currently playing whereas no light demonstrates the media is currently paused. Subtle mood lighting from four blue LED's gives a novelty effect surrounding the device, with the option to dim the lights using a potentiometer.

The whole device is housed by a hard transparent case protecting the electronics from small bumps and spillages. It also gives a minimalist professional look to the product and allows all the lighting to be visible as a glow through the case.

Target Audience

The device is designed to be akin to a professional style mixing desk but for the average computer user who just wishes to playback simple media. Therefore a wide audience is targeted but more heavily aimed at the younger generation. However, due to it being a convenient and intuitive way of controlling media on ones computer this device would be beneficial to any age and with any amount of computing experience as the set-up process is extremely simple. It is unlikely that our product is going to attract users in the older generation, however for middle aged people it would be greatly beneficial as it is so efficient at changing music without the hassle of mouse clicking and typing.

2. Design Requirements


This set of requirements is revised and updated from the feasibility report. Any changes that have occurred are discussed in the prototype analysis of this report. The requirements are ordered by importance.
  1. The device must implement the following functionality for both audio and video media: Play/Pause, Next Track/video, Previous Track/video, Stop, Volume up, Volume down.
  2. Use USB B type interface to USB 2.0 between the Arduino and computer with a standard A type to B type cable. A type on the Arduino side.
  3. The media controller is fully functional with VLC media player software.
  4. The resolution of the volume control will mean at least seven different volume states will be achieved
  5. The product must operate off 500ma at 5v. It must be powered through the USB with no external power supply.
  6. A response from a button press should be registered and carried out in less than a tenth of a second of the button being released. Hardware and software delay should be less than 0.1 seconds. Buttons may not register when held down.
  7. Within 40 seconds of plugging the device into the computer the device must be acknowledged as a Human Interface device and all buttons should be able to perform their required functionality.
  8. The device must be functional on Windows, linux and Macintosh operating systems.
  9. At least seven LED’s must accompany the volume control to indicate each volume level
  10. Volume accompanying LED’s must use no more than four digital input/output pins from the arduino.
  11. At least one LED must display the state of the play and pause button. When in play mode a solid light and off in pause mode.
  12. Between all buttons on the device a minimum distance of 20.3mm must be present.
  13. The device must be fully functional between the temperatures of 0oc and 70oc.
  14. The device must be fully functional between the relative humidity ranges of 30%-80%.

3. Prototyping Analysis


Prototyping Virtual USB keyboard:

Phase 1:

Hardware:
text

Software: Code Beta 1

Description and Analysis:

I started building on a strip-board a simple configuration using a USB “B” socket and few passive components like resistors and diodes. First of all I wired Pin 1 (VCC) and Pin 4 (Ground) from the USB socket to Arduino in order to power it. Then I connected it to the computer and using a multimeter I verified the 0V and 5V. I also used a USB Hub to avoid blowing up my computer in case there was some short circuit. After checking that everything was fine I soldered a 2k2 and 68R resistors connecting the Pin 2 (D-) to Arduino digital I/O (Pin5) and I/O (Pin4) respectively. I did the same for Pin 3 (D+) to I/O (Pin2) using a 68R resistor. Finally I soldered under the strip-board two Zener diodes (3V6) from ground to the USB data lines Pin 2 (D-) and Pin 3 (D+). Also I connected a push button to I/O (Pin 8 )in order to test the software. Also I put a push button in (Pin 6) as a (KEY_A) for testing purpose.

The reason why I used those 3 specifics pins in Arduino is because the UsbKeyboard library created by Philip Lindsay is associated to them, so it won’t work using different ones. The USB standard says that the communications lines (D-/ D+) must work in a range of 2.8V to 3.6V, so this is the reason for the Zener diodes. Hardware was done, so now was time for the software part. I downloaded and uploaded the "VirtualUsbKeyboard.pde" [2] in order to check if the hardware was working and if my computer would recognize Arduino as a Keyboard. After having few issues compiling the code I noticed that I needed to import the (UsbKeyboard.h) libraries, after adding them I was having many compiling errors.

I read in the “Practical Arduino” book [3] that the library will only compile using the version "0016" so I downloaded this old version and tried again but this time was even worse because it was not compatible with Windows 7 and I had multiple errors. After playing for a while I managed to compile it with the actual version 1.0 and uploaded to the board. But when I connected it to my computer I was getting the message “USB Device Not Recognized”. After trying many things I was having the same issue and I decided to start Phase 2.

Phase 2:

Hardware:
text
text

Software: Code Beta 2

Description and Analysis:
Before starting to make it in hardware I wanted to simulate it, but in this case It would not be possible because It also needs a computer to run the Virtual USB Keyboard. Anyway I did some research In how I could add an Arduino UNO or ATMega328 in Multisim. But fortunately I found in Arduino forum people asking the same kind of question and found Fritzing (http://fritzing.org/) an open source package that has already Arduino UNO on it and it let you do the breadboard design, schematics and PCB (In case we need it). It also let you put code on it but as I mentioned early is not possible for our product. So here it is the breadboard design including the resistors and zener diodes configuration for the Virtual USB keyboard, plus 4 push button (Play/Pause, Stop, Previous, Next).

After I build it in a breadboard and tested it again following the same procedure as I did in Phase 1. Unfortunately I had the same message (USB device not recognized) as before. I tried different codes and checked again that the usb keyboard libraries were the right ones and still did not work. So clearly It was some issue with the hardware. I was not really sure about the power rating of the zener diodes. I took them from the analogue lab a while ago and did not mention to Steve that they had to be 0,25W or 0,5W in order to work. So I thought that this could be the issue. I went to a locally electronic store back in home and bought few zener diodes (3v6/0,25w). After replacing them my laptop was finally recononizing it as an external usb keyboard. I managed to tested it with VLC media player. But I was having an issue with the push buttons. Every time I was pressing one of them the computer was receiving 6 keystrokes instead of one "ssssss". So I put a delay after each button as seen below, for more details download the full code. After testing all the push-buttons an implemeting the volume with push buttons as well I decided to start Phase and tried to implement the volume with a pot and reading it with the analogue inputs from arduino.

#if BYPASS_TIMER_ISR  // check if timer isr fixed.
    delayMs(250);
#else
    delay(250);
#endif


Phase 3:

Hardware:
text
text

Software: Code Beta 3

Description and Analysis:
In this phase I tried to implement the pot for the volume up/down, two of the pins were connected to 5V/0V, and the middle one to analogue input (Pin 2) in order to read the value. After doing some research about the analogue reading and playing around with the analogRead(A2) I managed to make it work only with specific reading values ans without covering the whole range of the pot. Due to the lack of time I could not improve it more for the presentation day.

Prototyping Speed Control Using A Rotary Encoder:

Speed Control Using A Rotary Encoder

Aim = To use a slide potentiometer in order to control the volume that the media will play at on the computer whilst also giving a visual indication of volume on the hardware by means of LED’s.
To use a rotary encoder to incrementally control the speed change function up and down on the media player.
We had chosen to use a rotary encoder that changed its output dependant on what position the dial was in.



The encoder uses grey code as it turns and repeats the pattern of three times in a 360˚ rotation. We weren’t fussed about what the actual state was, whether it be 1,2,3 or 4. We were simply interested in had the encoder been turned up or down.

Phase 1 = As we didn’t have a rotary encoder we set up the first test using two push buttons to control a logic input to the arduino. If the button was pressed it would send 5V or logic 1 to the arduino and if it was released it would send 0V or logic 0.
We set about the code to read the two inputs and from that determine what state it was in(1,2,3,4) we then stored this as ‘Current Input’. When a new input was read, ‘Current Input’ was sent to ‘Previous Input’ and the new value stored in ‘Current Input’. These two values were then compared to determine if it had gone up or down. Dependant on if it had gone up or down would change the output and it would be this output that we would use to trigger the change in speed.
The image below shows our prototype. We used two LED’s to display if the output was going up or down.

The code below shows how we programmed the arduino
/* Rotary encoder read example */
#define ENC_A 14
#define ENC_B 15
#define ENC_PORT PINC
 
void setup()
{
  /* Setup encoder pins as inputs */
  pinMode(ENC_A, INPUT);
  digitalWrite(ENC_A, HIGH);
  pinMode(ENC_B, INPUT);
  digitalWrite(ENC_B, HIGH);
  Serial.begin (115200);
  Serial.println("Start");
}
 
void loop()
{
 static uint8_t counter = 0;      //this variable will be changed by encoder input
 int8_t tmpdata;
 /**/
  tmpdata = read_encoder();
  if( tmpdata ) {
    Serial.print("Counter value: ");
    Serial.println(counter, DEC);
    counter += tmpdata;
  }
}
 
/* returns change in encoder state (-1,0,1) */
int8_t read_encoder()
{
  static int8_t enc_states[] = {0,-1,1,0,1,0,0,-1,-1,0,0,1,0,1,-1,0};
  static uint8_t old_AB = 0;
  /**/
  old_AB <<= 2;                   //remember previous state
  old_AB |= ( ENC_PORT & 0x03 )//add current state
  return ( enc_states[( old_AB & 0x0f )]);
}

Phase 2 = Once the rotary encoder arrived we went about implementing the encoder instead of the two switches; however we found that it wasn’t as simple as we thought it would be.
The data sheet for the encoder was very simple and vague and so it took a while to work out how it operated.
We were able to find a tutorial on how it worked and from this we re-wrote the code.
The code below is the code we used.

This was then adapted to work with the registers and libraries needed for the usb keyboard.
Volume control with accompanying LED’s

Aim = To use a slide potentiometer in order to control the volume that the media will play at on the computer whilst also giving a visual indication of volume on the hardware by means of LED’s.



This shows the general idea of how we want the LED’s to change with increasing and decreasing volume. We aim to have at least 7 different volume states.

Phase 1:
Phase one involves setting up the hardware. This is a relatively simple circuit however it has a down side of using quite a few output pins. For every LED we require it uses an output pin. There are other ways of achieving the same outcome with less pins however it becomes more complex. This is just a starting point however and should we require less output pins to be used these other methods would have to be investigated.



The Pin labels represent pins from the Arduino. In order to simplify the circuit slightly a resistor pack is used instead of many individual resistors. The potentiometer is attached to analogue input pin 3.

To start with I am going to just investigate implementing the LED’s as I have little knowledge as yet on communicating with pc.

The code in order to implement this requires the potentiometer position to be read and depending on the position display the required amount of LED's. The arduino automatically converts the analogue output of the potentiometer into digital so it is a case of if statements to determine position and which lights to turn on. This all must be with in an infinite loop so it is constantly reading from the potentiometer.

The code is as followed:
// INPUT: Potentiometer should be connected to 5V and GND
int potPin = 3; // Potentiometer output connected to analog pin 3
int potVal = 0; // Variable to store the input from the potentiometer

// OUTPUT: Use digital pins 6-12

int red1Pin = 12;   
int red2Pin = 11
int grn1Pin = 10;
int grn2Pin = 9;
int grn3Pin = 8;
int grn4Pin = 7;
int grn5Pin = 6;

// Program variables
// Variables to store the values to send to the pins
int red1Val = 0
int red2Val = 0;
int grn1Val = 0;
int grn2Val = 0;
int grn3Val = 0;
int grn4Val = 0;
int grn5Val = 0;


int DEBUG = 1;          // Set to 1 to turn on debugging output

void setup()
{
  pinMode(red1Pin, OUTPUT);   // sets the pins as output
  pinMode(red2Pin, OUTPUT);
  pinMode(grn1Pin, OUTPUT);   
  pinMode(grn2Pin, OUTPUT);
  pinMode(grn3Pin, OUTPUT);
  pinMode(grn4Pin, OUTPUT);
  pinMode(grn5Pin, OUTPUT);
 

  if (DEBUG) {           // If we want to see the pin values for debugging...
    Serial.begin(9600)// ...set up the serial ouput in 0004 format
  }
}

// Main program
void loop()
{
  potVal = analogRead(potPin);   // read the potentiometer value at the input pin


  if (potVal > 50)
  {
  grn5Val = 600;
  }               
  else{grn5Val = 0;}
 
  if (potVal > 290)
  {
  grn4Val = 700;
  }               
  else{grn4Val = 0;}
 
  if (potVal > 435)
  {
  grn3Val = 800;
  }
  else{grn3Val = 0;}
 
  if (potVal > 580)
  {
  grn2Val = 900;
  }               
  else{grn2Val = 0;}
 
  if (potVal > 725)
  {
  grn1Val = 1023;
  }               
  else{grn1Val = 0;}
 
  if (potVal > 870)
  {
  red2Val = 900;
  }               
  else{red2Val = 0;}
 
  if (potVal > 1015)
  {
  red1Val = 1023;
  }               
  else{red1Val = 0;}
 
 
    // Write values to LED pins
  analogWrite(grn5Pin, grn5Val);
  analogWrite(grn4Pin, grn4Val);
  analogWrite(grn3Pin, grn3Val);
  analogWrite(grn2Pin, grn2Val);
  analogWrite(grn1Pin, grn1Val);
  analogWrite(red1Pin, red1Val);
  analogWrite(red2Pin, red2Val)

  if (DEBUG) { // If we want to read the output
    DEBUG += 1;      // Increment the DEBUG counter
    if (DEBUG > 100) // Print every hundred loops
    {
      DEBUG = 1;     // Reset the counter
                             // Serial output using 0004-style functions                             
      Serial.print(potVal);
      Serial.print("\t");   
     
     
    }
  }




The hardware and code work well with the response being very quick. Some of the values for testing the slide position are not in equal increments as i found the lower end of the potentiometer to not be very responsive and therefore the slider had to be about half way for just one LED to show. I also changed the brightness of some of the LED's as some where brighter than others. Also i did this so brightness would increase as it got to the higher volumes.

From here it is necessary to add the code in order to send keystrokes to the computer. As i did not have any means of creating the circuit that allows communication with the computer for usb keyboard i simply used the line "Serial.print("KEYSTROKE GOES HERE"); then when i was able to communicate with the computer this line would be changed to the relevant code. After experimenting with lots of code i found it very difficult in implementing the keystrokes. The main problem was trying to determine where the potentiometer was, as it was inside an infinite loop it kept sending the serial print commands over and over again. Keeping track of position was hard because trying to increment a variable was impossible as it would do so thousands of times. After trying and failing for a few days i came to the decision to abandon the potentiometer as time was becoming scarce and maybe one of the other members of the group would have more of an idea of how to implement the potentiometer.

For a backup i proceeded to implement the volume control with buttons. I hoped this would be a simple job.

Two buttons were attached to the arduino, a button press is only registered when the button is pushed down then released. This is an attempt to reduce the chance of button bounce. An example code off the internet was found and used in order to help. Certain variables kept track of how many up presses and down presses occurred and then a case statement dealt with sending the required LED output. When an up click occured the counter increased and sent a serial.print("up"); command. When a down click occurred the counter decreased and sent a serial.print("down"); command. However if the count got too six or zero no more up or down commands were to be sent. The code looks like the following:

void loop() {
//Up button

  // read the pushbutton input pin:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
      // if the current state is HIGH then the button
      // wend from off to on:
     
      if (buttonPushCounter == maxCount)
      {
        buttonPushCounter = maxCount;
      }
      else
      {
      buttonPushCounter++;
      Serial.println("UP");
      }
    }
    else {
      // if the current state is LOW then the button
      // wend from on to off:
    //  Serial.println("off");
    }
  }
  // save the current state as the last state,
  //for next time through the loop
  lastButtonState = buttonState;
 
  //Down button
 
   // read the pushbutton input pin:
  buttonState2 = digitalRead(buttonPin2);

  // compare the buttonState to its previous state
  if (buttonState2 != lastButtonState2) {
    // if the state has changed, increment the counter
    if (buttonState2 == HIGH) {
      // if the current state is HIGH then the button
      // wend from off to on:
      if (buttonPushCounter == minCount)
      {
        buttonPushCounter = minCount;
      }
      else
      {
      buttonPushCounter--;
      Serial.println("DOWN");
      }
    }
   
    else {
      // if the current state is LOW then the button
      // wend from on to off:
    }
  }
  // save the current state as the last state,
  //for next time through the loop
  lastButtonState2 = buttonState2;

//Deals with LED's

  switch(buttonPushCounter) {
    case 0:
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 1:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 2:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 3:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 4:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin5, LOW);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 5:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin5, HIGH);
    digitalWrite(ledPin6, LOW);
    digitalWrite(ledPin7, LOW);
    break;
    case 6:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin5, HIGH);
    digitalWrite(ledPin6, HIGH);
    digitalWrite(ledPin7, LOW);
    break;
    case 7:
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin5, HIGH);
    digitalWrite(ledPin6, HIGH);
    digitalWrite(ledPin7, HIGH);
    break;
  }

This code successfully lights the LED's and sends serial prints to the serial monitor. It has a resolution of 7 so 7 different volume states can be heard.

It became obvious that using 7 output pins for the LED's would not be feasible as these needed to be used for the buttons for play/pause, stop, next, previous and seeking. In order to tackle this problem we had to look into multiplexing the LED's. The solution meant using a shift register IC. This means the data is in putted into the IC using serial connection and outputted as parallel to drive each individual LED. The chip was included in our starter arduino kit supplied by the university. The chip is a 74HC595 8-bit shift register serial in parallel out. It uses one serial data input from the arduino however also requires a clock and latch input meaning the overall i/o pins used from the arduino is 3. A huge reduction on the 7 used previously.

Below is the pin diagram and pin description for the 74HC595 [1]:


Below shows how the 74HC595 connects to the arduino. One of the output pins is not being used as we only require 7 output LED's.


Once we had a completed circuit diagram we designed a schematic to build the PCB. The Circuit diagram above shows the whole circuit, whereas the schematic below shows the excess circuitry with specified mount points for connecting to power and the arduino.



The following code reduces the number of i/o pins and works in the same way as before using the buttons to increase and decrease the volume. The case statement deals with the LED's and cycles through a pre defined sequence that lights the required LED's but only depending on the count variable. The code only shows the parts that differ from the previous.

int dataPin = 2;        //Define which pins will be used for the Shift Register control
int latchPin = 3;
int clockPin = 4;

int seq[8] = {0,1,3,7,15,31,63,127}; //each value in the array is the 7 different states of the LED's to show volume

void setup() {
    // initialize the LED as an output:
  pinMode(dataPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}
 switch(buttonPushCounter) {
    case 0:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[0]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 1:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[1]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 2:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[2]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 3:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[3]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 4:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[4]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 5:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[5]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 6:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[6]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;
    case 7:
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, seq[7]);
    digitalWrite(latchPin, HIGH);
    delay(10);
    break;


Product Casing

During the process of testing and prototyping we knew that the hardware of our product may have to be adjusted depending on what we can and cannot get working in the time given. We had an original design for the casing and controls which included a potentiometer and rotary encoder for speed control and volume control. Towards the end of the testing and prototyping period we realized that it was unlikely to get a the potentiometer and rotary encoder working properly with our circuit. With this in mind and after discussions with Tom H and Andreu, Steve and I took it upon ourselves to construct an alternative casing in order to have one that we could display in the presentation. The rotary encoder and potentiometer were to be replaced by buttons so we measured and designed a casing with the new design requirements in mind.

Design Rendered drawings
Before encountering problems with the rotary encoder this is how we envisaged the case looking. In these designs the rotary encoder and potentiometer spaces are still in place. We did not have time to amened these CAD designs in order to facilitate the changes to the circuit.




The final casing for the product consisted of two same sized sheets of acrylic (18cm by 12cm). This made up the top and bottom of the casing. The two pieces were then held together by two long strips of acrylic at both the left and right side. For the button controls, we pillar drilled 14mm holes into the top faceplate.
We used araldite to stick it all together. This design leaves the front and back open, as planned.

Final Phase

The final phase of prototyping was bringing together all the aspects of the process into one final prototype. This was done so on a breadboard implementing the button volume with the LED's as incorporating the aspects from the phase that dealt with communicating with the computer. This was achieved successfully on the breadboard so a working prototype was achieved. This was then replicated on a Strip board in order to be placed inside the case. This strip board version however was not fully functional and time limitations meant the fault was never found. Our end results left the team with a fully functional prototype on a breadboard and a non functional device within its case demonstrating what the product should actually look like.


Areas that caused a change in design requirements


4. Design Specifications


Design Specifications

Hardware


Whole Circuit Diagram
Below is the schematic diagram of the circuit.

Please note, the diodes that connect the USB port to ground are actually 3.6V Zener diodes rated at 0.5 Watts.

Parts and supply ordering information
Here the parts required for this build are outlined and details of where to obtain them and at what cost is also described.


Software

Source code
Below is the source code required for programming the Arduino.
MCBox Completed Code

Housing/Case

Schematic for size and scales


Parts and ordering Information
The housing requires clear acrylic sheets, of thickness 5mm. Both the top plate and bottom plate have the dimensions 180mm by 120mm.
This is available from picturemaster.co.uk priced at £8.66

Reference list


[1] NXP semiconductors, 74HC595 data sheet. Found at: http://www.nxp.com/documents/data_sheet/74HC_HCT595.pdf
[2] Virtual USB keyboard source. Found at: https://github.com/practicalarduino/VirtualUsbKeyboard/blob/master/VirtualUsbKeyboard.pde
[3] Book Practical Arduino: Cool Projects for Open Source Hardware Authors: Jonathan Oxer and Hugh Blemings
Attachment Timestamp Size
case.JPG 2012-05-20 17:03 314.71 KB
breadboard.jpg 2012-05-20 17:01 426.93 KB
Mark.jpg 2012-05-20 15:37 61.85 KB
Scmatic.jpg 2012-05-20 15:32 35.66 KB
Topmk2.jpg 2012-05-20 15:32 29.91 KB
Mk 1.jpg 2012-05-20 15:31 160.29 KB
firstdes.jpg 2012-05-20 15:31 6.53 KB
simulation_phase3.JPG 2012-05-20 13:00 47.94 KB
hardware_phase3.JPG 2012-05-20 13:00 43.5 KB
keyboard_beta2.txt 2012-05-20 12:52 1.49 KB
simulation_phase2.JPG 2012-05-20 12:44 45.9 KB
hardware_phase2.JPG 2012-05-20 12:37 47.28 KB
hardware_phase1.bmp 2012-05-20 12:34 1.01 MB
keyboard_beta1.txt 2012-05-20 12:10 905 Bytes
MCBoxfinalcode.txt 2012-05-20 06:57 7.45 KB
supplyorder.jpg 2012-05-20 06:25 119.35 KB
4.png 2012-05-20 05:06 13.76 KB
mcboxschem.jpg 2012-05-19 18:51 109.98 KB
shiftschem.jpg 2012-05-13 10:20 158.44 KB
74hc595pindescription.jpg 2012-05-13 10:08 79.28 KB
74hc595.jpg 2012-05-13 10:08 21.14 KB
grey code.bmp 2012-05-10 08:24 74.76 KB
workinghardware1.jpg 2012-05-04 10:43 117.24 KB
hardware1.jpg 2012-05-04 10:34 25.11 KB
ledspot.jpg 2012-05-04 10:30 29.58 KB